bentocache/build/src/test_suite.js

Multi-tier cache module for Node.js. Redis, Upstash, CloudfareKV, File, in-memory and others drivers

// tests/helpers/driver_test_suite.ts
import { sleep } from "@julr/utils/misc";
function registerCacheDriverTestSuite(options) {
  const { test, group } = options;
  let cache;
  group.setup(async () => {
    cache = options.createDriver();
    return () => cache.disconnect();
  });
  group.tap((t) => t.disableTimeout());
  group.each.teardown(async () => {
    await cache.clear();
  });
  options.configureGroup?.(group);
  test("get() returns undefined when key does not exists", async ({ assert }) => {
    assert.deepEqual(await cache.get("key"), void 0);
  });
  test("get() returns value", async ({ assert }) => {
    await cache.set("key", "value");
    assert.deepEqual(await cache.get("key"), "value");
  });
  test("set() store a value", async ({ assert }) => {
    await cache.set("key", "value");
    assert.deepEqual(await cache.get("key"), "value");
  });
  test("set() store a value with expiration", async ({ assert }) => {
    await cache.delete("key");
    await cache.set("key", "value", 1500);
    assert.deepEqual(await cache.get("key"), "value");
    await sleep(2500);
    assert.deepEqual(await cache.get("key"), void 0);
  });
  test("set() returns true when value is set", async ({ assert }) => {
    const result = await cache.set("key", "value");
    assert.isTrue(result);
  });
  test("clear() remove all keys", async ({ assert }) => {
    await cache.set("key1", "value1");
    await cache.set("key2", "value2", 6e4);
    await cache.clear();
    assert.deepEqual(await cache.get("key1"), void 0);
    assert.deepEqual(await cache.get("key2"), void 0);
  });
  test("clear() remove only keys with prefix", async ({ assert, cleanup }) => {
    const cache2 = options.createDriver({ prefix: "prefix" });
    cleanup(async () => {
      await cache2.clear();
      await cache2.disconnect();
    });
    await cache2.set("key1", "value1");
    await cache.clear();
    assert.deepEqual(await cache2.get("key1"), "value1");
  });
  test("delete() removes a key", async ({ assert }) => {
    await cache.set("key1", "value1");
    await cache.delete("key1");
    assert.deepEqual(await cache.get("key1"), void 0);
  });
  test("deleteMany() removes many keys", async ({ assert }) => {
    await cache.set("key1", "value1");
    await cache.set("key2", "value2");
    await cache.deleteMany(["key1", "key2"]);
    assert.deepEqual(await cache.get("key1"), void 0);
    assert.deepEqual(await cache.get("key2"), void 0);
  });
  test("deleteMany() return true when no keys are provided", async ({ assert }) => {
    const result = await cache.deleteMany([]);
    assert.isTrue(result);
  });
  test("delete() returns true when key is removed", async ({ assert }) => {
    await cache.set("key1", "value1");
    const result = await cache.delete("key1");
    assert.isTrue(result);
  });
  test("delete() returns false when key does not exists", async ({ assert }) => {
    const result = await cache.delete("key1");
    assert.isFalse(result);
  });
  test("pull() returns value and removes it", async ({ assert }) => {
    await cache.set("key1", "foo");
    const value = await cache.pull("key1");
    assert.deepEqual(value, "foo");
  });
  test("pull() returns undefined when key does not exists", async ({ assert }) => {
    const value = await cache.pull("key1");
    assert.isUndefined(value);
  });
  test("namespace() returns a new instance", async ({ assert }) => {
    const cache2 = cache.namespace("foo");
    assert.notEqual(cache, cache2);
  });
  test("set() value on namespace", async ({ assert }) => {
    const fooNamespace = cache.namespace("foo");
    await fooNamespace.set("key1", "value1");
    assert.deepEqual(await cache.get("key1"), void 0);
    assert.deepEqual(await fooNamespace.get("key1"), "value1");
  });
  test("get() value from namespace", async ({ assert }) => {
    const fooNamespace = cache.namespace("foo");
    await cache.set("key1", "value1");
    await fooNamespace.set("key1", "value2");
    assert.deepEqual(await cache.get("key1"), "value1");
    assert.deepEqual(await fooNamespace.get("key1"), "value2");
  });
  test("clear() should only clear namespaces items", async ({ assert }) => {
    const fooNamespace = cache.namespace("foo");
    await cache.set("key1", "value1");
    await fooNamespace.set("key2", "value2");
    await fooNamespace.clear();
    assert.deepEqual(await cache.get("key1"), "value1");
    assert.isUndefined(await fooNamespace.get("key2"));
  });
  test("clear() on root cache should clear namespaces items too", async ({ assert }) => {
    const fooNamespace = cache.namespace("foo");
    await cache.set("key1", "value1");
    await fooNamespace.set("key2", "value2");
    await cache.clear();
    assert.isUndefined(await cache.get("key1"));
    assert.isUndefined(await fooNamespace.get("key2"));
  });
  test("should be able to access namespaced key from root if prefixed", async ({ assert }) => {
    const users = cache.namespace("users");
    const usersPosts = users.namespace("posts");
    await users.set("key1", "value1");
    await usersPosts.set("key1", "value2");
    const r1 = await cache.get("users:key1");
    const r2 = await usersPosts.get("key1");
    const r3 = await users.get("posts:key1");
    const r4 = await cache.get("users:posts:key1");
    assert.deepEqual(r1, "value1");
    assert.deepEqual(r2, "value2");
    assert.deepEqual(r3, "value2");
    assert.deepEqual(r4, "value2");
  });
  test("namespace clear() should only clear prefixed keys", async ({ assert }) => {
    const users = cache.namespace("users");
    await cache.set("usersAbc", "value1");
    await users.set("abc", "value2");
    await users.clear();
    const r1 = await cache.get("usersAbc");
    const r2 = await users.get("abc");
    assert.deepEqual(r1, "value1");
    assert.isUndefined(r2);
  });
}
export {
  registerCacheDriverTestSuite
};
//# sourceMappingURL=test_suite.js.map