richie 2.29.2__py2.py3-none-any.whl → 2.30.0__py2.py3-none-any.whl

frontend/js/components/OpenEdxFullNameForm/index.spec.tsx

@@ -0,0 +1,229 @@
+import { PropsWithChildren } from 'react';
+import { act, screen } from '@testing-library/react';
+import fetchMock from 'fetch-mock';
+import { userEvent } from '@testing-library/user-event';
+import {
+  RichieContextFactory as mockRichieContextFactory,
+  UserFactory,
+} from 'utils/test/factories/richie';
+import { render } from 'utils/test/render';
+import { BaseJoanieAppWrapper } from 'utils/test/wrappers/BaseJoanieAppWrapper';
+import OpenEdxFullNameForm from 'components/OpenEdxFullNameForm/index';
+import { SaleTunnelContext } from 'components/SaleTunnel/GenericSaleTunnel';
+import { SaleTunnelContextFactory } from 'utils/test/factories/joanie';
+import { OpenEdxApiProfileFactory } from 'utils/test/factories/openEdx';
+import { createTestQueryClient } from 'utils/test/createTestQueryClient';
+import { setupJoanieSession } from 'utils/test/wrappers/JoanieAppWrapper';
+import { AppWrapperProps } from 'utils/test/wrappers/types';
+import { expectBannerError } from 'utils/test/expectBanner';
+
+jest.mock('utils/context', () => ({
+  __esModule: true,
+  default: mockRichieContextFactory({
+    authentication: { backend: 'fonzie', endpoint: 'https://auth.test' },
+    joanie_backend: { endpoint: 'https://joanie.endpoint' },
+  }).one(),
+}));
+
+jest.mock('utils/errors/handle', () => ({
+  handle: jest.fn(),
+}));
+
+describe('OpenEdxFullNameForm', () => {
+  let submitCallbacks: Record<PropertyKey, () => Promise<void>> = {};
+  const Wrapper = ({ children, ...props }: PropsWithChildren<AppWrapperProps>) => (
+    <BaseJoanieAppWrapper {...props}>
+      <SaleTunnelContext.Provider
+        value={SaleTunnelContextFactory({
+          registerSubmitCallback: (key: string, callback: () => Promise<void>) => {
+            submitCallbacks[key] = callback;
+          },
+        }).one()}
+      >
+        {children}
+      </SaleTunnelContext.Provider>
+      ,
+    </BaseJoanieAppWrapper>
+  );
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    fetchMock.restore();
+    submitCallbacks = {};
+  });
+  setupJoanieSession();
+
+  it('should not populate form with username', async () => {
+    const user = UserFactory({ full_name: '' }).one();
+    const queryClient = createTestQueryClient({ user });
+    const { 'pref-lang': prefLang, ...profile } = OpenEdxApiProfileFactory({
+      name: user.full_name,
+      username: user.username,
+      email: user.email,
+    }).one();
+    fetchMock.get(`https://auth.test/api/user/v1/accounts/${user.username}`, profile);
+    fetchMock.get(`https://auth.test/api/user/v1/preferences/${user.username}`, {
+      'pref-lang': prefLang,
+    });
+
+    render(<OpenEdxFullNameForm />, {
+      queryOptions: { client: queryClient },
+      wrapper: Wrapper,
+    });
+
+    const $input = await screen.findByRole('textbox', { name: 'Full name' });
+    expect($input).toHaveValue('');
+  });
+
+  it('should populate form with existing full name', async () => {
+    const user = UserFactory().one();
+    const queryClient = createTestQueryClient({ user });
+    const { 'pref-lang': prefLang, ...profile } = OpenEdxApiProfileFactory({
+      name: user.full_name,
+      username: user.username,
+      email: user.email,
+    }).one();
+    fetchMock.get(`https://auth.test/api/user/v1/accounts/${user.username}`, profile);
+    fetchMock.get(`https://auth.test/api/user/v1/preferences/${user.username}`, {
+      'pref-lang': prefLang,
+    });
+
+    render(<OpenEdxFullNameForm />, {
+      queryOptions: { client: queryClient },
+      wrapper: Wrapper,
+    });
+
+    const $input = await screen.findByRole('textbox', { name: 'Full name' });
+    expect($input).toHaveValue(user.full_name);
+  });
+
+  it('should require a value to submit the form', async () => {
+    const user = UserFactory({ full_name: '' }).one();
+    const queryClient = createTestQueryClient({ user });
+    const { 'pref-lang': prefLang, ...profile } = OpenEdxApiProfileFactory({
+      name: user.full_name,
+      username: user.username,
+      email: user.email,
+    }).one();
+    fetchMock.get(`https://auth.test/api/user/v1/accounts/${user.username}`, profile);
+    fetchMock.get(`https://auth.test/api/user/v1/preferences/${user.username}`, {
+      'pref-lang': prefLang,
+    });
+
+    expect(submitCallbacks).toEqual({});
+
+    render(<OpenEdxFullNameForm />, {
+      queryOptions: { client: queryClient },
+      wrapper: Wrapper,
+    });
+
+    expect(submitCallbacks.hasOwnProperty('openEdxFullNameForm')).toBe(true);
+
+    const $input = await screen.findByRole('textbox', { name: 'Full name' });
+    expect($input).toHaveValue('');
+
+    // Submit the form
+    await act(async () => {
+      await expect(submitCallbacks.openEdxFullNameForm()).rejects.not.toBeUndefined();
+    });
+
+    screen.getByText('This field is required.');
+  });
+
+  it('should require a value with at least 3 chars to submit the form', async () => {
+    const user = UserFactory({ full_name: '' }).one();
+    const queryClient = createTestQueryClient({ user });
+    const { 'pref-lang': prefLang, ...profile } = OpenEdxApiProfileFactory({
+      name: user.full_name,
+      username: user.username,
+      email: user.email,
+    }).one();
+    fetchMock.get(`https://auth.test/api/user/v1/accounts/${user.username}`, profile);
+    fetchMock.get(`https://auth.test/api/user/v1/preferences/${user.username}`, {
+      'pref-lang': prefLang,
+    });
+
+    expect(submitCallbacks).toEqual({});
+
+    render(<OpenEdxFullNameForm />, {
+      queryOptions: { client: queryClient },
+      wrapper: Wrapper,
+    });
+
+    expect(submitCallbacks.hasOwnProperty('openEdxFullNameForm')).toBe(true);
+
+    const $input = await screen.findByRole('textbox', { name: 'Full name' });
+    expect($input).toHaveValue('');
+
+    const eventHandler = userEvent.setup();
+    await eventHandler.type($input, 'Jo');
+
+    // Submit the form
+    await act(async () => {
+      await expect(submitCallbacks.openEdxFullNameForm()).rejects.not.toBeUndefined();
+    });
+
+    screen.getByText('The minimum length is 3 chars.');
+  });
+
+  it('should submit the form', async () => {
+    const user = UserFactory({ full_name: '' }).one();
+    const queryClient = createTestQueryClient({ user });
+    const { 'pref-lang': prefLang, ...profile } = OpenEdxApiProfileFactory({
+      name: user.full_name,
+      username: user.username,
+      email: user.email,
+    }).one();
+    fetchMock
+      .get(`https://auth.test/api/user/v1/accounts/${user.username}`, profile)
+      .get(`https://auth.test/api/user/v1/preferences/${user.username}`, {
+        'pref-lang': prefLang,
+      });
+
+    expect(submitCallbacks).toEqual({});
+
+    render(<OpenEdxFullNameForm />, {
+      queryOptions: { client: queryClient },
+      wrapper: Wrapper,
+    });
+
+    expect(submitCallbacks.hasOwnProperty('openEdxFullNameForm')).toBe(true);
+
+    const $input = await screen.findByRole('textbox', { name: 'Full name' });
+    expect($input).toHaveValue('');
+
+    const eventHandler = userEvent.setup();
+    await eventHandler.type($input, 'John Doe');
+
+    // Submit the form
+    fetchMock
+      .patch(`https://auth.test/api/user/v1/accounts/${user.username}`, 200)
+      .patch(`https://auth.test/api/user/v1/preferences/${user.username}`, 200)
+      .get('https://auth.test/api/v1.0/user/me', { ...user, full_name: 'John Doe' })
+      .get(
+        `https://auth.test/api/user/v1/accounts/JohnDoe`,
+        { ...profile, name: 'John Doe' },
+        { overwriteRoutes: true },
+      );
+
+    await act(async () => {
+      await submitCallbacks.openEdxFullNameForm();
+    });
+
+    expect($input).toHaveValue('John Doe');
+  });
+
+  it('should display error if request to retrieve account fails', async () => {
+    const user = UserFactory().one();
+    const queryClient = createTestQueryClient({ user });
+    fetchMock.get(`https://auth.test/api/user/v1/accounts/${user.username}`, 500);
+    fetchMock.get(`https://auth.test/api/user/v1/preferences/${user.username}`, 500);
+
+    render(<OpenEdxFullNameForm />, {
+      queryOptions: { client: queryClient },
+      wrapper: Wrapper,
+    });
+
+    await expectBannerError('An error occurred while fetching your profile. Please retry later.');
+  });
+});

frontend/js/components/OpenEdxFullNameForm/index.tsx

@@ -9,7 +9,6 @@ import useOpenEdxProfile from 'hooks/useOpenEdxProfile';
 import Form, { getLocalizedCunninghamErrorProp } from 'components/Form';
 import { Spinner } from 'components/Spinner';
 import Banner, { BannerType } from 'components/Banner';
-import { UserHelper } from 'utils/UserHelper';
 import { useSaleTunnelContext } from 'components/SaleTunnel/GenericSaleTunnel';
 
 const messages = defineMessages({
@@ -51,7 +50,7 @@ export interface OpenEdxFullNameFormValues {
 }
 
 const validationSchema = Yup.object().shape({
-  name: Yup.string().required(),
+  name: Yup.string().required().min(3),
 });
 
 const OpenEdxFullNameForm = () => {
@@ -70,7 +69,7 @@ const OpenEdxFullNameForm = () => {
 
   const defaultValues = useMemo(
     () => ({
-      name: (openEdxProfileData ? UserHelper.getName(openEdxProfileData) : '')?.trim(),
+      name: (openEdxProfileData?.name || '')?.trim(),
     }),
     [openEdxProfileData],
   );
@@ -82,19 +81,20 @@ const OpenEdxFullNameForm = () => {
     resolver: yupResolver(validationSchema),
   });
 
-  const { register, handleSubmit, reset, formState } = form;
+  const { getValues, register, handleSubmit, reset, formState } = form;
 
   useEffect(() => {
     if (openEdxProfileData) {
-      reset({ name: (openEdxProfileData ? UserHelper.getName(openEdxProfileData) : '')?.trim() });
+      reset({ name: (openEdxProfileData?.name || '')?.trim() });
     }
   }, [openEdxProfileData]);
 
   useEffect(() => {
     registerSubmitCallback('openEdxFullNameForm', async () => {
       return new Promise<void>((resolve, reject) => {
+        const { name } = getValues();
         // Don't save if the form has not been modified.
-        if (!formState.isDirty) {
+        if (name && !formState.isDirty) {
           resolve();
           return;
         }
@@ -110,7 +110,7 @@ const OpenEdxFullNameForm = () => {
             },
             onError: (e) => reject(e),
           });
-        })();
+        }, reject)();
       });
     });
     return () => {

frontend/js/components/PaymentInterfaces/LyraPopIn.tsx

@@ -29,7 +29,7 @@ const LyraPopIn = ({
     if (error && typeof error === 'string') handle(`[LyraPopIn] - ${error}`);
 
     if (shouldAbort.current) {
-      onError(PaymentErrorMessageId.ERROR_ABORTING);
+      onError(PaymentErrorMessageId.ERROR_ABORT);
     } else if (typeof error === 'string') {
       onError(error);
     } else {
@@ -114,7 +114,7 @@ const LyraPopIn = ({
 
     const handleClosePopIn = () => {
       if (shouldAbort.current === true) {
-        onError(PaymentErrorMessageId.ERROR_ABORTING);
+        onError(PaymentErrorMessageId.ERROR_ABORT);
       }
     };
 

frontend/js/components/PaymentInterfaces/PayplugLightbox.tsx

@@ -27,7 +27,7 @@ const PayplugLightbox = ({
       switch (event.data) {
         case 'closePayPlugFrame':
           ref.current = setTimeout(() => {
-            onError(PaymentErrorMessageId.ERROR_ABORTING);
+            onError(PaymentErrorMessageId.ERROR_ABORT);
           }, 2000);
           break;
       }

frontend/js/components/PaymentInterfaces/__mocks__/index.tsx

@@ -9,10 +9,7 @@ const PaymentInterface = ({ onError, onSuccess }: PaymentInterfaceProps) => (
     >
       Simulate payment failure
     </button>
-    <button
-      data-testid="payment-abort"
-      onClick={() => onError(PaymentErrorMessageId.ERROR_ABORTING)}
-    >
+    <button data-testid="payment-abort" onClick={() => onError(PaymentErrorMessageId.ERROR_ABORT)}>
       Simulate payment abort
     </button>
     <button data-testid="payment-success" onClick={onSuccess}>

frontend/js/components/PaymentInterfaces/types.ts

@@ -1,10 +1,13 @@
 export enum PaymentErrorMessageId {
   ERROR_ABORT = 'errorAbort',
-  ERROR_ABORTING = 'errorAborting',
+  ERROR_DEFAULT = 'errorDefault',
+}
+
+export enum SubscriptionErrorMessageId {
+  ERROR_ABORT = 'errorAbort',
   ERROR_ADDRESS = 'errorAddress',
   ERROR_DEFAULT = 'errorDefault',
   ERROR_FULL_PRODUCT = 'errorFullProduct',
-  ERROR_TERMS = 'errorTerms',
 }
 
 export enum PaymentProviders {

frontend/js/components/PaymentScheduleGrid/_styles.scss

@@ -1,3 +1,16 @@
+.payment-schedule__grid {
+  .payment-schedule__cell {
+    &--wrapped {
+      white-space: normal;
+    }
+
+    &--alignRight {
+      display: flex;
+      justify-content: flex-end;
+    }
+  }
+}
+
 .status-pill {
   display: inline-flex;
   align-items: center;

frontend/js/components/PaymentScheduleGrid/index.tsx

@@ -1,91 +1,93 @@
-import { DataList } from '@openfun/cunningham-react';
+import { DataGrid } from '@openfun/cunningham-react';
+import { defineMessages, FormattedMessage, useIntl } from 'react-intl';
 import { StringHelper } from 'utils/StringHelper';
+import { PaymentSchedule, PaymentScheduleState } from 'types/Joanie';
+import useDateFormat from 'hooks/useDateFormat';
+
+type Props = {
+  schedule: PaymentSchedule;
+};
+
+const messages = defineMessages({
+  withdrawnAt: {
+    id: 'components.PaymentScheduleGrid.withdrawnAt',
+    defaultMessage: 'Withdrawn on {date}',
+    description: 'Label displayed to explain when the installment will be withdrawn.',
+  },
+});
+
+export const stateMessages = defineMessages({
+  [PaymentScheduleState.PENDING]: {
+    id: 'components.PaymentScheduleGrid.state.pending',
+    defaultMessage: 'Pending',
+    description: 'Label displayed for pending payment state',
+  },
+  [PaymentScheduleState.PAID]: {
+    id: 'components.PaymentScheduleGrid.state.paid',
+    defaultMessage: 'Paid',
+    description: 'Label displayed for paid payment state',
+  },
+  [PaymentScheduleState.REFUSED]: {
+    id: 'components.PaymentScheduleGrid.state.refused',
+    defaultMessage: 'Refused',
+    description: 'Label displayed for refused payment state',
+  },
+});
+
+export const PaymentScheduleGrid = ({ schedule }: Props) => {
+  const intl = useIntl();
+  const formatDate = useDateFormat();
 
-export const PaymentScheduleGrid = () => {
   return (
     <div className="payment-schedule__grid">
-      <DataList
+      <DataGrid
+        displayHeader={false}
         columns={[
+          { field: 'index', size: 10 },
+          { field: 'amount', size: 90 },
           {
-            id: 'date',
-            renderCell: (context) =>
-              context.row.id === 'total' ? <strong>{context.row.date}</strong> : context.row.date,
+            field: 'date',
+            renderCell: ({ row }) => (
+              <span className="payment-schedule__cell--wrapped">
+                <FormattedMessage {...messages.withdrawnAt} values={{ date: row.date }} />
+              </span>
+            ),
           },
           {
-            id: 'amount',
-            renderCell: (context) =>
-              context.row.id === 'total' ? (
-                <strong>{context.row.amount}</strong>
+            id: 'state',
+            renderCell: ({ row }) =>
+              row.state ? (
+                <div className="payment-schedule__cell--alignRight">
+                  <StatusPill state={row.state} />
+                </div>
               ) : (
-                context.row.amount
+                ''
               ),
           },
-          {
-            id: 'status',
-            renderCell: (context) =>
-              context.row.status ? <StatusPill status={context.row.status} /> : '',
-          },
-          { field: 'message' },
-        ]}
-        rows={[
-          {
-            id: '1',
-            date: '2023-03-15',
-            amount: '€ 100.00',
-            status: PaymentScheduleStatus.PAID,
-            message: 'First payment (30%)',
-          },
-          {
-            id: '2',
-            date: '2023-04-15',
-            amount: '€ 100.00',
-            status: PaymentScheduleStatus.REQUIRE_PAYMENT,
-            message: 'Periodic',
-          },
-          {
-            id: '3',
-            date: '2023-05-15',
-            amount: '€ 100.00',
-            status: PaymentScheduleStatus.FAILED,
-            message: 'Periodic',
-          },
-          {
-            id: '4',
-            date: '2023-06-15',
-            amount: '€ 100.00',
-            status: PaymentScheduleStatus.INCOMING,
-            message: 'Periodic',
-          },
-          {
-            id: '5',
-            date: '2023-06-15',
-            amount: '€ 100.00',
-            status: PaymentScheduleStatus.PENDING,
-            message: 'Periodic',
-          },
-          {
-            id: 'total',
-            date: 'Total',
-            amount: '€ 1150.00',
-          },
         ]}
+        rows={schedule.map((installment, index) => ({
+          id: installment.id,
+          index: index + 1,
+          date: formatDate(installment.due_date),
+          amount: intl.formatNumber(installment.amount, {
+            style: 'currency',
+            currency: installment.currency,
+          }),
+          state: installment.state,
+        }))}
       />
     </div>
   );
 };
 
-export enum PaymentScheduleStatus {
-  INCOMING = 'incoming',
-  PENDING = 'pending',
-  PAID = 'paid',
-  FAILED = 'failed',
-  REQUIRE_PAYMENT = 'require_payment',
-}
-
-export const StatusPill = ({ status }: { status: PaymentScheduleStatus }) => {
+export const StatusPill = ({ state }: { state: PaymentScheduleState }) => {
   return (
-    <span className={`status-pill status-pill--${status}`}>
-      {StringHelper.capitalizeFirst(status.replace('_', ' '))}
+    <span className={`status-pill status-pill--${state}`}>
+      {state in stateMessages ? (
+        <FormattedMessage {...stateMessages[state]} />
+      ) : (
+        StringHelper.capitalizeFirst(state.replace('_', ' '))
+      )}
     </span>
   );
 };