@hot-updater/plugin-insights 1.0.0-rc.20

package/dist/server/testing/insightsModelTests.mjs

@@ -0,0 +1,714 @@
+import { expectInsightsIndex } from "./expectInsightsIndex.mjs";
+import { createBundleEventRowFixture } from "./fixtures.mjs";
+import { describe, expect, it } from "vitest";
+//#region src/server/testing/insightsModelTests.ts
+const record = (model, event) => model.recordEvent({ event });
+const createMovementEvent = (suffix, receivedAtMs, type, installId) => {
+	const row = createBundleEventRowFixture(suffix, receivedAtMs);
+	return {
+		...row,
+		type,
+		install_id: installId,
+		from_bundle_id: row.to_bundle_id,
+		metadata: {
+			...row.metadata,
+			update_strategy: "appVersion"
+		}
+	};
+};
+/**
+* The Insights report contract on `InsightsModel`: what the Insights plugin
+* records and reads, through `createInsightsModel`, on one database.
+*/
+const registerInsightsModelTests = (state) => {
+	describe("Insights report contract", () => {
+		it("preserves ancillary JSON through event history and latest-event reads", async () => {
+			const model = state.getDatabase();
+			const base = createBundleEventRowFixture("979", 100);
+			const event = {
+				...base,
+				metadata: {
+					...base.metadata,
+					device: {
+						locale: "ko-KR",
+						tags: [
+							"minor",
+							null,
+							true,
+							2
+						]
+					},
+					diagnostic: null
+				}
+			};
+			await record(model, event);
+			await expect(model.findLatestEvents({ installId: event.install_id })).resolves.toEqual([event]);
+			await expectInsightsIndex(() => model.listEvents({
+				filter: { kind: "all" },
+				beforeReceivedAtMs: 101,
+				limit: 10
+			}), [event]);
+		});
+		it("selects the latest complete event across download, replacement, apply, and delayed reports", async () => {
+			const model = state.getDatabase();
+			const download = {
+				...createBundleEventRowFixture("980", 100),
+				type: "UPDATE_DOWNLOADED",
+				from_bundle_id: "00000000-0000-7000-8000-000000001980",
+				metadata: {
+					...createBundleEventRowFixture("980", 100).metadata,
+					update_strategy: "appVersion"
+				},
+				to_release_id: "00000000-0000-7000-8000-000000004980"
+			};
+			await record(model, download);
+			await record(model, download);
+			await expect(model.findLatestEvents({ installId: download.install_id })).resolves.toEqual([download]);
+			await expectInsightsIndex(() => model.listEvents({
+				filter: {
+					kind: "bundle",
+					type: "UPDATE_DOWNLOADED",
+					toBundleId: download.to_bundle_id,
+					platform: "ios",
+					channel: "production"
+				},
+				beforeReceivedAtMs: 200,
+				limit: 10
+			}), [download]);
+			const replacement = {
+				...download,
+				id: createBundleEventRowFixture("981", 110).id,
+				received_at_ms: 110,
+				to_bundle_id: "00000000-0000-7000-8000-000000002981"
+			};
+			await record(model, replacement);
+			await expect(model.findLatestEvents({ installId: download.install_id })).resolves.toEqual([replacement]);
+			const applied = {
+				...replacement,
+				type: "UPDATE_APPLIED",
+				id: createBundleEventRowFixture("982", 120).id,
+				received_at_ms: 120
+			};
+			await record(model, applied);
+			await record(model, {
+				...download,
+				id: createBundleEventRowFixture("983", 105).id,
+				received_at_ms: 105
+			});
+			await expect(model.findLatestEvents({ installId: download.install_id })).resolves.toEqual([applied]);
+			await expectInsightsIndex(() => model.listEvents({
+				filter: {
+					kind: "installationMovement",
+					installId: download.install_id
+				},
+				beforeReceivedAtMs: 200,
+				limit: 10
+			}), [
+				applied,
+				replacement,
+				{
+					...download,
+					id: createBundleEventRowFixture("983", 105).id,
+					received_at_ms: 105
+				},
+				download
+			]);
+		});
+		it("treats duplicate IDs as complete no-ops, including changed retry payloads", async () => {
+			const model = state.getDatabase();
+			const event = createBundleEventRowFixture("901", 100);
+			await Promise.all([
+				record(model, event),
+				record(model, event),
+				record(model, event)
+			]);
+			await record(model, event);
+			const changed = {
+				...event,
+				received_at_ms: 300,
+				user_id: "changed-user"
+			};
+			await record(model, changed);
+			const otherInstallation = {
+				...changed,
+				install_id: "different-install"
+			};
+			await record(model, otherInstallation);
+			await expect(model.findLatestEvents({ installId: event.install_id })).resolves.toEqual([event]);
+			await expect(model.findLatestEvents({ installId: otherInstallation.install_id })).resolves.toEqual([]);
+			await expectInsightsIndex(() => model.listEvents({
+				filter: { kind: "all" },
+				beforeReceivedAtMs: 400,
+				limit: 10
+			}), [event]);
+		});
+		it("keeps all concurrent events and the greatest timestamp/ID state, including logout", async () => {
+			const model = state.getDatabase();
+			const older = {
+				...createBundleEventRowFixture("912", 100),
+				install_id: "concurrent",
+				user_id: "previous"
+			};
+			const tied = {
+				...createBundleEventRowFixture("910", 200),
+				install_id: "concurrent",
+				user_id: "previous"
+			};
+			const newest = {
+				...createBundleEventRowFixture("911", 200),
+				install_id: "concurrent",
+				user_id: null
+			};
+			await Promise.all([
+				record(model, newest),
+				record(model, older),
+				record(model, tied)
+			]);
+			await record(model, older);
+			await expect(model.findLatestEvents({ installId: "concurrent" })).resolves.toEqual([newest]);
+			await expect(model.findLatestEvents({
+				userId: "previous",
+				limit: 10
+			})).resolves.toEqual([]);
+			await expectInsightsIndex(() => model.listEvents({
+				filter: { kind: "all" },
+				beforeReceivedAtMs: 201,
+				limit: 10
+			}), [
+				newest,
+				tied,
+				older
+			]);
+		});
+		it("rejects invalid event metadata before persisting a report", async () => {
+			const model = state.getDatabase();
+			const event = createBundleEventRowFixture("920", 100);
+			await expect(model.recordEvent({ event: {
+				...event,
+				metadata: {
+					...event.metadata,
+					cohort: 123
+				}
+			} })).rejects.toMatchObject({ code: "invalid-data" });
+			await expect(model.findLatestEvents({ installId: event.install_id })).resolves.toEqual([]);
+			await expect(model.listEvents({
+				filter: { kind: "all" },
+				beforeReceivedAtMs: 200,
+				limit: 10
+			})).resolves.toEqual([]);
+		});
+		it("shares scoped list/count predicates, recovery attribution, and half-open time bounds", async () => {
+			const model = state.getDatabase();
+			const bundleA = createBundleEventRowFixture("1", 0).to_bundle_id;
+			const bundleB = createBundleEventRowFixture("2", 0).to_bundle_id;
+			const bundleC = createBundleEventRowFixture("3", 0).to_bundle_id;
+			const applied = {
+				...createBundleEventRowFixture("930", 100),
+				install_id: "target",
+				to_bundle_id: bundleB
+			};
+			const recovered = {
+				...createBundleEventRowFixture("931", 120),
+				install_id: "target",
+				type: "RECOVERED",
+				from_bundle_id: bundleB,
+				to_bundle_id: bundleA,
+				metadata: {
+					...createBundleEventRowFixture("931", 120).metadata,
+					update_strategy: "appVersion"
+				}
+			};
+			const unchanged = {
+				...createBundleEventRowFixture("932", 130),
+				type: "UNCHANGED",
+				from_bundle_id: null,
+				to_bundle_id: bundleB,
+				metadata: {
+					...createBundleEventRowFixture("932", 130).metadata,
+					update_strategy: null
+				}
+			};
+			const excluded = [
+				{
+					...applied,
+					id: createBundleEventRowFixture("933", 99).id,
+					install_id: "before",
+					received_at_ms: 99
+				},
+				{
+					...applied,
+					id: createBundleEventRowFixture("934", 200).id,
+					install_id: "after",
+					received_at_ms: 200
+				},
+				{
+					...applied,
+					id: createBundleEventRowFixture("935", 110).id,
+					install_id: "android",
+					platform: "android"
+				},
+				{
+					...applied,
+					id: createBundleEventRowFixture("936", 110).id,
+					install_id: "preview",
+					channel: "preview"
+				},
+				{
+					...recovered,
+					id: createBundleEventRowFixture("937", 125).id,
+					install_id: "other-source",
+					from_bundle_id: bundleC,
+					to_bundle_id: bundleB
+				}
+			];
+			for (const row of [
+				applied,
+				recovered,
+				unchanged,
+				...excluded
+			]) await record(model, row);
+			await expect(async () => record(model, {
+				...applied,
+				type: "RELEASE_ADOPTED"
+			})).rejects.toThrow();
+			await expect(async () => record(model, {
+				...applied,
+				type: "UNCHANGED",
+				from_bundle_id: bundleB,
+				metadata: {
+					...applied.metadata,
+					update_strategy: "appVersion"
+				}
+			})).rejects.toThrow();
+			await expect(model.findLatestEvents({ installId: "target" })).resolves.toEqual([recovered]);
+			const cases = [[{
+				platform: "ios",
+				channel: "production",
+				type: "UPDATE_APPLIED",
+				toBundleId: bundleB
+			}, applied], [{
+				platform: "ios",
+				channel: "production",
+				type: "RECOVERED",
+				fromBundleId: bundleB
+			}, recovered]];
+			for (const [filter, expected] of cases) {
+				await expectInsightsIndex(() => model.countEvents({
+					filter,
+					sinceMs: 100,
+					beforeReceivedAtMs: 200
+				}), 1);
+				await expectInsightsIndex(() => model.listEvents({
+					filter: {
+						kind: "bundle",
+						...filter
+					},
+					sinceMs: 100,
+					beforeReceivedAtMs: 200,
+					limit: 1
+				}), [expected]);
+			}
+			await expect(model.findLatestEvents({ installId: unchanged.install_id })).resolves.toEqual([unchanged]);
+			await expectInsightsIndex(() => model.listEvents({
+				filter: { kind: "all" },
+				sinceMs: 100,
+				beforeReceivedAtMs: 200,
+				limit: 10
+			}), [
+				excluded[4],
+				recovered,
+				excluded[3],
+				excluded[2],
+				applied
+			]);
+			await expect(model.countEvents({
+				filter: {
+					platform: "ios",
+					channel: "production",
+					type: "UNCHANGED",
+					toBundleId: bundleB
+				},
+				sinceMs: 100,
+				beforeReceivedAtMs: 200
+			})).rejects.toThrow();
+			await expectInsightsIndex(() => model.countLatestEvents({
+				platform: "ios",
+				channel: "production",
+				sinceMs: 0,
+				bundle: [{
+					field: "to_bundle_id",
+					value: bundleA,
+					types: [
+						"UNCHANGED",
+						"UPDATE_APPLIED",
+						"RECOVERED"
+					]
+				}]
+			}), 1);
+			await expectInsightsIndex(() => model.countLatestEvents({
+				platform: "ios",
+				channel: "production",
+				sinceMs: 0
+			}), 5);
+			await expect(model.countLatestEvents({
+				platform: "ios",
+				channel: "production",
+				sinceMs: 100
+			})).rejects.toThrow();
+		});
+		it("uses exact identity and UTF-8 cursor order for user installations", async () => {
+			const model = state.getDatabase();
+			const ids = [
+				"Install-a",
+				"é",
+				"install-a",
+				"install-a ",
+				"é",
+				"",
+				"😀"
+			];
+			const events = ids.map((install_id, index) => ({
+				...createBundleEventRowFixture(String(950 + index), 100),
+				install_id,
+				user_id: "User-é"
+			}));
+			for (const event of events.toReversed()) await record(model, event);
+			const spacedUser = {
+				...createBundleEventRowFixture("960", 100),
+				install_id: "spaced-user-install",
+				user_id: "User-é "
+			};
+			await record(model, spacedUser);
+			await expectInsightsIndex(async () => {
+				const found = [];
+				let afterInstallId;
+				for (let pageIndex = 0; pageIndex <= ids.length; pageIndex++) {
+					const page = await model.findLatestEvents({
+						userId: "User-é",
+						afterInstallId,
+						limit: 2
+					});
+					found.push(...page.map((row) => row.install_id));
+					if (page.length < 2) return found;
+					const nextCursor = page[page.length - 1].install_id;
+					expect(nextCursor, "Insights cursor must advance").not.toBe(afterInstallId);
+					afterInstallId = nextCursor;
+				}
+				throw new Error("Insights pagination did not terminate");
+			}, ids);
+			await expectInsightsIndex(() => model.findLatestEvents({
+				userId: "User-é ",
+				limit: 10
+			}), [spacedUser]);
+			await expect(model.findLatestEvents({
+				userId: "user-é",
+				limit: 10
+			})).resolves.toEqual([]);
+			await expect(model.findLatestEvents({ installId: "INSTALL-a" })).resolves.toEqual([]);
+			await expect(model.findLatestEvents({ installId: "Install-a" })).resolves.toEqual([events[0]]);
+			await expect(model.findLatestEvents({ installId: "install-a " })).resolves.toEqual([events[3]]);
+			await expect(model.findLatestEvents({ installId: "install-a" })).resolves.toEqual([events[2]]);
+		});
+		it("counts overlapping bundle predicates once per latest installation", async () => {
+			const model = state.getDatabase();
+			const event = createBundleEventRowFixture("9700", 100);
+			await record(model, event);
+			const predicate = {
+				field: "to_bundle_id",
+				value: event.to_bundle_id,
+				types: [event.type]
+			};
+			await expectInsightsIndex(() => model.countLatestEvents({
+				platform: event.platform,
+				channel: event.channel,
+				sinceMs: 0,
+				bundle: [predicate, predicate]
+			}), 1);
+		});
+		it("counts a latest installation once when a from and a to predicate both match it", async () => {
+			const model = state.getDatabase();
+			const moved = createBundleEventRowFixture("9701", 100);
+			await record(model, moved);
+			await expectInsightsIndex(() => model.countLatestEvents({
+				platform: moved.platform,
+				channel: moved.channel,
+				sinceMs: 0,
+				bundle: [{
+					field: "from_bundle_id",
+					value: moved.from_bundle_id,
+					types: [moved.type]
+				}, {
+					field: "to_bundle_id",
+					value: moved.to_bundle_id,
+					types: [moved.type]
+				}]
+			}), 1);
+		});
+		it("returns zero for successful empty scalar queries", async () => {
+			const model = state.getDatabase();
+			await expect(model.countLatestEvents({
+				platform: "ios",
+				channel: "production",
+				sinceMs: 0
+			})).resolves.toBe(0);
+			await expect(model.countEvents({
+				filter: {
+					platform: "ios",
+					channel: "production",
+					type: "RECOVERED",
+					fromBundleId: createBundleEventRowFixture("1", 0).to_bundle_id
+				},
+				sinceMs: 0,
+				beforeReceivedAtMs: 100
+			})).resolves.toBe(0);
+		});
+		it("maintains idempotent release, scope, usage, and latest-distribution summaries", async () => {
+			const model = state.getDatabase();
+			const releaseA = "00000000-0000-7000-8000-000000008001";
+			const releaseB = "00000000-0000-7000-8000-000000008002";
+			const download = {
+				...createBundleEventRowFixture("9801", 1e3),
+				type: "UPDATE_DOWNLOADED",
+				install_id: "summary-install-a",
+				from_release_id: releaseA,
+				to_release_id: releaseB
+			};
+			const appliedA = {
+				...download,
+				id: createBundleEventRowFixture("9802", 2e3).id,
+				type: "UPDATE_APPLIED",
+				received_at_ms: 2e3
+			};
+			const appliedB = {
+				...appliedA,
+				id: createBundleEventRowFixture("9803", 2100).id,
+				install_id: "summary-install-b",
+				received_at_ms: 2100
+			};
+			const recovered = {
+				...appliedA,
+				id: createBundleEventRowFixture("9804", 3e3).id,
+				type: "RECOVERED",
+				from_release_id: releaseB,
+				to_release_id: releaseA,
+				received_at_ms: 3e3
+			};
+			for (const event of [
+				download,
+				appliedA,
+				appliedB,
+				appliedB,
+				recovered
+			]) await record(model, event);
+			const releases = [{
+				releaseId: releaseA,
+				platform: "ios",
+				channel: "production"
+			}, {
+				releaseId: releaseB,
+				platform: "ios",
+				channel: "production"
+			}];
+			const lifetime = await model.getReleaseActivity({ releases });
+			expect(lifetime.data.map(({ metrics }) => metrics)).toEqual([{
+				downloads: 0,
+				launches: 1,
+				failedLaunches: 0
+			}, {
+				downloads: 1,
+				launches: 2,
+				failedLaunches: 1
+			}]);
+			const scope = await model.getReleaseActivity({
+				scope: {
+					platform: "ios",
+					channel: "production"
+				},
+				timeRange: {
+					start: 0,
+					end: 36e5
+				}
+			});
+			expect(scope.data[0]?.metrics).toMatchObject({
+				downloads: 1,
+				launches: 3,
+				failedLaunches: 1,
+				uniqueUsers: 2
+			});
+			const usage = await model.getAppUsage({
+				channel: "production",
+				platform: "all",
+				timeRange: {
+					start: 0,
+					end: 36e5
+				},
+				intervalMs: 36e5
+			});
+			expect(usage.activeInstallations).toBe(2);
+			expect(usage.points).toEqual([{
+				startMs: 0,
+				installations: 2
+			}]);
+			expect(usage.bundleDistribution).toEqual(expect.arrayContaining([{
+				appVersion: "1.0.0",
+				platform: "ios",
+				releaseId: releaseA,
+				installations: 1
+			}, {
+				appVersion: "1.0.0",
+				platform: "ios",
+				releaseId: releaseB,
+				installations: 1
+			}]));
+		});
+		it("pages insights events newest first with a stable cursor", async () => {
+			const model = state.getDatabase();
+			const first = createBundleEventRowFixture("701", 100);
+			const second = createBundleEventRowFixture("702", 100);
+			const third = createBundleEventRowFixture("703", 200);
+			await model.recordEvent({ event: third });
+			await model.recordEvent({ event: second });
+			await model.recordEvent({ event: first });
+			await expectInsightsIndex(() => model.listEvents({
+				filter: { kind: "all" },
+				beforeReceivedAtMs: 201,
+				limit: 2
+			}), [third, second]);
+			await expectInsightsIndex(() => model.listEvents({
+				filter: { kind: "all" },
+				after: {
+					receivedAtMs: second.received_at_ms,
+					id: second.id
+				},
+				beforeReceivedAtMs: 201,
+				limit: 2
+			}), [first]);
+			await expectInsightsIndex(() => model.listEvents({
+				filter: { kind: "all" },
+				beforeReceivedAtMs: 200,
+				limit: 10
+			}), [second, first]);
+		});
+		it("filters installation movements before applying the page limit", async () => {
+			const model = state.getDatabase();
+			const unchanged = {
+				...createBundleEventRowFixture("711", 300),
+				type: "UNCHANGED",
+				install_id: "install-target",
+				from_bundle_id: null,
+				metadata: {
+					...createBundleEventRowFixture("711", 300).metadata,
+					update_strategy: null
+				}
+			};
+			const unrelated = createMovementEvent("712", 250, "UPDATE_APPLIED", "install-other");
+			const applied = createMovementEvent("713", 200, "UPDATE_APPLIED", "install-target");
+			const recovered = createMovementEvent("714", 100, "RECOVERED", "install-target");
+			for (const row of [
+				unchanged,
+				unrelated,
+				applied,
+				recovered
+			]) await model.recordEvent({ event: row });
+			await expectInsightsIndex(() => model.listEvents({
+				filter: {
+					kind: "installationMovement",
+					installId: "install-target"
+				},
+				beforeReceivedAtMs: 301,
+				limit: 1
+			}), [applied]);
+			await expectInsightsIndex(() => model.listEvents({
+				filter: {
+					kind: "installationMovement",
+					installId: "install-target"
+				},
+				after: {
+					receivedAtMs: applied.received_at_ms,
+					id: applied.id
+				},
+				beforeReceivedAtMs: 301,
+				limit: 1
+			}), [recovered]);
+		});
+		it("lists an update failure where its target's list and installation history read it, and a failed check in no bundle list, moving no latest event", async () => {
+			const model = state.getDatabase();
+			const applied = createMovementEvent("721", 100, "UPDATE_APPLIED", "install-failing");
+			const failure = (suffix, receivedAtMs, failed) => ({
+				...applied,
+				id: createBundleEventRowFixture(suffix, 0).id,
+				type: "UPDATE_FAILED",
+				from_bundle_id: applied.to_bundle_id,
+				to_bundle_id: failed.stage === "check" ? applied.to_bundle_id : createBundleEventRowFixture("729", 0).to_bundle_id,
+				metadata: {
+					...applied.metadata,
+					failure: failed
+				},
+				received_at_ms: receivedAtMs
+			});
+			const download = failure("722", 200, {
+				stage: "download",
+				reason: "http",
+				http_status: 403,
+				origin_code: "AccessDenied"
+			});
+			const check = failure("723", 300, {
+				stage: "check",
+				reason: "http"
+			});
+			for (const event of [
+				applied,
+				download,
+				check
+			]) await record(model, event);
+			await expect(model.findLatestEvents({ installId: "install-failing" })).resolves.toEqual([applied]);
+			await expectInsightsIndex(() => model.listEvents({
+				filter: {
+					kind: "installationMovement",
+					installId: "install-failing"
+				},
+				beforeReceivedAtMs: 301,
+				limit: 10
+			}), [
+				check,
+				download,
+				applied
+			]);
+			await expectInsightsIndex(() => model.listEvents({
+				filter: { kind: "all" },
+				beforeReceivedAtMs: 301,
+				limit: 10
+			}), [
+				check,
+				download,
+				applied
+			]);
+			const scope = {
+				platform: "ios",
+				channel: "production"
+			};
+			for (const [toBundleId, listed] of [[download.to_bundle_id, [download]], [check.to_bundle_id, []]]) {
+				const filter = {
+					...scope,
+					type: "UPDATE_FAILED",
+					toBundleId
+				};
+				await expectInsightsIndex(() => model.listEvents({
+					filter: {
+						kind: "bundle",
+						...filter
+					},
+					beforeReceivedAtMs: 301,
+					limit: 10
+				}), listed);
+				await expect(model.countEvents({
+					filter,
+					sinceMs: 0,
+					beforeReceivedAtMs: 301
+				})).resolves.toBe(listed.length);
+			}
+		});
+	});
+};
+//#endregion
+export { registerInsightsModelTests };