From bc4f083368cceb7e8dfa8ea96fb6a0277f7e8d40 Mon Sep 17 00:00:00 2001 From: hiteshkumar87 Date: Thu, 12 Oct 2023 16:33:13 +0530 Subject: [PATCH] unit test cases unit test cases --- src/helpers/add-to-calendar-helper.js | 2 +- src/helpers/add-to-calendar-helper.spec.js | 79 +++++++ src/helpers/date-helper.js | 81 ++++---- src/helpers/date-helper.spec.js | 191 +++++++++++++++++ .../add-to-calendar/add-to-calendar.spec.js | 156 ++++++++++++++ src/layouts/confirmation/confirmation.spec.js | 194 +++++++++++++++++- 6 files changed, 651 insertions(+), 52 deletions(-) create mode 100644 src/helpers/add-to-calendar-helper.spec.js create mode 100644 src/helpers/date-helper.spec.js diff --git a/src/helpers/add-to-calendar-helper.js b/src/helpers/add-to-calendar-helper.js index 36c700cb3..93a5e7c18 100644 --- a/src/helpers/add-to-calendar-helper.js +++ b/src/helpers/add-to-calendar-helper.js @@ -6,7 +6,7 @@ export function getCalendarFile(calFile) { calEvent.push("BEGIN:VCALENDAR"); calEvent.push("VERSION:2.0"); calEvent.push("BEGIN:VEVENT"); - calEvent.push("DTSTAMP:" + getDateFormat(new Date(), dateFormat)); + calEvent.push("DTSTAMP:" + calFile.TimeStamp); calEvent.push("UID:" + calFile.UniqueId + "@safelite.com"); calEvent.push("PRODID:noreply@safelite.com"); switch (calFile.Status) { diff --git a/src/helpers/add-to-calendar-helper.spec.js b/src/helpers/add-to-calendar-helper.spec.js new file mode 100644 index 000000000..1cb40d499 --- /dev/null +++ b/src/helpers/add-to-calendar-helper.spec.js @@ -0,0 +1,79 @@ +import { download, getCalendarFile } from "./add-to-calendar-helper"; + +// Create a mock function +const mockDownload = jest.fn((filename, fileBody) => { + // Simulate creating an anchor element + const mockElement = { + setAttribute: jest.fn(), + style: { display: "none" }, + click: jest.fn(), + }; + // Mock the document.createElement method + document.createElement = jest.fn(() => mockElement); + // Mock the document.body.appendChild method + document.body.appendChild = jest.fn(); + // Mock the document.body.removeChild method + document.body.removeChild = jest.fn(); + + // Call the original function with the mock element + download(filename, fileBody); + + // Return the mock element for further assertions + return mockElement; +}); + +// Use the mock function in a test +test("download function", () => { + // Call the mock function with some arguments + const mockElement = mockDownload("test.txt", "Hello world"); + + // Make assertions about the mock function and the mock element + expect(mockDownload).toHaveBeenCalledTimes(1); + expect(mockDownload).toHaveBeenCalledWith("test.txt", "Hello world"); + expect(mockElement.setAttribute).toHaveBeenCalledTimes(2); + expect(mockElement.setAttribute).toHaveBeenCalledWith( + "href", + "data:text/plain;charset=utf-8," + encodeURIComponent("Hello world") + ); + expect(mockElement.setAttribute).toHaveBeenCalledWith("download", "test.txt"); + expect(mockElement.style.display).toBe("none"); + expect(mockElement.click).toHaveBeenCalledTimes(1); + expect(document.body.appendChild).toHaveBeenCalledTimes(1); + expect(document.body.appendChild).toHaveBeenCalledWith(mockElement); + expect(document.body.removeChild).toHaveBeenCalledTimes(1); + expect(document.body.removeChild).toHaveBeenCalledWith(mockElement); +}); + +// Use the mock function in a test +test("getCalendarFile function", () => { + // Create a mock calFile object + const mockCalFile = { + UniqueId: "123456", + Status: "Busy", + StartDate: new Date(2023, 9, 11, 12, 0, 0), + EndDate: new Date(2023, 9, 11, 13, 0, 0), + Subject: "Meeting with John", + Location: "Conference Room", + Body: "Discuss the project progress", + TimeStamp: "20231011T113118", + }; + + // Call the mock function with the mock calFile object + const mockCalendarFile = getCalendarFile(mockCalFile); + + // Make assertions about the mock function and the mock calendar file + expect(mockCalendarFile).toContain("BEGIN:VCALENDAR"); + expect(mockCalendarFile).toContain("VERSION:2.0"); + expect(mockCalendarFile).toContain("BEGIN:VEVENT"); + expect(mockCalendarFile).toContain("DTSTAMP:20231011T113118"); + expect(mockCalendarFile).toContain("UID:123456@safelite.com"); + expect(mockCalendarFile).toContain("PRODID:noreply@safelite.com"); + expect(mockCalendarFile).toContain("DTSTART:20231011T120000"); + expect(mockCalendarFile).toContain("DTEND:20231011T130000"); + expect(mockCalendarFile).toContain("X-MICROSOFT-CDO-BUSYSTATUS:BUSY"); + expect(mockCalendarFile).toContain("SUMMARY:Meeting with John"); + expect(mockCalendarFile).toContain("LOCATION:Conference Room"); + expect(mockCalendarFile).toContain("DESCRIPTION:Discuss the project progress"); + expect(mockCalendarFile).toContain("END:VEVENT"); + expect(mockCalendarFile).toContain("END:VCALENDAR"); +}); diff --git a/src/helpers/date-helper.js b/src/helpers/date-helper.js index d1c9f968b..d42ad326f 100644 --- a/src/helpers/date-helper.js +++ b/src/helpers/date-helper.js @@ -1,35 +1,27 @@ export function getDateDifferenceInDays(startDate, endDate) { + // Create date objects from the input strings var date1 = new Date(endDate); - date1.setHours(0, 0, 0, 0); var date2 = new Date(startDate); - date2.setHours(0, 0, 0, 0); - // To calculate the time difference of two dates - var Difference_In_Time = date1.getTime() - date2.getTime(); - // To calculate the no. of days between two dates - return Difference_In_Time / (1000 * 3600 * 24); + // Use the built-in method to get the difference in milliseconds + var difference = date1 - date2; + // Convert milliseconds to days and return the result + return difference / (1000 * 3600 * 24); } export function getFullDayName(date) { - if (date instanceof Date !== true) return; - const days = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"]; - return days[date.getDay()]; + // Use a ternary operator to check if the input is a valid date object + return date instanceof Date + ? // Use the built-in method toLocaleDateString() to get the full day name in the current locale + date.toLocaleDateString(undefined, { weekday: "long" }) + : // Return undefined if the input is not a valid date object + undefined; } export function getFullMonthName(date) { - if (date instanceof Date !== true) return; - const monthNames = [ - "January", - "February", - "March", - "April", - "May", - "June", - "July", - "August", - "September", - "October", - "November", - "December", - ]; - return monthNames[date.getMonth()]; + // Use a ternary operator to check if the input is a valid date object + return date instanceof Date + ? // Use the built-in method toLocaleDateString() to get the full month name in the current locale + date.toLocaleDateString(undefined, { month: "long" }) + : // Return undefined if the input is not a valid date object + undefined; } export function get12HourTimeFormat(time) { // Check correct time format and split into components @@ -96,32 +88,31 @@ export function convertMsToTime(milliseconds) { return `${padTo2Digits(hours)}${padTo2Digits(minutes)}`; } export function padTo2Digits(time) { - return ("0" + time).slice(-2); + // Use the built-in method toString() with a radix of 10 to convert the time value to a decimal string + time = time.toString(10); + // Use the conditional operator to check if the length of the string is less than 2 + return time.length < 2 + ? // If yes, prepend a '0' to the string and return it + "0" + time + : // If no, return the original string + time; } export function combineDateAndTime(date, time) { - var newDate = new Date(date); - var timeParts = time.split(":"); - newDate.setHours(timeParts[0]); - newDate.setMinutes(timeParts[1]); + // Use the Date.parse() method to convert the date and time strings to a numeric value + var timestamp = Date.parse(date + "T" + time); + // Use the new Date() constructor to create a new date object from the numeric value + var newDate = new Date(timestamp); + // Return the new date object return newDate; } export function addMinutes(date, minutes) { return new Date(date.getTime() + minutes * 60000); } export function shortTimeString(date) { - if (date instanceof Date !== true) return; - const hour = ("0" + date.getHours()).slice(-2); - const minute = ("0" + date.getMinutes()).slice(-2); - //const second = ("0" + date.getSeconds()).slice(-2); - let time = hour + ":" + minute; - // Check correct time format and split into components - time = time.toString().match(/^([01]\d|2[0-3])(:)([0-5]\d)?$/) || [time]; - - if (time.length > 1) { - // If time format correct - time = time.slice(1); // Remove full string match value - time[5] = +time[0] < 12 ? " AM" : " PM"; // Set AM/PM - time[0] = +time[0] % 12 || 12; // Adjust hours - } - return time.join(""); // return adjusted time or original string + // Use a ternary operator to check if the input is a valid date object + return date instanceof Date + ? // Use the built-in method toLocaleTimeString() to get the short time string in the current locale + date.toLocaleTimeString(undefined, { hour: "numeric", minute: "numeric", hour12: true }) + : // Return undefined if the input is not a valid date object + undefined; } diff --git a/src/helpers/date-helper.spec.js b/src/helpers/date-helper.spec.js new file mode 100644 index 000000000..4ea2157f5 --- /dev/null +++ b/src/helpers/date-helper.spec.js @@ -0,0 +1,191 @@ +import { + getFullDayName, + getFullMonthName, + get12HourTimeFormat, + get12HourTimeMobileFormat, + getDateFormat, + getDateDifferenceInDays, + calculateDuration, + padTo2Digits, + combineDateAndTime, + addMinutes, + shortTimeString, +} from "./date-helper"; +describe("date-helper.js", () => { + it("get12HourTimeMobileFormat should return time in expected 12 hour mobile format.", () => { + // Define some sample times and their expected 12-hour formats + const testCases = [ + { time: "00:00", expected: "12 AM" }, + { time: "01:23", expected: "1:23 AM" }, + { time: "11:59", expected: "11:59 AM" }, + { time: "12:00", expected: "12 PM" }, + { time: "13:45", expected: "1:45 PM" }, + { time: "23:59", expected: "11:59 PM" }, + ]; + // Loop through the test cases and call the function with each time + for (let testCase of testCases) { + // Call the function and store the result + const result = get12HourTimeMobileFormat(testCase.time); + // Assert that the result is equal to the expected 12-hour format + expect(result).toEqual(testCase.expected); + } + }); + // Test if the function returns the correct 12-hour format for some sample times + it("should return the correct 12-hour format", function () { + // Define some sample times and their expected 12-hour formats + const testCases = [ + { time: "00:00", expected: "12:00 AM" }, + { time: "01:23", expected: "1:23 AM" }, + { time: "11:59", expected: "11:59 AM" }, + { time: "12:00", expected: "12:00 PM" }, + { time: "13:45", expected: "1:45 PM" }, + { time: "23:59", expected: "11:59 PM" }, + ]; + // Loop through the test cases and call the function with each time + for (let testCase of testCases) { + // Call the function and store the result + const result = get12HourTimeFormat(testCase.time); + // Assert that the result is equal to the expected 12-hour format + expect(result).toEqual(testCase.expected); + } + }); + it("getFullMonthName should return full month format.", () => { + // Arrange / Act + const date = new Date("2023-10-01"); + const monthName = getFullMonthName(date); + + // Assert + expect(monthName).toEqual("October"); + }); + it("getFullDayName should return full Day Name format.", () => { + // Arrange / Act + const date = new Date("2023-10-01"); + const dayName = getFullDayName(date); + + // Assert + expect(dayName).toEqual("Sunday"); + }); + it("getDateFormat should return date in the given format.", () => { + // Arrange / Act + const date = new Date("2023-10-01"); + const format = "yyyy-MM-dd"; + const formattedDate = getDateFormat(date, format); + + // Assert + expect(formattedDate).toEqual("2023-10-01"); + }); + it("should return the correct difference in days", function () { + // Define some sample dates and their expected differences + const testCases = [ + { startDate: "2023-10-12", endDate: "2023-10-15", expected: 3 }, + { startDate: "2023-01-01", endDate: "2023-01-31", expected: 30 }, + { startDate: "2022-12-31", endDate: "2023-01-01", expected: 1 }, + { startDate: "2023-02-28", endDate: "2023-03-01", expected: 1 }, + { startDate: "2023-03-01", endDate: "2023-02-28", expected: -1 }, + ]; + // Loop through the test cases and call the function with each pair of dates + for (let testCase of testCases) { + // Call the function and store the result + const result = getDateDifferenceInDays(testCase.startDate, testCase.endDate); + // Assert that the result is equal to the expected difference + expect(result).toEqual(testCase.expected); + } + }); + it("calculateDuration should return duration in hhmm format.", () => { + // Arrange / Act + const startDate = new Date("2023-10-01 10:00:00"); + const endDate = new Date("2023-10-01 23:00:00"); + const duration = calculateDuration(startDate, endDate); + + // Assert + expect(duration).toEqual("1300"); + }); + it("padTo2Digits should return time in 2 digit format.", () => { + // Define some sample time values and their expected strings + const testCases = [ + { time: 0, expected: "00" }, + { time: 1, expected: "01" }, + { time: 9, expected: "09" }, + { time: 10, expected: "10" }, + { time: 59, expected: "59" }, + ]; + // Loop through the test cases and call the function with each time value + for (let testCase of testCases) { + // Call the function and store the result + const result = padTo2Digits(testCase.time); + // Assert that the result is equal to the expected string + expect(result).toEqual(testCase.expected); + } + }); + it("combineDateAndTime should return combined dateTime format.", () => { + // Define some sample inputs and their expected outputs + const testCases = [ + { date: "2023-10-12", time: "12:00", expected: new Date(2023, 9, 12, 12, 0) }, + { date: "2023-01-01", time: "00:00", expected: new Date(2023, 0, 1, 0, 0) }, + { date: "2022-12-31", time: "23:59", expected: new Date(2022, 11, 31, 23, 59) }, + { date: "2023-02-28", time: "13:45", expected: new Date(2023, 1, 28, 13, 45) }, + { date: "2023-03-01", time: "01:23", expected: new Date(2023, 2, 1, 1, 23) }, + ]; + // Loop through the test cases and call the function with each pair of date and time + for (let testCase of testCases) { + // Call the function and store the result + const result = combineDateAndTime(testCase.date, testCase.time); + // Assert that the result is equal to the expected new date object + expect(result.getTime()).toEqual(testCase.expected.getTime()); + } + }); + it("addMinutes should add given time to date.", () => { + // Define some sample inputs and their expected outputs + const testCases = [ + { + date: new Date(2023, 9, 12, 12, 0), + minutes: 15, + expected: new Date(2023, 9, 12, 12, 15), + }, + { + date: new Date(2023, 0, 1, 0, 0), + minutes: -30, + expected: new Date(2022, 11, 31, 23, 30), + }, + { + date: new Date(2022, 11, 31, 23, 59), + minutes: 1, + expected: new Date(2023, 0, 1, 0, 0), + }, + { + date: new Date(2023, 1, 28, 13, 45), + minutes: 60, + expected: new Date(2023, 1, 28, 14, 45), + }, + { + date: new Date(2023, 2, 1, 1, 23), + minutes: -1440, + expected: new Date(2023, 1, 28, 1, 23), + }, + ]; + // Loop through the test cases and call the function with each pair of date and minutes + for (let testCase of testCases) { + // Call the function and store the result + const result = addMinutes(testCase.date, testCase.minutes); + // Assert that the result is equal to the expected modified date object + expect(result.getTime()).toEqual(testCase.expected.getTime()); + } + }); + it("shortTimeString should return time in short format.", () => { + // Define some sample dates and their expected short time strings + const testCases = [ + { date: new Date(2023, 9, 12, 12, 0), expected: "12:00 PM" }, + { date: new Date(2023, 0, 1, 0, 0), expected: "12:00 AM" }, + { date: new Date(2022, 11, 31, 23, 59), expected: "11:59 PM" }, + { date: new Date(2023, 1, 28, 13, 45), expected: "1:45 PM" }, + { date: new Date(2023, 2, 1, 1, 23), expected: "1:23 AM" }, + ]; + // Loop through the test cases and call the function with each date + for (let testCase of testCases) { + // Call the function and store the result + const result = shortTimeString(testCase.date); + // Assert that the result is equal to the expected short time string + expect(result).toEqual(testCase.expected); + } + }); +}); diff --git a/src/layouts/add-to-calendar/add-to-calendar.spec.js b/src/layouts/add-to-calendar/add-to-calendar.spec.js index 1bee62c2c..1e3e5ae4e 100644 --- a/src/layouts/add-to-calendar/add-to-calendar.spec.js +++ b/src/layouts/add-to-calendar/add-to-calendar.spec.js @@ -1,5 +1,7 @@ // Components import addToCalendar from "@/layouts/add-to-calendar/add-to-calendar.vue"; +import { calendarOptions } from "@/constants/calendar-options"; +import { AppointmentTypeStrings, RouteCodeFlags } from "@/constants/schedule-constants"; // Supporting Files import { shallowMount } from "@vue/test-utils"; @@ -75,6 +77,160 @@ describe("Add-to-calendar methods...", () => { //Assert expect(wrapper.vm.$refs.calendarModalQuestion.openModal).toBeCalled(); }); + test("serviceType should return 'replacement and recalibration' when isRepair and funnelHasRecalibrationPart true.", () => { + //Arrange + store.getters.order.damage.isRepair = true; + store.getters.funnelHasRecalibrationPart = true; + const { wrapper } = setupMocks({}); + + //Act + const testValue = wrapper.vm.serviceType(); + + //Assert + expect(testValue).toEqual("replacement and recalibration"); + }); + test("serviceType should return 'replacement' when isRepair is true and funnelHasRecalibrationPart is false.", () => { + //Arrange + store.getters.order.damage.isRepair = true; + store.getters.funnelHasRecalibrationPart = false; + const { wrapper } = setupMocks({}); + + //Act + const testValue = wrapper.vm.serviceType(); + + //Assert + expect(testValue).toEqual("replacement"); + }); + test("serviceType should return 'repair' when isRepair is false.", () => { + //Arrange + store.getters.order.damage.isRepair = false; + const { wrapper } = setupMocks({}); + + //Act + const testValue = wrapper.vm.serviceType(); + + //Assert + expect(testValue).toEqual("repair"); + }); + test("getCalendarData should return expected model value.", () => { + //Arrange + const type = calendarOptions.OUTLOOKCOM; + const { wrapper } = setupMocks({}); + + //Act + const testValue = wrapper.vm.getCalendarData(type); + + //Assert + expect(testValue.name).toEqual(calendarOptions.OUTLOOKCOM); + }); + test("getappointmentData should return expected model value for appointmentType mobile.", () => { + //Arrange + store.getters.order.serviceLocation.appointmentType = AppointmentTypeStrings.MOBILE; + store.getters.order.damage.isRepair = true; + store.getters.funnelHasRecalibrationPart = true; + const { wrapper } = setupMocks({}); + + //Act + const testValue = wrapper.vm.getappointmentData(); + + //Assert + expect(testValue.Subject).toEqual("Safelite replacement and recalibration appointment"); + }); + test("getappointmentData should return expected model value for appointmentType DROP_OFF and OVERNIGHT_DROP_OFF.", () => { + //Arrange + store.getters.order.serviceLocation.appointmentType = AppointmentTypeStrings.DROP_OFF; + store.getters.order.schedule.routeCode = RouteCodeFlags.OVERNIGHT_DROP_OFF; + const { wrapper } = setupMocks({}); + + //Act + const testValue = wrapper.vm.getappointmentData(); + + //Assert + expect(testValue.Subject).toEqual("Drop off your vehicle by 5:30 PM"); + }); + test("getappointmentData should return expected model value for appointmentType DROP_OFF and ALL_DAY_DROP_OFF and isSameDayDropOff.", () => { + //Arrange + store.getters.order.serviceLocation.appointmentType = AppointmentTypeStrings.DROP_OFF; + store.getters.order.schedule.routeCode = RouteCodeFlags.ALL_DAY_DROP_OFF; + store.getters.order.schedule.date = new Date().toISOString().split("T")[0]; + const { wrapper } = setupMocks({}); + + //Act + const testValue = wrapper.vm.getappointmentData(); + + //Assert + expect(testValue.Subject).toEqual("Drop off your vehicle in the next 30 - 60 minutes"); + }); + test("getappointmentData should return expected model value for appointmentType DROP_OFF and ALL_DAY_DROP_OFF.", () => { + //Arrange + store.getters.order.serviceLocation.appointmentType = AppointmentTypeStrings.DROP_OFF; + store.getters.order.schedule.routeCode = RouteCodeFlags.ALL_DAY_DROP_OFF; + const { wrapper } = setupMocks({}); + + //Act + const testValue = wrapper.vm.getappointmentData(); + + //Assert + expect(testValue.Subject).toEqual("Drop off your vehicle between 9:00 AM - 11:00 AM"); + }); + test("getappointmentData should return expected model value for appointmentType DROP_OFF.", () => { + //Arrange + store.getters.order.serviceLocation.appointmentType = AppointmentTypeStrings.DROP_OFF; + store.getters.order.damage.isRepair = false; + const { wrapper } = setupMocks({}); + + //Act + const testValue = wrapper.vm.getappointmentData(); + + //Assert + expect(testValue.Subject).toEqual("Safelite repair appointment"); + }); + test("getappointmentData should return expected model value for appointmentType IN_SHOP.", () => { + //Arrange + store.getters.order.serviceLocation.appointmentType = AppointmentTypeStrings.IN_SHOP; + store.getters.order.damage.isRepair = false; + const { wrapper } = setupMocks({}); + + //Act + const testValue = wrapper.vm.getappointmentData(); + + //Assert + expect(testValue.Subject).toEqual("Safelite repair appointment"); + }); + test("isSameDayDropOff should return true for current schedule date.", () => { + //Arrange + store.getters.order.schedule.date = new Date().toISOString().split("T")[0]; + const { wrapper } = setupMocks({}); + + //Act + const testValue = wrapper.vm.isSameDayDropOff(); + + //Assert + expect(testValue).toEqual(true); + }); + test("setCalendarAppointment should call getAppointment method for iCAL and Outlook.", () => { + //Arrange + const newValue = { name: calendarOptions.OUTLOOK }; + const { wrapper } = setupMocks({}); + wrapper.vm.getAppointment = jest.fn(); + //Act + wrapper.vm.setCalendarAppointment(newValue); + + //Assert + expect(wrapper.vm.getAppointment).toHaveBeenCalled(); + }); + test("setCalendarAppointment should call window.open for Google, yahoo and Outlook.com.", () => { + //Arrange + const newValue = { name: calendarOptions.GOOGLE }; + const { wrapper } = setupMocks({}); + window.open = jest.fn(); + + //Act + wrapper.vm.setCalendarAppointment(newValue); + + //Assert + expect(window.open).toHaveBeenCalledTimes(1); + }); }); function setupMocks({ customMountOptions }) { diff --git a/src/layouts/confirmation/confirmation.spec.js b/src/layouts/confirmation/confirmation.spec.js index c60b19c26..4bef5f8a3 100644 --- a/src/layouts/confirmation/confirmation.spec.js +++ b/src/layouts/confirmation/confirmation.spec.js @@ -1,5 +1,7 @@ // Components import confirmation from "@/layouts/confirmation/confirmation.vue"; +import { AppointmentTypeStrings } from "@/constants/schedule-constants"; +import { applicationConfig } from "@/constants/application-config.js"; // Supporting Files import { shallowMount } from "@vue/test-utils"; @@ -12,14 +14,14 @@ import router from "@/router"; jest.mock("@/helpers/layout-helper.js", () => ({ settleAllPromises: jest.fn(), })); - +var wordingText = "wording Text {custom:ADDRESS}"; beforeEach(() => { jest.restoreAllMocks(); jest.clearAllMocks(); store.getters = { order: { schedule: { - date: "2019-01-01", + date: "2023-01-01", startTime: "09:00", endTime: "10:00", routeCode: "000", @@ -33,9 +35,9 @@ beforeEach(() => { supportingItems: [], }, serviceLocation: { - address: "", - address2: null, - city: "", + address: "test", + address2: "123", + city: "test", state: "AZ", appointmentType: "Inshop", zipCode: "12345", @@ -112,8 +114,188 @@ describe("confirmation.vue", () => { expect(window.location.assign).toHaveBeenCalled(); }); }); +describe("computed properties...", () => { + test("ScheduleDateFormatted should return date in expected format.", () => { + //Arrange + const { wrapper } = setupMocks({}); + + // Act + const testValue = wrapper.vm.ScheduleDateFormatted; + + // Assert + expect(testValue).toEqual("Sunday, January 1"); + }); + test("ScheduleTimeFormatted should return mobile time in expected format.", () => { + //Arrange + store.getters.order.serviceLocation.appointmentType = AppointmentTypeStrings.MOBILE; + store.getters.order.schedule.startTime = "09:00"; + store.getters.order.schedule.endTime = "11:00"; + const { wrapper } = setupMocks({}); + + // Act + const testValue = wrapper.vm.ScheduleTimeFormatted; + + // Assert + expect(testValue).toEqual("Between 9 AM - 11 AM"); + }); + test("ScheduleTimeFormatted should return DROP_OFF time in expected format.", () => { + //Arrange + store.getters.order.serviceLocation.appointmentType = AppointmentTypeStrings.DROP_OFF; + store.getters.order.schedule.startTime = "09:00"; + store.getters.order.schedule.endTime = "11:00"; + const { wrapper } = setupMocks({}); + + // Act + const testValue = wrapper.vm.ScheduleTimeFormatted; + + // Assert + expect(testValue).toEqual("Drop off before 9:30 AM"); + }); + test("ScheduleTimeFormatted should return Inshop time in expected format.", () => { + //Arrange + store.getters.order.serviceLocation.appointmentType = AppointmentTypeStrings.IN_SHOP; + store.getters.order.schedule.startTime = "09:00"; + store.getters.order.schedule.endTime = "11:00"; + const { wrapper } = setupMocks({}); + + // Act + const testValue = wrapper.vm.ScheduleTimeFormatted; + + // Assert + expect(testValue).toEqual("at 9:00 AM"); + }); + test("AppointmentWordingText should return mobile text in expected format.", () => { + //Arrange + store.getters.order.serviceLocation.appointmentType = AppointmentTypeStrings.MOBILE; + + const { wrapper } = setupMocks({}); + // Act + const testValue = wrapper.vm.AppointmentWordingText; + + // Assert + expect(testValue).toEqual("wording Text 123, test,
test, AZ 12345"); + }); + test("AppointmentWordingText should return DROP_OFF text in expected format.", () => { + //Arrange + store.getters.order.serviceLocation.appointmentType = AppointmentTypeStrings.DROP_OFF; + + const { wrapper } = setupMocks({}); + + // Act + const testValue = wrapper.vm.AppointmentWordingText; + + // Assert + expect(testValue).toEqual("wording Text test1,
test, AZ 12345"); + }); + test("AppointmentWordingText should return IN_SHOP text in expected format.", () => { + //Arrange + store.getters.order.serviceLocation.appointmentType = AppointmentTypeStrings.IN_SHOP; + + const { wrapper } = setupMocks({}); + + // Act + const testValue = wrapper.vm.AppointmentWordingText; + + // Assert + expect(testValue).toEqual("wording Text test1,
test, AZ 12345"); + }); + test("ConfirmationEmailText should return text in expected format.", () => { + //Arrange + wordingText = "{custom:MY_ACCOUNT_URL}"; + const { wrapper } = setupMocks({}); + // Act + const testValue = wrapper.vm.ConfirmationEmailText; + + // Assert + expect(testValue).toEqual(applicationConfig.MY_ACCOUNT); + }); + test("ScheduleDate should return date in expected format.", () => { + //Arrange + const { wrapper } = setupMocks({}); + + // Act + const testValue = wrapper.vm.ScheduleDate; + + // Assert + expect(testValue).toEqual("2023-01-01"); + }); + test("ScheduleStartTime should return time in expected format.", () => { + //Arrange + const { wrapper } = setupMocks({}); + + // Act + const testValue = wrapper.vm.ScheduleStartTime; + + // Assert + expect(testValue).toEqual("09:00"); + }); + test("ScheduleEndTime should return time in expected format.", () => { + //Arrange + const { wrapper } = setupMocks({}); + + // Act + const testValue = wrapper.vm.ScheduleEndTime; + + // Assert + expect(testValue).toEqual("10:00"); + }); + test("InShopWordingText should return text in expected format.", () => { + //Arrange + wordingText = "InShopWordingText format"; + const { wrapper } = setupMocks({}); + + // Act + const testValue = wrapper.vm.InShopWordingText; + + // Assert + expect(testValue).toEqual(wordingText); + }); + test("MobileWordingText should return text in expected format.", () => { + //Arrange + wordingText = "MobileWordingText format"; + const { wrapper } = setupMocks({}); + + // Act + const testValue = wrapper.vm.MobileWordingText; + + // Assert + expect(testValue).toEqual(wordingText); + }); + test("DropOffWordingText should return text in expected format.", () => { + //Arrange + wordingText = "DropOffWordingText format"; + const { wrapper } = setupMocks({}); + + // Act + const testValue = wrapper.vm.DropOffWordingText; + + // Assert + expect(testValue).toEqual(wordingText); + }); + test("ServiceLocationFullAddress should return text in expected format.", () => { + //Arrange + + const { wrapper } = setupMocks({}); + + // Act + const testValue = wrapper.vm.ServiceLocationFullAddress; + + // Assert + expect(testValue).toEqual("123, test,
test, AZ 12345"); + }); + test("ProviderFullAddress should return text in expected format.", () => { + //Arrange + + const { wrapper } = setupMocks({}); + + // Act + const testValue = wrapper.vm.ProviderFullAddress; + + // Assert + expect(testValue).toEqual("test1,
test, AZ 12345"); + }); +}); -const wordingText = "wording Text"; function setupMocks({ customMountOptions }) { const mountOptions = getMountOptions({ ...customMountOptions,