@chipmobilesdk/rn-ads 0.3.0 → 0.5.0

package/src/testing/index.ts

@@ -26,6 +26,7 @@ import type {
 	EngineConsentInfo,
 	EngineConsentOptions,
 	EnginePrivacy,
+	EngineRequestOptions,
 } from '../engine/port';
 
 /**
@@ -97,9 +98,27 @@ export function createTestClock(startMs = 1_000_000): TestClock {
 export type FakeConsentCall =
 	| { readonly kind: 'requestInfoUpdate'; readonly options: EngineConsentOptions }
 	| { readonly kind: 'showFormIfRequired' }
+	| { readonly kind: 'showPrivacyOptionsForm' }
 	| { readonly kind: 'getInfo' }
 	| { readonly kind: 'reset' };
 
+/**
+ * A privacy options form the test is holding open (0.4.0).
+ *
+ * Settle it whenever the test chooses, which is what lets `busy`, a second
+ * call, a consent update, and `dispose()` all be exercised *while* the form is
+ * on screen — in any order, rather than only the one a resolved promise allows.
+ */
+export interface HeldPrivacyOptionsForm {
+	/**
+	 * The user closes the form. `info` is what the provider reports afterwards,
+	 * merged over the current information; omit it for a user who changed nothing.
+	 */
+	close(info?: Partial<EngineConsentInfo>): void;
+	/** The form fails while open. */
+	fail(cause?: unknown): void;
+}
+
 export type FakeEngineCall =
 	| { readonly kind: 'initialize'; readonly privacy: EnginePrivacy }
 	| {
@@ -107,6 +126,8 @@ export type FakeEngineCall =
 			readonly format: FullScreenFormat;
 			readonly adUnitId: string;
 			readonly handleId: string;
+			/** Per-request privacy as the package sent it (FR-017's personalization half). */
+			readonly request?: EngineRequestOptions;
 	  }
 	| { readonly kind: 'show'; readonly handleId: string }
 	| { readonly kind: 'dispose'; readonly handleId: string };
@@ -133,6 +154,7 @@ const DEFAULT_CONSENT: EngineConsentInfo = {
 	status: 'not_required',
 	canRequestAds: true,
 	isFormAvailable: false,
+	privacyOptions: 'not_required',
 };
 
 export interface FakeAdsEngine extends AdsEngine {
@@ -166,6 +188,19 @@ export interface FakeAdsEngine extends AdsEngine {
 	failConsentRequest(cause?: unknown): void;
 	/** Makes `showFormIfRequired` reject — dismissal is not consent (FR-106). */
 	failConsentForm(cause?: unknown): void;
+
+	/**
+	 * What the privacy options form reports when the user closes it, merged over
+	 * the current information. Unset, the form closes with nothing changed — the
+	 * same as a user who opens it and backs out.
+	 */
+	setPrivacyOptionsFormResult(info: Partial<EngineConsentInfo>): void;
+	/** Makes `showPrivacyOptionsForm` reject — a failure is never consent (FR-106). */
+	failPrivacyOptionsForm(cause?: unknown): void;
+	/** Holds the next privacy options form open until the test settles it. */
+	holdPrivacyOptionsForm(): HeldPrivacyOptionsForm;
+	/** Makes `getInfo` reject, for the case where even the re-read after a failed form fails. */
+	failConsentInfoRead(cause?: unknown): void;
 }
 
 export function createFakeAdsEngine(options: FakeEngineOptions = {}): FakeAdsEngine {
@@ -175,6 +210,11 @@ export function createFakeAdsEngine(options: FakeEngineOptions = {}): FakeAdsEng
 	let consentInfo: EngineConsentInfo = { ...DEFAULT_CONSENT, ...options.consentInfo };
 	let consentRequestFailure: unknown;
 	let consentFormFailure: unknown;
+	let privacyFormFailure: unknown;
+	let privacyFormResult: Partial<EngineConsentInfo> = {};
+	let consentReadFailure: unknown;
+	/** Set by `holdPrivacyOptionsForm`; consumed by the next form. */
+	let heldForm: Promise<Partial<EngineConsentInfo>> | null = null;
 
 	const consent: ConsentPort = {
 		async requestInfoUpdate(consentOptions) {
@@ -192,18 +232,49 @@ export function createFakeAdsEngine(options: FakeEngineOptions = {}): FakeAdsEng
 			// 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.
+			// A region that required a form is one that requires a way back into
+			// it, which is what the provider reports once consent is obtained.
 			if (consentInfo.status === 'required' && consentInfo.isFormAvailable) {
-				consentInfo = { status: 'obtained', canRequestAds: true, isFormAvailable: false };
+				consentInfo = {
+					status: 'obtained',
+					canRequestAds: true,
+					isFormAvailable: false,
+					privacyOptions: 'required',
+				};
+			}
+			return consentInfo;
+		},
+		async showPrivacyOptionsForm() {
+			consentCalls.push({ kind: 'showPrivacyOptionsForm' });
+			const held = heldForm;
+			heldForm = null;
+			if (held) {
+				// Rejects if the test calls `fail`, which is exactly the provider's
+				// failure path; resolves with what the user left behind otherwise.
+				consentInfo = { ...consentInfo, ...(await held) };
+				return consentInfo;
 			}
+			if (privacyFormFailure !== undefined) {
+				throw privacyFormFailure;
+			}
+			consentInfo = { ...consentInfo, ...privacyFormResult };
 			return consentInfo;
 		},
 		async getInfo() {
 			consentCalls.push({ kind: 'getInfo' });
+			if (consentReadFailure !== undefined) {
+				throw consentReadFailure;
+			}
 			return consentInfo;
 		},
 		reset() {
 			consentCalls.push({ kind: 'reset' });
-			consentInfo = { status: 'unknown', canRequestAds: false, isFormAvailable: true };
+			consentInfo = {
+				status: 'unknown',
+				canRequestAds: false,
+				isFormAvailable: true,
+				privacyOptions: 'unknown',
+			};
 		},
 	};
 	const listeners = new Map<string, Set<(event: EngineAdEvent) => void>>();
@@ -238,6 +309,37 @@ export function createFakeAdsEngine(options: FakeEngineOptions = {}): FakeAdsEng
 			consentFormFailure = cause;
 		},
 
+		setPrivacyOptionsFormResult(info) {
+			privacyFormResult = info;
+		},
+
+		failPrivacyOptionsForm(cause = new Error('privacy options form failed')) {
+			privacyFormFailure = cause;
+		},
+
+		holdPrivacyOptionsForm() {
+			let settle!: {
+				resolve: (info: Partial<EngineConsentInfo>) => void;
+				reject: (cause: unknown) => void;
+			};
+			const promise = new Promise<Partial<EngineConsentInfo>>((resolve, reject) => {
+				settle = { resolve, reject };
+			});
+			heldForm = promise;
+			return {
+				close(info = {}) {
+					settle.resolve(info);
+				},
+				fail(cause = new Error('privacy options form failed')) {
+					settle.reject(cause);
+				},
+			};
+		},
+
+		failConsentInfoRead(cause = new Error('consent information read failed')) {
+			consentReadFailure = cause;
+		},
+
 		isAvailable() {
 			return options.available !== false;
 		},
@@ -249,10 +351,10 @@ export function createFakeAdsEngine(options: FakeEngineOptions = {}): FakeAdsEng
 			}
 		},
 
-		async createFullScreen(format, adUnitId) {
+		async createFullScreen(format, adUnitId, request) {
 			counter += 1;
 			const id = `fake-${counter}`;
-			record({ kind: 'createFullScreen', format, adUnitId, handleId: id });
+			record({ kind: 'createFullScreen', format, adUnitId, handleId: id, request });
 			live.add(id);
 			// A real provider delivers `loaded` to a listener attached after the
 			// ad object exists, so the callback is queued here and flushed when