Add YUI Tests

Author: juandopazo

tests/assets/firefox-tests.js

@@ -0,0 +1,181 @@
+YUI.add('task-tests', function (Y) {
+    var Promise = function (fn) {
+        var deferred = new task.Deferred();
+        fn(function (value) {
+            deferred.resolve(value);
+        }, function (reason) {
+            deferred.reject(reason);
+        });
+        return deferred.promise;
+    };
+    var spawn = task.spawn;
+    var Assert = Y.Assert;
+
+    Promise.resolve = function (value) {
+        var deferred = new task.Deferred();
+        deferred.resolve(value);
+        return deferred.promise;
+    };
+    Promise.reject = function (reason) {
+        var deferred = new task.Deferred();
+        deferred.reject(reason);
+        return deferred.promise;
+    };
+    Y.Test.Case.prototype.next = function (fn) {
+        var test = this;
+
+        return function () {
+            var args = arguments;
+
+            test.resume(function () {
+                fn.apply(test, args);
+            });
+        };
+    };
+
+    var suite = new Y.Test.Suite({
+        name: 'Task tests'
+    });
+
+    suite.add(new Y.Test.Case({
+        name: 'spawn',
+
+        'should return a new Task': function () {
+            Assert.isInstanceOf(task.Task, spawn(function() {}));
+        }
+    }));
+
+    suite.add(new Y.Test.Case({
+        name: 'yield',
+
+        'should retrieve a promise\'s value': function (done) {
+            var test = this;
+            var expected = 'hello world';
+
+            spawn(function () {
+                var actual = yield Promise.resolve(expected);
+
+                test.resume(function () {
+                    Assert.areSame(expected, actual);
+                });
+            });
+
+            test.wait();
+        },
+        'should wait for promises to resolve': function (done) {
+            var test = this;
+            var expected = 'hello world';
+
+            spawn(function () {
+                var actual = yield new Promise(function (resolve) {
+                    setTimeout(function () {
+                        resolve(expected);
+                    }, 50);
+                });
+
+                test.resume(function () {
+                    Assert.areSame(expected, actual);
+                });
+            });
+
+            test.wait();
+        },
+        'should allow for catching rejected promises': function (done) {
+            var test = this;
+            var expected = new Error('failed');
+
+            spawn(function () {
+                try {
+                    yield Promise.reject(expected);
+                } catch (error) {
+                    test.resume(function () {
+                        Assert.areEqual(expected, error);
+                    });
+                }
+            });
+
+            test.wait();
+        },
+        'should wait for multiple yields': function (done) {
+            spawn(function () {
+                var count = yield Promise.resolve(1);
+                count = yield Promise.resolve(count + 2);
+                count = yield Promise.resolve(count + 3);
+                test.resume(function () {
+                    Assert.areSame(6, count);
+                });
+            });
+        }
+    }));
+
+    suite.add(new Y.Test.Case({
+        name: 'Task as a promise',
+
+        'should be a promise': function () {
+            Assert.isFunction(spawn(function () {}).then);
+        },
+        'should resolve to undefined': function (done) {
+            var test = this;
+
+            spawn(function () {
+                yield Promise.resolve(5);
+            }).then(test.next(function (value) {
+                Assert.isUndefined(value);
+            }));
+
+            test.wait();
+        },
+        'should be rejected when a non-generator function is passed': function (done) {
+            var test = this;
+
+            spawn(function () {}).then(null, test.next(function (error) {
+                Assert.isInstanceOf(Error, error);
+            }));
+
+            test.wait();
+        },
+        'should throw when passed non-generator function that throws': function () {
+            var expected = new Error('failed');
+
+            try {
+                spawn(function () {
+                    throw expected;
+                });
+            } catch (error) {
+                Assert.areSame(expected, error);
+            }
+        },
+        'should be rejected when an error is thrown in the generator function': function (done) {
+            var test = this;
+            var expected = new Error('failed');
+
+            spawn(function () {
+                var foo = yield Promise.resolve(5);
+                throw expected;
+            }).then(null, test.next(function (error) {
+                Assert.areSame(expected, error);
+            }));
+
+            test.wait();
+        },
+        'should be rejected when a yielded rejected promise is uncaught': function (done) {
+            var test = this;
+            var expected = new Error('failed');
+
+            spawn(function () {
+                yield Promise.reject(expected);
+            }).then(null, test.next(function (error) {
+                Assert.areSame(expected, error);
+            }));
+
+            test.wait();
+        }
+    }));
+
+    Y.Test.Runner.add(suite);
+
+}, '0.0.1', {
+    requires: [
+        'test'
+    ]
+});

tests/index.html

@@ -0,0 +1,28 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="utf-8">
+    <title>Task.js tests</title>
+</head>
+<body class="yui3-skin-sam">
+    <div id="logger"></div>
+    <script src="../lib/task.js"></script>
+    <script src="http://yui.yahooapis.com/3.10.1/build/yui/yui-min.js"></script>
+    <script src="assets/firefox-tests.js" type="application/javascript;version=1.8"></script>
+    <script>
+YUI({
+    filter: (window.location.search.match(/[?&]filter=([^&]+)/) || [])[1] || 'raw'
+}).use('test-console', 'task-tests', function (Y) {
+
+    (new Y.Test.Console({
+        height: 500,
+        filters: {
+            pass: true
+        }
+    })).render('#log');
+    Y.Test.Runner.setName('Task');
+    Y.Test.Runner.run();
+});
+    </script>
+</body>
+</html>