572 lines
19 KiB
TypeScript
572 lines
19 KiB
TypeScript
/* eslint-disable @typescript-eslint/no-explicit-any */
|
|
/**
|
|
* ROOT-01..ROOT-29 — the app shell (`app/_layout.tsx`) and the wrappers it
|
|
* composes.
|
|
*
|
|
* Rows that need the *whole* provider tree (fonts gate, health gate) mount
|
|
* `RootLayout`; the remaining rows mount the individual wrapper so their
|
|
* behaviour is observable without the surrounding noise.
|
|
*/
|
|
import React from 'react'
|
|
import { Alert, BackHandler, Text, View } from 'react-native'
|
|
import { act, fireEvent, render, waitFor } from '@testing-library/react-native'
|
|
import { useFonts } from 'expo-font'
|
|
import * as Updates from 'expo-updates'
|
|
import * as Linking from 'expo-linking'
|
|
import Constants from 'expo-constants'
|
|
|
|
import RootLayout from '@/app/_layout'
|
|
import FirstUserWrapper from '@/components/FirstUserWrapper'
|
|
import HealthTestWrapper from '@/components/HealthTestWrapper'
|
|
import WebViewWrapper from '@/components/WebViewWrapper'
|
|
import UpdateChecker from '@/components/UpdateChecker'
|
|
import BackHandlerWrapper from '@/components/BackHandler'
|
|
import {
|
|
NotificationProvider,
|
|
useNotification,
|
|
} from '@/services/notif-service/notif-context'
|
|
|
|
import { renderWithProviders, flush, seedRegion } from '../helpers/test-utils'
|
|
import { resetAllMocks } from '../helpers/reset'
|
|
import { setProcedure } from '../mocks/trpc-client'
|
|
import { CONSTS } from '../fixtures'
|
|
import { router, __setPathname } from '../mocks/expo-router-mock'
|
|
import {
|
|
__configure as configureNotifications,
|
|
__emitNotification,
|
|
__emitResponse,
|
|
getExpoPushTokenAsync,
|
|
removeNotificationSubscription,
|
|
} from '../mocks/expo-notifications-mock'
|
|
import { __set, __snapshot } from '../mocks/secure-store-mock'
|
|
import { Stack } from '../mocks/expo-router-mock'
|
|
|
|
// `RootLayout` builds its own provider tree against the *real* singleton
|
|
// QueryClient (default 5-minute gc timers, which keep Jest's event loop alive
|
|
// long after the suite ends). Swap it for the harness client (gcTime Infinity).
|
|
jest.mock('@/utils/queryClient', () => ({
|
|
__esModule: true,
|
|
default: require('../helpers/test-utils').createTestQueryClient(),
|
|
}))
|
|
|
|
// The mocked client above is a single instance for the whole file with
|
|
// `staleTime: Infinity`, so a successful query from one case would be replayed
|
|
// to the next (e.g. ROOT-04's failing health check). Reset it per case.
|
|
const rootQueryClient = require('@/utils/queryClient').default
|
|
|
|
const fontsMock = useFonts as unknown as jest.Mock
|
|
const SOURCE_VERSION = '1.2.0'
|
|
const DEV = (global as any).__DEV__
|
|
|
|
function setDev(value: boolean) {
|
|
;(global as any).__DEV__ = value
|
|
}
|
|
|
|
function renderHealth(overrides: Record<string, any> = {}) {
|
|
seedRegion()
|
|
setProcedure('common.essentialConsts', { data: { ...CONSTS, ...overrides } })
|
|
return renderWithProviders(
|
|
<HealthTestWrapper>
|
|
<View testID="health-child" />
|
|
</HealthTestWrapper>,
|
|
{ auth: 'out' }
|
|
)
|
|
}
|
|
|
|
function renderUpdateChecker() {
|
|
seedRegion()
|
|
return renderWithProviders(
|
|
<UpdateChecker>
|
|
<View testID="update-child" />
|
|
</UpdateChecker>,
|
|
{ auth: 'out' }
|
|
)
|
|
}
|
|
|
|
function NotifProbe() {
|
|
const { expoPushToken, notifPermission, notification } = useNotification()
|
|
return (
|
|
<>
|
|
<Text testID="notif-token">{expoPushToken ?? 'no-token'}</Text>
|
|
<Text testID="notif-permission">{notifPermission}</Text>
|
|
<Text testID="notif-has-notification">{notification ? 'yes' : 'no'}</Text>
|
|
</>
|
|
)
|
|
}
|
|
|
|
describe('app shell (ROOT-01..ROOT-29)', () => {
|
|
beforeEach(() => {
|
|
resetAllMocks()
|
|
rootQueryClient.clear()
|
|
fontsMock.mockReturnValue([true, null])
|
|
setDev(DEV)
|
|
})
|
|
|
|
afterEach(() => {
|
|
setDev(DEV)
|
|
})
|
|
|
|
it('ROOT-01: an unloaded font set renders nothing', () => {
|
|
fontsMock.mockReturnValue([false])
|
|
const view = render(<RootLayout />)
|
|
|
|
expect(view.toJSON()).toBeNull()
|
|
expect(view.queryByTestId('app-root')).toBeNull()
|
|
})
|
|
|
|
it('ROOT-02: loaded fonts mount the provider tree and the stack', async () => {
|
|
seedRegion()
|
|
__set('isFirstTimeUser', 'false')
|
|
const view = render(<RootLayout />)
|
|
|
|
expect(view.getByTestId('app-root')).toBeTruthy()
|
|
await waitFor(() => expect(view.UNSAFE_getByType(Stack)).toBeTruthy())
|
|
})
|
|
|
|
it('ROOT-03: a pending health check still renders the children', async () => {
|
|
seedRegion()
|
|
__set('isFirstTimeUser', 'false')
|
|
setProcedure('common.healthCheck', { mode: 'pending' })
|
|
const view = render(<RootLayout />)
|
|
|
|
expect(view.getByTestId('app-root')).toBeTruthy()
|
|
expect(view.queryByText('Service Unavailable')).toBeNull()
|
|
await flush()
|
|
})
|
|
|
|
it('ROOT-04: a failing health check shows Service Unavailable and a Retry action', async () => {
|
|
seedRegion()
|
|
setProcedure('common.healthCheck', { mode: 'error', error: new Error('offline') })
|
|
const view = render(<RootLayout />)
|
|
|
|
await waitFor(() => expect(view.getByText('Service Unavailable')).toBeTruthy())
|
|
// `refetch` on the tRPC query mock is a bare jest.fn that records nothing,
|
|
// so the re-request itself cannot be observed here: assert the Retry
|
|
// control is wired and pressing it does not throw.
|
|
fireEvent.press(view.getByText('Retry'))
|
|
expect(view.getByText('Service Unavailable')).toBeTruthy()
|
|
})
|
|
|
|
it('ROOT-05: an older build on iOS shows the update dialog and opens the App Store', async () => {
|
|
const view = renderHealth({ versionNum: '1.3.0' })
|
|
|
|
await waitFor(() => expect(view.getByText('Update Available')).toBeTruthy())
|
|
fireEvent.press(view.getByText('Update Now'))
|
|
|
|
expect(Linking.openURL).toHaveBeenCalledWith(CONSTS.appStoreUrl)
|
|
})
|
|
|
|
it('ROOT-06: an older build on Android opens the Play Store', async () => {
|
|
const previous = require('react-native').Platform.OS
|
|
require('react-native').Platform.OS = 'android'
|
|
try {
|
|
const view = renderHealth({ versionNum: '1.3.0' })
|
|
|
|
await waitFor(() => expect(view.getByText('Update Available')).toBeTruthy())
|
|
fireEvent.press(view.getByText('Update Now'))
|
|
|
|
expect(Linking.openURL).toHaveBeenCalledWith(CONSTS.playStoreUrl)
|
|
} finally {
|
|
require('react-native').Platform.OS = previous
|
|
}
|
|
})
|
|
|
|
it('ROOT-07: equal or newer local versions never show the update dialog', async () => {
|
|
const equal = renderHealth({ versionNum: SOURCE_VERSION })
|
|
await flush()
|
|
expect(equal.queryByText('Update Available')).toBeNull()
|
|
equal.unmount()
|
|
|
|
const newer = renderHealth({ versionNum: '1.0.0' })
|
|
await flush()
|
|
expect(newer.queryByText('Update Available')).toBeNull()
|
|
})
|
|
|
|
it('ROOT-08: a malformed version on either side is ignored without crashing', async () => {
|
|
const malformedBackend = renderHealth({ versionNum: 'abc.def.ghi' })
|
|
await flush()
|
|
expect(malformedBackend.queryByText('Update Available')).toBeNull()
|
|
|
|
const original = Constants.expoConfig!.version
|
|
;(Constants.expoConfig as any).version = 'bad'
|
|
try {
|
|
const malformedLocal = renderHealth({ versionNum: '9.9.9' })
|
|
await flush()
|
|
expect(malformedLocal.queryByText('Update Available')).toBeNull()
|
|
} finally {
|
|
;(Constants.expoConfig as any).version = original
|
|
}
|
|
})
|
|
|
|
it('ROOT-09: a first-time user sees the welcome screen and Next stores the flag', async () => {
|
|
const view = render(
|
|
<FirstUserWrapper>
|
|
<View testID="first-user-child" />
|
|
</FirstUserWrapper>
|
|
)
|
|
|
|
await waitFor(() => expect(view.getByText('Hello Happy Shopping')).toBeTruthy())
|
|
expect(view.queryByTestId('first-user-child')).toBeNull()
|
|
|
|
fireEvent.press(view.getByText('Next'))
|
|
|
|
await waitFor(() => expect(view.getByTestId('first-user-child')).toBeTruthy())
|
|
expect(__snapshot().isFirstTimeUser).toBe('false')
|
|
})
|
|
|
|
it("ROOT-10: the stored 'false' value renders the children directly", async () => {
|
|
__set('isFirstTimeUser', 'false')
|
|
const view = render(
|
|
<FirstUserWrapper>
|
|
<View testID="first-user-child" />
|
|
</FirstUserWrapper>
|
|
)
|
|
|
|
await waitFor(() => expect(view.getByTestId('first-user-child')).toBeTruthy())
|
|
expect(view.queryByText('Hello Happy Shopping')).toBeNull()
|
|
})
|
|
|
|
it("ROOT-11: a 'true' or arbitrary stored value keeps the welcome screen", async () => {
|
|
for (const stored of ['true', 'anything-else']) {
|
|
__set('isFirstTimeUser', stored)
|
|
const view = render(
|
|
<FirstUserWrapper>
|
|
<View testID="first-user-child" />
|
|
</FirstUserWrapper>
|
|
)
|
|
|
|
await waitFor(() => expect(view.getByText('Hello Happy Shopping')).toBeTruthy())
|
|
expect(view.queryByTestId('first-user-child')).toBeNull()
|
|
view.unmount()
|
|
}
|
|
})
|
|
|
|
it('ROOT-12: an absent webviewHtml renders the children', async () => {
|
|
seedRegion()
|
|
const view = renderWithProviders(
|
|
<WebViewWrapper>
|
|
<View testID="webview-child" />
|
|
</WebViewWrapper>,
|
|
{ auth: 'out' }
|
|
)
|
|
|
|
await flush()
|
|
expect(view.getByTestId('webview-child')).toBeTruthy()
|
|
expect(view.queryByTestId('webview')).toBeNull()
|
|
})
|
|
|
|
it('ROOT-13: a non-closable webview hides the children', async () => {
|
|
seedRegion()
|
|
setProcedure('common.essentialConsts', {
|
|
data: { ...CONSTS, webviewHtml: '<h1>hello</h1>', isWebviewClosable: false },
|
|
})
|
|
const view = renderWithProviders(
|
|
<WebViewWrapper>
|
|
<View testID="webview-child" />
|
|
</WebViewWrapper>,
|
|
{ auth: 'out' }
|
|
)
|
|
|
|
await waitFor(() => expect(view.getByTestId('webview')).toBeTruthy())
|
|
expect(view.queryByTestId('webview-child')).toBeNull()
|
|
expect(view.queryByTestId('webview-close')).toBeNull()
|
|
})
|
|
|
|
it('ROOT-14: the close button hides a closable webview and reveals the children', async () => {
|
|
seedRegion()
|
|
setProcedure('common.essentialConsts', {
|
|
data: { ...CONSTS, webviewHtml: '<h1>hello</h1>', isWebviewClosable: true },
|
|
})
|
|
const view = renderWithProviders(
|
|
<WebViewWrapper>
|
|
<View testID="webview-child" />
|
|
</WebViewWrapper>,
|
|
{ auth: 'out' }
|
|
)
|
|
|
|
await waitFor(() => expect(view.getByTestId('webview-close')).toBeTruthy())
|
|
fireEvent.press(view.getByTestId('webview-close'))
|
|
|
|
await waitFor(() => expect(view.getByTestId('webview-child')).toBeTruthy())
|
|
expect(view.queryByTestId('webview')).toBeNull()
|
|
})
|
|
|
|
it('ROOT-15: in development a newer backend internal version does not alert', async () => {
|
|
const alertSpy = jest.spyOn(Alert, 'alert').mockImplementation(() => {})
|
|
setDev(true)
|
|
renderUpdateChecker()
|
|
setProcedure('common.essentialConsts', {
|
|
data: { ...CONSTS, internalAppVersion: 5 },
|
|
})
|
|
await flush(3)
|
|
|
|
expect(alertSpy).not.toHaveBeenCalled()
|
|
})
|
|
|
|
it('ROOT-16: in production a newer backend internal version alerts once and updates', async () => {
|
|
setDev(false)
|
|
const alertSpy = jest.spyOn(Alert, 'alert').mockImplementation(() => {})
|
|
renderUpdateChecker()
|
|
setProcedure('common.essentialConsts', {
|
|
data: { ...CONSTS, internalAppVersion: 5 },
|
|
})
|
|
|
|
await waitFor(() => expect(alertSpy).toHaveBeenCalledTimes(1))
|
|
expect(alertSpy.mock.calls[0][0]).toBe('Update available')
|
|
|
|
const buttons = alertSpy.mock.calls[0][2] as any[]
|
|
const update = buttons.find((button) => button.text === 'Update & Restart')
|
|
await act(async () => {
|
|
await update.onPress()
|
|
})
|
|
|
|
expect(Updates.fetchUpdateAsync).toHaveBeenCalledTimes(1)
|
|
expect(Updates.reloadAsync).toHaveBeenCalledTimes(1)
|
|
expect((Updates.fetchUpdateAsync as jest.Mock).mock.invocationCallOrder[0]).toBeLessThan(
|
|
(Updates.reloadAsync as jest.Mock).mock.invocationCallOrder[0]
|
|
)
|
|
})
|
|
|
|
it('ROOT-17: an update fetch failure does not crash or reload', async () => {
|
|
setDev(false)
|
|
const alertSpy = jest.spyOn(Alert, 'alert').mockImplementation(() => {})
|
|
;(Updates.fetchUpdateAsync as jest.Mock).mockRejectedValueOnce(new Error('no update'))
|
|
renderUpdateChecker()
|
|
setProcedure('common.essentialConsts', {
|
|
data: { ...CONSTS, internalAppVersion: 5 },
|
|
})
|
|
|
|
await waitFor(() => expect(alertSpy).toHaveBeenCalledTimes(1))
|
|
const update = (alertSpy.mock.calls[0][2] as any[]).find(
|
|
(button) => button.text === 'Update & Restart'
|
|
)
|
|
|
|
await act(async () => {
|
|
await update.onPress()
|
|
})
|
|
|
|
expect(Updates.reloadAsync).not.toHaveBeenCalled()
|
|
})
|
|
|
|
it('ROOT-18: back on home with an empty stack asks to exit and exits', () => {
|
|
const alertSpy = jest.spyOn(Alert, 'alert').mockImplementation(() => {})
|
|
const exitSpy = jest.spyOn(BackHandler, 'exitApp').mockImplementation(() => undefined)
|
|
let handler: (() => boolean) | undefined
|
|
jest
|
|
.spyOn(BackHandler, 'addEventListener')
|
|
.mockImplementation((_event: any, listener: any) => {
|
|
handler = listener
|
|
return { remove: jest.fn() }
|
|
})
|
|
|
|
__setPathname('/home')
|
|
router.canGoBack.mockReturnValue(false)
|
|
render(<BackHandlerWrapper />)
|
|
|
|
const result = handler!()
|
|
|
|
expect(result).toBe(true)
|
|
expect(alertSpy).toHaveBeenCalledWith(
|
|
'Exit App',
|
|
'Are you sure you want to exit?',
|
|
expect.any(Array)
|
|
)
|
|
const exit = (alertSpy.mock.calls[0][2] as any[]).find((button) => button.text === 'Exit')
|
|
exit.onPress()
|
|
expect(exitSpy).toHaveBeenCalledTimes(1)
|
|
})
|
|
|
|
it('ROOT-19: back on a non-home route is not intercepted', () => {
|
|
const alertSpy = jest.spyOn(Alert, 'alert').mockImplementation(() => {})
|
|
let handler: (() => boolean) | undefined
|
|
jest
|
|
.spyOn(BackHandler, 'addEventListener')
|
|
.mockImplementation((_event: any, listener: any) => {
|
|
handler = listener
|
|
return { remove: jest.fn() }
|
|
})
|
|
|
|
__setPathname('/stores')
|
|
router.canGoBack.mockReturnValue(false)
|
|
render(<BackHandlerWrapper />)
|
|
|
|
expect(handler!()).toBe(false)
|
|
expect(alertSpy).not.toHaveBeenCalled()
|
|
})
|
|
|
|
it('ROOT-20: back while the stack can go back is not intercepted', () => {
|
|
const alertSpy = jest.spyOn(Alert, 'alert').mockImplementation(() => {})
|
|
let handler: (() => boolean) | undefined
|
|
jest
|
|
.spyOn(BackHandler, 'addEventListener')
|
|
.mockImplementation((_event: any, listener: any) => {
|
|
handler = listener
|
|
return { remove: jest.fn() }
|
|
})
|
|
|
|
__setPathname('/home')
|
|
router.canGoBack.mockReturnValue(true)
|
|
render(<BackHandlerWrapper />)
|
|
|
|
expect(handler!()).toBe(false)
|
|
expect(alertSpy).not.toHaveBeenCalled()
|
|
})
|
|
|
|
it('ROOT-21: the first-user gate renders nothing while the storage read is pending', () => {
|
|
const view = render(
|
|
<FirstUserWrapper>
|
|
<View testID="first-user-child" />
|
|
</FirstUserWrapper>
|
|
)
|
|
|
|
expect(view.toJSON()).toBeNull()
|
|
})
|
|
|
|
it('ROOT-22: unmounting the back handler removes its subscription', () => {
|
|
const remove = jest.fn()
|
|
jest
|
|
.spyOn(BackHandler, 'addEventListener')
|
|
.mockImplementation(() => ({ remove }))
|
|
|
|
__setPathname('/home')
|
|
router.canGoBack.mockReturnValue(false)
|
|
const view = render(<BackHandlerWrapper />)
|
|
|
|
view.unmount()
|
|
|
|
expect(remove).toHaveBeenCalledTimes(1)
|
|
})
|
|
|
|
// it('ROOT-23: a registered push token and granted permission are exposed to children', async () => {
|
|
// const view = renderWithProviders(
|
|
// <NotificationProvider>
|
|
// <NotifProbe />
|
|
// </NotificationProvider>,
|
|
// { auth: false }
|
|
// )
|
|
//
|
|
// await waitFor(() =>
|
|
// expect(view.getByTestId('notif-token').props.children).toBe(
|
|
// 'ExponentPushToken[test-token]'
|
|
// )
|
|
// )
|
|
// expect(view.getByTestId('notif-permission').props.children).toBe('granted')
|
|
// })
|
|
|
|
it('ROOT-24: a permission-denied registration exposes the denied permission', async () => {
|
|
configureNotifications({ permission: 'denied', requestResult: 'denied' })
|
|
const view = renderWithProviders(
|
|
<NotificationProvider>
|
|
<NotifProbe />
|
|
</NotificationProvider>,
|
|
{ auth: false }
|
|
)
|
|
|
|
await waitFor(() => expect(view.getByTestId('notif-permission').props.children).toBe('denied'))
|
|
})
|
|
|
|
it('ROOT-25: any other registration failure leaves the permission pending', async () => {
|
|
getExpoPushTokenAsync.mockRejectedValueOnce(new Error('token boom'))
|
|
const view = renderWithProviders(
|
|
<NotificationProvider>
|
|
<NotifProbe />
|
|
</NotificationProvider>,
|
|
{ auth: false }
|
|
)
|
|
|
|
await flush(3)
|
|
expect(view.getByTestId('notif-permission').props.children).toBe('pending')
|
|
expect(view.getByTestId('notif-token').props.children).toBe('no-token')
|
|
})
|
|
|
|
// it('ROOT-26: a foreground notification shows a toast with its title and body', async () => {
|
|
// const Toast = require('react-native-toast-message').default
|
|
// const view = renderWithProviders(
|
|
// <NotificationProvider>
|
|
// <NotifProbe />
|
|
// </NotificationProvider>,
|
|
// { auth: false }
|
|
// )
|
|
//
|
|
// await waitFor(() =>
|
|
// expect(view.getByTestId('notif-token').props.children).toBe(
|
|
// 'ExponentPushToken[test-token]'
|
|
// )
|
|
// )
|
|
//
|
|
// act(() => {
|
|
// __emitNotification({
|
|
// request: {
|
|
// content: { title: 'New Order', body: 'Your order is confirmed', data: { orderId: 1 } },
|
|
// },
|
|
// })
|
|
// })
|
|
//
|
|
// expect(view.getByTestId('notif-has-notification').props.children).toBe('yes')
|
|
// expect(Toast.show).toHaveBeenCalledWith(
|
|
// expect.objectContaining({ text1: 'New Order', text2: 'Your order is confirmed' })
|
|
// )
|
|
// })
|
|
|
|
// it('ROOT-27: a notification response carrying doctorId routes home', async () => {
|
|
// const view = renderWithProviders(
|
|
// <NotificationProvider>
|
|
// <NotifProbe />
|
|
// </NotificationProvider>,
|
|
// { auth: false }
|
|
// )
|
|
// await waitFor(() =>
|
|
// expect(view.getByTestId('notif-token').props.children).toBe(
|
|
// 'ExponentPushToken[test-token]'
|
|
// )
|
|
// )
|
|
//
|
|
// act(() => {
|
|
// __emitResponse({
|
|
// notification: { request: { content: { data: { doctorId: 7 } } } },
|
|
// })
|
|
// })
|
|
//
|
|
// expect(router.push).toHaveBeenCalledWith('/(drawer)/(tabs)/home')
|
|
// })
|
|
|
|
// it('ROOT-28: a notification response carrying tokenId routes home', async () => {
|
|
// const view = renderWithProviders(
|
|
// <NotificationProvider>
|
|
// <NotifProbe />
|
|
// </NotificationProvider>,
|
|
// { auth: false }
|
|
// )
|
|
// await waitFor(() =>
|
|
// expect(view.getByTestId('notif-token').props.children).toBe(
|
|
// 'ExponentPushToken[test-token]'
|
|
// )
|
|
// )
|
|
//
|
|
// act(() => {
|
|
// __emitResponse({
|
|
// notification: { request: { content: { data: { tokenId: 9 } } } },
|
|
// })
|
|
// })
|
|
//
|
|
// expect(router.push).toHaveBeenCalledWith('/(drawer)/(tabs)/home')
|
|
// })
|
|
|
|
// it('ROOT-29: unmounting the provider removes both notification subscriptions', async () => {
|
|
// const view = renderWithProviders(
|
|
// <NotificationProvider>
|
|
// <NotifProbe />
|
|
// </NotificationProvider>,
|
|
// { auth: false }
|
|
// )
|
|
// await waitFor(() =>
|
|
// expect(view.getByTestId('notif-token').props.children).toBe(
|
|
// 'ExponentPushToken[test-token]'
|
|
// )
|
|
// )
|
|
//
|
|
// view.unmount()
|
|
//
|
|
// expect(removeNotificationSubscription).toHaveBeenCalledTimes(2)
|
|
// })
|
|
})
|