Refactor to replace mocha with tape

Author: wooorm

package.json

@@ -30,11 +30,11 @@
     "remark-lint": "^2.0.0",
     "remark-slug": "^3.0.0",
     "remark-validate-links": "^2.0.0",
-    "mocha": "^2.0.0"
+    "tape": "^4.4.0"
   },
   "scripts": {
-    "test-api": "mocha --check-leaks test.js",
-    "test-coverage": "istanbul cover _mocha -- test.js",
+    "test-api": "node test.js",
+    "test-coverage": "istanbul cover test.js",
     "test-travis": "npm run test-coverage",
     "test": "npm run test-api",
     "lint-api": "eslint .",

test.js

@@ -1,20 +1,14 @@
 'use strict';
 
-/* eslint-env mocha */
+/* eslint-env node */
 
 /*
  * Dependencies.
  */
 
-var assert = require('assert');
+var test = require('tape');
 var position = require('./index.js');
 
-/*
- * Methods.
- */
-
-var dequal = assert.deepEqual;
-
 /*
  * Fixture.
  */
@@ -60,52 +54,78 @@ var pos = {
  * Tests.
  */
 
-describe('mdast-util-position', function () {
+test('mdast-util-position', function (t) {
     ['start', 'end'].forEach(function (type) {
-        describe(type, function () {
+        t.test(type, function (st) {
             var fn = position[type];
 
-            it('should not throw without node', function () {
-                dequal(fn(), pos);
-            });
-
-            it('should get type', function () {
-                dequal(fn(properties), properties.position[type]);
-            });
-
-            it('should return an empty object without objects', function () {
-                dequal(fn(objects), pos);
-            });
-
-            it('should return an empty object without values', function () {
-                dequal(fn(values), pos);
-            });
-
-            it('should return an empty object without position', function () {
-                dequal(fn(none), pos);
-            });
+            st.same(
+                fn(),
+                pos,
+                'should not throw without node'
+            );
+
+            st.same(
+                fn(properties),
+                properties.position[type],
+                'should get type'
+            );
+
+            st.same(
+                fn(objects),
+                pos,
+                'should return an empty object without objects'
+            );
+
+            st.same(
+                fn(values),
+                pos,
+                'should return an empty object without values'
+            );
+
+            st.same(
+                fn(none),
+                pos,
+                'should return an empty object without position'
+            );
+
+            st.end();
         });
     });
 
-    describe('generated', function () {
-        it('should not throw without node', function () {
-            assert.equal(position.generated(), true);
-        });
-
-        it('should return false when with properties', function () {
-            assert.equal(position.generated(properties), false);
-        });
-
-        it('should return false when without properties', function () {
-            assert.equal(position.generated(objects), true);
-        });
-
-        it('should return false when without objects', function () {
-            assert.equal(position.generated(values), true);
-        });
-
-        it('should return false when without position', function () {
-            assert.equal(position.generated(none), true);
-        });
-    });
+    t.test('generated', function (st) {
+        st.equal(
+            position.generated(),
+            true,
+            'should not throw without node'
+        );
+
+        st.equal(
+            position.generated(properties),
+            false,
+            'should return false when with properties'
+        );
+
+        st.equal(
+            position.generated(objects),
+            true,
+            'should return true when without properties'
+        );
+
+        st.equal(
+            position.generated(values),
+            true,
+            'should return true when without objects'
+        );
+
+        st.equal(
+            position.generated(none),
+            true,
+            'should return true when without position'
+        );
+
+        st.end();
+    })
+
+    t.end();
 });