/* eslint-disable @typescript-eslint/no-explicit-any */ import * as React from 'react' import { render as rtlRender, RenderResult } from '@testing-library/react-native' import { QueryClient, QueryClientProvider } from '@tanstack/react-query' import { RefreshProvider } from 'common-ui' import { AuthProvider } from '@/src/contexts/AuthContext' import { trpc, trpcClient } from '@/src/trpc-client' import { recordQueryInvalidation } from '../mocks/trpc-client' import { setJsonResponse } from '../mocks/fetch-json' import { __set as setSecureItem, __delete as deleteSecureItem } from '../mocks/secure-store-mock' import { AVAILABILITY_RESPONSE, PRODUCT_AVAILABILITY, PRODUCTS_RESPONSE, SLOTS, SLOTS_RESPONSE, STORES_RESPONSE, STORE_DETAIL_1, MERGED_PRODUCTS, AVAILABILITY, TEST_JWT, availabilityCacheUrl, productsCacheUrl, slotsCacheUrl, storeDetailCacheUrl, storesCacheUrl, A1, REGION_1, } from '../fixtures' import { useCentralProductStore } from '@/src/store/centralProductStore' import { useCentralSlotStore } from '@/src/store/centralSlotStore' import { useRegionStore } from '@/src/store/regionStore' import { useAddressStore } from '@/src/store/addressStore' export function createTestQueryClient(): QueryClient { const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false, gcTime: Infinity, staleTime: Infinity, refetchOnWindowFocus: false, }, mutations: { retry: false }, }, }) // Record real tRPC invalidations (`useUtils().x.invalidate()`) for the // existing `procedureInvalidations(path)` assertions. const originalInvalidate = queryClient.invalidateQueries.bind(queryClient) ;(queryClient as any).invalidateQueries = ((filters?: any, options?: any) => { recordQueryInvalidation(filters) return originalInvalidate(filters, options) }) as any return queryClient } type AuthMode = 'in' | 'out' | false export interface RenderOptions { queryClient?: QueryClient auth?: AuthMode withRefresh?: boolean userId?: string token?: string } export function seedAuthStorage(mode: AuthMode, userId = '5', token = TEST_JWT) { if (mode === 'in') { setSecureItem('authToken', token) setSecureItem('userId', userId) } else { deleteSecureItem('authToken') deleteSecureItem('userId') } } export interface RenderWithProvidersResult extends RenderResult { queryClient: QueryClient } export function renderWithProviders( ui: React.ReactElement, options: RenderOptions = {} ): RenderWithProvidersResult { const queryClient = options.queryClient ?? createTestQueryClient() const auth = options.auth ?? 'out' const withRefresh = options.withRefresh ?? true if (auth !== false) { // Synchronous seeding so AuthProvider's bootstrap effect reads the token. seedAuthStorage(auth, options.userId, options.token) } const Wrapper = ({ children }: { children: React.ReactNode }) => { let tree: React.ReactElement = React.createElement(React.Fragment, null, children) if (auth !== false) { tree = React.createElement(AuthProvider, null, tree) } if (withRefresh) { tree = React.createElement(RefreshProvider, { queryClient, children: tree } as any) } // Real tRPC React hooks need the real client + provider. tree = React.createElement(trpc.Provider, { client: trpcClient, queryClient, children: tree }) tree = React.createElement(QueryClientProvider, { client: queryClient }, tree) return tree } const result = rtlRender(ui, { wrapper: Wrapper }) return { ...result, queryClient } } /** Render and let queued effects / microtasks settle. */ export async function renderAndFlush( ui: React.ReactElement, options: RenderOptions = {} ): Promise { const result = renderWithProviders(ui, options) await flush() return result } /** Await a macrotask so promise chains and effects settle. */ export async function flush(times = 2) { const { act } = require('@testing-library/react-native') for (let index = 0; index < times; index += 1) { // eslint-disable-next-line no-await-in-loop await act(async () => { await new Promise((resolve) => setTimeout(resolve, 0)) }) } } /** * Register the standard regional CDN documents. Override any of them by calling * `setJsonResponse` again *after* this helper (later registrations win). */ export function seedJsonCache(overrides: { products?: any availability?: any slots?: any stores?: any storeDetail?: any regionId?: number } = {}) { const regionId = overrides.regionId ?? 1 setJsonResponse(productsCacheUrl(regionId), overrides.products ?? PRODUCTS_RESPONSE) setJsonResponse(availabilityCacheUrl(regionId), overrides.availability ?? AVAILABILITY_RESPONSE) setJsonResponse(slotsCacheUrl(regionId), overrides.slots ?? SLOTS_RESPONSE) setJsonResponse(`${slotsCacheUrl(regionId)}?v=123`, overrides.slots ?? SLOTS_RESPONSE) setJsonResponse(storesCacheUrl(regionId), overrides.stores ?? STORES_RESPONSE) setJsonResponse(storeDetailCacheUrl(1, regionId), overrides.storeDetail ?? STORE_DETAIL_1) setJsonResponse(storeDetailCacheUrl(2, regionId), overrides.storeDetail ?? STORE_DETAIL_1) } /** Populate the central product/slot stores so `useGetCart` can enrich lines. */ export function seedCentralStores(options: { products?: any[]; slots?: any[] } = {}) { const products = options.products ?? MERGED_PRODUCTS useCentralProductStore.getState().setProducts(products) useCentralSlotStore .getState() .setSlotsData((options.slots ?? SLOTS) as any, PRODUCT_AVAILABILITY as any, AVAILABILITY as any) } /** Select a browsing region (+ bound) without going through the location flow. */ export function seedRegion(region = REGION_1, boundId: number | null = 7) { useRegionStore.getState().setRegion(region as any, boundId) } export function seedSelectedAddress(addressId: number | null = A1.id) { useAddressStore.getState().setSelectedAddressId(addressId) } /** Convenience: the usual home/cart boot state (region + catalogue + cache). */ export function seedBoot(options: { auth?: AuthMode; addressId?: number | null } = {}) { seedJsonCache() seedCentralStores() seedRegion() seedSelectedAddress(options.addressId ?? null) } export function setConsoleErrorMock() { return jest.spyOn(console, 'error').mockImplementation(() => undefined) }