@planet-matrix/mobius-model 0.5.0 → 0.9.0

package/tests/unit/storage/table.spec.ts

@@ -0,0 +1,620 @@
+import { expect, test } from "vitest"
+
+import { BaseTable } from "#Source/storage/index.ts"
+
+interface TestRow extends Record<string, unknown> {
+  id: string
+  label: string
+  count: number
+  meta: {
+    rank: number
+  }
+  status?: string
+}
+
+class TestTable extends BaseTable<TestRow> {
+  // No additional implementation needed for testing BaseTable functionality
+}
+
+const createTestTable = (): TestTable => {
+  return new TestTable({
+    uniqueGetter: (row) => row.id,
+  })
+}
+
+const createRow = (overrides: Partial<TestRow> = {}): TestRow => {
+  return {
+    id: "row-1",
+    label: "alpha",
+    count: 1,
+    meta: {
+      rank: 1,
+    },
+    status: "kept",
+    ...overrides,
+  }
+}
+
+const createRows = (): [TestRow, TestRow, TestRow] => {
+  return [
+    createRow(),
+    createRow({
+      id: "row-2",
+      label: "beta",
+      count: 2,
+      meta: {
+        rank: 2,
+      },
+      status: "held",
+    }),
+    createRow({
+      id: "row-3",
+      label: "gamma",
+      count: 3,
+      meta: {
+        rank: 3,
+      },
+      status: "fresh",
+    }),
+  ]
+}
+
+test("BaseTable.clearTable removes all rows and emits an empty snapshot", async () => {
+  const table = createTestTable()
+  const [rowA, rowB] = createRows()
+  const snapshots: TestRow[][] = []
+
+  await table.safeInsertRows([rowA, rowB])
+  table.event.subscribe("valueChanged", (rows) => {
+    snapshots.push(rows)
+  })
+
+  await table.clearTable()
+
+  expect(snapshots).toHaveLength(1)
+  expect(snapshots[0]).toEqual([])
+
+  snapshots[0]?.push(createRow({ id: "extra" }))
+
+  expect(await table.getRows(() => true)).toEqual([])
+  expect(snapshots[0]).toEqual([createRow({ id: "extra" })])
+})
+
+test("BaseTable.getRow returns a cloned row and keeps predicate mutations isolated", async () => {
+  const table = createTestTable()
+  const [rowA] = createRows()
+
+  await table.safeInsertRow(rowA)
+
+  const foundRow = await table.getRow((row) => {
+    row.label = "mutated-in-getter"
+    row.meta.rank = 99
+    return row.id === rowA.id
+  })
+
+  foundRow!.label = "mutated-in-result"
+  foundRow!.meta.rank = 100
+
+  expect(foundRow).toEqual({
+    ...rowA,
+    label: "mutated-in-result",
+    meta: {
+      rank: 100,
+    },
+  })
+  expect(await table.getRow((row) => row.id === rowA.id)).toEqual(rowA)
+})
+
+test("BaseTable.getRows returns cloned rows and keeps predicate mutations isolated", async () => {
+  const table = createTestTable()
+  const [rowA, rowB, rowC] = createRows()
+
+  await table.safeInsertRows([rowA, rowB, rowC])
+
+  const foundRows = await table.getRows((row) => {
+    row.status = "mutated"
+    return row.count >= 2
+  })
+
+  foundRows[0]!.status = "changed-after-read"
+
+  expect(foundRows).toEqual([
+    {
+      ...rowB,
+      status: "changed-after-read",
+    },
+    rowC,
+  ])
+  expect(await table.getRows((row) => row.count >= 2)).toEqual([rowB, rowC])
+})
+
+test("BaseTable.safeInsertRow inserts one row, emits snapshots, and rejects duplicate uniques", async () => {
+  const table = createTestTable()
+  const [rowA] = createRows()
+  const snapshots: TestRow[][] = []
+
+  table.event.subscribe("valueChanged", (rows) => {
+    snapshots.push(rows)
+  })
+
+  const insertedRow = await table.safeInsertRow(rowA)
+  insertedRow.meta.rank = 100
+  snapshots[0]![0]!.label = "mutated-snapshot"
+
+  await expect(table.safeInsertRow(rowA)).rejects.toThrow('Row with unique "row-1" already exists')
+  expect(await table.getRow((row) => row.id === rowA.id)).toEqual(rowA)
+  expect(snapshots).toHaveLength(1)
+})
+
+test("BaseTable.insertRow returns undefined for duplicate uniques and inserts missing rows", async () => {
+  const table = createTestTable()
+  const [rowA, rowB] = createRows()
+
+  await table.safeInsertRow(rowA)
+
+  expect(await table.insertRow(rowA)).toBeUndefined()
+  expect(await table.insertRow(rowB)).toEqual(rowB)
+  expect(await table.getRows(() => true)).toEqual([rowA, rowB])
+})
+
+test("BaseTable.safeInsertRows inserts a batch and rejects duplicate uniques inside the batch", async () => {
+  const table = createTestTable()
+  const [rowA, rowB] = createRows()
+  const duplicateBatch = [
+    rowA,
+    createRow({
+      id: rowA.id,
+      label: "duplicate",
+      count: 9,
+      meta: {
+        rank: 9,
+      },
+    }),
+  ]
+
+  const insertedRows = await table.safeInsertRows([rowA, rowB])
+  insertedRows[0]!.meta.rank = 100
+
+  await expect(table.safeInsertRows(duplicateBatch)).rejects.toThrow('Duplicate row unique "row-1" found in batch')
+  expect(await table.getRows(() => true)).toEqual([rowA, rowB])
+})
+
+test("BaseTable.safeSimpleUpdateRow returns the merged stored row", async () => {
+  const table = createTestTable()
+  const [rowA] = createRows()
+
+  await table.safeInsertRow(rowA)
+
+  const updatedRow = await table.safeSimpleUpdateRow({
+    id: rowA.id,
+    label: "beta",
+    count: 8,
+    meta: {
+      rank: 8,
+    },
+  })
+
+  expect(updatedRow).toEqual({
+    ...rowA,
+    label: "beta",
+    count: 8,
+    meta: {
+      rank: 8,
+    },
+  })
+  expect(await table.getRow((row) => row.id === rowA.id)).toEqual(updatedRow)
+})
+
+test("BaseTable.simpleUpdateRow returns merged rows and undefined for missing uniques", async () => {
+  const table = createTestTable()
+  const [rowA] = createRows()
+
+  await table.safeInsertRow(rowA)
+
+  expect(await table.simpleUpdateRow({
+    id: rowA.id,
+    label: "simple",
+    count: 6,
+    meta: {
+      rank: 6,
+    },
+  })).toEqual({
+    ...rowA,
+    label: "simple",
+    count: 6,
+    meta: {
+      rank: 6,
+    },
+  })
+  expect(await table.simpleUpdateRow(createRow({ id: "missing" }))).toBeUndefined()
+})
+
+test("BaseTable.safeSimpleUpdateRows merges each row and rejects duplicate batch uniques", async () => {
+  const table = createTestTable()
+  const [rowA, rowB] = createRows()
+
+  await table.safeInsertRows([rowA, rowB])
+
+  const updatedRows = await table.safeSimpleUpdateRows([
+    {
+      id: rowA.id,
+      label: "alpha-updated",
+      count: 11,
+      meta: {
+        rank: 11,
+      },
+    },
+    {
+      id: rowB.id,
+      label: "beta-updated",
+      count: 12,
+      meta: {
+        rank: 12,
+      },
+    },
+  ])
+
+  expect(updatedRows).toEqual([
+    {
+      ...rowA,
+      label: "alpha-updated",
+      count: 11,
+      meta: {
+        rank: 11,
+      },
+    },
+    {
+      ...rowB,
+      label: "beta-updated",
+      count: 12,
+      meta: {
+        rank: 12,
+      },
+    },
+  ])
+
+  await expect(table.safeSimpleUpdateRows([
+    createRow({ id: rowA.id }),
+    createRow({ id: rowA.id, label: "duplicate" }),
+  ])).rejects.toThrow('Duplicate row unique "row-1" found in batch')
+})
+
+test("BaseTable.safeUpdateRow updates one matching row and rejects invalid transitions", async () => {
+  const table = createTestTable()
+  const [rowA] = createRows()
+
+  await table.safeInsertRow(rowA)
+
+  const updatedRow = await table.safeUpdateRow(
+    (row) => row.id === rowA.id,
+    (row) => ({
+      ...row,
+      label: "updated",
+      count: row.count + 5,
+      meta: {
+        rank: row.meta.rank + 5,
+      },
+    }),
+  )
+
+  expect(updatedRow).toEqual({
+    ...rowA,
+    label: "updated",
+    count: 6,
+    meta: {
+      rank: 6,
+    },
+  })
+  await expect(table.safeUpdateRow(
+    (row) => row.id === "missing",
+    (row) => row,
+  )).rejects.toThrow("Row not found.")
+  await expect(table.safeUpdateRow(
+    (row) => row.id === rowA.id,
+    (row) => ({
+      ...row,
+      id: "changed",
+    }),
+  )).rejects.toThrow("Unique cannot be changed")
+})
+
+test("BaseTable.updateRow returns undefined when no row matches or the unique changes", async () => {
+  const table = createTestTable()
+  const [rowA] = createRows()
+
+  await table.safeInsertRow(rowA)
+
+  expect(await table.updateRow(
+    (row) => row.id === rowA.id,
+    (row) => ({
+      ...row,
+      label: "updated-by-updateRow",
+    }),
+  )).toEqual({
+    ...rowA,
+    label: "updated-by-updateRow",
+  })
+  expect(await table.updateRow(
+    (row) => row.id === "missing",
+    (row) => row,
+  )).toBeUndefined()
+  expect(await table.updateRow(
+    (row) => row.id === rowA.id,
+    (row) => ({
+      ...row,
+      id: "changed",
+    }),
+  )).toBeUndefined()
+})
+
+test("BaseTable.updateRows updates all matching rows and isolates predicate mutations", async () => {
+  const table = createTestTable()
+  const [rowA, rowB, rowC] = createRows()
+
+  await table.safeInsertRows([rowA, rowB, rowC])
+
+  const updatedRows = await table.updateRows(
+    (row) => {
+      row.status = "mutated-in-getter"
+      return row.count >= 2
+    },
+    (row) => ({
+      ...row,
+      count: row.count + 10,
+    }),
+  )
+
+  expect(updatedRows).toEqual([
+    {
+      ...rowB,
+      count: 12,
+    },
+    {
+      ...rowC,
+      count: 13,
+    },
+  ])
+  expect(await table.getRow((row) => row.id === rowA.id)).toEqual(rowA)
+
+  await expect(table.updateRows(
+    () => true,
+    (row) => ({
+      ...row,
+      id: `${row.id}-changed`,
+    }),
+  )).rejects.toThrow("Unique cannot be changed")
+})
+
+test("BaseTable.upsertRow inserts new rows and returns merged stored rows for updates", async () => {
+  const table = createTestTable()
+  const [rowA, rowB] = createRows()
+
+  expect(await table.upsertRow(rowA)).toEqual(rowA)
+  expect(await table.upsertRow({
+    id: rowA.id,
+    label: "upserted",
+    count: 20,
+    meta: {
+      rank: 20,
+    },
+  })).toEqual({
+    ...rowA,
+    label: "upserted",
+    count: 20,
+    meta: {
+      rank: 20,
+    },
+  })
+  expect(await table.upsertRow(rowB)).toEqual(rowB)
+})
+
+test("BaseTable.upsertRows returns merged stored rows and rejects duplicate batch uniques", async () => {
+  const table = createTestTable()
+  const [rowA, rowB] = createRows()
+
+  await table.safeInsertRow(rowA)
+
+  expect(await table.upsertRows([
+    {
+      id: rowA.id,
+      label: "merged",
+      count: 21,
+      meta: {
+        rank: 21,
+      },
+    },
+    rowB,
+  ])).toEqual([
+    {
+      ...rowA,
+      label: "merged",
+      count: 21,
+      meta: {
+        rank: 21,
+      },
+    },
+    rowB,
+  ])
+
+  await expect(table.upsertRows([
+    createRow({ id: rowA.id }),
+    createRow({ id: rowA.id, label: "duplicate" }),
+  ])).rejects.toThrow('Duplicate row unique "row-1" found in batch')
+})
+
+test("BaseTable.safeSimpleDeleteRow deletes by unique and returns the stored row", async () => {
+  const table = createTestTable()
+  const [rowA] = createRows()
+
+  await table.safeInsertRow(rowA)
+
+  expect(await table.safeSimpleDeleteRow({
+    id: rowA.id,
+    label: "ignored",
+    count: 0,
+    meta: {
+      rank: 0,
+    },
+  })).toEqual(rowA)
+  await expect(table.safeSimpleDeleteRow(createRow({ id: "missing" }))).rejects.toThrow("Row not found")
+})
+
+test("BaseTable.simpleDeleteRow returns undefined when the unique does not exist", async () => {
+  const table = createTestTable()
+  const [rowA] = createRows()
+
+  await table.safeInsertRow(rowA)
+
+  expect(await table.simpleDeleteRow({
+    id: rowA.id,
+    label: "ignored",
+    count: 0,
+    meta: {
+      rank: 0,
+    },
+  })).toEqual(rowA)
+  expect(await table.simpleDeleteRow(createRow({ id: "missing" }))).toBeUndefined()
+})
+
+test("BaseTable.simpleDeleteRows returns stored rows and rejects duplicate batch uniques", async () => {
+  const table = createTestTable()
+  const [rowA, rowB] = createRows()
+
+  await table.safeInsertRows([rowA, rowB])
+
+  expect(await table.simpleDeleteRows([
+    {
+      id: rowA.id,
+      label: "ignored",
+      count: 0,
+      meta: {
+        rank: 0,
+      },
+    },
+    {
+      id: rowB.id,
+      label: "ignored",
+      count: 0,
+      meta: {
+        rank: 0,
+      },
+    },
+  ])).toEqual([rowA, rowB])
+
+  await table.safeInsertRows([rowA, rowB])
+  await expect(table.simpleDeleteRows([
+    createRow({ id: rowA.id }),
+    createRow({ id: rowA.id, label: "duplicate" }),
+  ])).rejects.toThrow('Duplicate row unique "row-1" found in batch')
+})
+
+test("BaseTable.safeDeleteRow deletes one matched row and rejects zero or many matches", async () => {
+  const table = createTestTable()
+  const [rowA, rowB] = createRows()
+
+  await table.safeInsertRows([rowA, rowB])
+
+  expect(await table.safeDeleteRow((row) => row.id === rowA.id)).toEqual(rowA)
+  await expect(table.safeDeleteRow((row) => row.id === "missing")).rejects.toThrow("Row not found.")
+
+  await table.safeInsertRow(rowA)
+  await expect(table.safeDeleteRow((row) => row.count >= 1)).rejects.toThrow("Multiple rows found")
+})
+
+test("BaseTable.deleteRow returns undefined for no matches and throws for multiple matches", async () => {
+  const table = createTestTable()
+  const [rowA, rowB] = createRows()
+
+  await table.safeInsertRows([rowA, rowB])
+
+  await expect(table.deleteRow((row) => row.count >= 1)).rejects.toThrow("Multiple rows found")
+  expect(await table.deleteRow((row) => row.id === rowA.id)).toEqual(rowA)
+  expect(await table.deleteRow((row) => row.id === "missing")).toBeUndefined()
+})
+
+test("BaseTable.deleteRows deletes all matched rows and keeps predicate mutations isolated", async () => {
+  const table = createTestTable()
+  const [rowA, rowB, rowC] = createRows()
+
+  await table.safeInsertRows([rowA, rowB, rowC])
+
+  expect(await table.deleteRows((row) => {
+    row.status = "mutated-in-getter"
+    return row.count >= 2
+  })).toEqual([rowB, rowC])
+  expect(await table.getRows(() => true)).toEqual([rowA])
+})
+
+test("BaseTable event valueChanged publishes cloned snapshots for successive mutations", async () => {
+  const table = createTestTable()
+  const [rowA, rowB] = createRows()
+  const snapshots: TestRow[][] = []
+
+  table.event.subscribe("valueChanged", (rows) => {
+    snapshots.push(rows)
+  })
+
+  await table.safeInsertRow(rowA)
+  await table.upsertRow({
+    id: rowA.id,
+    label: "updated",
+    count: 30,
+    meta: {
+      rank: 30,
+    },
+  })
+  await table.safeInsertRow(rowB)
+  await table.deleteRow((row) => row.id === rowB.id)
+
+  snapshots[0]![0]!.label = "mutated-outside"
+
+  expect(snapshots).toEqual([
+    [
+      {
+        ...rowA,
+        label: "mutated-outside",
+      },
+    ],
+    [
+      {
+        ...rowA,
+        label: "updated",
+        count: 30,
+        meta: {
+          rank: 30,
+        },
+      },
+    ],
+    [
+      {
+        ...rowA,
+        label: "updated",
+        count: 30,
+        meta: {
+          rank: 30,
+        },
+      },
+      rowB,
+    ],
+    [
+      {
+        ...rowA,
+        label: "updated",
+        count: 30,
+        meta: {
+          rank: 30,
+        },
+      },
+    ],
+  ])
+  expect(await table.getRows(() => true)).toEqual([
+    {
+      ...rowA,
+      label: "updated",
+      count: 30,
+      meta: {
+        rank: 30,
+      },
+    },
+  ])
+})