d3ro-voice/apps/mobile-rn/__tests__/context-lifecycle-guards.test.tsx

467 lines
15 KiB
TypeScript

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<Promise<unknown>, []>(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<string, unknown> & {
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<T>() {
let resolve: (value: T) => void = () => undefined
let reject: (reason?: unknown) => void = () => undefined
const promise = new Promise<T>((res, rej) => {
resolve = res
reject = rej
})
return { promise, resolve, reject }
}
async function flushMicrotasks(): Promise<void> {
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<unknown[]>()
mockedAds.MobileAds.mockImplementation(() => ({
setRequestConfiguration: jest.fn(async () => undefined),
initialize: jest.fn(() => initGate.promise),
}))
let latestAds: ReturnType<typeof useMobileAds> | null = null
function Probe(): null {
latestAds = useMobileAds()
return null
}
let renderer!: ReactTestRenderer.ReactTestRenderer
await act(async () => {
renderer = ReactTestRenderer.create(
<MobileAdsProvider><Probe /></MobileAdsProvider>,
)
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(<MobileAdsProvider><Probe /></MobileAdsProvider>)
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<typeof useRewardedCredits> | 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<unknown>()
mockEntitlementHookValue.refresh = jest.fn(() => refreshGate.promise)
function Probe(): null {
latestRewarded = useRewardedCredits()
return null
}
let renderer!: ReactTestRenderer.ReactTestRenderer
await act(async () => {
renderer = ReactTestRenderer.create(
<MobileAdsProvider><Probe /></MobileAdsProvider>,
)
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<unknown>()
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<typeof useBilling> | null = null
function Probe(): null {
latestBilling = useBilling()
return null
}
let renderer!: ReactTestRenderer.ReactTestRenderer
await act(async () => {
renderer = ReactTestRenderer.create(
<BillingProvider><Probe /></BillingProvider>,
)
activeRenderer = renderer
await flushMicrotasks()
})
let pendingPurchase: Promise<unknown> = 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(<BillingProvider><Probe /></BillingProvider>)
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<typeof useDevice> | null = null
function Probe(): null {
latestDevice = useDevice()
return null
}
let renderer!: ReactTestRenderer.ReactTestRenderer
await act(async () => {
renderer = ReactTestRenderer.create(
<DeviceProvider><Probe /></DeviceProvider>,
)
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<string, unknown> = {
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<typeof actualModule.useEntitlement> | null = null
function Probe(): null {
latestEnt = actualModule.useEntitlement()
return null
}
let renderer!: ReactTestRenderer.ReactTestRenderer
await act(async () => {
renderer = ReactTestRenderer.create(
<actualModule.EntitlementProvider><Probe /></actualModule.EntitlementProvider>,
)
activeRenderer = renderer
await flushMicrotasks()
await new Promise<void>((resolve) => setTimeout(resolve, 0))
})
process.off('unhandledRejection', onUnhandled)
expect(unhandledError).toBe(null)
expect(latestEnt?.loading).toBe(false)
act(() => renderer.unmount())
})
})