richie-education 2.24.0 → 2.25.0-b2.dev101

package/js/pages/TeacherDashboardContractsLayout/hooks/useDefaultOrganizationId/index.spec.tsx

@@ -0,0 +1,134 @@
+import { QueryClientProvider } from '@tanstack/react-query';
+import { PropsWithChildren } from 'react';
+import { IntlProvider } from 'react-intl';
+import { MemoryRouter, Route, Routes } from 'react-router-dom';
+import { renderHook, waitFor } from '@testing-library/react';
+import fetchMock from 'fetch-mock';
+import { RichieContextFactory as mockRichieContextFactory } from 'utils/test/factories/richie';
+import JoanieSessionProvider from 'contexts/SessionContext/JoanieSessionProvider';
+import { createTestQueryClient } from 'utils/test/createTestQueryClient';
+import { OrganizationFactory } from 'utils/test/factories/joanie';
+import { Organization } from 'types/Joanie';
+import useDefaultOrganizationId from '.';
+
+jest.mock('utils/context', () => ({
+  __esModule: true,
+  default: mockRichieContextFactory({
+    authentication: { backend: 'fonzie', endpoint: 'https://demo.test' },
+    joanie_backend: { endpoint: 'https://joanie.test' },
+  }).one(),
+}));
+
+interface WrapperProps {
+  routePath: string;
+  initialEntry: string;
+}
+
+describe('useDefaultOrganizationId', () => {
+  const organizations: {
+    routeOrganization: Organization;
+    queryOrganization: Organization;
+    userOrganizationList: Organization[];
+  } = {
+    routeOrganization: OrganizationFactory().one(),
+    queryOrganization: OrganizationFactory().one(),
+    userOrganizationList: OrganizationFactory().many(2),
+  };
+
+  const Wrapper = ({ children, routePath, initialEntry }: PropsWithChildren<WrapperProps>) => {
+    return (
+      <IntlProvider locale="en">
+        <QueryClientProvider client={createTestQueryClient({ user: true })}>
+          <JoanieSessionProvider>
+            <MemoryRouter initialEntries={[initialEntry]}>
+              <Routes>
+                <Route path={routePath} element={children} />
+              </Routes>
+            </MemoryRouter>
+          </JoanieSessionProvider>
+        </QueryClientProvider>
+      </IntlProvider>
+    );
+  };
+
+  beforeEach(() => {
+    // Joanie provider's calls
+    fetchMock.get('https://joanie.test/api/v1.0/orders/', []);
+    fetchMock.get('https://joanie.test/api/v1.0/credit-cards/', []);
+    fetchMock.get('https://joanie.test/api/v1.0/addresses/', []);
+  });
+
+  afterEach(() => {
+    fetchMock.restore();
+  });
+
+  it.each([
+    {
+      testLabel: 'route organization before query',
+      routeOrganization: organizations.routeOrganization,
+      queryOrganization: organizations.queryOrganization,
+      userOrganizationList: organizations.userOrganizationList,
+      expectedOrganizationId: organizations.routeOrganization.id,
+    },
+    {
+      testLabel: 'query organization before first element of list',
+      routeOrganization: undefined,
+      queryOrganization: organizations.queryOrganization,
+      userOrganizationList: organizations.userOrganizationList,
+      expectedOrganizationId: organizations.queryOrganization.id,
+    },
+    {
+      testLabel: 'first element of list when nothing else is found',
+      routeOrganization: undefined,
+      queryOrganization: undefined,
+      userOrganizationList: organizations.userOrganizationList,
+      expectedOrganizationId: organizations.userOrganizationList[0].id,
+    },
+    {
+      testLabel: 'undefined when user have no organization in his list',
+      routeOrganization: undefined,
+      queryOrganization: undefined,
+      userOrganizationList: [],
+      expectedOrganizationId: undefined,
+    },
+  ])(
+    'should return $testLabel',
+    async ({
+      routeOrganization,
+      queryOrganization,
+      userOrganizationList,
+      expectedOrganizationId,
+    }) => {
+      let routePath = '/';
+      if (routeOrganization) {
+        routePath += ':organizationId/';
+      }
+      let initialEntry = '/';
+      if (routeOrganization) {
+        initialEntry += `${routeOrganization.id}/`;
+      }
+      if (queryOrganization) {
+        initialEntry += `?organization_id=${queryOrganization.id}`;
+      }
+
+      fetchMock.get(
+        'https://joanie.test/api/v1.0/organizations/',
+        [...userOrganizationList, routeOrganization, queryOrganization].filter(
+          (organization) => organization !== undefined,
+        ),
+      );
+      const { result } = renderHook(useDefaultOrganizationId, {
+        wrapper: ({ children }) => (
+          <Wrapper routePath={routePath} initialEntry={initialEntry}>
+            {children}
+          </Wrapper>
+        ),
+      });
+
+      // when looking in organization list defaultOrganization will be updated when organizations are fetched.
+      await waitFor(() => {
+        expect(result.current).toBe(expectedOrganizationId);
+      });
+    },
+  );
+});

package/js/pages/TeacherDashboardContractsLayout/hooks/useDefaultOrganizationId/index.tsx

@@ -0,0 +1,28 @@
+import { useParams, useSearchParams } from 'react-router-dom';
+import { useOrganizations } from 'hooks/useOrganizations';
+import { Organization } from 'types/Joanie';
+
+/**
+ * return organization id with this priority:
+ * * route param
+ * * query param
+ * * first organization of user's organizations
+ */
+const useDefaultOrganizationId = () => {
+  const { organizationId: routeOrganizationId } = useParams<{
+    organizationId?: Organization['id'];
+  }>();
+  const [searchParams] = useSearchParams();
+  const queryOrganizationId = searchParams.get('organization_id') || undefined;
+  const { items: organizations } = useOrganizations(undefined, {
+    enabled: !routeOrganizationId && !queryOrganizationId,
+  });
+
+  return (
+    routeOrganizationId ||
+    queryOrganizationId ||
+    (organizations.length > 0 ? organizations[0].id : undefined)
+  );
+};
+
+export default useDefaultOrganizationId;

package/js/pages/TeacherDashboardContractsLayout/hooks/useDownloadContractArchive/contractArchiveLocalStorage.spec.ts

@@ -0,0 +1,85 @@
+import { faker } from '@faker-js/faker';
+import { CONTRACT_DOWNLOAD_SETTINGS } from 'settings';
+import {
+  getStoredContractArchiveId,
+  isStoredContractArchiveIdExpired,
+  storeContractArchiveId,
+  unstoreContractArchiveId,
+} from './contractArchiveLocalStorage';
+
+describe('contractArchiveLocalStorage', () => {
+  afterEach(() => {
+    unstoreContractArchiveId();
+  });
+
+  it('should store and unstore contractArchiveId and creation date in localStorage', () => {
+    expect(
+      localStorage.getItem(CONTRACT_DOWNLOAD_SETTINGS.contractArchiveLocalStorageKey),
+    ).toBeNull();
+
+    const contractArchiveId = faker.string.uuid();
+    storeContractArchiveId(contractArchiveId);
+    expect(localStorage.getItem(CONTRACT_DOWNLOAD_SETTINGS.contractArchiveLocalStorageKey)).toMatch(
+      new RegExp(`[0-9]+::${contractArchiveId}`),
+    );
+
+    unstoreContractArchiveId();
+    expect(
+      localStorage.getItem(CONTRACT_DOWNLOAD_SETTINGS.contractArchiveLocalStorageKey),
+    ).toBeNull();
+  });
+
+  it('should retrieve contractArchiveId from localStorage', () => {
+    const contractArchiveId = faker.string.uuid();
+    storeContractArchiveId(contractArchiveId);
+
+    const retrievedcontractArchiveId = getStoredContractArchiveId();
+    expect(retrievedcontractArchiveId).toBe(contractArchiveId);
+  });
+
+  it.each([
+    {
+      label: 'outdated creation date in the past',
+      now: Date.now(),
+      storageCreationTime:
+        Date.now() - CONTRACT_DOWNLOAD_SETTINGS.contractArchiveLocalVaklidityDurationMs * 2,
+    },
+    {
+      label: 'outdated creation date in the future',
+      now: Date.now(),
+      storageCreationTime:
+        Date.now() + CONTRACT_DOWNLOAD_SETTINGS.contractArchiveLocalVaklidityDurationMs * 2,
+    },
+  ])(
+    'isStoredContractArchiveIdExpired should be true for $label',
+    ({ now, storageCreationTime }) => {
+      jest.useFakeTimers();
+      jest.setSystemTime(new Date(storageCreationTime));
+      const contractArchiveId = faker.string.uuid();
+      storeContractArchiveId(contractArchiveId);
+
+      jest.setSystemTime(new Date(now));
+      expect(isStoredContractArchiveIdExpired()).toBe(true);
+
+      jest.runOnlyPendingTimers();
+      jest.useRealTimers();
+    },
+  );
+
+  it("isStoredContractArchiveIdExpired should be true false storage isn't expired", () => {
+    const now = Date.now();
+    const validCreationTime =
+      now - CONTRACT_DOWNLOAD_SETTINGS.contractArchiveLocalVaklidityDurationMs / 2;
+
+    jest.useFakeTimers();
+    jest.setSystemTime(new Date(validCreationTime));
+    const contractArchiveId = faker.string.uuid();
+    storeContractArchiveId(contractArchiveId);
+
+    jest.setSystemTime(new Date(now));
+    expect(isStoredContractArchiveIdExpired()).toBe(false);
+
+    jest.runOnlyPendingTimers();
+    jest.useRealTimers();
+  });
+});

package/js/pages/TeacherDashboardContractsLayout/hooks/useDownloadContractArchive/contractArchiveLocalStorage.ts

@@ -0,0 +1,50 @@
+import { CONTRACT_DOWNLOAD_SETTINGS } from 'settings';
+
+const generateLocalStorageId = (contractArchiveId: string) => {
+  return `${Date.now()}::${contractArchiveId}`;
+};
+
+const storeContractArchiveId = (contractArchiveId: string) => {
+  localStorage.setItem(
+    CONTRACT_DOWNLOAD_SETTINGS.contractArchiveLocalStorageKey,
+    generateLocalStorageId(contractArchiveId),
+  );
+};
+
+const unstoreContractArchiveId = () => {
+  localStorage.removeItem(CONTRACT_DOWNLOAD_SETTINGS.contractArchiveLocalStorageKey);
+};
+
+const getStoredContractArchiveId = () => {
+  const value = localStorage.getItem(CONTRACT_DOWNLOAD_SETTINGS.contractArchiveLocalStorageKey);
+  if (value === null) {
+    return value;
+  }
+
+  const [, contractArchiveId] = value.split('::');
+  return contractArchiveId;
+};
+
+const isStoredContractArchiveIdExpired = () => {
+  const value = localStorage.getItem(CONTRACT_DOWNLOAD_SETTINGS.contractArchiveLocalStorageKey);
+  if (value === null) {
+    return false;
+  }
+  const [creationTimestamp] = value.split('::');
+
+  const bounds: number[] = [Date.now(), parseInt(creationTimestamp, 10)];
+  // reverse bounds when computer time change.
+  if (bounds[0] > bounds[1]) {
+    bounds.reverse();
+  }
+
+  const [begin, end] = bounds;
+  return end - begin > CONTRACT_DOWNLOAD_SETTINGS.contractArchiveLocalVaklidityDurationMs;
+};
+
+export {
+  storeContractArchiveId,
+  unstoreContractArchiveId,
+  getStoredContractArchiveId,
+  isStoredContractArchiveIdExpired,
+};

package/js/pages/TeacherDashboardContractsLayout/hooks/useDownloadContractArchive/index.spec.tsx

@@ -0,0 +1,266 @@
+import { faker } from '@faker-js/faker';
+import { act, renderHook, waitFor } 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 { CONTRACT_DOWNLOAD_SETTINGS } from 'settings';
+import {
+  getStoredContractArchiveId,
+  storeContractArchiveId,
+  unstoreContractArchiveId,
+} from './contractArchiveLocalStorage';
+import useDownloadContractArchive, { ContractDownloadStatus } from '.';
+
+jest.mock('settings', () => ({
+  ...jest.requireActual('settings'),
+  CONTRACT_DOWNLOAD_SETTINGS: {
+    ...jest.requireActual('settings').CONTRACT_DOWNLOAD_SETTINGS,
+    pollInterval: 100,
+  },
+}));
+
+jest.mock('utils/context', () => ({
+  __esModule: true,
+  default: mockRichieContextFactory({
+    authentication: { backend: 'fonzie', endpoint: 'https://auth.test' },
+    joanie_backend: { endpoint: 'https://joanie.test' },
+  }).one(),
+}));
+
+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 },
+  }),
+}));
+
+let mockHasContractToDownload: boolean;
+jest.mock('pages/TeacherDashboardContractsLayout/hooks/useHasContractToDownload/index.tsx', () => ({
+  __esModule: true,
+  default: () => mockHasContractToDownload,
+}));
+
+describe('useDownloadContractArchive', () => {
+  let organizationId: string;
+  const Wrapper = ({ children }: PropsWithChildren) => {
+    return (
+      <IntlProvider locale="en">
+        <JoanieApiProvider>{children}</JoanieApiProvider>
+      </IntlProvider>
+    );
+  };
+
+  afterEach(() => {
+    jest.resetAllMocks();
+    unstoreContractArchiveId();
+  });
+
+  describe('with no contract available for download', () => {
+    beforeEach(() => {
+      organizationId = faker.string.uuid();
+      mockHasContractToDownload = false;
+    });
+
+    it('should return IDLE status when no contractArchiveId is stored', async () => {
+      const { result } = renderHook(() => useDownloadContractArchive({ organizationId }), {
+        wrapper: Wrapper,
+      });
+      expect(result.current.status).toBe(ContractDownloadStatus.IDLE);
+
+      // no api call should have been done.
+      expect(mockCheckArchive).not.toHaveBeenCalled();
+      expect(mockGetArchive).not.toHaveBeenCalled();
+      expect(mockCreateArchive).not.toHaveBeenCalled();
+    });
+
+    it('should return IDLE status when contractArchiveId is stored', async () => {
+      const contractArchiveId = faker.string.uuid();
+      storeContractArchiveId(contractArchiveId);
+
+      const { result } = renderHook(() => useDownloadContractArchive({ organizationId }), {
+        wrapper: Wrapper,
+      });
+
+      expect(result.current.status).toBe(ContractDownloadStatus.IDLE);
+
+      // no api call should have been done.
+      expect(mockCheckArchive).not.toHaveBeenCalled();
+      expect(mockGetArchive).not.toHaveBeenCalled();
+      expect(mockCreateArchive).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('with contracts available for download', () => {
+    beforeEach(() => {
+      organizationId = faker.string.uuid();
+      mockHasContractToDownload = true;
+    });
+
+    it('should return IDLE status when no contractArchiveId is stored', async () => {
+      const { result } = renderHook(() => useDownloadContractArchive({ organizationId }), {
+        wrapper: Wrapper,
+      });
+
+      // ensure that initial effects are done
+      expect(result.current.status).toBe(ContractDownloadStatus.IDLE);
+
+      // no api call should have been done.
+      expect(mockCheckArchive).not.toHaveBeenCalled();
+      expect(mockGetArchive).not.toHaveBeenCalled();
+      expect(mockCreateArchive).not.toHaveBeenCalled();
+    });
+
+    it('should return PENDING status when a contractArchiveId is stored', async () => {
+      const contractArchiveId = faker.string.uuid();
+      storeContractArchiveId(contractArchiveId);
+      mockCheckArchive.mockResolvedValue(false);
+
+      const { result } = renderHook(() => useDownloadContractArchive({ organizationId }), {
+        wrapper: Wrapper,
+      });
+
+      await waitFor(() => {
+        expect(result.current.status).toBe(ContractDownloadStatus.PENDING);
+      });
+
+      expect(mockCheckArchive).toHaveBeenCalledTimes(1);
+      expect(mockGetArchive).not.toHaveBeenCalled();
+      expect(mockCreateArchive).not.toHaveBeenCalled();
+    });
+
+    it('should return READY status when a contractArchiveId is stored and it exists on the server', async () => {
+      const contractArchiveId = faker.string.uuid();
+      storeContractArchiveId(contractArchiveId);
+      mockCheckArchive.mockResolvedValue(true);
+
+      const { result } = renderHook(() => useDownloadContractArchive({ organizationId }), {
+        wrapper: Wrapper,
+      });
+
+      // ensure that initial effects are done
+      await waitFor(() => {
+        expect(result.current.status).toBe(ContractDownloadStatus.READY);
+      });
+
+      expect(mockCheckArchive).toHaveBeenCalledTimes(1);
+      expect(mockGetArchive).not.toHaveBeenCalled();
+      expect(mockCreateArchive).not.toHaveBeenCalled();
+    });
+
+    it("doDownloadArchive should call 'getArchive' if the archive is ready for download", async () => {
+      const contractArchiveId = faker.string.uuid();
+      storeContractArchiveId(contractArchiveId);
+      mockCheckArchive.mockResolvedValue(true);
+
+      const { result } = renderHook(() => useDownloadContractArchive({ organizationId }), {
+        wrapper: Wrapper,
+      });
+
+      // ensure that initial effects are done
+      await waitFor(() => {
+        expect(result.current.status).toBe(ContractDownloadStatus.READY);
+      });
+      expect(mockCheckArchive).toHaveBeenCalledTimes(1);
+
+      act(() => {
+        result.current.downloadContractArchive();
+      });
+
+      await waitFor(() => {
+        expect(result.current.status).toBe(ContractDownloadStatus.IDLE);
+      });
+
+      expect(mockCheckArchive).toHaveBeenCalledTimes(1);
+      // backend is called to download the archive
+      expect(mockGetArchive).toHaveBeenCalledTimes(1);
+
+      // but not to generate the archive
+      expect(mockCreateArchive).not.toHaveBeenCalled();
+    });
+
+    it("doDownloadArchive should call 'createArchive' if no contractArchiveId is stored", async () => {
+      const { result } = renderHook(() => useDownloadContractArchive({ organizationId }), {
+        wrapper: Wrapper,
+      });
+
+      mockCheckArchive.mockResolvedValue(true);
+      mockCreateArchive.mockResolvedValue(faker.string.uuid());
+      act(() => {
+        result.current.downloadContractArchive();
+      });
+
+      await waitFor(() => {
+        expect(result.current.status).toBe(ContractDownloadStatus.IDLE);
+      });
+
+      expect(mockCreateArchive).toHaveBeenCalledTimes(1);
+      expect(mockCheckArchive).toHaveBeenCalledTimes(1);
+      expect(mockGetArchive).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('with contracts available for download and expired contractArchiveId', () => {
+    let contractArchiveId: string;
+    beforeEach(() => {
+      organizationId = faker.string.uuid();
+      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();
+    });
+
+    it('should return READY status when archive exists on the server', async () => {
+      mockCheckArchive.mockResolvedValue(true);
+
+      const { result } = renderHook(() => useDownloadContractArchive({ organizationId }), {
+        wrapper: Wrapper,
+      });
+
+      // ensure that initial effects are done
+      await waitFor(() => {
+        expect(result.current.status).toBe(ContractDownloadStatus.READY);
+      });
+
+      expect(getStoredContractArchiveId()).toBe(contractArchiveId);
+
+      expect(mockCheckArchive).toHaveBeenCalledTimes(1);
+      expect(mockGetArchive).not.toHaveBeenCalled();
+      expect(mockCreateArchive).not.toHaveBeenCalled();
+    });
+
+    it("should return IDLE status and clear stored id when archive doesn't exists on the server", async () => {
+      mockCheckArchive.mockResolvedValue(false);
+
+      const { result } = renderHook(() => useDownloadContractArchive({ organizationId }), {
+        wrapper: Wrapper,
+      });
+
+      // ensure that initial effects are done
+      await waitFor(() => {
+        expect(result.current.status).toBe(ContractDownloadStatus.IDLE);
+      });
+
+      expect(getStoredContractArchiveId()).toBe(null);
+
+      expect(mockCheckArchive).toHaveBeenCalledTimes(1);
+      expect(mockGetArchive).not.toHaveBeenCalled();
+      expect(mockCreateArchive).not.toHaveBeenCalled();
+    });
+  });
+});