| import { |
| render, |
| getAllByLabelText as getAllByLabelTextInNode, |
| getByText as getByTextInNode, |
| queryByText as queryByTextInNode, |
| screen, |
| waitFor, |
| } from '@testing-library/react'; |
| import userEvent from '@testing-library/user-event'; |
| import { createContext, useState, useContext } from 'react'; |
| import { |
| CheckoutProvider, |
| CheckoutStep, |
| CheckoutStepBody, |
| useIsStepComplete, |
| useTransactionStatus, |
| usePaymentProcessor, |
| CheckoutFormSubmit, |
| CheckoutStepGroup, |
| useSetStepComplete, |
| useTogglePaymentMethod, |
| makeErrorResponse, |
| useMakeStepActive, |
| } from '../src/public-api'; |
| import { PaymentProcessorFunction, PaymentProcessorResponseType } from '../src/types'; |
| import { DefaultCheckoutSteps } from './utils/default-checkout-steps'; |
|
|
| const myContext = createContext( undefined ); |
| const usePaymentData = () => useContext( myContext ); |
|
|
| function TogglePaymentMethodBlock( { mockMethod } ) { |
| const togglePaymentMethod = useTogglePaymentMethod(); |
|
|
| return ( |
| <div> |
| <button onClick={ () => togglePaymentMethod( mockMethod.id, false ) }> |
| Disable Payment Method |
| </button> |
| <button onClick={ () => togglePaymentMethod( mockMethod.id, true ) }> |
| Enable Payment Method |
| </button> |
| </div> |
| ); |
| } |
|
|
| const createMockMethod = createMockMethodFactory(); |
|
|
| describe( 'Checkout', () => { |
| describe( 'using the default steps', function () { |
| describe( 'using other defaults', function () { |
| let MyCheckout; |
| const mockMethod = createMockMethod(); |
| const mockMethod2 = createMockMethod( { |
| submitButton: <MockSubmitButton content="Second method" />, |
| activeContent: <div />, |
| } ); |
| const { items, total } = createMockItems(); |
|
|
| beforeEach( () => { |
| MyCheckout = () => ( |
| <CheckoutProvider |
| paymentMethods={ [ mockMethod, mockMethod2 ] } |
| paymentProcessors={ getMockPaymentProcessors() } |
| selectFirstAvailablePaymentMethod |
| > |
| <DefaultCheckoutSteps items={ items } /> |
| <TogglePaymentMethodBlock mockMethod={ mockMethod } /> |
| </CheckoutProvider> |
| ); |
| } ); |
|
|
| it( 'renders the line items and the total', () => { |
| const { container } = render( <MyCheckout /> ); |
|
|
| |
| getAllByLabelTextInNode( container, items[ 0 ].label ).map( ( element ) => |
| expect( element ).toHaveTextContent( items[ 0 ].amount ) |
| ); |
| getAllByLabelTextInNode( container, items[ 1 ].label ).map( ( element ) => |
| expect( element ).toHaveTextContent( items[ 1 ].amount ) |
| ); |
|
|
| |
| getAllByLabelTextInNode( container, total.label ).map( ( element ) => |
| expect( element ).toHaveTextContent( total.amount ) |
| ); |
| } ); |
|
|
| it( 'renders the payment method label', () => { |
| const { getAllByText } = render( <MyCheckout /> ); |
| expect( getAllByText( mockMethod.inactiveContent )[ 0 ] ).toBeInTheDocument(); |
| expect( getAllByText( mockMethod2.inactiveContent )[ 0 ] ).toBeInTheDocument(); |
| } ); |
|
|
| it( 'renders the payment method label as selected', async () => { |
| const { getAllByText, findByLabelText } = render( <MyCheckout /> ); |
| const user = userEvent.setup(); |
| await user.click( getAllByText( 'Continue' )[ 0 ] ); |
| const paymentMethod = await findByLabelText( mockMethod.inactiveContent ); |
| expect( paymentMethod ).toBeChecked(); |
| } ); |
|
|
| it( 'does not render the payment method label if the payment method is disabled', async () => { |
| const { queryByText, getByText, getAllByText } = render( <MyCheckout /> ); |
| const user = userEvent.setup(); |
| await user.click( getAllByText( 'Continue' )[ 0 ] ); |
| await user.click( getByText( 'Disable Payment Method' ) ); |
| expect( queryByText( mockMethod.inactiveContent ) ).not.toBeVisible(); |
| } ); |
|
|
| it( 'does render the payment method label if the payment method is disabled then enabled', async () => { |
| const { getAllByText, getByText } = render( <MyCheckout /> ); |
| const user = userEvent.setup(); |
| await user.click( getAllByText( 'Continue' )[ 0 ] ); |
| await user.click( getByText( 'Disable Payment Method' ) ); |
| await user.click( getByText( 'Enable Payment Method' ) ); |
| expect( getAllByText( mockMethod.inactiveContent )[ 0 ] ).toBeVisible(); |
| } ); |
|
|
| it( 'renders the second payment method label as selected if the first is disabled', async () => { |
| const { getByText, getAllByText, findByLabelText } = render( <MyCheckout /> ); |
| const user = userEvent.setup(); |
| await user.click( getAllByText( 'Continue' )[ 0 ] ); |
| await user.click( getByText( 'Disable Payment Method' ) ); |
| const paymentMethod = await findByLabelText( mockMethod2.inactiveContent ); |
| expect( paymentMethod ).toBeChecked(); |
| } ); |
|
|
| it( 'renders the payment method activeContent', () => { |
| const { getByTestId } = render( <MyCheckout /> ); |
| const activeComponent = getByTestId( 'mock-payment-form' ); |
| expect( activeComponent ).toHaveTextContent( 'Cardholder Name' ); |
| } ); |
|
|
| it( 'renders the review step', () => { |
| const { getAllByText } = render( <MyCheckout /> ); |
| expect( getAllByText( items[ 0 ].label ) ).toHaveLength( 2 ); |
| expect( getAllByText( items[ 0 ].amount ) ).toHaveLength( 1 ); |
| expect( getAllByText( items[ 1 ].label ) ).toHaveLength( 2 ); |
| expect( getAllByText( items[ 1 ].amount ) ).toHaveLength( 1 ); |
| } ); |
|
|
| it( 'renders the payment method submitButton', () => { |
| const { getByText } = render( <MyCheckout /> ); |
| expect( getByText( 'Pay Please' ) ).toBeTruthy(); |
| } ); |
| } ); |
|
|
| describe( 'before clicking a button', function () { |
| let container; |
|
|
| beforeEach( () => { |
| const mockMethod = createMockMethod(); |
| const { items } = createMockItems(); |
| const MyCheckout = () => ( |
| <CheckoutProvider |
| paymentMethods={ [ mockMethod ] } |
| paymentProcessors={ getMockPaymentProcessors() } |
| selectFirstAvailablePaymentMethod |
| > |
| <DefaultCheckoutSteps items={ items } /> |
| </CheckoutProvider> |
| ); |
| const renderResult = render( <MyCheckout /> ); |
| container = renderResult.container; |
| } ); |
|
|
| it( 'renders steps', () => { |
| const activeSteps = container.querySelectorAll( '.checkout-step' ); |
| expect( activeSteps ).toHaveLength( 2 ); |
| } ); |
|
|
| it( 'makes the review step active', () => { |
| const activeSteps = container.querySelectorAll( '.checkout-step.is-active' ); |
| expect( activeSteps ).toHaveLength( 1 ); |
| expect( activeSteps[ 0 ] ).toHaveTextContent( 'Review your order' ); |
| } ); |
|
|
| it( 'makes the payment method step invisible', () => { |
| const firstStep = container.querySelector( '.checkout__payment-method-step' ); |
| const firstStepContent = firstStep.querySelector( '.checkout-steps__step-content' ); |
| expect( firstStepContent ).toHaveStyle( 'display: none' ); |
| } ); |
|
|
| it( 'makes the review step visible', () => { |
| const reviewStep = container.querySelector( '.checkout__review-order-step' ); |
| expect( reviewStep ).toHaveTextContent( 'Review your order' ); |
| const reviewStepContent = reviewStep.querySelector( '.checkout-steps__step-content' ); |
| expect( reviewStepContent ).toHaveStyle( 'display: block' ); |
| } ); |
| } ); |
|
|
| describe( 'when clicking continue from the first step', function () { |
| let container; |
|
|
| beforeEach( async () => { |
| const mockMethod = createMockMethod(); |
| const { items } = createMockItems(); |
| const MyCheckout = () => ( |
| <CheckoutProvider |
| paymentMethods={ [ mockMethod ] } |
| paymentProcessors={ getMockPaymentProcessors() } |
| selectFirstAvailablePaymentMethod |
| > |
| <DefaultCheckoutSteps items={ items } /> |
| </CheckoutProvider> |
| ); |
| const renderResult = render( <MyCheckout /> ); |
| container = renderResult.container; |
| const firstStepContinue = renderResult.getAllByText( 'Continue' )[ 0 ]; |
| const user = userEvent.setup(); |
| await user.click( firstStepContinue ); |
| } ); |
|
|
| it( 'makes the first step invisible', async () => { |
| const firstStep = container.querySelector( '.checkout__review-order-step' ); |
| const firstStepContent = firstStep.querySelector( '.checkout-steps__step-content' ); |
| await waitFor( () => { |
| expect( firstStepContent ).toHaveStyle( 'display: none' ); |
| } ); |
| } ); |
|
|
| it( 'makes the next step visible', async () => { |
| const reviewStep = container.querySelector( '.checkout__payment-method-step' ); |
| const reviewStepContent = reviewStep.querySelector( '.checkout-steps__step-content' ); |
| await waitFor( () => { |
| expect( reviewStepContent ).toHaveStyle( 'display: block' ); |
| } ); |
| } ); |
| } ); |
| } ); |
|
|
| describe( 'with custom steps', function () { |
| let MyCheckout; |
| const mockMethod = createMockMethod(); |
| const steps = createMockStepObjects(); |
| let validateForm; |
|
|
| beforeEach( () => { |
| MyCheckout = ( props ) => { |
| const [ paymentData, setPaymentData ] = useState( {} ); |
| const { stepObjectsWithStepNumber, stepObjectsWithoutStepNumber } = |
| createStepsFromStepObjects( props.steps || steps ); |
| const createStepFromStepObject = createStepObjectConverter( paymentData ); |
| return ( |
| <myContext.Provider value={ [ paymentData, setPaymentData ] }> |
| <CheckoutProvider |
| paymentMethods={ [ mockMethod ] } |
| paymentProcessors={ getMockPaymentProcessors() } |
| selectFirstAvailablePaymentMethod |
| > |
| <CheckoutStepGroup> |
| { stepObjectsWithoutStepNumber.map( createStepFromStepObject ) } |
| { stepObjectsWithStepNumber.map( createStepFromStepObject ) } |
| <CheckoutFormSubmit validateForm={ validateForm } /> |
| </CheckoutStepGroup> |
| </CheckoutProvider> |
| </myContext.Provider> |
| ); |
| }; |
| } ); |
|
|
| it( 'renders the step className', () => { |
| const { container } = render( <MyCheckout /> ); |
| expect( container.querySelector( '.' + steps[ 0 ].className ) ).toBeTruthy(); |
| expect( container.querySelector( '.' + steps[ 1 ].className ) ).toBeTruthy(); |
| expect( container.querySelector( '.' + steps[ 2 ].className ) ).toBeTruthy(); |
| expect( container.querySelector( '.' + steps[ 3 ].className ) ).toBeTruthy(); |
| } ); |
|
|
| it( 'renders the step titleContent', () => { |
| const { getByText } = render( <MyCheckout /> ); |
| expect( getByText( 'Custom Step - Summary Title' ) ).toBeInTheDocument(); |
| expect( getByText( 'Custom Step - Contact Title' ) ).toBeInTheDocument(); |
| expect( getByText( 'Custom Step - Review Title' ) ).toBeInTheDocument(); |
| expect( getByText( 'Custom Step - Incomplete Title' ) ).toBeInTheDocument(); |
| } ); |
|
|
| it( 'renders the step activeStepContent always', () => { |
| const { getByText } = render( <MyCheckout /> ); |
| expect( getByText( 'Custom Step - Summary Active' ) ).toBeInTheDocument(); |
| expect( getByText( 'Custom Step - Contact Active' ) ).toBeInTheDocument(); |
| expect( getByText( 'Custom Step - Review Active' ) ).toBeInTheDocument(); |
| expect( getByText( 'Custom Step - Incomplete Active' ) ).toBeInTheDocument(); |
| } ); |
|
|
| it( 'renders the activeStepContent as visible when active', () => { |
| const { container } = render( <MyCheckout /> ); |
| const step = container.querySelector( '.' + steps[ 1 ].className ); |
| const content = step.querySelector( '.checkout-steps__step-content' ); |
| expect( content ).toHaveStyle( 'display: block' ); |
| } ); |
|
|
| it( 'renders the activeStepContent as invisible when inactive', () => { |
| const { container } = render( <MyCheckout /> ); |
| let step = container.querySelector( '.' + steps[ 0 ].className ); |
| let content = step.querySelector( '.checkout-steps__step-content' ); |
| expect( content ).toHaveStyle( 'display: none' ); |
| step = container.querySelector( '.' + steps[ 2 ].className ); |
| content = step.querySelector( '.checkout-steps__step-content' ); |
| expect( content ).toHaveStyle( 'display: none' ); |
| } ); |
|
|
| it( 'renders the step completeStepContent immediately for complete ContactStepBody', () => { |
| const { getByText, queryByText } = render( <MyCheckout /> ); |
| expect( getByText( 'Custom Step - Summary Complete' ) ).toBeInTheDocument(); |
| expect( queryByText( 'Custom Step - Contact Complete' ) ).not.toBeInTheDocument(); |
| expect( queryByText( 'Custom Step - Review Complete' ) ).not.toBeInTheDocument(); |
| expect( queryByText( 'Custom Step - Incomplete Complete' ) ).not.toBeInTheDocument(); |
| } ); |
|
|
| it( 'renders the completeStepContent as visible when inactive and complete', () => { |
| const { container } = render( <MyCheckout /> ); |
| let step = container.querySelector( '.' + steps[ 0 ].className ); |
| let content = step.querySelector( '.checkout-steps__step-complete-content' ); |
| expect( content ).toHaveStyle( 'display: block' ); |
| step = container.querySelector( '.' + steps[ 2 ].className ); |
| content = step.querySelector( '.checkout-steps__step-complete-content' ); |
| expect( content ).toBeNull; |
| step = container.querySelector( '.' + steps[ 3 ].className ); |
| content = step.querySelector( '.checkout-steps__step-complete-content' ); |
| expect( content ).toBeNull; |
| } ); |
|
|
| it( 'does not render the completeStepContent when active', () => { |
| const { container } = render( <MyCheckout /> ); |
| const step = container.querySelector( '.' + steps[ 1 ].className ); |
| const content = step.querySelector( '.checkout-steps__step-complete-content' ); |
| expect( content ).toBeNull; |
| } ); |
|
|
| it( 'renders the continue button for the active step', () => { |
| const { container } = render( <MyCheckout /> ); |
| const step = container.querySelector( '.' + steps[ 1 ].className ); |
| expect( getByTextInNode( step, 'Continue' ) ).toBeInTheDocument(); |
| } ); |
|
|
| it( 'does not render the continue button for a step without a number', () => { |
| const { container } = render( <MyCheckout /> ); |
| const step = container.querySelector( '.' + steps[ 0 ].className ); |
| expect( queryByTextInNode( step, 'Continue' ) ).not.toBeInTheDocument(); |
| } ); |
|
|
| it( 'does not render the continue button for an inactive step', () => { |
| const { container } = render( <MyCheckout /> ); |
| const step = container.querySelector( '.' + steps[ 2 ].className ); |
| expect( queryByTextInNode( step, 'Continue' ) ).not.toBeInTheDocument(); |
| } ); |
|
|
| it( 'renders the continue button enabled if the step is active and incomplete', () => { |
| const { container } = render( |
| <MyCheckout steps={ [ steps[ 0 ], steps[ 4 ], steps[ 1 ] ] } /> |
| ); |
| const step = container.querySelector( '.' + steps[ 4 ].className ); |
| expect( getByTextInNode( step, 'Continue' ) ).not.toBeDisabled(); |
| } ); |
|
|
| it( 'does not change steps if the continue button is clicked when the step is active and incomplete', async () => { |
| const incompleteStep = { |
| ...steps[ 0 ], |
| hasStepNumber: true, |
| isCompleteCallback: () => false, |
| }; |
| const { container, getAllByText } = render( |
| <MyCheckout steps={ [ incompleteStep, steps[ 4 ], steps[ 1 ] ] } /> |
| ); |
| const firstStepContinue = getAllByText( 'Continue' )[ 0 ]; |
| const firstStep = container.querySelector( '.' + steps[ 0 ].className ); |
| const firstStepContent = firstStep.querySelector( '.checkout-steps__step-content' ); |
| expect( firstStepContent ).toHaveStyle( 'display: block' ); |
| const user = userEvent.setup(); |
| await user.click( firstStepContinue ); |
| expect( firstStepContent ).toHaveStyle( 'display: block' ); |
| } ); |
|
|
| it( 'does change steps if the continue button is clicked when the step is active and complete', async () => { |
| const completeStep = { ...steps[ 0 ], hasStepNumber: true, isCompleteCallback: () => true }; |
| const { container, getAllByText } = render( |
| <MyCheckout steps={ [ completeStep, steps[ 4 ], steps[ 1 ] ] } /> |
| ); |
| const firstStepContinue = getAllByText( 'Continue' )[ 0 ]; |
| const firstStep = container.querySelector( '.custom-summary-step-class' ); |
| const firstStepContent = firstStep.querySelector( '.checkout-steps__step-content' ); |
| expect( firstStepContent ).toHaveStyle( 'display: block' ); |
| const user = userEvent.setup(); |
| await user.click( firstStepContinue ); |
| await waitFor( () => { |
| expect( firstStepContent ).toHaveStyle( 'display: none' ); |
| } ); |
| } ); |
|
|
| it( 'disables the continue button while isCompleteCallback resolves a Promise', async () => { |
| const stepWithAsyncIsComplete = { |
| ...steps[ 1 ], |
| isCompleteCallback: () => new Promise( () => {} ), |
| }; |
| const { getAllByText } = render( |
| <MyCheckout steps={ [ stepWithAsyncIsComplete, steps[ 4 ], steps[ 2 ] ] } /> |
| ); |
| const firstStepContinue = getAllByText( 'Continue' )[ 0 ]; |
| expect( firstStepContinue ).not.toBeDisabled(); |
| const user = userEvent.setup(); |
| await user.click( firstStepContinue ); |
| expect( firstStepContinue ).toBeDisabled(); |
| } ); |
|
|
| it( 'does change steps if the continue button is clicked and the step becomes complete after a Promise resolves', async () => { |
| const stepWithAsyncIsComplete = { |
| ...steps[ 1 ], |
| isCompleteCallback: () => Promise.resolve( true ), |
| }; |
| const { container, getAllByText } = render( |
| <MyCheckout steps={ [ stepWithAsyncIsComplete, steps[ 4 ], steps[ 2 ] ] } /> |
| ); |
| const firstStepContinue = getAllByText( 'Continue' )[ 0 ]; |
| const firstStep = container.querySelector( '.' + steps[ 1 ].className ); |
| const firstStepContent = firstStep.querySelector( '.checkout-steps__step-content' ); |
| expect( firstStepContent ).toHaveStyle( 'display: block' ); |
| const user = userEvent.setup(); |
| await user.click( firstStepContinue ); |
| await waitFor( () => { |
| expect( firstStepContent ).toHaveStyle( 'display: none' ); |
| } ); |
| } ); |
|
|
| it( 'changes steps if useMakeStepActive is used', async () => { |
| function ManualStepChangeButton( { stepId } ) { |
| const setActiveStep = useMakeStepActive(); |
| return <button onClick={ () => setActiveStep( stepId ) }>Change step</button>; |
| } |
| const stepOne = { |
| ...steps[ 1 ], |
| id: 'step-will-pass', |
| className: 'step-will-pass', |
| }; |
| const stepTwo = { |
| ...steps[ 1 ], |
| activeStepContent: ( |
| <div> |
| <span>Custom Step - Summary Active</span> |
| <ManualStepChangeButton stepId={ steps[ 1 ].id } /> |
| </div> |
| ), |
| }; |
| const { container, getAllByText } = render( <MyCheckout steps={ [ stepOne, stepTwo ] } /> ); |
| const manualContinue = getAllByText( 'Change step' )[ 0 ]; |
| const firstStep = container.querySelector( '.' + stepOne.className ); |
| const secondStep = container.querySelector( '.' + stepTwo.className ); |
| const firstStepContent = firstStep.querySelector( '.checkout-steps__step-content' ); |
| const secondStepContent = secondStep.querySelector( '.checkout-steps__step-content' ); |
| expect( firstStepContent ).toHaveStyle( 'display: block' ); |
| expect( secondStepContent ).toHaveStyle( 'display: none' ); |
| const user = userEvent.setup(); |
| await user.click( manualContinue ); |
| await waitFor( () => { |
| expect( firstStepContent ).toHaveStyle( 'display: none' ); |
| } ); |
| expect( secondStepContent ).toHaveStyle( 'display: block' ); |
| } ); |
|
|
| it( 'changes steps to the first incomplete step if useMakeStepActive is used', async () => { |
| function ManualStepChangeButton( { stepId } ) { |
| const setActiveStep = useMakeStepActive(); |
| return <button onClick={ () => setActiveStep( stepId ) }>Change step</button>; |
| } |
| const stepOne = { |
| ...steps[ 1 ], |
| id: 'step-will-fail', |
| className: 'step-will-fail', |
| isCompleteCallback: () => Promise.resolve( false ), |
| }; |
| const stepTwo = { |
| ...steps[ 1 ], |
| activeStepContent: ( |
| <div> |
| <span>Custom Step - Summary Active</span> |
| <ManualStepChangeButton stepId={ steps[ 1 ].id } /> |
| </div> |
| ), |
| }; |
| const { container, getAllByText } = render( <MyCheckout steps={ [ stepOne, stepTwo ] } /> ); |
| const manualContinue = getAllByText( 'Change step' )[ 0 ]; |
| const firstStep = container.querySelector( '.' + stepOne.className ); |
| const secondStep = container.querySelector( '.' + stepTwo.className ); |
| const firstStepContent = firstStep.querySelector( '.checkout-steps__step-content' ); |
| const secondStepContent = secondStep.querySelector( '.checkout-steps__step-content' ); |
| expect( firstStepContent ).toHaveStyle( 'display: block' ); |
| expect( secondStepContent ).toHaveStyle( 'display: none' ); |
| const user = userEvent.setup(); |
| await user.click( manualContinue ); |
| expect( firstStepContent ).toHaveStyle( 'display: block' ); |
| expect( secondStepContent ).toHaveStyle( 'display: none' ); |
| } ); |
|
|
| it( 'does change steps if useSetStepComplete is used and the step becomes complete after a Promise resolves', async () => { |
| function ManualStepCompleteButton( { stepId } ) { |
| const setStepComplete = useSetStepComplete(); |
| return <button onClick={ () => setStepComplete( stepId ) }>Complete manually</button>; |
| } |
| const stepWillPass = { |
| ...steps[ 1 ], |
| id: 'step-will-pass', |
| className: 'step-will-pass', |
| isCompleteCallback: () => Promise.resolve( true ), |
| }; |
| const stepWithAsyncIsComplete = { |
| ...steps[ 1 ], |
| isCompleteCallback: () => Promise.resolve( true ), |
| activeStepContent: ( |
| <div> |
| <span>Custom Step - Summary Active</span> |
| <ManualStepCompleteButton stepId={ steps[ 1 ].id } /> |
| </div> |
| ), |
| }; |
| const { container, getAllByText } = render( |
| <MyCheckout steps={ [ stepWillPass, stepWithAsyncIsComplete, steps[ 4 ], steps[ 2 ] ] } /> |
| ); |
| const manualContinue = getAllByText( 'Complete manually' )[ 0 ]; |
| const firstStep = container.querySelector( '.' + stepWillPass.className ); |
| const secondStep = container.querySelector( '.' + stepWithAsyncIsComplete.className ); |
| const thirdStep = container.querySelector( '.' + steps[ 4 ].className ); |
| const firstStepContent = firstStep.querySelector( '.checkout-steps__step-content' ); |
| const secondStepContent = secondStep.querySelector( '.checkout-steps__step-content' ); |
| const thirdStepContent = thirdStep.querySelector( '.checkout-steps__step-content' ); |
| expect( firstStepContent ).toHaveStyle( 'display: block' ); |
| expect( secondStepContent ).toHaveStyle( 'display: none' ); |
| const user = userEvent.setup(); |
| await user.click( manualContinue ); |
| await waitFor( () => { |
| expect( firstStepContent ).toHaveStyle( 'display: none' ); |
| } ); |
| expect( secondStepContent ).toHaveStyle( 'display: none' ); |
| expect( thirdStepContent ).toHaveStyle( 'display: block' ); |
| } ); |
|
|
| it( 'does not change steps if useSetStepComplete is used and the previous step remains incomplete', async () => { |
| function ManualStepCompleteButton( { stepId } ) { |
| const setStepComplete = useSetStepComplete(); |
| return <button onClick={ () => setStepComplete( stepId ) }>Complete manually</button>; |
| } |
| const stepWillFail = { |
| ...steps[ 1 ], |
| id: 'step-will-fail', |
| className: 'step-will-fail', |
| isCompleteCallback: () => Promise.resolve( false ), |
| }; |
| const stepWithAsyncIsComplete = { |
| ...steps[ 1 ], |
| isCompleteCallback: () => Promise.resolve( true ), |
| activeStepContent: ( |
| <div> |
| <span>Custom Step - Summary Active</span> |
| <ManualStepCompleteButton stepId={ steps[ 1 ].id } /> |
| </div> |
| ), |
| }; |
| const { container, getAllByText } = render( |
| <MyCheckout steps={ [ stepWillFail, stepWithAsyncIsComplete, steps[ 4 ], steps[ 2 ] ] } /> |
| ); |
| const manualContinue = getAllByText( 'Complete manually' )[ 0 ]; |
| const firstStep = container.querySelector( '.' + stepWillFail.className ); |
| const secondStep = container.querySelector( '.' + stepWithAsyncIsComplete.className ); |
| const firstStepContent = firstStep.querySelector( '.checkout-steps__step-content' ); |
| const secondStepContent = secondStep.querySelector( '.checkout-steps__step-content' ); |
| expect( firstStepContent ).toHaveStyle( 'display: block' ); |
| expect( secondStepContent ).toHaveStyle( 'display: none' ); |
| const user = userEvent.setup(); |
| await user.click( manualContinue ); |
| expect( firstStepContent ).toHaveStyle( 'display: block' ); |
| expect( secondStepContent ).toHaveStyle( 'display: none' ); |
| } ); |
|
|
| it( 'does not change steps if the continue button is clicked and the step remains incomplete after a Promise resolves', async () => { |
| const stepWithAsyncIsComplete = { |
| ...steps[ 1 ], |
| isCompleteCallback: () => Promise.resolve( false ), |
| }; |
| const { container, getAllByText } = render( |
| <MyCheckout steps={ [ stepWithAsyncIsComplete, steps[ 4 ], steps[ 2 ] ] } /> |
| ); |
| const firstStepContinue = getAllByText( 'Continue' )[ 0 ]; |
| const firstStep = container.querySelector( '.' + steps[ 1 ].className ); |
| const firstStepContent = firstStep.querySelector( '.checkout-steps__step-content' ); |
| expect( firstStepContent ).toHaveStyle( 'display: block' ); |
| const user = userEvent.setup(); |
| await user.click( firstStepContinue ); |
| expect( firstStepContent ).toHaveStyle( 'display: block' ); |
| } ); |
|
|
| it( 'does not change steps if useSetStepComplete is used and the step remains incomplete after a Promise resolves', async () => { |
| function ManualStepCompleteButton( { stepId } ) { |
| const setStepComplete = useSetStepComplete(); |
| return <button onClick={ () => setStepComplete( stepId ) }>Complete manually</button>; |
| } |
| const stepWithAsyncIsComplete = { |
| ...steps[ 1 ], |
| isCompleteCallback: () => Promise.resolve( false ), |
| activeStepContent: ( |
| <div> |
| <span>Custom Step - Summary Active</span> |
| <ManualStepCompleteButton stepId={ steps[ 1 ].id } /> |
| </div> |
| ), |
| }; |
| const { container, getAllByText } = render( |
| <MyCheckout steps={ [ stepWithAsyncIsComplete, steps[ 4 ], steps[ 2 ] ] } /> |
| ); |
| const manualContinue = getAllByText( 'Complete manually' )[ 0 ]; |
| const firstStep = container.querySelector( '.' + steps[ 1 ].className ); |
| const firstStepContent = firstStep.querySelector( '.checkout-steps__step-content' ); |
| expect( firstStepContent ).toHaveStyle( 'display: block' ); |
| const user = userEvent.setup(); |
| await user.click( manualContinue ); |
| expect( firstStepContent ).toHaveStyle( 'display: block' ); |
| } ); |
|
|
| it( 'renders the continue button enabled if the step is active and complete', async () => { |
| const { container, getByLabelText } = render( |
| <MyCheckout steps={ [ steps[ 0 ], steps[ 4 ], steps[ 1 ] ] } /> |
| ); |
|
|
| const user = userEvent.setup(); |
| await user.type( getByLabelText( 'User Name' ), 'Lyra' ); |
| const step = container.querySelector( '.' + steps[ 4 ].className ); |
| expect( getByTextInNode( step, 'Continue' ) ).not.toBeDisabled(); |
| } ); |
|
|
| it( 'does not render the edit button for steps without a number', () => { |
| const { container } = render( <MyCheckout /> ); |
| const step = container.querySelector( '.' + steps[ 0 ].className ); |
| expect( queryByTextInNode( step, 'Edit' ) ).not.toBeInTheDocument(); |
| } ); |
|
|
| it( 'does not render the edit button for the active step', () => { |
| const { container } = render( <MyCheckout /> ); |
| const step = container.querySelector( '.' + steps[ 1 ].className ); |
| expect( queryByTextInNode( step, 'Edit' ) ).not.toBeInTheDocument(); |
| } ); |
|
|
| it( 'does not render the edit button for editable steps with a higher index than the active step', () => { |
| const { container } = render( <MyCheckout /> ); |
| const step = container.querySelector( '.' + steps[ 2 ].className ); |
| expect( queryByTextInNode( step, 'Edit' ) ).not.toBeInTheDocument(); |
| } ); |
|
|
| it( 'renders the edit button for editable steps with a lower index than the active step', async () => { |
| const { container, getAllByText } = render( <MyCheckout /> ); |
| const firstStepContinue = getAllByText( 'Continue' )[ 0 ]; |
| const user = userEvent.setup(); |
| await user.click( firstStepContinue ); |
| const step = container.querySelector( '.' + steps[ 1 ].className ); |
| await waitFor( () => { |
| expect( getByTextInNode( step, 'Edit' ) ).toBeInTheDocument(); |
| } ); |
| } ); |
|
|
| it( 'does not render the edit button if the form status is submitting', async () => { |
| const { queryByText, getAllByText } = render( |
| <MyCheckout steps={ [ steps[ 0 ], steps[ 1 ], steps[ 2 ] ] } /> |
| ); |
| const firstStepContinue = getAllByText( 'Continue' )[ 0 ]; |
| const user = userEvent.setup(); |
| await user.click( firstStepContinue ); |
| await waitFor( () => { |
| expect( queryByText( 'Edit' ) ).toBeInTheDocument(); |
| } ); |
| const submitButton = getAllByText( 'Pay Please' )[ 0 ]; |
| await user.click( submitButton ); |
| expect( queryByText( 'Edit' ) ).not.toBeInTheDocument(); |
| } ); |
|
|
| it( 'renders the payment method submitButton', () => { |
| const { getByText } = render( <MyCheckout /> ); |
| expect( getByText( 'Pay Please' ) ).toBeTruthy(); |
| } ); |
|
|
| it( 'renders the payment method submitButton disabled if any steps are incomplete and the last step is not active', () => { |
| const { getByText } = render( |
| <MyCheckout steps={ [ steps[ 0 ], steps[ 1 ], steps[ 2 ] ] } /> |
| ); |
| expect( getByText( 'Pay Please' ) ).toBeDisabled(); |
| } ); |
|
|
| it( 'renders the payment method submitButton enabled if any steps are incomplete and the last step is active', () => { |
| const { getByText } = render( <MyCheckout steps={ [ steps[ 0 ], steps[ 3 ] ] } /> ); |
| expect( getByText( 'Pay Please' ) ).not.toBeDisabled(); |
| } ); |
|
|
| it( 'renders the payment method submitButton disabled if all steps are complete but the last step is not active', () => { |
| const { getByText } = render( |
| <MyCheckout steps={ [ steps[ 0 ], steps[ 1 ], steps[ 2 ] ] } /> |
| ); |
| expect( getByText( 'Pay Please' ) ).toBeDisabled(); |
| } ); |
|
|
| it( 'renders the payment method submitButton active if all steps are complete and the last step is active', () => { |
| const { getByText } = render( <MyCheckout steps={ [ steps[ 0 ], steps[ 1 ] ] } /> ); |
| expect( getByText( 'Pay Please' ) ).not.toBeDisabled(); |
| } ); |
|
|
| it( 'provides useIsStepComplete that changes based on isCompleteCallback', async () => { |
| const { getAllByText, getByText, getByLabelText } = render( |
| <MyCheckout steps={ [ steps[ 4 ], steps[ 1 ] ] } /> |
| ); |
| expect( getByText( 'Possibly Complete isComplete false' ) ).toBeInTheDocument(); |
| const firstStepContinue = getAllByText( 'Continue' )[ 0 ]; |
| const user = userEvent.setup(); |
| await user.click( firstStepContinue ); |
| await user.type( getByLabelText( 'User Name' ), 'Lyra' ); |
| |
| await user.click( firstStepContinue ); |
| await waitFor( () => { |
| expect( getByText( 'Possibly Complete isComplete true' ) ).toBeInTheDocument(); |
| } ); |
| } ); |
| } ); |
|
|
| describe( 'submitting the form', function () { |
| let MyCheckout; |
| const submitButtonComponent = <MockSubmitButtonSimple />; |
| const mockMethod = createMockMethod( { submitButton: submitButtonComponent } ); |
| const steps = createMockStepObjects(); |
|
|
| beforeEach( () => { |
| MyCheckout = ( props ) => { |
| const [ paymentData, setPaymentData ] = useState( {} ); |
| const { stepObjectsWithStepNumber, stepObjectsWithoutStepNumber } = |
| createStepsFromStepObjects( props.steps || steps ); |
| const createStepFromStepObject = createStepObjectConverter( paymentData ); |
| return ( |
| <myContext.Provider value={ [ paymentData, setPaymentData ] }> |
| <CheckoutProvider |
| paymentMethods={ [ mockMethod ] } |
| paymentProcessors={ { mock: props.paymentProcessor } } |
| selectFirstAvailablePaymentMethod |
| > |
| <CheckoutStepGroup> |
| { stepObjectsWithoutStepNumber.map( createStepFromStepObject ) } |
| { stepObjectsWithStepNumber.map( createStepFromStepObject ) } |
| <CheckoutFormSubmit validateForm={ props.validateForm } /> |
| </CheckoutStepGroup> |
| </CheckoutProvider> |
| </myContext.Provider> |
| ); |
| }; |
| } ); |
|
|
| it( 'does not call the payment processor function if the validateForm callback is falsy', async () => { |
| const validateForm = jest.fn(); |
| validateForm.mockResolvedValue( false ); |
| const processor = jest.fn().mockResolvedValue( makeErrorResponse( 'good' ) ); |
| render( |
| <MyCheckout |
| steps={ [ steps[ 0 ] ] } |
| validateForm={ validateForm } |
| paymentProcessor={ processor } |
| /> |
| ); |
| const submitButton = screen.getByText( 'Pay Please' ); |
|
|
| const user = userEvent.setup(); |
| await user.click( submitButton ); |
|
|
| expect( processor ).not.toHaveBeenCalled(); |
| } ); |
|
|
| it( 'calls the payment processor function if the validateForm callback is truthy', async () => { |
| const validateForm = jest.fn(); |
| validateForm.mockResolvedValue( true ); |
| const processor = jest.fn().mockResolvedValue( makeErrorResponse( 'good' ) ); |
| render( |
| <MyCheckout |
| steps={ [ steps[ 0 ] ] } |
| validateForm={ validateForm } |
| paymentProcessor={ processor } |
| /> |
| ); |
| const submitButton = screen.getByText( 'Pay Please' ); |
|
|
| const user = userEvent.setup(); |
| await user.click( submitButton ); |
|
|
| expect( processor ).toHaveBeenCalled(); |
| } ); |
|
|
| it( 'calls the payment processor function if the validateForm callback undefined', async () => { |
| const processor = jest.fn().mockResolvedValue( makeErrorResponse( 'good' ) ); |
| render( <MyCheckout steps={ [ steps[ 0 ] ] } paymentProcessor={ processor } /> ); |
| const submitButton = screen.getByText( 'Pay Please' ); |
|
|
| const user = userEvent.setup(); |
| await user.click( submitButton ); |
|
|
| expect( processor ).toHaveBeenCalled(); |
| } ); |
| } ); |
| } ); |
|
|
| function createMockMethodFactory() { |
| let mockMethodIdCounter = 0; |
| return function ( { |
| submitButton = <MockSubmitButton content="Pay Please" />, |
| activeContent = <MockPaymentForm />, |
| } = {} ) { |
| mockMethodIdCounter = mockMethodIdCounter + 1; |
| const title = `Mock Payment Method ${ mockMethodIdCounter }`; |
| return { |
| id: 'mock' + mockMethodIdCounter, |
| paymentProcessorId: 'mock', |
| label: <span data-testid="mock-label">{ title }</span>, |
| activeContent, |
| submitButton, |
| inactiveContent: title, |
| getAriaLabel: () => title, |
| }; |
| }; |
| } |
|
|
| function MockSubmitButton( { disabled, content }: { disabled?: boolean; content: string } ) { |
| const { setTransactionComplete, setTransactionPending } = useTransactionStatus(); |
| const process = usePaymentProcessor( 'mock' ); |
| const onClick = () => { |
| setTransactionPending(); |
| process( true ).then( ( result ) => setTransactionComplete( result ) ); |
| }; |
| return ( |
| <button disabled={ disabled } onClick={ onClick }> |
| { content } |
| </button> |
| ); |
| } |
|
|
| function MockPaymentForm( { summary } ) { |
| const [ cardholderName, changeCardholderName ] = useState( '' ); |
| return ( |
| <div data-testid="mock-payment-form"> |
| <label> |
| { summary ? 'Name Summary' : 'Cardholder Name' } |
| <input |
| name="cardholderName" |
| value={ cardholderName } |
| onChange={ ( event ) => changeCardholderName( event.target.value ) } |
| /> |
| </label> |
| </div> |
| ); |
| } |
|
|
| function MockSubmitButtonSimple( { disabled, onClick }: { disabled?: boolean; onClick: any } ) { |
| return ( |
| <button disabled={ disabled } onClick={ onClick }> |
| Pay Please |
| </button> |
| ); |
| } |
|
|
| interface LineItem { |
| type: string; |
| id: string; |
| label: string; |
| amount: number; |
| } |
|
|
| function createMockItems(): { items: LineItem[]; total: LineItem } { |
| const items = [ |
| { |
| label: 'Illudium Q-36 Explosive Space Modulator', |
| id: 'space-modulator', |
| type: 'widget', |
| amount: 5500, |
| }, |
| { |
| label: 'Air Jordans', |
| id: 'sneakers', |
| type: 'apparel', |
| amount: 12000, |
| }, |
| ]; |
| const total = { |
| label: 'Total', |
| id: 'total', |
| type: 'total', |
| amount: 17500, |
| }; |
| return { items, total }; |
| } |
|
|
| function createStepsFromStepObjects( stepObjects ) { |
| const stepObjectsWithoutStepNumber = stepObjects.filter( |
| ( stepObject ) => ! stepObject.hasStepNumber |
| ); |
| const stepObjectsWithStepNumber = stepObjects.filter( |
| ( stepObject ) => stepObject.hasStepNumber |
| ); |
| return { |
| stepObjectsWithStepNumber, |
| stepObjectsWithoutStepNumber, |
| }; |
| } |
|
|
| function createStepObjectConverter( paymentData ) { |
| return function createStepFromStepObject( stepObject ) { |
| if ( stepObject.hasStepNumber ) { |
| return ( |
| <CheckoutStep |
| activeStepContent={ stepObject.activeStepContent } |
| completeStepContent={ stepObject.completeStepContent } |
| titleContent={ stepObject.titleContent } |
| stepId={ stepObject.id } |
| key={ stepObject.id } |
| isCompleteCallback={ () => stepObject.isCompleteCallback( { paymentData } ) } |
| editButtonAriaLabel={ stepObject.getEditButtonAriaLabel() } |
| nextStepButtonAriaLabel={ stepObject.getNextStepButtonAriaLabel() } |
| className={ stepObject.className } |
| /> |
| ); |
| } |
| return ( |
| <CheckoutStepBody |
| errorMessage="error" |
| editButtonAriaLabel={ stepObject.getEditButtonAriaLabel() } |
| nextStepButtonAriaLabel={ stepObject.getNextStepButtonAriaLabel() } |
| isStepActive={ false } |
| isStepComplete |
| stepNumber={ 1 } |
| stepId={ stepObject.id } |
| key={ stepObject.id } |
| activeStepContent={ stepObject.activeStepContent } |
| completeStepContent={ stepObject.completeStepContent } |
| titleContent={ stepObject.titleContent } |
| className={ stepObject.className } |
| /> |
| ); |
| }; |
| } |
|
|
| function createMockStepObjects() { |
| return [ |
| { |
| id: 'custom-summary-step', |
| className: 'custom-summary-step-class', |
| hasStepNumber: false, |
| titleContent: <span>Custom Step - Summary Title</span>, |
| activeStepContent: <span>Custom Step - Summary Active</span>, |
| completeStepContent: <span>Custom Step - Summary Complete</span>, |
| isCompleteCallback: () => true, |
| getEditButtonAriaLabel: () => 'Custom Step - Summary edit button label', |
| getNextStepButtonAriaLabel: () => 'Custom Step - Summary next button label', |
| }, |
| { |
| id: 'custom-contact-step', |
| className: 'custom-contact-step-class', |
| hasStepNumber: true, |
| titleContent: <span>Custom Step - Contact Title</span>, |
| activeStepContent: <span>Custom Step - Contact Active</span>, |
| completeStepContent: <span>Custom Step - Contact Complete</span>, |
| isCompleteCallback: () => true, |
| getEditButtonAriaLabel: () => 'Custom Step - Contact edit button label', |
| getNextStepButtonAriaLabel: () => 'Custom Step - Contact next button label', |
| }, |
| { |
| id: 'custom-review-step', |
| className: 'custom-review-step-class', |
| hasStepNumber: true, |
| titleContent: <span>Custom Step - Review Title</span>, |
| activeStepContent: <span>Custom Step - Review Active</span>, |
| completeStepContent: <span>Custom Step - Review Complete</span>, |
| isCompleteCallback: () => true, |
| getEditButtonAriaLabel: () => 'Custom Step - Review edit button label', |
| getNextStepButtonAriaLabel: () => 'Custom Step - Review next button label', |
| }, |
| { |
| id: 'custom-incomplete-step', |
| className: 'custom-incomplete-step-class', |
| hasStepNumber: true, |
| titleContent: <span>Custom Step - Incomplete Title</span>, |
| activeStepContent: <span>Custom Step - Incomplete Active</span>, |
| completeStepContent: <span>Custom Step - Incomplete Complete</span>, |
| isCompleteCallback: () => false, |
| getEditButtonAriaLabel: () => 'Custom Step - Incomplete edit button label', |
| getNextStepButtonAriaLabel: () => 'Custom Step - Incomplete next button label', |
| }, |
| { |
| id: 'custom-possibly-complete-step', |
| className: 'custom-possibly-complete-step-class', |
| hasStepNumber: true, |
| titleContent: <PossiblyCompleteTitle />, |
| activeStepContent: <StepWithEditableField />, |
| completeStepContent: <span>Custom Step - Possibly Complete Complete</span>, |
| isCompleteCallback: ( { paymentData } ) => { |
| return paymentData.userName && paymentData.userName.length > 0 ? true : false; |
| }, |
| getEditButtonAriaLabel: () => 'Custom Step - Incomplete edit button label', |
| getNextStepButtonAriaLabel: () => 'Custom Step - Incomplete next button label', |
| }, |
| { |
| id: 'custom-uneditable-step', |
| className: 'custom-uneditable-step-class', |
| hasStepNumber: true, |
| titleContent: <span>Custom Step - Uneditable Title</span>, |
| activeStepContent: <span>Custom Step - Uneditable Active</span>, |
| completeStepContent: <span>Custom Step - Uneditable Complete</span>, |
| isCompleteCallback: () => true, |
| getEditButtonAriaLabel: () => 'Custom Step - Uneditable edit button label', |
| getNextStepButtonAriaLabel: () => 'Custom Step - Uneditable next button label', |
| }, |
| ]; |
| } |
|
|
| function PossiblyCompleteTitle() { |
| const isComplete = useIsStepComplete(); |
| const text = `Possibly Complete isComplete ${ isComplete ? 'true' : 'false' }`; |
| return ( |
| <div> |
| <span>Custom Step - Possibly Complete Title</span> |
| <span>{ text }</span> |
| </div> |
| ); |
| } |
|
|
| function StepWithEditableField() { |
| const [ paymentData, setPaymentData ] = usePaymentData(); |
| const onChange = ( event ) => { |
| setPaymentData( { userName: event.target.value } ); |
| }; |
| const value = paymentData.userName || ''; |
| return ( |
| <div> |
| <label htmlFor="username-field">User Name</label> |
| <input id="username-field" type="text" value={ value } onChange={ onChange } /> |
| </div> |
| ); |
| } |
|
|
| function getMockPaymentProcessors(): Record< string, PaymentProcessorFunction > { |
| return { |
| mock: async () => ( { type: PaymentProcessorResponseType.SUCCESS, payload: true } ), |
| }; |
| } |
|
|
