@fireproof/core-test 0.23.1 → 0.23.2

package/blockstore/interceptor-gateway.test.ts

@@ -1,259 +0,0 @@
-import { BuildURI, Result, URI } from "@adviser/cement";
-import { fireproof, SuperThis } from "@fireproof/core";
-import * as bs from "@fireproof/core-types-blockstore";
-import { describe, expect, it, vitest } from "vitest";
-import { PassThroughGateway, URIInterceptor } from "@fireproof/core-gateways-base";
-import { MemoryGateway } from "@fireproof/core-gateways-memory";
-import { registerStoreProtocol } from "@fireproof/core-blockstore";
-
-class TestInterceptor extends PassThroughGateway {
-  readonly fn = vitest.fn();
-
-  async buildUrl(ctx: bs.SerdeGatewayCtx, baseUrl: URI, key: string): Promise<Result<bs.SerdeGatewayBuildUrlReturn>> {
-    const ret = await super.buildUrl(ctx, baseUrl, key);
-    this.fn("buildUrl", ret);
-    return ret;
-  }
-
-  async start(ctx: bs.SerdeGatewayCtx, baseUrl: URI): Promise<Result<bs.SerdeGatewayStartReturn>> {
-    const ret = await super.start(ctx, baseUrl);
-    this.fn("start", ret);
-    return ret;
-  }
-  async close(ctx: bs.SerdeGatewayCtx, baseUrl: URI): Promise<Result<bs.SerdeGatewayCloseReturn>> {
-    const ret = await super.close(ctx, baseUrl);
-    this.fn("close", ret);
-    return ret;
-  }
-  async delete(ctx: bs.SerdeGatewayCtx, baseUrl: URI): Promise<Result<bs.SerdeGatewayDeleteReturn>> {
-    const ret = await super.delete(ctx, baseUrl);
-    this.fn("delete", ret);
-    return ret;
-  }
-  async destroy(ctx: bs.SerdeGatewayCtx, baseUrl: URI): Promise<Result<bs.SerdeGatewayDestroyReturn>> {
-    const ret = await super.destroy(ctx, baseUrl);
-    this.fn("destroy", ret);
-    return ret;
-  }
-  async put<T>(ctx: bs.SerdeGatewayCtx, url: URI, body: bs.FPEnvelope<T>): Promise<Result<bs.SerdeGatewayPutReturn<T>>> {
-    const ret = await super.put<T>(ctx, url, body);
-    this.fn("put", ret);
-    return ret;
-  }
-  async get<S>(ctx: bs.SerdeGatewayCtx, url: URI): Promise<Result<bs.SerdeGatewayGetReturn<S>>> {
-    const ret = await super.get<S>(ctx, url);
-    this.fn("get", ret);
-    return ret;
-  }
-  async subscribe(
-    ctx: bs.SerdeGatewayCtx,
-    url: URI,
-    callback: (meta: bs.FPEnvelopeMeta) => Promise<void>,
-  ): Promise<Result<bs.SerdeGatewaySubscribeReturn>> {
-    const ret = await super.subscribe(ctx, url, callback);
-    this.fn("subscribe", ret);
-    return ret;
-  }
-}
-
-export class URITrackGateway implements bs.Gateway {
-  readonly uris: Set<string>;
-  readonly memgw: MemoryGateway;
-
-  constructor(sthis: SuperThis, memorys: Map<string, Uint8Array>, uris: Set<string>) {
-    this.memgw = new MemoryGateway(sthis, memorys);
-    this.uris = uris;
-  }
-
-  uriAdd(uri: URI) {
-    if (!uri.getParam("itis")) {
-      throw new Error("itis not set");
-    }
-    if (this.uris.has(uri.toString())) {
-      throw new Error(`uri already added:${uri.toString()}`);
-    }
-    this.uris.add(uri.toString());
-  }
-
-  buildUrl(baseUrl: URI, key: string): Promise<Result<URI>> {
-    this.uriAdd(baseUrl);
-    return this.memgw.buildUrl(baseUrl, key);
-  }
-  start(baseUrl: URI): Promise<Result<URI>> {
-    this.uriAdd(baseUrl);
-    return this.memgw.start(baseUrl);
-  }
-  close(uri: URI): Promise<bs.VoidResult> {
-    this.uriAdd(uri);
-    return this.memgw.close(uri);
-  }
-  destroy(baseUrl: URI): Promise<bs.VoidResult> {
-    this.uriAdd(baseUrl);
-    return this.memgw.destroy(baseUrl);
-  }
-
-  put(url: URI, bytes: Uint8Array, sthis: SuperThis): Promise<bs.VoidResult> {
-    // console.log("put", url.getParam(PARAM.KEY), url.toString());
-    this.uriAdd(url);
-    return this.memgw.put(url.build().cleanParams("itis").URI(), bytes, sthis);
-  }
-
-  async get(url: URI, sthis: SuperThis): Promise<bs.GetResult> {
-    this.uriAdd(url);
-    const ret = await this.memgw.get(url.build().cleanParams("itis").URI(), sthis);
-    // if (ret.isErr()) {
-    //   console.log("get-err", url.getParam(PARAM.KEY), url.toString());
-    // }
-    return ret;
-  }
-  delete(url: URI): Promise<bs.VoidResult> {
-    this.uriAdd(url);
-    return this.memgw.delete(url);
-  }
-
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  subscribe(url: URI, callback: (meta: Uint8Array) => void, sthis: SuperThis): Promise<bs.UnsubscribeResult> {
-    this.uriAdd(url);
-    return Promise.resolve(
-      Result.Ok(() => {
-        /* noop */
-      }),
-    );
-  }
-
-  async getPlain(url: URI, key: string): Promise<Result<Uint8Array>> {
-    this.uriAdd(url);
-    return this.memgw.getPlain(url, key);
-  }
-}
-
-describe("InterceptorGateway", () => {
-  it("passthrough", async () => {
-    const gwi = new TestInterceptor();
-    const db = fireproof("interceptor-gateway", {
-      gatewayInterceptor: gwi,
-    });
-    expect(
-      await db.put({
-        _id: "foo",
-        foo: 4,
-      }),
-    );
-    expect(await db.get("foo")).toEqual({
-      _id: "foo",
-      foo: 4,
-    });
-    await db.close();
-    await db.destroy();
-    // await sleep(1000);
-    expect(gwi.fn.mock.calls.length).toBe(54);
-    // might be a stupid test
-    expect(gwi.fn.mock.calls.map((i) => i[0]).sort() /* not ok there are some operation */).toEqual(
-      [
-        "start",
-        "start",
-        "buildUrl",
-        "get",
-        "buildUrl",
-        "buildUrl",
-        "buildUrl",
-        "buildUrl",
-        "buildUrl",
-        "buildUrl",
-        "buildUrl",
-        "buildUrl",
-        "get",
-        "get",
-        "start",
-        "start",
-        "buildUrl",
-        "get",
-        "get",
-        "buildUrl",
-        "put",
-        "put",
-        "buildUrl",
-        "put",
-        "buildUrl",
-        "put",
-        "put",
-        "put",
-        "put",
-        "put",
-        "start",
-        "start",
-        "start",
-        "start",
-        "close",
-        "close",
-        "close",
-        "close",
-        "buildUrl",
-        "get",
-        "close",
-        "close",
-        "close",
-        "close",
-        "destroy",
-        "destroy",
-        "destroy",
-        "destroy",
-        "destroy",
-        "destroy",
-        "destroy",
-        "destroy",
-        "subscribe",
-        "subscribe",
-      ].sort() /* not ok there are some operation */,
-    );
-  });
-
-  it("use the uri-interceptor", async () => {
-    let callCount = 0;
-    const gwUris = new Set<string>();
-    const unreg = registerStoreProtocol({
-      protocol: "uriTest:",
-      isDefault: false,
-      defaultURI: () => {
-        return BuildURI.from("uriTest://").pathname("ram").URI();
-      },
-      gateway: async (sthis) => {
-        return new URITrackGateway(sthis, new Map<string, Uint8Array>(), gwUris);
-      },
-    });
-    const db = fireproof("interceptor-gateway", {
-      storeUrls: {
-        base: "uriTest://inspector-gateway",
-      },
-      gatewayInterceptor: URIInterceptor.withMapper(async (uri: URI) =>
-        uri
-          .build()
-          .setParam("itis", "" + ++callCount)
-          .URI(),
-      ),
-    });
-    await Promise.all(
-      Array(5)
-        .fill(0)
-        .map((_, i) => db.put({ _id: "foo" + i, foo: i })),
-    );
-    expect((await db.allDocs<{ foo: number }>()).rows.map((i) => i.value.foo)).toEqual(
-      Array(5)
-        .fill(0)
-        .map((_, i) => i),
-    );
-    await db.close();
-    expect(callCount).toBe(gwUris.size);
-    expect(
-      Array.from(gwUris)
-        .map((i) => URI.from(i).getParam("itis"))
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        .sort((a, b) => +a! - +b!),
-    ).toEqual(
-      Array(gwUris.size)
-        .fill(1)
-        .map((_, i) => "" + (i + 1)),
-    );
-    unreg();
-  });
-});

package/blockstore/keyed-crypto-indexeddb-file.test.ts

@@ -1,134 +0,0 @@
-import { runtimeFn, toCryptoRuntime, URI } from "@adviser/cement";
-import { base58btc } from "multiformats/bases/base58";
-import { mockLoader, mockSuperThis } from "../helpers.js";
-import { ensureSuperThis } from "@fireproof/core-runtime";
-import { V2KeysItem, PARAM } from "@fireproof/core-types-base";
-import { describe, beforeAll, it, expect, beforeEach } from "vitest";
-import { coerceMaterial, getKeyBag, toKeyWithFingerPrint } from "@fireproof/core-keybag";
-import { KeyBagProviderIndexedDB } from "@fireproof/core-gateways-indexeddb";
-import { KeyBagProviderFile } from "@fireproof/core-gateways-file";
-import { KeyWithFingerPrint, Loadable } from "@fireproof/core-types-blockstore";
-import { createAttachedStores } from "@fireproof/core-blockstore";
-
-describe("KeyBag indexeddb and file", () => {
-  let url: URI;
-  const sthis = mockSuperThis();
-  beforeAll(async () => {
-    await sthis.start();
-    if (runtimeFn().isBrowser) {
-      url = URI.from("indexeddb://fp-keybag");
-    } else {
-      url = URI.merge(`file://./dist/tests/key.bag`, sthis.env.get("FP_KEYBAG_URL"));
-    }
-  });
-  it("default-path", async () => {
-    const old = sthis.env.get("FP_KEYBAG_URL");
-    sthis.env.delete("FP_KEYBAG_URL");
-    const kb = await getKeyBag(sthis);
-    if (runtimeFn().isBrowser) {
-      expect(kb.rt.url.toString()).toBe(`indexeddb://fp-keybag`);
-    } else {
-      expect(kb.rt.url.toString()).toBe(`file://${sthis.env.get("HOME")}/.fireproof/keybag`);
-    }
-    sthis.env.set("FP_KEYBAG_URL", old);
-  });
-  it("from env", async () => {
-    const old = sthis.env.get("FP_KEYBAG_URL");
-    sthis.env.set("FP_KEYBAG_URL", url.toString());
-    const kb = await getKeyBag(sthis);
-    expect(kb.rt.url.toString()).toBe(url.toString());
-    sthis.env.set("FP_KEYBAG_URL", old);
-  });
-  it("simple add", async () => {
-    const kb = await getKeyBag(sthis, {
-      url: url.toString(),
-      crypto: toCryptoRuntime({
-        randomBytes: (size) => new Uint8Array(size).map((_, i) => i),
-      }),
-    });
-    const name = "setkey" + Math.random();
-    expect((await kb.getNamedKey(name, true)).isErr()).toBeTruthy();
-
-    const key = base58btc.encode(kb.rt.crypto.randomBytes(kb.rt.keyLength));
-    const res = await kb.getNamedKey(name, false, key);
-    expect(res.isOk()).toBeTruthy();
-    expect((await kb.getNamedKey(name, true)).Ok()).toEqual(res.Ok());
-
-    const name2 = "implicit" + Math.random();
-    const created = await kb.getNamedKey(name2);
-    expect(created.isOk()).toBeTruthy();
-
-    expect((await kb.getNamedKey(name2)).Ok()).toEqual(created.Ok());
-
-    let diskBag: V2KeysItem;
-    let diskBag2: V2KeysItem;
-    const provider = await kb.rt.getBagProvider();
-    if (runtimeFn().isBrowser) {
-      const p = provider as KeyBagProviderIndexedDB;
-      diskBag = await p._prepare().then((db) => db.get("bag", name));
-      diskBag2 = await p._prepare().then((db) => db.get("bag", name2));
-    } else {
-      const p = provider as KeyBagProviderFile;
-      const { sysFS } = await p._prepare(name);
-
-      diskBag = await sysFS.readfile((await p._prepare(name)).fName).then((data) => {
-        return JSON.parse(sthis.txt.decode(data)) as V2KeysItem;
-      });
-      diskBag2 = await sysFS.readfile((await p._prepare(name2)).fName).then((data) => {
-        return JSON.parse(sthis.txt.decode(data)) as V2KeysItem;
-      });
-    }
-    expect((await toKeyWithFingerPrint(kb, coerceMaterial(kb, Object.values(diskBag.keys)[0].key), true)).Ok().fingerPrint).toEqual(
-      (await res.Ok().get())?.fingerPrint,
-    );
-    expect(
-      (await toKeyWithFingerPrint(kb, coerceMaterial(kb, Object.values(diskBag2.keys)[0].key), true)).Ok().fingerPrint,
-    ).toEqual((await created.Ok().get())?.fingerPrint);
-    const algo = {
-      name: "AES-GCM",
-      iv: kb.rt.crypto.randomBytes(12),
-      tagLength: 128,
-    };
-    const data = kb.rt.crypto.randomBytes(122);
-    const rkc = (await res.Ok().get()) as KeyWithFingerPrint;
-    const ckc = (await created.Ok().get()) as KeyWithFingerPrint;
-    expect(await kb.rt.crypto.encrypt(algo, rkc.key, data)).toEqual(await kb.rt.crypto.encrypt(algo, ckc.key, data));
-    expect(await kb.rt.crypto.encrypt(algo, await kb.subtleKey(Object.values(diskBag.keys)[0].key), data)).toEqual(
-      await kb.rt.crypto.encrypt(algo, ckc.key, data),
-    );
-    expect(await kb.rt.crypto.encrypt(algo, await kb.subtleKey(Object.values(diskBag2.keys)[0].key), data)).toEqual(
-      await kb.rt.crypto.encrypt(algo, ckc.key, data),
-    );
-  });
-});
-
-describe("KeyedCryptoStore", () => {
-  let loader: Loadable;
-  // let logger: Logger;
-  let baseUrl: URI;
-  const sthis = ensureSuperThis();
-  beforeEach(async () => {
-    await sthis.start();
-    // logger = MockLogger().logger;
-    // let kbUrl: URI;
-    if (runtimeFn().isBrowser) {
-      // kbUrl = URI.from("indexeddb://fp-keybag");
-      baseUrl = URI.from("indexeddb://fp-keyed-crypto-store");
-    } else {
-      // kbUrl = URI.merge(`file://./dist/tests/key.bag`, sthis.env.get("FP_KEYBAG_URL"));
-      baseUrl = URI.merge("file://./dist/tests/keyed-crypto-store", sthis.env.get("FP_STORAGE_URL"));
-    }
-    baseUrl = baseUrl.build().defParam(PARAM.NAME, "test").URI();
-    loader = mockLoader(sthis);
-  });
-  it("no crypto", async () => {
-    const url = baseUrl.build().setParam(PARAM.STORE_KEY, "insecure").URI();
-    for (const pstore of (await createAttachedStores(url, loader, "insecure")).stores.baseStores) {
-      const store = await pstore;
-      // await store.start();
-      const kc = await store.keyedCrypto();
-      expect(kc.constructor.name).toBe("noCrypto");
-      // expect(kc.isEncrypting).toBe(false);
-    }
-  });
-});