@chipmobilesdk/rn-ads 0.1.0 → 0.2.0

package/src/testing/index.ts

@@ -17,13 +17,89 @@
  */
 
 import type { FullScreenFormat, Reward, Unsubscribe } from '../config/types';
+import type { Scheduler } from '../core/timers';
 import type {
 	AdsEngine,
+	ConsentPort,
 	EngineAdEvent,
 	EngineAdHandle,
+	EngineConsentInfo,
+	EngineConsentOptions,
 	EnginePrivacy,
 } from '../engine/port';
 
+/**
+ * A clock a test can move by hand.
+ *
+ * Retry backoff, app-open expiry, the undecided-state warning, and the
+ * ad-originated-return windows are all time-dependent, and all four must be
+ * assertable exactly rather than approximately. Advancing a clock makes "two
+ * retries, 2s then 4s" a precise assertion; sleeping would make it a flaky one.
+ *
+ * Callbacks fire in due order, and a callback scheduled *during* an advance is
+ * honored within the same advance if its deadline has also passed — matching how
+ * real timers behave when work chains.
+ */
+export interface TestClock {
+	now(): number;
+	advance(ms: number): void;
+	readonly scheduler: Scheduler;
+	pending(): number;
+}
+
+export function createTestClock(startMs = 1_000_000): TestClock {
+	let current = startMs;
+	let sequence = 0;
+	const timers = new Map<number, { at: number; callback: () => void }>();
+
+	const scheduler: Scheduler = {
+		setTimeout(callback, ms) {
+			sequence += 1;
+			timers.set(sequence, { at: current + ms, callback });
+			return sequence;
+		},
+		clearTimeout(handle) {
+			timers.delete(handle as number);
+		},
+	};
+
+	return {
+		now: () => current,
+		advance(ms) {
+			const target = current + ms;
+			// Loop rather than iterate once: a fired callback may schedule another
+			// timer that is also due before `target`, which is exactly what a retry
+			// chain does.
+			for (;;) {
+				let nextId: number | null = null;
+				let nextAt = Number.POSITIVE_INFINITY;
+				for (const [id, timer] of timers) {
+					if (timer.at <= target && timer.at < nextAt) {
+						nextAt = timer.at;
+						nextId = id;
+					}
+				}
+				if (nextId === null) {
+					break;
+				}
+				const timer = timers.get(nextId)!;
+				timers.delete(nextId);
+				current = timer.at;
+				timer.callback();
+			}
+			current = target;
+		},
+		scheduler,
+		pending: () => timers.size,
+	};
+}
+
+export type FakeConsentCall =
+	| { readonly kind: 'requestInfoUpdate'; readonly options: EngineConsentOptions }
+	| { readonly kind: 'showFormIfRequired' }
+	| { readonly kind: 'getInfo' }
+	| { readonly kind: 'reset' };
+
 export type FakeEngineCall =
 	| { readonly kind: 'initialize'; readonly privacy: EnginePrivacy }
 	| {
@@ -47,8 +123,18 @@ export interface FakeEngineOptions {
 	readonly neverCallBack?: boolean;
 	/** Rejects `show`, for the display-failure path (FR-044). */
 	readonly failShow?: unknown;
+	/** Initial consent information. Defaults to the not-required, allowed case. */
+	readonly consentInfo?: Partial<EngineConsentInfo>;
+	/** Drives time for retry, expiry, and the undecided warning. */
+	readonly clock?: TestClock;
 }
 
+const DEFAULT_CONSENT: EngineConsentInfo = {
+	status: 'not_required',
+	canRequestAds: true,
+	isFormAvailable: false,
+};
+
 export interface FakeAdsEngine extends AdsEngine {
 	/** Every call the package made, in order. */
 	readonly calls: readonly FakeEngineCall[];
@@ -66,10 +152,60 @@ export interface FakeAdsEngine extends AdsEngine {
 	listenerCount(): number;
 	/** Drops every recorded call, for tests that assert on a later window only. */
 	reset(): void;
+
+	/** The clock driving this engine's timers. Wire it into `createAds`. */
+	readonly clock: TestClock;
+	/** Moves the clock and fires anything due. */
+	advance(ms: number): void;
+
+	/** Every consent call the package made, in order (FR-113's assertion surface). */
+	readonly consentCalls: readonly FakeConsentCall[];
+	/** Sets what the consent platform will report from now on. */
+	setConsentInfo(info: Partial<EngineConsentInfo>): void;
+	/** Makes `requestInfoUpdate` reject — the flow must yield `error`, never granted. */
+	failConsentRequest(cause?: unknown): void;
+	/** Makes `showFormIfRequired` reject — dismissal is not consent (FR-106). */
+	failConsentForm(cause?: unknown): void;
 }
 
 export function createFakeAdsEngine(options: FakeEngineOptions = {}): FakeAdsEngine {
 	const calls: FakeEngineCall[] = [];
+	const consentCalls: FakeConsentCall[] = [];
+	const clock = options.clock ?? createTestClock();
+	let consentInfo: EngineConsentInfo = { ...DEFAULT_CONSENT, ...options.consentInfo };
+	let consentRequestFailure: unknown;
+	let consentFormFailure: unknown;
+
+	const consent: ConsentPort = {
+		async requestInfoUpdate(consentOptions) {
+			consentCalls.push({ kind: 'requestInfoUpdate', options: consentOptions });
+			if (consentRequestFailure !== undefined) {
+				throw consentRequestFailure;
+			}
+			return consentInfo;
+		},
+		async showFormIfRequired() {
+			consentCalls.push({ kind: 'showFormIfRequired' });
+			if (consentFormFailure !== undefined) {
+				throw consentFormFailure;
+			}
+			// A presented form that the user completes moves the status on. The
+			// fake only does this when a form was actually required, mirroring the
+			// provider: showing nothing cannot change an answer.
+			if (consentInfo.status === 'required' && consentInfo.isFormAvailable) {
+				consentInfo = { status: 'obtained', canRequestAds: true, isFormAvailable: false };
+			}
+			return consentInfo;
+		},
+		async getInfo() {
+			consentCalls.push({ kind: 'getInfo' });
+			return consentInfo;
+		},
+		reset() {
+			consentCalls.push({ kind: 'reset' });
+			consentInfo = { status: 'unknown', canRequestAds: false, isFormAvailable: true };
+		},
+	};
 	const listeners = new Map<string, Set<(event: EngineAdEvent) => void>>();
 	/** Callbacks queued before anyone subscribed; see `subscribe`. */
 	const pending = new Map<string, EngineAdEvent>();
@@ -82,6 +218,25 @@ export function createFakeAdsEngine(options: FakeEngineOptions = {}): FakeAdsEng
 
 	return {
 		calls,
+		consentCalls,
+		consent,
+		clock,
+
+		advance(ms) {
+			clock.advance(ms);
+		},
+
+		setConsentInfo(info) {
+			consentInfo = { ...consentInfo, ...info };
+		},
+
+		failConsentRequest(cause = new Error('consent request failed')) {
+			consentRequestFailure = cause;
+		},
+
+		failConsentForm(cause = new Error('consent form failed')) {
+			consentFormFailure = cause;
+		},
 
 		isAvailable() {
 			return options.available !== false;