DigitalConsumer.FixMyGlass/src/helpers/page-prerequisites-helper.spec.js

import * as pagePrereqsHelper from "@/helpers/page-prerequisites-helper";
import { AppointmentTypeStrings } from "@/constants/schedule-constants";
import { coverageStatus } from "@/constants/insurance";

jest.mock("@/helpers/debug-log-helper.js", () => ({
    debugLog: jest.fn(),
}));

const { debugLog } = require("@/helpers/debug-log-helper.js");

describe("page-prerequisites-helper.js", () => {
    beforeEach(() => {
        jest.clearAllMocks();
    });

    describe("logPagePrereqsStart", () => {
        test("calls debugLog with source and forceLog when preReqResult is false", () => {
            pagePrereqsHelper.logPagePrereqsStart("payment.vue", false);

            expect(debugLog).toHaveBeenCalledWith(
                "--- payment.vue pagePrereqs start ---",
                null,
                true
            );
        });

        test("calls debugLog with forceLog false when preReqResult is true", () => {
            pagePrereqsHelper.logPagePrereqsStart("payment.vue", true);

            expect(debugLog).toHaveBeenCalledWith(
                "--- payment.vue pagePrereqs start ---",
                null,
                false
            );
        });
    });

    describe("flushPagePrereqsLogs", () => {
        test("calls logPagePrereqsStart, executes logQueue, and logPagePrereqsEnd", () => {
            const logQueue = [jest.fn(), jest.fn()];

            pagePrereqsHelper.flushPagePrereqsLogs("payment.vue", true, logQueue);

            expect(debugLog).toHaveBeenCalledWith(
                "--- payment.vue pagePrereqs start ---",
                null,
                false
            );
            expect(debugLog).toHaveBeenCalledWith(
                "--- payment.vue pagePrereqs end ---",
                null,
                false
            );
            expect(logQueue[0]).toHaveBeenCalled();
            expect(logQueue[1]).toHaveBeenCalled();
        });
    });

    describe("logPagePrereqsEnd", () => {
        test("calls debugLog with source and forceLog when preReqResult is false", () => {
            pagePrereqsHelper.logPagePrereqsEnd("payment-method.vue", false);

            expect(debugLog).toHaveBeenCalledWith(
                "--- payment-method.vue pagePrereqs end ---",
                null,
                true
            );
        });

        test("calls debugLog with forceLog false when preReqResult is true", () => {
            pagePrereqsHelper.logPagePrereqsEnd("payment-method.vue", true);

            expect(debugLog).toHaveBeenCalledWith(
                "--- payment-method.vue pagePrereqs end ---",
                null,
                false
            );
        });
    });

    describe("hasServiceZipInfo", () => {
        test("returns true when zipCode and zipCodeCtu are set", () => {
            const order = {
                serviceLocation: { zipCode: "12345", zipCodeCtu: "12345" },
            };

            const result = pagePrereqsHelper.hasServiceZipInfo(order);

            expect(result).toBe(true);
        });

        test("returns false when zipCode is missing", () => {
            const order = {
                serviceLocation: { zipCode: null, zipCodeCtu: "12345" },
            };

            const result = pagePrereqsHelper.hasServiceZipInfo(order);

            expect(result).toBe(false);
        });

        test("returns false when zipCodeCtu is missing", () => {
            const order = {
                serviceLocation: { zipCode: "12345", zipCodeCtu: null },
            };

            const result = pagePrereqsHelper.hasServiceZipInfo(order);

            expect(result).toBe(false);
        });

        test("returns false when both are empty strings", () => {
            const order = {
                serviceLocation: { zipCode: "", zipCodeCtu: "" },
            };

            const result = pagePrereqsHelper.hasServiceZipInfo(order);

            expect(result).toBe(false);
        });

        test("does not add to logQueue when logQueue is null", () => {
            const order = {
                serviceLocation: { zipCode: "12345", zipCodeCtu: "12345" },
            };

            pagePrereqsHelper.hasServiceZipInfo(order, null);

            expect(debugLog).not.toHaveBeenCalled();
        });

        test("adds log functions to logQueue when logQueue is provided", () => {
            const order = {
                serviceLocation: { zipCode: "12345", zipCodeCtu: "12345" },
            };
            const logQueue = [];

            pagePrereqsHelper.hasServiceZipInfo(order, logQueue);

            expect(logQueue).toHaveLength(1);
            logQueue[0]();
            expect(debugLog).toHaveBeenCalled();
        });
    });

    describe("hasServiceLocationInfo", () => {
        const baseOrder = {
            serviceLocation: {
                provider: {
                    address: {
                        streetAddress: "123 Provider St",
                        city: "ProviderCity",
                        state: "OH",
                        zipCode: "00000",
                    },
                },
            },
        };

        test("returns true for mobile when address, city, state, zipCode are set", () => {
            const order = {
                ...baseOrder,
                serviceLocation: {
                    ...baseOrder.serviceLocation,
                    address: "123 Main St",
                    city: "Anytown",
                    state: "OH",
                    zipCode: "12345",
                    appointmentType: AppointmentTypeStrings.MOBILE,
                    provider: baseOrder.serviceLocation.provider,
                },
            };

            const result = pagePrereqsHelper.hasServiceLocationInfo(order);

            expect(result).toBe(true);
        });

        test("returns false for mobile when address is missing", () => {
            const order = {
                ...baseOrder,
                serviceLocation: {
                    ...baseOrder.serviceLocation,
                    address: null,
                    city: "Anytown",
                    state: "OH",
                    zipCode: "12345",
                    appointmentType: AppointmentTypeStrings.MOBILE,
                    provider: baseOrder.serviceLocation.provider,
                },
            };

            const result = pagePrereqsHelper.hasServiceLocationInfo(order);

            expect(result).toBe(false);
        });

        test("returns true for drop-off when provider address has all fields", () => {
            const order = {
                ...baseOrder,
                serviceLocation: {
                    ...baseOrder.serviceLocation,
                    appointmentType: AppointmentTypeStrings.DROP_OFF,
                },
            };

            const result = pagePrereqsHelper.hasServiceLocationInfo(order);

            expect(result).toBe(true);
        });

        test("returns false for drop-off when provider streetAddress is missing", () => {
            const order = {
                ...baseOrder,
                serviceLocation: {
                    ...baseOrder.serviceLocation,
                    appointmentType: AppointmentTypeStrings.DROP_OFF,
                    provider: {
                        address: {
                            streetAddress: null,
                            city: "ProviderCity",
                            state: "OH",
                            zipCode: "00000",
                        },
                    },
                },
            };

            const result = pagePrereqsHelper.hasServiceLocationInfo(order);

            expect(result).toBe(false);
        });

        test("returns true for in-shop when provider address has all fields", () => {
            const order = {
                ...baseOrder,
                serviceLocation: {
                    ...baseOrder.serviceLocation,
                    appointmentType: AppointmentTypeStrings.IN_SHOP,
                },
            };

            const result = pagePrereqsHelper.hasServiceLocationInfo(order);

            expect(result).toBe(true);
        });

        test("does not add to logQueue when logQueue is null", () => {
            const order = {
                ...baseOrder,
                serviceLocation: {
                    ...baseOrder.serviceLocation,
                    appointmentType: AppointmentTypeStrings.MOBILE,
                    address: "123",
                    city: "City",
                    state: "OH",
                    zipCode: "12345",
                    provider: baseOrder.serviceLocation.provider,
                },
            };

            pagePrereqsHelper.hasServiceLocationInfo(order, null);

            expect(debugLog).not.toHaveBeenCalled();
        });

        test("adds log functions to logQueue when logQueue is provided", () => {
            const order = {
                ...baseOrder,
                serviceLocation: {
                    ...baseOrder.serviceLocation,
                    appointmentType: AppointmentTypeStrings.MOBILE,
                    address: "123",
                    city: "City",
                    state: "OH",
                    zipCode: "12345",
                    provider: baseOrder.serviceLocation.provider,
                },
            };
            const logQueue = [];

            pagePrereqsHelper.hasServiceLocationInfo(order, logQueue);

            expect(logQueue).toHaveLength(1);
            expect(typeof logQueue[0]).toBe("function");
            logQueue[0]();
            expect(debugLog).toHaveBeenCalled();
        });
    });

    describe("hasInsuranceInfo", () => {
        test("returns false when isInsurance is null", () => {
            const order = { payment: { isInsurance: null } };

            const result = pagePrereqsHelper.hasInsuranceInfo(order);

            expect(result).toBe(false);
        });

        test("returns true when isInsurance is false (cash selected)", () => {
            const order = {
                payment: {
                    isInsurance: false,
                    insuranceCoverage: { coverageStatus: coverageStatus.PENDING },
                },
            };

            const result = pagePrereqsHelper.hasInsuranceInfo(order);

            expect(result).toBe(true);
        });

        test("returns true when isInsurance is true and coverage is not verified", () => {
            const order = {
                payment: {
                    isInsurance: true,
                    insuranceCoverage: { coverageStatus: coverageStatus.PENDING },
                    parentAccountNumber: 999999,
                },
                policy: { policyNumber: "POL123" },
            };

            const result = pagePrereqsHelper.hasInsuranceInfo(order);

            expect(result).toBe(true);
        });

        test("returns true when isInsurance is true and coverage is verified with valid deductible", () => {
            const order = {
                payment: {
                    isInsurance: true,
                    insuranceCoverage: { coverageStatus: coverageStatus.VERIFIED },
                    parentAccountNumber: 999999,
                },
                policy: { policyNumber: "POL123", currentDeductible: 100 },
            };

            const result = pagePrereqsHelper.hasInsuranceInfo(order);

            expect(result).toBe(true);
        });

        test("returns true when coverage is verified and deductible is 0", () => {
            const order = {
                payment: {
                    isInsurance: true,
                    insuranceCoverage: { coverageStatus: coverageStatus.VERIFIED },
                    parentAccountNumber: 999999,
                },
                policy: { policyNumber: "POL123", currentDeductible: 0 },
            };

            const result = pagePrereqsHelper.hasInsuranceInfo(order);

            expect(result).toBe(true);
        });

        test("returns false when isInsurance is true but parentAccountNumber is CASH_PARENT_ACCOUNT_NUMBER", () => {
            const order = {
                payment: {
                    isInsurance: true,
                    insuranceCoverage: { coverageStatus: coverageStatus.PENDING },
                    parentAccountNumber: 167132,
                },
                policy: { policyNumber: "POL123" },
            };

            const result = pagePrereqsHelper.hasInsuranceInfo(order);

            expect(result).toBe(false);
        });

        test("returns false when isInsurance is true but policyNumber is missing", () => {
            const order = {
                payment: {
                    isInsurance: true,
                    insuranceCoverage: { coverageStatus: coverageStatus.PENDING },
                    parentAccountNumber: 999999,
                },
                policy: { policyNumber: null },
            };

            const result = pagePrereqsHelper.hasInsuranceInfo(order);

            expect(result).toBe(false);
        });

        test("returns false when coverage is verified but deductible is null", () => {
            const order = {
                payment: {
                    isInsurance: true,
                    insuranceCoverage: { coverageStatus: coverageStatus.VERIFIED },
                    parentAccountNumber: 999999,
                },
                policy: { policyNumber: "POL123", currentDeductible: null },
            };

            const result = pagePrereqsHelper.hasInsuranceInfo(order);

            expect(result).toBe(false);
        });

        test("returns false when coverage is verified but deductible is undefined", () => {
            const order = {
                payment: {
                    isInsurance: true,
                    insuranceCoverage: { coverageStatus: coverageStatus.VERIFIED },
                    parentAccountNumber: 999999,
                },
                policy: { policyNumber: "POL123", currentDeductible: undefined },
            };

            const result = pagePrereqsHelper.hasInsuranceInfo(order);

            expect(result).toBe(false);
        });

        test("returns false when coverage is verified but deductible is negative", () => {
            const order = {
                payment: {
                    isInsurance: true,
                    insuranceCoverage: { coverageStatus: coverageStatus.VERIFIED },
                    parentAccountNumber: 999999,
                },
                policy: { policyNumber: "POL123", currentDeductible: -1 },
            };

            const result = pagePrereqsHelper.hasInsuranceInfo(order);

            expect(result).toBe(false);
        });

        test("adds log functions to logQueue when logQueue is provided", () => {
            const order = { payment: { isInsurance: null } };
            const logQueue = [];

            pagePrereqsHelper.hasInsuranceInfo(order, logQueue);

            expect(logQueue).toHaveLength(1);
            logQueue[0]();
            expect(debugLog).toHaveBeenCalled();
        });
    });

    describe("hasSchedulingInfo", () => {
        const validSchedule = {
            date: "2024-01-15",
            startTime: "09:00",
            endTime: "17:00",
            jobMinMinutes: "30",
            jobMaxMinutes: "45",
        };

        test("returns true when all schedule fields are set", () => {
            const order = { schedule: validSchedule };

            const result = pagePrereqsHelper.hasSchedulingInfo(order);

            expect(result).toBe(true);
        });

        test("returns false when date is missing", () => {
            const order = {
                schedule: { ...validSchedule, date: null },
            };

            const result = pagePrereqsHelper.hasSchedulingInfo(order);

            expect(result).toBe(false);
        });

        test("returns false when startTime is missing", () => {
            const order = {
                schedule: { ...validSchedule, startTime: null },
            };

            const result = pagePrereqsHelper.hasSchedulingInfo(order);

            expect(result).toBe(false);
        });

        test("returns false when jobMinMinutes is missing", () => {
            const order = {
                schedule: { ...validSchedule, jobMinMinutes: null },
            };

            const result = pagePrereqsHelper.hasSchedulingInfo(order);

            expect(result).toBe(false);
        });

        test("does not add to logQueue when logQueue is null", () => {
            const order = { schedule: validSchedule };

            pagePrereqsHelper.hasSchedulingInfo(order, null);

            expect(debugLog).not.toHaveBeenCalled();
        });

        test("adds log functions to logQueue when logQueue is provided", () => {
            const order = { schedule: validSchedule };
            const logQueue = [];

            pagePrereqsHelper.hasSchedulingInfo(order, logQueue);

            expect(logQueue).toHaveLength(1);
            logQueue[0]();
            expect(debugLog).toHaveBeenCalled();
        });
    });

    describe("hasCustomerInfo", () => {
        const validCustomer = {
            firstName: "John",
            lastName: "Doe",
            phoneNumber: "555-555-5555",
            emailAddress: "john@example.com",
        };

        test("returns true when all customer fields are set", () => {
            const order = { customer: validCustomer };

            const result = pagePrereqsHelper.hasCustomerInfo(order);

            expect(result).toBe(true);
        });

        test("returns false when firstName is missing", () => {
            const order = {
                customer: { ...validCustomer, firstName: null },
            };

            const result = pagePrereqsHelper.hasCustomerInfo(order);

            expect(result).toBe(false);
        });

        test("returns false when emailAddress is missing", () => {
            const order = {
                customer: { ...validCustomer, emailAddress: "" },
            };

            const result = pagePrereqsHelper.hasCustomerInfo(order);

            expect(result).toBe(false);
        });

        test("returns false when phoneNumber is empty", () => {
            const order = {
                customer: { ...validCustomer, phoneNumber: "" },
            };

            const result = pagePrereqsHelper.hasCustomerInfo(order);

            expect(result).toBe(false);
        });

        test("does not add to logQueue when logQueue is null", () => {
            const order = { customer: validCustomer };

            pagePrereqsHelper.hasCustomerInfo(order, null);

            expect(debugLog).not.toHaveBeenCalled();
        });
    });

    describe("hasGlassPartsOrRepairInfo", () => {
        test("returns true when isRepair is true", () => {
            const order = {
                damage: { isRepair: true },
                lineItems: { glassParts: [] },
            };

            const result = pagePrereqsHelper.hasGlassPartsOrRepairInfo(order);

            expect(result).toBe(true);
        });

        test("returns true when glassParts has items", () => {
            const order = {
                damage: { isRepair: false },
                lineItems: { glassParts: [{ id: "1" }] },
            };

            const result = pagePrereqsHelper.hasGlassPartsOrRepairInfo(order);

            expect(result).toBe(true);
        });

        test("returns false when isRepair is false and glassParts is empty", () => {
            const order = {
                damage: { isRepair: false },
                lineItems: { glassParts: [] },
            };

            const result = pagePrereqsHelper.hasGlassPartsOrRepairInfo(order);

            expect(result).toBe(false);
        });

        test("returns false when isRepair is false and glassParts is null", () => {
            const order = {
                damage: { isRepair: false },
                lineItems: { glassParts: null },
            };

            const result = pagePrereqsHelper.hasGlassPartsOrRepairInfo(order);

            expect(result).toBe(false);
        });

        test("returns false when damage and lineItems are undefined", () => {
            const order = {};

            const result = pagePrereqsHelper.hasGlassPartsOrRepairInfo(order);

            expect(result).toBe(false);
        });

        test("does not add to logQueue when logQueue is null", () => {
            const order = {
                damage: { isRepair: true },
                lineItems: { glassParts: [] },
            };

            pagePrereqsHelper.hasGlassPartsOrRepairInfo(order, null);

            expect(debugLog).not.toHaveBeenCalled();
        });

        test("adds log functions to logQueue when logQueue is provided", () => {
            const order = {
                damage: { isRepair: true },
                lineItems: { glassParts: [] },
            };
            const logQueue = [];

            pagePrereqsHelper.hasGlassPartsOrRepairInfo(order, logQueue);

            expect(logQueue).toHaveLength(1);
            logQueue[0]();
            expect(debugLog).toHaveBeenCalled();
        });
    });

    describe("hasPaymentMethodInfo", () => {
        test("returns true when isPia is true and piaType is set", () => {
            const order = {
                payment: { isPia: true, piaType: "Afterpay" },
            };

            const result = pagePrereqsHelper.hasPaymentMethodInfo(order);

            expect(result).toBe(true);
        });

        test("returns true when isPia is false and piaType is set", () => {
            const order = {
                payment: { isPia: false, piaType: "PayLater" },
            };

            const result = pagePrereqsHelper.hasPaymentMethodInfo(order);

            expect(result).toBe(true);
        });

        test("returns false when isPia is null", () => {
            const order = {
                payment: { isPia: null, piaType: "Afterpay" },
            };

            const result = pagePrereqsHelper.hasPaymentMethodInfo(order);

            expect(result).toBe(false);
        });

        test("returns false when isPia is false and piaType is null", () => {
            const order = {
                payment: { isPia: false, piaType: null },
            };

            const result = pagePrereqsHelper.hasPaymentMethodInfo(order);

            expect(result).toBe(false);
        });

        test("returns false when isPia is false and piaType is empty string", () => {
            const order = {
                payment: { isPia: false, piaType: "" },
            };

            const result = pagePrereqsHelper.hasPaymentMethodInfo(order);

            expect(result).toBe(false);
        });

        test("does not add to logQueue when logQueue is null", () => {
            const order = { payment: { isPia: true, piaType: "Afterpay" } };

            pagePrereqsHelper.hasPaymentMethodInfo(order, null);

            expect(debugLog).not.toHaveBeenCalled();
        });

        test("adds log functions to logQueue when logQueue is provided", () => {
            const order = { payment: { isPia: true, piaType: "Afterpay" } };
            const logQueue = [];

            pagePrereqsHelper.hasPaymentMethodInfo(order, logQueue);

            expect(logQueue).toHaveLength(1);
            logQueue[0]();
            expect(debugLog).toHaveBeenCalled();
        });
    });
});