@fireproof/core 0.20.0-dev-preview-40 → 0.20.0-dev-preview-50

package/tests/fireproof/crdt.test.ts

@@ -6,11 +6,11 @@ import { Index, index } from "@fireproof/core";
 describe("Fresh crdt", function () {
   let crdt: CRDT;
   const sthis = ensureSuperThis();
-  afterEach(async function () {
+  afterEach(async () => {
     await crdt.close();
     await crdt.destroy();
   });
-  beforeEach(async function () {
+  beforeEach(async () => {
     await sthis.start();
     const dbOpts: LedgerOpts = {
       name: "test-crdt",
@@ -20,17 +20,18 @@ describe("Fresh crdt", function () {
       storeEnDe: bs.ensureStoreEnDeFile({}),
     };
     crdt = new CRDTImpl(sthis, dbOpts);
+    await crdt.ready();
   });
-  it("should have an empty head", async function () {
+  it("should have an empty head", async () => {
     const head = crdt.clock.head;
     expect(head.length).toBe(0);
   });
-  it("should accept put and return results", async function () {
+  it("should accept put and return results", async () => {
     const didPut = await crdt.bulk([{ id: "hello", value: { hello: "world" } }]);
     const head = didPut.head;
     expect(head.length).toBe(1);
   });
-  it("should accept multi-put and return results", async function () {
+  it("should accept multi-put and return results", async () => {
     const didPut = await crdt.bulk([
       { id: "ace", value: { points: 11 } },
       { id: "king", value: { points: 10 } },
@@ -49,12 +50,12 @@ describe("CRDT with one record", function () {
   let firstPut: CRDTMeta;
   const sthis = ensureSuperThis();
 
-  afterEach(async function () {
+  afterEach(async () => {
     await crdt.close();
     await crdt.destroy();
   });
 
-  beforeEach(async function () {
+  beforeEach(async () => {
     await sthis.start();
     const dbOpts: LedgerOpts = {
       name: "test-crdt",
@@ -66,32 +67,32 @@ describe("CRDT with one record", function () {
     crdt = new CRDTImpl(sthis, dbOpts);
     firstPut = await crdt.bulk([{ id: "hello", value: { hello: "world" } }]);
   });
-  it("should have a one-element head", async function () {
+  it("should have a one-element head", async () => {
     const head = crdt.clock.head;
     expect(head.length).toBe(1);
   });
-  it("should return the head", async function () {
+  it("should return the head", async () => {
     expect(firstPut.head.length).toBe(1);
   });
-  it("return the record on get", async function () {
+  it("return the record on get", async () => {
     const got = (await crdt.get("hello")) as DocValue<CRDTTestType>;
     expect(got).toBeTruthy();
     expect(got.doc.hello).toBe("world");
   });
-  it("should accept another put and return results", async function () {
+  it("should accept another put and return results", async () => {
     const didPut = await crdt.bulk([{ id: "nice", value: { nice: "data" } }]);
     const head = didPut.head;
     expect(head.length).toBe(1);
     const { doc } = (await crdt.get("nice")) as DocValue<CRDTTestType>;
     expect(doc.nice).toBe("data");
   });
-  it("should allow for a delete", async function () {
+  it("should allow for a delete", async () => {
     const didDel = await crdt.bulk([{ id: "hello", del: true }]);
     expect(didDel.head).toBeTruthy();
     const got = await crdt.get("hello");
     expect(got).toBeFalsy();
   });
-  it("should offer changes", async function () {
+  it("should offer changes", async () => {
     const { result } = await crdt.changes<Partial<CRDTTestType>>([]);
     expect(result.length).toBe(1);
     expect(result[0].id).toBe("hello");
@@ -107,11 +108,11 @@ describe("CRDT with a multi-write", function () {
   let firstPut: CRDTMeta;
   const sthis = ensureSuperThis();
 
-  afterEach(async function () {
+  afterEach(async () => {
     await crdt.close();
     await crdt.destroy();
   });
-  beforeEach(async function () {
+  beforeEach(async () => {
     await sthis.start();
     const dbOpts: LedgerOpts = {
       name: "test-crdt",
@@ -126,12 +127,12 @@ describe("CRDT with a multi-write", function () {
       { id: "king", value: { points: 10 } },
     ]);
   });
-  it("should have a one-element head", async function () {
+  it("should have a one-element head", async () => {
     const head = crdt.clock.head;
     expect(head.length).toBe(1);
     expect(firstPut.head.length).toBe(1);
   });
-  it("return the records on get", async function () {
+  it("return the records on get", async () => {
     const { doc } = (await crdt.get("ace")) as DocValue<CRDTTestType>;
     expect(doc.points).toBe(11);
 
@@ -139,7 +140,7 @@ describe("CRDT with a multi-write", function () {
     expect(got2).toBeTruthy();
     expect(got2.doc.points).toBe(10);
   });
-  it("should accept another put and return results", async function () {
+  it("should accept another put and return results", async () => {
     const didPut = await crdt.bulk([{ id: "queen", value: { points: 10 } }]);
     const head = didPut.head;
     expect(head.length).toBe(1);
@@ -147,14 +148,14 @@ describe("CRDT with a multi-write", function () {
     expect(got).toBeTruthy();
     expect(got.doc.points).toBe(10);
   });
-  it("should offer changes", async function () {
+  it("should offer changes", async () => {
     const { result } = await crdt.changes<CRDTTestType>([]);
     expect(result.length).toBe(2);
     expect(result[0].id).toBe("ace");
     expect(result[0].value?.points).toBe(11);
     expect(result[1].id).toBe("king");
   });
-  it("should offer changes since", async function () {
+  it("should offer changes since", async () => {
     /** @type {CRDTMeta} */
     const secondPut = await crdt.bulk([
       { id: "queen", value: { points: 10 } },
@@ -178,7 +179,7 @@ describe("CRDT with two multi-writes", function () {
   let firstPut: CRDTMeta;
   let secondPut: CRDTMeta;
   const sthis = ensureSuperThis();
-  afterEach(async function () {
+  afterEach(async () => {
     await crdt.close();
     await crdt.destroy();
   });
@@ -201,14 +202,14 @@ describe("CRDT with two multi-writes", function () {
       { id: "jack", value: { points: 10 } },
     ]);
   });
-  it("should have a one-element head", async function () {
+  it("should have a one-element head", async () => {
     const head = crdt.clock.head;
     expect(head.length).toBe(1);
     expect(firstPut.head.length).toBe(1);
     expect(secondPut.head.length).toBe(1);
     expect(firstPut.head[0]).not.toBe(secondPut.head[0]);
   });
-  it("return the records on get", async function () {
+  it("return the records on get", async () => {
     const ret = await crdt.get("ace");
     expect(ret).not.toBeNull();
     const { doc } = ret as DocValue<CRDTTestType>;
@@ -219,7 +220,7 @@ describe("CRDT with two multi-writes", function () {
       expect(doc.points).toBe(10);
     }
   });
-  it("should offer changes", async function () {
+  it("should offer changes", async () => {
     const { result } = await crdt.changes<CRDTTestType>();
     expect(result.length).toBe(4);
     expect(result[0].id).toBe("ace");
@@ -233,17 +234,22 @@ describe("CRDT with two multi-writes", function () {
 describe("Compact a named CRDT with writes", function () {
   let crdt: CRDT;
   const sthis = ensureSuperThis();
-  afterEach(async function () {
+  afterEach(async () => {
     await crdt.close();
     await crdt.destroy();
   });
-  beforeEach(async function () {
+  beforeEach(async () => {
     await sthis.start();
+    // sthis.env.set(
+    //   "FP_STORAGE_URL",
+    //   BuildURI.from(sthis.env.get("FP_STORAGE_URL")).setParam(PARAM.STORE_KEY, "insecure").toString(),
+    // );
+    // console.log("FP_STORAGE_URL", sthis.env.get("FP_STORAGE_URL"));
     const dbOpts: LedgerOpts = {
       name: "test-crdt",
       writeQueue: defaultWriteQueueOpts({}),
       keyBag: rt.defaultKeyBagOpts(sthis),
-      storeUrls: toStoreURIRuntime(sthis, `named-crdt-compaction`),
+      storeUrls: toStoreURIRuntime(sthis, `named-crdt-compaction-${sthis.nextId().str}`),
       storeEnDe: bs.ensureStoreEnDeFile({}),
     };
     crdt = new CRDTImpl(sthis, dbOpts);
@@ -254,25 +260,59 @@ describe("Compact a named CRDT with writes", function () {
       ];
       await crdt.bulk(bulk);
     }
+    // await sleep(1000);
   });
-  it("has data", async function () {
+  it("has data", async () => {
     const got = (await crdt.get("ace")) as DocValue<CRDTTestType>;
     expect(got.doc).toBeTruthy();
     expect(got.doc.points).toBe(11);
   });
-  it("should start with blocks", async function () {
+  it("should start with blocks", async () => {
     const blz: bs.AnyBlock[] = [];
     for await (const blk of crdt.blockstore.entries()) {
       blz.push(blk);
     }
-    expect(blz.length).toBe(13);
-  });
-  it("should start with changes", async function () {
+    //    expect(blz.map((i) => sthis.txt.decode(i.bytes) + "\n=================\n")).toEqual([
+    //
+    //    ])
+    expect(blz.map((i) => i.cid.toString())).toEqual([
+      "bafyreicuomyooryb747esregkhooc4phr656tocowyo6dwcocq22h7qdhu",
+      "bafyreig5jhovaiocwk3vfafzdspgtwinftjygyghjzigkc554muhdmp5ba",
+      "bafyreiegj7yumreue7llzqroebigscedyzrkeir3zneg5q7zia77itowy4",
+      "bafyreihobual6tt3hgdfve4h5uzt7fey62se3dfecbuj6f4ndkkwquke4u",
+      "bafyreibqqcs3r6mhpr3525na6jtqnjcf6dmgskk27x4a2jb3r2qveqgexm",
+      "bafyreibr7udlekt4xgavn54i4zfsdlrmi4r76iq6gh3bdq4xh52px6to3e",
+      "bafyreidg2eyas62nvwvi6ggq44tsldj4kwmupyk2xtwmxbwf77g3noqtp4",
+      "bafyreigbzxzj4eh7ljfvzlc7smdextuuk7gvep5mpnb3igaj5r2qzjlfye",
+      "bafyreicr7takuntpofvk52xerdcoiq7wdt73ef54acoya2geig2ywkqlsi",
+      "bafyreihmmgm5sufvnsgjic4fbizkdbajpy2yrklyieadstbtegfr4qko2m",
+      "bafyreibnu44uyu3ggqwgmnlxodw6dyta3qg7e5qldsjq7bkbv452ova6oa",
+      "bafyreieh4nlzg7enfczmj4z7uxvgrnykh7ajw7crxjrncqfrzj47ip6t6m",
+      "bafyreigqqrccymfvvdfetjd2twsdzjwxbb6cn6tedqntvpgp5vboky2ol4",
+      "bafyreid6kkobhgdmce2cyroepyos3jwumtdrfuzi6suldlxzjsgagc3fvi",
+      "bafyreibo2d56wo5ldey24hygtmsfhdxsqgdpmtne5oitehxjppipru33ma",
+      "bafyreifjv6havcza3is7w6ii345f5akba7e34xqcxwoqozmsnihkivykum",
+      "bafyreig6eroqeg3y7am4bnrun3yzbvd656epzxjyivdpzwqo3j3vpuwysi",
+      "bafyreibpsnfsducp7refempcyqnte54j7ueh4ysdlabggihclbddfnuzxm",
+      "bafyreicfkkygbzz5zawr3xbfah2gy3e7w4opzysew4tini7xnksujj4gf4",
+      "bafyreiddjm5xkpfa5vmyhoj5opocrwo6zbdnmqyhouc5ttfxoilmaf25bm",
+      "bafyreibp7vlgfexaknaoxpemnnwadyfa4cfuc3euzlkslskks2n44wwspu",
+      "bafyreichwj7izzpxeyjkhwl26pq45m4hnhxcgzqfk5ffeqkscafleiwfzm",
+      "bafyreidzjjqou36q2ghqdue4buq7536w4sl5aejni6tw25mzsusl26gtwu",
+      "bafyreibxibqhi6wh5klrje7ne4htffeqyyqfd6y7x2no6wnhid4nixizau",
+      "bafyreidnvv4mwvweup5w52ddre2sl4syhvczm6ejqsmuekajowdl2cf2q4",
+      "bafyreihh6nbfbhgkf5lz7hhsscjgiquw426rxzr3fprbgonekzmyvirrhe",
+      "bafyreiejg3twlaxr7gfvvhtxrhvwaydytdv4guidmtvaz5dskm6gp73ryi",
+      "bafyreiblui55o25dopc5faol3umsnuohb5carto7tot4kicnkfc37he4h4",
+    ]);
+    // expect(blz.length).toBe(13);
+  }, 1000000);
+  it("should start with changes", async () => {
     const { result } = await crdt.changes();
     expect(result.length).toBe(2);
     expect(result[0].id).toBe("ace");
   });
-  it.skip("should have fewer blocks after compact", async function () {
+  it.skip("should have fewer blocks after compact", async () => {
     await crdt.compact();
     const blz: bs.AnyBlock[] = [];
     for await (const blk of crdt.blockstore.entries()) {
@@ -280,13 +320,13 @@ describe("Compact a named CRDT with writes", function () {
     }
     expect(blz.length).toBe(23);
   });
-  it("should have data after compact", async function () {
+  it("should have data after compact", async () => {
     await crdt.compact();
     const got = (await crdt.get("ace")) as DocValue<CRDTTestType>;
     expect(got.doc).toBeTruthy();
     expect(got.doc.points).toBe(11);
   });
-  it("should have changes after compact", async function () {
+  it("should have changes after compact", async () => {
     const chs = await crdt.changes();
     expect(chs.result[0].id).toBe("ace");
   });
@@ -296,11 +336,11 @@ describe("CRDT with an index", function () {
   let crdt: CRDT;
   let idx: Index<number, CRDTTestType>;
   const sthis = ensureSuperThis();
-  afterEach(async function () {
+  afterEach(async () => {
     await crdt.close();
     await crdt.destroy();
   });
-  beforeEach(async function () {
+  beforeEach(async () => {
     await sthis.start();
     const dbOpts: LedgerOpts = {
       name: "test-crdt",
@@ -316,13 +356,13 @@ describe("CRDT with an index", function () {
     ]);
     idx = await index<number, CRDTTestType>(crdt, "points");
   });
-  it("should query the data", async function () {
+  it("should query the data", async () => {
     const got = await idx.query({ range: [9, 12] });
     expect(got.rows.length).toBe(2);
     expect(got.rows[0].id).toBe("king");
     expect(got.rows[0].key).toBe(10);
   });
-  it("should register the index", async function () {
+  it("should register the index", async () => {
     const rIdx = await index<number, CRDTTestType>(crdt, "points");
     expect(rIdx).toBeTruthy();
     expect(rIdx.name).toBe("points");
@@ -331,7 +371,7 @@ describe("CRDT with an index", function () {
     expect(got.rows[0].id).toBe("king");
     expect(got.rows[0].key).toBe(10);
   });
-  it("creating a different index with same name should not work", async function () {
+  it("creating a different index with same name should not work", async () => {
     const e = await index(crdt, "points", (doc) => doc._id)
       .query()
       .catch((err) => err);
@@ -346,11 +386,11 @@ describe("Loader with a committed transaction", function () {
   let done: CRDTMeta;
   const dbname = "test-loader";
   const sthis = ensureSuperThis();
-  afterEach(async function () {
+  afterEach(async () => {
     await crdt.close();
     await crdt.destroy();
   });
-  beforeEach(async function () {
+  beforeEach(async () => {
     await sthis.start();
     const dbOpts: LedgerOpts = {
       name: "test-crdt",
@@ -376,16 +416,16 @@ describe("Loader with a committed transaction", function () {
   it("should commit a transaction", function () {
     expect(done.head).toBeTruthy();
     // expect(done.cars).toBeTruthy();
-    expect(loader.carLog.length).toBe(1);
+    expect(loader.carLog.length).toBe(1 + 1 /* genesis */);
   });
   it("can load the car", async () => {
-    const blk = loader.carLog[0][0];
+    const blk = loader.carLog.asArray()[0][0];
     expect(blk).toBeTruthy();
-    const reader = await loader.loadCar(blk);
+    const reader = await loader.loadCar(blk, loader.attachedStores.local());
     expect(reader).toBeTruthy();
     const parsed = await bs.parseCarFile<CRDTMeta>(reader, loader.logger);
     expect(parsed.cars).toBeTruthy();
-    expect(parsed.cars.length).toBe(0);
+    expect(parsed.cars.length).toBe(0 + 1 /* genesis */);
     expect(parsed.meta).toBeTruthy();
     expect(parsed.meta.head).toBeTruthy();
   });
@@ -398,11 +438,11 @@ describe("Loader with two committed transactions", function () {
   let done1: CRDTMeta;
   let done2: CRDTMeta;
   const sthis = ensureSuperThis();
-  afterEach(async function () {
+  afterEach(async () => {
     await crdt.close();
     await crdt.destroy();
   });
-  beforeEach(async function () {
+  beforeEach(async () => {
     await sthis.start();
     const dbOpts: LedgerOpts = {
       name: "test-crdt",
@@ -426,20 +466,20 @@ describe("Loader with two committed transactions", function () {
     expect(done1.head).not.toBe(done2.head);
     // expect(done1.cars).not.toBe(done2.cars);
     // expect(blockstore.transactions.size).toBe(2);
-    expect(loader.carLog.length).toBe(2);
+    expect(loader.carLog.length).toBe(2 + 1 /* genesis */);
     // expect(loader.carLog.indexOf(done1.cars)).toBe(1);
     // expect(loader.carLog.map((cs) => cs.toString()).indexOf(done1.cars.toString())).toBe(1);
     // expect(loader.carLog.indexOf(done2.cars)).toBe(0);
     // expect(loader.carLog.map((cs) => cs.toString()).indexOf(done2.cars.toString())).toBe(0);
   });
-  it("can load the car", async function () {
-    const blk = loader.carLog[0][0];
+  it("can load the car", async () => {
+    const blk = loader.carLog.asArray()[0][0];
     expect(blk).toBeTruthy();
-    const reader = await loader.loadCar(blk);
+    const reader = await loader.loadCar(blk, loader.attachedStores.local());
     expect(reader).toBeTruthy();
     const parsed = await bs.parseCarFile<CRDTMeta>(reader, loader.logger);
     expect(parsed.cars).toBeTruthy();
-    expect(parsed.cars.length).toBe(1);
+    expect(parsed.cars.length).toBe(1 + 1 /* genesis */);
     expect(parsed.meta).toBeTruthy();
     expect(parsed.meta.head).toBeTruthy();
   });
@@ -452,11 +492,11 @@ describe("Loader with many committed transactions", function () {
   let dones: CRDTMeta[];
   const count = 10;
   const sthis = ensureSuperThis();
-  afterEach(async function () {
+  afterEach(async () => {
     await crdt.close();
     await crdt.destroy();
   });
-  beforeEach(async function () {
+  beforeEach(async () => {
     await sthis.start();
     const dbOpts: LedgerOpts = {
       name: "test-crdt",
@@ -481,16 +521,16 @@ describe("Loader with many committed transactions", function () {
       // expect(done.cars).toBeTruthy();
     }
     expect(blockstore.transactions.size).toBe(0); // cleaned up on commit
-    expect(loader.carLog.length).toBe(count);
+    expect(loader.carLog.length).toBe(count + 1 /* genesis */);
   });
-  it("can load the car", async function () {
-    const blk = loader.carLog[2][0];
+  it("can load the car", async () => {
+    const blk = loader.carLog.asArray()[2][0];
     // expect(dones[5].cars).toBeTruthy();
-    const reader = await loader.loadCar(blk);
+    const reader = await loader.loadCar(blk, loader.attachedStores.local());
     expect(reader).toBeTruthy();
     const parsed = await bs.parseCarFile<CRDTMeta>(reader, loader.logger);
     expect(parsed.cars).toBeTruthy();
-    expect(parsed.cars.length).toBe(7);
+    expect(parsed.cars.length).toBe(7 + 1 /* genesis */);
     expect(parsed.meta).toBeTruthy();
     expect(parsed.meta.head).toBeTruthy();
   });