Added async support

Author: sunesimonsen

documentation/assertions/function/to-be-valid-for-all.md

@@ -1,4 +1,4 @@
-An assertion that runs the subject function up to 100 times with different
+An assertion that runs the subject function up to 300 times with different
 generated input. If the subject function fails an error is thrown.
 
 Let's tests that
@@ -144,3 +144,25 @@ expect(function (actions) {
   expect(dequeued, 'to equal', enqueued);
 }, 'to be valid for all', actions);
 ```
+
+Support for asynchronous testing by returning a promise from the subject
+function:
+
+```js#async:true
+expect.use(require('unexpected-stream'));
+
+return expect(function (text) {
+  return expect(
+    text,
+    'when piped through',
+    [
+      require('zlib').Gzip(),
+      require('zlib').Gunzip()
+    ],
+    'to yield output satisfying',
+    'when decoded as', 'utf-8',
+    'to equal',
+    text
+  );
+}, 'to be valid for all', g.string);
+```

documentation/index.md

@@ -150,6 +150,30 @@ define(['unexpected', 'unexpected-check'], funtion (unexpected, unexpectedCheck)
 Notice that the [chance](www.chancejs.com) library some we configured with the
 name `chance`.
 
+## Asynchronous testing
+
+Support for asynchronous testing by returning a promise from the subject
+function:
+
+```js#async:true
+expect.use(require('unexpected-stream'));
+
+return expect(function (text) {
+  return expect(
+    text,
+    'when piped through',
+    [
+      require('zlib').Gzip(),
+      require('zlib').Gunzip()
+    ],
+    'to yield output satisfying',
+    'when decoded as', 'utf-8',
+    'to equal',
+    text
+  );
+}, 'to be valid for all', g.string);
+```
+
 ## Source
 
 The source for this plugin can be found on

lib/unexpected-check.js

@@ -34,6 +34,19 @@
     return {
         name: 'unexpected-check',
         installInto: function (expect) {
+            var promiseLoop = function (condition, action) {
+                return expect.promise(function (resolve, reject) {
+                    var loop = function () {
+                        if (!condition()) return resolve();
+                        return action()
+                            .then(loop)
+                            .catch(reject);
+                    };
+
+                    loop();
+                });
+            };
+
             expect.addAssertion('<function> to be valid for all <object>', function (expect, subject, options) {
                 var generators = options.generators;
                 var maxIterations = options.maxIterations || 300;
@@ -48,15 +61,6 @@
                         args: args
                     };
 
-                    try {
-                        subject.apply(null, args);
-                    } catch (e) {
-                        generators = generators.map(function (g, i) {
-                            return g.shrink ? g.shrink(args[i]) : g;
-                        });
-                        task.error = e;
-                    }
-
                     return task;
                 }
 
@@ -69,51 +73,66 @@
                 function createTasks() {
                     var tasks = [];
                     var errors = 0;
-                    for (var i = 0; i < maxIterations && errors < maxErrors; i += 1) {
-                        if (errors > 0 && !hasShrinkableGenerators()) {
-                            break;
-                        }
+                    var i = 0;
 
+                    return promiseLoop(function () {
+                        return (
+                            i < maxIterations &&
+                            errors < maxErrors &&
+                            (errors === 0 || hasShrinkableGenerators())
+                        );
+                    }, function () {
                         var task = createTask();
                         tasks.push(task);
-                        if (task.error) {
+
+                        return expect.promise(function () {
+                            return subject.apply(null, task.args);
+                        }).then(function () {
+                            i++;
+                        }, function (err) {
+                            generators = generators.map(function (g, i) {
+                                return g.shrink ? g.shrink(task.args[i]) : g;
+                            });
+                            task.error = err;
                             errors++;
-                        }
-                    }
-                    return tasks;
+                            i++;
+                        });
+                    }).then(function () {
+                        return tasks;
+                    });
                 }
 
-                var tasks = createTasks();
+                return createTasks().then(function (tasks) {
+                    var failedTasks = tasks.filter(function (task) {
+                        return task.error;
+                    });
 
-                var failedTasks = tasks.filter(function (task) {
-                    return task.error;
-                });
+                    if (failedTasks.length > 0) {
+                        var bestFailure = failedTasks[failedTasks.length - 1];
+
+                        expect.errorMode = 'bubble';
+                        expect.fail(function (output) {
+                            output.error('Ran ').jsNumber(tasks.length).sp()
+                                .error(tasks.length > 1 ? 'iterations' : 'iteration')
+                                .error(' and found ').jsNumber(failedTasks.length).error(' errors').nl()
+                                .error('counterexample:').nl(2);
 
-                if (failedTasks.length > 0) {
-                    var bestFailure = failedTasks[failedTasks.length - 1];
-
-                    expect.errorMode = 'bubble';
-                    expect.fail(function (output) {
-                        output.error('Ran ').jsNumber(tasks.length).sp()
-                            .error(tasks.length > 1 ? 'iterations' : 'iteration')
-                            .error(' and found ').jsNumber(failedTasks.length).error(' errors').nl()
-                            .error('counterexample:').nl(2);
-
-                        output.indentLines();
-                        output.i().block(function (output) {
-                            output.text('Generated input: ').appendItems(bestFailure.args, ', ');
-                            output.nl(2).block(function (output) {
-                                output.appendErrorMessage(bestFailure.error);
+                            output.indentLines();
+                            output.i().block(function (output) {
+                                output.text('Generated input: ').appendItems(bestFailure.args, ', ');
+                                output.nl(2).block(function (output) {
+                                    output.appendErrorMessage(bestFailure.error);
+                                });
                             });
                         });
-                    });
-                }
+                    }
+                });
             });
 
             expect.addAssertion('<function> to be valid for all <function+>', function (expect, subject) {
                 expect.errorMode = 'bubble';
 
-                expect(subject, 'to be valid for all', {
+                return expect(subject, 'to be valid for all', {
                     generators: Array.prototype.slice.call(arguments, 2)
                 });
             });

package.json

@@ -24,8 +24,9 @@
     "lodash.escape": "3.1.0",
     "lodash.unescape": "3.1.0",
     "mocha": "2.3.4",
-    "unexpected": "10.5.1",
+    "unexpected": "10.13.3",
     "unexpected-documentation-site-generator": "^4.0.0",
-    "unexpected-markdown": "^1.4.0"
+    "unexpected-markdown": "^1.4.0",
+    "unexpected-stream": "2.0.3"
   }
 }

test/unexpected-check.spec.js

@@ -157,4 +157,48 @@ describe('unexpected-check', function () {
                '                    //             ^\n' +
                '  ]');
     });
+
+    it('supports asynchronous bodies', function () {
+        return expect(
+            expect(function (items, i) {
+                return expect.promise(function () {
+                    expect(items, 'not to contain', i);
+                }).delay(1);
+            }, 'to be valid for all', arrays, g.integer({ min: -20, max: 20 }))
+        , 'to be rejected with',
+            'Ran 143 iterations and found 20 errors\n' +
+            'counterexample:\n' +
+            '\n' +
+            '  Generated input: [ -4 ], -4\n' +
+            '\n' +
+            '  expected [ -4 ] not to contain -4\n' +
+            '\n' +
+            '  [\n' +
+            '    -4 // should be removed\n' +
+            '  ]');
+    });
+
+    it('supports a mix between synchronous and asynchronous bodies', function () {
+        return expect(
+            expect(function (items, i) {
+                if (i % 2 === 0) {
+                    expect(items, 'not to contain', i);
+                } else {
+                    return expect.promise(function () {
+                        expect(items, 'not to contain', i);
+                    }).delay(1);
+                }
+            }, 'to be valid for all', arrays, g.integer({ min: -20, max: 20 }))
+        , 'to be rejected with',
+            'Ran 143 iterations and found 20 errors\n' +
+            'counterexample:\n' +
+            '\n' +
+            '  Generated input: [ -4 ], -4\n' +
+            '\n' +
+            '  expected [ -4 ] not to contain -4\n' +
+            '\n' +
+            '  [\n' +
+            '    -4 // should be removed\n' +
+            '  ]');
+    });
 });