summaryrefslogtreecommitdiff
path: root/mocha_test/map.js
diff options
context:
space:
mode:
Diffstat (limited to 'mocha_test/map.js')
-rw-r--r--mocha_test/map.js311
1 files changed, 311 insertions, 0 deletions
diff --git a/mocha_test/map.js b/mocha_test/map.js
new file mode 100644
index 0000000..a537427
--- /dev/null
+++ b/mocha_test/map.js
@@ -0,0 +1,311 @@
+var async = require('../lib');
+var expect = require('chai').expect;
+var assert = require('assert');
+
+describe("map", function() {
+
+ function mapIteratee(call_order, x, callback) {
+ setTimeout(function() {
+ call_order.push(x);
+ callback(null, x * 2);
+ }, x * 25);
+ }
+
+ it('basic', function(done) {
+ var call_order = [];
+ async.map([1, 3, 2], mapIteratee.bind(this, call_order), function(err, results) {
+ assert(err === null, err + " passed instead of 'null'");
+ expect(call_order).to.eql([1, 2, 3]);
+ expect(results).to.eql([2, 6, 4]);
+ done();
+ });
+ });
+
+ it('with reflect', function(done) {
+ var call_order = [];
+ async.map([1, 3, 2], async.reflect(function(item, cb) {
+ setTimeout(function() {
+ call_order.push(item);
+ cb(null, item * 2);
+ }, item * 25);
+ }), function(err, results) {
+ assert(err === null, err + " passed instead of 'null'");
+ expect(call_order).to.eql([1, 2, 3]);
+ expect(results).to.eql([{
+ value: 2
+ }, {
+ value: 6
+ }, {
+ value: 4
+ }]);
+ done();
+ });
+ });
+
+ it('error with reflect', function(done) {
+ var call_order = [];
+ async.map([-1, 1, 3, 2], async.reflect(function(item, cb) {
+ setTimeout(function() {
+ call_order.push(item);
+ if (item < 0) {
+ cb('number less then zero');
+ } else {
+ cb(null, item * 2);
+ }
+ }, item * 25);
+ }), function(err, results) {
+ assert(err === null, err + " passed instead of 'null'");
+ expect(call_order).to.eql([-1, 1, 2, 3]);
+ expect(results).to.eql([{
+ error: 'number less then zero'
+ }, {
+ value: 2
+ }, {
+ value: 6
+ }, {
+ value: 4
+ }]);
+ done();
+ });
+ });
+
+ it('map original untouched', function(done) {
+ var a = [1, 2, 3];
+ async.map(a, function(x, callback) {
+ callback(null, x * 2);
+ }, function(err, results) {
+ expect(results).to.eql([2, 4, 6]);
+ expect(a).to.eql([1, 2, 3]);
+ done();
+ });
+ });
+
+ it('map without main callback', function(done) {
+ var a = [1, 2, 3];
+ var r = [];
+ async.map(a, function(x, callback) {
+ r.push(x);
+ var done_ = r.length == a.length;
+ callback(null);
+ if (done_) {
+ expect(r).to.eql(a);
+ done();
+ }
+ });
+ });
+
+ it('map error', function(done) {
+ async.map([1, 2, 3], function(x, callback) {
+ callback('error');
+ }, function(err) {
+ expect(err).to.equal('error');
+ });
+ setTimeout(done, 50);
+ });
+
+ it('map undefined array', function(done) {
+ async.map(undefined, function(x, callback) {
+ callback();
+ }, function(err, result) {
+ expect(err).to.equal(null);
+ expect(result).to.eql([]);
+ });
+ setTimeout(done, 50);
+ });
+
+ it('map object', function(done) {
+ async.map({
+ a: 1,
+ b: 2,
+ c: 3
+ }, function(val, callback) {
+ callback(null, val * 2);
+ }, function(err, result) {
+ if (err) throw err;
+ expect(Object.prototype.toString.call(result)).to.equal('[object Object]');
+ expect(result).to.eql({
+ a: 2,
+ b: 4,
+ c: 6
+ });
+ done();
+ });
+ });
+
+ it('mapSeries', function(done) {
+ var call_order = [];
+ async.mapSeries([1, 3, 2], mapIteratee.bind(this, call_order), function(err, results) {
+ assert(err === null, err + " passed instead of 'null'");
+ expect(call_order).to.eql([1, 3, 2]);
+ expect(results).to.eql([2, 6, 4]);
+ done();
+ });
+ });
+
+ it('mapSeries error', function(done) {
+ async.mapSeries([1, 2, 3], function(x, callback) {
+ callback('error');
+ }, function(err) {
+ expect(err).to.equal('error');
+ });
+ setTimeout(done, 50);
+ });
+
+ it('mapSeries undefined array', function(done) {
+ async.mapSeries(undefined, function(x, callback) {
+ callback();
+ }, function(err, result) {
+ expect(err).to.equal(null);
+ expect(result).to.eql([]);
+ });
+ setTimeout(done, 50);
+ });
+
+ it('mapSeries object', function(done) {
+ async.mapSeries({
+ a: 1,
+ b: 2,
+ c: 3
+ }, function(val, callback) {
+ callback(null, val * 2);
+ }, function(err, result) {
+ if (err) throw err;
+ expect(result).to.eql({
+ a: 2,
+ b: 4,
+ c: 6
+ });
+ done();
+ });
+ });
+
+ it('mapLimit', function(done) {
+ var call_order = [];
+ async.mapLimit([2, 4, 3], 2, mapIteratee.bind(this, call_order), function(err, results) {
+ assert(err === null, err + " passed instead of 'null'");
+ expect(call_order).to.eql([2, 4, 3]);
+ expect(results).to.eql([4, 8, 6]);
+ done();
+ });
+ });
+
+ it('mapLimit empty array', function(done) {
+ async.mapLimit([], 2, function(x, callback) {
+ assert(false, 'iteratee should not be called');
+ callback();
+ }, function(err) {
+ if (err) throw err;
+ assert(true, 'should call callback');
+ });
+ setTimeout(done, 25);
+ });
+
+ it('mapLimit undefined array', function(done) {
+ async.mapLimit(undefined, 2, function(x, callback) {
+ callback();
+ }, function(err, result) {
+ expect(err).to.equal(null);
+ expect(result).to.eql([]);
+ });
+ setTimeout(done, 50);
+ });
+
+ it('mapLimit limit exceeds size', function(done) {
+ var call_order = [];
+ async.mapLimit([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], 20, mapIteratee.bind(this, call_order), function(err, results) {
+ expect(call_order).to.eql([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
+ expect(results).to.eql([0, 2, 4, 6, 8, 10, 12, 14, 16, 18]);
+ done();
+ });
+ });
+
+ it('mapLimit limit equal size', function(done) {
+ var call_order = [];
+ async.mapLimit([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], 10, mapIteratee.bind(this, call_order), function(err, results) {
+ expect(call_order).to.eql([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
+ expect(results).to.eql([0, 2, 4, 6, 8, 10, 12, 14, 16, 18]);
+ done();
+ });
+ });
+
+ it('mapLimit zero limit', function(done) {
+ async.mapLimit([0, 1, 2, 3, 4, 5], 0, function(x, callback) {
+ assert(false, 'iteratee should not be called');
+ callback();
+ }, function(err, results) {
+ expect(results).to.eql([]);
+ assert(true, 'should call callback');
+ });
+ setTimeout(done, 25);
+ });
+
+ it('mapLimit error', function(done) {
+ var arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+ var call_order = [];
+
+ async.mapLimit(arr, 3, function(x, callback) {
+ call_order.push(x);
+ if (x === 2) {
+ callback('error');
+ }
+ }, function(err) {
+ expect(call_order).to.eql([0, 1, 2]);
+ expect(err).to.equal('error');
+ });
+ setTimeout(done, 25);
+ });
+
+ it('mapLimit does not continue replenishing after error', function(done) {
+ var started = 0;
+ var arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+ var delay = 10;
+ var limit = 3;
+ var maxTime = 10 * arr.length;
+
+ async.mapLimit(arr, limit, function(x, callback) {
+ started++;
+ if (started === 3) {
+ return callback(new Error("Test Error"));
+ }
+ setTimeout(function() {
+ callback();
+ }, delay);
+ }, function() {});
+
+ setTimeout(function() {
+ expect(started).to.equal(3);
+ done();
+ }, maxTime);
+ });
+
+ it('map with Map', function(done) {
+ if (typeof Map !== 'function')
+ return done();
+
+ var map = new Map();
+ map.set(1, "a");
+ map.set(2, "b");
+ async.map(map, function(val, cb) {
+ cb(null, val);
+ }, function(err, result) {
+ assert(Array.isArray(result), "map should return an array for an iterable");
+ done();
+ });
+ });
+
+ // Issue 1106 on github: https://github.com/caolan/async/issues/1106
+ it('map main callback is called only once', function(done) {
+ async.map([1, 2], function(item, callback) {
+ try {
+ callback(item);
+ } catch (exception) {
+ expect(function() {
+ callback(exception);
+ }).to.throw(/already called/);
+ done();
+ }
+ }, function(err) {
+ no_such_function();
+ });
+ });
+});
View Lorry Controller Status