@chipmobilesdk/rn-notification 0.1.2 → 0.2.0

package/src/testing/fake-provider.ts

@@ -1,129 +1,129 @@
-/**
- * In-memory push provider for tests.
- *
- * Exists so the entire push surface — token lifecycle, receipt in every app
- * state, malformed payloads, redelivery, and provider unavailability — is
- * provable with no live provider and no device.
- *
- * It is also the second adapter that proves the swap costs a consumer nothing:
- * running the full push suite against this instead of the real provider must
- * pass with zero changes to consuming code.
- */
-
-import type {
-	PushAvailability,
-	PushProviderAdapter,
-} from '../push/provider-adapter';
-import type { Unsubscribe } from '../contract/interaction';
-
-export interface FakeProviderOptions {
-	readonly name?: string;
-	readonly availability?: PushAvailability;
-	readonly initialToken?: string;
-	/** When true, `getToken` resolves only after `releaseToken()` is called. */
-	readonly withholdToken?: boolean;
-	readonly invalidationSucceeds?: boolean;
-}
-
-export interface FakeProviderControls {
-	/** Delivers a raw payload as the provider would. */
-	deliver(raw: unknown): void;
-	/** Queues the payload that launched the app. */
-	queueInitial(raw: unknown): void;
-	/** Simulates the platform rotating the registration token. */
-	rotateToken(token: string): void;
-	/** Resolves a withheld token, so "waits for availability" is testable. */
-	releaseToken(token: string): void;
-	setAvailability(availability: PushAvailability): void;
-	readonly invalidated: boolean;
-}
-
-export type FakeProvider = PushProviderAdapter & FakeProviderControls;
-
-export function createFakeProvider(options: FakeProviderOptions = {}): FakeProvider {
-	let availability: PushAvailability = options.availability ?? 'available';
-	let token = options.withholdToken === true ? undefined : (options.initialToken ?? 'fake-token-1');
-	let invalidated = false;
-	let messageHandlers: ((raw: unknown) => void)[] = [];
-	let tokenHandlers: ((token: string) => void)[] = [];
-	let initial: unknown | undefined;
-	let waiters: ((token: string) => void)[] = [];
-
-	return {
-		name: options.name ?? 'fake-provider',
-
-		async getAvailability() {
-			return availability;
-		},
-
-		async getToken() {
-			if (token !== undefined) return token;
-			// Waits rather than returning a placeholder — an empty string presented
-			// as a token is worse than not answering yet.
-			return new Promise<string>(resolve => {
-				waiters.push(resolve);
-			});
-		},
-
-		onTokenChange(handler): Unsubscribe {
-			tokenHandlers.push(handler);
-			return () => {
-				tokenHandlers = tokenHandlers.filter(h => h !== handler);
-			};
-		},
-
-		async invalidateToken() {
-			invalidated = true;
-			token = undefined;
-			return options.invalidationSucceeds ?? true;
-		},
-
-		subscribeToMessages(handler): Unsubscribe {
-			messageHandlers.push(handler);
-			return () => {
-				messageHandlers = messageHandlers.filter(h => h !== handler);
-			};
-		},
-
-		async takeInitialMessage() {
-			const raw = initial;
-			initial = undefined;
-			return raw;
-		},
-
-		// --- FakeProviderControls ---------------------------------------------
-
-		deliver(raw) {
-			for (const handler of messageHandlers) {
-				handler(raw);
-			}
-		},
-
-		queueInitial(raw) {
-			initial = raw;
-		},
-
-		rotateToken(next) {
-			token = next;
-			for (const handler of tokenHandlers) {
-				handler(next);
-			}
-		},
-
-		releaseToken(next) {
-			token = next;
-			for (const resolve of waiters) {
-				resolve(next);
-			}
-			waiters = [];
-		},
-
-		setAvailability(next) {
-			availability = next;
-		},
-
-		get invalidated() {
-			return invalidated;
-		},
-	};
-}
+/**
+ * In-memory push provider for tests.
+ *
+ * Exists so the entire push surface — token lifecycle, receipt in every app
+ * state, malformed payloads, redelivery, and provider unavailability — is
+ * provable with no live provider and no device.
+ *
+ * It is also the second adapter that proves the swap costs a consumer nothing:
+ * running the full push suite against this instead of the real provider must
+ * pass with zero changes to consuming code.
+ */
+
+import type {
+	PushAvailability,
+	PushProviderAdapter,
+} from '../push/provider-adapter';
+import type { Unsubscribe } from '../contract/interaction';
+
+export interface FakeProviderOptions {
+	readonly name?: string;
+	readonly availability?: PushAvailability;
+	readonly initialToken?: string;
+	/** When true, `getToken` resolves only after `releaseToken()` is called. */
+	readonly withholdToken?: boolean;
+	readonly invalidationSucceeds?: boolean;
+}
+
+export interface FakeProviderControls {
+	/** Delivers a raw payload as the provider would. */
+	deliver(raw: unknown): void;
+	/** Queues the payload that launched the app. */
+	queueInitial(raw: unknown): void;
+	/** Simulates the platform rotating the registration token. */
+	rotateToken(token: string): void;
+	/** Resolves a withheld token, so "waits for availability" is testable. */
+	releaseToken(token: string): void;
+	setAvailability(availability: PushAvailability): void;
+	readonly invalidated: boolean;
+}
+
+export type FakeProvider = PushProviderAdapter & FakeProviderControls;
+
+export function createFakeProvider(options: FakeProviderOptions = {}): FakeProvider {
+	let availability: PushAvailability = options.availability ?? 'available';
+	let token = options.withholdToken === true ? undefined : (options.initialToken ?? 'fake-token-1');
+	let invalidated = false;
+	let messageHandlers: ((raw: unknown) => void)[] = [];
+	let tokenHandlers: ((token: string) => void)[] = [];
+	let initial: unknown | undefined;
+	let waiters: ((token: string) => void)[] = [];
+
+	return {
+		name: options.name ?? 'fake-provider',
+
+		async getAvailability() {
+			return availability;
+		},
+
+		async getToken() {
+			if (token !== undefined) return token;
+			// Waits rather than returning a placeholder — an empty string presented
+			// as a token is worse than not answering yet.
+			return new Promise<string>(resolve => {
+				waiters.push(resolve);
+			});
+		},
+
+		onTokenChange(handler): Unsubscribe {
+			tokenHandlers.push(handler);
+			return () => {
+				tokenHandlers = tokenHandlers.filter(h => h !== handler);
+			};
+		},
+
+		async invalidateToken() {
+			invalidated = true;
+			token = undefined;
+			return options.invalidationSucceeds ?? true;
+		},
+
+		subscribeToMessages(handler): Unsubscribe {
+			messageHandlers.push(handler);
+			return () => {
+				messageHandlers = messageHandlers.filter(h => h !== handler);
+			};
+		},
+
+		async takeInitialMessage() {
+			const raw = initial;
+			initial = undefined;
+			return raw;
+		},
+
+		// --- FakeProviderControls ---------------------------------------------
+
+		deliver(raw) {
+			for (const handler of messageHandlers) {
+				handler(raw);
+			}
+		},
+
+		queueInitial(raw) {
+			initial = raw;
+		},
+
+		rotateToken(next) {
+			token = next;
+			for (const handler of tokenHandlers) {
+				handler(next);
+			}
+		},
+
+		releaseToken(next) {
+			token = next;
+			for (const resolve of waiters) {
+				resolve(next);
+			}
+			waiters = [];
+		},
+
+		setAvailability(next) {
+			availability = next;
+		},
+
+		get invalidated() {
+			return invalidated;
+		},
+	};
+}

package/src/testing/faults.ts

@@ -1,72 +1,72 @@
-/**
- * Fault injection.
- *
- * Every documented failure condition must be reachable on demand, or the claim
- * that each has its own distinct diagnostic is untestable. This is what the
- * demo app's fault panel and the conformance suite both drive.
- */
-
-import { ALL_DIAGNOSTIC_CODES, type DiagnosticCode } from '../contract/errors';
-
-export type FaultKind = DiagnosticCode;
-
-export interface FaultRecord {
-	readonly code: DiagnosticCode;
-	readonly at: number;
-}
-
-export interface Disposable {
-	dispose(): void;
-}
-
-export interface FaultInjectorOptions {
-	readonly now?: () => number;
-	readonly emit?: (code: string, message: string, context?: Record<string, unknown>) => void;
-}
-
-/**
- * Triggers a named condition and records that it fired.
- *
- * Deliberately a thin mechanism: it proves each identifier is reachable and
- * distinct, which is the property under test. Making the *real* condition occur
- * is each module's own test's job.
- */
-export function createFaultInjector(options: FaultInjectorOptions = {}) {
-	const now = options.now ?? (() => Date.now());
-	const emit = options.emit ?? (() => {});
-	const fired: FaultRecord[] = [];
-
-	return {
-		/** Every condition a consumer can reach from the fault panel. */
-		available: ALL_DIAGNOSTIC_CODES,
-
-		inject(kind: FaultKind): Disposable {
-			const record: FaultRecord = { code: kind, at: now() };
-			fired.push(record);
-			emit(kind, `Injected fault: ${kind}`, { injected: true });
-
-			return {
-				dispose() {
-					const index = fired.indexOf(record);
-					if (index >= 0) fired.splice(index, 1);
-				},
-			};
-		},
-
-		get fired(): readonly FaultRecord[] {
-			return fired;
-		},
-
-		/** Which documented conditions have not yet been exercised. */
-		unexercised(): readonly DiagnosticCode[] {
-			const seen = new Set(fired.map(record => record.code));
-			return ALL_DIAGNOSTIC_CODES.filter(code => !seen.has(code));
-		},
-
-		reset(): void {
-			fired.length = 0;
-		},
-	};
-}
-
-export type FaultInjector = ReturnType<typeof createFaultInjector>;
+/**
+ * Fault injection.
+ *
+ * Every documented failure condition must be reachable on demand, or the claim
+ * that each has its own distinct diagnostic is untestable. This is what the
+ * demo app's fault panel and the conformance suite both drive.
+ */
+
+import { ALL_DIAGNOSTIC_CODES, type DiagnosticCode } from '../contract/errors';
+
+export type FaultKind = DiagnosticCode;
+
+export interface FaultRecord {
+	readonly code: DiagnosticCode;
+	readonly at: number;
+}
+
+export interface Disposable {
+	dispose(): void;
+}
+
+export interface FaultInjectorOptions {
+	readonly now?: () => number;
+	readonly emit?: (code: string, message: string, context?: Record<string, unknown>) => void;
+}
+
+/**
+ * Triggers a named condition and records that it fired.
+ *
+ * Deliberately a thin mechanism: it proves each identifier is reachable and
+ * distinct, which is the property under test. Making the *real* condition occur
+ * is each module's own test's job.
+ */
+export function createFaultInjector(options: FaultInjectorOptions = {}) {
+	const now = options.now ?? (() => Date.now());
+	const emit = options.emit ?? (() => {});
+	const fired: FaultRecord[] = [];
+
+	return {
+		/** Every condition a consumer can reach from the fault panel. */
+		available: ALL_DIAGNOSTIC_CODES,
+
+		inject(kind: FaultKind): Disposable {
+			const record: FaultRecord = { code: kind, at: now() };
+			fired.push(record);
+			emit(kind, `Injected fault: ${kind}`, { injected: true });
+
+			return {
+				dispose() {
+					const index = fired.indexOf(record);
+					if (index >= 0) fired.splice(index, 1);
+				},
+			};
+		},
+
+		get fired(): readonly FaultRecord[] {
+			return fired;
+		},
+
+		/** Which documented conditions have not yet been exercised. */
+		unexercised(): readonly DiagnosticCode[] {
+			const seen = new Set(fired.map(record => record.code));
+			return ALL_DIAGNOSTIC_CODES.filter(code => !seen.has(code));
+		},
+
+		reset(): void {
+			fired.length = 0;
+		},
+	};
+}
+
+export type FaultInjector = ReturnType<typeof createFaultInjector>;