richie-education 2.29.1-dev32 → 2.29.1-dev37

package/js/components/ContractStatus/index.spec.tsx

@@ -23,7 +23,7 @@ describe('<ContractStatus />', () => {
     );
 
     expect(
-      screen.queryByText('You have to sign this training contract to access your training.'),
+      screen.queryByText('You have to sign this training contract to finalize your subscription.'),
     ).toBeInTheDocument();
 
     expect(screen.queryByText(/You signed this training contract/)).not.toBeInTheDocument();

package/js/components/ContractStatus/index.tsx

@@ -15,7 +15,7 @@ const messages = defineMessages({
     id: 'components.ContractStatus.organizationSignedOn',
   },
   waitingLearnerSignature: {
-    defaultMessage: 'You have to sign this training contract to access your training.',
+    defaultMessage: 'You have to sign this training contract to finalize your subscription.',
     description: 'Label displayed when a training contract need to be signed by the learner',
     id: 'components.ContractStatus.waitingSignature',
   },

package/js/components/PurchaseButton/index.tsx

@@ -1,13 +1,12 @@
 import c from 'classnames';
 import { defineMessages, FormattedMessage, useIntl } from 'react-intl';
-import { useMemo } from 'react';
 import { Button, ButtonProps, useModal } from '@openfun/cunningham-react';
 import { useSession } from 'contexts/SessionContext';
 import * as Joanie from 'types/Joanie';
-import { isOpenedCourseRunCertificate, isOpenedCourseRunCredential } from 'utils/CourseRuns';
 import { SaleTunnel, SaleTunnelProps } from 'components/SaleTunnel';
-import { Organization } from 'types/Joanie';
+import { CourseLight, Organization } from 'types/Joanie';
 import { PacedCourse } from 'types';
+import { ProductHelper } from 'utils/ProductHelper';
 
 const messages = defineMessages({
   loginToPurchase: {
@@ -53,7 +52,7 @@ interface PurchaseButtonPropsBase {
 
 interface CredentialPurchaseButtonProps extends PurchaseButtonPropsBase {
   product: Joanie.CredentialProduct;
-  course: PacedCourse;
+  course: PacedCourse | CourseLight;
   enrollment?: undefined;
 }
 
@@ -77,26 +76,9 @@ const PurchaseButton = ({
   const intl = useIntl();
   const { user, login } = useSession();
 
-  const hasAtLeastOneCourseRun = useMemo(() => {
-    if (product.type === Joanie.ProductType.CERTIFICATE) {
-      if (!enrollment?.course_run) {
-        throw new Error(
-          'Unable to instanciate PurchaseButton with a product CERTIFICATE without the according CourseRun.',
-        );
-      }
-      return isOpenedCourseRunCertificate(enrollment.course_run.state);
-    }
-    return (
-      product.target_courses.length > 0 &&
-      product.target_courses.every(({ course_runs }) =>
-        course_runs.some((targetCourseRun) => isOpenedCourseRunCredential(targetCourseRun.state)),
-      )
-    );
-  }, [product]);
-
-  const hasAtLeastOneRemainingOrder =
-    typeof product?.remaining_order_count !== 'number' || product.remaining_order_count > 0;
-  const isPurchasable = hasAtLeastOneRemainingOrder && hasAtLeastOneCourseRun;
+  const hasOpenedTargetCourse = ProductHelper.hasOpenedTargetCourse(product, enrollment);
+  const hasRemainingSeat = ProductHelper.hasRemainingSeats(product);
+  const isPurchasable = hasRemainingSeat && hasOpenedTargetCourse;
 
   const saleTunnelModal = useModal({
     isOpenDefault: false,
@@ -121,7 +103,7 @@ const PurchaseButton = ({
             data-testid="PurchaseButton__cta"
             className={c('purchase-button__cta', className)}
             onClick={() => {
-              if (hasAtLeastOneCourseRun) {
+              if (hasOpenedTargetCourse) {
                 saleTunnelModal.open();
               }
             }}
@@ -136,7 +118,7 @@ const PurchaseButton = ({
           >
             {product.call_to_action}
           </Button>
-          {!hasAtLeastOneCourseRun && (
+          {!hasOpenedTargetCourse && (
             <p className="purchase-button__no-course-run">
               <FormattedMessage
                 {...(product.type === Joanie.ProductType.CREDENTIAL
@@ -145,7 +127,7 @@ const PurchaseButton = ({
               />
             </p>
           )}
-          {hasAtLeastOneCourseRun && !hasAtLeastOneRemainingOrder && (
+          {hasOpenedTargetCourse && !hasRemainingSeat && (
             <p className="purchase-button__no-course-run">
               <FormattedMessage {...messages.noRemainingOrder} />
             </p>

package/js/components/SaleTunnel/index.tsx

@@ -1,6 +1,7 @@
 import { ModalProps } from '@openfun/cunningham-react';
 import {
   CertificateProduct,
+  CourseLight,
   CredentialProduct,
   Enrollment,
   Order,
@@ -17,7 +18,7 @@ export interface SaleTunnelProps extends Pick<ModalProps, 'isOpen' | 'onClose'>
   product: Product;
   organizations?: Organization[];
 
-  course?: PacedCourse;
+  course?: PacedCourse | CourseLight;
   enrollment?: Enrollment;
   orderGroup?: OrderGroup;
   onFinish?: (order: Order) => void;

package/js/pages/DashboardOrderLayout/index.spec.tsx

@@ -1,7 +1,8 @@
 import { findByRole, render, screen, waitFor } from '@testing-library/react';
 import fetchMock from 'fetch-mock';
+import queryString from 'query-string';
 import { RichieContextFactory as mockRichieContextFactory } from 'utils/test/factories/richie';
-import { CredentialOrder } from 'types/Joanie';
+import { CredentialOrder, NOT_CANCELED_ORDER_STATES } from 'types/Joanie';
 import { CredentialOrderFactory, TargetCourseFactory } from 'utils/test/factories/joanie';
 import { mockCourseProductWithOrder } from 'utils/test/mockCourseProductWithOrder';
 import { createTestQueryClient } from 'utils/test/createTestQueryClient';
@@ -54,6 +55,14 @@ describe('<DashboardOrderLayout />', () => {
       { results: [order], next: null, previous: null, count: null },
       { overwriteRoutes: true },
     );
+    const orderQueryParameters = {
+      course_code: order.course.code,
+      product_id: order.product_id,
+      state: NOT_CANCELED_ORDER_STATES,
+    };
+    const queryParams = queryString.stringify(orderQueryParameters);
+    const url = `https://joanie.endpoint/api/v1.0/orders/?${queryParams}`;
+    fetchMock.get(url, [order]);
 
     render(WrapperWithDashboard(LearnerDashboardPaths.ORDER.replace(':orderId', order.id)));
 

package/js/utils/ProductHelper/index.spec.ts

@@ -1,183 +1,339 @@
 import { createIntl } from 'react-intl';
-import { CourseRunFactory, ProductFactory, TargetCourseFactory } from 'utils/test/factories/joanie';
+import {
+  CertificateProductFactory,
+  CourseRunFactory,
+  CredentialProductFactory,
+  EnrollmentFactory,
+  ProductFactory,
+  TargetCourseFactory,
+} from 'utils/test/factories/joanie';
+import { CourseStateFactory } from 'utils/test/factories/richie';
+import { Priority } from 'types';
 import { ProductHelper } from '.';
 
 describe('ProductHelper', () => {
-  it('should return the product date range processed from course runs dates', () => {
-    const product = ProductFactory({
-      target_courses: [
-        TargetCourseFactory({
-          course_runs: [
-            CourseRunFactory({
-              start: new Date('2023-08-13').toISOString(),
-              end: new Date('2024-04-27').toISOString(),
-            }).one(),
-            CourseRunFactory({
-              start: new Date('2023-09-17').toISOString(),
-              end: new Date('2024-05-29').toISOString(),
-            }).one(),
-          ],
-        }).one(),
-        TargetCourseFactory({
-          course_runs: [
-            CourseRunFactory({
-              start: new Date('2024-01-19').toISOString(),
-              end: new Date('2025-02-17').toISOString(),
-            }).one(),
-          ],
-        }).one(),
-      ],
-    }).one();
-
-    expect(ProductHelper.getDateRange(product)).toEqual([
-      new Date('2023-08-13'),
-      new Date('2025-02-17'),
-    ]);
+  beforeEach(() => {
+    jest.resetAllMocks();
   });
 
-  it('should return undefined minDate when there is a course run with an undefined start date', () => {
-    const product = ProductFactory({
-      target_courses: [
-        TargetCourseFactory({
-          course_runs: [
-            CourseRunFactory({
-              start: undefined,
-              end: new Date('2024-04-27').toISOString(),
-            }).one(),
-            CourseRunFactory({
-              start: new Date('2023-09-17').toISOString(),
-              end: new Date('2024-05-29').toISOString(),
-            }).one(),
-          ],
-        }).one(),
-        TargetCourseFactory({
-          course_runs: [
-            CourseRunFactory({
-              start: new Date('2024-01-19').toISOString(),
-              end: new Date('2025-02-17').toISOString(),
-            }).one(),
-          ],
-        }).one(),
-      ],
-    }).one();
-
-    expect(ProductHelper.getDateRange(product)).toEqual([undefined, new Date('2025-02-17')]);
-  });
+  describe('getDateRange', () => {
+    it('should return the product date range processed from course runs dates', () => {
+      const product = ProductFactory({
+        target_courses: [
+          TargetCourseFactory({
+            course_runs: [
+              CourseRunFactory({
+                start: new Date('2023-08-13').toISOString(),
+                end: new Date('2024-04-27').toISOString(),
+              }).one(),
+              CourseRunFactory({
+                start: new Date('2023-09-17').toISOString(),
+                end: new Date('2024-05-29').toISOString(),
+              }).one(),
+            ],
+          }).one(),
+          TargetCourseFactory({
+            course_runs: [
+              CourseRunFactory({
+                start: new Date('2024-01-19').toISOString(),
+                end: new Date('2025-02-17').toISOString(),
+              }).one(),
+            ],
+          }).one(),
+        ],
+      }).one();
+
+      expect(ProductHelper.getDateRange(product)).toEqual([
+        new Date('2023-08-13'),
+        new Date('2025-02-17'),
+      ]);
+    });
+
+    it('should return undefined minDate when there is a course run with an undefined start date', () => {
+      const product = ProductFactory({
+        target_courses: [
+          TargetCourseFactory({
+            course_runs: [
+              CourseRunFactory({
+                start: undefined,
+                end: new Date('2024-04-27').toISOString(),
+              }).one(),
+              CourseRunFactory({
+                start: new Date('2023-09-17').toISOString(),
+                end: new Date('2024-05-29').toISOString(),
+              }).one(),
+            ],
+          }).one(),
+          TargetCourseFactory({
+            course_runs: [
+              CourseRunFactory({
+                start: new Date('2024-01-19').toISOString(),
+                end: new Date('2025-02-17').toISOString(),
+              }).one(),
+            ],
+          }).one(),
+        ],
+      }).one();
+
+      expect(ProductHelper.getDateRange(product)).toEqual([undefined, new Date('2025-02-17')]);
+    });
+
+    it('should return undefined maxDate when there is a course run with an undefined end date', () => {
+      const product = ProductFactory({
+        target_courses: [
+          TargetCourseFactory({
+            course_runs: [
+              CourseRunFactory({
+                start: new Date('2023-08-13').toISOString(),
+                end: undefined,
+              }).one(),
+              CourseRunFactory({
+                start: new Date('2023-09-17').toISOString(),
+                end: new Date('2024-05-29').toISOString(),
+              }).one(),
+            ],
+          }).one(),
+          TargetCourseFactory({
+            course_runs: [
+              CourseRunFactory({
+                start: new Date('2024-01-19').toISOString(),
+                end: new Date('2025-02-17').toISOString(),
+              }).one(),
+            ],
+          }).one(),
+        ],
+      }).one();
 
-  it('should return undefined maxDate when there is a course run with an undefined end date', () => {
-    const product = ProductFactory({
-      target_courses: [
-        TargetCourseFactory({
-          course_runs: [
-            CourseRunFactory({
-              start: new Date('2023-08-13').toISOString(),
-              end: undefined,
-            }).one(),
-            CourseRunFactory({
-              start: new Date('2023-09-17').toISOString(),
-              end: new Date('2024-05-29').toISOString(),
-            }).one(),
-          ],
-        }).one(),
-        TargetCourseFactory({
-          course_runs: [
-            CourseRunFactory({
-              start: new Date('2024-01-19').toISOString(),
-              end: new Date('2025-02-17').toISOString(),
-            }).one(),
-          ],
-        }).one(),
-      ],
-    }).one();
-
-    expect(ProductHelper.getDateRange(product)).toEqual([new Date('2023-08-13'), undefined]);
+      expect(ProductHelper.getDateRange(product)).toEqual([new Date('2023-08-13'), undefined]);
+    });
   });
 
-  it('should return the product languages processed from course runs languages', () => {
-    const product = ProductFactory({
-      target_courses: [
-        TargetCourseFactory({
-          course_runs: [
-            CourseRunFactory({
-              languages: ['fr', 'en'],
-            }).one(),
-            CourseRunFactory({
-              languages: ['fr', 'de'],
-            }).one(),
-          ],
-        }).one(),
-        TargetCourseFactory({
-          course_runs: [
-            CourseRunFactory({
-              languages: ['fr', 'es'],
-            }).one(),
-          ],
-        }).one(),
-      ],
-    }).one();
-
-    expect(ProductHelper.getLanguages(product)).toEqual(['fr', 'en', 'de', 'es']);
+  describe('getLanguages', () => {
+    it('should return the product languages processed from course runs languages', () => {
+      const product = ProductFactory({
+        target_courses: [
+          TargetCourseFactory({
+            course_runs: [
+              CourseRunFactory({
+                languages: ['fr', 'en'],
+              }).one(),
+              CourseRunFactory({
+                languages: ['fr', 'de'],
+              }).one(),
+            ],
+          }).one(),
+          TargetCourseFactory({
+            course_runs: [
+              CourseRunFactory({
+                languages: ['fr', 'es'],
+              }).one(),
+            ],
+          }).one(),
+        ],
+      }).one();
+
+      expect(ProductHelper.getLanguages(product)).toEqual(['fr', 'en', 'de', 'es']);
+    });
+
+    it('should return an empty array when there is no language', () => {
+      const product = ProductFactory({
+        target_courses: [
+          TargetCourseFactory({
+            course_runs: [
+              CourseRunFactory({
+                languages: [],
+              }).one(),
+            ],
+          }).one(),
+        ],
+      }).one();
+
+      expect(ProductHelper.getLanguages(product)).toEqual([]);
+    });
+
+    it('should return sorted human readable languages according to the active language', () => {
+      const product = ProductFactory({
+        target_courses: [
+          TargetCourseFactory({
+            course_runs: [
+              CourseRunFactory({
+                languages: ['fr', 'en'],
+              }).one(),
+              CourseRunFactory({
+                languages: ['fr', 'de'],
+              }).one(),
+            ],
+          }).one(),
+          TargetCourseFactory({
+            course_runs: [
+              CourseRunFactory({
+                languages: ['fr', 'es'],
+              }).one(),
+            ],
+          }).one(),
+        ],
+      }).one();
+
+      const intl = createIntl({ locale: 'en' });
+      expect(ProductHelper.getLanguages(product, true, intl)).toEqual(
+        'English, French, German and Spanish',
+      );
+    });
+
+    it('should return an empty string when there is no language', () => {
+      const product = ProductFactory({
+        target_courses: [
+          TargetCourseFactory({
+            course_runs: [
+              CourseRunFactory({
+                languages: [],
+              }).one(),
+            ],
+          }).one(),
+        ],
+      }).one();
+
+      const intl = createIntl({ locale: 'en' });
+      expect(ProductHelper.getLanguages(product, true, intl)).toEqual('');
+    });
   });
 
-  it('should return an empty array when there is no language', () => {
-    const product = ProductFactory({
-      target_courses: [
-        TargetCourseFactory({
-          course_runs: [
-            CourseRunFactory({
-              languages: [],
-            }).one(),
-          ],
-        }).one(),
-      ],
-    }).one();
-
-    expect(ProductHelper.getLanguages(product)).toEqual([]);
+  describe('hasRemainingSeats', () => {
+    it('should return false when the product is undefined', () => {
+      expect(ProductHelper.hasRemainingSeats(undefined)).toBe(false);
+    });
+
+    it('should return true when the product has no order group', () => {
+      const product = ProductFactory({
+        remaining_order_count: null,
+      }).one();
+
+      expect(ProductHelper.hasRemainingSeats(product)).toBe(true);
+    });
+
+    it('should return true when the product has remaining seats', () => {
+      const product = ProductFactory({
+        remaining_order_count: 10,
+      }).one();
+
+      expect(ProductHelper.hasRemainingSeats(product)).toBe(true);
+    });
+
+    it('should return false when the product does not have remaining seats', () => {
+      const product = ProductFactory({
+        remaining_order_count: 0,
+      }).one();
+
+      expect(ProductHelper.hasRemainingSeats(product)).toBe(false);
+    });
   });
 
-  it('should return sorted human readable languages according to the active language', () => {
-    const product = ProductFactory({
-      target_courses: [
-        TargetCourseFactory({
-          course_runs: [
-            CourseRunFactory({
-              languages: ['fr', 'en'],
-            }).one(),
-            CourseRunFactory({
-              languages: ['fr', 'de'],
-            }).one(),
-          ],
-        }).one(),
-        TargetCourseFactory({
-          course_runs: [
-            CourseRunFactory({
-              languages: ['fr', 'es'],
-            }).one(),
-          ],
-        }).one(),
-      ],
-    }).one();
-
-    const intl = createIntl({ locale: 'en' });
-    expect(ProductHelper.getLanguages(product, true, intl)).toEqual(
-      'English, French, German and Spanish',
-    );
+  describe('hasOpenedTargetCourse', () => {
+    const openedCourseRunFactory = CourseRunFactory({
+      state: CourseStateFactory({
+        priority: Priority.ONGOING_OPEN,
+      }).one(),
+    });
+
+    const closedCourseRunFactory = CourseRunFactory({
+      state: CourseStateFactory({
+        priority: Priority.ARCHIVED_CLOSED,
+      }).one(),
+    });
+
+    it('should return false when the product is undefined', () => {
+      expect(ProductHelper.hasOpenedTargetCourse(undefined)).toBe(false);
+    });
+
+    it('should throw an error when the product is a certificate and the enrollment is undefined', () => {
+      const product = CertificateProductFactory().one();
+
+      expect(() => ProductHelper.hasOpenedTargetCourse(product, undefined)).toThrowError(
+        'Unable to check if the certificate product relies on an opened course run without enrollment.',
+      );
+    });
+
+    it('should return true when the product is a certificate and the related course run is opened', () => {
+      const product = CertificateProductFactory().one();
+      const courseRun = openedCourseRunFactory.one();
+      const enrollment = EnrollmentFactory({ course_run: courseRun }).one();
+
+      expect(ProductHelper.hasOpenedTargetCourse(product, enrollment)).toBe(true);
+    });
+
+    it('should return false when the product is a certificate and the related course run is not opened', () => {
+      const product = CertificateProductFactory().one();
+      const courseRun = closedCourseRunFactory.one();
+      const enrollment = EnrollmentFactory({ course_run: courseRun }).one();
+
+      expect(ProductHelper.hasOpenedTargetCourse(product, enrollment)).toBe(false);
+    });
+
+    it('should return false when the product is a credential and has not target courses', () => {
+      const product = CredentialProductFactory({ target_courses: [] }).one();
+
+      expect(ProductHelper.hasOpenedTargetCourse(product)).toBe(false);
+    });
+
+    it('should return false when the product is a credential and at least one target course has no opened course run', () => {
+      const targetCourseOpen = TargetCourseFactory({
+        course_runs: [openedCourseRunFactory.one(), closedCourseRunFactory.one()],
+      }).one();
+      const targetCourseClosed = TargetCourseFactory({
+        course_runs: [closedCourseRunFactory.one(), closedCourseRunFactory.one()],
+      }).one();
+      const product = CredentialProductFactory({
+        target_courses: [targetCourseOpen, targetCourseClosed],
+      }).one();
+
+      expect(ProductHelper.hasOpenedTargetCourse(product)).toBe(false);
+    });
+
+    it('should return false when the product is a credential and target courses has one opened course run', () => {
+      const targetCourseOpen = TargetCourseFactory({
+        course_runs: [openedCourseRunFactory.one(), closedCourseRunFactory.one()],
+      }).many(1);
+      const product = CredentialProductFactory({ target_courses: targetCourseOpen }).one();
+
+      expect(ProductHelper.hasOpenedTargetCourse(product)).toBe(true);
+    });
   });
 
-  it('should return an empty string when there is no language', () => {
-    const product = ProductFactory({
-      target_courses: [
-        TargetCourseFactory({
-          course_runs: [
-            CourseRunFactory({
-              languages: [],
-            }).one(),
-          ],
-        }).one(),
-      ],
-    }).one();
-
-    const intl = createIntl({ locale: 'en' });
-    expect(ProductHelper.getLanguages(product, true, intl)).toEqual('');
+  describe('isPurchasable', () => {
+    it('should return false when the product is undefined', () => {
+      expect(ProductHelper.isPurchasable(undefined)).toBe(false);
+    });
+
+    it('should return false when the product does not have opened target courses', () => {
+      jest.spyOn(ProductHelper, 'hasOpenedTargetCourse').mockReturnValue(false);
+      jest.spyOn(ProductHelper, 'hasRemainingSeats').mockReturnValue(true);
+      const product = ProductFactory().one();
+
+      expect(ProductHelper.isPurchasable(product)).toBe(false);
+    });
+
+    it('should return false when the product does not remaining seats', () => {
+      jest.spyOn(ProductHelper, 'hasOpenedTargetCourse').mockReturnValue(true);
+      jest.spyOn(ProductHelper, 'hasRemainingSeats').mockReturnValue(false);
+      const product = ProductFactory().one();
+
+      expect(ProductHelper.isPurchasable(product)).toBe(false);
+    });
+
+    it('should return false when the product does not have opened target courses and remaining seats', () => {
+      jest.spyOn(ProductHelper, 'hasOpenedTargetCourse').mockReturnValue(false);
+      jest.spyOn(ProductHelper, 'hasRemainingSeats').mockReturnValue(false);
+      const product = ProductFactory().one();
+
+      expect(ProductHelper.isPurchasable(product)).toBe(false);
+    });
+
+    it('should return true when the product has opened target courses and remaining seats', () => {
+      jest.spyOn(ProductHelper, 'hasOpenedTargetCourse').mockReturnValue(true);
+      jest.spyOn(ProductHelper, 'hasRemainingSeats').mockReturnValue(true);
+      const product = ProductFactory().one();
+
+      expect(ProductHelper.isPurchasable(product)).toBe(true);
+    });
   });
 });