@hot-updater/server 1.0.0-rc.18 → 1.0.0-rc.21

package/dist/plugins/insights/testing/insightsModelTests.mjs

@@ -1,714 +0,0 @@
-import { expectInsightsIndex } from "./expectInsightsIndex.mjs";
-import { createBundleEventRowFixture } from "./fixtures.mjs";
-import { describe, expect, it } from "vitest";
-//#region src/plugins/insights/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 };