freshyo/apps/user-ui/tests/lib/notifications.test.tsx
2026-10-18 21:51:01 +05:30

390 lines
14 KiB
TypeScript

/* eslint-disable @typescript-eslint/no-explicit-any */
/* eslint-disable @typescript-eslint/no-require-imports */
/**
* Section 25 "App helpers" — push notifications.
*
* Rows: NOTIF-01..07 (`registerForPushNotificationsAsync`),
* NOTIFC-01..05 (`NotificationProvider` + `NotifChecker`) and
* NOTIFR-01..07 (`NotifRegionSync`).
*
* Native swap-ins come from the shared mocks: `expo-notifications` is the
* configurable `tests/mocks/expo-notifications-mock`, `expo-device` defaults to a
* physical device and `expo-constants` carries a project id.
*
* `NotifRegionSync` reads the region through `useRegion` (covered by its own
* suite, `REGION-01..15`) so here it is replaced by a settable stub — otherwise
* every case would drag in the location fix + region resolve machinery.
*/
import * as React from 'react'
import { Linking, Modal, Platform } from 'react-native'
import { waitFor, fireEvent } from '@testing-library/react-native'
import { NOTIF_PERMISSION_DENIED } from 'common-ui/src/lib/const-strs'
import { registerForPushNotificationsAsync } from '@/services/notif-service/notif-register'
import {
NotificationProvider,
NotificationContext,
} from '@/services/notif-service/notif-context'
import NotifChecker from '@/services/notif-service/notif-checker'
import NotifRegionSync from '@/src/components/NotifRegionSync'
import { renderWithProviders, flush } from '../helpers/test-utils'
import { resetAllMocks } from '../helpers/reset'
import {
lastProcedureInput,
procedureMutationCalls,
setProcedure,
} from '../mocks/trpc-client'
import {
__configure as configureNotifications,
getExpoPushTokenAsync,
requestPermissionsAsync,
setNotificationChannelAsync,
} from '../mocks/expo-notifications-mock'
import { __setAuthState } from '../mocks/auth-context'
import { AUTH_USER } from '../fixtures'
/**
* `NotifRegionSync`'s only region dependency. `jest.mock` hoists above the
* imports, but the stub object is read lazily at render time.
*/
const mockUseRegion: { regionId: number | null; bound: { id: number } | null } = {
regionId: null,
bound: null,
}
jest.mock('@/src/hooks/useRegion', () => ({
useRegion: () => ({
region: null,
regionId: mockUseRegion.regionId,
boundId: null,
bound: mockUseRegion.bound,
regionGeneration: 0,
hydrated: true,
coords: null,
locationStatus: 'granted',
isResolvingRegion: false,
setRegion: jest.fn(),
clearRegion: jest.fn(),
refreshLocation: jest.fn(),
}),
}))
// Deterministic auth for `NotifChecker` (same replacement the README documents).
jest.mock('@/src/contexts/AuthContext', () => require('../mocks/auth-context'))
const IOS: typeof Platform.OS = 'ios'
function setPlatform(os: typeof Platform.OS) {
;(Platform as any).OS = os
}
function renderChecker(auth: boolean) {
__setAuthState({
isAuthenticated: auth,
isLoading: false,
user: auth ? AUTH_USER : null,
})
return renderWithProviders(
<NotificationProvider>
<NotifChecker />
</NotificationProvider>,
{ auth: auth ? 'in' : 'out' }
)
}
interface RegionSyncState {
token: string | null
notifPermission: 'pending' | 'granted' | 'denied'
regionId?: number | null
bound?: { id: number } | null
}
/** Builds a *fresh* element so `rerender` never bails out on identity. */
function regionSyncElement(state: RegionSyncState) {
mockUseRegion.regionId = state.regionId ?? null
mockUseRegion.bound = state.bound ?? null
return (
<NotificationContext.Provider
value={
{
expoPushToken: state.token,
notification: null,
error: null,
notifPermission: state.notifPermission,
} as any
}
>
<NotifRegionSync />
</NotificationContext.Provider>
)
}
function renderRegionSync(state: RegionSyncState) {
return renderWithProviders(regionSyncElement(state), { auth: false })
}
describe('notification helpers', () => {
beforeEach(() => {
resetAllMocks()
})
afterEach(() => {
setPlatform(IOS)
})
describe('registerForPushNotificationsAsync', () => {
it('NOTIF-01: Android creates the default notification channel', async () => {
setPlatform('android')
const token = await registerForPushNotificationsAsync()
expect(setNotificationChannelAsync).toHaveBeenCalledWith(
'default',
expect.objectContaining({ name: 'default', importance: 5 })
)
expect(token).toBe('ExponentPushToken[test-token]')
})
it('NOTIF-02: an already granted permission is not re-requested', async () => {
configureNotifications({ permission: 'granted' })
const token = await registerForPushNotificationsAsync()
expect(requestPermissionsAsync).not.toHaveBeenCalled()
expect(getExpoPushTokenAsync).toHaveBeenCalledWith({ projectId: 'test-project-id' })
expect(token).toBe('ExponentPushToken[test-token]')
})
it('NOTIF-03: a permission granted after the request returns the Expo token', async () => {
configureNotifications({ permission: 'undetermined', requestResult: 'granted' })
const token = await registerForPushNotificationsAsync()
expect(requestPermissionsAsync).toHaveBeenCalledTimes(1)
expect(token).toBe('ExponentPushToken[test-token]')
})
it('NOTIF-04: a denied permission throws the permission error', async () => {
configureNotifications({ permission: 'denied', requestResult: 'denied' })
await expect(registerForPushNotificationsAsync()).rejects.toThrow(
NOTIF_PERMISSION_DENIED
)
expect(getExpoPushTokenAsync).not.toHaveBeenCalled()
})
it('NOTIF-05: a missing project id throws', async () => {
// Freshly required module so the local `expo-constants` stub (no project
// id anywhere) is the one `notif-register` captured.
let isolated: typeof import('@/services/notif-service/notif-register') | undefined
jest.isolateModules(() => {
jest.doMock('expo-constants', () => ({
__esModule: true,
default: { expoConfig: { extra: {} }, easConfig: {} },
Constants: { expoConfig: { extra: {} }, easConfig: {} },
}))
isolated = require('@/services/notif-service/notif-register')
})
await expect(isolated!.registerForPushNotificationsAsync()).rejects.toThrow(
'Project ID not found'
)
})
it('NOTIF-06: a non-physical device throws', async () => {
let isolated: typeof import('@/services/notif-service/notif-register') | undefined
jest.isolateModules(() => {
jest.doMock('expo-device', () => ({ __esModule: true, isDevice: false }))
isolated = require('@/services/notif-service/notif-register')
})
await expect(isolated!.registerForPushNotificationsAsync()).rejects.toThrow(
'Must use physical device for push notifications'
)
})
it('NOTIF-07: a failing getExpoPushToken is wrapped', async () => {
getExpoPushTokenAsync.mockRejectedValueOnce(new Error('token boom'))
// The wrap replaces the error but keeps its message.
await expect(registerForPushNotificationsAsync()).rejects.toThrow('token boom')
})
})
describe('NotificationProvider / NotifChecker', () => {
it('NOTIFC-01: a granted token is saved through savePushToken', async () => {
renderChecker(true)
await waitFor(() =>
expect(lastProcedureInput('user.user.savePushToken')).toEqual({
token: 'ExponentPushToken[test-token]',
})
)
expect(procedureMutationCalls('user.user.savePushToken')).toHaveLength(1)
})
it('NOTIFC-02: a signed-out user still saves the token (current behaviour)', async () => {
// GAP: the effect lists `isAuthenticated` as a dependency but the guard
// never reads it, so the token is posted while signed out too. Pin the
// current behaviour; update when an auth check is added.
renderChecker(false)
await waitFor(() =>
expect(lastProcedureInput('user.user.savePushToken')).toEqual({
token: 'ExponentPushToken[test-token]',
})
)
})
it('NOTIFC-03: a denied permission opens the permission dialog', async () => {
configureNotifications({ permission: 'denied', requestResult: 'denied' })
const { getByText } = renderChecker(true)
await waitFor(() => expect(getByText('Notification Permission Denied')).toBeTruthy())
})
it('NOTIFC-04: the Settings button opens the device settings', async () => {
configureNotifications({ permission: 'denied', requestResult: 'denied' })
const openSettings = jest
.spyOn(Linking, 'openSettings')
.mockImplementation(async () => undefined)
const { getByText } = renderChecker(true)
await waitFor(() => expect(getByText('Notification Permission Denied')).toBeTruthy())
fireEvent.press(getByText('Settings'))
expect(openSettings).toHaveBeenCalledTimes(1)
})
it('NOTIFC-05: Cancel closes the dialog', async () => {
configureNotifications({ permission: 'denied', requestResult: 'denied' })
const { getByText, UNSAFE_getByType } = renderChecker(true)
await waitFor(() => expect(UNSAFE_getByType(Modal).props.visible).toBe(true))
fireEvent.press(getByText('Cancel'))
// NOTE: the RN Modal keeps its children mounted on iOS after the first
// show (`isRendered`), so the close state is asserted on the prop, not on
// the copy disappearing.
expect(UNSAFE_getByType(Modal).props.visible).toBe(false)
})
})
describe('NotifRegionSync', () => {
it('NOTIFR-01: no token, no region or a pending permission makes no call', async () => {
const cases: RegionSyncState[] = [
{ token: null, notifPermission: 'granted', regionId: 1 },
{ token: 'tok', notifPermission: 'granted', regionId: null },
{ token: 'tok', notifPermission: 'pending', regionId: 1 },
]
for (const state of cases) {
const view = renderRegionSync(state)
await flush()
expect(procedureMutationCalls('user.user.savePushToken')).toHaveLength(0)
expect(procedureMutationCalls('user.user.recordTrackedRegion')).toHaveLength(0)
view.unmount()
}
})
it('NOTIFR-02: a granted token + region saves the token with the region', async () => {
renderRegionSync({ token: 'tok', notifPermission: 'granted', regionId: 1 })
await waitFor(() =>
expect(lastProcedureInput('user.user.savePushToken')).toEqual({
token: 'tok',
regionId: 1,
})
)
expect(procedureMutationCalls('user.user.recordTrackedRegion')).toHaveLength(0)
})
it('NOTIFR-03: a location-derived bound also records the tracked region', async () => {
renderRegionSync({
token: 'tok',
notifPermission: 'granted',
regionId: 1,
bound: { id: 7 },
})
await waitFor(() =>
expect(lastProcedureInput('user.user.recordTrackedRegion')).toEqual({ regionId: 1 })
)
expect(lastProcedureInput('user.user.savePushToken')).toEqual({ token: 'tok', regionId: 1 })
})
it('NOTIFR-04: an address-derived region does not record a tracked region', async () => {
renderRegionSync({ token: 'tok', notifPermission: 'granted', regionId: 2, bound: null })
await waitFor(() =>
expect(lastProcedureInput('user.user.savePushToken')).toEqual({
token: 'tok',
regionId: 2,
})
)
expect(procedureMutationCalls('user.user.recordTrackedRegion')).toHaveLength(0)
})
it('NOTIFR-05: the same token/region/source is deduped', async () => {
const view = renderRegionSync({
token: 'tok',
notifPermission: 'granted',
regionId: 1,
bound: { id: 7 },
})
await waitFor(() => expect(procedureMutationCalls('user.user.savePushToken')).toHaveLength(1))
// Another location bound for the same region re-runs the effect but keeps
// the (token, region, 'loc') key.
view.rerender(
regionSyncElement({
token: 'tok',
notifPermission: 'granted',
regionId: 1,
bound: { id: 9 },
})
)
await flush()
expect(procedureMutationCalls('user.user.savePushToken')).toHaveLength(1)
expect(procedureMutationCalls('user.user.recordTrackedRegion')).toHaveLength(1)
})
it('NOTIFR-06: a region change triggers a new sync', async () => {
const view = renderRegionSync({
token: 'tok',
notifPermission: 'granted',
regionId: 1,
})
await waitFor(() => expect(procedureMutationCalls('user.user.savePushToken')).toHaveLength(1))
view.rerender(
regionSyncElement({ token: 'tok', notifPermission: 'granted', regionId: 2 })
)
await waitFor(() =>
expect(procedureMutationCalls('user.user.savePushToken')).toHaveLength(2)
)
expect(lastProcedureInput('user.user.savePushToken')).toEqual({ token: 'tok', regionId: 2 })
})
it('NOTIFR-07: a failing save is logged and not retried', async () => {
const consoleError = jest.spyOn(console, 'error').mockImplementation(() => undefined)
setProcedure('user.user.savePushToken', { mode: 'error', error: new Error('save boom') })
renderRegionSync({ token: 'tok', notifPermission: 'granted', regionId: 1 })
await waitFor(() => expect(consoleError).toHaveBeenCalled())
const logged = consoleError.mock.calls.some((call) =>
String(call[0]).includes('[NotifRegionSync] saving the region with the push token failed')
)
expect(logged).toBe(true)
// Best-effort telemetry: one attempt, no retry.
await flush(3)
expect(procedureMutationCalls('user.user.savePushToken')).toHaveLength(1)
})
})
})