diff options
Diffstat (limited to 'assets/node_modules/gensync/test/index.test.js')
| -rw-r--r-- | assets/node_modules/gensync/test/index.test.js | 475 |
1 files changed, 475 insertions, 0 deletions
diff --git a/assets/node_modules/gensync/test/index.test.js b/assets/node_modules/gensync/test/index.test.js new file mode 100644 index 0000000..fd4f231 --- /dev/null +++ b/assets/node_modules/gensync/test/index.test.js @@ -0,0 +1,475 @@ +"use strict"; + +const promisify = require("util.promisify"); +const gensync = require("../"); + +const TEST_ERROR = new Error("TEST_ERROR"); + +const DID_ERROR = new Error("DID_ERROR"); + +const doSuccess = gensync({ + sync: () => 42, + async: () => Promise.resolve(42), +}); + +const doError = gensync({ + sync: () => { + throw DID_ERROR; + }, + async: () => Promise.reject(DID_ERROR), +}); + +function throwTestError() { + throw TEST_ERROR; +} + +async function expectResult( + fn, + arg, + { error, value, expectSync = false, syncErrback = expectSync } +) { + if (!expectSync) { + expect(() => fn.sync(arg)).toThrow(TEST_ERROR); + } else if (error) { + expect(() => fn.sync(arg)).toThrow(error); + } else { + expect(fn.sync(arg)).toBe(value); + } + + if (error) { + await expect(fn.async(arg)).rejects.toBe(error); + } else { + await expect(fn.async(arg)).resolves.toBe(value); + } + + await new Promise((resolve, reject) => { + let sync = true; + fn.errback(arg, (err, val) => { + try { + expect(err).toBe(error); + expect(val).toBe(value); + expect(sync).toBe(syncErrback); + + resolve(); + } catch (e) { + reject(e); + } + }); + sync = false; + }); +} + +describe("gensync({})", () => { + describe("option validation", () => { + test("disallow async and errback handler together", () => { + try { + gensync({ + sync: throwTestError, + async: throwTestError, + errback: throwTestError, + }); + + throwTestError(); + } catch (err) { + expect(err.message).toMatch( + /Expected one of either opts.async or opts.errback, but got _both_\./ + ); + expect(err.code).toBe("GENSYNC_OPTIONS_ERROR"); + } + }); + + test("disallow missing sync handler", () => { + try { + gensync({ + async: throwTestError, + }); + + throwTestError(); + } catch (err) { + expect(err.message).toMatch(/Expected opts.sync to be a function./); + expect(err.code).toBe("GENSYNC_OPTIONS_ERROR"); + } + }); + + test("errback callback required", () => { + const fn = gensync({ + sync: throwTestError, + async: throwTestError, + }); + + try { + fn.errback(); + + throwTestError(); + } catch (err) { + expect(err.message).toMatch(/function called without callback/); + expect(err.code).toBe("GENSYNC_ERRBACK_NO_CALLBACK"); + } + }); + }); + + describe("generator function metadata", () => { + test("automatic naming", () => { + expect( + gensync({ + sync: function readFileSync() {}, + async: () => {}, + }).name + ).toBe("readFile"); + expect( + gensync({ + sync: function readFile() {}, + async: () => {}, + }).name + ).toBe("readFile"); + expect( + gensync({ + sync: function readFileAsync() {}, + async: () => {}, + }).name + ).toBe("readFileAsync"); + + expect( + gensync({ + sync: () => {}, + async: function readFileSync() {}, + }).name + ).toBe("readFileSync"); + expect( + gensync({ + sync: () => {}, + async: function readFile() {}, + }).name + ).toBe("readFile"); + expect( + gensync({ + sync: () => {}, + async: function readFileAsync() {}, + }).name + ).toBe("readFile"); + + expect( + gensync({ + sync: () => {}, + errback: function readFileSync() {}, + }).name + ).toBe("readFileSync"); + expect( + gensync({ + sync: () => {}, + errback: function readFile() {}, + }).name + ).toBe("readFile"); + expect( + gensync({ + sync: () => {}, + errback: function readFileAsync() {}, + }).name + ).toBe("readFileAsync"); + }); + + test("explicit naming", () => { + expect( + gensync({ + name: "readFile", + sync: () => {}, + async: () => {}, + }).name + ).toBe("readFile"); + }); + + test("default arity", () => { + expect( + gensync({ + sync: function(a, b, c, d, e, f, g){ throwTestError(); }, + async: throwTestError, + }).length + ).toBe(7); + }); + + test("explicit arity", () => { + expect( + gensync({ + arity: 3, + sync: throwTestError, + async: throwTestError, + }).length + ).toBe(3); + }); + }); + + describe("'sync' handler", async () => { + test("success", async () => { + const fn = gensync({ + sync: (...args) => JSON.stringify(args), + }); + + await expectResult(fn, 42, { value: "[42]", expectSync: true }); + }); + + test("failure", async () => { + const fn = gensync({ + sync: (...args) => { + throw JSON.stringify(args); + }, + }); + + await expectResult(fn, 42, { error: "[42]", expectSync: true }); + }); + }); + + describe("'async' handler", async () => { + test("success", async () => { + const fn = gensync({ + sync: throwTestError, + async: (...args) => Promise.resolve(JSON.stringify(args)), + }); + + await expectResult(fn, 42, { value: "[42]" }); + }); + + test("failure", async () => { + const fn = gensync({ + sync: throwTestError, + async: (...args) => Promise.reject(JSON.stringify(args)), + }); + + await expectResult(fn, 42, { error: "[42]" }); + }); + }); + + describe("'errback' sync handler", async () => { + test("success", async () => { + const fn = gensync({ + sync: throwTestError, + errback: (...args) => args.pop()(null, JSON.stringify(args)), + }); + + await expectResult(fn, 42, { value: "[42]", syncErrback: true }); + }); + + test("failure", async () => { + const fn = gensync({ + sync: throwTestError, + errback: (...args) => args.pop()(JSON.stringify(args)), + }); + + await expectResult(fn, 42, { error: "[42]", syncErrback: true }); + }); + }); + + describe("'errback' async handler", async () => { + test("success", async () => { + const fn = gensync({ + sync: throwTestError, + errback: (...args) => + process.nextTick(() => args.pop()(null, JSON.stringify(args))), + }); + + await expectResult(fn, 42, { value: "[42]" }); + }); + + test("failure", async () => { + const fn = gensync({ + sync: throwTestError, + errback: (...args) => + process.nextTick(() => args.pop()(JSON.stringify(args))), + }); + + await expectResult(fn, 42, { error: "[42]" }); + }); + }); +}); + +describe("gensync(function* () {})", () => { + test("sync throw before body", async () => { + const fn = gensync(function*(arg = throwTestError()) {}); + + await expectResult(fn, undefined, { + error: TEST_ERROR, + syncErrback: true, + }); + }); + + test("sync throw inside body", async () => { + const fn = gensync(function*() { + throwTestError(); + }); + + await expectResult(fn, undefined, { + error: TEST_ERROR, + syncErrback: true, + }); + }); + + test("async throw inside body", async () => { + const fn = gensync(function*() { + const val = yield* doSuccess(); + throwTestError(); + }); + + await expectResult(fn, undefined, { + error: TEST_ERROR, + }); + }); + + test("error inside body", async () => { + const fn = gensync(function*() { + yield* doError(); + }); + + await expectResult(fn, undefined, { + error: DID_ERROR, + expectSync: true, + syncErrback: false, + }); + }); + + test("successful return value", async () => { + const fn = gensync(function*() { + const value = yield* doSuccess(); + + expect(value).toBe(42); + + return 84; + }); + + await expectResult(fn, undefined, { + value: 84, + expectSync: true, + syncErrback: false, + }); + }); + + test("successful final value", async () => { + const fn = gensync(function*() { + return 42; + }); + + await expectResult(fn, undefined, { + value: 42, + expectSync: true, + }); + }); + + test("yield unexpected object", async () => { + const fn = gensync(function*() { + yield {}; + }); + + try { + await fn.async(); + + throwTestError(); + } catch (err) { + expect(err.message).toMatch( + /Got unexpected yielded value in gensync generator/ + ); + expect(err.code).toBe("GENSYNC_EXPECTED_START"); + } + }); + + test("yield suspend yield", async () => { + const fn = gensync(function*() { + yield Symbol.for("gensync:v1:start"); + + // Should be "yield*" for no error. + yield {}; + }); + + try { + await fn.async(); + + throwTestError(); + } catch (err) { + expect(err.message).toMatch(/Expected GENSYNC_SUSPEND, got {}/); + expect(err.code).toBe("GENSYNC_EXPECTED_SUSPEND"); + } + }); + + test("yield suspend return", async () => { + const fn = gensync(function*() { + yield Symbol.for("gensync:v1:start"); + + // Should be "yield*" for no error. + return {}; + }); + + try { + await fn.async(); + + throwTestError(); + } catch (err) { + expect(err.message).toMatch(/Unexpected generator completion/); + expect(err.code).toBe("GENSYNC_EXPECTED_SUSPEND"); + } + }); +}); + +describe("gensync.all()", () => { + test("success", async () => { + const fn = gensync(function*() { + const result = yield* gensync.all([doSuccess(), doSuccess()]); + + expect(result).toEqual([42, 42]); + }); + + await expectResult(fn, undefined, { + value: undefined, + expectSync: true, + syncErrback: false, + }); + }); + + test("error first", async () => { + const fn = gensync(function*() { + yield* gensync.all([doError(), doSuccess()]); + }); + + await expectResult(fn, undefined, { + error: DID_ERROR, + expectSync: true, + syncErrback: false, + }); + }); + + test("error last", async () => { + const fn = gensync(function*() { + yield* gensync.all([doSuccess(), doError()]); + }); + + await expectResult(fn, undefined, { + error: DID_ERROR, + expectSync: true, + syncErrback: false, + }); + }); +}); + +describe("gensync.race()", () => { + test("success", async () => { + const fn = gensync(function*() { + const result = yield* gensync.race([doSuccess(), doError()]); + + expect(result).toEqual(42); + }); + + await expectResult(fn, undefined, { + value: undefined, + expectSync: true, + syncErrback: false, + }); + }); + + test("error", async () => { + const fn = gensync(function*() { + yield* gensync.race([doError(), doSuccess()]); + }); + + await expectResult(fn, undefined, { + error: DID_ERROR, + expectSync: true, + syncErrback: false, + }); + }); +}); |