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

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/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();
+  });
+});

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

@@ -0,0 +1,144 @@
+import { faker } from '@faker-js/faker';
+import { render, screen, waitFor } from '@testing-library/react';
+import { IntlProvider } from 'react-intl';
+import { PropsWithChildren } from 'react';
+import { QueryClientProvider } from '@tanstack/react-query';
+import { RichieContextFactory as mockRichieContextFactory } from 'utils/test/factories/richie';
+import JoanieApiProvider from 'contexts/JoanieApiContext';
+import { createTestQueryClient } from 'utils/test/createTestQueryClient';
+
+import {
+  getStoredContractArchiveId,
+  storeContractArchiveId,
+  unstoreContractArchiveId,
+} from 'pages/TeacherDashboardContractsLayout/hooks/useDownloadContractArchive/contractArchiveLocalStorage';
+import { CONTRACT_DOWNLOAD_SETTINGS } from 'settings';
+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 mockHasContractToDownload: boolean;
+jest.mock('pages/TeacherDashboardContractsLayout/hooks/useHasContractToDownload/index.tsx', () => ({
+  __esModule: true,
+  default: () => mockHasContractToDownload,
+}));
+
+const mockCheckArchive = jest.fn();
+const mockCreateArchive = jest.fn();
+const mockGetArchive = jest.fn();
+jest.mock('hooks/useContractArchive', () => ({
+  __esModule: true,
+  default: () => ({
+    methods: { get: mockGetArchive, create: mockCreateArchive, check: mockCheckArchive },
+  }),
+}));
+
+describe('TeacherDashboardContractsLayout/BulkDownloadContractButton with fake timer', () => {
+  const Wrapper = ({ children }: PropsWithChildren) => {
+    return (
+      <IntlProvider locale="en">
+        <QueryClientProvider client={createTestQueryClient({ user: true })}>
+          <JoanieApiProvider>{children}</JoanieApiProvider>
+        </QueryClientProvider>
+      </IntlProvider>
+    );
+  };
+
+  let contractArchiveId: string;
+  beforeEach(() => {
+    mockHasContractToDownload = true;
+
+    const now = Date.now();
+    const unvalidCreationTime =
+      now - CONTRACT_DOWNLOAD_SETTINGS.contractArchiveLocalVaklidityDurationMs * 2;
+
+    jest.useFakeTimers();
+    jest.setSystemTime(new Date(unvalidCreationTime));
+    contractArchiveId = faker.string.uuid();
+    storeContractArchiveId(contractArchiveId);
+    jest.setSystemTime(new Date(now));
+  });
+
+  afterEach(() => {
+    jest.runOnlyPendingTimers();
+    jest.useRealTimers();
+    jest.clearAllMocks();
+    unstoreContractArchiveId();
+  });
+
+  it("should return IDLE status and clear stored id when archive doesn't exists on the server", async () => {
+    mockHasContractToDownload = true;
+    mockCheckArchive.mockResolvedValue(false);
+
+    render(
+      <Wrapper>
+        <BulkDownloadContractButton organizationId={faker.string.uuid()} />
+      </Wrapper>,
+    );
+
+    const $downloadButton = screen.queryByRole('button', {
+      name: /Download contracts archive/,
+    });
+    expect($downloadButton).toBeInTheDocument();
+
+    // BulkDownloadButton is disabled until initiliazed
+    expect($downloadButton).toBeDisabled();
+    expect(mockCheckArchive).toHaveBeenCalledTimes(1);
+
+    // Button should initalize with idle state and propose an archive generation
+    await waitFor(() => {
+      const $createArchiveButton = screen.queryByRole('button', {
+        name: /Request contracts archive/,
+      });
+      expect($createArchiveButton).toBeInTheDocument();
+      expect($createArchiveButton).toBeEnabled();
+    });
+
+    expect(getStoredContractArchiveId()).toBe(null);
+    expect(mockGetArchive).not.toHaveBeenCalled();
+    expect(mockCreateArchive).not.toHaveBeenCalled();
+
+    // polling shouldn't start, mockCheckArchive shouldn't been called more than once
+    expect(mockCheckArchive).toHaveBeenCalledTimes(1);
+  });
+
+  it('should return READY status when archive exists on the server', async () => {
+    mockHasContractToDownload = true;
+    mockCheckArchive.mockResolvedValue(true);
+
+    render(
+      <Wrapper>
+        <BulkDownloadContractButton organizationId={faker.string.uuid()} />
+      </Wrapper>,
+    );
+
+    const $initButton = screen.queryByRole('button', {
+      name: /Download contracts archive/,
+    });
+    expect($initButton).toBeInTheDocument();
+    // BulkDownloadButton is disabled until initiliazed
+    expect($initButton).toBeDisabled();
+    expect(mockCheckArchive).toHaveBeenCalledTimes(1);
+
+    await waitFor(() => {
+      const $downloadButton = screen.queryByRole('button', {
+        name: /Download contracts archive/,
+      });
+      expect($downloadButton).toBeInTheDocument();
+      expect($downloadButton).toBeEnabled();
+    });
+
+    expect(getStoredContractArchiveId()).toBe(contractArchiveId);
+    expect(mockGetArchive).not.toHaveBeenCalled();
+    expect(mockCreateArchive).not.toHaveBeenCalled();
+
+    // polling shouldn't start, mockCheckArchive shouldn't been called more than once
+    expect(mockCheckArchive).toHaveBeenCalledTimes(1);
+  });
+});