import React from 'react' import ReactTestRenderer, { act } from 'react-test-renderer' import AsyncStorage from '@react-native-async-storage/async-storage' import { Platform } from 'react-native' const USER_A = '11111111-1111-4111-8111-111111111111' const USER_B = '22222222-2222-4222-8222-222222222222' const PRODUCT_ID = 'd3ro_voice_pro_monthly' let mockAuthState: { user: { id: string } | null purgeLocalSession: jest.Mock } = { user: { id: USER_A }, purgeLocalSession: jest.fn(async () => undefined), } const mockEntitlementHookValue = { loading: false, stale: false, error: null, snapshot: { tier: 'free', adFree: false, overageCredits: 0, provider: 'none', storeProductId: null, }, refresh: jest.fn, []>(async () => null), } const mockFrom = jest.fn() const mockFunctionsInvoke = jest.fn() jest.mock('../src/lib/auth-context', () => ({ useAuth: () => mockAuthState, })) jest.mock('../src/lib/entitlement-context', () => { const actual = jest.requireActual('../src/lib/entitlement-context') as typeof import('../src/lib/entitlement-context') return { ...actual, useEntitlement: jest.fn(() => mockEntitlementHookValue), } }) jest.mock('../src/lib/native-config', () => ({ getMobileRuntimeConfig: jest.fn(() => ({ debug: true, installedFromPlayStore: true, adMobBannerUnitId: 'ca-app-pub-3940256099942544/6300978111', adMobRewardedUnitId: 'ca-app-pub-3940256099942544/5224354917', })), })) jest.mock('../src/lib/supabase', () => ({ supabase: { from: (...args: unknown[]) => mockFrom(...args), functions: { invoke: (...args: unknown[]) => mockFunctionsInvoke(...args), }, channel: jest.fn(() => ({ on: jest.fn().mockReturnThis(), subscribe: jest.fn().mockReturnThis(), })), removeChannel: jest.fn(async () => 'ok'), }, })) const mockedEntitlement = jest.requireMock('../src/lib/entitlement-context') as { useEntitlement: jest.Mock EntitlementProvider: typeof import('../src/lib/entitlement-context').EntitlementProvider } const mockedAds = jest.requireActual('react-native-google-mobile-ads') as { AdsConsent: { gatherConsent: jest.Mock getConsentInfo: jest.Mock showPrivacyOptionsForm: jest.Mock } MobileAds: jest.Mock useRewardedAd: jest.Mock } const mockedIap = jest.requireActual('react-native-iap') as { useIAP: jest.Mock __stableUseIapResult: Record & { onPurchaseSuccess?: (purchase: unknown) => void } } import { MobileAdsProvider, useMobileAds, useRewardedCredits } from '../src/lib/mobile-ads-context' import { BillingProvider, useBilling } from '../src/lib/billing-context' import { DeviceProvider, useDevice } from '../src/lib/device-context' import { DeviceServiceError, registerCurrentDevice } from '../src/features/devices/device-service' function deferred() { let resolve: (value: T) => void = () => undefined let reject: (reason?: unknown) => void = () => undefined const promise = new Promise((res, rej) => { resolve = res reject = rej }) return { promise, resolve, reject } } async function flushMicrotasks(): Promise { for (let index = 0; index < 8; index += 1) await Promise.resolve() } describe('context lifecycle and concurrency guards', () => { const originalPlatform = Platform.OS let activeRenderer: ReactTestRenderer.ReactTestRenderer | null = null beforeAll(() => { Object.defineProperty(Platform, 'OS', { configurable: true, value: 'android' }) }) afterAll(() => { Object.defineProperty(Platform, 'OS', { configurable: true, value: originalPlatform }) }) beforeEach(async () => { await AsyncStorage.clear() mockAuthState = { user: { id: USER_A }, purgeLocalSession: jest.fn(async () => undefined), } mockEntitlementHookValue.loading = false mockEntitlementHookValue.stale = false mockEntitlementHookValue.error = null mockEntitlementHookValue.snapshot = { tier: 'free', adFree: false, overageCredits: 0, provider: 'none', storeProductId: null, } mockEntitlementHookValue.refresh = jest.fn(async () => null) mockedEntitlement.useEntitlement.mockImplementation(() => mockEntitlementHookValue) mockFrom.mockReset() mockFunctionsInvoke.mockReset() mockedAds.AdsConsent.gatherConsent.mockReset().mockResolvedValue({ canRequestAds: true, privacyOptionsRequirementStatus: 'NOT_REQUIRED', }) mockedAds.AdsConsent.getConsentInfo.mockReset().mockResolvedValue({ canRequestAds: true, privacyOptionsRequirementStatus: 'NOT_REQUIRED', }) mockedAds.MobileAds.mockReset().mockImplementation(() => ({ initialize: jest.fn(async () => []), setRequestConfiguration: jest.fn(async () => undefined), })) mockedIap.__stableUseIapResult.connected = true mockedIap.__stableUseIapResult.subscriptions = [] mockedIap.useIAP.mockImplementation(() => mockedIap.__stableUseIapResult) }) afterEach(() => { if (activeRenderer !== null) { const target = activeRenderer activeRenderer = null act(() => target.unmount()) } jest.restoreAllMocks() jest.useRealTimers() }) test('MobileAdsProvider_광고초기화중비대상전환시_ready로덮어쓰지않음', async () => { const initGate = deferred() mockedAds.MobileAds.mockImplementation(() => ({ setRequestConfiguration: jest.fn(async () => undefined), initialize: jest.fn(() => initGate.promise), })) let latestAds: ReturnType | null = null function Probe(): null { latestAds = useMobileAds() return null } let renderer!: ReactTestRenderer.ReactTestRenderer await act(async () => { renderer = ReactTestRenderer.create( , ) activeRenderer = renderer await flushMicrotasks() }) expect(latestAds?.status).toBe('initializing') // User upgrades to Pro (adFree: true -> eligible: false) while MobileAds().initialize() is pending. mockEntitlementHookValue.snapshot = { ...mockEntitlementHookValue.snapshot, tier: 'pro', adFree: true, } await act(async () => { renderer.update() await flushMicrotasks() }) expect(latestAds?.status).toBe('disabled') await act(async () => { initGate.resolve([]) await flushMicrotasks() }) expect(latestAds?.status).toBe('disabled') act(() => renderer.unmount()) }) test('useRewardedCredits_entitlement갱신중재시도시_이전검증완료상태로덮어쓰지않음', async () => { jest.useFakeTimers() let latestRewarded: ReturnType | null = null mockedAds.useRewardedAd.mockImplementation(() => ({ error: undefined, isClosed: false, isEarnedReward: true, isLoaded: true, isShowing: false, load: jest.fn(), show: jest.fn(), })) mockFrom.mockImplementation(() => ({ select: jest.fn().mockReturnThis(), eq: jest.fn().mockReturnThis(), maybeSingle: jest.fn(async () => ({ data: { overage_credits: 5 }, error: null })), })) const refreshGate = deferred() mockEntitlementHookValue.refresh = jest.fn(() => refreshGate.promise) function Probe(): null { latestRewarded = useRewardedCredits() return null } let renderer!: ReactTestRenderer.ReactTestRenderer await act(async () => { renderer = ReactTestRenderer.create( , ) activeRenderer = renderer await flushMicrotasks() }) await act(async () => { await jest.advanceTimersByTimeAsync(1_200) await flushMicrotasks() }) expect(mockEntitlementHookValue.refresh).toHaveBeenCalledTimes(1) // Call reload() while entitlement.refresh() is still in flight. act(() => { latestRewarded?.reload() }) expect(latestRewarded?.status).toBe('loading') await act(async () => { refreshGate.resolve(null) await flushMicrotasks() }) expect(latestRewarded?.status).toBe('loading') act(() => renderer.unmount()) }) test('BillingProvider_결제요청중계정전환시_이전계정오류로상태를덮어쓰지않음', async () => { const requestPurchaseGate = deferred() mockedIap.__stableUseIapResult.subscriptions = [{ id: PRODUCT_ID, platform: 'android', title: 'Pro Monthly', description: 'Pro', displayPrice: '$9.99', subscriptionOffers: [{ offerTokenAndroid: 'offer-token-1', displayPrice: '$9.99', basePlanIdAndroid: 'monthly', offerTagsAndroid: ['default'], }], }] mockedIap.__stableUseIapResult.getAvailablePurchases = jest.fn(async () => []) mockedIap.__stableUseIapResult.requestPurchase = jest.fn(() => requestPurchaseGate.promise) let latestBilling: ReturnType | null = null function Probe(): null { latestBilling = useBilling() return null } let renderer!: ReactTestRenderer.ReactTestRenderer await act(async () => { renderer = ReactTestRenderer.create( , ) activeRenderer = renderer await flushMicrotasks() }) let pendingPurchase: Promise = Promise.resolve() act(() => { pendingPurchase = latestBilling!.purchase(PRODUCT_ID).catch(() => undefined) }) await flushMicrotasks() expect(latestBilling?.operation).toBe('purchasing') // Account switches from USER_A to USER_B while Google Play purchase flow is pending. mockAuthState.user = { id: USER_B } await act(async () => { renderer.update() await flushMicrotasks() }) expect(latestBilling?.operation).toBe('idle') await act(async () => { requestPurchaseGate.reject(new Error('billing unavailable')) await pendingPurchase await flushMicrotasks() }) expect(latestBilling?.operation).toBe('idle') expect(latestBilling?.errorCode).toBe(null) activeRenderer = null act(() => renderer.unmount()) }) test('DeviceProvider_세션파기실패후재시도시_복구호출을영구차단하지않음', async () => { mockAuthState.purgeLocalSession .mockRejectedValueOnce(new Error('storage busy')) .mockResolvedValueOnce(undefined) const revokedRow = { id: 'device-1', user_id: USER_A, installation_id: '00000000-0000-4000-8000-000000000001', platform: 'android', device_name: 'Pixel 8', app_version: '1.0.0', os_version: 'Android 14', push_token: null, last_seen_at: '2026-08-21T00:00:00Z', revoked_at: '2026-08-21T00:00:05Z', created_at: '2026-08-20T00:00:00Z', updated_at: '2026-08-21T00:00:05Z', } mockFrom.mockImplementation(() => ({ select: jest.fn().mockReturnThis(), eq: jest.fn().mockReturnThis(), maybeSingle: jest.fn(async () => ({ data: revokedRow, error: null })), update: jest.fn().mockReturnThis(), single: jest.fn(async () => ({ data: revokedRow, error: null })), })) let latestDevice: ReturnType | null = null function Probe(): null { latestDevice = useDevice() return null } let renderer!: ReactTestRenderer.ReactTestRenderer await act(async () => { renderer = ReactTestRenderer.create( , ) activeRenderer = renderer await flushMicrotasks() }) expect(mockAuthState.purgeLocalSession).toHaveBeenCalledTimes(1) await act(async () => { await latestDevice?.refreshCurrentDevice() }) expect(mockAuthState.purgeLocalSession).toHaveBeenCalledTimes(2) act(() => renderer.unmount()) }) test('registerCurrentDevice_23505충돌반복시_무한재귀없이실패종료', async () => { const maybeSingle = jest.fn(async () => ({ data: null, error: null })) let attempts = 0 const single = jest.fn(async () => { attempts += 1 if (attempts <= 5) { return { data: null, error: { code: '23505', message: 'duplicate key value violates unique constraint' }, } } return { data: { id: 'device-after-loop', user_id: USER_A, installation_id: '00000000-0000-4000-8000-000000000001', platform: 'android', device_name: 'Pixel 8', app_version: '1.0.0', os_version: 'Android 14', push_token: null, last_seen_at: '2026-08-21T00:00:00Z', revoked_at: null, created_at: '2026-08-20T00:00:00Z', updated_at: '2026-08-21T00:00:00Z', }, error: null, } }) mockFrom.mockImplementation(() => ({ select: jest.fn().mockReturnThis(), eq: jest.fn().mockReturnThis(), maybeSingle, insert: jest.fn(() => ({ select: jest.fn(() => ({ single })), })), })) await expect( registerCurrentDevice(USER_A, { debug: true, packageName: 'com.d3ro.voice' } as never), ).rejects.toThrow(DeviceServiceError) expect(single).toHaveBeenCalledTimes(2) }) test('EntitlementProvider_캐시읽기실패시_미처리거부없이원격갱신진행', async () => { jest.spyOn(AsyncStorage, 'getItem').mockRejectedValueOnce(new Error('disk I/O failure')) mockFrom.mockImplementation((table: string) => { const result = table === 'subscriptions' ? { data: null, error: null } : { data: [], error: null } const builder: Record = { select: jest.fn(() => builder), eq: jest.fn(() => builder), order: jest.fn(() => builder), limit: jest.fn(() => builder), maybeSingle: jest.fn(async () => ({ data: null, error: null })), then: (resolve: (val: unknown) => unknown, reject: (err: unknown) => unknown) => ( Promise.resolve(result).then(resolve, reject) ), } return builder }) let unhandledError: unknown = null const onUnhandled = (reason: unknown): void => { unhandledError = reason } process.on('unhandledRejection', onUnhandled) const actualModule = jest.requireActual('../src/lib/entitlement-context') as typeof import('../src/lib/entitlement-context') let latestEnt: ReturnType | null = null function Probe(): null { latestEnt = actualModule.useEntitlement() return null } let renderer!: ReactTestRenderer.ReactTestRenderer await act(async () => { renderer = ReactTestRenderer.create( , ) activeRenderer = renderer await flushMicrotasks() await new Promise((resolve) => setTimeout(resolve, 0)) }) process.off('unhandledRejection', onUnhandled) expect(unhandledError).toBe(null) expect(latestEnt?.loading).toBe(false) act(() => renderer.unmount()) }) })