richie-education 2.25.0-b2.dev32 → 2.25.0-b2.dev35

package/js/api/joanie.ts

@@ -12,7 +12,7 @@ import queryString from 'query-string';
 import type * as Joanie from 'types/Joanie';
 import { AuthenticationApi } from 'api/authentication';
 import context from 'utils/context';
-import { HttpError } from 'utils/errors/HttpError';
+import { HttpError, HttpStatusCode } from 'utils/errors/HttpError';
 import { JOANIE_API_VERSION } from 'settings';
 import { ResourcesQuery } from 'hooks/useResources';
 import { ObjectHelper } from 'utils/ObjectHelper';
@@ -20,14 +20,15 @@ import { Maybe } from 'types/utils';
 
 interface CheckStatusOptions {
   fallbackValue: any;
-  ignoredErrorStatus: number[];
+  ignoredErrorStatus: (number | HttpStatusCode)[];
 }
 
 export function getResponseBody(response: Response) {
   if (response.headers.get('Content-Type') === 'application/json') {
     return response.json();
   }
-  if (response.headers.get('Content-Type') === 'application/pdf') {
+  const fileType = ['application/pdf', 'application/zip'];
+  if (fileType.includes(response.headers.get('Content-Type') || '')) {
     return response.blob();
   }
   return response.text();
@@ -154,6 +155,10 @@ export const getRoutes = () => {
       contracts: {
         get: `${baseUrl}/contracts/:id/`,
         download: `${baseUrl}/contracts/:id/download/`,
+        zip_archive: {
+          create: `${baseUrl}/contracts/zip-archive/`,
+          get: `${baseUrl}/contracts/zip-archive/:id/`,
+        },
       },
     },
     organizations: {
@@ -379,6 +384,24 @@ const API = (): Joanie.API => {
             method: 'GET',
           }).then(checkStatus);
         },
+        zip_archive: {
+          check: async (id) => {
+            return fetchWithJWT(ROUTES.user.contracts.zip_archive.get.replace(':id', id), {
+              method: 'OPTIONS',
+            });
+          },
+          create: async (payload) => {
+            return fetchWithJWT(ROUTES.user.contracts.zip_archive.create, {
+              method: 'POST',
+              body: JSON.stringify(payload),
+            }).then(checkStatus);
+          },
+          get: async (id) => {
+            return fetchWithJWT(ROUTES.user.contracts.zip_archive.get.replace(':id', id), {
+              method: 'GET',
+            }).then(checkStatus);
+          },
+        },
       },
     },
     organizations: {

package/js/api/lms/dummy.spec.ts

@@ -36,7 +36,15 @@ describe('Dummy API', () => {
 
   describe('user', () => {
     it('simulates that authenticated user is admin', async () => {
-      const response = await BaseAPI.user.me();
+      // Not logged-in.
+      let response = await BaseAPI.user.me();
+      expect(response).toBeNull();
+
+      // Log-in.
+      await BaseAPI.user.login();
+
+      // Is logged-in.
+      response = await BaseAPI.user.me();
       expect(response?.username).toBe('admin');
       expect(response?.access_token).toBeDefined();
     });

package/js/api/lms/dummy.ts

@@ -38,6 +38,8 @@ const JOANIE_DEV_DEMO_USER_JWT_TOKENS = {
     'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ0b2tlbl90eXBlIjoiYWNjZXNzIiwiZXhwIjoxNzMzOTI4MjE0LCJpYXQiOjE3MDIzOTIyMTQsImp0aSI6ImNkZjAyMGM4ODdjOTQxYzU5ZmExN2FkZGExNjNjMDIzIiwiZW1haWwiOiJqZWFuLWJhcHRpc3RlLnBlbnJhdGgrc3R1ZGVudF91c2VyQGZ1bi1tb29jLmZyIiwibGFuZ3VhZ2UiOiJmci1mciIsInVzZXJuYW1lIjoic3R1ZGVudF91c2VyIiwiZnVsbF9uYW1lIjoiXHUwMGM5dHVkaWFudCJ9.JMdnC2VXwq2VbNPrIYxj8PEq0oJJ4LZZT_ywWyE1lBM',
 };
 
+export const RICHIE_DUMMY_IS_LOGGED_IN = 'RICHIE_DUMMY_IS_LOGGED_IN';
+
 function getUserInfo(username: keyof typeof JOANIE_DEV_DEMO_USER_JWT_TOKENS): Maybe<User> {
   const accessToken = JOANIE_DEV_DEMO_USER_JWT_TOKENS[username];
   const JWTPayload: JWTPayload = JSON.parse(base64Decode(accessToken.split('.')[1]));
@@ -71,11 +73,19 @@ const API = (APIConf: LMSBackend | AuthenticationBackend): APILms => {
               "username": "admin",
             }
         */
+        if (!localStorage.getItem(RICHIE_DUMMY_IS_LOGGED_IN)) {
+          return null;
+        }
         return getUserInfo(CURRENT_JOANIE_DEV_DEMO_USER) || null;
       },
-      login: () => location.reload(),
+      login: () => {
+        localStorage.setItem(RICHIE_DUMMY_IS_LOGGED_IN, 'true');
+        location.reload();
+      },
       register: () => location.reload(),
-      logout: async () => undefined,
+      logout: async () => {
+        localStorage.removeItem(RICHIE_DUMMY_IS_LOGGED_IN);
+      },
       accessToken: () => sessionStorage.getItem(RICHIE_USER_TOKEN),
     },
     enrollment: {

package/js/contexts/SessionContext/BaseSessionProvider.tsx

@@ -47,29 +47,21 @@ const BaseSessionProvider = ({ children }: PropsWithChildren<any>) => {
     AuthenticationApi!.register();
   }, [queryClient]);
 
-  const invalidate = useCallback(() => {
-    /*
-      Invalidate all queries except 'user' as we can set it to null manually
-      after logout to avoid extra requests
-    */
+  const destroy = useCallback(async () => {
+    await AuthenticationApi!.logout();
+    sessionStorage.removeItem(REACT_QUERY_SETTINGS.cacheStorage.key);
     queryClient.removeQueries({
       predicate: (query: any) =>
         query.options.queryKey.includes('user') && query.options.queryKey.length > 1,
     });
     queryClient.setQueryData(['user'], null);
-  }, [queryClient]);
-
-  const destroy = useCallback(async () => {
-    invalidate();
-    await AuthenticationApi!.logout();
-  }, [invalidate]);
+  }, []);
 
   const context = useMemo(
     () => ({
       user,
       isPending,
       destroy,
-      invalidate,
       login,
       register,
     }),

package/js/contexts/SessionContext/JoanieSessionProvider.tsx

@@ -75,23 +75,16 @@ const JoanieSessionProvider = ({ children }: React.PropsWithChildren<{}>) => {
     AuthenticationApi!.register();
   }, [queryClient]);
 
-  const invalidate = useCallback(() => {
-    /*
-      Invalidate all queries except 'user' as we can set it to null manually
-      after logout to avoid extra requests
-    */
+  const destroy = useCallback(async () => {
+    await AuthenticationApi!.logout();
+    sessionStorage.removeItem(REACT_QUERY_SETTINGS.cacheStorage.key);
     sessionStorage.removeItem(RICHIE_USER_TOKEN);
     queryClient.removeQueries({
       predicate: (query: any) =>
         query.options.queryKey.includes('user') && query.options.queryKey.length > 1,
     });
     queryClient.setQueryData(['user'], null);
-  }, [queryClient]);
-
-  const destroy = useCallback(async () => {
-    invalidate();
-    await AuthenticationApi!.logout();
-  }, [invalidate]);
+  }, []);
 
   useEffect(() => {
     if (user) {

package/js/contexts/SessionContext/index.spec.tsx

@@ -169,10 +169,8 @@ describe('SessionProvider', () => {
         jest.runOnlyPendingTimers();
       });
 
-      expect(result.current.user).toBeNull();
-      expect(sessionStorage.getItem(REACT_QUERY_SETTINGS.cacheStorage.key)).toMatch(
-        /"data":null,.*"queryKey":\["user"]/,
-      );
+      await waitFor(() => expect(result.current.user).toBeNull());
+      expect(sessionStorage.getItem(REACT_QUERY_SETTINGS.cacheStorage.key)).toBeNull();
     });
 
     it('does not make request if there is a valid session in cache', async () => {

package/js/hooks/useContractArchive/index.download.spec.tsx

@@ -0,0 +1,119 @@
+import fetchMock from 'fetch-mock';
+import { PropsWithChildren } from 'react';
+import { QueryClientProvider } from '@tanstack/react-query';
+import { IntlProvider } from 'react-intl';
+import { fireEvent, renderHook, waitFor } from '@testing-library/react';
+import { faker } from '@faker-js/faker';
+import { RichieContextFactory as mockRichieContextFactory } from 'utils/test/factories/richie';
+import { createTestQueryClient } from 'utils/test/createTestQueryClient';
+import { handle } from 'utils/errors/handle';
+import { SessionProvider } from 'contexts/SessionContext';
+import { Deferred } from 'utils/test/deferred';
+import { HttpStatusCode } from 'utils/errors/HttpError';
+import useContractArchive from '.';
+
+jest.mock('utils/errors/handle');
+jest.mock('utils/context', () => ({
+  __esModule: true,
+  default: mockRichieContextFactory({
+    authentication: { backend: 'fonzie', endpoint: 'https://auth.test' },
+    joanie_backend: { endpoint: 'https://joanie.test' },
+  }).one(),
+}));
+
+const mockHandle = handle as jest.MockedFn<typeof handle>;
+
+describe('useContractArchive', () => {
+  beforeEach(() => {
+    fetchMock.get('https://joanie.test/api/v1.0/orders/', []);
+    fetchMock.get('https://joanie.test/api/v1.0/addresses/', []);
+    fetchMock.get('https://joanie.test/api/v1.0/credit-cards/', []);
+  });
+
+  beforeAll(() => {
+    // eslint-disable-next-line compat/compat
+    URL.createObjectURL = jest.fn();
+    // eslint-disable-next-line compat/compat
+    URL.revokeObjectURL = jest.fn();
+    HTMLAnchorElement.prototype.click = jest.fn();
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+    fetchMock.restore();
+  });
+
+  const Wrapper = ({ children }: PropsWithChildren) => {
+    return (
+      <QueryClientProvider client={createTestQueryClient({ user: true })}>
+        <IntlProvider locale="en">
+          <SessionProvider>{children}</SessionProvider>
+        </IntlProvider>
+      </QueryClientProvider>
+    );
+  };
+
+  it('downloads the certificate', async () => {
+    const archiveId = faker.string.uuid();
+    const DOWNLOAD_URL = `https://joanie.test/api/v1.0/contracts/zip-archive/${archiveId}/`;
+    const deferred = new Deferred();
+    fetchMock.get(DOWNLOAD_URL, deferred.promise);
+
+    const { result } = renderHook(() => useContractArchive(), {
+      wrapper: Wrapper,
+    });
+    await waitFor(() => expect(result.current).not.toBeNull());
+
+    expect(fetchMock.called(DOWNLOAD_URL)).toBe(false);
+    // eslint-disable-next-line compat/compat
+    expect(URL.createObjectURL).toHaveBeenCalledTimes(0);
+    // eslint-disable-next-line compat/compat
+    expect(URL.revokeObjectURL).toHaveBeenCalledTimes(0);
+
+    result.current.methods.get(archiveId);
+    deferred.resolve(HttpStatusCode.OK);
+
+    await waitFor(() => {
+      expect(fetchMock.called(DOWNLOAD_URL)).toBe(true);
+      // eslint-disable-next-line compat/compat
+      expect(URL.createObjectURL).toHaveBeenCalledTimes(1);
+      // eslint-disable-next-line compat/compat
+      expect(URL.revokeObjectURL).toHaveBeenCalledTimes(0);
+    });
+
+    // - A event listener should have attached to window to know when window is blurred.
+    // This event is triggered in browser when the download pop up is displayed.
+    fireEvent.blur(window);
+    // eslint-disable-next-line compat/compat
+    expect(URL.revokeObjectURL).toHaveBeenCalledTimes(1);
+  });
+
+  it('handles an error if certificate download request fails', async () => {
+    const archiveId = faker.string.uuid();
+    const DOWNLOAD_URL = `https://joanie.test/api/v1.0/contracts/zip-archive/${archiveId}/`;
+    fetchMock.get(DOWNLOAD_URL, HttpStatusCode.UNAUTHORIZED);
+
+    const { result } = renderHook(() => useContractArchive(), {
+      wrapper: Wrapper,
+    });
+    await waitFor(() => expect(result.current).not.toBeNull());
+
+    expect(fetchMock.called(DOWNLOAD_URL)).toBe(false);
+    expect(mockHandle).not.toHaveBeenCalled();
+    // eslint-disable-next-line compat/compat
+    expect(URL.createObjectURL).toHaveBeenCalledTimes(0);
+    // eslint-disable-next-line compat/compat
+    expect(URL.revokeObjectURL).toHaveBeenCalledTimes(0);
+
+    await result.current.methods.get(archiveId);
+
+    await waitFor(() => {
+      expect(fetchMock.called(DOWNLOAD_URL)).toBe(true);
+      expect(mockHandle).toHaveBeenNthCalledWith(1, new Error('Unauthorized'));
+      // eslint-disable-next-line compat/compat
+      expect(URL.createObjectURL).toHaveBeenCalledTimes(0);
+      // eslint-disable-next-line compat/compat
+      expect(URL.revokeObjectURL).toHaveBeenCalledTimes(0);
+    });
+  });
+});

package/js/hooks/useContractArchive/index.spec.tsx

@@ -0,0 +1,91 @@
+import { faker } from '@faker-js/faker';
+import fetchMock from 'fetch-mock';
+import { renderHook } from '@testing-library/react';
+import { IntlProvider } from 'react-intl';
+import { PropsWithChildren } from 'react';
+import { RichieContextFactory as mockRichieContextFactory } from 'utils/test/factories/richie';
+import JoanieApiProvider from 'contexts/JoanieApiContext';
+import { HttpStatusCode } from 'utils/errors/HttpError';
+import useContractArchive from '.';
+
+jest.mock('utils/context', () => ({
+  __esModule: true,
+  default: mockRichieContextFactory({
+    authentication: { backend: 'fonzie', endpoint: 'https://auth.test' },
+    joanie_backend: { endpoint: 'https://joanie.test' },
+  }).one(),
+}));
+
+describe('useContractArchive', () => {
+  const Wrapper = ({ children }: PropsWithChildren) => {
+    return (
+      <IntlProvider locale="en">
+        <JoanieApiProvider>{children}</JoanieApiProvider>
+      </IntlProvider>
+    );
+  };
+  afterEach(() => {
+    fetchMock.restore();
+  });
+  it.each([
+    {
+      label: `response code: ${HttpStatusCode.NO_CONTENT}`,
+      statusCode: HttpStatusCode.NO_CONTENT,
+      expectedValue: true,
+    },
+    {
+      label: `response code: ${HttpStatusCode.NOT_FOUND}`,
+      statusCode: HttpStatusCode.NOT_FOUND,
+      expectedValue: false,
+    },
+    {
+      label: `response code: ${HttpStatusCode.FORBIDDEN}`,
+      statusCode: HttpStatusCode.FORBIDDEN,
+      expectedValue: false,
+    },
+    {
+      label: `response code: ${HttpStatusCode.INTERNAL_SERVER_ERROR}`,
+      statusCode: HttpStatusCode.INTERNAL_SERVER_ERROR,
+      expectedValue: false,
+    },
+    {
+      label: `response code: ${HttpStatusCode.UNAUTHORIZED}`,
+      statusCode: HttpStatusCode.UNAUTHORIZED,
+      expectedValue: false,
+    },
+  ])(
+    'check method should return the right value for response code: $label',
+    async ({ statusCode, expectedValue }) => {
+      const contractArchiveId = faker.string.uuid();
+      fetchMock.mock(
+        (url, options) => {
+          return (
+            options.method === 'OPTIONS' &&
+            url === `https://joanie.test/api/v1.0/contracts/zip-archive/${contractArchiveId}/`
+          );
+        },
+        new Response('', { status: statusCode }),
+      );
+
+      const { result } = renderHook(useContractArchive, {
+        wrapper: Wrapper,
+      });
+      const response = await result.current.methods.check(contractArchiveId);
+      expect(response).toBe(expectedValue);
+    },
+  );
+
+  it('create should return a contractArchiveId', async () => {
+    const contractArchiveId = faker.string.uuid();
+    fetchMock.post('https://joanie.test/api/v1.0/contracts/zip-archive/', {
+      url: `http://test.url/uri/${contractArchiveId}/uri/?toto=tata`,
+    });
+    const { result } = renderHook(useContractArchive, {
+      wrapper: Wrapper,
+    });
+
+    const organizationId = faker.string.uuid();
+    const response = await result.current.methods.create(organizationId);
+    expect(response).toBe(contractArchiveId);
+  });
+});

package/js/hooks/useContractArchive/index.ts

@@ -0,0 +1,83 @@
+import { useJoanieApi } from 'contexts/JoanieApiContext';
+import { HttpStatusCode } from 'utils/errors/HttpError';
+import { handle } from 'utils/errors/handle';
+
+const extractArchiveId = (url: string): string => {
+  const uuidRegex = /[0-9A-Fa-f]{8}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{12}/;
+  const match = url.match(uuidRegex);
+
+  if (match === null) {
+    const error = new Error(
+      'Unable to extract `contractArchiveId` from `contract.zip_archive.create` response',
+    );
+    handle(error);
+    throw error;
+  }
+
+  return match[0];
+};
+
+// TODO: should be factorized with useDownloadCertificate
+// and maybe DownloadContractButton
+const buildArchiveFromBlob = (fileName: string, blob: Blob) => {
+  // eslint-disable-next-line compat/compat
+  const url = URL.createObjectURL(blob);
+  const $link = document.createElement('a');
+  $link.href = url;
+  $link.download = fileName;
+
+  const revokeObject = () => {
+    // eslint-disable-next-line compat/compat
+    URL.revokeObjectURL(url);
+    window.removeEventListener('blur', revokeObject);
+  };
+
+  window.addEventListener('blur', revokeObject);
+  $link.click();
+};
+
+const useContractArchive = () => {
+  const api = useJoanieApi();
+  return {
+    methods: {
+      check: async (archiveId: string): Promise<boolean> => {
+        const response = await api.user.contracts.zip_archive.check(archiveId);
+
+        if (response.ok) {
+          if (response.status === HttpStatusCode.NO_CONTENT) {
+            return true;
+          }
+          handle(
+            new Error(
+              `Unknown success code ${response.status} for OPTION request to contract's zip_archive endpoint.`,
+            ),
+          );
+        }
+
+        return false;
+      },
+      get: async (archiveId: string): Promise<true | void> => {
+        try {
+          const response = api.user.contracts.zip_archive.get(archiveId);
+          buildArchiveFromBlob('contracts.zip', await response);
+          return true;
+        } catch (error) {
+          handle(error);
+        }
+
+        // FIXME: two thing could happen here with HttpStatusCode.NOT_FOUND response:
+        // * nothing found because the zip is generating.
+        // * nothing found because the zip doesn't and will never exist.
+      },
+      create: async (organizationId: string): Promise<string> => {
+        const response = await api.user.contracts.zip_archive.create({
+          organization_id: organizationId,
+        });
+
+        return extractArchiveId(response.url);
+      },
+    },
+  };
+};
+
+export default useContractArchive;

package/js/pages/TeacherDashboardContractsLayout/components/BulkDownloadContractButton/index.spec.tsx

@@ -0,0 +1,136 @@
+import { faker } from '@faker-js/faker';
+import { render, screen } from '@testing-library/react';
+import { IntlProvider } from 'react-intl';
+import { PropsWithChildren } from 'react';
+import { QueryClientProvider } from '@tanstack/react-query';
+import userEvent from '@testing-library/user-event';
+import { RichieContextFactory as mockRichieContextFactory } from 'utils/test/factories/richie';
+import JoanieApiProvider from 'contexts/JoanieApiContext';
+
+import { createTestQueryClient } from 'utils/test/createTestQueryClient';
+import { ContractDownloadStatus } from 'pages/TeacherDashboardContractsLayout/hooks/useDownloadContractArchive';
+
+import BulkDownloadContractButton from '.';
+
+jest.mock('utils/context', () => ({
+  __esModule: true,
+  default: mockRichieContextFactory({
+    authentication: { backend: 'fonzie', endpoint: 'https://auth.test' },
+    joanie_backend: { endpoint: 'https://joanie.test' },
+  }).one(),
+}));
+
+let mockDownloadContractArchive = jest.fn(() => Promise<void>);
+let mockCreateContractArchive = jest.fn(() => Promise<void>);
+let mockDownloadContractArchiveStatus: ContractDownloadStatus;
+jest.mock('pages/TeacherDashboardContractsLayout/hooks/useDownloadContractArchive', () => ({
+  __esModule: true,
+  ...jest.requireActual('pages/TeacherDashboardContractsLayout/hooks/useDownloadContractArchive'),
+  default: () => ({
+    downloadContractArchive: mockDownloadContractArchive,
+    createContractArchive: mockCreateContractArchive,
+    status: mockDownloadContractArchiveStatus,
+  }),
+}));
+
+let mockHasContractToDownload: boolean;
+jest.mock('pages/TeacherDashboardContractsLayout/hooks/useHasContractToDownload/index.tsx', () => ({
+  __esModule: true,
+  default: () => mockHasContractToDownload,
+}));
+
+describe('TeacherDashboardContractsLayout/BulkDownloadContractButton', () => {
+  const Wrapper = ({ children }: PropsWithChildren) => {
+    return (
+      <IntlProvider locale="en">
+        <QueryClientProvider client={createTestQueryClient({ user: true })}>
+          <JoanieApiProvider>{children}</JoanieApiProvider>
+        </QueryClientProvider>
+      </IntlProvider>
+    );
+  };
+
+  beforeEach(() => {
+    // useDownloadContractArchive mocked values
+    mockHasContractToDownload = false;
+    mockDownloadContractArchive = jest.fn(() => Promise<void>);
+    mockCreateContractArchive = jest.fn(() => Promise<void>);
+    mockDownloadContractArchiveStatus = ContractDownloadStatus.IDLE;
+  });
+
+  afterEach(() => {
+    jest.resetAllMocks();
+  });
+
+  it("shouldn't render generate archive button for archive generation IDLE", async () => {
+    mockDownloadContractArchiveStatus = ContractDownloadStatus.IDLE;
+
+    render(
+      <Wrapper>
+        <BulkDownloadContractButton organizationId={faker.string.uuid()} />
+      </Wrapper>,
+    );
+
+    const $button = screen.queryByRole('button', { name: /Request contracts archive/ });
+    expect($button).toBeInTheDocument();
+    expect($button).toBeEnabled();
+
+    const user = userEvent.setup();
+    await user.click($button!);
+    expect(mockDownloadContractArchive).toHaveBeenCalledTimes(1);
+  });
+
+  it("shouldn't render waiting archive button for archive generation PENDING", async () => {
+    mockDownloadContractArchiveStatus = ContractDownloadStatus.PENDING;
+
+    render(
+      <Wrapper>
+        <BulkDownloadContractButton organizationId={faker.string.uuid()} />
+      </Wrapper>,
+    );
+
+    const $button = screen.queryByRole('button', { name: /Generating contracts archive.../ });
+    expect($button).toBeInTheDocument();
+    expect($button).toBeDisabled();
+
+    const user = userEvent.setup();
+    await user.click($button!);
+    expect(mockDownloadContractArchive).not.toHaveBeenCalled();
+  });
+
+  it("shouldn't render download button for archive is READY", async () => {
+    mockDownloadContractArchiveStatus = ContractDownloadStatus.READY;
+
+    render(
+      <Wrapper>
+        <BulkDownloadContractButton organizationId={faker.string.uuid()} />
+      </Wrapper>,
+    );
+
+    const $button = screen.queryByRole('button', { name: /Download contracts archive/ });
+    expect($button).toBeInTheDocument();
+    expect($button).toBeEnabled();
+
+    const user = userEvent.setup();
+    await user.click($button!);
+    expect(mockDownloadContractArchive).toHaveBeenCalledTimes(1);
+  });
+
+  it('should render disabled download button when INITIALIZING', async () => {
+    mockDownloadContractArchiveStatus = ContractDownloadStatus.INITIALIZING;
+
+    render(
+      <Wrapper>
+        <BulkDownloadContractButton organizationId={faker.string.uuid()} />
+      </Wrapper>,
+    );
+
+    const $button = screen.queryByRole('button', { name: /Download contracts archive/ });
+    expect($button).toBeInTheDocument();
+    expect($button).toBeDisabled();
+
+    const user = userEvent.setup();
+    await user.click($button!);
+    expect(mockDownloadContractArchive).not.toHaveBeenCalled();
+  });
+});