From 764600eef0801abd7afbd9cd2a0878c17c3a101e Mon Sep 17 00:00:00 2001
From: ezubarev <zubarev.eugene@gmail.com>
Date: Fri, 6 May 2016 13:09:16 +0600
Subject: Convert asyncify tests to mocha

---
 mocha_test/asyncify.js | 114 +++++++++++++++++++++++++++++++++++++++++++++++++
 test/test-async.js     | 109 ----------------------------------------------
 2 files changed, 114 insertions(+), 109 deletions(-)
 create mode 100644 mocha_test/asyncify.js

diff --git a/mocha_test/asyncify.js b/mocha_test/asyncify.js
new file mode 100644
index 0000000..587ca32
--- /dev/null
+++ b/mocha_test/asyncify.js
@@ -0,0 +1,114 @@
+var async = require('../lib');
+var assert = require('assert');
+var isBrowser = require('./support/is_browser');
+
+describe('asyncify', function(done){
+
+    it('asyncify', function(done) {
+        var parse = async.asyncify(JSON.parse);
+        parse("{\"a\":1}", function (err, result) {
+            assert(!err);
+            assert(result.a === 1);
+            done();
+        });
+    });
+
+    it('asyncify null', function(done) {
+        var parse = async.asyncify(function() {
+            return null;
+        });
+        parse("{\"a\":1}", function (err, result) {
+            assert(!err);
+            assert(result === null);
+            done();
+        });
+    });
+
+    it('variable numbers of arguments', function(done) {
+        async.asyncify(function (x, y, z) {
+            assert(arguments.length === 3);
+            assert(x === 1);
+            assert(y === 2);
+            assert(z === 3);
+        })(1, 2, 3, function () {});
+        done();
+    });
+
+    it('catch errors', function(done) {
+        async.asyncify(function () {
+            throw new Error("foo");
+        })(function (err) {
+            assert(err);
+            assert(err.message === "foo");
+            done();
+        });
+    });
+
+    it('dont catch errors in the callback', function(done) {
+        try {
+            async.asyncify(function () {})(function (err) {
+                if (err) {
+                    return done(new Error("should not get an error here"));
+                }
+                throw new Error("callback error");
+            });
+        } catch (e) {
+            assert(e.message === "callback error");
+            done();
+        }
+    });
+
+    describe('promisified', function() {
+        if (isBrowser()) {
+            // node only tests
+            return;
+        }
+
+        var names = [
+            'native-promise-only',
+            'bluebird',
+            'es6-promise',
+            'rsvp'
+        ];
+
+        names.forEach(function(name) {
+            describe(name, function() {
+
+                var Promise = require(name);
+                if (typeof Promise.Promise === 'function') {
+                    Promise = Promise.Promise;
+                }
+
+                it('resolve', function(done) {
+                    var promisified = function(argument) {
+                        return new Promise(function (resolve) {
+                            setTimeout(function () {
+                                resolve(argument + " resolved");
+                            }, 15);
+                        });
+                    };
+                    async.asyncify(promisified)("argument", function (err, value) {
+                        if (err) {
+                            return done(new Error("should not get an error here"));
+                        }
+                        assert(value === "argument resolved");
+                        done();
+                    });
+                });
+
+                it('reject', function(done) {
+                    var promisified = function(argument) {
+                        return new Promise(function (resolve, reject) {
+                            reject(argument + " rejected");
+                        });
+                    };
+                    async.asyncify(promisified)("argument", function (err) {
+                        assert(err);
+                        assert(err.message === "argument rejected");
+                        done();
+                    });
+                });
+            });
+        });
+    });
+});
diff --git a/test/test-async.js b/test/test-async.js
index c91648c..5530d72 100755
--- a/test/test-async.js
+++ b/test/test-async.js
@@ -16,11 +16,6 @@ if (!Function.prototype.bind) {
     };
 }
 
-function isBrowser() {
-    return (typeof process === "undefined") ||
-        (process + "" !== "[object process]"); // browserify
-}
-
 exports['sortBy'] = function(test){
     test.expect(2);
 
@@ -576,107 +571,3 @@ exports['constant'] = function (test) {
         test.done();
     });
 };
-
-exports['asyncify'] = {
-    'asyncify': function (test) {
-        var parse = async.asyncify(JSON.parse);
-        parse("{\"a\":1}", function (err, result) {
-            test.ok(!err);
-            test.ok(result.a === 1);
-            test.done();
-        });
-    },
-
-    'asyncify null': function (test) {
-        var parse = async.asyncify(function() {
-            return null;
-        });
-        parse("{\"a\":1}", function (err, result) {
-            test.ok(!err);
-            test.ok(result === null);
-            test.done();
-        });
-    },
-
-    'variable numbers of arguments': function (test) {
-        async.asyncify(function (x, y, z) {
-            test.ok(arguments.length === 3);
-            test.ok(x === 1);
-            test.ok(y === 2);
-            test.ok(z === 3);
-        })(1, 2, 3, function () {});
-        test.done();
-    },
-
-    'catch errors': function (test) {
-        async.asyncify(function () {
-            throw new Error("foo");
-        })(function (err) {
-            test.ok(err);
-            test.ok(err.message === "foo");
-            test.done();
-        });
-    },
-
-    'dont catch errors in the callback': function (test) {
-        try {
-            async.asyncify(function () {})(function (err) {
-                if (err) {
-                    return test.done(new Error("should not get an error here"));
-                }
-                throw new Error("callback error");
-            });
-        } catch (e) {
-            test.ok(e.message === "callback error");
-            test.done();
-        }
-    },
-
-    'promisified': [
-        'native-promise-only',
-        'bluebird',
-        'es6-promise',
-        'rsvp'
-    ].reduce(function(promises, name) {
-        if (isBrowser()) {
-            // node only test
-            return;
-        }
-        var Promise = require(name);
-        if (typeof Promise.Promise === 'function') {
-            Promise = Promise.Promise;
-        }
-        promises[name] = {
-            'resolve': function(test) {
-                var promisified = function(argument) {
-                    return new Promise(function (resolve) {
-                        setTimeout(function () {
-                            resolve(argument + " resolved");
-                        }, 15);
-                    });
-                };
-                async.asyncify(promisified)("argument", function (err, value) {
-                    if (err) {
-                        return test.done(new Error("should not get an error here"));
-                    }
-                    test.ok(value === "argument resolved");
-                    test.done();
-                });
-            },
-
-            'reject': function(test) {
-                var promisified = function(argument) {
-                    return new Promise(function (resolve, reject) {
-                        reject(argument + " rejected");
-                    });
-                };
-                async.asyncify(promisified)("argument", function (err) {
-                    test.ok(err);
-                    test.ok(err.message === "argument rejected");
-                    test.done();
-                });
-            }
-        };
-        return promises;
-    }, {})
-};
-- 
cgit v1.2.1