feathers-utils 1.6.1 → 1.8.0

package/test/utils/addHook.test.ts

@@ -1,307 +0,0 @@
-import assert from "assert";
-import feathers from "@feathersjs/feathers";
-import createService from "feathers-memory";
-
-import { addHook } from "../../src";
-
-import { HookType, ServiceMethodName } from "../../src/types";
-
-const mockApp = (withHooks?: boolean) => {
-  const app = feathers();
-  app.use("users", createService());
-  app.use("tasks", createService());
-  app.use("authentication", createService());
-  const usersService = app.service("users");
-  const tasksService = app.service("tasks");
-  const authenticationService = app.service("authentication");
-  usersService.path = "users";
-  tasksService.path = "tasks";
-  authenticationService.path = "authentication";
-  if (withHooks) {
-    [usersService, tasksService, authenticationService].forEach(service => {
-      service.hooks({
-        before: {
-          // eslint-disable-next-line @typescript-eslint/no-empty-function
-          all: [() => {}]
-        },
-        after: {
-          // eslint-disable-next-line @typescript-eslint/no-empty-function
-          all: [() => {}]
-        },
-        error: {
-          // eslint-disable-next-line @typescript-eslint/no-empty-function
-          all: [() => {}]
-        }
-      });
-    });
-  } else {
-    [usersService, tasksService, authenticationService].forEach(service => {
-      service.hooks({
-        before: { all: [] },
-        after: { all: [] },
-        error: { all: [] }
-      });
-    });
-  }
-  return {
-    app,
-    usersService,
-    tasksService,
-    authenticationService
-  };
-};
-
-describe("util - addHook", function() {
-  it("adds all hooks", function() {
-    const {
-      app,
-      usersService,
-      tasksService,
-      authenticationService
-    } = mockApp();
-    
-    const types = ["before", "after", "error"] as HookType[];
-    const methods = ["find", "get", "create", "update", "patch", "remove"] as ServiceMethodName[];
-    
-    addHook(app, "addHook", {
-      types,
-      methods,
-      orderByType: {
-        before: "first",
-        after: "first",
-        error: "first"
-      }
-    });
-    
-    [usersService, tasksService, authenticationService].forEach(service => {
-      types.forEach(type => {
-        methods.forEach(method => {
-          const hooks = service.__hooks[type][method];
-          assert.strictEqual(hooks.length, 1, `'${service.path}/${type}:${method}': has 1 hook`);
-          assert.strictEqual(hooks[0], "addHook", `'${service.path}/${type}:${method}': hook is 'addHook'`);
-        });
-      });
-    });
-  });
-
-  it("adds hooks to specific type", function() {
-    const types = ["before", "after", "error"] as HookType[];
-    const methods = ["find", "get", "create", "update", "patch", "remove"] as ServiceMethodName[];
-    
-    types.forEach(type => {
-      const {
-        app,
-        usersService,
-        tasksService,
-        authenticationService
-      } = mockApp();
-      
-      addHook(app, "addHook", {
-        types: [type],
-        methods,
-        orderByType: {
-          before: "first",
-          after: "first",
-          error: "first"
-        }
-      });
-
-      const remainingTypes = types.filter(x => x !== type);
-
-      [usersService, tasksService, authenticationService].forEach(service => {
-        methods.forEach(method => {
-          const hooks = service.__hooks[type][method];
-          assert.strictEqual(hooks.length, 1, `'${service.path}/${type}:${method}': has 1 hook`);
-          assert.strictEqual(hooks[0], "addHook", `'${service.path}/${type}:${method}': hook is 'addHook'`);
-          remainingTypes.forEach(type => {
-            const hooks = service.__hooks[type][method];
-            assert.strictEqual(hooks.length, 0, `'${service.path}/${type}:${method}': has zero hooks`);
-          });
-        });
-      });
-    });
-  });
-
-  it("adds hooks to specific type and method", function() {
-    const types = ["before", "after", "error"] as HookType[];
-    const methods = ["find", "get", "create", "update", "patch", "remove"] as ServiceMethodName[];
-
-    const method = "find";
-    
-    types.forEach(type => {
-      const {
-        app,
-        usersService,
-        tasksService,
-        authenticationService
-      } = mockApp();
-      
-      addHook(app, "addHook", {
-        types: [type],
-        methods: [method],
-        orderByType: {
-          before: "first",
-          after: "first",
-          error: "first"
-        }
-      });
-
-      const remainingTypes = types.filter(x => x !== type);
-      const remainingMethods = methods.filter(x => x != method);
-
-      [usersService, tasksService, authenticationService].forEach(service => {
-        const hooks = service.__hooks[type][method];
-        assert.strictEqual(hooks.length, 1, `'${service.path}/${type}:${method}': has 1 hook`);
-        assert.strictEqual(hooks[0], "addHook", `'${service.path}/${type}:${method}': hook is 'addHook'`);
-        remainingTypes.forEach(type => {
-          remainingMethods.forEach(method => {
-            const hooks = service.__hooks[type][method];
-            assert.strictEqual(hooks.length, 0, `'${service.path}/${type}:${method}': has zero hooks`);
-          });
-        });
-      });
-    });
-  });
-
-  it("appends all hooks with 'last'", function() {
-    const {
-      app,
-      usersService,
-      tasksService,
-      authenticationService
-    } = mockApp(true);
-
-    const types = ["before", "after", "error"] as HookType[];
-    const methods = ["find", "get", "create", "update", "patch", "remove"] as ServiceMethodName[];
-
-    addHook(app, "addHook", {
-      types,
-      methods,
-      orderByType: {
-        before: "last",
-        after: "last",
-        error: "last"
-      }
-    });
-
-    [usersService, tasksService, authenticationService].forEach(service => {
-      types.forEach(type => {
-        methods.forEach(method => {
-          const hooks = service.__hooks[type][method];
-          assert.strictEqual(hooks.length, 2, `'${service.path}/${type}:${method}': has 2 hooks`);
-          assert.strictEqual(hooks[1], "addHook", `'${service.path}/${type}:${method}': last hook is 'addHook'`);
-        });
-      });
-    });
-  });
-
-  it("prepends all hooks with 'first'", function() {
-    const {
-      app,
-      usersService,
-      tasksService,
-      authenticationService
-    } = mockApp(true);
-
-    const types = ["before", "after", "error"] as HookType[];
-    const methods = ["find", "get", "create", "update", "patch", "remove"] as ServiceMethodName[];
-
-    addHook(app, "addHook", {
-      types,
-      methods,
-      orderByType: {
-        before: "first",
-        after: "first",
-        error: "first"
-      }
-    });
-
-    [usersService, tasksService, authenticationService].forEach(service => {
-      types.forEach(type => {
-        methods.forEach(method => {
-          const hooks = service.__hooks[type][method];
-          assert.strictEqual(hooks.length, 2, `'${service.path}/${type}:${method}' has 2 hooks`);
-          assert.strictEqual(hooks[0], "addHook", `'${service.path}/${type}:${method}': first hook is 'addHook'`);
-        });
-      });
-    });
-  });
-
-  it("ignores blacklisted", function() {
-    const {
-      app,
-      usersService,
-      tasksService,
-      authenticationService
-    } = mockApp();
-
-    const types = ["before", "after", "error"] as HookType[];
-    const methods = ["find", "get", "create", "update", "patch", "remove"] as ServiceMethodName[];
-
-    const blacklist = ["authentication"];
-
-    addHook(app, "addHook", {
-      types,
-      methods,
-      orderByType: {
-        before: "first",
-        after: "first",
-        error: "first"
-      },
-      blacklist: ["authentication"]
-    });
-
-    [usersService, tasksService, authenticationService].forEach(service => {
-      types.forEach(type => {
-        methods.forEach(method => {
-          const hooks = service.__hooks[type][method];
-          if (blacklist.includes(service.path)) {
-            assert.strictEqual(hooks.length, 0, `'${service.path}/${type}:${method}' has zero hooks`);
-          } else {
-            assert.strictEqual(hooks.length, 1, `'${service.path}/${type}:${method}' has 1 hook`);
-            assert.strictEqual(hooks[0], "addHook", "hook is 'addHook'");
-          }
-        });
-      });
-    });
-  });
-
-  it("only sets whitelist", function() {
-    const {
-      app,
-      usersService,
-      tasksService,
-      authenticationService
-    } = mockApp();
-
-    const types = ["before", "after", "error"] as HookType[];
-    const methods = ["find", "get", "create", "update", "patch", "remove"] as ServiceMethodName[];
-
-    const whitelist = ["users"];
-
-    addHook(app, "addHook", {
-      types,
-      methods,
-      orderByType: {
-        before: "first",
-        after: "first",
-        error: "first"
-      },
-      whitelist
-    });
-
-    [usersService, tasksService, authenticationService].forEach(service => {
-      types.forEach(type => {
-        methods.forEach(method => {
-          const hooks = service.__hooks[type][method];
-          if (whitelist.includes(service.path)) {
-            assert.strictEqual(hooks.length, 1, `'${service.path}/${type}:${method}' has 1 hook`);
-            assert.strictEqual(hooks[0], "addHook", "hook is 'addHook'");
-          } else {
-            assert.strictEqual(hooks.length, 0, `'${service.path}/${type}:${method}' has zero hooks`);
-          }
-        });
-      });
-    });
-  });
-});

package/test/utils/isMulti.test.ts

@@ -1,53 +0,0 @@
-import assert from "assert";
-import { isMulti } from "../../src";
-
-describe("util - isMulti", function() {
-  it("returns true", function() {
-    const makeContext = (type: string, method: string) => {
-      const context = {
-        method,
-        type,
-      };
-      if (method === "create") {
-        (type === "before") 
-        //@ts-ignore
-          ? context.data = [] 
-        //@ts-ignore
-          : context.result = [];
-      }
-      return context;
-    };
-    ["before", "after"].forEach(type => {
-      ["find", "create", "patch", "remove"].forEach(method => {
-        const context = makeContext(type, method);
-        //@ts-ignore
-        assert.strictEqual(isMulti(context), true, `'${type}:${method}': returns true`);
-      });
-    });
-  });
-
-  it("returns false", function() {
-    const makeContext = (type: string, method: string) => {
-      const context = {
-        method,
-        type,
-        id: 0
-      };
-      if (method === "create") {
-        (type === "before")
-        //@ts-ignore
-          ? context.data = {}
-        //@ts-ignore
-          : context.result = {};
-      }
-      return context;
-    };
-    ["before", "after"].forEach(type => {
-      ["get", "create", "update", "patch", "remove"].forEach(method => {
-        const context = makeContext(type, method);
-        //@ts-ignore
-        assert.strictEqual(isMulti(context), false, `'${type}:${method}': returns false`);
-      });
-    });
-  });
-});

package/test/utils/markHookForSkip.test.ts

@@ -1,292 +0,0 @@
-import assert from "assert";
-import feathers from "@feathersjs/feathers";
-import { Service } from "feathers-memory";
-import { shouldSkip, markHookForSkip } from "../../src";
-
-describe("util - markHookForSkip", function() {
-  it("returns hook object", function() {
-    const context = markHookForSkip("test", "all", {});
-    assert.ok(context, "returned context");
-    assert.ok(context.params.skipHooks, "has skipHooks");
-  });
-
-  it("returns hook object for undefined context", function() {
-    const context = markHookForSkip("test", "all");
-    assert.ok(context, "returned context");
-    assert.ok(context.params.skipHooks, "has skipHooks");
-  });
-  
-  it("skips explicitly before hook", async function() {
-    const app = feathers();
-    app.use("service", new Service());
-    const service = app.service("service");
-    const ranInto = {};
-    service.hooks({
-      before: {
-        all: [
-          context => {
-            markHookForSkip("test", "before", context);
-          }
-        ],
-        find: [
-          context => {
-            if (shouldSkip("test", context)) { return context; }
-            ranInto["find"] = true;
-          },
-          context => { context.result = null; }
-        ],
-        get: [
-          context => {
-            if (shouldSkip("test", context)) { return context; }
-            ranInto["get"] = true;
-          },
-          context => { context.result = null; }
-        ],
-        create: [
-          context => {
-            if (shouldSkip("test", context)) { return context; }
-            ranInto["create"] = true;
-          },
-          context => { context.result = null; }
-        ],
-        update: [
-          context => {
-            if (shouldSkip("test", context)) { return context; }
-            ranInto["update"] = true;
-          },
-          context => { context.result = null; }
-        ],
-        patch: [
-          context => {
-            if (shouldSkip("test", context)) { return context; }
-            ranInto["patch"] = true;
-          },
-          context => { context.result = null; }
-        ],
-        remove: [
-          context => {
-            if (shouldSkip("test", context)) { return context; }
-            ranInto["remove"] = true;
-          },
-          context => { context.result = null; }
-        ]
-      }
-    });
-    const methods = {
-      find: [],
-      get: [1],
-      create: [{}],
-      update: [1, {}],
-      patch: [1, {}],
-      remove: [1]
-    };
-    const promises = Object.keys(methods).map(async method => {
-      await service[method](...methods[method]);
-      assert.ok(!Object.prototype.hasOwnProperty.call(ranInto, method), `'${method}': did not run into hook`);
-      return true;
-    });
-
-    const results = await Promise.all(promises);
-    assert.ok(results.every(x => x === true), "all ok");
-  });
-
-  it("skips explicitly after hook", async function() {
-    const app = feathers();
-    app.use("service", new Service());
-    const service = app.service("service");
-    const ranInto = {};
-    service.hooks({
-      before: {
-        all: [
-          context => {
-            markHookForSkip("test", "after", context);
-          },
-          context => {
-            context.result = null;
-            return context;
-          }
-        ]
-      },
-      after: {
-        find: [
-          context => {
-            if (shouldSkip("test", context)) { return context; }
-            ranInto["find"] = true;
-          },
-          context => { context.result = null; }
-        ],
-        get: [
-          context => {
-            if (shouldSkip("test", context)) { return context; }
-            ranInto["get"] = true;
-          },
-          context => { context.result = null; }
-        ],
-        create: [
-          context => {
-            if (shouldSkip("test", context)) { return context; }
-            ranInto["create"] = true;
-          },
-          context => { context.result = null; }
-        ],
-        update: [
-          context => {
-            if (shouldSkip("test", context)) { return context; }
-            ranInto["update"] = true;
-          },
-          context => { context.result = null; }
-        ],
-        patch: [
-          context => {
-            if (shouldSkip("test", context)) { return context; }
-            ranInto["patch"] = true;
-          },
-          context => { context.result = null; }
-        ],
-        remove: [
-          context => {
-            if (shouldSkip("test", context)) { return context; }
-            ranInto["remove"] = true;
-          },
-          context => { context.result = null; }
-        ]
-      }
-    });
-    const methods = {
-      find: [],
-      get: [1],
-      create: [{}],
-      update: [1, {}],
-      patch: [1, {}],
-      remove: [1]
-    };
-    const promises = Object.keys(methods).map(async method => {
-      await service[method](...methods[method]);
-      assert.ok(!Object.prototype.hasOwnProperty.call(ranInto, method), `'${method}': did not run into hook`);
-      return true;
-    });
-
-    const results = await Promise.all(promises);
-    assert.ok(results.every(x => x === true), "all ok");
-  });
-
-  it("skips all hooks", async function() {
-    const app = feathers();
-    app.use("service", new Service());
-    const service = app.service("service");
-    const ranIntoBefore = {};
-    const ranIntoAfter = {};
-    service.hooks({
-      before: {
-        all: [
-          context => {
-            markHookForSkip("test", "all", context);
-          }
-        ],
-        find: [
-          context => {
-            if (shouldSkip("test", context)) { return context; }
-            ranIntoBefore["find"] = true;
-          },
-          context => { context.result = null; }
-        ],
-        get: [
-          context => {
-            if (shouldSkip("test", context)) { return context; }
-            ranIntoBefore["get"] = true;
-          },
-          context => { context.result = null; }
-        ],
-        create: [
-          context => {
-            if (shouldSkip("test", context)) { return context; }
-            ranIntoBefore["create"] = true;
-          },
-          context => { context.result = null; }
-        ],
-        update: [
-          context => {
-            if (shouldSkip("test", context)) { return context; }
-            ranIntoBefore["update"] = true;
-          },
-          context => { context.result = null; }
-        ],
-        patch: [
-          context => {
-            if (shouldSkip("test", context)) { return context; }
-            ranIntoBefore["patch"] = true;
-          },
-          context => { context.result = null; }
-        ],
-        remove: [
-          context => {
-            if (shouldSkip("test", context)) { return context; }
-            ranIntoBefore["remove"] = true;
-          },
-          context => { context.result = null; }
-        ]
-      },
-      after: {
-        find: [
-          context => {
-            if (shouldSkip("test", context)) { return context; }
-            ranIntoAfter["find"] = true;
-          },
-          context => { context.result = null; }
-        ],
-        get: [
-          context => {
-            if (shouldSkip("test", context)) { return context; }
-            ranIntoAfter["get"] = true;
-          },
-          context => { context.result = null; }
-        ],
-        create: [
-          context => {
-            if (shouldSkip("test", context)) { return context; }
-            ranIntoAfter["create"] = true;
-          },
-          context => { context.result = null; }
-        ],
-        update: [
-          context => {
-            if (shouldSkip("test", context)) { return context; }
-            ranIntoAfter["update"] = true;
-          },
-          context => { context.result = null; }
-        ],
-        patch: [
-          context => {
-            if (shouldSkip("test", context)) { return context; }
-            ranIntoAfter["patch"] = true;
-          },
-          context => { context.result = null; }
-        ],
-        remove: [
-          context => {
-            if (shouldSkip("test", context)) { return context; }
-            ranIntoAfter["remove"] = true;
-          },
-          context => { context.result = null; }
-        ]
-      }
-    });
-    const methods = {
-      find: [],
-      get: [1],
-      create: [{}],
-      update: [1, {}],
-      patch: [1, {}],
-      remove: [1]
-    };
-    const promises = Object.keys(methods).map(async method => {
-      await service[method](...methods[method]);
-      assert.ok(!Object.prototype.hasOwnProperty.call(ranIntoBefore, method), `'${method}': did not run into before hook`);
-      assert.ok(!Object.prototype.hasOwnProperty.call(ranIntoAfter, method), `'${method}': did not run into after hook`);
-      return true;
-    });
-
-    const results = await Promise.all(promises);
-    assert.ok(results.every(x => x === true), "all ok");
-  });
-});