Merge branch 'dev' into test/explore-e2e

Author: im-saif

src/__tests__/hooks/tweets/useTweetDetail.test.tsx

@@ -0,0 +1,119 @@
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { renderHook, waitFor } from '@testing-library/react-native';
+
+import { useTweetDetail } from '@/hooks/tweets/useTweetDetail';
+import { getTweetCache } from '@/libs/tweetCache';
+import { getTweet } from '@/services/tweets';
+
+// Mock dependencies
+jest.mock('@/services/tweets', () => ({
+  getTweet: jest.fn(),
+}));
+
+jest.mock('@/libs/tweetCache', () => ({
+  getTweetCache: jest.fn(() => ({
+    setTweet: jest.fn(),
+    setTweets: jest.fn(),
+  })),
+}));
+
+describe('useTweetDetail', () => {
+  let queryClient: QueryClient;
+  const mockTweetCache = {
+    setTweet: jest.fn(),
+    setTweets: jest.fn(),
+  };
+
+  beforeEach(() => {
+    queryClient = new QueryClient({
+      defaultOptions: {
+        queries: {
+          retry: false,
+          retryDelay: 0, // No delay between retries for fast testing
+        },
+      },
+    });
+    jest.clearAllMocks();
+    (getTweetCache as jest.Mock).mockReturnValue(mockTweetCache);
+  });
+
+  const wrapper = ({ children }: { children: React.ReactNode }) => (
+    <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
+  );
+
+  it('fetches and caches tweet successfully', async () => {
+    const mockTweet = {
+      id: '123',
+      content: 'test tweet',
+      author: { id: 'u1', username: 'user1' },
+      rootTweet: { id: 'root1', content: 'root tweet' },
+      parentTweets: [{ id: 'p1', content: 'parent tweet' }],
+    };
+
+    (getTweet as jest.Mock).mockResolvedValue({
+      success: true,
+      data: mockTweet,
+    });
+
+    const { result } = renderHook(() => useTweetDetail('123'), { wrapper });
+
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+
+    expect(result.current.data).toEqual(mockTweet);
+    expect(mockTweetCache.setTweet).toHaveBeenCalledWith(mockTweet);
+    expect(mockTweetCache.setTweet).toHaveBeenCalledWith(mockTweet.rootTweet);
+    expect(mockTweetCache.setTweets).toHaveBeenCalledWith(mockTweet.parentTweets);
+  });
+
+  it('does not cache deleted root/parent tweets', async () => {
+    const mockTweet = {
+      id: '123',
+      content: 'test tweet',
+      rootTweet: { id: 'root1', isDeleted: true },
+      parentTweets: [
+        { id: 'p1', content: 'parent tweet' },
+        { id: 'p2', isDeleted: true },
+      ],
+    };
+
+    (getTweet as jest.Mock).mockResolvedValue({
+      success: true,
+      data: mockTweet,
+    });
+
+    const { result } = renderHook(() => useTweetDetail('123'), { wrapper });
+
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+
+    expect(mockTweetCache.setTweet).toHaveBeenCalledWith(mockTweet);
+    expect(mockTweetCache.setTweet).not.toHaveBeenCalledWith(
+      expect.objectContaining({ id: 'root1' })
+    );
+    expect(mockTweetCache.setTweets).toHaveBeenCalledWith([{ id: 'p1', content: 'parent tweet' }]);
+  });
+
+  it('handles 404 error by preventing retry', async () => {
+    interface ErrorWithStatus extends Error {
+      status: number;
+    }
+    const error = new Error('Not found') as ErrorWithStatus;
+    error.status = 404;
+    (getTweet as jest.Mock).mockRejectedValue(error);
+
+    const { result } = renderHook(() => useTweetDetail('123'), { wrapper });
+
+    await waitFor(() => expect(result.current.isError).toBe(true));
+    expect(result.current.failureCount).toBe(1); // Should fail once and not retry
+  });
+
+  it('throws error when response is not success', async () => {
+    (getTweet as jest.Mock).mockResolvedValue({
+      success: false,
+    });
+
+    const { result } = renderHook(() => useTweetDetail('123'), { wrapper });
+
+    await waitFor(() => expect(result.current.isError).toBe(true));
+    expect(result.current.error).toEqual(new Error('Failed to fetch tweet'));
+  });
+});

src/__tests__/hooks/tweets/useTweetReplies.test.tsx

@@ -0,0 +1,99 @@
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { renderHook, waitFor } from '@testing-library/react-native';
+
+import { useTweetReplies } from '@/hooks/tweets/useTweetReplies';
+import { getTweetCache } from '@/libs/tweetCache';
+import { getTweetReplies } from '@/services/tweets';
+
+// Mock dependencies
+jest.mock('@/services/tweets', () => ({
+  getTweetReplies: jest.fn(),
+}));
+
+jest.mock('@/libs/tweetCache', () => ({
+  getTweetCache: jest.fn(() => ({
+    setTweets: jest.fn(),
+  })),
+}));
+
+describe('useTweetReplies', () => {
+  let queryClient: QueryClient;
+  const mockTweetCache = {
+    setTweets: jest.fn(),
+  };
+
+  beforeEach(() => {
+    queryClient = new QueryClient({
+      defaultOptions: {
+        queries: {
+          retry: false,
+        },
+      },
+    });
+    jest.clearAllMocks();
+    (getTweetCache as jest.Mock).mockReturnValue(mockTweetCache);
+  });
+
+  const wrapper = ({ children }: { children: React.ReactNode }) => (
+    <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
+  );
+
+  it('fetches and caches first page of replies', async () => {
+    const mockReplies = [{ id: 'r1', content: 'reply 1' }];
+    (getTweetReplies as jest.Mock).mockResolvedValue({
+      data: mockReplies,
+      pagination: { hasNextPage: true, nextCursor: 'next-cursor' },
+    });
+
+    const { result } = renderHook(() => useTweetReplies('123'), { wrapper });
+
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+
+    expect(result.current.data?.pages[0].data).toEqual(mockReplies);
+    expect(mockTweetCache.setTweets).toHaveBeenCalledWith(mockReplies);
+  });
+
+  it('fetches next page with cursor', async () => {
+    // Setup mocks for sequential calls
+    (getTweetReplies as jest.Mock)
+      .mockResolvedValueOnce({
+        data: [{ id: 'r1', content: 'reply 1' }],
+        pagination: { hasNextPage: true, nextCursor: 'page2' },
+      })
+      .mockResolvedValueOnce({
+        data: [{ id: 'r2', content: 'reply 2' }],
+        pagination: { hasNextPage: false },
+      });
+
+    const { result } = renderHook(() => useTweetReplies('123'), { wrapper });
+
+    // Wait for first page
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+    expect(result.current.data?.pages).toHaveLength(1);
+
+    // Trigger next page
+    await result.current.fetchNextPage();
+
+    // Wait for the update
+    await waitFor(() => expect(result.current.data?.pages).toHaveLength(2));
+
+    // Verify calls
+    expect(getTweetReplies).toHaveBeenCalledTimes(2);
+    expect(getTweetReplies).toHaveBeenLastCalledWith(
+      '123',
+      expect.objectContaining({ cursor: 'page2' })
+    );
+  });
+
+  it('handles empty response gracefully', async () => {
+    (getTweetReplies as jest.Mock).mockResolvedValue({
+      data: [],
+      pagination: { hasNextPage: false },
+    });
+
+    const { result } = renderHook(() => useTweetReplies('123'), { wrapper });
+
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+    expect(result.current.data?.pages[0].data).toEqual([]);
+  });
+});

src/__tests__/screens/settings/SettingsScreen.test.tsx

@@ -7,6 +7,7 @@ const mockNavigate = jest.fn();
 jest.mock('@react-navigation/native', () => ({
   useNavigation: () => ({
     push: mockNavigate,
+    navigate: mockNavigate,
   }),
 }));
 
@@ -47,4 +48,18 @@ describe('SettingsScreen', () => {
     fireEvent.press(getByText('Appearance'));
     expect(mockNavigate).toHaveBeenCalledWith('Appearance');
   });
+
+  it('navigates to Terms of Service screen when ToS card is pressed', () => {
+    const { getByText } = renderWithTheme(<SettingsScreen />);
+
+    fireEvent.press(getByText('Terms of Service'));
+    expect(mockNavigate).toHaveBeenCalledWith('TermsOfService');
+  });
+
+  it('navigates to Privacy Policy screen when Privacy Policy card is pressed', () => {
+    const { getByText } = renderWithTheme(<SettingsScreen />);
+
+    fireEvent.press(getByText('Privacy Policy'));
+    expect(mockNavigate).toHaveBeenCalledWith('PrivacyPolicy');
+  });
 });