@chipmobilesdk/rn-payment 0.0.0-stage → 0.1.0

package/src/testing/fakeStore.ts

@@ -0,0 +1,341 @@
+/**
+ * Fake store — a full `ProviderPort` implementation for automated tests.
+ *
+ * Lives behind `@chipmobilesdk/rn-payment/testing` so test doubles cannot reach a
+ * production bundle.
+ *
+ * Nearly every requirement in this package concerns a rare ordering or failure
+ * path — a pending purchase settling two sessions later, an app killed between
+ * payment and acknowledgement, a billing connection dropping mid-sync. None of
+ * those are reachable on a real device on demand, so this is what makes them
+ * testable at all (NFR-007, SC-008).
+ */
+
+import type {
+	ProviderCapabilities,
+	ProviderConnectOutcome,
+	ProviderFailureReason,
+	ProviderPort,
+	ProviderPriceChangeOutcome,
+	ProviderProduct,
+	ProviderPurchase,
+	ProviderPurchaseOutcome,
+	ProviderPurchaseRequest,
+	ProviderToken,
+	StoreProductId,
+} from '../adapter/port';
+import type { ProductType, Unsubscribe } from '../config/types';
+
+export interface FakeStoreOptions {
+	/** Fails `connect` until `setConnectOutcome` says otherwise. */
+	connectOutcome?: ProviderConnectOutcome;
+	capabilities?: Partial<ProviderCapabilities>;
+	products?: ProviderProduct[];
+	owned?: ProviderPurchase[];
+}
+
+export interface FakeStore extends ProviderPort {
+	// --- Scripting the next purchase -------------------------------------------
+	/** Next `launchPurchase` succeeds and yields this purchase. */
+	scriptPurchaseSuccess(overrides?: Partial<ProviderPurchase>): void;
+	/** Next `launchPurchase` fails with this reason — cancellation included (FR-032). */
+	scriptPurchaseFailure(reason: ProviderFailureReason): void;
+	/** Next `launchPurchase` returns a purchase in the pending state (FR-037). */
+	scriptPurchasePending(overrides?: Partial<ProviderPurchase>): void;
+
+	// --- Store-side state ------------------------------------------------------
+	setOwned(purchases: ProviderPurchase[]): void;
+	/** Push a purchase through `observePurchases`, as a settling pending one does. */
+	pushPurchaseUpdate(purchase: ProviderPurchase): void;
+	/** Stop reporting a transaction as valid — a refund or revocation (FR-064). */
+	revoke(transactionId: string): void;
+	setProducts(products: ProviderProduct[]): void;
+
+	// --- Connection ------------------------------------------------------------
+	setConnectOutcome(outcome: ProviderConnectOutcome): void;
+	/** Drop the connection, as the billing service does (FR-020). */
+	dropConnection(reason?: string): void;
+	restoreConnection(): void;
+
+	// --- Finalization ----------------------------------------------------------
+	/** Make `acknowledge`/`consume` fail, to exercise bounded retry (FR-045). */
+	setFinalizeFailure(failing: boolean): void;
+
+	// --- Inspection ------------------------------------------------------------
+	acknowledged(): ProviderToken[];
+	consumed(): ProviderToken[];
+	connectCount(): number;
+	launchCount(): number;
+	queryOwnedCount(): number;
+	disconnectCount(): number;
+	subscriptionManagementOpenedFor(): (StoreProductId | undefined)[];
+	reset(): void;
+}
+
+const DEFAULT_CAPABILITIES: ProviderCapabilities = {
+	supportsSubscriptions: true,
+	supportsPlanChange: true,
+	supportsPriceChangeConfirmation: true,
+	// Matches Android reality: grace and hold are not separable client-side.
+	reportsGraceAndHoldDistinctly: false,
+	supportsExternalTransactions: false,
+	// The whole point of the fake: it moves no money, so the environment guard
+	// lets a test complete a purchase while still blocking the real adapter
+	// outside production (FR-014).
+	createsRealTransactions: false,
+};
+
+let sequence = 0;
+
+/** A purchase with sensible defaults, so tests state only what they care about. */
+export function makePurchase(
+	overrides: Partial<ProviderPurchase> = {},
+): ProviderPurchase {
+	sequence += 1;
+	return {
+		storeProductId: overrides.storeProductId ?? 'store.product.default',
+		transactionId: overrides.transactionId ?? `txn_${sequence}`,
+		token: overrides.token ?? `token_${sequence}`,
+		state: overrides.state ?? 'purchased',
+		purchasedAt: overrides.purchasedAt ?? 1_700_000_000_000,
+		isAcknowledged: overrides.isAcknowledged ?? false,
+		expiresAt: overrides.expiresAt,
+		willAutoRenew: overrides.willAutoRenew,
+		verificationPayload: overrides.verificationPayload ?? 'fake-verification',
+	};
+}
+
+export function createFakeStore(options: FakeStoreOptions = {}): FakeStore {
+	let connectOutcome: ProviderConnectOutcome = options.connectOutcome ?? {
+		ok: true,
+	};
+	let capabilities: ProviderCapabilities = {
+		...DEFAULT_CAPABILITIES,
+		...options.capabilities,
+	};
+	let products = [...(options.products ?? [])];
+	let owned = [...(options.owned ?? [])];
+
+	let scripted:
+		| { kind: 'success' | 'pending'; overrides?: Partial<ProviderPurchase> }
+		| { kind: 'failure'; reason: ProviderFailureReason }
+		| undefined;
+
+	let finalizeFails = false;
+	let connected = false;
+
+	const acknowledgedTokens: ProviderToken[] = [];
+	const consumedTokens: ProviderToken[] = [];
+	const managementOpenedFor: (StoreProductId | undefined)[] = [];
+	const connectionListeners = new Set<
+		(connected: boolean, reason?: string) => void
+	>();
+	const purchaseListeners = new Set<(purchase: ProviderPurchase) => void>();
+
+	let connectCalls = 0;
+	let launchCalls = 0;
+	let queryOwnedCalls = 0;
+	let disconnectCalls = 0;
+
+	const notifyConnection = (next: boolean, reason?: string): void => {
+		connected = next;
+		for (const listener of [...connectionListeners]) {
+			listener(next, reason);
+		}
+	};
+
+	return {
+		// --- ProviderPort ------------------------------------------------------
+		async connect(): Promise<ProviderConnectOutcome> {
+			connectCalls += 1;
+			if (connectOutcome.ok) {
+				notifyConnection(true);
+			}
+			return connectOutcome;
+		},
+
+		async disconnect(): Promise<void> {
+			disconnectCalls += 1;
+			if (connected) {
+				notifyConnection(false, 'disconnect');
+			}
+		},
+
+		observeConnection(listener): Unsubscribe {
+			connectionListeners.add(listener);
+			let removed = false;
+			return () => {
+				if (removed) {
+					return;
+				}
+				removed = true;
+				connectionListeners.delete(listener);
+			};
+		},
+
+		async queryProducts(
+			storeProductIds: StoreProductId[],
+			productType: ProductType,
+		): Promise<ProviderProduct[]> {
+			return products.filter(
+				p =>
+					storeProductIds.includes(p.storeProductId) &&
+					p.productType === productType,
+			);
+		},
+
+		async queryOwned(): Promise<ProviderPurchase[]> {
+			queryOwnedCalls += 1;
+			// Pending purchases are returned flagged, never filtered out: the engine
+			// must see them to raise the pending signal while never granting.
+			return [...owned];
+		},
+
+		async launchPurchase(
+			request: ProviderPurchaseRequest,
+		): Promise<ProviderPurchaseOutcome> {
+			launchCalls += 1;
+			const script = scripted;
+			scripted = undefined;
+
+			if (!script) {
+				return { ok: false, reason: 'store_error', detail: 'no script set' };
+			}
+			if (script.kind === 'failure') {
+				return { ok: false, reason: script.reason };
+			}
+
+			const purchase = makePurchase({
+				storeProductId: request.storeProductId,
+				state: script.kind === 'pending' ? 'pending' : 'purchased',
+				...script.overrides,
+			});
+			owned = [...owned.filter(p => p.transactionId !== purchase.transactionId), purchase];
+			return { ok: true, purchase };
+		},
+
+		observePurchases(listener): Unsubscribe {
+			purchaseListeners.add(listener);
+			let removed = false;
+			return () => {
+				if (removed) {
+					return;
+				}
+				removed = true;
+				purchaseListeners.delete(listener);
+			};
+		},
+
+		async acknowledge(token: ProviderToken): Promise<void> {
+			if (finalizeFails) {
+				throw new Error('fake acknowledge failure');
+			}
+			// Safe to call for an already-acknowledged transaction (FR-044).
+			if (!acknowledgedTokens.includes(token)) {
+				acknowledgedTokens.push(token);
+			}
+			owned = owned.map(p =>
+				p.token === token ? { ...p, isAcknowledged: true } : p,
+			);
+		},
+
+		async consume(token: ProviderToken): Promise<void> {
+			if (finalizeFails) {
+				throw new Error('fake consume failure');
+			}
+			if (!consumedTokens.includes(token)) {
+				consumedTokens.push(token);
+			}
+			// A consumed purchase stops being owned, which is what lets the same
+			// product be bought again (FR-043).
+			owned = owned.filter(p => p.token !== token);
+		},
+
+		async openSubscriptionManagement(
+			storeProductId?: StoreProductId,
+		): Promise<void> {
+			managementOpenedFor.push(storeProductId);
+		},
+
+		async confirmPriceChange(): Promise<ProviderPriceChangeOutcome> {
+			return { ok: true, confirmed: true };
+		},
+
+		capabilities: () => capabilities,
+
+		// --- Scripting ---------------------------------------------------------
+		scriptPurchaseSuccess(overrides) {
+			scripted = { kind: 'success', overrides };
+		},
+		scriptPurchaseFailure(reason) {
+			scripted = { kind: 'failure', reason };
+		},
+		scriptPurchasePending(overrides) {
+			scripted = { kind: 'pending', overrides };
+		},
+
+		// --- Store state -------------------------------------------------------
+		setOwned(purchases) {
+			owned = [...purchases];
+		},
+		pushPurchaseUpdate(purchase) {
+			owned = [
+				...owned.filter(p => p.transactionId !== purchase.transactionId),
+				purchase,
+			];
+			for (const listener of [...purchaseListeners]) {
+				listener(purchase);
+			}
+		},
+		revoke(transactionId) {
+			owned = owned.filter(p => p.transactionId !== transactionId);
+		},
+		setProducts(next) {
+			products = [...next];
+		},
+
+		// --- Connection --------------------------------------------------------
+		setConnectOutcome(outcome) {
+			connectOutcome = outcome;
+		},
+		dropConnection(reason = 'service_disconnected') {
+			notifyConnection(false, reason);
+		},
+		restoreConnection() {
+			notifyConnection(true);
+		},
+
+		// --- Finalization ------------------------------------------------------
+		setFinalizeFailure(failing) {
+			finalizeFails = failing;
+		},
+
+		// --- Inspection --------------------------------------------------------
+		acknowledged: () => [...acknowledgedTokens],
+		consumed: () => [...consumedTokens],
+		connectCount: () => connectCalls,
+		launchCount: () => launchCalls,
+		queryOwnedCount: () => queryOwnedCalls,
+		disconnectCount: () => disconnectCalls,
+		subscriptionManagementOpenedFor: () => [...managementOpenedFor],
+
+		reset() {
+			connectOutcome = { ok: true };
+			capabilities = { ...DEFAULT_CAPABILITIES, ...options.capabilities };
+			products = [];
+			owned = [];
+			scripted = undefined;
+			finalizeFails = false;
+			connected = false;
+			acknowledgedTokens.length = 0;
+			consumedTokens.length = 0;
+			managementOpenedFor.length = 0;
+			connectionListeners.clear();
+			purchaseListeners.clear();
+			connectCalls = 0;
+			launchCalls = 0;
+			queryOwnedCalls = 0;
+			disconnectCalls = 0;
+		},
+	};
+}

package/src/testing/index.ts

@@ -0,0 +1,10 @@
+/**
+ * `@chipmobilesdk/rn-payment/testing` — test doubles.
+ *
+ * A separate entrypoint so the fake store cannot reach a production bundle
+ * (LIB-003). Nothing here is part of the package's public runtime contract.
+ */
+
+export { createFakeStore, makePurchase } from './fakeStore';
+export type { FakeStore, FakeStoreOptions } from './fakeStore';
+export { createMemorySnapshotStore } from '../persistence/mmkv-store';