feathers-utils 1.6.1 → 2.0.0-0

package/test/mixins/debounce-mixin.test.ts

@@ -1,174 +0,0 @@
-import assert from "assert";
-import feathers from "@feathersjs/feathers";
-import createService from "feathers-memory";
-import { debounceMixin as makeMixin } from "../../src";
-import { performance } from "perf_hooks";
-
-const mockApp = () => {
-  const app = feathers();
-  app.configure(makeMixin({
-    default: {
-      wait: 50,
-      maxWait: 1000
-    },
-    blacklist: ["authentication"]
-  }));
-  app.use("users", createService());
-  app.use("tasks", createService());
-  app.use("posts", createService());
-
-  app.use("authentication", createService());
-
-  const usersService = app.service("users");
-  const tasksService = app.service("tasks");
-  const postsService = app.service("posts");
-  const authenticationService = app.service("authentication");
-
-  return {
-    app,
-    usersService,
-    tasksService,
-    postsService,
-    authenticationService
-  };
-};
-
-describe("mixin: debounce-mixin", function() {
-  it("initializes debounce-mixin", function() {
-    const {
-      usersService,
-      tasksService,
-      postsService,
-      authenticationService
-    } = mockApp();
-
-    [usersService, tasksService, postsService].forEach(service => {
-      assert.ok(service.debouncedStore, "service has debounceStore");
-      assert.strictEqual(typeof service.debouncedStore.add, "function", "service has 'add' function");
-    });
-
-    assert.strictEqual(authenticationService.debouncedStore, undefined, "authentication has no debounced Store");
-  });
-
-  it("only gets called once", async function() {
-    const {
-      usersService
-    } = mockApp();
-    let callCounter = 0;
-    for (let i = 0; i < 50; i++) {
-      usersService.debouncedStore.add(1, () => {
-        callCounter++;
-        return usersService.create({ id: i, test: true });
-      });
-    }
-    await new Promise(resolve => setTimeout(resolve, 400));
-    const items = await usersService.find({ query: {}, paginate: false });
-    assert.strictEqual(items.length, 1, "only has one item");
-    assert.strictEqual(items[0].id, 49, "called with last iteration");
-    assert.strictEqual(callCounter, 1, "only called once");
-    assert.deepStrictEqual(usersService.debouncedStore._queueById, {}, "queue is empty");
-    assert.deepStrictEqual(usersService.debouncedStore._isRunningById, {}, "nothing is running");
-  });
-
-  it("doesn't call instantly", async function() {
-    const {
-      usersService
-    } = mockApp();
-    let callCounter = 0;
-    for (let i = 0; i < 50; i++) {
-      usersService.debouncedStore.add(1, () => {
-        callCounter++;
-        return usersService.create({ id: i, test: true });
-      });
-    }
-    const items = await usersService.find({ query: {}, paginate: false });
-    assert.strictEqual(items.length, 0, "hasn't any items yet");
-    assert.strictEqual(callCounter, 0, "not called yet");
-  });
-
-  it("stores per id", async function() {
-    const {
-      usersService
-    } = mockApp();
-    const callCounter = {};
-    const times = 100;
-    for (let i = 0; i < times; i++) {
-      callCounter[i] = 0;
-      for (let j = 0; j < 50; j++) {
-        usersService.debouncedStore.add(i, () => {
-          callCounter[i]++;
-          return usersService.create({ id: i, test: true });
-        });
-      }
-    }
-    
-    await new Promise(resolve => setTimeout(resolve, 400));
-    const items = await usersService.find({ query: { $sort: { id: 1 } }, paginate: false });
-    assert.strictEqual(items.length, times, `has ${times} items`);
-    items.forEach((item, i) => {
-      assert.strictEqual(item.id, i, "continuous ids");
-      assert.strictEqual(callCounter[i], 1, "only called once");
-    });
-  });
-
-  it("waits per id", function(done) {
-    const {
-      usersService
-    } = mockApp();
-    const callCounter = {
-      1: 0,
-      2: 0
-    };
-    const times = 60;
-    usersService.debouncedStore.add(1, () => {
-      callCounter[1]++;
-      return usersService.create({ id: 1, test: true });
-    });
-    let counter = 0;
-    const started = performance.now();
-    const callTwo = () => {
-      if (counter > times) {
-        assert(performance.now() - started > 200, "enough time elapsed");
-        usersService
-          .find({ query: { $sort: { id: 1 } }, paginate: false })
-          .then(items => {
-            assert.strictEqual(items.length, 1, "has just one item yet");
-            assert.strictEqual(items[0].id, 1, "id is one");
-            const timeElapsed = performance.now() - started;
-            assert(timeElapsed > 200, "enough time elapsed");
-            assert(timeElapsed < 1000, "less than maxWait");
-            done();
-          });
-        
-        return; 
-      }
-      setTimeout(() => {
-        usersService.debouncedStore.add(2, () => {
-          callCounter[2]++;
-          return usersService.create({ id: 2, test: true });
-        });
-        counter++;
-        callTwo();
-      }, 5);
-    };
-    callTwo();
-  });
-
-  it("cancel works", async function() {
-    const {
-      usersService
-    } = mockApp();
-    let callCounter = 0;
-    for (let i = 0; i < 50; i++) {
-      usersService.debouncedStore.add(1, () => {
-        callCounter++;
-        return usersService.create({ id: i, test: true });
-      });
-    }
-    usersService.debouncedStore.cancel(1);
-    await new Promise(resolve => setTimeout(resolve, 400));
-    const items = await usersService.find({ query: {}, paginate: false });
-    assert.strictEqual(items.length, 0, "hasn't items");
-    assert.strictEqual(callCounter, 0, "not called once");
-  });
-});

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`);
-      });
-    });
-  });
-});