1525 lines
56 KiB
JavaScript
1525 lines
56 KiB
JavaScript
import { shallowMount } from '@vue/test-utils';
|
|
import { createTestingPinia } from '@pinia/testing';
|
|
import cartDropdown from '@/iss-components/cart-dropdown/cart-dropdown.vue';
|
|
|
|
// Supporting Files
|
|
import { getMountOptions } from '@/helpers/unit-test-helper.js';
|
|
import { useMainStore, getDefaultState } from '@/store';
|
|
import coverageStatuses from '@/constants/coverage-statuses';
|
|
import { formatAmountInDollars } from '@/helpers/text-helper.js';
|
|
import partTypeStrings from '@/constants/part-type-strings';
|
|
import partNumberStrings from '@/constants/part-number-strings';
|
|
import { getHighestFullySatisfiedTier, getPackageContents } from '@/helpers/service-package-helper.js';
|
|
import getPriceOfLineItems from '@/helpers/price-calculator.js';
|
|
|
|
const VERIFYING_COVERAGE = 'Verifying coverage';
|
|
|
|
jest.mock('@/helpers/text-helper', () => ({
|
|
formatAmountInDollars: jest.fn()
|
|
}));
|
|
jest.mock('@/helpers/price-calculator.js', () => jest.fn());
|
|
|
|
jest.mock('@/helpers/service-package-helper', () => ({
|
|
getHighestFullySatisfiedTier: jest.fn(),
|
|
getPackageContents: jest.fn()
|
|
}));
|
|
|
|
function getMountedComponent(mainInitialState = {}, initialData = {}, propsData = {}) {
|
|
const mountOptions = getMountOptions({
|
|
router: {
|
|
navigate: jest.fn()
|
|
}
|
|
});
|
|
|
|
const testingPinia = createTestingPinia({
|
|
initialState: {
|
|
main: mainInitialState
|
|
}
|
|
});
|
|
useMainStore(testingPinia);
|
|
|
|
mountOptions.global.plugins = [testingPinia];
|
|
mountOptions.data = () => (initialData);
|
|
mountOptions.propsData = propsData;
|
|
|
|
const wrapper = shallowMount(cartDropdown, mountOptions);
|
|
return { wrapper };
|
|
}
|
|
|
|
describe('cart-dropdown component', () => {
|
|
test('initial data rendered as expected', () => {
|
|
// Arrange
|
|
const { wrapper } = getMountedComponent({});
|
|
|
|
// Assert
|
|
expect(wrapper.vm.$data).toMatchSnapshot();
|
|
});
|
|
describe('displays', () => {
|
|
test('cart dropdown head', () => {
|
|
// Arrange
|
|
const reference = '#cart-dropdown-head';
|
|
const { wrapper } = getMountedComponent(cartDropdown);
|
|
|
|
// Act
|
|
const head = wrapper.find(reference);
|
|
|
|
// Assert
|
|
expect(head.exists()).toBeTruthy();
|
|
});
|
|
test('cart table', () => {
|
|
// Arrange
|
|
const reference = '#cart-table';
|
|
const isExpanded = true;
|
|
const initialData = { isExpanded };
|
|
const { wrapper } = getMountedComponent({}, {}, initialData);
|
|
|
|
// Act
|
|
const cartTable = wrapper.find(reference);
|
|
|
|
// Assert
|
|
expect(cartTable.exists()).toBeTruthy();
|
|
});
|
|
test('cart deductible when showDeductibleLineItem is true', () => {
|
|
// Arrange
|
|
const reference = '#cart-deductible';
|
|
const isExpanded = true;
|
|
const initialData = { isExpanded };
|
|
const storeData = {
|
|
order: {
|
|
payment: {
|
|
insuranceCoverage: {
|
|
coverageStatus: coverageStatuses.PENDING
|
|
}
|
|
},
|
|
policy: {
|
|
isITAC: false
|
|
}
|
|
}
|
|
};
|
|
const { wrapper } = getMountedComponent(storeData, {}, initialData);
|
|
|
|
// Act
|
|
const cartDeductible = wrapper.find(reference);
|
|
|
|
// Assert
|
|
expect(cartDeductible.exists()).toBeTruthy();
|
|
});
|
|
test('cart base price when showDeductibleLineItem is false', () => {
|
|
// Arrange
|
|
const reference = '#cart-base-price';
|
|
const isExpanded = true;
|
|
const initialData = { isExpanded };
|
|
const storeData = {
|
|
order: {
|
|
payment: {
|
|
insuranceCoverage: {
|
|
coverageStatus: coverageStatuses.PENDING
|
|
}
|
|
},
|
|
policy: {
|
|
isITAC: true
|
|
}
|
|
}
|
|
};
|
|
const { wrapper } = getMountedComponent(storeData, {}, initialData);
|
|
|
|
// Act
|
|
const cartBasePrice = wrapper.find(reference);
|
|
|
|
// Assert
|
|
expect(cartBasePrice.exists()).toBeTruthy();
|
|
});
|
|
test('service package', () => {
|
|
// Arrange
|
|
const reference = '#cart-service-package';
|
|
const isExpanded = true;
|
|
const initialData = { isExpanded };
|
|
const { wrapper } = getMountedComponent({}, {}, initialData);
|
|
|
|
// Act
|
|
const servicePackage = wrapper.find(reference);
|
|
|
|
// Assert
|
|
expect(servicePackage.exists()).toBeTruthy();
|
|
});
|
|
test('cart footer', () => {
|
|
// Arrange
|
|
const reference = '#cart-footer';
|
|
const isExpanded = true;
|
|
const initialData = { isExpanded };
|
|
const { wrapper } = getMountedComponent({}, {}, initialData);
|
|
|
|
// Act
|
|
const cartFooter = wrapper.find(reference);
|
|
|
|
// Assert
|
|
expect(cartFooter.exists()).toBeTruthy();
|
|
});
|
|
test('subtotal', () => {
|
|
// Arrange
|
|
const reference = '#cart-subtotal';
|
|
const isExpanded = true;
|
|
const initialData = { isExpanded };
|
|
const { wrapper } = getMountedComponent({}, {}, initialData);
|
|
|
|
// Act
|
|
const subtotal = wrapper.find(reference);
|
|
|
|
// Assert
|
|
expect(subtotal.exists()).toBeTruthy();
|
|
});
|
|
test('tax', () => {
|
|
// Arrange
|
|
const reference = '#cart-sales-tax';
|
|
const isExpanded = true;
|
|
const initialData = { isExpanded };
|
|
const { wrapper } = getMountedComponent({}, {}, initialData);
|
|
|
|
// Act
|
|
const salesTax = wrapper.find(reference);
|
|
|
|
// Assert
|
|
expect(salesTax.exists()).toBeTruthy();
|
|
});
|
|
test('recycle fee when preset in supported items', () => {
|
|
// Arrange
|
|
const reference = '#recycle-fee-item';
|
|
const { wrapper } = getMountedComponent({
|
|
order: {
|
|
lineItems: {
|
|
supportingItems: [{
|
|
partNumber: partNumberStrings.RECYCLE_FEE
|
|
}]
|
|
}
|
|
}
|
|
});
|
|
|
|
// Act
|
|
const recycleFee = wrapper.find(reference);
|
|
|
|
// Assert
|
|
expect(wrapper.vm.recycleFeeCartItem).not.toBeNull();
|
|
expect(recycleFee.exists()).toBeTruthy();
|
|
});
|
|
test('mobile fee when preset', () => {
|
|
// Arrange
|
|
const reference = '#mobile-fee-item';
|
|
const { wrapper } = getMountedComponent({
|
|
order: {
|
|
lineItems: {
|
|
supportingItems: [],
|
|
mobileFee: {}
|
|
}
|
|
}
|
|
});
|
|
|
|
// Act
|
|
const mobileFee = wrapper.find(reference);
|
|
|
|
// Assert
|
|
expect(wrapper.vm.mobileFeeCartItem).not.toBeNull();
|
|
expect(mobileFee.exists()).toBeTruthy();
|
|
});
|
|
test('bottom amount due', () => {
|
|
// Arrange
|
|
const reference = '#bottom-amount-due';
|
|
const isExpanded = true;
|
|
const initialData = { isExpanded };
|
|
const { wrapper } = getMountedComponent({}, {}, initialData);
|
|
|
|
// Act
|
|
const bottomAmountDue = wrapper.find(reference);
|
|
|
|
// Assert
|
|
expect(bottomAmountDue.exists()).toBeTruthy();
|
|
});
|
|
});
|
|
describe('does not display', () => {
|
|
test('cart deductible when showDeductibleLineItem is false', () => {
|
|
// Arrange
|
|
const reference = '#cart-deductible';
|
|
const isExpanded = true;
|
|
const initialData = { isExpanded };
|
|
const storeData = {
|
|
order: {
|
|
payment: {
|
|
insuranceCoverage: {
|
|
coverageStatus: coverageStatuses.PENDING
|
|
}
|
|
},
|
|
policy: {
|
|
isITAC: true
|
|
}
|
|
}
|
|
};
|
|
const { wrapper } = getMountedComponent(storeData, {}, initialData);
|
|
|
|
// Act
|
|
const cartDeductible = wrapper.find(reference);
|
|
|
|
// Assert
|
|
expect(cartDeductible.exists()).toBeFalsy();
|
|
});
|
|
test('cart base price when showDeductibleLineItem is true', () => {
|
|
// Arrange
|
|
const reference = '#cart-base-price';
|
|
const isExpanded = true;
|
|
const initialData = { isExpanded };
|
|
const storeData = {
|
|
order: {
|
|
payment: {
|
|
insuranceCoverage: {
|
|
coverageStatus: coverageStatuses.PENDING
|
|
}
|
|
},
|
|
policy: {
|
|
isITAC: false
|
|
}
|
|
}
|
|
};
|
|
const { wrapper } = getMountedComponent(storeData, {}, initialData);
|
|
|
|
// Act
|
|
const cartBasePrice = wrapper.find(reference);
|
|
|
|
// Assert
|
|
expect(cartBasePrice.exists()).toBeFalsy();
|
|
});
|
|
test('recycle fee when not in supported items', () => {
|
|
// Arrange
|
|
const reference = '#recycle-fee-item';
|
|
const { wrapper } = getMountedComponent({
|
|
order: {
|
|
lineItems: {
|
|
supportingItems: []
|
|
}
|
|
}
|
|
});
|
|
|
|
// Act
|
|
const recycleFee = wrapper.find(reference);
|
|
|
|
// Assert
|
|
expect(wrapper.vm.recycleFeeCartItem).toBeNull();
|
|
expect(recycleFee.exists()).toBeFalsy();
|
|
});
|
|
test('mobile fee when not in supported items', () => {
|
|
// Arrange
|
|
const reference = '#mobile-fee-item';
|
|
const { wrapper } = getMountedComponent({
|
|
order: {
|
|
lineItems: {
|
|
supportingItems: [],
|
|
mobileFee: null
|
|
}
|
|
}
|
|
});
|
|
|
|
// Act
|
|
const mobileFee = wrapper.find(reference);
|
|
|
|
// Assert
|
|
expect(wrapper.vm.mobileFeeCartItem).toBeNull();
|
|
expect(mobileFee.exists()).toBeFalsy();
|
|
});
|
|
});
|
|
describe('computed', () => {
|
|
describe('isUnverified', () => {
|
|
test('returns false when no comp', () => {
|
|
// Arrange
|
|
const storeData = {
|
|
order: {
|
|
policy: {
|
|
isITAC: false,
|
|
noCoverage: true
|
|
},
|
|
currentDeductible: null
|
|
}
|
|
};
|
|
const { wrapper } = getMountedComponent(storeData);
|
|
|
|
// Act
|
|
const result = wrapper.vm.isUnverified;
|
|
|
|
// Assert
|
|
expect(result).toBeFalsy();
|
|
});
|
|
test('returns false when itac', () => {
|
|
// Arrange
|
|
const storeData = {
|
|
order: {
|
|
payment: {
|
|
insuranceCoverage: {
|
|
coverageStatus: coverageStatuses.PENDING
|
|
}
|
|
},
|
|
policy: {
|
|
isITAC: true
|
|
},
|
|
currentDeductible: null
|
|
}
|
|
};
|
|
const { wrapper } = getMountedComponent(storeData);
|
|
|
|
// Act
|
|
const result = wrapper.vm.isUnverified;
|
|
|
|
// Assert
|
|
expect(result).toBeFalsy();
|
|
});
|
|
test('returns false when deductible not null and verified coverage status', () => {
|
|
// Arrange
|
|
const storeData = {
|
|
order: {
|
|
payment: {
|
|
insuranceCoverage: {
|
|
coverageStatus: coverageStatuses.VERIFIED
|
|
}
|
|
},
|
|
policy: {
|
|
isITAC: false
|
|
},
|
|
currentDeductible: 23
|
|
}
|
|
};
|
|
const { wrapper } = getMountedComponent(storeData);
|
|
|
|
// Act
|
|
const result = wrapper.vm.isUnverified;
|
|
|
|
// Assert
|
|
expect(result).toBeFalsy();
|
|
});
|
|
test('returns true when not no comp, not itac, and deductible is null', () => {
|
|
// Arrange
|
|
const storeData = {
|
|
order: {
|
|
policy: {
|
|
isITAC: false,
|
|
noCoverage: false
|
|
},
|
|
currentDeductible: null
|
|
}
|
|
};
|
|
const { wrapper } = getMountedComponent(storeData);
|
|
|
|
// Act
|
|
const result = wrapper.vm.isUnverified;
|
|
|
|
// Assert
|
|
expect(result).toBeTruthy();
|
|
});
|
|
test('returns true when not no comp, not itac, and coverage status is not verified', () => {
|
|
// Arrange
|
|
const storeData = {
|
|
order: {
|
|
payment: {
|
|
insuranceCoverage: {
|
|
coverageStatus: coverageStatuses.PENDING
|
|
}
|
|
},
|
|
policy: {
|
|
isITAC: false
|
|
},
|
|
currentDeductible: 12
|
|
}
|
|
};
|
|
const { wrapper } = getMountedComponent(storeData);
|
|
|
|
// Act
|
|
const result = wrapper.vm.isUnverified;
|
|
|
|
// Assert
|
|
expect(result).toBeTruthy();
|
|
});
|
|
});
|
|
describe('amountDue', () => {
|
|
test('returns 0 when showAsPaid is true', () => {
|
|
// Arrange
|
|
const propsData = {
|
|
showAsPaid: true
|
|
};
|
|
const { wrapper } = getMountedComponent({}, {}, propsData);
|
|
|
|
// Act
|
|
const result = wrapper.vm.amountDue;
|
|
|
|
// Assert
|
|
expect(result).toBe(0);
|
|
});
|
|
test('returns sum of subTotal and salesTax when showAsPaid is false', () => {
|
|
// TODO when subTotal and salesTax are finished
|
|
});
|
|
});
|
|
describe('subTotal', () => {
|
|
// TODO when method implemented
|
|
});
|
|
describe('salesTax', () => {
|
|
test('salesTax is treated as 0 when line items are null', () => {
|
|
// Arrange
|
|
const storeData = getDefaultState();
|
|
storeData.order.lineItems.glassParts = null;
|
|
storeData.order.lineItems.otherParts = null;
|
|
storeData.order.lineItems.supportingItems = null;
|
|
storeData.order.lineItems.vaps = null;
|
|
|
|
const { wrapper } = getMountedComponent(storeData);
|
|
|
|
// Act
|
|
const result = wrapper.vm.salesTax;
|
|
|
|
// Assert
|
|
expect(result).toBe(0);
|
|
});
|
|
|
|
test("salesTax is treated as 0 when null or undefined is set as the line item's sales tax.", () => {
|
|
// Arrange
|
|
const storeData = getDefaultState();
|
|
storeData.order.lineItems.glassParts = [
|
|
{ partType: 'mock', salesTax: null },
|
|
{ partType: 'mock', salesTax: undefined }
|
|
];
|
|
storeData.order.lineItems.supportingItems = [
|
|
{ partType: 'mock', salesTax: null },
|
|
{ partType: 'mock', salesTax: undefined }
|
|
];
|
|
storeData.order.lineItems.vaps = [
|
|
{ partType: 'mock', salesTax: null },
|
|
{ partType: 'mock', salesTax: undefined }
|
|
];
|
|
|
|
const { wrapper } = getMountedComponent(storeData);
|
|
|
|
// Act
|
|
const result = wrapper.vm.salesTax;
|
|
|
|
// Assert
|
|
expect(result).toBe(0);
|
|
});
|
|
|
|
test('Returns 0 as sales tax when coverage is unverified and order does not contain vaps.', () => {
|
|
// Arrange
|
|
const storeData = getDefaultState();
|
|
storeData.order.lineItems.glassParts = [
|
|
{ partType: 'mock', salesTax: 10 }
|
|
];
|
|
storeData.order.lineItems.vaps = [];
|
|
storeData.order.payment.insuranceCoverage.isVerified = false;
|
|
|
|
const { wrapper } = getMountedComponent(storeData);
|
|
|
|
// Act
|
|
const result = wrapper.vm.salesTax;
|
|
|
|
// Assert
|
|
expect(result).toBe(0);
|
|
});
|
|
|
|
test('Returns sum of vaps sales tax when coverage is unverified and order has vaps.', () => {
|
|
// Arrange
|
|
const storeData = getDefaultState();
|
|
storeData.order.lineItems.glassParts = [
|
|
{ partType: 'mock', salesTax: 10 }
|
|
];
|
|
storeData.order.lineItems.vaps = [
|
|
{ partType: 'mock', salesTax: 1 },
|
|
{ partType: 'mock', salesTax: 2 }
|
|
];
|
|
storeData.order.payment.insuranceCoverage.isVerified = false;
|
|
|
|
const { wrapper } = getMountedComponent(storeData);
|
|
|
|
// Act
|
|
const result = wrapper.vm.salesTax;
|
|
|
|
// Assert
|
|
expect(result).toBe(3);
|
|
});
|
|
|
|
test('Returns Recycle Fee tax when coverage is Verified-Deductible, replace service, and no vaps.', () => {
|
|
// Arrange
|
|
const storeData = getDefaultState();
|
|
storeData.order.currentDeductible = 250;
|
|
storeData.order.lineItems.glassParts = [
|
|
{ partType: 'mock', salesTax: 10, sellingPrice: 150 }
|
|
];
|
|
storeData.order.lineItems.supportingItems = [
|
|
{ partNumber: partNumberStrings.RECYCLE_FEE, partType: 'mock', salesTax: 10, sellingPrice: 39.99 }
|
|
];
|
|
storeData.order.lineItems.vaps = null;
|
|
storeData.order.payment.insuranceCoverage.isVerified = true;
|
|
|
|
const { wrapper } = getMountedComponent(storeData);
|
|
|
|
// Act
|
|
const result = wrapper.vm.salesTax;
|
|
|
|
// Assert
|
|
expect(result).toBe(10);
|
|
});
|
|
|
|
test('Returns sum of vaps + recycle fee sales tax when Verified-Deductible, replace service, and has vaps.', () => {
|
|
// Arrange
|
|
const storeData = getDefaultState();
|
|
storeData.order.currentDeductible = 250;
|
|
storeData.order.lineItems.glassParts = [
|
|
{ partType: 'mock', salesTax: 10, sellingPrice: 100 }
|
|
];
|
|
storeData.order.lineItems.otherParts = [
|
|
{ partType: 'mock', salesTax: 10, kitPrice: 100 }
|
|
];
|
|
storeData.order.lineItems.supportingItems = [
|
|
{ partNumber: partNumberStrings.RECYCLE_FEE, partType: 'mock', salesTax: 10, sellingPrice: 39.99 },
|
|
{ partType: 'mock', salesTax: 10, kitPrice: 100 }
|
|
];
|
|
storeData.order.lineItems.vaps = [
|
|
{ partType: 'mock', salesTax: 2 },
|
|
{ partType: 'mock', salesTax: 3 }
|
|
];
|
|
storeData.order.payment.insuranceCoverage.isVerified = true;
|
|
|
|
const { wrapper } = getMountedComponent(storeData);
|
|
|
|
// Act
|
|
const result = wrapper.vm.salesTax;
|
|
|
|
// Assert
|
|
expect(result).toBe(15);
|
|
});
|
|
|
|
test('Returns sum of sales tax when Verified-ITAC.', () => {
|
|
// Arrange
|
|
const storeData = getDefaultState();
|
|
storeData.order.currentDeductible = 0;
|
|
storeData.order.lineItems.glassParts = [
|
|
{ partType: 'mock', salesTax: 10, sellingPrice: 100 }
|
|
];
|
|
storeData.order.lineItems.otherParts = [
|
|
{ partType: 'mock', salesTax: 10, kitPrice: 100 }
|
|
];
|
|
storeData.order.lineItems.supportingItems = [
|
|
{ partType: 'mock', salesTax: 10, kitPrice: 100 }
|
|
];
|
|
storeData.order.lineItems.vaps = [
|
|
{ partType: 'mock', salesTax: 5 }
|
|
];
|
|
storeData.order.payment.insuranceCoverage.isVerified = true;
|
|
storeData.order.policy.isITAC = true;
|
|
|
|
const { wrapper } = getMountedComponent(storeData);
|
|
|
|
// Act
|
|
const result = wrapper.vm.salesTax;
|
|
|
|
// Assert
|
|
expect(result).toBe(35);
|
|
});
|
|
|
|
test('Returns sum of sales tax when Verified-NoComp.', () => {
|
|
// Arrange
|
|
const storeData = getDefaultState();
|
|
storeData.order.currentDeductible = 0;
|
|
storeData.order.lineItems.glassParts = [
|
|
{ partType: 'mock', salesTax: 10, sellingPrice: 100 }
|
|
];
|
|
storeData.order.lineItems.otherParts = [
|
|
{ partType: 'mock', salesTax: 10, kitPrice: 100 }
|
|
];
|
|
storeData.order.lineItems.supportingItems = [
|
|
{ partType: 'mock', salesTax: 10, kitPrice: 100 }
|
|
];
|
|
storeData.order.lineItems.vaps = [
|
|
{ partType: 'mock', salesTax: 5 }
|
|
];
|
|
storeData.order.payment.insuranceCoverage.isVerified = true;
|
|
storeData.order.policy.noCoverage = true;
|
|
|
|
const { wrapper } = getMountedComponent(storeData);
|
|
|
|
// Act
|
|
const result = wrapper.vm.salesTax;
|
|
|
|
// Assert
|
|
expect(result).toBe(35);
|
|
});
|
|
});
|
|
describe('availableLineItems', () => {
|
|
test('returns expected when glassParts null', async () => {
|
|
// Arrange
|
|
const storeData = {
|
|
order: {
|
|
lineItems: {
|
|
glassParts: null,
|
|
supportingItems: []
|
|
}
|
|
}
|
|
};
|
|
const propsData = { availableVaps: [] };
|
|
const { wrapper } = getMountedComponent(storeData, {}, propsData);
|
|
|
|
// Act
|
|
const result = wrapper.vm.availableLineItems;
|
|
|
|
// Assert
|
|
expect(result).toStrictEqual([]);
|
|
});
|
|
test('returns expected when supportingItems null', async () => {
|
|
// Arrange
|
|
const storeData = {
|
|
order: {
|
|
lineItems: {
|
|
glassParts: [],
|
|
supportingItems: null
|
|
}
|
|
}
|
|
};
|
|
const propsData = { availableVaps: [] };
|
|
const { wrapper } = getMountedComponent(storeData, {}, propsData);
|
|
|
|
// Act
|
|
const result = wrapper.vm.availableLineItems;
|
|
|
|
// Assert
|
|
expect(result).toStrictEqual([]);
|
|
});
|
|
test('returns expected when availableVaps null', async () => {
|
|
// Arrange
|
|
const storeData = {
|
|
order: {
|
|
lineItems: {
|
|
glassParts: [],
|
|
supportingItems: []
|
|
}
|
|
}
|
|
};
|
|
const propsData = {
|
|
availableVaps: undefined
|
|
};
|
|
const { wrapper } = getMountedComponent(storeData, {}, propsData);
|
|
|
|
// Act
|
|
const result = wrapper.vm.availableLineItems;
|
|
|
|
// Assert
|
|
expect(result).toStrictEqual([]);
|
|
});
|
|
test('returns expected when glassParts, supportingItems, and availableVaps have content', async () => {
|
|
// Arrange
|
|
const part1 = { partType: 'apple' };
|
|
const part2 = { partType: 'banana' };
|
|
const part3 = { partType: 'orange' };
|
|
const part4 = { partType: 'grape' };
|
|
const part5 = { partType: 'raspberry' };
|
|
const storeData = {
|
|
order: {
|
|
lineItems: {
|
|
glassParts: [part1],
|
|
supportingItems: [part2, part3]
|
|
}
|
|
}
|
|
};
|
|
const propsData = {
|
|
availableVaps: [part4, part5]
|
|
};
|
|
const { wrapper } = getMountedComponent(storeData, {}, propsData);
|
|
const expected = [part1, part2, part3, part4, part5];
|
|
|
|
// Act
|
|
const result = wrapper.vm.availableLineItems;
|
|
|
|
// Assert
|
|
expect(result).toStrictEqual(expected);
|
|
});
|
|
});
|
|
describe('servicePackageCartItems', () => {
|
|
test.each([
|
|
[undefined], [null], [[]]
|
|
])('returns empty list when package contents %p', (packageContents) => {
|
|
// Arrange
|
|
getPackageContents.mockImplementationOnce(() => packageContents);
|
|
const { wrapper } = getMountedComponent();
|
|
const expected = [];
|
|
|
|
// Act
|
|
const result = wrapper.vm.servicePackageCartItems;
|
|
|
|
// Assert
|
|
expect(result).toStrictEqual(expected);
|
|
});
|
|
test('returns front wiper when front wiper included in types', () => {
|
|
// Arrange
|
|
const frontWiperPartType = partTypeStrings.FRONT_WIPER;
|
|
const packageContents = [frontWiperPartType];
|
|
getPackageContents.mockImplementation(() => packageContents);
|
|
|
|
const mountOptions = getMountOptions({
|
|
router: { navigate: jest.fn() }
|
|
});
|
|
const expectedName = 'some name';
|
|
const vapsItemDescriptions = [
|
|
{
|
|
Name: frontWiperPartType,
|
|
Text: expectedName
|
|
}
|
|
];
|
|
const widgetName = 'VapsItemDescriptions';
|
|
const mockMixin = {
|
|
methods: {
|
|
getCmsContent: jest.fn((widget, _) => (widget === widgetName ? vapsItemDescriptions : []))
|
|
}
|
|
};
|
|
mountOptions.mixins = [mockMixin];
|
|
const storeData = {
|
|
order: {
|
|
lineItems: {
|
|
vaps: [{ partType: frontWiperPartType }]
|
|
}
|
|
}
|
|
};
|
|
const testingPinia = createTestingPinia({
|
|
initialState: {
|
|
main: storeData
|
|
}
|
|
});
|
|
useMainStore(testingPinia);
|
|
mountOptions.global.plugins = [testingPinia];
|
|
|
|
const wrapper = shallowMount(cartDropdown, mountOptions);
|
|
|
|
// Act
|
|
const result = wrapper.vm.servicePackageCartItems;
|
|
|
|
// Assert
|
|
expect(result.length).toBe(1);
|
|
expect(result[0].name).toBe(expectedName);
|
|
});
|
|
test('returns rear wiper when rear wiper included in types', () => {
|
|
// Arrange
|
|
const rearWiperPartType = partTypeStrings.REAR_WIPER;
|
|
const packageContents = [rearWiperPartType];
|
|
getPackageContents.mockImplementationOnce(() => packageContents);
|
|
|
|
const mountOptions = getMountOptions({
|
|
router: { navigate: jest.fn() }
|
|
});
|
|
const expectedName = 'some other name';
|
|
const vapsItemDescriptions = [
|
|
{
|
|
Name: rearWiperPartType,
|
|
Text: expectedName
|
|
}
|
|
];
|
|
const mockMixin = {
|
|
methods: {
|
|
getCmsContent: jest.fn(() => vapsItemDescriptions)
|
|
}
|
|
};
|
|
mountOptions.mixins = [mockMixin];
|
|
const storeData = {
|
|
order: {
|
|
lineItems: {
|
|
vaps: [{ partType: rearWiperPartType }]
|
|
}
|
|
}
|
|
};
|
|
const testingPinia = createTestingPinia({
|
|
initialState: {
|
|
main: storeData
|
|
}
|
|
});
|
|
useMainStore(testingPinia);
|
|
mountOptions.global.plugins = [testingPinia];
|
|
|
|
const wrapper = shallowMount(cartDropdown, mountOptions);
|
|
|
|
// Act
|
|
const result = wrapper.vm.servicePackageCartItems;
|
|
|
|
// Assert
|
|
expect(result.length).toBe(1);
|
|
expect(result[0].name).toBe(expectedName);
|
|
});
|
|
test('returns rain defense when rain defense included in types', () => {
|
|
// Arrange
|
|
const rainDefensePartType = partTypeStrings.RAIN_DEFENSE;
|
|
const packageContents = [rainDefensePartType];
|
|
getPackageContents.mockImplementationOnce(() => packageContents);
|
|
|
|
const mountOptions = getMountOptions({
|
|
router: { navigate: jest.fn() }
|
|
});
|
|
const expectedName = 'different name';
|
|
const vapsItemDescriptions = [
|
|
{
|
|
Name: rainDefensePartType,
|
|
Text: expectedName
|
|
}
|
|
];
|
|
const mockMixin = {
|
|
methods: {
|
|
getCmsContent: jest.fn(() => vapsItemDescriptions)
|
|
}
|
|
};
|
|
mountOptions.mixins = [mockMixin];
|
|
const storeData = {
|
|
order: {
|
|
lineItems: {
|
|
vaps: [{ partType: rainDefensePartType }]
|
|
}
|
|
}
|
|
};
|
|
const testingPinia = createTestingPinia({
|
|
initialState: {
|
|
main: storeData
|
|
}
|
|
});
|
|
useMainStore(testingPinia);
|
|
mountOptions.global.plugins = [testingPinia];
|
|
|
|
const wrapper = shallowMount(cartDropdown, mountOptions);
|
|
|
|
// Act
|
|
const result = wrapper.vm.servicePackageCartItems;
|
|
|
|
// Assert
|
|
expect(result.length).toBe(1);
|
|
expect(result[0].name).toBe(expectedName);
|
|
});
|
|
test('returns expected when all included in types', () => {
|
|
// Arrange
|
|
const frontWiperPartType = partTypeStrings.FRONT_WIPER;
|
|
const rearWiperPartType = partTypeStrings.REAR_WIPER;
|
|
const rainDefensePartType = partTypeStrings.RAIN_DEFENSE;
|
|
const packageContents = [frontWiperPartType, rearWiperPartType, rainDefensePartType];
|
|
getPackageContents.mockImplementationOnce(() => packageContents);
|
|
|
|
const mountOptions = getMountOptions({
|
|
router: { navigate: jest.fn() }
|
|
});
|
|
const expectedFrontWiperName = 'front wiper';
|
|
const expectedRearWiperName = 'rear wiper';
|
|
const expectedRainDefenseName = 'rain defense';
|
|
const vapsItemDescriptions = [
|
|
{
|
|
Name: frontWiperPartType,
|
|
Text: expectedFrontWiperName
|
|
},
|
|
{
|
|
Name: rearWiperPartType,
|
|
Text: expectedRearWiperName
|
|
},
|
|
{
|
|
Name: rainDefensePartType,
|
|
Text: expectedRainDefenseName
|
|
}
|
|
];
|
|
const mockMixin = {
|
|
methods: {
|
|
getCmsContent: jest.fn(() => vapsItemDescriptions)
|
|
}
|
|
};
|
|
mountOptions.mixins = [mockMixin];
|
|
const storeData = {
|
|
order: {
|
|
lineItems: {
|
|
vaps: [
|
|
{ partType: frontWiperPartType },
|
|
{ partType: rearWiperPartType },
|
|
{ partType: rainDefensePartType }
|
|
]
|
|
}
|
|
}
|
|
};
|
|
const testingPinia = createTestingPinia({
|
|
initialState: {
|
|
main: storeData
|
|
}
|
|
});
|
|
useMainStore(testingPinia);
|
|
mountOptions.global.plugins = [testingPinia];
|
|
|
|
const wrapper = shallowMount(cartDropdown, mountOptions);
|
|
|
|
// Act
|
|
const result = wrapper.vm.servicePackageCartItems;
|
|
|
|
// Assert
|
|
expect(result.length).toBe(3);
|
|
expect(result).toContainEqual(expect.objectContaining({
|
|
name: expectedFrontWiperName
|
|
}));
|
|
expect(result).toContainEqual(expect.objectContaining({
|
|
name: expectedRearWiperName
|
|
}));
|
|
expect(result).toContainEqual(expect.objectContaining({
|
|
name: expectedRainDefenseName
|
|
}));
|
|
});
|
|
});
|
|
describe('servicePackageLabelWidget', () => {
|
|
test.each([
|
|
[null],
|
|
[undefined]
|
|
])('returns "" when servicePackageNames %p', (servicePackageNames) => {
|
|
// Arrange
|
|
const mountOptions = getMountOptions({
|
|
router: { navigate: jest.fn() }
|
|
});
|
|
const mockMixin = {
|
|
methods: {
|
|
getCmsContent: jest.fn(() => servicePackageNames)
|
|
}
|
|
};
|
|
mountOptions.mixins = [mockMixin];
|
|
|
|
const wrapper = shallowMount(cartDropdown, mountOptions);
|
|
|
|
// Act
|
|
const result = wrapper.vm.servicePackageLabelWidget;
|
|
|
|
// Assert
|
|
expect(result).toBe('');
|
|
});
|
|
test('returns "" when servicePackageTier not found in servicePackageNames', () => {
|
|
// Arrange
|
|
const mountOptions = getMountOptions({
|
|
router: { navigate: jest.fn() }
|
|
});
|
|
getHighestFullySatisfiedTier.mockImplementationOnce(() => 'some other tier');
|
|
const servicePackageNames = [{ Name: 'some tier' }];
|
|
const mockMixin = {
|
|
methods: {
|
|
getCmsContent: jest.fn(() => servicePackageNames)
|
|
}
|
|
};
|
|
mountOptions.mixins = [mockMixin];
|
|
const wrapper = shallowMount(cartDropdown, mountOptions);
|
|
|
|
// Act
|
|
const result = wrapper.vm.servicePackageLabelWidget;
|
|
|
|
// Assert
|
|
expect(result).toBe('');
|
|
});
|
|
test('returns "" when servicePackageTier has no SubWidgetName', () => {
|
|
// Arrange
|
|
const mountOptions = getMountOptions({
|
|
router: { navigate: jest.fn() }
|
|
});
|
|
const tier = 'tier1';
|
|
getHighestFullySatisfiedTier.mockImplementationOnce(() => tier);
|
|
const servicePackageNames = [{ Name: tier }];
|
|
const mockMixin = {
|
|
methods: {
|
|
getCmsContent: jest.fn(() => servicePackageNames)
|
|
}
|
|
};
|
|
mountOptions.mixins = [mockMixin];
|
|
const wrapper = shallowMount(cartDropdown, mountOptions);
|
|
|
|
// Act
|
|
const result = wrapper.vm.servicePackageLabelWidget;
|
|
|
|
// Assert
|
|
expect(result).toBe('');
|
|
});
|
|
test('returns expected when servicePackageTier has SubWidgetName', () => {
|
|
// Arrange
|
|
const mountOptions = getMountOptions({
|
|
router: { navigate: jest.fn() }
|
|
});
|
|
const tier = 'tier1';
|
|
getHighestFullySatisfiedTier.mockImplementationOnce(() => tier);
|
|
const expected = 'name of sub widget';
|
|
const servicePackageNames = [{
|
|
Name: tier,
|
|
SubWidgetName: expected
|
|
}];
|
|
const mockMixin = {
|
|
methods: {
|
|
getCmsContent: jest.fn(() => servicePackageNames)
|
|
}
|
|
};
|
|
mountOptions.mixins = [mockMixin];
|
|
const wrapper = shallowMount(cartDropdown, mountOptions);
|
|
|
|
// Act
|
|
const result = wrapper.vm.servicePackageLabelWidget;
|
|
|
|
// Assert
|
|
expect(result).toBe(expected);
|
|
});
|
|
});
|
|
describe('recycleFeeCartItem', () => {
|
|
test.each([
|
|
[null], [undefined], [[]]
|
|
])('returns null when supporting items %p', (supportingItems) => {
|
|
// Arrange
|
|
const storeData = {
|
|
order: {
|
|
lineItems: { supportingItems }
|
|
}
|
|
};
|
|
const { wrapper } = getMountedComponent(storeData);
|
|
const expected = null;
|
|
|
|
// Act
|
|
const result = wrapper.vm.recycleFeeCartItem;
|
|
|
|
// Assert
|
|
expect(result).toStrictEqual(expected);
|
|
});
|
|
test('returns null when recycle fee not in non empty supporting items', () => {
|
|
// Arrange
|
|
const storeData = {
|
|
order: {
|
|
lineItems: {
|
|
supportingItems: [{ partNumber: 'not recycle' }]
|
|
}
|
|
}
|
|
};
|
|
const { wrapper } = getMountedComponent(storeData);
|
|
const expected = null;
|
|
|
|
// Act
|
|
const result = wrapper.vm.recycleFeeCartItem;
|
|
|
|
// Assert
|
|
expect(result).toStrictEqual(expected);
|
|
});
|
|
test('returns expected when recycle fee in supporting items', () => {
|
|
// Arrange
|
|
const mountOptions = getMountOptions({
|
|
router: { navigate: jest.fn() }
|
|
});
|
|
const expectedName = 'recycling fee';
|
|
const widgetName = 'RecycleFeeWidget';
|
|
const mockMixin = {
|
|
methods: {
|
|
getCmsContent: jest.fn((widget, _) => (widget === widgetName ? expectedName : []))
|
|
}
|
|
};
|
|
mountOptions.mixins = [mockMixin];
|
|
const storeData = {
|
|
order: {
|
|
lineItems: {
|
|
supportingItems: [{ partNumber: partNumberStrings.RECYCLE_FEE }]
|
|
}
|
|
}
|
|
};
|
|
const testingPinia = createTestingPinia({
|
|
initialState: {
|
|
main: storeData
|
|
}
|
|
});
|
|
useMainStore(testingPinia);
|
|
mountOptions.global.plugins = [testingPinia];
|
|
|
|
const wrapper = shallowMount(cartDropdown, mountOptions);
|
|
|
|
// Act
|
|
const result = wrapper.vm.recycleFeeCartItem;
|
|
|
|
// Assert
|
|
expect(result.name).toBe(expectedName);
|
|
});
|
|
});
|
|
describe('mobileFeeCartItem', () => {
|
|
test.each([[null], [undefined]])('returns null when mobile fee %p', (mobileFee) => {
|
|
// Arrange
|
|
const storeData = {
|
|
order: {
|
|
lineItems: { mobileFee }
|
|
}
|
|
};
|
|
const { wrapper } = getMountedComponent(storeData);
|
|
const expected = null;
|
|
|
|
// Act
|
|
const result = wrapper.vm.mobileFeeCartItem;
|
|
|
|
// Assert
|
|
expect(result).toStrictEqual(expected);
|
|
});
|
|
test('returns expected when mobile fee in supporting items', () => {
|
|
// Arrange
|
|
const mountOptions = getMountOptions({
|
|
router: { navigate: jest.fn() }
|
|
});
|
|
const expectedName = 'mobile fee';
|
|
const widgetName = 'MobileServiceWidget';
|
|
const mockMixin = {
|
|
methods: {
|
|
getCmsContent: jest.fn((widget, _) => (widget === widgetName ? expectedName : []))
|
|
}
|
|
};
|
|
mountOptions.mixins = [mockMixin];
|
|
const storeData = {
|
|
order: {
|
|
lineItems: {
|
|
mobileFee: { partType: partTypeStrings.MOBILE_FEE }
|
|
}
|
|
}
|
|
};
|
|
const testingPinia = createTestingPinia({
|
|
initialState: {
|
|
main: storeData
|
|
}
|
|
});
|
|
useMainStore(testingPinia);
|
|
mountOptions.global.plugins = [testingPinia];
|
|
|
|
const wrapper = shallowMount(cartDropdown, mountOptions);
|
|
|
|
// Act
|
|
const result = wrapper.vm.mobileFeeCartItem;
|
|
|
|
// Assert
|
|
expect(result.name).toBe(expectedName);
|
|
});
|
|
});
|
|
});
|
|
describe('method', () => {
|
|
describe('getDisplayed', () => {
|
|
test('returns "Verifying coverage" when not no comp, not itac, and deductible null', () => {
|
|
// Arrange
|
|
const storeData = getDefaultState();
|
|
storeData.order.payment.insuranceCoverage.coverageStatus = coverageStatuses.VERIFIED;
|
|
storeData.order.policy.isITAC = false;
|
|
storeData.order.currentDeductible = null;
|
|
|
|
const { wrapper } = getMountedComponent(storeData);
|
|
const amount = 123;
|
|
|
|
// Act
|
|
const result = wrapper.vm.getDisplayed(amount);
|
|
|
|
// Assert
|
|
expect(result).toBe(VERIFYING_COVERAGE);
|
|
});
|
|
test('returns "Verifying coverage" when not no comp, not itac, and coverage status PENDING', () => {
|
|
// Arrange
|
|
const storeData = getDefaultState();
|
|
storeData.order.payment.insuranceCoverage.coverageStatus = coverageStatuses.PENDING;
|
|
storeData.order.policy.isITAC = false;
|
|
storeData.order.currentDeductible = 321;
|
|
|
|
const { wrapper } = getMountedComponent(storeData);
|
|
const amount = 123;
|
|
|
|
// Act
|
|
const result = wrapper.vm.getDisplayed(amount);
|
|
|
|
// Assert
|
|
expect(result).toBe(VERIFYING_COVERAGE);
|
|
});
|
|
test('returns dollar amount when itac', () => {
|
|
// Arrange
|
|
const storeData = {
|
|
order: {
|
|
payment: {
|
|
insuranceCoverage: {
|
|
coverageStatus: coverageStatuses.PENDING
|
|
}
|
|
},
|
|
policy: {
|
|
isITAC: true
|
|
},
|
|
currentDeductible: 321
|
|
}
|
|
};
|
|
const { wrapper } = getMountedComponent(storeData);
|
|
const amount = 123;
|
|
const dollarAmount = '$84.00';
|
|
formatAmountInDollars.mockImplementationOnce(() => dollarAmount);
|
|
|
|
// Act
|
|
const result = wrapper.vm.getDisplayed(amount);
|
|
|
|
// Assert
|
|
expect(result).toBe(dollarAmount);
|
|
});
|
|
test('returns dollar amount when no comp', () => {
|
|
// Arrange
|
|
const storeData = {
|
|
order: {
|
|
policy: {
|
|
isITAC: false,
|
|
noCoverage: true
|
|
},
|
|
currentDeductible: 321
|
|
}
|
|
};
|
|
const { wrapper } = getMountedComponent(storeData);
|
|
const amount = 123;
|
|
const dollarAmount = '$84.00';
|
|
formatAmountInDollars.mockImplementationOnce(() => dollarAmount);
|
|
|
|
// Act
|
|
const result = wrapper.vm.getDisplayed(amount);
|
|
|
|
// Assert
|
|
expect(result).toBe(dollarAmount);
|
|
});
|
|
test('returns dollar amount when deductible set, not itac, not no comp, and verified', () => {
|
|
// Arrange
|
|
const storeData = {
|
|
order: {
|
|
payment: {
|
|
insuranceCoverage: {
|
|
coverageStatus: coverageStatuses.VERIFIED
|
|
}
|
|
},
|
|
policy: {
|
|
isITAC: false
|
|
},
|
|
currentDeductible: 321
|
|
}
|
|
};
|
|
const { wrapper } = getMountedComponent(storeData);
|
|
const amount = 123;
|
|
const dollarAmount = '$84.00';
|
|
formatAmountInDollars.mockImplementationOnce(() => dollarAmount);
|
|
|
|
// Act
|
|
const result = wrapper.vm.getDisplayed(amount);
|
|
|
|
// Assert
|
|
expect(result).toBe(dollarAmount);
|
|
});
|
|
});
|
|
describe('getCartItemForVapsPart', () => {
|
|
test('returns item with no label when no descriptions returned', () => {
|
|
// Arrange
|
|
const mountOptions = getMountOptions({
|
|
router: { navigate: jest.fn() }
|
|
});
|
|
const descriptions = [];
|
|
const widgetName = 'VapsItemDescriptions';
|
|
const mockMixin = {
|
|
methods: {
|
|
getCmsContent: jest.fn((widget, _) => (widget === widgetName ? descriptions : []))
|
|
}
|
|
};
|
|
mountOptions.mixins = [mockMixin];
|
|
const part = 'some part';
|
|
const storeData = {
|
|
order: {
|
|
lineItems: {
|
|
vaps: [{ partType: part }]
|
|
}
|
|
}
|
|
};
|
|
const testingPinia = createTestingPinia({
|
|
initialState: {
|
|
main: storeData
|
|
}
|
|
});
|
|
useMainStore(testingPinia);
|
|
mountOptions.global.plugins = [testingPinia];
|
|
const wrapper = shallowMount(cartDropdown, mountOptions);
|
|
|
|
const expectedName = '';
|
|
|
|
// Act
|
|
const result = wrapper.vm.getCartItemForVapsPart(part);
|
|
|
|
// Assert
|
|
expect(result.name).toBe(expectedName);
|
|
});
|
|
test('returns item with no label when type not in descriptions', () => {
|
|
// Arrange
|
|
const mountOptions = getMountOptions({
|
|
router: { navigate: jest.fn() }
|
|
});
|
|
const descriptions = [{
|
|
Name: 'not part name'
|
|
}];
|
|
const widgetName = 'VapsItemDescriptions';
|
|
const mockMixin = {
|
|
methods: {
|
|
getCmsContent: jest.fn((widget, _) => (widget === widgetName ? descriptions : []))
|
|
}
|
|
};
|
|
mountOptions.mixins = [mockMixin];
|
|
const part = 'some part';
|
|
const storeData = {
|
|
order: {
|
|
lineItems: {
|
|
vaps: [{ partType: part }]
|
|
}
|
|
}
|
|
};
|
|
const testingPinia = createTestingPinia({
|
|
initialState: {
|
|
main: storeData
|
|
}
|
|
});
|
|
useMainStore(testingPinia);
|
|
mountOptions.global.plugins = [testingPinia];
|
|
const wrapper = shallowMount(cartDropdown, mountOptions);
|
|
|
|
const expectedName = '';
|
|
|
|
// Act
|
|
const result = wrapper.vm.getCartItemForVapsPart(part);
|
|
|
|
// Assert
|
|
expect(result.name).toBe(expectedName);
|
|
});
|
|
test('returns item with no label when description text not defined', () => {
|
|
// Arrange
|
|
const mountOptions = getMountOptions({
|
|
router: { navigate: jest.fn() }
|
|
});
|
|
const part = 'some part';
|
|
const descriptions = [{
|
|
Name: part
|
|
}];
|
|
const widgetName = 'VapsItemDescriptions';
|
|
const mockMixin = {
|
|
methods: {
|
|
getCmsContent: jest.fn((widget, _) => (widget === widgetName ? descriptions : []))
|
|
}
|
|
};
|
|
mountOptions.mixins = [mockMixin];
|
|
const storeData = {
|
|
order: {
|
|
lineItems: {
|
|
vaps: [{ partType: part }]
|
|
}
|
|
}
|
|
};
|
|
const testingPinia = createTestingPinia({
|
|
initialState: {
|
|
main: storeData
|
|
}
|
|
});
|
|
useMainStore(testingPinia);
|
|
mountOptions.global.plugins = [testingPinia];
|
|
const wrapper = shallowMount(cartDropdown, mountOptions);
|
|
const expectedName = '';
|
|
|
|
// Act
|
|
const result = wrapper.vm.getCartItemForVapsPart(part);
|
|
|
|
// Assert
|
|
expect(result.name).toBe(expectedName);
|
|
});
|
|
test('returns expected label when vaps description text set', () => {
|
|
// Arrange
|
|
const mountOptions = getMountOptions({
|
|
router: { navigate: jest.fn() }
|
|
});
|
|
const part = 'some part';
|
|
const expectedName = 'name to show up';
|
|
const descriptions = [{
|
|
Name: part,
|
|
Text: expectedName
|
|
}];
|
|
const widgetName = 'VapsItemDescriptions';
|
|
const mockMixin = {
|
|
methods: {
|
|
getCmsContent: jest.fn((widget, _) => (widget === widgetName ? descriptions : []))
|
|
}
|
|
};
|
|
mountOptions.mixins = [mockMixin];
|
|
const storeData = {
|
|
order: {
|
|
lineItems: {
|
|
vaps: [{ partType: part }]
|
|
}
|
|
}
|
|
};
|
|
const testingPinia = createTestingPinia({
|
|
initialState: {
|
|
main: storeData
|
|
}
|
|
});
|
|
useMainStore(testingPinia);
|
|
mountOptions.global.plugins = [testingPinia];
|
|
const wrapper = shallowMount(cartDropdown, mountOptions);
|
|
|
|
// Act
|
|
const result = wrapper.vm.getCartItemForVapsPart(part);
|
|
|
|
// Assert
|
|
expect(result.name).toBe(expectedName);
|
|
});
|
|
test.each([
|
|
[undefined], [null]
|
|
])('returns null when vapsInOrder %p', async (vapsInOrder) => {
|
|
// Arrange
|
|
const mountOptions = getMountOptions({
|
|
router: { navigate: jest.fn() }
|
|
});
|
|
const part = 'some part';
|
|
const expectedName = 'name to show up';
|
|
const descriptions = [{
|
|
Name: part,
|
|
Text: expectedName
|
|
}];
|
|
const widgetName = 'VapsItemDescriptions';
|
|
const mockMixin = {
|
|
methods: {
|
|
getCmsContent: jest.fn((widget, _) => (widget === widgetName ? descriptions : []))
|
|
}
|
|
};
|
|
mountOptions.mixins = [mockMixin];
|
|
const storeData = {
|
|
order: {
|
|
lineItems: {
|
|
vaps: vapsInOrder
|
|
}
|
|
}
|
|
};
|
|
const testingPinia = createTestingPinia({
|
|
initialState: {
|
|
main: storeData
|
|
}
|
|
});
|
|
useMainStore(testingPinia);
|
|
mountOptions.global.plugins = [testingPinia];
|
|
const wrapper = shallowMount(cartDropdown, mountOptions);
|
|
|
|
// Act
|
|
const result = wrapper.vm.getCartItemForVapsPart(part);
|
|
|
|
// Assert
|
|
expect(result).toBe(null);
|
|
});
|
|
test('returns item with expected price when part type found in vapsInOrder', () => {
|
|
// Arrange
|
|
const mountOptions = getMountOptions({
|
|
router: { navigate: jest.fn() }
|
|
});
|
|
const part = 'some part';
|
|
const vaps = [{ partType: part }];
|
|
const storeData = {
|
|
order: {
|
|
lineItems: { vaps }
|
|
}
|
|
};
|
|
const testingPinia = createTestingPinia({
|
|
initialState: {
|
|
main: storeData
|
|
}
|
|
});
|
|
useMainStore(testingPinia);
|
|
mountOptions.global.plugins = [testingPinia];
|
|
const expectedSubtotal = 93;
|
|
getPriceOfLineItems.mockImplementation(() => expectedSubtotal);
|
|
const wrapper = shallowMount(cartDropdown, mountOptions);
|
|
|
|
// Act
|
|
const result = wrapper.vm.getCartItemForVapsPart(part);
|
|
|
|
// Assert
|
|
expect(result.subTotal).toBe(expectedSubtotal);
|
|
});
|
|
});
|
|
describe('removeItem', () => {
|
|
// TODO when written
|
|
});
|
|
});
|
|
});
|