@fireproof/core 0.19.8-dev-global → 0.19.8-dev-series-2

package/tests/blockstore/store.test.ts

@@ -1,16 +1,16 @@
 import { CID } from "multiformats";
-import { rt, bs } from "@fireproof/core";
-import { MockLogger } from "@adviser/cement";
-import { NotFoundError } from "../../src/blockstore/gateway";
+import { bs, NotFoundError, SuperThis } from "@fireproof/core";
+import { mockSuperThis } from "../helpers";
 
 const decoder = new TextDecoder("utf-8");
 
-function runtime() {
-  return bs.toStoreRuntime({}, MockLogger().logger);
+function runtime(sthis: SuperThis) {
+  return bs.toStoreRuntime({}, sthis);
 }
 
-function mockLoader(name: string): bs.Loadable {
+function mockLoader(sthis: SuperThis, name: string): bs.Loadable {
   return {
+    sthis,
     name,
     ebOpts: {
       store: {},
@@ -20,18 +20,19 @@ function mockLoader(name: string): bs.Loadable {
 
 describe("DataStore", function () {
   let store: bs.DataStore;
-  let raw: bs.TestStore;
+  let raw: bs.TestGateway;
 
+  const sthis = mockSuperThis();
   afterEach(async () => {
     await store.close();
     await store.destroy();
   });
 
   beforeEach(async () => {
-    await rt.SysContainer.start();
-    store = await runtime().makeDataStore(mockLoader("test"));
+    await sthis.start();
+    store = await runtime(sthis).makeDataStore(mockLoader(sthis, "test"));
     await store.start();
-    raw = await bs.testStoreFactory(store.url);
+    raw = await bs.testStoreFactory(store.url(), sthis);
   });
 
   it("should have a name", function () {
@@ -44,26 +45,28 @@ describe("DataStore", function () {
       bytes: new Uint8Array([55, 56, 57]),
     };
     await store.save(car);
-    const data = await raw.get(store.url, car.cid.toString());
+    const data = await raw.get(store.url(), car.cid.toString());
     expect(decoder.decode(data)).toEqual(decoder.decode(car.bytes));
   });
 });
 
 describe("DataStore with a saved car", function () {
   let store: bs.DataStore;
-  let raw: bs.TestStore;
+  let raw: bs.TestGateway;
   let car: bs.AnyBlock;
 
+  const sthis = mockSuperThis();
+
   afterEach(async () => {
     await store.close();
     await store.destroy();
   });
 
   beforeEach(async function () {
-    await rt.SysContainer.start();
-    store = await runtime().makeDataStore(mockLoader("test2"));
+    await sthis.start();
+    store = await runtime(sthis).makeDataStore(mockLoader(sthis, "test2"));
     await store.start();
-    raw = await bs.testStoreFactory(store.url);
+    raw = await bs.testStoreFactory(store.url(), sthis);
     car = {
       cid: "cid" as unknown as CID,
       bytes: new Uint8Array([55, 56, 57, 80]),
@@ -72,7 +75,7 @@ describe("DataStore with a saved car", function () {
   });
 
   it("should have a car", async function () {
-    const data = await raw.get(store.url, car.cid.toString());
+    const data = await raw.get(store.url(), car.cid.toString());
     expect(decoder.decode(data)).toEqual(decoder.decode(car.bytes));
   });
 
@@ -85,15 +88,16 @@ describe("DataStore with a saved car", function () {
 
   it("should remove a car", async function () {
     await store.remove(car.cid);
-    const error = (await store.load(car.cid).catch((e: Error) => e)) as NotFoundError;
-    expect(error.code).toMatch("ENOENT");
-    // matches(error.message, "ENOENT");
+    const { e: error } = (await store.load(car.cid).catch((e: Error) => ({ e }))) as { e: NotFoundError };
+    expect(error).toBeTruthy();
   });
 });
 
 describe("MetaStore", function () {
   let store: bs.MetaStore;
-  let raw: bs.TestStore;
+  let raw: bs.TestGateway;
+
+  const sthis = mockSuperThis();
 
   afterEach(async () => {
     await store.close();
@@ -101,10 +105,10 @@ describe("MetaStore", function () {
   });
 
   beforeEach(async function () {
-    await rt.SysContainer.start();
-    store = await runtime().makeMetaStore(mockLoader("test"));
+    await sthis.start();
+    store = await runtime(sthis).makeMetaStore(mockLoader(sthis, "test"));
     await store.start();
-    raw = await bs.testStoreFactory(store.url);
+    raw = await bs.testStoreFactory(store.url(), sthis);
   });
 
   it("should have a name", function () {
@@ -115,21 +119,23 @@ describe("MetaStore", function () {
     const cid = CID.parse("bafybeia4luuns6dgymy5kau5rm7r4qzrrzg6cglpzpogussprpy42cmcn4");
     const h: bs.DbMeta = {
       cars: [cid],
-      key: undefined,
+      // key: undefined,
     };
     await store.save(h);
-    const file = await raw.get(store.url, "main");
-    const header = JSON.parse(decoder.decode(file));
-    expect(header).toBeTruthy();
-    expect(header.cars).toBeTruthy();
-    expect(header.cars[0]["/"]).toEqual(cid.toString());
+    const file = await raw.get(store.url(), "main");
+    const [blockMeta] = await store.handleByteHeads(file);
+    const decodedHeader = blockMeta.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: bs.MetaStore;
-  let raw: bs.TestStore;
+  let raw: bs.TestGateway;
   let cid: CID;
+  const sthis = mockSuperThis();
 
   afterEach(async () => {
     await store.close();
@@ -137,21 +143,26 @@ describe("MetaStore with a saved header", function () {
   });
 
   beforeEach(async function () {
-    await rt.SysContainer.start();
-    store = await runtime().makeMetaStore(mockLoader("test-saved-header"));
+    await sthis.start();
+    store = await runtime(sthis).makeMetaStore(mockLoader(sthis, "test-saved-header"));
     await store.start();
-    raw = await bs.testStoreFactory(store.url);
+    raw = await bs.testStoreFactory(store.url(), sthis);
     cid = CID.parse("bafybeia4luuns6dgymy5kau5rm7r4qzrrzg6cglpzpogussprpy42cmcn4");
-    await store.save({ cars: [cid], key: undefined });
+    await store.save({ cars: [cid] /*, key: undefined */ });
   });
 
   it("should have a header", async function () {
-    const data = decoder.decode(await raw.get(store.url, "main"));
-    expect(data).toMatch(/car/);
-    const header = JSON.parse(data);
-    expect(header).toBeTruthy();
-    expect(header.cars).toBeTruthy();
-    expect(header.cars[0]["/"]).toEqual(cid.toString());
+    const bytes = await raw.get(store.url(), "main");
+    const data = decoder.decode(bytes);
+    expect(data).toMatch(/parents/);
+    const header = JSON.parse(data)[0];
+    expect(header).toBeDefined();
+    expect(header.parents).toBeDefined();
+    const [blockMeta] = await store.handleByteHeads(bytes);
+    const decodedHeader = blockMeta.dbMeta;
+    expect(decodedHeader).toBeDefined();
+    expect(decodedHeader.cars).toBeDefined();
+    expect(decodedHeader.cars[0].toString()).toEqual(cid.toString());
   });
 
   it("should load a header", async function () {

package/tests/blockstore/transaction.test.ts

@@ -1,9 +1,10 @@
 import { CID } from "multiformats";
-// import { matches, equalsJSON } from "../helpers.js";
-import { bs } from "@fireproof/core";
+import { bs, SuperThis } from "@fireproof/core";
+import { mockSuperThis } from "../helpers";
 
 describe("Fresh TransactionBlockstore", function () {
   let blocks: bs.BaseBlockstore;
+  const sthis = mockSuperThis();
   beforeEach(function () {
     blocks = new bs.BaseBlockstore();
   });
@@ -14,7 +15,7 @@ describe("Fresh TransactionBlockstore", function () {
     expect(blocks.loader).toBeFalsy();
   });
   it("should not put", async function () {
-    const value = new TextEncoder().encode("value");
+    const value = sthis.txt.encode("value");
     const e = await blocks.put("key" as unknown as bs.AnyLink, value).catch((e) => e);
     expect(e.message).toMatch(/transaction/g);
   });
@@ -32,8 +33,9 @@ describe("Fresh TransactionBlockstore", function () {
 
 describe("TransactionBlockstore with name", function () {
   let blocks: bs.EncryptedBlockstore;
+  const sthis = mockSuperThis();
   beforeEach(function () {
-    blocks = new bs.EncryptedBlockstore({ name: "test" });
+    blocks = new bs.EncryptedBlockstore(sthis, { name: "test" });
   });
   it("should have a name", function () {
     expect(blocks.name).toEqual("test");
@@ -42,7 +44,7 @@ describe("TransactionBlockstore with name", function () {
     expect(blocks.loader).toBeTruthy();
   });
   it("should get from loader", async function () {
-    const bytes = new TextEncoder().encode("bytes");
+    const bytes = sthis.txt.encode("bytes");
     expect(blocks.loader).toBeTruthy();
     blocks.loader.getBlock = async (cid) => {
       return { cid, bytes };
@@ -55,14 +57,15 @@ describe("TransactionBlockstore with name", function () {
 describe("A transaction", function () {
   let tblocks: bs.CarTransaction;
   let blocks: bs.EncryptedBlockstore;
+  const sthis = mockSuperThis();
   beforeEach(async function () {
-    blocks = new bs.EncryptedBlockstore({ name: "test" });
+    blocks = new bs.EncryptedBlockstore(sthis, { name: "test" });
     tblocks = new bs.CarTransaction(blocks);
     blocks.transactions.add(tblocks);
   });
   it("should put and get", async function () {
     const cid = CID.parse("bafybeia4luuns6dgymy5kau5rm7r4qzrrzg6cglpzpogussprpy42cmcn4");
-    const bytes = new TextEncoder().encode("bytes");
+    const bytes = sthis.txt.encode("bytes");
     await tblocks.put(cid, bytes);
     expect(blocks.transactions.has(tblocks)).toBeTruthy();
     const got = await tblocks.get(cid);
@@ -72,14 +75,15 @@ describe("A transaction", function () {
   });
 });
 
-function asUInt8Array(str: string) {
-  return new TextEncoder().encode(str);
+function asUInt8Array(str: string, sthis: SuperThis) {
+  return sthis.txt.encode(str);
 }
 
 describe("TransactionBlockstore with a completed transaction", function () {
   let blocks: bs.BaseBlockstore;
   let cid: CID;
   let cid2: CID;
+  const sthis = mockSuperThis();
 
   beforeEach(async function () {
     cid = CID.parse("bafybeia4luuns6dgymy5kau5rm7r4qzrrzg6cglpzpogussprpy42cmcn4");
@@ -87,13 +91,13 @@ describe("TransactionBlockstore with a completed transaction", function () {
 
     blocks = new bs.BaseBlockstore();
     await blocks.transaction(async (tblocks) => {
-      await tblocks.put(cid, asUInt8Array("value"));
-      await tblocks.put(cid2, asUInt8Array("value2"));
+      await tblocks.put(cid, asUInt8Array("value", sthis));
+      await tblocks.put(cid, asUInt8Array("value", sthis));
       return { head: [] };
     });
     await blocks.transaction(async (tblocks) => {
-      await tblocks.put(cid, asUInt8Array("value"));
-      await tblocks.put(cid2, asUInt8Array("value2"));
+      await tblocks.put(cid, asUInt8Array("value", sthis));
+      await tblocks.put(cid2, asUInt8Array("value2", sthis));
       return { head: [] };
     });
   });
@@ -104,10 +108,10 @@ describe("TransactionBlockstore with a completed transaction", function () {
   it("should get", async function () {
     const value = (await blocks.get(cid)) as bs.AnyBlock;
     expect(value.cid).toEqual(cid);
-    expect(value.bytes.toString()).toEqual(asUInt8Array("value").toString());
+    expect(value.bytes.toString()).toEqual(asUInt8Array("value", sthis).toString());
 
     const value2 = (await blocks.get(cid2)) as bs.AnyBlock;
-    expect(value2.bytes.toString()).toEqual(asUInt8Array("value2").toString());
+    expect(value2.bytes.toString()).toEqual(asUInt8Array("value2", sthis).toString());
   });
   it("should yield entries", async function () {
     const blz = [];

package/tests/fireproof/all-gateway.test.ts

@@ -0,0 +1,394 @@
+import { Database, bs } from "@fireproof/core";
+import { URI } from "@adviser/cement";
+
+import { fileContent } from "./cars/bafkreidxwt2nhvbl4fnqfw3ctlt6zbrir4kqwmjo5im6rf4q5si27kgo2i.js";
+
+function customExpect(value: unknown, matcher: (val: unknown) => void, message: string): void {
+  try {
+    matcher(value);
+  } catch (error) {
+    void error;
+    // console.error(error);
+    throw new Error(message);
+  }
+}
+
+interface ExtendedGateway extends bs.Gateway {
+  logger: { _attributes: { module: string; url?: string } };
+  headerSize: number;
+  fidLength: number;
+}
+
+interface ExtendedStore {
+  gateway: ExtendedGateway;
+  _url: URI;
+  name: string;
+}
+
+describe("noop Gateway", function () {
+  let db: Database;
+  let carStore: ExtendedStore;
+  let metaStore: ExtendedStore;
+  let fileStore: ExtendedStore;
+  let walStore: ExtendedStore;
+  let carGateway: ExtendedGateway;
+  let metaGateway: ExtendedGateway;
+  let fileGateway: ExtendedGateway;
+  let walGateway: ExtendedGateway;
+
+  afterEach(async function () {
+    await db.close();
+    await db.destroy();
+  });
+  beforeEach(async function () {
+    db = new Database("test-gateway-" + Math.random().toString(36).substring(7));
+
+    // Extract stores from the loader
+    carStore = (await db.blockstore.loader?.carStore()) as unknown as ExtendedStore;
+    metaStore = (await db.blockstore.loader?.metaStore()) as unknown as ExtendedStore;
+    fileStore = (await db.blockstore.loader?.fileStore()) as unknown as ExtendedStore;
+    walStore = (await db.blockstore.loader?.WALStore()) as unknown as ExtendedStore;
+
+    // Extract and log gateways
+    carGateway = carStore?.gateway;
+    metaGateway = metaStore?.gateway;
+    fileGateway = fileStore?.gateway;
+    walGateway = walStore?.gateway;
+  });
+
+  it("should have valid stores and gateways", async function () {
+    // Add assertions
+    expect(carStore).toBeTruthy();
+    expect(metaStore).toBeTruthy();
+    expect(fileStore).toBeTruthy();
+    expect(walStore).toBeTruthy();
+
+    expect(carGateway).toBeTruthy();
+    expect(metaGateway).toBeTruthy();
+    expect(fileGateway).toBeTruthy();
+    expect(walGateway).toBeTruthy();
+  });
+
+  it("should have correct store names", async function () {
+    // Check that all stores have the correct name
+    expect(carStore?.name).toContain("test-gateway");
+    expect(metaStore?.name).toContain("test-gateway");
+    expect(fileStore?.name).toContain("test-gateway");
+    expect(walStore?.name).toContain("test-gateway");
+  });
+
+  it("should have correct store types in URLs", async function () {
+    // Check that all stores have the correct store type in their URL
+    expect(carStore?._url.toString()).toContain("store=data");
+    expect(metaStore?._url.toString()).toContain("store=meta");
+    expect(fileStore?._url.toString()).toContain("store=data");
+    expect(walStore?._url.toString()).toContain("store=wal");
+  });
+
+  it("should have version specified in URLs", async function () {
+    // Verify that all stores have a version specified
+    expect(carStore?._url.toString()).toContain("version=");
+    expect(metaStore?._url.toString()).toContain("version=");
+    expect(fileStore?._url.toString()).toContain("version=");
+    expect(walStore?._url.toString()).toContain("version=");
+  });
+
+  it("should have correct gateway types", async function () {
+    // Check that all gateways are instances of the expected gateway class
+    expect(typeof carGateway).toBe("object");
+    expect(typeof metaGateway).toBe("object");
+    expect(typeof fileGateway).toBe("object");
+    expect(typeof walGateway).toBe("object");
+  });
+
+  it("should build CAR Gateway URL", async function () {
+    const testKey = "bafkreidxwt2nhvbl4fnqfw3ctlt6zbrir4kqwmjo5im6rf4q5si27kgo2i";
+    const carUrl = await carGateway?.buildUrl(carStore?._url, testKey);
+    expect(carUrl?.Ok()).toBeTruthy();
+  });
+
+  it("should start CAR Gateway", async function () {
+    await carGateway?.start(carStore?._url);
+  });
+
+  it("should put data in CAR Gateway", async function () {
+    const testKey = "bafkreidxwt2nhvbl4fnqfw3ctlt6zbrir4kqwmjo5im6rf4q5si27kgo2i";
+    const testData = fileContent;
+    const carUrl = await carGateway?.buildUrl(carStore?._url, testKey);
+    await carGateway?.start(carStore?._url);
+    const carPutResult = await carGateway?.put(carUrl?.Ok(), testData);
+    expect(carPutResult?.Ok()).toBeFalsy();
+  });
+
+  it("should get data from CAR Gateway", async function () {
+    const testKey = "bafkreidxwt2nhvbl4fnqfw3ctlt6zbrir4kqwmjo5im6rf4q5si27kgo2i";
+    const testData = fileContent;
+    const carUrl = await carGateway?.buildUrl(carStore?._url, testKey);
+    await carGateway?.start(carStore?._url);
+    await carGateway?.put(carUrl?.Ok(), testData);
+    const carGetResult = await carGateway?.get(carUrl?.Ok());
+    customExpect(carGetResult?.Ok(), (v) => expect(v).toEqual(testData), "carGetResult should match testData");
+  });
+
+  it("should delete data from CAR Gateway", async function () {
+    const testKey = "bafkreidxwt2nhvbl4fnqfw3ctlt6zbrir4kqwmjo5im6rf4q5si27kgo2i";
+    const testData = fileContent;
+    const carUrl = await carGateway?.buildUrl(carStore?._url, testKey);
+    await carGateway?.start(carStore?._url);
+    await carGateway?.put(carUrl?.Ok(), testData);
+    const carDeleteResult = await carGateway?.delete(carUrl?.Ok());
+    expect(carDeleteResult?.Ok()).toBeFalsy();
+  });
+
+  it("should close CAR Gateway", async function () {
+    await carGateway?.close(carStore?._url);
+  });
+  it("should build Meta Gateway URL", async function () {
+    const metaUrl = await metaGateway?.buildUrl(metaStore?._url, "main");
+    expect(metaUrl?.Ok()).toBeTruthy();
+  });
+
+  it("should start Meta Gateway", async function () {
+    await metaGateway?.start(metaStore?._url);
+  });
+
+  it("should close Meta Gateway", async function () {
+    await metaGateway?.start(metaStore?._url);
+    await metaGateway?.close(metaStore?._url);
+  });
+
+  it("should build File Gateway URL", async function () {
+    const testKey = "bafkreidxwt2nhvbl4fnqfw3ctlt6zbrir4kqwmjo5im6rf4q5si27kgo2i";
+    const fileUrl = await fileGateway?.buildUrl(fileStore?._url, testKey);
+    expect(fileUrl?.Ok()).toBeTruthy();
+  });
+
+  it("should start File Gateway", async function () {
+    await fileGateway?.start(fileStore?._url);
+  });
+
+  it("should put data to File Gateway", async function () {
+    const testKey = "bafkreidxwt2nhvbl4fnqfw3ctlt6zbrir4kqwmjo5im6rf4q5si27kgo2i";
+    const testData = fileContent;
+    const fileUrl = await fileGateway?.buildUrl(fileStore?._url, testKey);
+    await fileGateway?.start(fileStore?._url);
+    const filePutResult = await fileGateway?.put(fileUrl?.Ok(), testData);
+    expect(filePutResult?.Ok()).toBeFalsy();
+  });
+
+  it("should get data from File Gateway", async function () {
+    const testKey = "bafkreidxwt2nhvbl4fnqfw3ctlt6zbrir4kqwmjo5im6rf4q5si27kgo2i";
+    const testData = fileContent;
+    const fileUrl = await fileGateway?.buildUrl(fileStore?._url, testKey);
+    await fileGateway?.start(fileStore?._url);
+    await fileGateway?.put(fileUrl?.Ok(), testData);
+    const fileGetResult = await fileGateway?.get(fileUrl?.Ok());
+    customExpect(fileGetResult?.Ok(), (v) => expect(v).toEqual(testData), "fileGetResult should match testData");
+  });
+
+  it("should delete data from File Gateway", async function () {
+    const testKey = "bafkreidxwt2nhvbl4fnqfw3ctlt6zbrir4kqwmjo5im6rf4q5si27kgo2i";
+    const testData = fileContent;
+    const fileUrl = await fileGateway?.buildUrl(fileStore?._url, testKey);
+    await fileGateway?.start(fileStore?._url);
+    await fileGateway?.put(fileUrl?.Ok(), testData);
+    const fileDeleteResult = await fileGateway?.delete(fileUrl?.Ok());
+    expect(fileDeleteResult?.Ok()).toBeFalsy();
+  });
+
+  it("should close File Gateway", async function () {
+    await fileGateway?.close(fileStore?._url);
+  });
+  it("should build WAL Gateway URL", async function () {
+    const testKey = "bafkreidxwt2nhvbl4fnqfw3ctlt6zbrir4kqwmjo5im6rf4q5si27kgo2i";
+    const walUrl = await walGateway?.buildUrl(walStore?._url, testKey);
+    expect(walUrl?.Ok()).toBeTruthy();
+  });
+
+  it("should start WAL Gateway", async function () {
+    await walGateway?.start(walStore?._url);
+  });
+
+  it("should put data to WAL Gateway", async function () {
+    const testKey = "bafkreidxwt2nhvbl4fnqfw3ctlt6zbrir4kqwmjo5im6rf4q5si27kgo2i";
+    const walUrl = await walGateway?.buildUrl(walStore?._url, testKey);
+    await walGateway?.start(walStore?._url);
+    const walTestDataString = JSON.stringify({
+      operations: [],
+      noLoaderOps: [],
+      fileOperations: [],
+    });
+    const walEncoder = new TextEncoder();
+    const walTestData = walEncoder.encode(walTestDataString);
+    const walPutResult = await walGateway?.put(walUrl?.Ok(), walTestData);
+    expect(walPutResult?.Ok()).toBeFalsy();
+  });
+
+  it("should get data from WAL Gateway", async function () {
+    const testKey = "bafkreidxwt2nhvbl4fnqfw3ctlt6zbrir4kqwmjo5im6rf4q5si27kgo2i";
+    const walUrl = await walGateway?.buildUrl(walStore?._url, testKey);
+    await walGateway?.start(walStore?._url);
+    const walTestDataString = JSON.stringify({
+      operations: [],
+      noLoaderOps: [],
+      fileOperations: [],
+    });
+    const walEncoder = new TextEncoder();
+    const walTestData = walEncoder.encode(walTestDataString);
+    await walGateway?.put(walUrl?.Ok(), walTestData);
+    const walGetResult = await walGateway?.get(walUrl?.Ok());
+    const okResult = walGetResult?.Ok();
+    const decodedResult = new TextDecoder().decode(okResult);
+    expect(decodedResult).toEqual(walTestDataString);
+  });
+
+  it("should delete data from WAL Gateway", async function () {
+    const testKey = "bafkreidxwt2nhvbl4fnqfw3ctlt6zbrir4kqwmjo5im6rf4q5si27kgo2i";
+    const walUrl = await walGateway?.buildUrl(walStore?._url, testKey);
+    await walGateway?.start(walStore?._url);
+    const walTestDataString = JSON.stringify({
+      operations: [],
+      noLoaderOps: [],
+      fileOperations: [],
+    });
+    const walEncoder = new TextEncoder();
+    const walTestData = walEncoder.encode(walTestDataString);
+    await walGateway?.put(walUrl?.Ok(), walTestData);
+    const walDeleteResult = await walGateway?.delete(walUrl?.Ok());
+    expect(walDeleteResult?.Ok()).toBeFalsy();
+  });
+
+  it("should close WAL Gateway", async function () {
+    await walGateway?.start(walStore?._url);
+    await walGateway?.close(walStore?._url);
+  });
+
+  it("should have correct CAR Gateway properties", async function () {
+    // CAR Gateway assertions
+    expect(carGateway?.fidLength).toBe(4);
+    expect(carGateway?.headerSize).toBe(36);
+    expect(carGateway?.logger._attributes).toHaveProperty("module");
+    expect(carGateway?.logger._attributes).toHaveProperty("url");
+  });
+
+  it("should have correct Meta Gateway properties", async function () {
+    // Meta Gateway assertions
+    expect(metaGateway?.fidLength).toBe(4);
+    expect(metaGateway?.headerSize).toBe(36);
+    expect(metaGateway?.logger._attributes).toHaveProperty("module");
+    expect(metaGateway?.logger._attributes).not.toHaveProperty("url");
+  });
+
+  it("should have correct File Gateway properties", async function () {
+    // File Gateway assertions
+    expect(fileGateway?.fidLength).toBe(4);
+    expect(fileGateway?.headerSize).toBe(36);
+    expect(fileGateway?.logger._attributes).toHaveProperty("module");
+    expect(fileGateway?.logger._attributes).toHaveProperty("url");
+  });
+
+  it("should have correct WAL Gateway properties", async function () {
+    // WAL Gateway assertions
+    expect(walGateway?.fidLength).toBe(4);
+    expect(walGateway?.headerSize).toBe(36);
+    expect(walGateway?.logger._attributes).toHaveProperty("module");
+    expect(walGateway?.logger._attributes).not.toHaveProperty("url");
+  });
+});
+
+describe("noop Gateway subscribe", function () {
+  let db: Database;
+
+  let metaStore: ExtendedStore;
+
+  let metaGateway: ExtendedGateway;
+
+  afterEach(async function () {
+    await db.close();
+    await db.destroy();
+  });
+  beforeEach(async function () {
+    db = new Database("test-gateway-" + Math.random().toString(36).substring(7));
+
+    // Extract stores from the loader
+    metaStore = (await db.blockstore.loader?.metaStore()) as unknown as ExtendedStore;
+
+    metaGateway = metaStore?.gateway;
+  });
+  it("should subscribe to meta Gateway", async function () {
+    const metaUrl = await metaGateway?.buildUrl(metaStore?._url, "main");
+    await metaGateway?.start(metaStore?._url);
+
+    let resolve: () => void;
+    let didCall = false;
+    const p = new Promise<void>((r) => {
+      resolve = r;
+    });
+    const metaSubscribeResult = await metaGateway?.subscribe?.(metaUrl?.Ok(), async (data: Uint8Array) => {
+      const decodedData = new TextDecoder().decode(data);
+      expect(decodedData).toContain("[]");
+      didCall = true;
+      resolve();
+    });
+    if (!metaSubscribeResult?.isErr()) {
+      expect(metaSubscribeResult?.Ok()).toBeTruthy();
+      const ok = await db.put({ _id: "key1", hello: "world1" });
+      expect(ok).toBeTruthy();
+      expect(ok.id).toBe("key1");
+      await p;
+      expect(didCall).toBeTruthy();
+    }
+  });
+});
+
+describe("Gateway", function () {
+  let db: Database;
+  // let carStore: ExtendedStore;
+  let metaStore: ExtendedStore;
+  // let fileStore: ExtendedStore;
+  // let walStore: ExtendedStore;
+  // let carGateway: ExtendedGateway;
+  let metaGateway: ExtendedGateway;
+  // let fileGateway: ExtendedGateway;
+  // let walGateway: ExtendedGateway;
+
+  afterEach(async function () {
+    await db.close();
+    await db.destroy();
+  });
+  beforeEach(async function () {
+    db = new Database("test-gateway-" + Math.random().toString(36).substring(7));
+    const ok = await db.put({ _id: "test", foo: "bar" });
+    expect(ok).toBeTruthy();
+    expect(ok.id).toBe("test");
+
+    // Extract stores from the loader
+    // carStore = (await db.blockstore.loader?.carStore()) as unknown as ExtendedStore;
+    metaStore = (await db.blockstore.loader?.metaStore()) as unknown as ExtendedStore;
+    // fileStore = (await db.blockstore.loader?.fileStore()) as unknown as ExtendedStore;
+    // walStore = (await db.blockstore.loader?.WALStore()) as unknown as ExtendedStore;
+
+    // Extract and log gateways
+    // carGateway = carStore?.gateway;
+    metaGateway = metaStore?.gateway;
+    // fileGateway = fileStore?.gateway;
+    // walGateway = walStore?.gateway;
+  });
+
+  it("should get data from Meta Gateway", async function () {
+    const metaUrl = await metaGateway?.buildUrl(metaStore?._url, "main");
+    await metaGateway?.start(metaStore?._url);
+    const metaGetResult = await metaGateway?.get(metaUrl?.Ok());
+    const metaGetResultOk = metaGetResult?.Ok();
+    const decodedMetaGetResultOk = new TextDecoder().decode(metaGetResultOk);
+    expect(decodedMetaGetResultOk).toContain("parents");
+  });
+
+  it("should delete data from Meta Gateway", async function () {
+    const metaUrl = await metaGateway?.buildUrl(metaStore?._url, "main");
+    await metaGateway?.start(metaStore?._url);
+    // should we be testing .destroy() instead?
+    const metaDeleteResult = await metaGateway?.delete(metaUrl?.Ok());
+    expect(metaDeleteResult?.Ok()).toBeFalsy();
+  });
+});