467 lines
15 KiB
TypeScript
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())
|
|
})
|
|
})
|