Homec4science
Diffusion Open Access Compliance Check Tool (OACCT) (master) Browse

rOACCT/node_modules/gensync/test/index.test.js
c8c51d555a67master

Last Change
Raw File

index.test.js
View Options

"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,
});
});
});
c4science · Help