wice_grid 7.1.0 → 7.1.2

data/node_modules/gensync/test/index.test.js

@@ -1,489 +0,0 @@
-"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,
-    });
-  });
-
-  test("empty list", async () => {
-    const fn = gensync(function*() {
-      yield* gensync.all([]);
-    });
-
-    await expectResult(fn, undefined, {
-      value: undefined,
-      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,
-    });
-  });
-});