Skip to content
3 changes: 2 additions & 1 deletion AGENTS.md
Original file line number Diff line number Diff line change
Expand Up @@ -56,7 +56,8 @@ GestureHandlerRootView
└── ThemeProvider
└── APIProvider
└── AuthProvider
└── BottomSheetModalProvider
└── AnalyticsProvider
└── BottomSheetModalProvider
```

Never add a new provider outside `APIProvider` if it requires API access, or outside `AuthProvider` if it requires auth state.
Expand Down
217 changes: 217 additions & 0 deletions __tests__/components/providers/analytics-tracking.test.tsx
Original file line number Diff line number Diff line change
@@ -0,0 +1,217 @@
import { useSegments } from 'expo-router';

import { AnalyticsProvider } from '@/components/providers/analytics';
import {
useAnalyticsScreenTracking,
useAnalyticsSessionReset,
} from '@/components/providers/analytics-tracking';
import { useAuth } from '@/components/providers/auth';
import type { AnalyticsProviderAdapter } from '@/lib/analytics';
import { clearUserIdentified, hasIdentifiedUser, markUserIdentified } from '@/lib/analytics';
import { renderHook, waitFor } from '@/lib/test-utils';

jest.mock('expo-router', () => ({
useSegments: jest.fn(),
}));

jest.mock('@/components/providers/auth', () => ({
useAuth: jest.fn(),
}));

const mockUseSegments = useSegments as jest.MockedFunction<() => string[]>;
const mockUseAuth = useAuth as jest.MockedFunction<typeof useAuth>;

function mockAuthenticated(isAuthenticated: boolean) {
mockUseAuth.mockReturnValue({
token: isAuthenticated ? 'token' : null,
isAuthenticated,
loading: false,
ready: true,
logout: jest.fn(),
});
}

function createMockProvider() {
return {
init: jest.fn(),
trackEvent: jest.fn(),
trackScreen: jest.fn(),
reset: jest.fn(),
} satisfies AnalyticsProviderAdapter;
}

function renderWithAnalytics(hook: () => void, providers: ReadonlyArray<AnalyticsProviderAdapter>) {
const wrapper = ({ children }: { children: React.ReactNode }) => (
<AnalyticsProvider providers={providers}>{children}</AnalyticsProvider>
);
return renderHook(hook, { wrapper });
}

describe('useAnalyticsScreenTracking', () => {
beforeEach(() => {
jest.clearAllMocks();
});

it('tracks the current screen on mount', async () => {
const provider = createMockProvider();
mockUseSegments.mockReturnValue(['sign-in']);

renderWithAnalytics(useAnalyticsScreenTracking, [provider]);

await waitFor(() => {
expect(provider.trackScreen).toHaveBeenCalledWith('/sign-in', undefined);
});
expect(provider.trackScreen).toHaveBeenCalledTimes(1);
});

it('reports the route pattern, without route groups or dynamic values', async () => {
const provider = createMockProvider();
mockUseSegments.mockReturnValue(['(app)', 'feed', '[id]']);

renderWithAnalytics(useAnalyticsScreenTracking, [provider]);

await waitFor(() => {
expect(provider.trackScreen).toHaveBeenCalledWith('/feed/[id]', undefined);
});
});

it('reports the index route of a group as the root screen', async () => {
const provider = createMockProvider();
mockUseSegments.mockReturnValue(['(app)']);

renderWithAnalytics(useAnalyticsScreenTracking, [provider]);

await waitFor(() => {
expect(provider.trackScreen).toHaveBeenCalledWith('/', undefined);
});
});

it('tracks again when the route changes and not on unrelated re-renders', async () => {
const provider = createMockProvider();
mockUseSegments.mockReturnValue(['(app)', 'feed']);

const { rerender } = renderWithAnalytics(useAnalyticsScreenTracking, [provider]);
mockUseSegments.mockReturnValue(['(app)', 'feed']);
rerender({});

await waitFor(() => {
expect(provider.trackScreen).toHaveBeenCalledTimes(1);
});

mockUseSegments.mockReturnValue(['(app)', 'settings']);
rerender({});

await waitFor(() => {
expect(provider.trackScreen).toHaveBeenCalledTimes(2);
});
expect(provider.trackScreen).toHaveBeenLastCalledWith('/settings', undefined);
});

it('reports only the redirect target when the route changes within the same tick', async () => {
const provider = createMockProvider();
mockUseSegments.mockReturnValue(['(app)']);

const { rerender } = renderWithAnalytics(useAnalyticsScreenTracking, [provider]);
mockUseSegments.mockReturnValue(['sign-in']);
rerender({});

await waitFor(() => {
expect(provider.trackScreen).toHaveBeenCalledWith('/sign-in', undefined);
});
await new Promise(resolve => setImmediate(resolve));
expect(provider.trackScreen).toHaveBeenCalledTimes(1);
});

it('does not report the same screen again when the providers array changes identity', async () => {
const provider = createMockProvider();
mockUseSegments.mockReturnValue(['(app)', 'settings']);
const wrapper = ({ children }: { children: React.ReactNode }) => (
<AnalyticsProvider providers={[provider]}>{children}</AnalyticsProvider>
);

const { rerender } = renderHook(useAnalyticsScreenTracking, { wrapper });
await waitFor(() => {
expect(provider.trackScreen).toHaveBeenCalledTimes(1);
});

rerender({});
rerender({});
await new Promise(resolve => setImmediate(resolve));

expect(provider.trackScreen).toHaveBeenCalledTimes(1);
expect(provider.init).toHaveBeenCalledTimes(1);
});
});

describe('useAnalyticsSessionReset', () => {
beforeEach(() => {
jest.clearAllMocks();
clearUserIdentified();
});

it('resets analytics when the user signs out', async () => {
const provider = createMockProvider();
mockAuthenticated(true);
const { rerender } = renderWithAnalytics(useAnalyticsSessionReset, [provider]);

mockAuthenticated(false);
rerender({});

await waitFor(() => {
expect(provider.reset).toHaveBeenCalledTimes(1);
});
});

it('resets analytics when the app starts signed out after a user was identified', async () => {
const provider = createMockProvider();
markUserIdentified();
mockAuthenticated(false);
const { rerender } = renderWithAnalytics(useAnalyticsSessionReset, [provider]);
rerender({});

await waitFor(() => {
expect(provider.reset).toHaveBeenCalledTimes(1);
});
expect(hasIdentifiedUser()).toBe(false);
});

it('does not reset when the app starts signed out and no user was identified', async () => {
const provider = createMockProvider();
mockAuthenticated(false);
const { rerender } = renderWithAnalytics(useAnalyticsSessionReset, [provider]);
rerender({});

await waitFor(() => {
expect(provider.init).toHaveBeenCalledTimes(1);
});
await new Promise(resolve => setImmediate(resolve));
expect(provider.reset).not.toHaveBeenCalled();
});

it('does not reset when the app starts signed in', async () => {
const provider = createMockProvider();
mockAuthenticated(true);
const { rerender } = renderWithAnalytics(useAnalyticsSessionReset, [provider]);
rerender({});

await waitFor(() => {
expect(provider.init).toHaveBeenCalledTimes(1);
});
expect(provider.reset).not.toHaveBeenCalled();
});

it('does not reset when the user signs in', async () => {
const provider = createMockProvider();
mockAuthenticated(false);
const { rerender } = renderWithAnalytics(useAnalyticsSessionReset, [provider]);

mockAuthenticated(true);
rerender({});

await waitFor(() => {
expect(provider.init).toHaveBeenCalledTimes(1);
});
await new Promise(resolve => setImmediate(resolve));
expect(provider.reset).not.toHaveBeenCalled();
});
});
Loading
Loading