test(client): Add basic unit tests for client code

package.json

@@ -64,6 +64,7 @@
     "@types/react-addons-linked-state-mixin": "^0.14.22",
     "css-loader": "^6.7.1",
     "jest": "^29.2.0",
+    "jest-canvas-mock": "^2.5.2",
     "mkdirp": "^1.0.3",
     "npm-run-all2": "^7.0.1",
     "rimraf": "^5.0.1",

src/__tests__/collection.spec.ts

@@ -0,0 +1,51 @@
+import { PairMap } from "../collection";
+
+describe("PairMap", () => {
+  it("sets and gets values with primitive keys", () => {
+    const map = new PairMap<number, string, string>();
+    map.set([1, "a"], "value1");
+    expect(map.get([1, "a"])).toBe("value1");
+    expect(map.get([2, "a"])).toBeUndefined();
+  });
+
+  it("checks has, delete, and clear", () => {
+    const map = new PairMap<number, number, string>();
+    map.set([1, 2], "foo");
+    expect(map.has([1, 2])).toBe(true);
+    expect(map.delete([1, 2])).toBe(true);
+    expect(map.has([1, 2])).toBe(false);
+    map.set([3, 4], "bar");
+    map.clear();
+    expect(map.size).toBe(0);
+  });
+
+  it("returns correct size", () => {
+    const map = new PairMap<string, string, number>();
+    map.set(["a", "b"], 1);
+    map.set(["c", "d"], 2);
+    expect(map.size).toBe(2);
+    map.delete(["a", "b"]);
+    expect(map.size).toBe(1);
+  });
+
+  it("overwrites values for same key", () => {
+    const map = new PairMap<number, number, string>();
+    map.set([1, 2], "first");
+    map.set([1, 2], "second");
+    expect(map.get([1, 2])).toBe("second");
+    expect(map.size).toBe(1);
+  });
+
+  it("iterates with forEach", () => {
+    const map = new PairMap<number, number, string>();
+    map.set([1, 2], "a");
+    map.set([3, 4], "b");
+    const entries: Array<[[number, number], string]> = [];
+    map.forEach((value, key) => {
+      entries.push([key, value]);
+    });
+    expect(entries).toContainEqual([[1, 2], "a"]);
+    expect(entries).toContainEqual([[3, 4], "b"]);
+    expect(entries.length).toBe(2);
+  });
+});

src/__tests__/model.spec.ts

@@ -0,0 +1,72 @@
+import "jest-canvas-mock";
+
+import { tableFromArrays } from "apache-arrow";
+import type * as Arrow from "apache-arrow";
+
+import { ArrowModel } from "../model";
+import { fetchStats, fetchTable } from "../requests";
+import type * as Req from "../requests";
+
+const MOCK_TABLE = tableFromArrays({
+  id: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
+  name: ["Alice", "Bob", "Charlie", "David", "Eve", "Frank", "Grace", "Hank", "Ivy", "Jack"],
+  age: [25, 30, 35, 40, 45, 50, 55, 60, 65, 70],
+  city: ["Paris", "London", "Ur", "Turin", "Rome", "Tokyo", "Boston", "Sydney", "Lima", "Cairo"],
+  score: [85, 90, 78, 92, 88, 76, 95, 81, 89, 93],
+});
+
+async function fetchStatsMocked(_params: Req.StatsParams): Promise<Req.StatsResponse> {
+  return {
+    num_rows: MOCK_TABLE.numRows,
+    num_cols: MOCK_TABLE.numCols,
+  };
+}
+
+async function fetchTableMocked(params: Req.TableParams): Promise<Arrow.Table> {
+  let table: Arrow.Table = MOCK_TABLE;
+
+  if (params.row_chunk !== undefined && params.row_chunk_size !== undefined) {
+    const start = params.row_chunk * params.row_chunk_size;
+    const end = start + params.row_chunk_size;
+    table = table.slice(start, end);
+  }
+
+  if (params.col_chunk !== undefined && params.col_chunk_size !== undefined) {
+    const colNames = table.schema.fields.map((field) => field.name);
+    const start = params.col_chunk * params.col_chunk_size;
+    const end = start + params.col_chunk_size;
+    const selectedCols = colNames.slice(start, end);
+    table = table.select(selectedCols);
+  }
+
+  return table;
+}
+
+jest.mock("../requests", () => ({
+  fetchTable: jest.fn(),
+  fetchStats: jest.fn(),
+}));
+
+describe("ArrowModel", () => {
+  (fetchTable as jest.Mock).mockImplementation(fetchTableMocked);
+  (fetchStats as jest.Mock).mockImplementation(fetchStatsMocked);
+
+  const model = new ArrowModel({ path: "test/path.parquet" });
+
+  it("should initialize data", async () => {
+    await model.ready;
+
+    expect(fetchStats).toHaveBeenCalledTimes(1);
+    // One for schema and once for data
+    expect(fetchTable).toHaveBeenCalledTimes(2);
+
+    expect(model.schema).toEqual(MOCK_TABLE.schema);
+    expect(model.columnCount("body")).toEqual(MOCK_TABLE.numCols);
+    expect(model.columnCount("row-header")).toEqual(1);
+    expect(model.rowCount("body")).toEqual(MOCK_TABLE.numRows);
+    expect(model.rowCount("column-header")).toEqual(1);
+
+    // First chunk is initialized
+    expect(model.data("body", 0, 0)).toEqual(MOCK_TABLE.getChildAt(0)?.get(0).toString());
+  });
+});

src/model.ts

@@ -43,7 +43,7 @@ export class ArrowModel extends DataModel {
     return this._ready;
   }
 
-  private get schema(): Arrow.Schema {
+  get schema(): Arrow.Schema {
     return this._schema;
   }