@chipmobilesdk/rn-notification 0.1.2 → 0.2.1

package/src/testing/measure.ts

@@ -1,334 +1,337 @@
-/**
- * The PERF-001 measurement harness.
- *
- * Every budget in the specification, measured against the real code paths and
- * reported as pass or fail with the number that produced the verdict. Written
- * as a plain async function rather than a Jest suite so the same harness runs
- * in continuous integration and from the demo app on a physical device — which
- * matters, because PERF-003 forbids emulator numbers standing in as evidence.
- *
- * Five budgets are deliberately absent and reported as such: delivery accuracy,
- * cold-start latency, startup delta and frame rate cannot be measured
- * in-process. The first needs the OS to actually fire an alarm, the second a
- * real process death. Pretending to measure them here would be worse than
- * leaving the gap visible.
- */
-
-import type { NotificationEngineAdapter } from '../engine/adapter';
-import type { NotificationRequest } from '../contract/notification';
-import type { ResolvedTone } from '../contract/channel';
-import type { RecurrenceRule } from '../contract/recurrence';
-import { createScheduler } from '../schedule';
-import { createReconciler } from '../reconcile';
-import { createRecurrence } from '../recurrence';
-import { createPermissions } from '../permission';
-import { createReAnchorStep } from '../maintenance/reanchor';
-import { MaintenanceRegistry } from '../maintenance/cycle';
-import { StateManager } from '../state/record';
-import { createMemoryStore } from '../state/store';
-import { planReAnchor } from '../schedule/anchor';
-import { recordSeen } from '../state/dedup-ledger';
-
-/** Every budget PERF-001 states, in milliseconds unless the name says otherwise. */
-export const PERF_BUDGETS = {
-	scheduleOne: 50,
-	readPending100: 200,
-	reconcileNoChange100: 150,
-	reconcile500With100Changes: 1_500,
-	maintenanceIdleCycle: 300,
-	windowRefresh32Series: 500,
-	reAnchor100: 1_000,
-	reAnchorNoChangeCheck: 20,
-	permissionRead: 50,
-	dedupCheck: 20,
-	interfaceThreadUnit: 16,
-	stateFootprintBytes: 1_048_576,
-} as const;
-
-export type BudgetName = keyof typeof PERF_BUDGETS;
-
-export interface Measurement {
-	readonly name: BudgetName;
-	readonly label: string;
-	/** Milliseconds, or bytes for the footprint budget. */
-	readonly measured: number;
-	readonly budget: number;
-	readonly unit: 'ms' | 'bytes';
-	readonly passed: boolean;
-	/** Present where the budget also demands zero platform operations. */
-	readonly operationCount?: number;
-}
-
-export interface MeasurementReport {
-	readonly measurements: readonly Measurement[];
-	readonly passed: number;
-	readonly failed: number;
-	/** Budgets this harness structurally cannot measure. Never silently omitted. */
-	readonly requiresDevice: readonly string[];
-	readonly ranAt: number;
-}
-
-const TONE: ResolvedTone = {
-	toneId: 'perf',
-	version: 1,
-	android: {
-		channelId: 'perf.v1',
-		importance: 'default',
-		vibration: false,
-		badge: false,
-		bypassDnd: false,
-	},
-	ios: { categoryId: 'perf', interruptionLevel: 'active', badge: false },
-};
-
-export interface MeasureOptions {
-	/** Defaults to the real clock, which is what a device run needs. */
-	readonly clock?: () => number;
-	/** Identifier prefix, so a device run cannot collide with real notifications. */
-	readonly prefix?: string;
-}
-
-export async function runMeasurementHarness(
-	engine: NotificationEngineAdapter,
-	options: MeasureOptions = {},
-): Promise<MeasurementReport> {
-	const clock = options.clock ?? (() => Date.now());
-	const prefix = options.prefix ?? 'perf';
-	const measurements: Measurement[] = [];
-
-	const now = () => Date.now();
-	const zone = 'UTC';
-	const state = new StateManager({ store: createMemoryStore(), now });
-	const resolveTone = () => TONE;
-
-	const record = (
-		name: BudgetName,
-		label: string,
-		measured: number,
-		operationCount?: number,
-	): void => {
-		const budget = PERF_BUDGETS[name];
-		// A budget that also demands zero operations fails on either count.
-		const opsOk = operationCount === undefined || operationCount === 0;
-		measurements.push({
-			name,
-			label,
-			measured,
-			budget,
-			unit: name === 'stateFootprintBytes' ? 'bytes' : 'ms',
-			passed: measured <= budget && opsOk,
-			operationCount,
-		});
-	};
-
-	/** Median of three, so one scheduler hiccup does not decide a verdict. */
-	const timeOf = async (run: () => Promise<unknown>): Promise<number> => {
-		const samples: number[] = [];
-		for (let i = 0; i < 3; i += 1) {
-			const started = clock();
-			await run();
-			samples.push(clock() - started);
-		}
-		return samples.sort((a, b) => a - b)[1];
-	};
-
-	const request = (id: string, at: number): NotificationRequest => ({
-		id: `${prefix}:${id}`,
-		content: { title: id, body: 'Measurement harness entry' },
-		tone: 'perf',
-		moment: { at },
-		groupTag: prefix,
-	});
-
-	const scheduler = createScheduler({
-		engine,
-		resolveTone,
-		timeZone: () => zone,
-		now,
-		canScheduleExactly: () => true,
-	});
-
-	await engine.cancelAll();
-
-	// --- Scheduling -----------------------------------------------------------
-
-	record(
-		'scheduleOne',
-		'Single schedule operation',
-		await timeOf(() => scheduler.schedule(request('single', now() + 3_600_000))),
-	);
-
-	for (let i = 0; i < 100; i += 1) {
-		await scheduler.schedule(request(`bulk:${i}`, now() + (i + 1) * 60_000));
-	}
-
-	record('readPending100', 'Read pending set of 100', await timeOf(() => scheduler.getPending()));
-
-	// --- Reconciliation -------------------------------------------------------
-
-	const reconciler = createReconciler({
-		engine,
-		resolveTone,
-		timeZone: () => zone,
-		now,
-		canScheduleExactly: () => true,
-	});
-
-	const hundred = Array.from({ length: 100 }, (_, i) =>
-		request(`recon:${i}`, now() + (i + 1) * 60_000),
-	);
-	await reconciler.reconcile({ domain: prefix, desired: hundred });
-
-	let noChangeOps = 0;
-	const noChangeMs = await timeOf(async () => {
-		const result = await reconciler.reconcile({ domain: prefix, desired: hundred });
-		noChangeOps = result.operationCount;
-	});
-	record('reconcileNoChange100', 'No-change reconcile over 100', noChangeMs, noChangeOps);
-
-	const fiveHundred = Array.from({ length: 500 }, (_, i) =>
-		request(`recon:${i}`, now() + (i + 1) * 60_000),
-	);
-	await reconciler.reconcile({ domain: prefix, desired: fiveHundred });
-
-	const changed = fiveHundred.map((entry, i) =>
-		i < 100 ? { ...entry, content: { title: `changed-${i}`, body: entry.content.body } } : entry,
-	);
-	record(
-		'reconcile500With100Changes',
-		'500-entry reconcile with 100 changes',
-		await timeOf(() => reconciler.reconcile({ domain: prefix, desired: changed })),
-	);
-
-	// --- Re-anchoring ---------------------------------------------------------
-
-	const pending = await engine.getPending();
-	record(
-		'reAnchorNoChangeCheck',
-		'Re-anchor check with no zone change',
-		await timeOf(async () => planReAnchor(pending, zone)),
-		planReAnchor(pending, zone).rewrites.length,
-	);
-
-	const context = { trigger: 'foreground' as const, now: now(), ownedIds: new Set<string>() };
-	const travelled = createReAnchorStep({
-		engine,
-		timeZone: () => 'Asia/Tokyo',
-		resolveTone,
-		canScheduleExactly: () => true,
-	});
-	record('reAnchor100', 'Re-anchor after a zone change', await timeOf(() => travelled.run(context)));
-
-	// --- Maintenance ----------------------------------------------------------
-
-	const registry = new MaintenanceRegistry();
-	registry.register(
-		createReAnchorStep({
-			engine,
-			timeZone: () => zone,
-			resolveTone,
-			canScheduleExactly: () => true,
-		}),
-	);
-
-	let idleOps = 0;
-	const idleMs = await timeOf(async () => {
-		const result = await registry.run({ ...context, now: now() });
-		idleOps = result.operationCount;
-	});
-	record('maintenanceIdleCycle', 'Idle maintenance cycle', idleMs, idleOps);
-
-	// --- Recurrence -----------------------------------------------------------
-
-	const recurrence = createRecurrence({
-		engine,
-		state,
-		resolveTone,
-		timeZone: () => zone,
-		now,
-		lookahead: { days: 60, occurrencesPerSeries: 32 },
-		canScheduleExactly: () => true,
-	});
-
-	const series: RecurrenceRule[] = Array.from({ length: 32 }, (_, i) => ({
-		id: `${prefix}:series:${i}`,
-		pattern: { kind: 'daily', hour: i % 24, minute: 0 },
-		end: { kind: 'count', count: 2 },
-		template: {
-			content: { title: `Series ${i}`, body: 'Measurement harness series' },
-			tone: 'perf',
-			groupTag: prefix,
-		},
-	}));
-
-	for (const rule of series) {
-		await recurrence.registerSeries(rule);
-	}
-
-	record(
-		'windowRefresh32Series',
-		'Window refresh across 32 series',
-		await timeOf(async () => {
-			for (const rule of series) {
-				await recurrence.refreshSeries(rule);
-			}
-		}),
-	);
-
-	// --- Permissions ----------------------------------------------------------
-
-	const permissions = createPermissions({
-		engine,
-		state,
-		platform: { os: 'android', apiLevel: 34 },
-		now,
-	});
-	record(
-		'permissionRead',
-		'Read all permission states',
-		await timeOf(() => permissions.getPermissions()),
-	);
-
-	// --- Deduplication and footprint -----------------------------------------
-
-	for (let i = 0; i < 400; i += 1) {
-		recordSeen(state, `${prefix}:dedup:${i}`, now());
-	}
-	record(
-		'dedupCheck',
-		'Deduplication ledger check',
-		await timeOf(async () => recordSeen(state, `${prefix}:dedup:probe`, now())),
-	);
-
-	record(
-		'stateFootprintBytes',
-		'Persisted state on disk at caps',
-		state.health().approximateBytes,
-	);
-
-	// The interface-thread ceiling is a property of one chunked unit of work, not
-	// of a whole pass, so it is measured per entry rather than per reconcile.
-	const chunkMs = await timeOf(() =>
-		reconciler.reconcile({ domain: prefix, desired: hundred.slice(0, 25) }),
-	);
-	record('interfaceThreadUnit', 'Single chunked unit of reconcile work', chunkMs / 25);
-
-	await engine.cancelAll();
-
-	const passed = measurements.filter(measurement => measurement.passed).length;
-
-	return {
-		measurements,
-		passed,
-		failed: measurements.length - passed,
-		// Stated rather than silently omitted — these need real hardware.
-		requiresDevice: [
-			'Delivery accuracy, exact mode (60 s) — needs the OS to fire a real alarm',
-			'Delivery accuracy, approximate mode (15 min) — needs a device under no vendor restriction',
-			'Cold-start tap to handler (500 ms) — needs a real process death and relaunch',
-			'App startup delta (100 ms) — needs a real cold start',
-			'Sustained frame rate during reconcile (55 fps) — needs a rendering device',
-		],
-		ranAt: now(),
-	};
-}
+/**
+ * The PERF-001 measurement harness.
+ *
+ * Every budget in the specification, measured against the real code paths and
+ * reported as pass or fail with the number that produced the verdict. Written
+ * as a plain async function rather than a Jest suite so the same harness runs
+ * in continuous integration and from the demo app on a physical device — which
+ * matters, because PERF-003 forbids emulator numbers standing in as evidence.
+ *
+ * Five budgets are deliberately absent and reported as such: delivery accuracy,
+ * cold-start latency, startup delta and frame rate cannot be measured
+ * in-process. The first needs the OS to actually fire an alarm, the second a
+ * real process death. Pretending to measure them here would be worse than
+ * leaving the gap visible.
+ */
+
+import type { NotificationEngineAdapter } from '../engine/adapter';
+import type { NotificationRequest } from '../contract/notification';
+import type { ResolvedTone } from '../contract/channel';
+import type { RecurrenceRule } from '../contract/recurrence';
+import { createScheduler } from '../schedule';
+import { createReconciler } from '../reconcile';
+import { createRecurrence } from '../recurrence';
+import { createPermissions } from '../permission';
+import { createReAnchorStep } from '../maintenance/reanchor';
+import { MaintenanceRegistry } from '../maintenance/cycle';
+import { StateManager } from '../state/record';
+import { createMemoryStore } from '../state/store';
+import { planReAnchor } from '../schedule/anchor';
+import { recordSeen } from '../state/dedup-ledger';
+
+/** Every budget PERF-001 states, in milliseconds unless the name says otherwise. */
+export const PERF_BUDGETS = {
+	scheduleOne: 50,
+	readPending100: 200,
+	reconcileNoChange100: 150,
+	reconcile500With100Changes: 1_500,
+	maintenanceIdleCycle: 300,
+	windowRefresh32Series: 500,
+	reAnchor100: 1_000,
+	reAnchorNoChangeCheck: 20,
+	permissionRead: 50,
+	dedupCheck: 20,
+	interfaceThreadUnit: 16,
+	stateFootprintBytes: 1_048_576,
+} as const;
+
+export type BudgetName = keyof typeof PERF_BUDGETS;
+
+export interface Measurement {
+	readonly name: BudgetName;
+	readonly label: string;
+	/** Milliseconds, or bytes for the footprint budget. */
+	readonly measured: number;
+	readonly budget: number;
+	readonly unit: 'ms' | 'bytes';
+	readonly passed: boolean;
+	/** Present where the budget also demands zero platform operations. */
+	readonly operationCount?: number;
+}
+
+export interface MeasurementReport {
+	readonly measurements: readonly Measurement[];
+	readonly passed: number;
+	readonly failed: number;
+	/** Budgets this harness structurally cannot measure. Never silently omitted. */
+	readonly requiresDevice: readonly string[];
+	readonly ranAt: number;
+}
+
+const TONE: ResolvedTone = {
+	toneId: 'perf',
+	version: 1,
+	android: {
+		channelId: 'perf.v1',
+		importance: 'default',
+		vibration: false,
+		badge: false,
+		bypassDnd: false,
+			name: 'Fixture tone',
+			loopSound: false,
+			alarmCategory: false,
+		},
+	ios: { categoryId: 'perf', interruptionLevel: 'active', badge: false, repeatRefused: false },
+};
+
+export interface MeasureOptions {
+	/** Defaults to the real clock, which is what a device run needs. */
+	readonly clock?: () => number;
+	/** Identifier prefix, so a device run cannot collide with real notifications. */
+	readonly prefix?: string;
+}
+
+export async function runMeasurementHarness(
+	engine: NotificationEngineAdapter,
+	options: MeasureOptions = {},
+): Promise<MeasurementReport> {
+	const clock = options.clock ?? (() => Date.now());
+	const prefix = options.prefix ?? 'perf';
+	const measurements: Measurement[] = [];
+
+	const now = () => Date.now();
+	const zone = 'UTC';
+	const state = new StateManager({ store: createMemoryStore(), now });
+	const resolveTone = () => TONE;
+
+	const record = (
+		name: BudgetName,
+		label: string,
+		measured: number,
+		operationCount?: number,
+	): void => {
+		const budget = PERF_BUDGETS[name];
+		// A budget that also demands zero operations fails on either count.
+		const opsOk = operationCount === undefined || operationCount === 0;
+		measurements.push({
+			name,
+			label,
+			measured,
+			budget,
+			unit: name === 'stateFootprintBytes' ? 'bytes' : 'ms',
+			passed: measured <= budget && opsOk,
+			operationCount,
+		});
+	};
+
+	/** Median of three, so one scheduler hiccup does not decide a verdict. */
+	const timeOf = async (run: () => Promise<unknown>): Promise<number> => {
+		const samples: number[] = [];
+		for (let i = 0; i < 3; i += 1) {
+			const started = clock();
+			await run();
+			samples.push(clock() - started);
+		}
+		return samples.sort((a, b) => a - b)[1];
+	};
+
+	const request = (id: string, at: number): NotificationRequest => ({
+		id: `${prefix}:${id}`,
+		content: { title: id, body: 'Measurement harness entry' },
+		tone: 'perf',
+		moment: { at },
+		groupTag: prefix,
+	});
+
+	const scheduler = createScheduler({
+		engine,
+		resolveTone,
+		timeZone: () => zone,
+		now,
+		canScheduleExactly: () => true,
+	});
+
+	await engine.cancelAll();
+
+	// --- Scheduling -----------------------------------------------------------
+
+	record(
+		'scheduleOne',
+		'Single schedule operation',
+		await timeOf(() => scheduler.schedule(request('single', now() + 3_600_000))),
+	);
+
+	for (let i = 0; i < 100; i += 1) {
+		await scheduler.schedule(request(`bulk:${i}`, now() + (i + 1) * 60_000));
+	}
+
+	record('readPending100', 'Read pending set of 100', await timeOf(() => scheduler.getPending()));
+
+	// --- Reconciliation -------------------------------------------------------
+
+	const reconciler = createReconciler({
+		engine,
+		resolveTone,
+		timeZone: () => zone,
+		now,
+		canScheduleExactly: () => true,
+	});
+
+	const hundred = Array.from({ length: 100 }, (_, i) =>
+		request(`recon:${i}`, now() + (i + 1) * 60_000),
+	);
+	await reconciler.reconcile({ domain: prefix, desired: hundred });
+
+	let noChangeOps = 0;
+	const noChangeMs = await timeOf(async () => {
+		const result = await reconciler.reconcile({ domain: prefix, desired: hundred });
+		noChangeOps = result.operationCount;
+	});
+	record('reconcileNoChange100', 'No-change reconcile over 100', noChangeMs, noChangeOps);
+
+	const fiveHundred = Array.from({ length: 500 }, (_, i) =>
+		request(`recon:${i}`, now() + (i + 1) * 60_000),
+	);
+	await reconciler.reconcile({ domain: prefix, desired: fiveHundred });
+
+	const changed = fiveHundred.map((entry, i) =>
+		i < 100 ? { ...entry, content: { title: `changed-${i}`, body: entry.content.body } } : entry,
+	);
+	record(
+		'reconcile500With100Changes',
+		'500-entry reconcile with 100 changes',
+		await timeOf(() => reconciler.reconcile({ domain: prefix, desired: changed })),
+	);
+
+	// --- Re-anchoring ---------------------------------------------------------
+
+	const pending = await engine.getPending();
+	record(
+		'reAnchorNoChangeCheck',
+		'Re-anchor check with no zone change',
+		await timeOf(async () => planReAnchor(pending, zone)),
+		planReAnchor(pending, zone).rewrites.length,
+	);
+
+	const context = { trigger: 'foreground' as const, now: now(), ownedIds: new Set<string>() };
+	const travelled = createReAnchorStep({
+		engine,
+		timeZone: () => 'Asia/Tokyo',
+		resolveTone,
+		canScheduleExactly: () => true,
+	});
+	record('reAnchor100', 'Re-anchor after a zone change', await timeOf(() => travelled.run(context)));
+
+	// --- Maintenance ----------------------------------------------------------
+
+	const registry = new MaintenanceRegistry();
+	registry.register(
+		createReAnchorStep({
+			engine,
+			timeZone: () => zone,
+			resolveTone,
+			canScheduleExactly: () => true,
+		}),
+	);
+
+	let idleOps = 0;
+	const idleMs = await timeOf(async () => {
+		const result = await registry.run({ ...context, now: now() });
+		idleOps = result.operationCount;
+	});
+	record('maintenanceIdleCycle', 'Idle maintenance cycle', idleMs, idleOps);
+
+	// --- Recurrence -----------------------------------------------------------
+
+	const recurrence = createRecurrence({
+		engine,
+		state,
+		resolveTone,
+		timeZone: () => zone,
+		now,
+		lookahead: { days: 60, occurrencesPerSeries: 32 },
+		canScheduleExactly: () => true,
+	});
+
+	const series: RecurrenceRule[] = Array.from({ length: 32 }, (_, i) => ({
+		id: `${prefix}:series:${i}`,
+		pattern: { kind: 'daily', hour: i % 24, minute: 0 },
+		end: { kind: 'count', count: 2 },
+		template: {
+			content: { title: `Series ${i}`, body: 'Measurement harness series' },
+			tone: 'perf',
+			groupTag: prefix,
+		},
+	}));
+
+	for (const rule of series) {
+		await recurrence.registerSeries(rule);
+	}
+
+	record(
+		'windowRefresh32Series',
+		'Window refresh across 32 series',
+		await timeOf(async () => {
+			for (const rule of series) {
+				await recurrence.refreshSeries(rule);
+			}
+		}),
+	);
+
+	// --- Permissions ----------------------------------------------------------
+
+	const permissions = createPermissions({
+		engine,
+		state,
+		platform: { os: 'android', apiLevel: 34 },
+		now,
+	});
+	record(
+		'permissionRead',
+		'Read all permission states',
+		await timeOf(() => permissions.getPermissions()),
+	);
+
+	// --- Deduplication and footprint -----------------------------------------
+
+	for (let i = 0; i < 400; i += 1) {
+		recordSeen(state, `${prefix}:dedup:${i}`, now());
+	}
+	record(
+		'dedupCheck',
+		'Deduplication ledger check',
+		await timeOf(async () => recordSeen(state, `${prefix}:dedup:probe`, now())),
+	);
+
+	record(
+		'stateFootprintBytes',
+		'Persisted state on disk at caps',
+		state.health().approximateBytes,
+	);
+
+	// The interface-thread ceiling is a property of one chunked unit of work, not
+	// of a whole pass, so it is measured per entry rather than per reconcile.
+	const chunkMs = await timeOf(() =>
+		reconciler.reconcile({ domain: prefix, desired: hundred.slice(0, 25) }),
+	);
+	record('interfaceThreadUnit', 'Single chunked unit of reconcile work', chunkMs / 25);
+
+	await engine.cancelAll();
+
+	const passed = measurements.filter(measurement => measurement.passed).length;
+
+	return {
+		measurements,
+		passed,
+		failed: measurements.length - passed,
+		// Stated rather than silently omitted — these need real hardware.
+		requiresDevice: [
+			'Delivery accuracy, exact mode (60 s) — needs the OS to fire a real alarm',
+			'Delivery accuracy, approximate mode (15 min) — needs a device under no vendor restriction',
+			'Cold-start tap to handler (500 ms) — needs a real process death and relaunch',
+			'App startup delta (100 ms) — needs a real cold start',
+			'Sustained frame rate during reconcile (55 fps) — needs a rendering device',
+		],
+		ranAt: now(),
+	};
+}