All new

alle new

node_modules/mammoth/test/promises.tests.js

@@ -0,0 +1,238 @@
+var assert = require("assert");
+
+var promises = require("../lib/promises");
+var test = require("./test")(module);
+
+test("forEachSeries", {
+    "empty array resolves immediately without calling function": function() {
+        return promises.forEachSeries([], function() {
+            throw new Error();
+        }).then(function(result) {
+            assert.deepStrictEqual(result, undefined);
+        });
+    },
+
+    "function is called on element after the previous element has been processed": function() {
+        var log = [];
+
+        return promises.forEachSeries([1, 2, 3], function(element) {
+            return new promises.Promise(function(resolve) {
+                log.push(["start", element]);
+                setTimeout(function() {
+                    log.push(["end", element]);
+                    resolve();
+                }, 0);
+            });
+        }).then(function(result) {
+            assert.deepStrictEqual(result, undefined);
+            assert.deepStrictEqual(log, [
+                ["start", 1],
+                ["end", 1],
+                ["start", 2],
+                ["end", 2],
+                ["start", 3],
+                ["end", 3]
+            ]);
+        });
+    },
+
+    "processing stops on sync error": function() {
+        var log = [];
+
+        return promises.forEachSeries([1, 2, 3], function(element) {
+            return new promises.Promise(function(resolve) {
+                log.push(["start", element]);
+                if (element === 2) {
+                    throw new Error("failure");
+                } else {
+                    setTimeout(function() {
+                        log.push(["end", element]);
+                        resolve();
+                    }, 0);
+                }
+            });
+        }).then(
+            function() {
+                assert.fail("Expected rejection");
+            },
+            function(error) {
+                assert.strictEqual(error.message, "failure");
+                assert.deepStrictEqual(log, [
+                    ["start", 1],
+                    ["end", 1],
+                    ["start", 2]
+                ]);
+            }
+        );
+    },
+
+    "processing stops on async error": function() {
+        var log = [];
+
+        return promises.forEachSeries([1, 2, 3], function(element) {
+            return new promises.Promise(function(resolve, reject) {
+                log.push(["start", element]);
+                setTimeout(function() {
+                    if (element === 2) {
+                        reject(new Error("failure"));
+                    } else {
+                        log.push(["end", element]);
+                        resolve();
+                    }
+                }, 0);
+            });
+        }).then(
+            function() {
+                assert.fail("Expected rejection");
+            },
+            function(error) {
+                assert.strictEqual(error.message, "failure");
+                assert.deepStrictEqual(log, [
+                    ["start", 1],
+                    ["end", 1],
+                    ["start", 2]
+                ]);
+            }
+        );
+    }
+});
+
+test("try", {
+    "when function succeeds with non-promise then promise is resolved": function() {
+        return promises.try(function() {
+            return "success";
+        }).then(function(result) {
+            assert.strictEqual(result, "success");
+        });
+    },
+
+    "when function succeeds with promise then promise is resolved": function() {
+        return promises.try(function() {
+            return promises.resolve("success");
+        }).then(function(result) {
+            assert.strictEqual(result, "success");
+        });
+    },
+
+    "when function throws error then promise is rejected": function() {
+        return promises.try(function() {
+            throw new Error("failure");
+        }).then(
+            function() {
+                assert.fail("Expected rejection");
+            },
+            function(error) {
+                assert.strictEqual(error.message, "failure");
+            }
+        );
+    },
+
+    "when function fails with promise then promise is rejected": function() {
+        return promises.try(function() {
+            return promises.reject(new Error("failure"));
+        }).then(
+            function() {
+                assert.fail("Expected rejection");
+            },
+            function(error) {
+                assert.strictEqual(error.message, "failure");
+            }
+        );
+    }
+});
+
+test("props", {
+    "props({}) resolve to {}": function() {
+        return promises.props({}).then(function(result) {
+            assert.deepStrictEqual(result, {});
+        });
+    },
+
+    "when object has promise values then props returns with all values resolved": function() {
+        return promises.props({
+            a: promises.resolve(1),
+            b: promises.resolve(2),
+            c: promises.resolve(3)
+        }).then(function(result) {
+            assert.deepStrictEqual(result, {
+                a: 1,
+                b: 2,
+                c: 3
+            });
+        });
+    },
+
+    "when object has non-promise values then props returns with same values": function() {
+        return promises.props({
+            a: 1,
+            b: 2,
+            c: 3
+        }).then(function(result) {
+            assert.deepStrictEqual(result, {
+                a: 1,
+                b: 2,
+                c: 3
+            });
+        });
+    },
+
+    "when value is rejected promise then props is rejected promise": function() {
+        return promises.props({
+            a: promises.resolve(1),
+            b: promises.reject(new Error("failure")),
+            c: promises.resolve(3)
+        }).then(
+            function(result) {
+                assert.fail("Expected rejection");
+            },
+            function(error) {
+                assert.strictEqual(error.message, "failure");
+            }
+        );
+    },
+
+    "props(...).also(...) can be used to add props": function() {
+        return promises.props({
+            a: promises.resolve(1)
+        }).also(function(result) {
+            return {
+                b: result.a + 1
+            };
+        }).then(function(result) {
+            assert.deepStrictEqual(result, {
+                a: 1,
+                b: 2
+            });
+        });
+    },
+
+    "also can be used multiple times": function() {
+        return promises.props({
+            a: promises.resolve(1)
+        }).also(function(result) {
+            return {
+                b: result.a + 1
+            };
+        }).also(function(result) {
+            return {
+                c: result.b + 1
+            };
+        }).then(function(result) {
+            assert.deepStrictEqual(result, {
+                a: 1,
+                b: 2,
+                c: 3
+            });
+        });
+    }
+});
+
+test("toExternalPromise() returns promise with .done()", function() {
+    var nativePromise = Promise.resolve("hello");
+
+    var externalPromise = promises.toExternalPromise(nativePromise);
+
+    externalPromise.done();
+
+    externalPromise.then().done();
+});