import { shallowMount, flushPromises } from "@vue/test-utils";
import { getMountOptions } from "@/helpers/unit-test-helper.js";
import timeSlotModalQuestion from "@/layouts/schedule/time-slot-modal-question/time-slot-modal-question.vue";
import store from "@/store";

import {
    RouteCodeFlags,
    PREMIUM_TIME_SLOT_ID_FLAG,
    PREMIUM_FEE_PART_TYPE,
} from "@/constants/schedule-constants";

describe("time-slot-modal-question.vue", () => {
    const timeSlotsForSelectedDate = {
        date: "2023-09-02",
        timeSlots: [
            {
                id: "03335-01820-S-B*20334*8 AM",
                startTime: "08:00",
                endTime: "09:00",
                offerPremium: false,
            },
            {
                id: "03335-01820-S-B*20334*830 AM",
                startTime: "08:30",
                endTime: "09:30",
                offerPremium: false,
            },
            {
                id: "03335-01820-S-B*20334*9 AM",
                startTime: "09:00",
                endTime: "10:00",
                offerPremium: false,
            },
            {
                id: "03335-01820-S-B*20334*930 AM",
                startTime: "09:30",
                endTime: "10:30",
                offerPremium: false,
            },
            {
                id: "03335-01820-S-B*20334*10 AM",
                startTime: "10:00",
                endTime: "11:00",
                offerPremium: false,
            },
            {
                id: "03335-01820-S-B*20334*1030 AM",
                startTime: "10:30",
                endTime: "11:30",
                offerPremium: false,
            },
        ],
    };

    test("When selected time slot is changed, a correctly formatted selectedTimeSlot should be emitted", async () => {
        //Arrange
        const date = "2023-09-02";
        const routeCode = "03335-01820-S-B*20334*830 AM";
        const startTime = "08:30";
        const endTime = "09:30";
        const jobMaxMinutes = 100;
        const jobMinMinutes = 50;
        const expectedEmit = [
            [
                {
                    timeSlot: {
                        date: date,
                        routeCode: routeCode,
                        startTime: startTime,
                        endTime: endTime,
                        jobMaxMinutes: jobMaxMinutes.toString(),
                        jobMinMinutes: jobMinMinutes.toString(),
                    },
                    isPremiumAppointment: false,
                },
            ],
        ];

        const { wrapper } = setupMocks({
            customMountOptions: {
                propsData: {
                    estimatedServiceMinutesMaximum: jobMaxMinutes,
                    estimatedServiceMinutesMinimum: jobMinMinutes,
                    timeSlotsForSelectedDate: timeSlotsForSelectedDate,
                },
            },
        });

        wrapper.vm.$refs.timeSlots.closeModal = jest.fn();

        await wrapper.setData({
            selectedRouteCode: routeCode,
        });

        //Act
        wrapper.vm.setSelectedTimeSlot();

        //Assert
        expect(wrapper.emitted()["update:modelValue"]).toEqual(expectedEmit);
        expect(wrapper.emitted()).toHaveProperty("TimeSlotSelected");
    });
});

describe("time-slot-modal-question.vue Supplemental information", () => {
    test("The correct supplemental information should be obtained from CMS - Mobile - Not Premium ", async () => {
        //Arrange
        const mobileCmsWidgetName = "MobileNotPremium";
        const { wrapper } = setupMocks({
            customMountOptions: {
                propsData: {
                    modelValue: { routeCode: "test" },
                    appointmentType: "Mobile",
                    mobileCmsWidgetName: mobileCmsWidgetName,
                },
            },
        });

        //Assert
        expect(wrapper.vm.supplementalInformationBlock).toEqual(
            mockCmsContent[mobileCmsWidgetName]["BodyText"]
        );
    });

    test("The correct supplemental information should be obtained from CMS - Mobile - Premium", async () => {
        //Arrange
        const mobileCmsWidgetName = "MobilePremium";
        const { wrapper } = setupMocks({
            customMountOptions: {
                propsData: {
                    modelValue: { routeCode: "test" + PREMIUM_TIME_SLOT_ID_FLAG },
                    appointmentType: "Mobile",
                    mobileCmsWidgetName: mobileCmsWidgetName,
                },
            },
        });

        //Assert
        expect(wrapper.vm.supplementalInformationBlock).toEqual(
            mockCmsContent[mobileCmsWidgetName]["BodyText"]
        );
    });

    test("No supplemental information should be obtained from CMS - Inshop", async () => {
        //Arrange
        const inshopWidgetName = "Inshop";
        const { wrapper } = setupMocks({
            customMountOptions: {
                propsData: {
                    modelValue: { routeCode: "test" },
                    appointmentType: "Inshop",
                    cmsWidgetName: inshopWidgetName,
                },
            },
        });
        //Assert
        expect(wrapper.vm.supplementalInformationBlock).toBeNull();
    });

    test("No supplemental information should be obtained from CMS - Drop off, nothing selected", async () => {
        //Arrange
        const dropOffWidgetName = "Dropoff";
        const { wrapper } = setupMocks({
            customMountOptions: {
                propsData: {
                    modelValue: null,
                    appointmentType: "Dropoff",
                    cmsWidgetName: dropOffWidgetName,
                },
            },
        });
        //Assert
        expect(wrapper.vm.supplementalInformationBlock).toBeNull();
    });

    test("Correct supplemental information should be retrieved, Dropoff regular", async () => {
        //Arrange
        const dropOffWidgetName = "Dropoff";
        const modelValue = {
            timeSlot: {
                routeCode: `test${RouteCodeFlags.ALL_DAY_DROP_OFF}`,
                date: null,
                startTime: null,
                endTime: null,
                jobMaxMinutes: null,
                jobMinMinutes: null,
            },
            isPremiumAppointment: null,
        };

        const { wrapper } = setupMocks({
            customMountOptions: {
                propsData: {
                    modelValue: modelValue,
                    appointmentType: "Dropoff",
                    dropoffCmsWidgetName: dropOffWidgetName,
                },
            },
        });

        //Assert
        expect(wrapper.vm.supplementalInformationBlock).toEqual(
            mockCmsContent[dropOffWidgetName]["BodyText"]
        );
    });

    test("Correct supplemental information should be retrieved, Dropoff Overnight", async () => {
        //Arrange
        const overnightDropOffCmsWidgetName = "Overnight";
        const modelValue = {
            timeSlot: {
                routeCode: `test${RouteCodeFlags.OVERNIGHT_DROP_OFF}`,
                date: null,
                startTime: null,
                endTime: null,
                jobMaxMinutes: null,
                jobMinMinutes: null,
            },
            isPremiumAppointment: null,
        };

        const { wrapper } = setupMocks({
            customMountOptions: {
                propsData: {
                    modelValue: modelValue,
                    appointmentType: "Dropoff",
                    overnightDropOffCmsWidgetName: overnightDropOffCmsWidgetName,
                },
            },
        });

        //Assert
        expect(wrapper.vm.supplementalInformationBlock).toEqual(
            mockCmsContent[overnightDropOffCmsWidgetName]["BodyText"]
        );
    });

    test("Correct supplemental information should be retrieved, Dropoff Sameday", async () => {
        //Arrange
        const sameDayDropOffCmsWidgetName = "Sameday";
        const date = new Date().toISOString().split("T")[0];
        const timeSlotId = "testRouteCodeId";
        const startTime = "8:00 AM";
        const endTime = "8:30 AM";
        const jobMaxMinutes = 100;
        const jobMinMinutes = 50;
        const modelValue = {
            timeSlot: {
                routeCode: `test${RouteCodeFlags.ALL_DAY_DROP_OFF}`,
                date: null,
                startTime: null,
                endTime: null,
                jobMaxMinutes: null,
                jobMinMinutes: null,
            },
            isPremiumAppointment: null,
        };

        const { wrapper } = setupMocks({
            customMountOptions: {
                propsData: {
                    estimatedServiceMinutesMaximum: jobMaxMinutes,
                    estimatedServiceMinutesMinimum: jobMinMinutes,
                    timeSlotsForSelectedDate: {
                        date: date,
                        timeSlots: [
                            {
                                id: timeSlotId,
                                startTime: startTime,
                                endTime: endTime,
                            },
                        ],
                    },
                    modelValue: modelValue,
                    appointmentType: "Dropoff",
                    sameDayDropOffCmsWidgetName: sameDayDropOffCmsWidgetName,
                },
            },
        });

        //Assert
        expect(wrapper.vm.supplementalInformationBlock).toEqual(
            mockCmsContent[sameDayDropOffCmsWidgetName]["BodyText"]
        );
    });
});

describe("time-slot-modal-list-button-question.vue Disclaimer", () => {
    test("The correct disclaimer information should be obtained from CMS - Dropoff - Sameday ", async () => {
        //Arrange
        const sameDayDropOffCmsWidgetName = "Sameday";
        const date = new Date().toISOString().split("T")[0];
        const timeSlotId = "testRouteCodeId";
        const startTime = "8:00 AM";
        const endTime = "8:30 AM";
        const jobMaxMinutes = 100;
        const jobMinMinutes = 50;

        const modelValue = {
            timeSlot: {
                routeCode: `Test${RouteCodeFlags.ALL_DAY_DROP_OFF}`,
                date: null,
                startTime: null,
                endTime: null,
                jobMaxMinutes: null,
                jobMinMinutes: null,
            },
            isPremiumAppointment: null,
        };

        const { wrapper } = setupMocks({
            customMountOptions: {
                propsData: {
                    estimatedServiceMinutesMaximum: jobMaxMinutes,
                    estimatedServiceMinutesMinimum: jobMinMinutes,
                    timeSlotsForSelectedDate: {
                        date: date,
                        timeSlots: [
                            {
                                id: timeSlotId,
                                startTime: startTime,
                                endTime: endTime,
                            },
                        ],
                    },
                    modelValue: modelValue,
                    appointmentType: "Dropoff",
                    sameDayDropOffCmsWidgetName: sameDayDropOffCmsWidgetName,
                },
            },
        });

        //Assert
        expect(wrapper.vm.disclaimerTextBlockCopy).toEqual(
            mockCmsContent[sameDayDropOffCmsWidgetName]["FooterText"]
        );
    });

    test("Correct disclaimer information should be retrieved, Dropoff regular", async () => {
        //Arrange
        const dropOffWidgetName = "Dropoff";
        const modelValue = {
            timeSlot: {
                routeCode: `Test${RouteCodeFlags.ALL_DAY_DROP_OFF}`,
                date: null,
                startTime: null,
                endTime: null,
                jobMaxMinutes: null,
                jobMinMinutes: null,
            },
            isPremiumAppointment: null,
        };

        const { wrapper } = setupMocks({
            customMountOptions: {
                propsData: {
                    modelValue: modelValue,
                    appointmentType: "Dropoff",
                    dropoffCmsWidgetName: dropOffWidgetName,
                },
            },
        });

        //Assert
        expect(wrapper.vm.disclaimerTextBlockCopy).toEqual(
            mockCmsContent[dropOffWidgetName]["FooterText"]
        );
    });

    test("Correct disclaimer information should be retrieved, Dropoff overnight", async () => {
        //Arrange
        const overnightDropOffCmsWidgetName = "Overnight";
        const modelValue = {
            timeSlot: {
                routeCode: `Test${RouteCodeFlags.OVERNIGHT_DROP_OFF}`,
                date: null,
                startTime: null,
                endTime: null,
                jobMaxMinutes: null,
                jobMinMinutes: null,
            },
            isPremiumAppointment: null,
        };

        const { wrapper } = setupMocks({
            customMountOptions: {
                propsData: {
                    modelValue: modelValue,
                    appointmentType: "Dropoff",
                    overnightDropOffCmsWidgetName: overnightDropOffCmsWidgetName,
                },
            },
        });

        //Assert
        expect(wrapper.vm.disclaimerTextBlockCopy).toEqual(
            mockCmsContent[overnightDropOffCmsWidgetName]["FooterText"]
        );
    });

    test("No disclaimer information should be retrieved, non-dropoff", async () => {
        //Arrange
        const inshopWidgetName = "Inshop";
        const modelValue = {
            timeSlot: {
                routeCode: `test`,
                date: null,
                startTime: null,
                endTime: null,
                jobMaxMinutes: null,
                jobMinMinutes: null,
            },
            isPremiumAppointment: null,
        };

        const { wrapper } = setupMocks({
            customMountOptions: {
                propsData: {
                    modelValue: modelValue,
                    appointmentType: "Inshop",
                    cmsWidgetName: inshopWidgetName,
                },
            },
        });
        //Assert
        expect(wrapper.vm.disclaimerTextBlockCopy).toBeNull();
    });
});

describe("time-slot-modal-question.vue Duration", () => {
    test("The correct duration information should be displayed - Dropoff - Sameday ", async () => {
        //Arrange
        const sameDayDropOffCmsWidgetName = "Sameday";
        const date = new Date().toISOString().split("T")[0];
        const timeSlotId = "testRouteCodeId";
        const startTime = "8:00 AM";
        const endTime = "8:30 AM";
        const jobMaxMinutes = 100;
        const jobMinMinutes = 50;

        const modelValue = {
            timeSlot: {
                routeCode: `test` + RouteCodeFlags.ALL_DAY_DROP_OFF,
                date: null,
                startTime: null,
                endTime: null,
                jobMaxMinutes: null,
                jobMinMinutes: null,
            },
            isPremiumAppointment: null,
        };

        const { wrapper } = setupMocks({
            customMountOptions: {
                propsData: {
                    estimatedServiceMinutesMaximum: jobMaxMinutes,
                    estimatedServiceMinutesMinimum: jobMinMinutes,
                    timeSlotsForSelectedDate: {
                        date: date,
                        timeSlots: [
                            {
                                id: timeSlotId,
                                startTime: startTime,
                                endTime: endTime,
                            },
                        ],
                    },
                    modelValue: modelValue,
                    appointmentType: "Dropoff",
                    sameDayDropOffCmsWidgetName: sameDayDropOffCmsWidgetName,
                },
            },
        });

        //Assert
        expect(wrapper.vm.durationTextBlockCopy).toEqual(
            mockCmsContent[sameDayDropOffCmsWidgetName]["SubheaderText"]
        );
    });

    test("Correct duration information should be retrieved, Dropoff overnight", async () => {
        //Arrange
        const overnightDropOffCmsWidgetName = "Overnight";

        const modelValue = {
            timeSlot: {
                routeCode: `test` + RouteCodeFlags.OVERNIGHT_DROP_OFF,
                date: null,
                startTime: null,
                endTime: null,
                jobMaxMinutes: null,
                jobMinMinutes: null,
            },
            isPremiumAppointment: null,
        };

        const { wrapper } = setupMocks({
            customMountOptions: {
                propsData: {
                    modelValue: modelValue,
                    appointmentType: "Dropoff",
                    overnightDropOffCmsWidgetName: overnightDropOffCmsWidgetName,
                },
            },
        });

        //Assert
        expect(wrapper.vm.durationTextBlockCopy).toEqual(
            mockCmsContent[overnightDropOffCmsWidgetName]["SubheaderText"]
        );
    });

    test("Correct duration information should be retrieved, Dropoff", async () => {
        //Arrange
        const dropoffCmsWidgetName = "Dropoff";

        const modelValue = {
            timeSlot: {
                routeCode: `test` + RouteCodeFlags.ALL_DAY_DROP_OFF,
                date: null,
                startTime: null,
                endTime: null,
                jobMaxMinutes: null,
                jobMinMinutes: null,
            },
            isPremiumAppointment: null,
        };

        const { wrapper } = setupMocks({
            customMountOptions: {
                propsData: {
                    modelValue: modelValue,
                    appointmentType: "Dropoff",
                    dropoffCmsWidgetName: dropoffCmsWidgetName,
                },
            },
        });
        //Assert
        expect(wrapper.vm.durationTextBlockCopy).toEqual(
            mockCmsContent[dropoffCmsWidgetName]["SubheaderText"]
        );
    });

    test("Correct duration information should be retrieved, Inshop - convert to hours", async () => {
        //Arrange
        const cmsWidgetName = "Inshop";

        const modelValue = {
            timeSlot: {
                routeCode: `test`,
                date: null,
                startTime: null,
                endTime: null,
            },
            isPremiumAppointment: null,
        };

        const { wrapper } = setupMocks({
            customMountOptions: {
                propsData: {
                    estimatedServiceMinutesMaximum: 180,
                    estimatedServiceMinutesMinimum: 120,
                    modelValue: modelValue,
                    appointmentType: "Inshop",
                    cmsWidgetName: cmsWidgetName,
                },
            },
        });

        //Assert
        expect(wrapper.vm.durationTextBlockCopy).toEqual(
            mockCmsContent[cmsWidgetName]["SubheaderText"] + " 2 - 3 hours"
        );
    });

    test("Correct duration information should be retrieved, Inshop - convert to minutes", async () => {
        //Arrange
        const cmsWidgetName = "Inshop";
        const { wrapper } = setupMocks({
            customMountOptions: {
                propsData: {
                    estimatedServiceMinutesMaximum: 90,
                    estimatedServiceMinutesMinimum: 60,
                    modelValue: { routeCode: "Test" },
                    appointmentType: "Inshop",
                    cmsWidgetName: cmsWidgetName,
                },
            },
        });
        //Assert
        expect(wrapper.vm.durationTextBlockCopy).toEqual(
            mockCmsContent[cmsWidgetName]["SubheaderText"] + " 60 - 90 minutes"
        );
    });

    test("Correct duration information should be retrieved, Inshop - min = maximum time", async () => {
        //Arrange
        const cmsWidgetName = "Inshop";
        const { wrapper } = setupMocks({
            customMountOptions: {
                propsData: {
                    estimatedServiceMinutesMaximum: 240,
                    estimatedServiceMinutesMinimum: 240,
                    modelValue: { routeCode: "Test" },
                    appointmentType: "Inshop",
                    cmsWidgetName: cmsWidgetName,
                },
            },
        });
        //Assert
        expect(wrapper.vm.durationTextBlockCopy).toEqual(
            mockCmsContent[cmsWidgetName]["SubheaderText"] + " 4 hours"
        );
    });

    test("No duration information should be displayed, Mobile", async () => {
        //Arrange
        const mobileCmsWidgetName = "Mobile";
        const { wrapper } = setupMocks({
            customMountOptions: {
                propsData: {
                    estimatedServiceMinutesMaximum: 240,
                    estimatedServiceMinutesMinimum: 240,
                    modelValue: { routeCode: "Test" },
                    appointmentType: "Mobile",
                    mobileCmsWidgetName: mobileCmsWidgetName,
                },
            },
        });
        //Assert
        expect(wrapper.vm.durationTextBlockCopy).toBeNull();
    });
});

describe("time-slot-modal-list-button-question.vue Available Timeslots", () => {
    test("Available Timeslots should be formatted correctly - Dropoff - Sameday ", async () => {
        //Arrange
        const sameDayDropOffCmsWidgetName = "Sameday";
        const date = new Date().toISOString().split("T")[0];
        const timeSlotId = "testRouteCodeId";
        const startTime = "8:00 AM";
        const endTime = "8:30 AM";
        const jobMaxMinutes = 100;
        const jobMinMinutes = 50;

        const { wrapper } = setupMocks({
            customMountOptions: {
                propsData: {
                    estimatedServiceMinutesMaximum: jobMaxMinutes,
                    estimatedServiceMinutesMinimum: jobMinMinutes,
                    timeSlotsForSelectedDate: {
                        date: date,
                        timeSlots: [
                            {
                                id: timeSlotId,
                                startTime: startTime,
                                endTime: endTime,
                            },
                        ],
                    },
                    appointmentType: "Dropoff",
                    sameDayDropOffCmsWidgetName: sameDayDropOffCmsWidgetName,
                },
            },
        });

        //Assert
        const expectedTimeSlotObject = {
            buttonLabel: mockCmsContent[sameDayDropOffCmsWidgetName]["HeaderText"],
            value: timeSlotId,
        };
        expect(wrapper.vm.availableTimeSlots[0]).toEqual(expectedTimeSlotObject);
    });

    test("Available Timeslots should be formatted correctly - Dropoff - Overnight ", async () => {
        //Arrange
        const overnightDropOffCmsWidgetName = "Overnight";
        const date = new Date().toISOString().split("T")[0];
        const timeSlotId = "testRouteCodeId" + RouteCodeFlags.OVERNIGHT_DROP_OFF;
        const startTime = "8:00 AM";
        const endTime = "8:30 AM";
        const jobMaxMinutes = 100;
        const jobMinMinutes = 50;

        const { wrapper } = setupMocks({
            customMountOptions: {
                propsData: {
                    estimatedServiceMinutesMaximum: jobMaxMinutes,
                    estimatedServiceMinutesMinimum: jobMinMinutes,
                    timeSlotsForSelectedDate: {
                        date: date,
                        timeSlots: [
                            {
                                id: timeSlotId,
                                startTime: startTime,
                                endTime: endTime,
                            },
                        ],
                    },
                    appointmentType: "Dropoff",
                    overnightDropOffCmsWidgetName: overnightDropOffCmsWidgetName,
                },
            },
        });

        //Assert
        const expectedTimeSlotObject = {
            buttonLabel: mockCmsContent[overnightDropOffCmsWidgetName]["HeaderText"],
            value: timeSlotId,
        };
        expect(wrapper.vm.availableTimeSlots[0]).toEqual(expectedTimeSlotObject);
    });

    test("Available Timeslots should be formatted correctly - Dropoff", async () => {
        //Arrange
        const dropoffCmsWidgetName = "Dropoff";
        const date = "2020-01-01";
        const timeSlotId = "testRouteCodeId" + RouteCodeFlags.ALL_DAY_DROP_OFF;
        const startTime = "8:00 AM";
        const endTime = "8:30 AM";
        const jobMaxMinutes = 100;
        const jobMinMinutes = 50;

        const { wrapper } = setupMocks({
            customMountOptions: {
                propsData: {
                    estimatedServiceMinutesMaximum: jobMaxMinutes,
                    estimatedServiceMinutesMinimum: jobMinMinutes,
                    timeSlotsForSelectedDate: {
                        date: date,
                        timeSlots: [
                            {
                                id: timeSlotId,
                                startTime: startTime,
                                endTime: endTime,
                            },
                        ],
                    },
                    appointmentType: "Dropoff",
                    dropoffCmsWidgetName: dropoffCmsWidgetName,
                },
            },
        });

        //Assert
        const expectedTimeSlotObject = {
            buttonLabel: mockCmsContent[dropoffCmsWidgetName]["HeaderText"],
            value: timeSlotId,
        };
        expect(wrapper.vm.availableTimeSlots[0]).toEqual(expectedTimeSlotObject);
    });

    test("Available Timeslots should be formatted correctly - Mobile not premium", async () => {
        //Arrange
        const mobileCmsWidgetName = "MobileNotPremium";
        const date = "2020-01-01";
        const timeSlotId = "testRouteCodeId";
        const startTime = "8:00";
        const endTime = "8:30";
        const jobMaxMinutes = 100;
        const jobMinMinutes = 50;

        const { wrapper } = setupMocks({
            customMountOptions: {
                propsData: {
                    estimatedServiceMinutesMaximum: jobMaxMinutes,
                    estimatedServiceMinutesMinimum: jobMinMinutes,
                    timeSlotsForSelectedDate: {
                        date: date,
                        timeSlots: [
                            {
                                id: timeSlotId,
                                startTime: startTime,
                                endTime: endTime,
                            },
                        ],
                    },
                    appointmentType: "Mobile",
                    mobileCmsWidgetName: mobileCmsWidgetName,
                },
            },
        });

        //Assert
        const expectedTimeSlotObject = {
            buttonLabel: startTime + " AM - " + endTime + " AM",
            value: timeSlotId,
        };
        expect(wrapper.vm.availableTimeSlots[0]).toEqual(expectedTimeSlotObject);
    });

    test("Available Timeslots should be formatted correctly - Mobile with premium", async () => {
        //Arrange
        const mobilePremiumCmsWidgetName = "MobilePremium";
        const date = "2020-01-01";
        const timeSlotId = "testRouteCodeId";
        const startTime = "8:00";
        const endTime = "8:30";
        const jobMaxMinutes = 100;
        const jobMinMinutes = 50;

        const { wrapper } = setupMocks({
            customMountOptions: {
                propsData: {
                    estimatedServiceMinutesMaximum: jobMaxMinutes,
                    estimatedServiceMinutesMinimum: jobMinMinutes,
                    premiumAppointmentFee: {
                        partType: PREMIUM_FEE_PART_TYPE,
                    },
                    timeSlotsForSelectedDate: {
                        date: date,
                        timeSlots: [
                            {
                                id: timeSlotId,
                                startTime: startTime,
                                endTime: endTime,
                                offerPremium: true,
                            },
                        ],
                    },
                    appointmentType: "Mobile",
                    mobilePremiumCmsWidgetName: mobilePremiumCmsWidgetName,
                },
            },
        });

        //Assert
        const expectedTimeSlotObject = {
            additionalButtonData: {
                isPremiumAppointment: true,
            },
            buttonLabel: mockCmsContent[mobilePremiumCmsWidgetName]["HeaderText"],
            buttonLabelSubCopy: "+$15.99",
            value: timeSlotId + PREMIUM_TIME_SLOT_ID_FLAG,
        };

        expect(wrapper.vm.availableTimeSlots[0]).toEqual(expectedTimeSlotObject);
    });

    test("Available Timeslots should be formatted correctly - Inshop", async () => {
        //Arrange
        const cmsWidgetName = "Inshop";
        const date = "2020-01-01";
        const timeSlotId = "testRouteCodeId";
        const startTime = "8:00";
        const endTime = "8:30";
        const jobMaxMinutes = 100;
        const jobMinMinutes = 50;

        const { wrapper } = setupMocks({
            customMountOptions: {
                propsData: {
                    estimatedServiceMinutesMaximum: jobMaxMinutes,
                    estimatedServiceMinutesMinimum: jobMinMinutes,
                    timeSlotsForSelectedDate: {
                        date: date,
                        timeSlots: [
                            {
                                id: timeSlotId,
                                startTime: startTime,
                                endTime: endTime,
                            },
                        ],
                    },
                    appointmentType: "Inshop",
                    cmsWidgetName: cmsWidgetName,
                },
            },
        });

        //Assert
        const expectedTimeSlotObject = { buttonLabel: startTime + " AM", value: timeSlotId };
        expect(wrapper.vm.availableTimeSlots[0]).toEqual(expectedTimeSlotObject);
    });
});

const mockCmsContent = {
    MobileNotPremium: {
        BodyText: "Mobile, not premium BodyText",
        FooterText: "Mobile, not premium FooterText",
        SubheaderText: "Mobile, not premium SubheaderText",
        HeaderText: "Mobile, not premium HeaderText",
    },
    MobilePremium: {
        BodyText: "Mobile, with premium BodyText",
        FooterText: "Mobile, with premium FooterText",
        SubheaderText: "Mobile, with premium SubheaderText",
        HeaderText: "Mobile, with premium HeaderText",
    },
    Inshop: {
        BodyText: "Inshop BodyText",
        FooterText: "Inshop FooterText",
        SubheaderText: "Inshop SubheaderText",
        HeaderText: "Inshop HeaderText",
    },
    Dropoff: {
        BodyText: "Dropoff BodyText",
        FooterText: "Dropoff FooterText",
        SubheaderText: "Dropoff SubheaderText",
        HeaderText: "Dropoff HeaderText",
    },
    Overnight: {
        BodyText: "Dropoff Overnight",
        FooterText: "Dropoff, Overnight FooterText",
        SubheaderText: "Dropoff, Overnight SubheaderText",
        HeaderText: "Dropoff, Overnight HeaderText",
    },
    Sameday: {
        BodyText: "Dropoff Sameday",
        FooterText: "Dropoff, Sameday FooterText",
        SubheaderText: "Dropoff, Sameday SubheaderText",
        HeaderText: "Dropoff, Sameday HeaderText",
    },
};

function setupMocks({ customMountOptions }) {
    const mountOptions = getMountOptions({
        ...customMountOptions,
    });
    mountOptions.global.mocks["$store"] = store;
    mountOptions["attachTo"] = document.body;
    mountOptions.mixins = [
        {
            methods: {
                getCmsContent: jest.fn().mockImplementation((widgetName, fieldName) => {
                    if (mockCmsContent[widgetName] && mockCmsContent[widgetName][fieldName])
                        return mockCmsContent[widgetName][fieldName];
                }),
                getTotalLineItemPrice: jest.fn().mockImplementation(() => 15.99),
            },
        },
    ];

    const wrapper = shallowMount(timeSlotModalQuestion, mountOptions);
    wrapper.vm.setCmsContent = jest.fn();
    return { wrapper };
}
