feat: Add in CachedBundlesQueryOpts (#3644)

Author: nsdeschenes

src/services/bundleAnalysis/CachedBundlesQueryOpts.test.tsx

@@ -0,0 +1,290 @@
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
+import {
+  QueryClientProvider as QueryClientProviderV5,
+  QueryClient as QueryClientV5,
+  useQuery as useQueryV5,
+  useSuspenseQuery as useSuspenseQueryV5,
+} from '@tanstack/react-queryV5'
+import { renderHook, waitFor } from '@testing-library/react'
+import { graphql, HttpResponse } from 'msw'
+import { setupServer } from 'msw/node'
+import { Suspense } from 'react'
+import { MockInstance } from 'vitest'
+
+import { CachedBundlesQueryOpts } from './CachedBundlesQueryOpts'
+
+const mockBranchBundles = {
+  owner: {
+    repository: {
+      __typename: 'Repository',
+      branch: {
+        head: {
+          bundleAnalysis: {
+            bundleAnalysisReport: {
+              __typename: 'BundleAnalysisReport',
+              bundles: [{ name: 'bundle1', isCached: true }],
+            },
+          },
+        },
+      },
+    },
+  },
+}
+
+const mockUnsuccessfulParseError = {}
+
+const mockNullOwner = { owner: null }
+
+const mockRepoNotFound = {
+  owner: {
+    repository: {
+      __typename: 'NotFoundError',
+      message: 'Repository not found',
+    },
+  },
+}
+
+const mockOwnerNotActivated = {
+  owner: {
+    repository: {
+      __typename: 'OwnerNotActivatedError',
+      message: 'Owner not activated',
+    },
+  },
+}
+
+const server = setupServer()
+const queryClient = new QueryClient({
+  defaultOptions: { queries: { retry: false, suspense: true } },
+})
+const queryClientV5 = new QueryClientV5({
+  defaultOptions: { queries: { retry: false } },
+})
+
+const wrapper: React.FC<React.PropsWithChildren> = ({ children }) => (
+  <QueryClientProviderV5 client={queryClientV5}>
+    <QueryClientProvider client={queryClient}>
+      <Suspense fallback={<p>loading</p>}>{children}</Suspense>
+    </QueryClientProvider>
+  </QueryClientProviderV5>
+)
+
+beforeAll(() => {
+  server.listen()
+})
+
+afterEach(() => {
+  vi.clearAllMocks()
+  queryClient.clear()
+  queryClientV5.clear()
+  server.resetHandlers()
+})
+
+afterAll(() => {
+  server.close()
+})
+
+interface SetupArgs {
+  isNotFoundError?: boolean
+  isOwnerNotActivatedError?: boolean
+  isUnsuccessfulParseError?: boolean
+  isNullOwner?: boolean
+}
+
+describe('CachedBundlesQueryOpts', () => {
+  function setup({
+    isNotFoundError = false,
+    isOwnerNotActivatedError = false,
+    isUnsuccessfulParseError = false,
+    isNullOwner = false,
+  }: SetupArgs) {
+    const passedBranch = vi.fn()
+
+    server.use(
+      graphql.query('CachedBundleList', (info) => {
+        if (info.variables?.branch) {
+          passedBranch(info.variables?.branch)
+        }
+
+        if (isNotFoundError) {
+          return HttpResponse.json({ data: mockRepoNotFound })
+        } else if (isOwnerNotActivatedError) {
+          return HttpResponse.json({ data: mockOwnerNotActivated })
+        } else if (isUnsuccessfulParseError) {
+          return HttpResponse.json({ data: mockUnsuccessfulParseError })
+        } else if (isNullOwner) {
+          return HttpResponse.json({ data: mockNullOwner })
+        }
+
+        return HttpResponse.json({ data: mockBranchBundles })
+      })
+    )
+
+    return { passedBranch }
+  }
+
+  describe('returns repository typename of repository', () => {
+    describe('there is valid data', () => {
+      it('returns the bundle summary', async () => {
+        setup({})
+        const { result } = renderHook(
+          () =>
+            useSuspenseQueryV5(
+              CachedBundlesQueryOpts({
+                provider: 'gh',
+                owner: 'codecov',
+                repo: 'codecov',
+                branch: 'cool-branch',
+              })
+            ),
+          { wrapper }
+        )
+
+        const expectedResponse = {
+          bundles: [{ bundleName: 'bundle1', isCached: true }],
+        }
+
+        await waitFor(() =>
+          expect(result.current.data).toStrictEqual(expectedResponse)
+        )
+      })
+    })
+
+    describe('there is invalid data', () => {
+      it('returns a null value', async () => {
+        setup({ isNullOwner: true })
+        const { result } = renderHook(
+          () =>
+            useSuspenseQueryV5(
+              CachedBundlesQueryOpts({
+                provider: 'gh',
+                owner: 'codecov',
+                repo: 'codecov',
+                branch: 'cool-branch',
+              })
+            ),
+          { wrapper }
+        )
+
+        const expectedResponse = {
+          bundles: [],
+        }
+
+        await waitFor(() =>
+          expect(result.current.data).toStrictEqual(expectedResponse)
+        )
+      })
+    })
+  })
+
+  describe('returns NotFoundError __typename', () => {
+    let consoleSpy: MockInstance
+
+    beforeEach(() => {
+      consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => null)
+    })
+
+    afterEach(() => {
+      consoleSpy.mockRestore()
+    })
+
+    it('throws a 404', async () => {
+      setup({ isNotFoundError: true })
+      const { result } = renderHook(
+        () =>
+          useQueryV5(
+            CachedBundlesQueryOpts({
+              provider: 'gh',
+              owner: 'codecov',
+              repo: 'codecov',
+              branch: 'main',
+            })
+          ),
+        { wrapper }
+      )
+
+      await waitFor(() => expect(result.current.isError).toBeTruthy())
+      await waitFor(() =>
+        expect(result.current.error).toEqual(
+          expect.objectContaining({
+            status: 404,
+          })
+        )
+      )
+    })
+  })
+
+  describe('returns OwnerNotActivatedError __typename', () => {
+    let consoleSpy: MockInstance
+
+    beforeEach(() => {
+      consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => null)
+    })
+
+    afterEach(() => {
+      consoleSpy.mockRestore()
+    })
+
+    it('throws a 403', async () => {
+      setup({ isOwnerNotActivatedError: true })
+      const { result } = renderHook(
+        () =>
+          useQueryV5(
+            CachedBundlesQueryOpts({
+              provider: 'gh',
+              owner: 'codecov',
+              repo: 'codecov',
+              branch: 'main',
+            })
+          ),
+        { wrapper }
+      )
+
+      await waitFor(() => expect(result.current.isError).toBeTruthy())
+      await waitFor(() =>
+        expect(result.current.error).toEqual(
+          expect.objectContaining({
+            status: 403,
+          })
+        )
+      )
+    })
+  })
+
+  describe('unsuccessful parse of zod schema', () => {
+    let consoleSpy: MockInstance
+
+    beforeEach(() => {
+      consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => null)
+    })
+
+    afterEach(() => {
+      consoleSpy.mockRestore()
+    })
+
+    it('throws a 404', async () => {
+      setup({ isUnsuccessfulParseError: true })
+      const { result } = renderHook(
+        () =>
+          useQueryV5(
+            CachedBundlesQueryOpts({
+              provider: 'gh',
+              owner: 'codecov',
+              repo: 'codecov',
+              branch: 'main',
+            })
+          ),
+        { wrapper }
+      )
+
+      await waitFor(() => expect(result.current.isError).toBeTruthy())
+      await waitFor(() =>
+        expect(result.current.error).toEqual(
+          expect.objectContaining({
+            status: 404,
+          })
+        )
+      )
+    })
+  })
+})