philon-
11 months ago
12 changed files with 517 additions and 69 deletions
@ -0,0 +1,30 @@ |
|||
import { vi } from "vitest"; |
|||
import type { NodeDB } from "./index.ts"; |
|||
|
|||
/** |
|||
* You can spread this base mock in your tests and override only the |
|||
* properties relevant to a specific test case. |
|||
*/ |
|||
export const mockNodeDBStore: NodeDB = { |
|||
id: 0, |
|||
myNodeNum: 0, |
|||
nodeErrors: new Map(), |
|||
nodeMap: new Map(), |
|||
|
|||
addNode: vi.fn(), |
|||
addUser: vi.fn(), |
|||
addPosition: vi.fn(), |
|||
removeNode: vi.fn(), |
|||
processPacket: vi.fn(), |
|||
setNodeError: vi.fn(), |
|||
clearNodeError: vi.fn(), |
|||
getNodeError: vi.fn().mockReturnValue(undefined), |
|||
hasNodeError: vi.fn().mockReturnValue(false), |
|||
getNodes: vi.fn().mockReturnValue([]), |
|||
getNodesLength: vi.fn().mockReturnValue(0), |
|||
getNode: vi.fn().mockReturnValue(undefined), |
|||
getMyNode: vi.fn(), |
|||
updateFavorite: vi.fn(), |
|||
updateIgnore: vi.fn(), |
|||
setNodeNum: vi.fn(), |
|||
}; |
|||
@ -0,0 +1,247 @@ |
|||
import { beforeEach, describe, expect, it, vi } from "vitest"; |
|||
|
|||
const idbMem = new Map<string, string>(); |
|||
vi.mock("idb-keyval", () => ({ |
|||
get: vi.fn((key: string) => Promise.resolve(idbMem.get(key))), |
|||
set: vi.fn((key: string, val: string) => { |
|||
idbMem.set(key, val); |
|||
return Promise.resolve(); |
|||
}), |
|||
del: vi.fn((k: string) => { |
|||
idbMem.delete(k); |
|||
return Promise.resolve(); |
|||
}), |
|||
})); |
|||
|
|||
// import a fresh copy of the store module (because the store is created at import time)
|
|||
async function freshStore() { |
|||
vi.resetModules(); |
|||
const mod = await import("../nodeDBStore"); |
|||
return mod; |
|||
} |
|||
|
|||
function makeNode(num: number, extras: Record<string, any> = {}) { |
|||
return { num, ...extras } as any; |
|||
} |
|||
|
|||
describe("NodeDB store", () => { |
|||
beforeEach(() => { |
|||
idbMem.clear(); |
|||
vi.clearAllMocks(); |
|||
}); |
|||
|
|||
it("addNodeDB returns same instance on repeated calls; getNodeDB works", async () => { |
|||
const { useNodeDBStore } = await freshStore(); |
|||
|
|||
const db1 = useNodeDBStore.getState().addNodeDB(123); |
|||
const db2 = useNodeDBStore.getState().addNodeDB(123); |
|||
expect(db1).toBe(db2); |
|||
|
|||
const got = useNodeDBStore.getState().getNodeDB(123); |
|||
expect(got).toBe(db1); |
|||
|
|||
expect(useNodeDBStore.getState().getNodeDBs().length).toBe(1); |
|||
}); |
|||
|
|||
it("addNode, getNode(s), getNodesLength, removeNode", async () => { |
|||
const { useNodeDBStore } = await freshStore(); |
|||
const db = useNodeDBStore.getState().addNodeDB(1); |
|||
|
|||
db.addNode(makeNode(10)); |
|||
db.addNode(makeNode(11)); |
|||
expect(db.getNodesLength()).toBe(2); |
|||
expect(db.getNode(10)?.num).toBe(10); |
|||
|
|||
const all = db.getNodes(); |
|||
expect(all.map(n => n.num).sort()).toEqual([10, 11]); |
|||
|
|||
db.removeNode(10); |
|||
expect(db.getNodesLength()).toBe(1); |
|||
expect(db.getNode(10)).toBeUndefined(); |
|||
}); |
|||
|
|||
it("processPacket creates or updates a node", async () => { |
|||
const { useNodeDBStore } = await freshStore(); |
|||
const db = useNodeDBStore.getState().addNodeDB(1); |
|||
|
|||
db.processPacket({ from: 50, time: 1111, snr: 7 } as any); |
|||
expect(db.getNode(50)).toBeTruthy(); |
|||
expect(db.getNode(50)?.lastHeard).toBe(1111); |
|||
expect(db.getNode(50)?.snr).toBe(7); |
|||
|
|||
db.processPacket({ from: 50, time: 2222, snr: 9 } as any); |
|||
expect(db.getNode(50)?.lastHeard).toBe(2222); |
|||
expect(db.getNode(50)?.snr).toBe(9); |
|||
}); |
|||
|
|||
it("addUser and addPosition updates existing or creates new nodes", async () => { |
|||
const { useNodeDBStore } = await freshStore(); |
|||
const db = useNodeDBStore.getState().addNodeDB(1); |
|||
|
|||
// addUser creates node if missing
|
|||
db.addUser({ from: 77, data: { id: "u" } } as any); |
|||
expect(db.getNode(77)?.user).toEqual({ id: "u" }); |
|||
|
|||
// addPosition updates same node
|
|||
db.addPosition({ from: 77, data: { lat: 1, lon: 2 } } as any); |
|||
expect(db.getNode(77)?.position).toEqual({ lat: 1, lon: 2 }); |
|||
expect(db.getNode(77)?.num).toBe(77); |
|||
}); |
|||
|
|||
it("errors map: setNodeError, getNodeError, hasNodeError, clearNodeError", async () => { |
|||
const { useNodeDBStore } = await freshStore(); |
|||
const db = useNodeDBStore.getState().addNodeDB(1); |
|||
|
|||
db.setNodeError(10, "BadFoo" as any); |
|||
expect(db.hasNodeError(10)).toBe(true); |
|||
expect(db.getNodeError(10)).toEqual({ node: 10, error: "BadFoo" }); |
|||
|
|||
db.clearNodeError(10); |
|||
expect(db.hasNodeError(10)).toBe(false); |
|||
expect(db.getNodeError(10)).toBeUndefined(); |
|||
}); |
|||
|
|||
it("getMyNode throws before setNodeNum; works after", async () => { |
|||
const { useNodeDBStore } = await freshStore(); |
|||
const db = useNodeDBStore.getState().addNodeDB(1); |
|||
db.addNode(makeNode(123)); |
|||
|
|||
expect(() => db.getMyNode()).toThrow(); |
|||
db.setNodeNum(123); |
|||
|
|||
const me = db.getMyNode(); |
|||
expect(me.num).toBe(123); |
|||
}); |
|||
|
|||
it("setNodeNum merges with existing DB with same myNodeNum", async () => { |
|||
const { useNodeDBStore } = await freshStore(); |
|||
const st = useNodeDBStore.getState(); |
|||
|
|||
|
|||
const oldDB = st.addNodeDB(10); |
|||
oldDB.setNodeNum(999); |
|||
oldDB.addNode(makeNode(200)); |
|||
oldDB.setNodeError(200, "ERROR" as any); |
|||
|
|||
const newDB = st.addNodeDB(11); |
|||
// newDB currently empty; setting same myNodeNum should copy maps from oldDB and delete old
|
|||
newDB.setNodeNum(999); |
|||
|
|||
expect(st.getNodeDB(10)).toBeUndefined(); |
|||
expect(st.getNodeDB(11)).toBeDefined(); |
|||
expect(newDB.getNode(200)).toBeTruthy(); |
|||
expect(newDB.getNodeError(200)).toEqual({ node: 200, error: "ERROR" }); |
|||
}); |
|||
|
|||
it("setNodeNum does not merge when new DB already has nodes; old is removed", async () => { |
|||
const { useNodeDBStore } = await freshStore(); |
|||
const st = useNodeDBStore.getState(); |
|||
|
|||
const oldDB = st.addNodeDB(10); |
|||
oldDB.setNodeNum(999); |
|||
oldDB.addNode(makeNode(200)); // old has data
|
|||
|
|||
const newDB = st.addNodeDB(11); |
|||
newDB.addNode(makeNode(300)); // new has data -> no merge
|
|||
newDB.setNodeNum(999); |
|||
|
|||
expect(st.getNodeDB(10)).toBeUndefined(); // old removed
|
|||
// new kept its own nodes; did not copy old's
|
|||
expect(newDB.getNode(300)).toBeTruthy(); |
|||
expect(newDB.getNode(200)).toBeUndefined(); |
|||
}); |
|||
|
|||
it("partialize persists only data, and onRehydrateStorage rebuilds methods", async () => { |
|||
{ |
|||
const { useNodeDBStore } = await freshStore(); |
|||
const st = useNodeDBStore.getState(); |
|||
const db = st.addNodeDB(123); |
|||
db.setNodeNum(321); |
|||
db.addNode(makeNode(50)); |
|||
db.setNodeError(50, "ERROR" as any); |
|||
} |
|||
{ |
|||
const { useNodeDBStore } = await freshStore(); |
|||
const st = useNodeDBStore.getState(); |
|||
const db = st.getNodeDB(123)!; |
|||
|
|||
// methods should work after rehydrate
|
|||
expect(db.getNode(50)?.num).toBe(50); |
|||
expect(db.getNodeError(50)).toEqual({ node: 50, error: "ERROR" }); |
|||
db.addNode(makeNode(51)); |
|||
expect(db.getNode(51)).toBeTruthy(); |
|||
} |
|||
}); |
|||
|
|||
it("getNodes applies filter and excludes myNodeNum", async () => { |
|||
const { useNodeDBStore } = await freshStore(); |
|||
const db = useNodeDBStore.getState().addNodeDB(1); |
|||
db.setNodeNum(11); |
|||
db.addNode(makeNode(10)); |
|||
db.addNode(makeNode(11)); |
|||
db.addNode(makeNode(12)); |
|||
|
|||
const all = db.getNodes(); |
|||
expect(all.map((n) => n.num).sort()).toEqual([10, 12]); // excludes my (11)
|
|||
|
|||
const filtered = db.getNodes((n) => n.num > 10); |
|||
expect(filtered.map((n) => n.num).sort()).toEqual([12]); // still excludes 11
|
|||
}); |
|||
|
|||
it("when exceeding cap, evicts earliest inserted, not the newly added", async () => { |
|||
const { useNodeDBStore } = await freshStore(); |
|||
const st = useNodeDBStore.getState(); |
|||
for (let i = 1; i <= 10; i++) st.addNodeDB(i); |
|||
st.addNodeDB(11); |
|||
expect(st.getNodeDB(1)).toBeUndefined(); |
|||
expect(st.getNodeDB(11)).toBeDefined(); |
|||
}); |
|||
|
|||
it("removeNodeDB persists removal across reload", async () => { |
|||
{ |
|||
const { useNodeDBStore } = await freshStore(); |
|||
const st = useNodeDBStore.getState(); |
|||
st.addNodeDB(99); |
|||
expect(st.getNodeDB(99)).toBeDefined(); |
|||
st.removeNodeDB(99); |
|||
expect(st.getNodeDB(99)).toBeUndefined(); |
|||
} |
|||
{ |
|||
const { useNodeDBStore } = await freshStore(); |
|||
const st = useNodeDBStore.getState(); |
|||
expect(st.getNodeDB(99)).toBeUndefined(); // still gone
|
|||
} |
|||
}); |
|||
|
|||
it("on rehydrate only rebuilds DBs with myNodeNum set (orphans dropped)", async () => { |
|||
{ |
|||
const { useNodeDBStore } = await freshStore(); |
|||
const st = useNodeDBStore.getState(); |
|||
|
|||
const orphan = st.addNodeDB(500); // no setNodeNum
|
|||
orphan.addNode(makeNode(1)); |
|||
|
|||
const good = st.addNodeDB(501); |
|||
good.setNodeNum(42); |
|||
good.addNode(makeNode(2)); |
|||
} |
|||
{ |
|||
const { useNodeDBStore } = await freshStore(); |
|||
const st = useNodeDBStore.getState(); |
|||
expect(st.getNodeDB(500)).toBeUndefined(); // orphan dropped
|
|||
expect(st.getNodeDB(501)).toBeDefined(); // kept
|
|||
expect(st.getNodeDB(501)!.getNode(2)).toBeTruthy(); |
|||
} |
|||
}); |
|||
|
|||
it("methods throw after their DB is removed from the map", async () => { |
|||
const { useNodeDBStore } = await freshStore(); |
|||
const st = useNodeDBStore.getState(); |
|||
const db = st.addNodeDB(800); |
|||
|
|||
st.removeNodeDB(800); |
|||
|
|||
expect(() => db.getNodesLength()).toThrow(/No nodeDB found/); |
|||
expect(() => db.addNode(makeNode(1))).toThrow(/No nodeDB found/); |
|||
}); |
|||
}); |
|||
@ -0,0 +1,158 @@ |
|||
import { beforeEach, describe, expect, it, vi } from "vitest"; |
|||
import * as idb from "idb-keyval"; |
|||
import { createStorage } from "./indexDB"; |
|||
|
|||
type PersistStorage<T> = ReturnType<typeof createStorage<T>>; |
|||
|
|||
describe("indexDB.ts persistence (steps 1–5)", () => { |
|||
let store: PersistStorage<any>; |
|||
|
|||
beforeEach(() => { |
|||
vi.restoreAllMocks(); |
|||
store = createStorage<any>(); |
|||
}); |
|||
|
|||
async function roundTrip(obj: any) { |
|||
const setSpy = vi.spyOn(idb, "set").mockResolvedValue(); |
|||
const getSpy = vi.spyOn(idb, "get"); |
|||
await store.setItem("rt", obj); |
|||
const storedStr = (setSpy.mock.calls[0] as any[])[1] as string; |
|||
getSpy.mockResolvedValue(storedStr); |
|||
return await store.getItem("rt"); |
|||
} |
|||
|
|||
// Basic methods
|
|||
it("getItem returns null when idb-keyval.get yields undefined", async () => { |
|||
const getSpy = vi.spyOn(idb, "get").mockResolvedValue(undefined); |
|||
const res = await store.getItem("missing-key"); |
|||
expect(getSpy).toHaveBeenCalledWith("missing-key"); |
|||
expect(res).toBeNull(); |
|||
}); |
|||
|
|||
it("setItem writes a string via idb-keyval.set", async () => { |
|||
const setSpy = vi.spyOn(idb, "set").mockResolvedValue(); |
|||
const payload = { state: { a: 1 }, version: 0 }; |
|||
await store.setItem("k1", payload); |
|||
expect(setSpy).toHaveBeenCalledTimes(1); |
|||
const [, value] = setSpy.mock.calls[0]!; |
|||
expect(typeof value).toBe("string"); |
|||
// sanity: it should be JSON
|
|||
expect(() => JSON.parse(value as string)).not.toThrow(); |
|||
}); |
|||
|
|||
it("removeItem calls idb-keyval.del and getItem returns null afterwards", async () => { |
|||
const delSpy = vi.spyOn(idb, "del").mockResolvedValue(); |
|||
await store.removeItem("k2"); |
|||
expect(delSpy).toHaveBeenCalledWith("k2"); |
|||
|
|||
const getSpy = vi.spyOn(idb, "get").mockResolvedValue(undefined); |
|||
const res = await store.getItem("k2"); |
|||
expect(getSpy).toHaveBeenCalledWith("k2"); |
|||
expect(res).toBeNull(); |
|||
}); |
|||
|
|||
// Map
|
|||
it("round-trips an empty Map", async () => { |
|||
const out = await roundTrip({ state: { m: new Map() }, version: 0 }); |
|||
expect(out?.state.m instanceof Map).toBe(true); |
|||
expect(out?.state.m.size).toBe(0); |
|||
}); |
|||
|
|||
it("round-trips a Map<number,string> and preserves numeric key semantics", async () => { |
|||
const m = new Map<number, string>([[1, "a"]]); |
|||
const out = await roundTrip({ state: { m }, version: 0 }); |
|||
const m2 = out!.state.m as Map<number, string>; |
|||
expect(m2 instanceof Map).toBe(true); |
|||
expect(m2.get(1)).toBe("a"); |
|||
}); |
|||
|
|||
it("round-trips nested Map inside arrays/objects", async () => { |
|||
const payload = { |
|||
state: { |
|||
list: [new Map<number, number>([[2, 3]])], |
|||
obj: { inner: new Map<string, number>([["k", 7]]) }, |
|||
}, |
|||
version: 0, |
|||
}; |
|||
const out = await roundTrip(payload); |
|||
|
|||
expect(out!.state.list[0] instanceof Map).toBe(true); |
|||
expect((out!.state.list[0] as Map<number, number>).get(2)).toBe(3); |
|||
expect(out!.state.obj.inner instanceof Map).toBe(true); |
|||
expect((out!.state.obj.inner as Map<string, number>).get("k")).toBe(7); |
|||
}); |
|||
|
|||
// Uint8Array
|
|||
it("round-trips a Uint8Array (simple)", async () => { |
|||
const u8 = new Uint8Array([1, 2, 255]); |
|||
const out = await roundTrip({ state: { u8 }, version: 0 }); |
|||
const u2 = out!.state.u8 as Uint8Array; |
|||
expect(u2 instanceof Uint8Array).toBe(true); |
|||
expect(Array.from(u2)).toEqual([1, 2, 255]); |
|||
}); |
|||
|
|||
it("round-trips a Uint8Array view with non-zero byteOffset", async () => { |
|||
const buf = new Uint8Array([0, 9, 8, 7, 6, 5, 4, 3]).buffer; |
|||
const view = new Uint8Array(buf, 2, 4); // [8,7,6,5]
|
|||
const out = await roundTrip({ state: { view }, version: 0 }); |
|||
const v2 = out!.state.view as Uint8Array; |
|||
expect(v2 instanceof Uint8Array).toBe(true); |
|||
expect(Array.from(v2)).toEqual([8, 7, 6, 5]); |
|||
// ensure it's a standalone buffer now, without offset
|
|||
expect(v2.byteOffset).toBe(0); |
|||
}); |
|||
|
|||
// Mixed & nested structures
|
|||
it("round-trips Map values containing objects with nested Uint8Array", async () => { |
|||
const inner = { key: new Uint8Array([7, 8]) }; |
|||
const m = new Map<number, { key: Uint8Array }>([[42, inner]]); |
|||
const out = await roundTrip({ state: { m }, version: 0 }); |
|||
const m2 = out!.state.m as Map<number, { key: Uint8Array }>; |
|||
expect(m2 instanceof Map).toBe(true); |
|||
|
|||
const got = m2.get(42)!; |
|||
expect(got.key instanceof Uint8Array).toBe(true); |
|||
expect(Array.from(got.key)).toEqual([7, 8]); |
|||
}); |
|||
|
|||
it("round-trips deep nesting (array → object → map → u8)", async () => { |
|||
const payload = { |
|||
state: { |
|||
arr: [ |
|||
{ |
|||
obj: { |
|||
m: new Map<string, Uint8Array>([["k", new Uint8Array([9])]]), |
|||
}, |
|||
}, |
|||
], |
|||
}, |
|||
version: 0, |
|||
}; |
|||
const out = await roundTrip(payload); |
|||
const m2 = out!.state.arr[0].obj.m as Map<string, Uint8Array>; |
|||
expect(m2 instanceof Map).toBe(true); |
|||
const u = m2.get("k")!; |
|||
expect(u instanceof Uint8Array).toBe(true); |
|||
expect(Array.from(u)).toEqual([9]); |
|||
}); |
|||
|
|||
it("does not alter plain objects/arrays", async () => { |
|||
const payload = { state: { a: 1, b: [2, 3], c: { d: 4 } }, version: 0 }; |
|||
const out = await roundTrip(payload); |
|||
expect(out).toEqual(payload); |
|||
}); |
|||
|
|||
it("revives envelope-looking objects", async () => { |
|||
// Current implementation will treat any {__datatype:"Map",value:[...]} as an envelope.
|
|||
const forged = JSON.stringify({ |
|||
state: { m: { __datatype: "Map", value: [[1, "x"]] } }, |
|||
version: 0, |
|||
}); |
|||
const getSpy = vi.spyOn(idb, "get").mockResolvedValue(forged); |
|||
const out = await store.getItem("forged"); |
|||
expect(getSpy).toHaveBeenCalled(); |
|||
const m2 = out!.state.m as Map<number, string>; |
|||
expect(m2 instanceof Map).toBe(true); |
|||
expect(m2.get(1)).toBe("x"); |
|||
}); |
|||
}); |
|||
Loading…
Reference in new issue