979 lines
38 KiB
JavaScript
979 lines
38 KiB
JavaScript
// Components
|
|
import orderConfirmation from '@/layouts/order-confirmation/order-confirmation.vue';
|
|
|
|
// Supporting Files
|
|
import { getMountOptions } from '@/helpers/unit-test-helper.js';
|
|
import { useMainStore } from '@/store/index.js';
|
|
import settleAllPromises from '@/helpers/layout-helper.js';
|
|
import { fetchCmsContentForPage, getStringWithCustomValues, processIfStatements } from '@/helpers/cms-content-helper';
|
|
import { mount } from '@vue/test-utils';
|
|
import { createTestingPinia } from '@pinia/testing';
|
|
import { nextTick } from 'vue';
|
|
import coverageStatuses from '@/constants/coverage-statuses';
|
|
import coverageType from '@/constants/coverage-type';
|
|
import { deepClone } from '@/helpers/object-helper';
|
|
import { AppointmentTypeStrings } from '@/constants/schedule-constants';
|
|
import { paymentMethods } from '@/constants/payment-method-constants';
|
|
|
|
jest.mock('@/helpers/layout-helper.js', () => jest.fn());
|
|
|
|
jest.mock('@/helpers/cms-content-helper', () => ({
|
|
fetchCmsContentForPage: jest.fn(),
|
|
processIfStatements: jest.fn(),
|
|
splitCopyOnCMSPlaceHolder: jest.fn(),
|
|
getStringWithCustomValues: jest.fn()
|
|
}));
|
|
|
|
const mockMixin = {
|
|
methods: {
|
|
getCmsContent: jest.fn(),
|
|
setCmsContent: jest.fn()
|
|
}
|
|
};
|
|
|
|
const footerStub = {
|
|
render: () => {},
|
|
methods: {
|
|
updateButtonText: jest.fn()
|
|
}
|
|
};
|
|
|
|
const headerStub = {
|
|
render: () => {}
|
|
};
|
|
|
|
const addToCalendarStub = {
|
|
render: () => {}
|
|
};
|
|
|
|
const initialStore = {
|
|
order: {
|
|
schedule: {
|
|
date: '2024-03-01',
|
|
startTime: '09:00',
|
|
endTime: '10:00',
|
|
jobMinMinutes: 60,
|
|
jobMaxMinutes: 90
|
|
},
|
|
serviceLocation: {
|
|
address: '123 Test Way',
|
|
address2: '#1',
|
|
city: 'Mesa',
|
|
state: 'AZ',
|
|
zipCode: '12345',
|
|
appointmentType: 'Inshop',
|
|
provider: {
|
|
address: {
|
|
streetAddress: '123 Safelite Street',
|
|
city: 'Mesa',
|
|
state: 'AZ',
|
|
zipCode: '12345'
|
|
}
|
|
}
|
|
},
|
|
insuranceCoverage: {
|
|
coverageStatus: coverageStatuses.VERIFIED,
|
|
coverageType: coverageType.Deductible
|
|
},
|
|
payment: {
|
|
isInsurance: true,
|
|
paymentMethod: paymentMethods.PAY_AT_TIME_OF_SERVICE
|
|
},
|
|
customer: {
|
|
firstName: 'Test',
|
|
lastName: 'Test',
|
|
emailAddress: 'test@email.com'
|
|
},
|
|
contactInfo: {
|
|
servicePhone: '123-456-7890'
|
|
},
|
|
damage: {
|
|
isRepair: false
|
|
},
|
|
currentDeductible: {
|
|
replace: 100,
|
|
repair: 0
|
|
}
|
|
}
|
|
};
|
|
|
|
const sessionStorage = {
|
|
schedule: {
|
|
date: '2024-03-01',
|
|
startTime: '09:00',
|
|
endTime: '10:00',
|
|
jobMinMinutes: 60,
|
|
jobMaxMinutes: 90
|
|
},
|
|
serviceLocation: {
|
|
address: '123 Test Way',
|
|
address2: '#1',
|
|
city: 'Mesa',
|
|
state: 'AZ',
|
|
zipCode: '12345',
|
|
appointmentType: 'Inshop',
|
|
provider: {
|
|
address: {
|
|
streetAddress: '123 Safelite Street',
|
|
city: 'Mesa',
|
|
state: 'AZ',
|
|
zipCode: '12345'
|
|
}
|
|
}
|
|
},
|
|
insuranceCoverage: {
|
|
coverageStatus: coverageStatuses.VERIFIED,
|
|
coverageType: coverageType.Deductible
|
|
},
|
|
payment: {
|
|
isPayInAdvance: false
|
|
},
|
|
lineItems: {
|
|
vaps: []
|
|
},
|
|
policy: {},
|
|
damage: {
|
|
isRepair: false
|
|
},
|
|
vehicle: {
|
|
year: 2000,
|
|
make: 'Honda',
|
|
model: 'Civic'
|
|
},
|
|
customer: {
|
|
firstName: 'Test',
|
|
lastName: 'Test',
|
|
emailAddress: 'test@email.com'
|
|
},
|
|
contactInfo: {
|
|
servicePhone: '123-456-7890'
|
|
},
|
|
customerPortalLoginToken: 'token',
|
|
currentDeductible: {
|
|
replace: 100,
|
|
repair: 0
|
|
}
|
|
};
|
|
|
|
function getMountedComponent(mainInitialState = {}, initialData = {}, methodToRun = () => {}, mixin = mockMixin) {
|
|
const mountOptions = getMountOptions({
|
|
router: {
|
|
navigate: jest.fn(),
|
|
navigateToExternalUrl: jest.fn()
|
|
}
|
|
});
|
|
|
|
mountOptions.global.stubs = {
|
|
siteFooter: footerStub,
|
|
siteHeader: headerStub,
|
|
addToCalendar: addToCalendarStub
|
|
};
|
|
|
|
const testingPinia = createTestingPinia({
|
|
initialState: {
|
|
main: mainInitialState
|
|
}
|
|
});
|
|
useMainStore(testingPinia);
|
|
methodToRun();
|
|
|
|
mountOptions.global.mixins[0].methods.getSettingValue = jest.fn(() => 'false');
|
|
mountOptions.global.plugins = [testingPinia];
|
|
mountOptions.mixins = [mixin];
|
|
mountOptions.data = () => (
|
|
initialData
|
|
);
|
|
|
|
const apiResponses = {
|
|
supportingItems: []
|
|
};
|
|
const apiPromise = Promise.resolve(apiResponses);
|
|
settleAllPromises.mockImplementation(() => apiPromise);
|
|
fetchCmsContentForPage.mockImplementation(() => Promise.resolve());
|
|
|
|
const wrapper = mount(orderConfirmation, mountOptions);
|
|
return { wrapper };
|
|
}
|
|
|
|
describe('OrderConfirmation.vue', () => {
|
|
afterEach(() => {
|
|
jest.resetAllMocks();
|
|
});
|
|
describe('Page pre-requisites', () => {
|
|
test('If submitted order saved to store, page pre-reqs return true', async () => {
|
|
// Arrange
|
|
const mockStoreActions = () => {
|
|
useMainStore().getSubmittedOrder = jest.fn().mockImplementation(() => sessionStorage);
|
|
};
|
|
const { wrapper } = getMountedComponent(initialStore, {}, mockStoreActions);
|
|
console.log(wrapper.vm.$refs);
|
|
|
|
// Act
|
|
const arePagePrerequisitesValid = wrapper.vm.arePagePrerequisitesValid();
|
|
await nextTick();
|
|
|
|
// Assert
|
|
expect(arePagePrerequisitesValid).toBe(true);
|
|
});
|
|
});
|
|
describe('Rendering', () => {
|
|
let wrapper;
|
|
beforeEach(() => {
|
|
const mockStoreActions = () => {
|
|
useMainStore().getSubmittedOrder = jest.fn().mockImplementation(() => sessionStorage);
|
|
};
|
|
wrapper = getMountedComponent({}, {}, mockStoreActions).wrapper;
|
|
});
|
|
test('Should render Site Header', () => {
|
|
// Act
|
|
const siteHeader = wrapper.findComponent(headerStub);
|
|
|
|
// Assert
|
|
expect(siteHeader.exists()).toBe(true);
|
|
});
|
|
test('If Advanced flow, should display Site Footer', () => {
|
|
// Arrange
|
|
const mockStoreActions = () => {
|
|
useMainStore().getSubmittedOrder = jest.fn().mockImplementation(() => sessionStorage);
|
|
};
|
|
const testStore = {
|
|
order: {
|
|
schedule: {
|
|
date: '2019-01-01',
|
|
startTime: '09:00'
|
|
},
|
|
serviceLocation: {
|
|
appointmentType: 'Inshop'
|
|
}
|
|
},
|
|
issConfig: {
|
|
successReturnURL: 'testURL'
|
|
}
|
|
};
|
|
wrapper = getMountedComponent(testStore, {}, mockStoreActions).wrapper;
|
|
|
|
// Act
|
|
const siteFooter = wrapper.findComponent({ ref: 'siteFooter' });
|
|
|
|
// Assert
|
|
expect(siteFooter.exists()).toBe(true);
|
|
});
|
|
test('If Essential flow, should not display Site Footer', () => {
|
|
// Act
|
|
const siteFooter = wrapper.findComponent({ ref: 'siteFooter' });
|
|
|
|
// Assert
|
|
expect(siteFooter.isVisible()).toBe(false);
|
|
});
|
|
});
|
|
describe('Navigation', () => {
|
|
test('If Advanced flow, forward button action navigates to carrier URL', () => {
|
|
// Arrange
|
|
window.sessionStorage.setItem('submittedOrder', JSON.stringify(sessionStorage));
|
|
const mockStoreActions = () => {
|
|
useMainStore().getSubmittedOrder = jest.fn().mockImplementation(() => sessionStorage);
|
|
};
|
|
const carrierReturnUrl = 'testURL';
|
|
const testStore = {
|
|
order: {
|
|
schedule: {
|
|
date: '2019-01-01',
|
|
startTime: '09:00'
|
|
},
|
|
serviceLocation: {
|
|
appointmentType: 'Inshop'
|
|
}
|
|
},
|
|
issConfig: {
|
|
successReturnURL: carrierReturnUrl
|
|
}
|
|
};
|
|
const { wrapper } = getMountedComponent(testStore, {}, mockStoreActions);
|
|
|
|
// Act
|
|
wrapper.vm.forwardButtonAction();
|
|
|
|
// Assert
|
|
expect(wrapper.vm.$router.navigateToExternalUrl).toHaveBeenCalledWith(carrierReturnUrl);
|
|
});
|
|
});
|
|
describe('Computed properties', () => {
|
|
describe('customValueMap', () => {
|
|
test.each([
|
|
'inShopAppointment',
|
|
'dropOffAppointment',
|
|
'vehicleYear',
|
|
'vehicleMake',
|
|
'vehicleModel',
|
|
'address',
|
|
'inShopDuration',
|
|
'email',
|
|
'CUSTOMER_PORTAL_URL',
|
|
'CUSTOMER_PORTAL_LOGIN_TOKEN'
|
|
])('contains key %p', (key) => {
|
|
// Arrange
|
|
const mockStoreActions = () => {
|
|
useMainStore().getSubmittedOrder = jest.fn().mockImplementation(() => sessionStorage);
|
|
};
|
|
const { wrapper } = getMountedComponent(initialStore, {}, mockStoreActions);
|
|
|
|
// Act
|
|
const keyExists = key in wrapper.vm.customValueMap;
|
|
|
|
// Assert
|
|
expect(keyExists).toBeTruthy();
|
|
});
|
|
test('returns expected vehicle info', () => {
|
|
// Arrange
|
|
const order = deepClone(sessionStorage);
|
|
const year = 1998;
|
|
const make = 'Toyota';
|
|
const model = 'Cruse';
|
|
order.vehicle = {
|
|
year, make, model
|
|
};
|
|
const mockStoreActions = () => {
|
|
useMainStore().getSubmittedOrder = jest.fn().mockImplementation(() => order);
|
|
};
|
|
const { wrapper } = getMountedComponent(initialStore, {}, mockStoreActions);
|
|
|
|
// Act
|
|
const actualYear = wrapper.vm.customValueMap.vehicleYear;
|
|
const actualMake = wrapper.vm.customValueMap.vehicleMake;
|
|
const actualModel = wrapper.vm.customValueMap.vehicleModel;
|
|
|
|
// Assert
|
|
expect(actualYear).toBe(year);
|
|
expect(actualMake).toBe(make);
|
|
expect(actualModel).toBe(model);
|
|
});
|
|
test('returns expected customer email', () => {
|
|
// Arrange
|
|
const order = deepClone(sessionStorage);
|
|
const emailAddress = 'email@google.com';
|
|
order.customer.emailAddress = emailAddress;
|
|
const mockStoreActions = () => {
|
|
useMainStore().getSubmittedOrder = jest.fn().mockImplementation(() => order);
|
|
};
|
|
const { wrapper } = getMountedComponent(initialStore, {}, mockStoreActions);
|
|
|
|
// Act
|
|
const actualEmail = wrapper.vm.customValueMap.email;
|
|
|
|
// Assert
|
|
expect(actualEmail).toBe(emailAddress);
|
|
});
|
|
});
|
|
describe('orderConfirmationUpdateAppointmentText', () => {
|
|
const greaterId = '>';
|
|
const lessId = '<';
|
|
test.each([
|
|
['test', 'test'],
|
|
[`te${greaterId}st`, 'te>st'],
|
|
[`${greaterId}test${greaterId}`, '>test>'],
|
|
[`te${greaterId}st ${greaterId}`, 'te>st >'],
|
|
[`${lessId} test`, '< test'],
|
|
[`t${lessId}e${lessId}st`, 't<e<st'],
|
|
[`${greaterId}t${lessId}${lessId}e st${greaterId}`, '>t<<e st>']
|
|
])('given %p returned from cms, returns %p', (rawCms, expected) => {
|
|
// Arrange
|
|
const mockStoreActions = () => {
|
|
useMainStore().getSubmittedOrder = jest.fn().mockImplementation(() => sessionStorage);
|
|
};
|
|
getStringWithCustomValues.mockReturnValue(rawCms);
|
|
const { wrapper } = getMountedComponent(initialStore, {}, mockStoreActions);
|
|
|
|
// Act
|
|
const text = wrapper.vm.orderConfirmationUpdateAppointmentText;
|
|
|
|
// Assert
|
|
expect(text).toBe(expected);
|
|
});
|
|
});
|
|
describe('appointmentTimeText', () => {
|
|
test.each([
|
|
['Your appointment is at 9 AM - 10 AM', '09:00', '10:00'],
|
|
['Your appointment is at 1 PM - 5 PM', '13:00', '17:00'],
|
|
['Your appointment is at 8:30 AM - 3 PM', '08:30', '15:00'],
|
|
['Your appointment is at 1 AM - 2 AM', '01:00', '02:00'],
|
|
['Your appointment is at 12 AM - 2 AM', '00:00', '02:00'],
|
|
['Your appointment is at 12 PM - 2 AM', '12:00', '02:00'],
|
|
['Your appointment is at 11 PM - 12 AM', '23:00', '00:00']
|
|
])('should return Mobile time in expected format "%p" when start time "%p" and end time "%p"', (expected, startTime, endTime) => {
|
|
// Arrange
|
|
const order = deepClone(sessionStorage);
|
|
order.schedule.startTime = startTime;
|
|
order.schedule.endTime = endTime;
|
|
order.serviceLocation.appointmentType = AppointmentTypeStrings.MOBILE;
|
|
const mockStoreActions = () => {
|
|
useMainStore().getSubmittedOrder = jest.fn().mockImplementation(() => order);
|
|
};
|
|
const { wrapper } = getMountedComponent({}, {}, mockStoreActions);
|
|
|
|
// Act
|
|
const testValue = wrapper.vm.appointmentTimeText;
|
|
|
|
// Assert
|
|
expect(testValue).toEqual(expected);
|
|
});
|
|
test.each([
|
|
['09:00', '10:00'],
|
|
['13:00', '17:00'],
|
|
['08:30', '15:00'],
|
|
['01:00', '02:00']
|
|
])('should return Drop off time in same format regardless of start/end time', (startTime, endTime) => {
|
|
// Arrange
|
|
const order = deepClone(sessionStorage);
|
|
order.schedule.startTime = startTime;
|
|
order.schedule.endTime = endTime;
|
|
order.serviceLocation.appointmentType = AppointmentTypeStrings.DROP_OFF;
|
|
const mockStoreActions = () => {
|
|
useMainStore().getSubmittedOrder = jest.fn().mockImplementation(() => order);
|
|
};
|
|
const { wrapper } = getMountedComponent({}, {}, mockStoreActions);
|
|
|
|
// Act
|
|
const testValue = wrapper.vm.appointmentTimeText;
|
|
|
|
// Assert
|
|
expect(testValue).toEqual('Drop off before 9:30 AM');
|
|
});
|
|
test.each([
|
|
['Your appointment is at 9:00 AM', '09:00', '10:00'],
|
|
['Your appointment is at 1:00 PM', '13:00', '17:00'],
|
|
['Your appointment is at 8:30 AM', '08:30', '15:00'],
|
|
['Your appointment is at 1:00 AM', '01:00', '02:00'],
|
|
['Your appointment is at 12:00 AM', '00:00', '02:00'],
|
|
['Your appointment is at 12:00 PM', '12:00', '02:00']
|
|
])('should return In Shop time in expected format "%p" when start time "%p"', (expected, startTime, endTime) => {
|
|
// Arrange
|
|
const order = deepClone(sessionStorage);
|
|
order.schedule.startTime = startTime;
|
|
order.schedule.endTime = endTime;
|
|
order.serviceLocation.appointmentType = AppointmentTypeStrings.IN_SHOP;
|
|
const mockStoreActions = () => {
|
|
useMainStore().getSubmittedOrder = jest.fn().mockImplementation(() => order);
|
|
};
|
|
const { wrapper } = getMountedComponent({}, {}, mockStoreActions);
|
|
|
|
// Act
|
|
const testValue = wrapper.vm.appointmentTimeText;
|
|
|
|
// Assert
|
|
expect(testValue).toEqual(expected);
|
|
});
|
|
});
|
|
describe('appointmentLocation', () => {
|
|
const order = deepClone(sessionStorage);
|
|
order.serviceLocation = {
|
|
address: '123 Service Rd.',
|
|
address2: 'Box 4',
|
|
city: 'Columbus',
|
|
state: 'OH',
|
|
zipCode: '12345',
|
|
provider: {
|
|
address: {
|
|
streetAddress: '304 provider Ln.',
|
|
city: 'pittsburg',
|
|
state: 'PA',
|
|
zipCode: '16001'
|
|
}
|
|
}
|
|
};
|
|
const expectedServiceLocation = '123 Service Rd., Box 4, Columbus, OH 12345';
|
|
const expectedShopLocation = '304 Provider Ln., Pittsburg, PA 16001';
|
|
test.each([
|
|
AppointmentTypeStrings.MOBILE,
|
|
AppointmentTypeStrings.MOBILE_NOT_ITAC_AND_NOT_NOCOMP
|
|
])('mobile location %p returns service location', (type) => {
|
|
// Arrange
|
|
order.serviceLocation.appointmentType = type;
|
|
const mockStoreActions = () => {
|
|
useMainStore().getSubmittedOrder = jest.fn().mockImplementation(() => order);
|
|
};
|
|
const { wrapper } = getMountedComponent({}, {}, mockStoreActions);
|
|
|
|
// Act
|
|
const text = wrapper.vm.appointmentLocation;
|
|
|
|
// Assert
|
|
expect(text).toBe(expectedServiceLocation);
|
|
});
|
|
test.each([
|
|
AppointmentTypeStrings.IN_SHOP,
|
|
AppointmentTypeStrings.DROP_OFF
|
|
])('%p appointment location returns shop location', (type) => {
|
|
// Arrange
|
|
order.serviceLocation.appointmentType = type;
|
|
const mockStoreActions = () => {
|
|
useMainStore().getSubmittedOrder = jest.fn().mockImplementation(() => order);
|
|
};
|
|
const { wrapper } = getMountedComponent({}, {}, mockStoreActions);
|
|
|
|
// Act
|
|
const text = wrapper.vm.appointmentLocation;
|
|
|
|
// Assert
|
|
expect(text).toBe(expectedShopLocation);
|
|
});
|
|
test.each(['turtle', undefined, null])('unknown appointment type %p returns null', (type) => {
|
|
// Arrange
|
|
order.serviceLocation.appointmentType = type;
|
|
const mockStoreActions = () => {
|
|
useMainStore().getSubmittedOrder = jest.fn().mockImplementation(() => order);
|
|
};
|
|
const { wrapper } = getMountedComponent({}, {}, mockStoreActions);
|
|
|
|
// Act
|
|
const text = wrapper.vm.appointmentLocation;
|
|
|
|
// Assert
|
|
expect(text).toBeNull();
|
|
});
|
|
});
|
|
describe('serviceLocationFullAddress', () => {
|
|
const order = deepClone(sessionStorage);
|
|
beforeEach(() => {
|
|
order.serviceLocation = {
|
|
address: '123 Service Rd.',
|
|
address2: 'Box 4',
|
|
city: 'Columbus',
|
|
state: 'OH',
|
|
zipCode: '12345',
|
|
provider: {
|
|
address: {
|
|
streetAddress: '304 provider Ln.',
|
|
city: 'pittsburg',
|
|
state: 'PA',
|
|
zipCode: '16001'
|
|
}
|
|
}
|
|
};
|
|
});
|
|
test('returns expected when all defined', () => {
|
|
const mockStoreActions = () => {
|
|
useMainStore().getSubmittedOrder = jest.fn().mockImplementation(() => order);
|
|
};
|
|
const { wrapper } = getMountedComponent({}, {}, mockStoreActions);
|
|
const expected = '123 Service Rd., Box 4, Columbus, OH 12345';
|
|
|
|
// Act
|
|
const text = wrapper.vm.serviceLocationFullAddress;
|
|
|
|
// Assert
|
|
expect(text).toBe(expected);
|
|
});
|
|
test('returns expected when address null', () => {
|
|
order.serviceLocation.address = null;
|
|
const mockStoreActions = () => {
|
|
useMainStore().getSubmittedOrder = jest.fn().mockImplementation(() => order);
|
|
};
|
|
const { wrapper } = getMountedComponent({}, {}, mockStoreActions);
|
|
const expected = ', Box 4, Columbus, OH 12345';
|
|
|
|
// Act
|
|
const text = wrapper.vm.serviceLocationFullAddress;
|
|
|
|
// Assert
|
|
expect(text).toBe(expected);
|
|
});
|
|
test('returns expected when address2 null', () => {
|
|
order.serviceLocation.address2 = null;
|
|
const mockStoreActions = () => {
|
|
useMainStore().getSubmittedOrder = jest.fn().mockImplementation(() => order);
|
|
};
|
|
const { wrapper } = getMountedComponent({}, {}, mockStoreActions);
|
|
const expected = '123 Service Rd., Columbus, OH 12345';
|
|
|
|
// Act
|
|
const text = wrapper.vm.serviceLocationFullAddress;
|
|
|
|
// Assert
|
|
expect(text).toBe(expected);
|
|
});
|
|
test('returns expected when city null', () => {
|
|
order.serviceLocation.city = null;
|
|
const mockStoreActions = () => {
|
|
useMainStore().getSubmittedOrder = jest.fn().mockImplementation(() => order);
|
|
};
|
|
const { wrapper } = getMountedComponent({}, {}, mockStoreActions);
|
|
const expected = '123 Service Rd., Box 4, , OH 12345';
|
|
|
|
// Act
|
|
const text = wrapper.vm.serviceLocationFullAddress;
|
|
|
|
// Assert
|
|
expect(text).toBe(expected);
|
|
});
|
|
test('returns expected when state null', () => {
|
|
order.serviceLocation.state = null;
|
|
const mockStoreActions = () => {
|
|
useMainStore().getSubmittedOrder = jest.fn().mockImplementation(() => order);
|
|
};
|
|
const { wrapper } = getMountedComponent({}, {}, mockStoreActions);
|
|
const expected = '123 Service Rd., Box 4, Columbus, 12345';
|
|
|
|
// Act
|
|
const text = wrapper.vm.serviceLocationFullAddress;
|
|
|
|
// Assert
|
|
expect(text).toBe(expected);
|
|
});
|
|
test('returns expected when zipCode null', () => {
|
|
order.serviceLocation.zipCode = null;
|
|
const mockStoreActions = () => {
|
|
useMainStore().getSubmittedOrder = jest.fn().mockImplementation(() => order);
|
|
};
|
|
const { wrapper } = getMountedComponent({}, {}, mockStoreActions);
|
|
const expected = '123 Service Rd., Box 4, Columbus, OH ';
|
|
|
|
// Act
|
|
const text = wrapper.vm.serviceLocationFullAddress;
|
|
|
|
// Assert
|
|
expect(text).toBe(expected);
|
|
});
|
|
test('returns expected when all null', () => {
|
|
order.serviceLocation.address = null;
|
|
order.serviceLocation.address2 = null;
|
|
order.serviceLocation.city = null;
|
|
order.serviceLocation.state = null;
|
|
order.serviceLocation.zipCode = null;
|
|
const mockStoreActions = () => {
|
|
useMainStore().getSubmittedOrder = jest.fn().mockImplementation(() => order);
|
|
};
|
|
const { wrapper } = getMountedComponent({}, {}, mockStoreActions);
|
|
const expected = ', , ';
|
|
|
|
// Act
|
|
const text = wrapper.vm.serviceLocationFullAddress;
|
|
|
|
// Assert
|
|
expect(text).toBe(expected);
|
|
});
|
|
});
|
|
describe('providerFullAddress', () => {
|
|
const order = deepClone(sessionStorage);
|
|
beforeEach(() => {
|
|
order.serviceLocation = {
|
|
address: '123 Service Rd.',
|
|
address2: 'Box 4',
|
|
city: 'Columbus',
|
|
state: 'OH',
|
|
zipCode: '12345',
|
|
provider: {
|
|
address: {
|
|
streetAddress: '304 provider Ln.',
|
|
city: 'pittsburg',
|
|
state: 'PA',
|
|
zipCode: '16001'
|
|
}
|
|
}
|
|
};
|
|
});
|
|
test('returns expected when all properties defined', () => {
|
|
const mockStoreActions = () => {
|
|
useMainStore().getSubmittedOrder = jest.fn().mockImplementation(() => order);
|
|
};
|
|
const { wrapper } = getMountedComponent({}, {}, mockStoreActions);
|
|
const expected = '304 Provider Ln., Pittsburg, PA 16001';
|
|
|
|
// Act
|
|
const text = wrapper.vm.providerFullAddress;
|
|
|
|
// Assert
|
|
expect(text).toBe(expected);
|
|
});
|
|
test('returns expected when streetAddress null', () => {
|
|
order.serviceLocation.provider.address.streetAddress = null;
|
|
const mockStoreActions = () => {
|
|
useMainStore().getSubmittedOrder = jest.fn().mockImplementation(() => order);
|
|
};
|
|
const { wrapper } = getMountedComponent({}, {}, mockStoreActions);
|
|
const expected = '';
|
|
|
|
// Act
|
|
const text = wrapper.vm.providerFullAddress;
|
|
|
|
// Assert
|
|
expect(text).toBe(expected);
|
|
});
|
|
test('returns expected when city null', () => {
|
|
order.serviceLocation.provider.address.city = null;
|
|
const mockStoreActions = () => {
|
|
useMainStore().getSubmittedOrder = jest.fn().mockImplementation(() => order);
|
|
};
|
|
const { wrapper } = getMountedComponent({}, {}, mockStoreActions);
|
|
const expected = '304 Provider Ln., , PA 16001';
|
|
|
|
// Act
|
|
const text = wrapper.vm.providerFullAddress;
|
|
|
|
// Assert
|
|
expect(text).toBe(expected);
|
|
});
|
|
test('returns expected when state null', () => {
|
|
order.serviceLocation.provider.address.state = null;
|
|
const mockStoreActions = () => {
|
|
useMainStore().getSubmittedOrder = jest.fn().mockImplementation(() => order);
|
|
};
|
|
const { wrapper } = getMountedComponent({}, {}, mockStoreActions);
|
|
const expected = '304 Provider Ln., Pittsburg, 16001';
|
|
|
|
// Act
|
|
const text = wrapper.vm.providerFullAddress;
|
|
|
|
// Assert
|
|
expect(text).toBe(expected);
|
|
});
|
|
test('returns expected when zipCode null', () => {
|
|
order.serviceLocation.provider.address.zipCode = null;
|
|
const mockStoreActions = () => {
|
|
useMainStore().getSubmittedOrder = jest.fn().mockImplementation(() => order);
|
|
};
|
|
const { wrapper } = getMountedComponent({}, {}, mockStoreActions);
|
|
const expected = '304 Provider Ln., Pittsburg, PA ';
|
|
|
|
// Act
|
|
const text = wrapper.vm.providerFullAddress;
|
|
|
|
// Assert
|
|
expect(text).toBe(expected);
|
|
});
|
|
test('returns expected when all null', () => {
|
|
order.serviceLocation.provider.address.streetAddress = null;
|
|
order.serviceLocation.provider.address.city = null;
|
|
order.serviceLocation.provider.address.state = null;
|
|
order.serviceLocation.provider.address.zipCode = null;
|
|
const mockStoreActions = () => {
|
|
useMainStore().getSubmittedOrder = jest.fn().mockImplementation(() => order);
|
|
};
|
|
const { wrapper } = getMountedComponent({}, {}, mockStoreActions);
|
|
const expected = '';
|
|
|
|
// Act
|
|
const text = wrapper.vm.providerFullAddress;
|
|
|
|
// Assert
|
|
expect(text).toBe(expected);
|
|
});
|
|
});
|
|
describe('appointmentWordingText', () => {
|
|
const mobileWording = 'Mobile wording';
|
|
const nonMobileWording = 'Non mobile wording';
|
|
const mobileWidget = 'MobileWordingWidget';
|
|
const dropOffAndInShopWidget = 'DropOffAndInShopWordingWidget';
|
|
let mixin;
|
|
beforeEach(() => {
|
|
processIfStatements.mockImplementation((content) => content);
|
|
getStringWithCustomValues.mockImplementation((content, _) => content);
|
|
mixin = {
|
|
methods: {
|
|
getCmsContent: jest.fn().mockImplementation((widget, _) => {
|
|
if (widget === mobileWidget) {
|
|
return mobileWording;
|
|
}
|
|
if (widget === dropOffAndInShopWidget) {
|
|
return nonMobileWording;
|
|
}
|
|
return '';
|
|
}),
|
|
setCmsContent: jest.fn()
|
|
}
|
|
};
|
|
});
|
|
test.each([
|
|
[AppointmentTypeStrings.MOBILE, mobileWording],
|
|
[AppointmentTypeStrings.MOBILE_NOT_ITAC_AND_NOT_NOCOMP, mobileWording],
|
|
[AppointmentTypeStrings.DROP_OFF, nonMobileWording],
|
|
[AppointmentTypeStrings.IN_SHOP, nonMobileWording],
|
|
['unknown', null],
|
|
[null, null],
|
|
[undefined, null]
|
|
])('appointment type %p returns wording %p', (type, wording) => {
|
|
// Arrange
|
|
const order = deepClone(sessionStorage);
|
|
order.serviceLocation.appointmentType = type;
|
|
const mockStoreActions = () => {
|
|
useMainStore().getSubmittedOrder = jest.fn().mockImplementation(() => order);
|
|
};
|
|
|
|
const { wrapper } = getMountedComponent({}, {}, mockStoreActions, mixin);
|
|
|
|
// Act
|
|
const testValue = wrapper.vm.appointmentWordingText;
|
|
|
|
// Assert
|
|
expect(testValue).toEqual(wording);
|
|
});
|
|
});
|
|
describe('appointmentWordingText2', () => {
|
|
const mobileWording = 'Mobile wording';
|
|
const nonMobileWording = 'Non mobile wording';
|
|
const mobileWidget = 'MobileWordingWidget';
|
|
const dropOffAndInShopWidget = 'DropOffAndInShopWordingWidget';
|
|
let mixin;
|
|
beforeEach(() => {
|
|
processIfStatements.mockImplementation((content) => content);
|
|
getStringWithCustomValues.mockImplementation((content, _) => content);
|
|
mixin = {
|
|
methods: {
|
|
getCmsContent: jest.fn().mockImplementation((widget, _) => {
|
|
if (widget === mobileWidget) {
|
|
return mobileWording;
|
|
}
|
|
if (widget === dropOffAndInShopWidget) {
|
|
return nonMobileWording;
|
|
}
|
|
return '';
|
|
}),
|
|
setCmsContent: jest.fn()
|
|
}
|
|
};
|
|
});
|
|
test.each([
|
|
[AppointmentTypeStrings.MOBILE, mobileWording],
|
|
[AppointmentTypeStrings.MOBILE_NOT_ITAC_AND_NOT_NOCOMP, mobileWording],
|
|
[AppointmentTypeStrings.DROP_OFF, nonMobileWording],
|
|
[AppointmentTypeStrings.IN_SHOP, nonMobileWording],
|
|
['unknown', null],
|
|
[null, null],
|
|
[undefined, null]
|
|
])('appointment type %p returns wording "%p"', (type, wording) => {
|
|
// Arrange
|
|
const order = deepClone(sessionStorage);
|
|
order.serviceLocation.appointmentType = type;
|
|
const mockStoreActions = () => {
|
|
useMainStore().getSubmittedOrder = jest.fn().mockImplementation(() => order);
|
|
};
|
|
const { wrapper } = getMountedComponent({}, {}, mockStoreActions, mixin);
|
|
|
|
// Act
|
|
const testValue = wrapper.vm.appointmentWordingText2;
|
|
|
|
// Assert
|
|
expect(testValue).toEqual(wording);
|
|
});
|
|
});
|
|
describe('isMobileAppointment', () => {
|
|
test.each([
|
|
[AppointmentTypeStrings.MOBILE, true],
|
|
[AppointmentTypeStrings.MOBILE_NOT_ITAC_AND_NOT_NOCOMP, true],
|
|
[AppointmentTypeStrings.IN_SHOP, false],
|
|
[AppointmentTypeStrings.DROP_OFF, false],
|
|
['other', false],
|
|
[null, false],
|
|
[undefined, false]
|
|
])('appointment type %p returns %p', (type, expected) => {
|
|
// Arrange
|
|
const order = deepClone(sessionStorage);
|
|
order.serviceLocation.appointmentType = type;
|
|
const mockStoreActions = () => {
|
|
useMainStore().getSubmittedOrder = jest.fn().mockImplementation(() => order);
|
|
};
|
|
const { wrapper } = getMountedComponent({}, {}, mockStoreActions);
|
|
|
|
// Act
|
|
const testValue = wrapper.vm.isMobileAppointment;
|
|
|
|
// Assert
|
|
expect(testValue).toBe(expected);
|
|
});
|
|
});
|
|
describe('isInShopAppointment', () => {
|
|
test.each([
|
|
[AppointmentTypeStrings.MOBILE, false],
|
|
[AppointmentTypeStrings.MOBILE_NOT_ITAC_AND_NOT_NOCOMP, false],
|
|
[AppointmentTypeStrings.IN_SHOP, true],
|
|
[AppointmentTypeStrings.DROP_OFF, false],
|
|
['other', false],
|
|
[null, false],
|
|
[undefined, false]
|
|
])('appointment type %p returns %p', (type, expected) => {
|
|
// Arrange
|
|
const order = deepClone(sessionStorage);
|
|
order.serviceLocation.appointmentType = type;
|
|
const mockStoreActions = () => {
|
|
useMainStore().getSubmittedOrder = jest.fn().mockImplementation(() => order);
|
|
};
|
|
const { wrapper } = getMountedComponent({}, {}, mockStoreActions);
|
|
|
|
// Act
|
|
const testValue = wrapper.vm.isInShopAppointment;
|
|
|
|
// Assert
|
|
expect(testValue).toBe(expected);
|
|
});
|
|
});
|
|
describe('isDropOffAppointment', () => {
|
|
test.each([
|
|
[AppointmentTypeStrings.MOBILE, false],
|
|
[AppointmentTypeStrings.MOBILE_NOT_ITAC_AND_NOT_NOCOMP, false],
|
|
[AppointmentTypeStrings.IN_SHOP, false],
|
|
[AppointmentTypeStrings.DROP_OFF, true],
|
|
['other', false],
|
|
[null, false],
|
|
[undefined, false]
|
|
])('appointment type %p returns %p', (type, expected) => {
|
|
// Arrange
|
|
const order = deepClone(sessionStorage);
|
|
order.serviceLocation.appointmentType = type;
|
|
const mockStoreActions = () => {
|
|
useMainStore().getSubmittedOrder = jest.fn().mockImplementation(() => order);
|
|
};
|
|
const { wrapper } = getMountedComponent({}, {}, mockStoreActions);
|
|
|
|
// Act
|
|
const testValue = wrapper.vm.isDropOffAppointment;
|
|
|
|
// Assert
|
|
expect(testValue).toBe(expected);
|
|
});
|
|
});
|
|
describe('showCart', () => {
|
|
test.each([
|
|
[true, true, 100],
|
|
[true, false, 100],
|
|
[false, true, 0],
|
|
[false, true, null]
|
|
])('showCart is %p when is PIA is %p and settledTenderAmount is %p', (expected, isPia, settledTenderAmount) => {
|
|
// Arrange
|
|
const order = deepClone(sessionStorage);
|
|
order.payment.isPayInAdvance = isPia;
|
|
order.settledTenderAmount = settledTenderAmount;
|
|
const mockStoreActions = () => {
|
|
useMainStore().getSubmittedOrder = jest.fn().mockImplementation(() => order);
|
|
};
|
|
const { wrapper } = getMountedComponent({}, {}, mockStoreActions);
|
|
|
|
// Act
|
|
const testValue = wrapper.vm.showCart;
|
|
|
|
// Assert
|
|
expect(testValue).toBe(expected);
|
|
});
|
|
});
|
|
});
|
|
describe('Methods', () => {
|
|
describe('formatDate', () => {
|
|
test.each([
|
|
['Wednesday, April 22, 2020', '2020-04-22'],
|
|
['Thursday, February 1, 2018', '2018-02-01'],
|
|
['Wednesday, December 30, 2026', '2026-12-30']
|
|
])('returns %p given %p', (expected, date) => {
|
|
// Arrange
|
|
const order = deepClone(sessionStorage);
|
|
const mockStoreActions = () => {
|
|
useMainStore().getSubmittedOrder = jest.fn().mockImplementation(() => order);
|
|
};
|
|
const { wrapper } = getMountedComponent({}, {}, mockStoreActions);
|
|
|
|
// Act
|
|
const result = wrapper.vm.formatDate(date);
|
|
|
|
// Assert
|
|
expect(result).toBe(expected);
|
|
});
|
|
});
|
|
});
|
|
});
|