@fireproof/core-test 0.22.0-keybag → 0.23.1-dev-issue-1057

package/blockstore/standalone.test.ts

@@ -1,156 +0,0 @@
-import { BuildURI, runtimeFn, URI } from "@adviser/cement";
-import { Link } from "multiformats";
-import { stripper } from "@adviser/cement/utils";
-import pLimit from "@fireproof/vendor/p-limit";
-import { ensureSuperThis, sleep } from "@fireproof/core-runtime";
-import { CRDT, PARAM, LedgerOpts } from "@fireproof/core-types-base";
-import { describe, it, vi, expect, beforeEach, afterEach } from "vitest";
-import { Loader } from "@fireproof/core-blockstore";
-import { CRDTImpl, fireproof } from "@fireproof/core-base";
-
-describe("standalone", () => {
-  const sthis = ensureSuperThis();
-
-  describe("howto-loader", () => {
-    // beforeAll(async () => {
-    //   const db = fireproof("howto-loader", {
-    //     storeUrls: {
-    //       base: "file://dist/how-to-loader?store-key=insecure",
-    //     },
-    //   });
-    //   for (let cid = 0; cid < 1; cid++) {
-    //     const blk = new Array(3)
-    //       .fill(0)
-    //       .map((_, peer) => ({ _id: `test-${cid}:peer-${peer}`, value: { cid: `test-${cid}`, peer: `peer-${peer}` } }));
-    //     await db.bulk(blk);
-    //   }
-    //   // await db.compact()
-    //   await db.close();
-    // });
-
-    it("understand the writer", async () => {
-      const db = fireproof("howto-writer", {
-        storeUrls: {
-          base: "memory://how-to-writer",
-        },
-      });
-      await db.put({ _id: "test-1", value: { cid: "test-1", peer: "peer-1" } });
-      await db.close();
-    });
-
-    it.skip("understand loader", async () => {
-      const db = fireproof("howto-loader", {
-        storeUrls: {
-          base: "file://dist/how-to-loader?store-key=insecure",
-        },
-      });
-      const fn = vi.fn();
-      const loader = db.ledger.crdt.blockstore.loader as Loader;
-      loader.cidCache.onSet(fn);
-      expect(fn).toHaveBeenCalledTimes(0);
-      await db.ready();
-      expect(
-        loader.cidCache.values().map((i) => {
-          const v = i.value.Ok();
-          return {
-            type: v.item.type,
-            cid: v.cid,
-            value: stripper(/(type|cid)/, v.item),
-          };
-        }),
-      ).toEqual([]);
-      // let last = 0
-      // for (let i = 0; i < 100; i++) {
-      //   if (last !== fn.mock.calls.length) {
-      //     console.log("fn", i, fn.mock.calls.length);
-      //     last = fn.mock.calls.length
-      //   }
-      //   await sleep(10);
-      // }
-      const ret = await db.allDocs();
-      expect(ret.rows.length).toBe(100);
-      expect(fn).toHaveBeenCalledTimes(109393);
-      await db.close();
-    });
-  });
-
-  describe("test-plimit", () => {
-    it("should work with plimit", async () => {
-      const limiter = pLimit(2);
-      let concurrent = 0;
-      const ret = await Promise.all(
-        Array(10)
-          .fill(0)
-          .map((_, i) => {
-            return limiter(async () => {
-              concurrent++;
-              expect(concurrent).toBeLessThanOrEqual(2);
-              await sleep(100);
-              concurrent--;
-              return i;
-            });
-          }),
-      );
-      expect(ret).toEqual(Array.from(Array(10).keys()));
-    });
-  });
-
-  describe.skip("crdt-stack", () => {
-    let crdt: CRDT;
-    beforeEach(async () => {
-      let uri: URI;
-      switch (true) {
-        case runtimeFn().isBrowser:
-          uri = BuildURI.from("indexeddb://standalone-peer-log").setParam(PARAM.NAME, "peer-log").URI();
-          break;
-        default:
-          uri = BuildURI.from("file://dist/standalone")
-            .setParam(PARAM.NAME, "peer-log")
-            .setParam(PARAM.STORE_KEY, "insecure")
-            .URI();
-          break;
-      }
-      // console.log("uri", uri.toString());
-      crdt = new CRDTImpl(sthis, {
-        name: "peer-log",
-        writeQueue: { chunkSize: 32 },
-        storeUrls: {
-          data: {
-            meta: uri.build().setParam(PARAM.STORE, "meta").setParam(PARAM.STORE_KEY, "insecure").URI(),
-            car: uri.build().setParam(PARAM.STORE, "car").setParam(PARAM.STORE_KEY, "insecure").URI(),
-            file: uri.build().setParam(PARAM.STORE, "file").setParam(PARAM.STORE_KEY, "insecure").URI(),
-            wal: uri.build().setParam(PARAM.STORE, "wal").setParam(PARAM.STORE_KEY, "insecure").URI(),
-          },
-        },
-      } as LedgerOpts);
-      await crdt.ready();
-    });
-    afterEach(async () => {
-      await crdt.close();
-    });
-
-    it.each(new Array(10).fill(0).map((_, i) => ({ cid: i })))("write:$cid", async ({ cid }) => {
-      const peers = new Array(10).fill(0).map((_, peer) => {
-        return { id: `test-${cid}:peer-${peer}`, value: { cid: `test-${cid}`, peer: `peer-${peer}` } };
-      });
-      await crdt.bulk(peers);
-    });
-    it("read", async () => {
-      for (let cid = 0; cid < 10; cid++) {
-        for (let peer = 0; peer < 10; peer++) {
-          const id = `test-${cid}:peer-${peer}`;
-          const res = (await crdt.get(id)) as unknown as { cid: Link; doc: { cid: string; peer: string } };
-          expect(res.doc).toEqual({ cid: `test-${cid}`, peer: `peer-${peer}` });
-        }
-      }
-    });
-    // for (let cid = 0; cid < 10; cid++) {
-    //   const gte = `test-${cid}`;
-    //   const ret = [];
-    //   for await (const [key, link] of entries(blk, root, { gte })) {
-    //     ret.push([key, link]);
-    //   }
-    //   expect(ret.length).toEqual(10);
-    // }
-  });
-});

package/blockstore/store.test.ts

@@ -1,199 +0,0 @@
-import { CID } from "multiformats";
-import { Result } from "@adviser/cement";
-import { mockLoader, noopUrl } from "../helpers.js";
-import { ensureSuperThis } from "@fireproof/core-runtime";
-import { PARAM, NotFoundError, DbMeta } from "@fireproof/core-types-base";
-import { describe, afterEach, beforeEach, it, expect } from "vitest";
-import { createAttachedStores } from "@fireproof/core-blockstore";
-import { CarStore, Loadable, AnyBlock, MetaStore, FPEnvelopeMeta } from "@fireproof/core-types-blockstore";
-import { fpDeserialize } from "@fireproof/core-gateways-base";
-
-// function runtime(sthis: SuperThis) {
-//   return toStoreRuntime(sthis);
-// }
-
-// async function mockLoader(sthis: SuperThis, name?: string): Promise<bs.StoreFactoryItem> {
-//   const url = noopUrl(name);
-//   return {
-//     // sthis,
-//     url: url,
-//     loader:
-//   };
-// }
-
-describe("CarStore", function () {
-  let store: CarStore;
-  const sthis = ensureSuperThis();
-
-  let loader: Loadable;
-
-  afterEach(async () => {
-    await store.close();
-    await store.destroy();
-  });
-
-  beforeEach(async () => {
-    loader = mockLoader(sthis);
-    await sthis.start();
-    const at = await createAttachedStores(noopUrl("test"), loader);
-    store = at.stores.car;
-    await store.start(at.stores);
-  });
-
-  it("should have a name", function () {
-    expect(store.url().getParam(PARAM.NAME)).toEqual("test");
-  });
-
-  it("should save a car", async () => {
-    const car: AnyBlock = {
-      cid: "cidKey" as unknown as CID,
-      bytes: new Uint8Array([55, 56, 57]),
-    };
-    await store.save(car);
-    const data = (await store.realGateway.getPlain({ loader }, store.url(), car.cid.toString())).Ok();
-    expect(sthis.txt.decode(data)).toEqual(sthis.txt.decode(car.bytes));
-  });
-});
-
-describe("CarStore with a saved car", function () {
-  let store: CarStore;
-  let car: AnyBlock;
-  let loader: Loadable;
-
-  const sthis = ensureSuperThis();
-
-  afterEach(async () => {
-    await store.close();
-    await store.destroy();
-  });
-
-  beforeEach(async () => {
-    loader = mockLoader(sthis);
-    await sthis.start();
-
-    const at = await createAttachedStores(noopUrl("test2"), loader);
-    store = at.stores.car;
-    await store.start(at.stores);
-    car = {
-      cid: "cid" as unknown as CID,
-      bytes: new Uint8Array([55, 56, 57, 80]),
-    };
-    await store.save(car);
-  });
-
-  it("should have a car", async () => {
-    const data = (await store.realGateway.getPlain({ loader }, store.url(), car.cid.toString())).Ok();
-    expect(sthis.txt.decode(data)).toEqual(sthis.txt.decode(car.bytes));
-  });
-
-  it("should load a car", async () => {
-    const loaded = await store.load(car.cid);
-    expect(loaded.cid).toEqual(car.cid);
-    expect(loaded.bytes.constructor.name).toEqual("Uint8Array");
-    expect(loaded.bytes.toString()).toEqual(car.bytes.toString());
-  });
-
-  it("should remove a car", async () => {
-    await store.remove(car.cid);
-    const { e: error } = (await store.load(car.cid).catch((e: Error) => ({ e }))) as { e: NotFoundError };
-    expect(error).toBeTruthy();
-  });
-});
-
-describe("MetaStore", function () {
-  let store: MetaStore;
-  const sthis = ensureSuperThis();
-  let loader: Loadable;
-
-  afterEach(async () => {
-    await store.close();
-    await store.destroy();
-  });
-
-  beforeEach(async () => {
-    loader = mockLoader(sthis);
-    await sthis.start();
-    const at = await createAttachedStores(noopUrl("test"), loader);
-    store = at.stores.meta;
-    await store.start(at.stores);
-  });
-
-  it("should have a name", function () {
-    expect(store.url().getParam(PARAM.NAME)).toEqual("test");
-  });
-
-  it("should save a header", async () => {
-    const cid = CID.parse("bafybeia4luuns6dgymy5kau5rm7r4qzrrzg6cglpzpogussprpy42cmcn4");
-    const h: DbMeta = {
-      cars: [cid],
-      // key: undefined,
-    };
-    await store.save(h);
-    const file = await store.realGateway.getPlain({ loader }, store.url(), "main");
-    const blockMeta = (await fpDeserialize(sthis, store.url(), file)) as Result<FPEnvelopeMeta>;
-    expect(blockMeta.Ok()).toBeTruthy();
-    expect(blockMeta.Ok().payload.length).toEqual(1);
-    const decodedHeader = blockMeta.Ok().payload[0].dbMeta;
-    expect(decodedHeader).toBeTruthy();
-    expect(decodedHeader.cars).toBeTruthy();
-    expect(decodedHeader.cars[0].toString()).toEqual(cid.toString());
-  });
-});
-
-describe("MetaStore with a saved header", function () {
-  let store: MetaStore;
-  let cid: CID;
-  const sthis = ensureSuperThis();
-  let loader: Loadable;
-
-  afterEach(async () => {
-    await store.close();
-    await store.destroy();
-  });
-
-  beforeEach(async () => {
-    loader = mockLoader(sthis);
-    await sthis.start();
-    const at = await createAttachedStores(noopUrl("test3-meta"), loader);
-    store = at.stores.meta;
-    await store.start(at.stores);
-    cid = CID.parse("bafybeia4luuns6dgymy5kau5rm7r4qzrrzg6cglpzpogussprpy42cmcn4");
-    await store.save({ cars: [cid] /*, key: undefined */ });
-  });
-
-  // it("should load", async () =>{
-  //   expect(onload).toBeTruthy();
-  //   expect(onload?.length).toEqual(1);
-  //   expect(onload?.[0].cars.toString()).toEqual(cid.toString());
-  // });
-
-  it("should have a header", async () => {
-    const bytes = await store.realGateway.getPlain({ loader }, store.url(), "main");
-    const data = sthis.txt.decode(bytes.Ok());
-    expect(data).toMatch(/parents/);
-    const header = JSON.parse(data)[0];
-    expect(header).toBeDefined();
-    expect(header.parents).toBeDefined();
-    // const [blockMeta] = await store.handleByteHeads(bytes);
-
-    const blockMeta = (await fpDeserialize(sthis, store.url(), bytes)) as Result<FPEnvelopeMeta>;
-    expect(blockMeta.Ok()).toBeTruthy();
-    expect(blockMeta.Ok().payload.length).toEqual(1);
-    const decodedHeader = blockMeta.Ok().payload[0].dbMeta;
-    expect(decodedHeader).toBeDefined();
-    expect(decodedHeader.cars).toBeDefined();
-    expect(decodedHeader.cars[0].toString()).toEqual(cid.toString());
-  });
-
-  it("should load a header", async () => {
-    const metaStream = store.stream().getReader();
-    while (true) {
-      const { done, value: cars } = await metaStream.read();
-      if (done) break;
-      // expect(loaded).toBeTruthy();
-      expect(cars).toBeTruthy();
-      expect(cars.map((i) => i.cars.map((i) => i.toString())).flat(2)).toEqual([cid.toString()]);
-      break;
-    }
-  });
-});

package/blockstore/transaction.test.ts

@@ -1,132 +0,0 @@
-import { CID } from "multiformats";
-import { simpleBlockOpts } from "../helpers.js";
-import { to_uint8 } from "@adviser/cement";
-import { anyBlock2FPBlock, BaseBlockstoreImpl, CarTransactionImpl, EncryptedBlockstore } from "@fireproof/core-blockstore";
-import { ensureSuperThis } from "@fireproof/core-runtime";
-import { BaseBlockstore, CarTransaction } from "@fireproof/core-types-base";
-import { describe, beforeEach, it, expect, assert } from "vitest";
-import { AnyAnyLink, AnyBlock, AnyLink } from "@fireproof/core-types-blockstore";
-
-describe("Fresh TransactionBlockstore", function () {
-  let blocks: BaseBlockstore;
-  const sthis = ensureSuperThis();
-  beforeEach(async () => {
-    blocks = new BaseBlockstoreImpl(simpleBlockOpts(sthis));
-    await blocks.ready();
-  });
-  // it("should not have a name", function () {
-  //   expect(blocks.name).toBeFalsy();
-  // });
-  // it("should not have a loader", function () {
-  //   expect(blocks.loader).toBeFalsy();
-  // });
-  it("should not put", async () => {
-    const value = sthis.txt.encode("value");
-    const e = await blocks.put(await anyBlock2FPBlock({ cid: "key" as unknown as AnyLink, bytes: value })).catch((e) => e);
-    expect(e.message).toMatch(/transaction/g);
-  });
-  it("should yield a transaction", async () => {
-    const txR = await blocks.transaction(async (tblocks) => {
-      expect(tblocks).toBeTruthy();
-      expect(tblocks instanceof CarTransactionImpl).toBeTruthy();
-      return { head: [] };
-    });
-    expect(txR).toBeTruthy();
-    expect(txR.t).toBeTruthy();
-    expect(txR.meta).toEqual({ head: [] });
-  });
-});
-
-describe("TransactionBlockstore with name", function () {
-  let blocks: EncryptedBlockstore;
-  const sthis = ensureSuperThis();
-  beforeEach(async () => {
-    blocks = new EncryptedBlockstore(sthis, simpleBlockOpts(sthis));
-    await blocks.ready();
-  });
-  // it("should have a name", function () {
-  //   expect(blocks.name).toEqual("test");
-  // });
-  it("should have a loader", function () {
-    expect(blocks.loader).toBeTruthy();
-  });
-  it("should get from loader", async () => {
-    const bytes = sthis.txt.encode("bytes");
-    expect(blocks.loader).toBeTruthy();
-    blocks.loader.getBlock = async (cid) => {
-      return anyBlock2FPBlock({ cid, bytes });
-    };
-    const value = await blocks.get("key" as unknown as AnyAnyLink);
-    expect(value).toEqual({ cid: "key" as unknown as AnyAnyLink, bytes });
-  });
-});
-
-describe("A transaction", function () {
-  let tblocks: CarTransaction;
-  let blocks: EncryptedBlockstore;
-  const sthis = ensureSuperThis();
-  beforeEach(async () => {
-    blocks = new EncryptedBlockstore(sthis, simpleBlockOpts(sthis, "test"));
-    tblocks = new CarTransactionImpl(blocks);
-    blocks.transactions.add(tblocks);
-  });
-  it("should put and get", async () => {
-    const cid = CID.parse("bafybeia4luuns6dgymy5kau5rm7r4qzrrzg6cglpzpogussprpy42cmcn4");
-    const bytes = sthis.txt.encode("bytes");
-    await tblocks.put(await anyBlock2FPBlock({ cid, bytes }));
-    expect(blocks.transactions.has(tblocks)).toBeTruthy();
-    const got = await tblocks.get(cid);
-    assert(got, "missing block");
-    expect(got.cid).toEqual(cid);
-    expect(got.bytes).toEqual(bytes);
-  });
-});
-
-// function asUInt8Array(str: string, sthis: SuperThis) {
-//   return sthis.txt.encode(str);
-// }
-
-describe("TransactionBlockstore with a completed transaction", function () {
-  let blocks: BaseBlockstore;
-  let cid: CID;
-  let cid2: CID;
-  const sthis = ensureSuperThis();
-
-  beforeEach(async () => {
-    cid = CID.parse("bafybeia4luuns6dgymy5kau5rm7r4qzrrzg6cglpzpogussprpy42cmcn4");
-    cid2 = CID.parse("bafybeibgouhn5ktecpjuovt52zamzvm4dlve5ak7x6d5smms3itkhplnhm");
-
-    blocks = new BaseBlockstoreImpl(simpleBlockOpts(sthis));
-    await blocks.transaction(async (tblocks) => {
-      await tblocks.put(await anyBlock2FPBlock({ cid, bytes: to_uint8("value") }));
-      await tblocks.put(await anyBlock2FPBlock({ cid, bytes: to_uint8("value") }));
-      return { head: [] };
-    });
-    await blocks.transaction(async (tblocks) => {
-      await tblocks.put(await anyBlock2FPBlock({ cid, bytes: to_uint8("value") }));
-      await tblocks.put(await anyBlock2FPBlock({ cid: cid2, bytes: to_uint8("value2") }));
-      return { head: [] };
-    });
-  });
-  it("should have transactions", async () => {
-    const ts = blocks.transactions;
-    expect(ts.size).toEqual(2);
-  });
-  it("should get", async () => {
-    const value = (await blocks.get(cid)) as AnyBlock;
-    expect(value.cid).toEqual(cid);
-    expect(value.bytes.toString()).toEqual(to_uint8("value").toString());
-
-    const value2 = (await blocks.get(cid2)) as AnyBlock;
-    expect(value2.bytes.toString()).toEqual(to_uint8("value2").toString());
-  });
-  it("should yield entries", async () => {
-    const blz = [];
-    for await (const blk of blocks.entries()) {
-      blz.push(blk);
-    }
-    expect(blz.length).toEqual(2);
-  });
-});
-
-// test compact