goldenmatch 0.1.0

package/tests/unit/hnsw-ann.test.ts

@@ -0,0 +1,283 @@
+import { describe, it, expect, vi } from "vitest";
+import {
+  ANNBlocker,
+  HNSWANNBlocker,
+  createANNBlocker,
+  type HNSWModule,
+  type HNSWIndexLike,
+} from "../../src/core/index.js";
+
+// ---------------------------------------------------------------------------
+// Mock hnswlib-node
+// ---------------------------------------------------------------------------
+
+/**
+ * Minimal in-memory stand-in for `hnswlib.HierarchicalNSW`. It records every
+ * init/add/search call so assertions can verify the fast-path is being used,
+ * and returns deterministic neighbours so pair assertions are stable.
+ */
+class MockIndex implements HNSWIndexLike {
+  public readonly points: Array<{ label: number; vec: number[] }> = [];
+  public initArgs: number[] | null = null;
+  public ef: number | null = null;
+  public searchCalls = 0;
+
+  constructor(public metric: string, public dim: number) {}
+
+  initIndex(
+    maxElements: number,
+    M?: number,
+    efConstruction?: number,
+    randomSeed?: number,
+  ): void {
+    this.initArgs = [maxElements, M ?? 16, efConstruction ?? 200, randomSeed ?? 100];
+  }
+
+  setEf(ef: number): void {
+    this.ef = ef;
+  }
+
+  addPoint(vector: number[] | Float32Array, labelId: number): void {
+    this.points.push({ label: labelId, vec: Array.from(vector) });
+  }
+
+  searchKnn(
+    _query: number[] | Float32Array,
+    k: number,
+  ): { distances: number[]; neighbors: number[] } {
+    this.searchCalls++;
+    const n = Math.min(k, this.points.length);
+    // Return the first n labels with small increasing distances. This makes
+    // the test deterministic without having to actually compute distances.
+    const neighbors: number[] = [];
+    const distances: number[] = [];
+    for (let i = 0; i < n; i++) {
+      neighbors.push(this.points[i]!.label);
+      distances.push(i * 0.1);
+    }
+    return { neighbors, distances };
+  }
+}
+
+function makeMockModule(): {
+  module: HNSWModule;
+  instances: MockIndex[];
+} {
+  const instances: MockIndex[] = [];
+  const module: HNSWModule = {
+    HierarchicalNSW: class extends MockIndex {
+      constructor(metric: string, dim: number) {
+        super(metric, dim);
+        instances.push(this);
+      }
+    } as unknown as HNSWModule["HierarchicalNSW"],
+  };
+  return { module, instances };
+}
+
+function vec(...nums: number[]): Float32Array {
+  return new Float32Array(nums);
+}
+
+// ---------------------------------------------------------------------------
+// HNSWANNBlocker — direct unit tests
+// ---------------------------------------------------------------------------
+
+describe("HNSWANNBlocker", () => {
+  it("buildIndex initialises the native index and adds every point", () => {
+    const { module, instances } = makeMockModule();
+    const blocker = new HNSWANNBlocker({
+      hnswModule: module,
+      topK: 3,
+      metric: "cosine",
+      M: 8,
+      efConstruction: 100,
+      efSearch: 42,
+    });
+    blocker.buildIndex([vec(1, 0, 0), vec(0, 1, 0), vec(0, 0, 1)]);
+    expect(instances).toHaveLength(1);
+    const idx = instances[0]!;
+    expect(idx.metric).toBe("cosine");
+    expect(idx.dim).toBe(3);
+    expect(idx.initArgs?.[1]).toBe(8); // M
+    expect(idx.initArgs?.[2]).toBe(100); // efConstruction
+    expect(idx.ef).toBe(42);
+    expect(idx.points.map((p) => p.label)).toEqual([0, 1, 2]);
+    expect(blocker.indexSize).toBe(3);
+  });
+
+  it("buildIndex with empty input clears the index", () => {
+    const { module } = makeMockModule();
+    const blocker = new HNSWANNBlocker({ hnswModule: module, topK: 3 });
+    blocker.buildIndex([]);
+    expect(blocker.indexSize).toBe(0);
+    expect(blocker.query([vec(1, 2, 3)])).toEqual([]);
+  });
+
+  it("maps 'euclidean' option to the 'l2' metric string", () => {
+    const { module, instances } = makeMockModule();
+    const blocker = new HNSWANNBlocker({
+      hnswModule: module,
+      metric: "euclidean",
+    });
+    blocker.buildIndex([vec(1, 0), vec(0, 1)]);
+    expect(instances[0]!.metric).toBe("l2");
+  });
+
+  it("query canonicalises pairs and drops self-matches", () => {
+    const { module } = makeMockModule();
+    const blocker = new HNSWANNBlocker({
+      hnswModule: module,
+      topK: 3,
+    });
+    blocker.buildIndex([vec(1, 0, 0), vec(0, 1, 0), vec(0, 0, 1)]);
+    const pairs = blocker.query([vec(1, 0, 0), vec(0, 1, 0), vec(0, 0, 1)]);
+    // MockIndex returns labels [0,1,2] for every query — after self-filter +
+    // canonicalisation we should get {0,1}, {0,2}, {1,2}.
+    const sorted = pairs.map(([a, b]) => `${a}-${b}`).sort();
+    expect(sorted).toEqual(["0-1", "0-2", "1-2"]);
+  });
+
+  it("queryWithScores converts cosine distance to similarity = 1 - d", () => {
+    const { module } = makeMockModule();
+    const blocker = new HNSWANNBlocker({
+      hnswModule: module,
+      topK: 3,
+      metric: "cosine",
+    });
+    blocker.buildIndex([vec(1, 0), vec(0, 1), vec(1, 1)]);
+    const scored = blocker.queryWithScores([vec(1, 0), vec(0, 1), vec(1, 1)]);
+    // Distances produced by MockIndex: 0, 0.1, 0.2 → similarities 1.0, 0.9, 0.8
+    // After dedup (best score kept per pair) all three unique pairs survive.
+    expect(scored).toHaveLength(3);
+    for (const [, , score] of scored) {
+      expect(score).toBeGreaterThanOrEqual(0.8 - 1e-6);
+      expect(score).toBeLessThanOrEqual(1.0 + 1e-6);
+    }
+  });
+
+  it("queryWithScores converts l2 distance to 1 / (1 + d)", () => {
+    const { module } = makeMockModule();
+    const blocker = new HNSWANNBlocker({
+      hnswModule: module,
+      topK: 2,
+      metric: "euclidean",
+    });
+    blocker.buildIndex([vec(0, 0), vec(1, 1)]);
+    const scored = blocker.queryWithScores([vec(0, 0), vec(1, 1)]);
+    // Best distance across the two queries for pair (0,1) is 0 → score 1.0.
+    expect(scored).toHaveLength(1);
+    const [, , score] = scored[0]!;
+    expect(score).toBeCloseTo(1.0, 6);
+  });
+
+  it("queryOne returns (neighbour, score) pairs", () => {
+    const { module } = makeMockModule();
+    const blocker = new HNSWANNBlocker({
+      hnswModule: module,
+      topK: 2,
+      metric: "cosine",
+    });
+    blocker.buildIndex([vec(1, 0), vec(0, 1), vec(1, 1)]);
+    const out = blocker.queryOne(vec(0.5, 0.5));
+    expect(out).toHaveLength(2);
+    // First mock neighbour has distance 0 → similarity 1.0.
+    expect(out[0]![1]).toBeCloseTo(1.0, 6);
+  });
+
+  it("addToIndex grows the index and returns sequential ids", () => {
+    const { module, instances } = makeMockModule();
+    const blocker = new HNSWANNBlocker({ hnswModule: module });
+    blocker.buildIndex([vec(1, 0), vec(0, 1)]);
+    const id1 = blocker.addToIndex(vec(1, 1));
+    const id2 = blocker.addToIndex(vec(0.5, 0.5));
+    expect(id1).toBe(2);
+    expect(id2).toBe(3);
+    expect(blocker.indexSize).toBe(4);
+    expect(instances[0]!.points).toHaveLength(4);
+  });
+
+  it("addToIndex before buildIndex throws", () => {
+    const { module } = makeMockModule();
+    const blocker = new HNSWANNBlocker({ hnswModule: module });
+    expect(() => blocker.addToIndex(vec(1, 2))).toThrow(/buildIndex/);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// createANNBlocker factory
+// ---------------------------------------------------------------------------
+
+describe("createANNBlocker", () => {
+  it("returns a brute-force ANNBlocker when useHNSW=false", async () => {
+    const blocker = await createANNBlocker({ useHNSW: false, topK: 5 });
+    expect(blocker).toBeInstanceOf(ANNBlocker);
+  });
+
+  it("returns a brute-force ANNBlocker with no options", async () => {
+    const blocker = await createANNBlocker();
+    expect(blocker).toBeInstanceOf(ANNBlocker);
+  });
+
+  it("uses the provided hnswModule when useHNSW=true", async () => {
+    const { module, instances } = makeMockModule();
+    const blocker = await createANNBlocker({
+      useHNSW: true,
+      hnswModule: module,
+      topK: 4,
+      metric: "cosine",
+    });
+    expect(blocker).toBeInstanceOf(HNSWANNBlocker);
+    blocker.buildIndex([vec(1, 0), vec(0, 1)]);
+    expect(instances).toHaveLength(1);
+  });
+
+  it("falls back to brute-force when hnswlib-node is not installed", async () => {
+    const warnings: string[] = [];
+    const blocker = await createANNBlocker({
+      useHNSW: true,
+      onFallbackWarning: (m) => warnings.push(m),
+    });
+    // hnswlib-node is not in devDependencies, so the dynamic import fails.
+    expect(blocker).toBeInstanceOf(ANNBlocker);
+    expect(warnings).toHaveLength(1);
+    expect(warnings[0]).toMatch(/hnswlib-node/);
+  });
+
+  it("forwards tuning knobs to HNSWANNBlocker", async () => {
+    const { module, instances } = makeMockModule();
+    const blocker = await createANNBlocker({
+      useHNSW: true,
+      hnswModule: module,
+      topK: 7,
+      metric: "euclidean",
+      M: 24,
+      efConstruction: 300,
+      efSearch: 77,
+      maxElements: 500,
+    });
+    expect(blocker).toBeInstanceOf(HNSWANNBlocker);
+    blocker.buildIndex([vec(1, 2), vec(3, 4)]);
+    const idx = instances[0]!;
+    expect(idx.metric).toBe("l2");
+    expect(idx.initArgs?.[0]).toBe(500); // maxElements
+    expect(idx.initArgs?.[1]).toBe(24); // M
+    expect(idx.initArgs?.[2]).toBe(300); // efConstruction
+    expect(idx.ef).toBe(77);
+  });
+
+  it("silences the warn sink via onFallbackWarning", async () => {
+    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+    try {
+      await createANNBlocker({
+        useHNSW: true,
+        onFallbackWarning: () => {
+          // swallow
+        },
+      });
+      expect(warnSpy).not.toHaveBeenCalled();
+    } finally {
+      warnSpy.mockRestore();
+    }
+  });
+});

package/tests/unit/hubspot-connector.test.ts

@@ -0,0 +1,118 @@
+import {
+  describe,
+  it,
+  expect,
+  vi,
+  beforeEach,
+  afterEach,
+} from "vitest";
+import { createHubSpotConnector } from "../../src/node/connectors/hubspot.js";
+
+let fetchMock: ReturnType<typeof vi.fn>;
+
+beforeEach(() => {
+  fetchMock = vi.fn();
+  vi.stubGlobal("fetch", fetchMock);
+});
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+});
+
+function jsonResponse(body: unknown): Response {
+  return {
+    ok: true,
+    status: 200,
+    text: async () => "",
+    json: async () => body,
+  } as Response;
+}
+
+describe("createHubSpotConnector", () => {
+  it("returns connector with proper shape", () => {
+    const c = createHubSpotConnector({ apiKey: "key" });
+    expect(c.name).toBe("hubspot");
+    expect(typeof c.connect).toBe("function");
+    expect(typeof c.read).toBe("function");
+    expect(typeof c.close).toBe("function");
+  });
+
+  it("connect() is a no-op (no fetch)", async () => {
+    const c = createHubSpotConnector({ apiKey: "key" });
+    await c.connect();
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+
+  it("throws when called with raw SQL string", async () => {
+    const c = createHubSpotConnector({ apiKey: "key" });
+    await expect(c.read("SELECT * FROM contacts")).rejects.toThrow(
+      /object query/i,
+    );
+  });
+
+  it("read() returns rows merging id + properties", async () => {
+    fetchMock.mockResolvedValueOnce(
+      jsonResponse({
+        results: [
+          { id: "1", properties: { firstname: "Ada", lastname: "Lovelace" } },
+          { id: "2", properties: { firstname: "Alan", lastname: "Turing" } },
+        ],
+      }),
+    );
+    const c = createHubSpotConnector({ apiKey: "key" });
+    const rows = await c.read({
+      table: "contacts",
+      columns: ["firstname", "lastname"],
+      limit: 50,
+    });
+    expect(rows.length).toBe(2);
+    expect(rows[0]!.id).toBe("1");
+    expect(rows[0]!.firstname).toBe("Ada");
+    expect(rows[1]!.lastname).toBe("Turing");
+
+    const url = fetchMock.mock.calls[0]![0] as string;
+    expect(url).toContain("/crm/v3/objects/contacts");
+    expect(url).toContain("limit=50");
+    expect(url).toContain("properties=firstname,lastname");
+
+    const init = fetchMock.mock.calls[0]![1] as RequestInit;
+    expect((init.headers as Record<string, string>).Authorization).toBe(
+      "Bearer key",
+    );
+  });
+
+  it("paginates via paging.next.link", async () => {
+    fetchMock
+      .mockResolvedValueOnce(
+        jsonResponse({
+          results: [{ id: "1", properties: { name: "A" } }],
+          paging: { next: { link: "https://api.hubapi.com/crm/v3/objects/contacts?after=abc" } },
+        }),
+      )
+      .mockResolvedValueOnce(
+        jsonResponse({
+          results: [{ id: "2", properties: { name: "B" } }],
+        }),
+      );
+
+    const c = createHubSpotConnector({ apiKey: "key" });
+    const rows = await c.read({ table: "contacts" });
+    expect(rows.length).toBe(2);
+    expect(fetchMock).toHaveBeenCalledTimes(2);
+    const secondUrl = fetchMock.mock.calls[1]![0] as string;
+    expect(secondUrl).toContain("after=abc");
+  });
+
+  it("throws on non-2xx response", async () => {
+    fetchMock.mockResolvedValueOnce({
+      ok: false,
+      status: 403,
+      text: async () => "forbidden",
+      json: async () => ({}),
+    } as Response);
+    const c = createHubSpotConnector({ apiKey: "key" });
+    await expect(c.read({ table: "contacts" })).rejects.toThrow(
+      /HubSpot query failed/,
+    );
+  });
+});

package/tests/unit/ingest.test.ts

@@ -0,0 +1,97 @@
+import { describe, it, expect } from "vitest";
+import {
+  applyColumnMap,
+  validateColumns,
+  concatRows,
+  tagSource,
+  assignRowIds,
+} from "../../src/core/ingest.js";
+import type { Row } from "../../src/core/types.js";
+
+describe("applyColumnMap", () => {
+  it("renames columns per the map", () => {
+    const rows: Row[] = [
+      { first: "Alice", last: "Brown", email: "a@x.com" },
+      { first: "Bob", last: "Smith", email: "b@x.com" },
+    ];
+    const out = applyColumnMap(rows, { first: "first_name", last: "last_name" });
+    expect(Object.keys(out[0]!).sort()).toEqual(
+      ["email", "first_name", "last_name"].sort(),
+    );
+    expect(out[0]!["first_name"]).toBe("Alice");
+    expect(out[0]!["last_name"]).toBe("Brown");
+  });
+
+  it("passes unmapped keys through untouched", () => {
+    const rows: Row[] = [{ a: 1, b: 2 }];
+    const out = applyColumnMap(rows, { a: "aa" });
+    expect(out[0]!["aa"]).toBe(1);
+    expect(out[0]!["b"]).toBe(2);
+  });
+
+  it("empty map clones rows unchanged", () => {
+    const rows: Row[] = [{ a: 1 }];
+    const out = applyColumnMap(rows, {});
+    expect(out).toEqual(rows);
+    // Different reference (shallow clone).
+    expect(out[0]).not.toBe(rows[0]);
+  });
+});
+
+describe("validateColumns", () => {
+  it("passes when all required columns are present", () => {
+    const rows: Row[] = [{ a: 1, b: 2, c: 3 }];
+    expect(() => validateColumns(rows, ["a", "b"])).not.toThrow();
+  });
+
+  it("throws with the missing columns listed", () => {
+    const rows: Row[] = [{ a: 1 }];
+    expect(() => validateColumns(rows, ["a", "b", "c"])).toThrow(
+      /Required columns missing:.*b.*c/,
+    );
+  });
+
+  it("no-ops on empty input", () => {
+    expect(() => validateColumns([], ["a"])).not.toThrow();
+  });
+});
+
+describe("concatRows", () => {
+  it("unions schemas and fills missing fields with null", () => {
+    const a: Row[] = [{ x: 1, y: 2 }];
+    const b: Row[] = [{ y: 3, z: 4 }];
+    const out = concatRows([a, b]);
+    expect(out.length).toBe(2);
+    // Both rows have all keys from union.
+    expect(Object.keys(out[0]!).sort()).toEqual(["x", "y", "z"]);
+    expect(Object.keys(out[1]!).sort()).toEqual(["x", "y", "z"]);
+    expect(out[0]!["z"]).toBeNull(); // missing in a
+    expect(out[1]!["x"]).toBeNull(); // missing in b
+    expect(out[0]!["x"]).toBe(1);
+    expect(out[1]!["z"]).toBe(4);
+  });
+
+  it("handles empty arrays gracefully", () => {
+    const out = concatRows([]);
+    expect(out).toEqual([]);
+    const out2 = concatRows([[], []]);
+    expect(out2).toEqual([]);
+  });
+});
+
+describe("tagSource / assignRowIds", () => {
+  it("tagSource adds __source__ to each row", () => {
+    const rows: Row[] = [{ a: 1 }, { a: 2 }];
+    const out = tagSource(rows, "csv_a");
+    expect(out[0]!["__source__"]).toBe("csv_a");
+    expect(out[1]!["__source__"]).toBe("csv_a");
+  });
+
+  it("assignRowIds fills missing __row_id__ with sequential ids", () => {
+    const rows: Row[] = [{ a: 1 }, { a: 2, __row_id__: 99 }, { a: 3 }];
+    const out = assignRowIds(rows, 10);
+    expect(out[0]!["__row_id__"]).toBe(10);
+    expect(out[1]!["__row_id__"]).toBe(99); // existing preserved
+    expect(out[2]!["__row_id__"]).toBe(12);
+  });
+});

package/tests/unit/learned-blocking.test.ts

@@ -0,0 +1,134 @@
+import { describe, it, expect } from "vitest";
+import {
+  learnBlockingRules,
+  applyLearnedBlocks,
+} from "../../src/core/learned-blocking.js";
+import type { Row, ScoredPair } from "../../src/core/types.js";
+
+// Build a small dataset where known duplicate pairs share last-name/email prefixes
+// so predicates like equal-on-last-name or soundex actually discriminate.
+function makeDataset(): { rows: Row[]; pairs: ScoredPair[] } {
+  const dupeGroups: Array<[string, string][]> = [
+    [["John", "Smith"], ["Jon", "Smith"]],
+    [["Mary", "Jones"], ["Marie", "Jones"]],
+    [["Alice", "Brown"], ["Alicia", "Brown"]],
+    [["Bob", "Miller"], ["Robert", "Miller"]],
+    [["Carol", "Davis"], ["Caroline", "Davis"]],
+  ];
+  // Plus distractor rows to give the predicate some reduction work to do.
+  const distractorLasts = [
+    "Zygmunt", "Xiong", "Petrov", "Kowalski", "Nakamura",
+    "Rasmussen", "Tanaka", "Vasquez", "Wojcik", "Yamamoto",
+  ];
+  const rows: Row[] = [];
+  let id = 0;
+  const pairs: ScoredPair[] = [];
+  for (const pair of dupeGroups) {
+    const idA = id++;
+    rows.push({ __row_id__: idA, first_name: pair[0]![0], last_name: pair[0]![1] });
+    const idB = id++;
+    rows.push({ __row_id__: idB, first_name: pair[1]![0], last_name: pair[1]![1] });
+    pairs.push({ idA, idB, score: 1.0 });
+  }
+  for (const last of distractorLasts) {
+    rows.push({ __row_id__: id++, first_name: `First${id}`, last_name: last });
+  }
+  return { rows, pairs };
+}
+
+describe("learnBlockingRules", () => {
+  it("produces predicates for a dataset with known matching pairs", () => {
+    const { rows, pairs } = makeDataset();
+    const rules = learnBlockingRules(rows, pairs, ["first_name", "last_name"], {
+      minRecall: 0.8,
+      minReduction: 0.5,
+      predicateDepth: 3,
+    });
+    expect(rules.predicates.length).toBeGreaterThan(0);
+    expect(rules.predicates.length).toBeLessThanOrEqual(3);
+    // Every selected predicate should have positive recall.
+    for (const p of rules.predicates) expect(p.recall).toBeGreaterThan(0);
+    expect(rules.minRecall).toBe(0.8);
+    expect(rules.minReduction).toBe(0.5);
+    expect(typeof rules.learnedAt).toBe("string");
+  });
+
+  it("learned predicates cover at least one of the known pairs (useful recall)", () => {
+    const { rows, pairs } = makeDataset();
+    const rules = learnBlockingRules(rows, pairs, ["last_name"], {
+      minRecall: 0.95,
+      minReduction: 0.5,
+      predicateDepth: 3,
+    });
+    // At least one predicate should retain some useful recall.
+    const bestRecall = Math.max(...rules.predicates.map((p) => p.recall));
+    expect(bestRecall).toBeGreaterThan(0);
+  });
+
+  it("empty known-pair input returns rules with no predicates (graceful fallback)", () => {
+    const { rows } = makeDataset();
+    const rules = learnBlockingRules(rows, [], ["first_name", "last_name"]);
+    expect(rules.predicates).toEqual([]);
+  });
+
+  it("is deterministic given the same inputs", () => {
+    const { rows, pairs } = makeDataset();
+    const r1 = learnBlockingRules(rows, pairs, ["first_name", "last_name"]);
+    const r2 = learnBlockingRules(rows, pairs, ["first_name", "last_name"]);
+    expect(r1.predicates.length).toBe(r2.predicates.length);
+    for (let i = 0; i < r1.predicates.length; i++) {
+      expect(r1.predicates[i]!.type).toBe(r2.predicates[i]!.type);
+      expect(r1.predicates[i]!.field).toBe(r2.predicates[i]!.field);
+      expect(r1.predicates[i]!.recall).toBeCloseTo(r2.predicates[i]!.recall, 10);
+      expect(r1.predicates[i]!.reduction).toBeCloseTo(
+        r2.predicates[i]!.reduction,
+        10,
+      );
+    }
+  });
+});
+
+describe("applyLearnedBlocks", () => {
+  it("produces BlockResult[] from learned rules with rows >= 2", () => {
+    const { rows, pairs } = makeDataset();
+    const rules = learnBlockingRules(rows, pairs, ["last_name"]);
+    const blocks = applyLearnedBlocks(rows, rules, 100);
+    for (const b of blocks) {
+      expect(b.rows.length).toBeGreaterThanOrEqual(2);
+      expect(b.strategy).toBe("learned");
+      expect(b.blockKey.startsWith("learned:")).toBe(true);
+    }
+    // Each duplicate pair should share at least one block.
+    if (blocks.length > 0) {
+      const groupsById = new Map<number, Set<string>>();
+      for (const b of blocks) {
+        for (const r of b.rows) {
+          const id = r["__row_id__"] as number;
+          let set = groupsById.get(id);
+          if (!set) {
+            set = new Set();
+            groupsById.set(id, set);
+          }
+          set.add(b.blockKey);
+        }
+      }
+      // Sanity: if a useful predicate was chosen, the first dupe pair shares a key.
+      const a = groupsById.get(0);
+      const b = groupsById.get(1);
+      if (a && b) {
+        const shared = [...a].some((k) => b.has(k));
+        expect(shared).toBe(true);
+      }
+    }
+  });
+
+  it("returns empty array when rules contain no predicates", () => {
+    const { rows } = makeDataset();
+    const blocks = applyLearnedBlocks(
+      rows,
+      { predicates: [], minRecall: 0.9, minReduction: 0.9, learnedAt: "" },
+      100,
+    );
+    expect(blocks).toEqual([]);
+  });
+});