@doctocar/tooling 0.3.1-16 → 0.3.1-17

package/dist/firebase/firestore/utils/order/getOrderCustomerAndProfessionalIds.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOrderCustomerAndProfessionalIds = getOrderCustomerAndProfessionalIds;
+function getOrderCustomerAndProfessionalIds({ orderDocument, }) {
+    return {
+        customerId: orderDocument.customerDetails.firestoreId,
+        professionalId: orderDocument.professionalDetails.firestoreId,
+    };
+}

package/dist/firebase/firestore/utils/order/types/BuildOrderProfessionalServicePreTaxLinesAndProfessionalServicesDetailsProps.type.d.ts

@@ -0,0 +1,8 @@
+import type { ServicesTypes, VehicleTypes } from "../../../enums";
+import type { CountryServicesPublicConfig, FirestoreProfessionalUserPublicDocument } from "../../../types";
+export type BuildOrderProfessionalServicePreTaxLinesAndProfessionalServicesDetailsProps = {
+    countryServicesPublicConfig: CountryServicesPublicConfig;
+    professionalServiceTypes: ServicesTypes[];
+    professionalUserPublicDocument: FirestoreProfessionalUserPublicDocument;
+    customerVehicleType: VehicleTypes;
+};

package/dist/firebase/firestore/utils/order/types/BuildOrderProfessionalServicePreTaxLinesAndProfessionalServicesDetailsProps.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/firebase/firestore/utils/order/types/BuildOrderProfessionalServicePreTaxLinesAndProfessionalServicesDetailsReturn.type.d.ts

@@ -0,0 +1,6 @@
+import type { PricingPreTaxLine } from "../../../../../pricing";
+import type { FirestoreOrderProfessionalServiceDetails } from "../../../types";
+export type BuildOrderProfessionalServicePreTaxLinesAndProfessionalServicesDetailsReturn = {
+    professionalServicesPreTaxLines: Array<PricingPreTaxLine>;
+    orderProfessionalServicesDetails: Array<FirestoreOrderProfessionalServiceDetails>;
+};

package/dist/firebase/firestore/utils/order/types/BuildOrderProfessionalServicePreTaxLinesAndProfessionalServicesDetailsReturn.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/firebase/firestore/utils/order/types/GetOrderCustomerAndProfessionalIdsParams.type.d.ts

@@ -0,0 +1,4 @@
+import type { FirestoreOrderDocument } from "../../../types";
+export type GetOrderCustomerAndProfessionalIdsParams = {
+    orderDocument: FirestoreOrderDocument;
+};

package/dist/firebase/firestore/utils/order/types/GetOrderCustomerAndProfessionalIdsParams.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/firebase/firestore/utils/order/types/GetOrderCustomerAndProfessionalIdsResult.type.d.ts

@@ -0,0 +1,4 @@
+export type GetOrderCustomerAndProfessionalIdsResult = {
+    customerId: string;
+    professionalId: string;
+};

package/dist/firebase/firestore/utils/order/types/GetOrderCustomerAndProfessionalIdsResult.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/firebase/firestore/utils/services/__tests__/areAllRequestedProfessionalUserServicesActiveForVehicleType.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/firebase/firestore/utils/services/__tests__/areAllRequestedProfessionalUserServicesActiveForVehicleType.test.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const enums_1 = require("../../../enums");
+const stubs_1 = require("../../stubs");
+const areAllRequestedProfessionalUserServicesActiveForVehicleType_1 = require("../areAllRequestedProfessionalUserServicesActiveForVehicleType");
+describe("areAllRequestedProfessionalUserServicesActiveForVehicleType", () => {
+    let pro;
+    beforeEach(() => {
+        pro = (0, stubs_1.firestoreProfessionalUserPublicDocumentStub)({
+            professionalServices: {
+                [enums_1.ServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.professionalServiceStub)({
+                    type: enums_1.ServicesTypes.EXTERIOR_CLEANING,
+                    isActive: true,
+                    pricingAndDurationByVehicleType: {
+                        [enums_1.VehicleTypes.CITY_CAR]: (0, stubs_1.pricingAndDurationForVehicleStub)({
+                            isActive: true,
+                            durationInMinutes: 30,
+                        }),
+                        [enums_1.VehicleTypes.SUV]: (0, stubs_1.pricingAndDurationForVehicleStub)({
+                            isActive: true,
+                            durationInMinutes: 45,
+                        }),
+                    },
+                }),
+                [enums_1.ServicesTypes.INTERIOR_CLEANING]: (0, stubs_1.professionalServiceStub)({
+                    type: enums_1.ServicesTypes.INTERIOR_CLEANING,
+                    isActive: true,
+                    pricingAndDurationByVehicleType: {
+                        [enums_1.VehicleTypes.CITY_CAR]: (0, stubs_1.pricingAndDurationForVehicleStub)({
+                            isActive: true,
+                            durationInMinutes: 20,
+                        }),
+                    },
+                }),
+            },
+        });
+    });
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    it("returns true when all requested services are active for the given vehicle type", () => {
+        const ok = (0, areAllRequestedProfessionalUserServicesActiveForVehicleType_1.areAllRequestedProfessionalUserServicesActiveForVehicleType)({
+            servicesTypes: [
+                enums_1.ServicesTypes.EXTERIOR_CLEANING,
+                enums_1.ServicesTypes.INTERIOR_CLEANING,
+            ],
+            vehicleType: enums_1.VehicleTypes.CITY_CAR,
+            professionalServices: pro.professionalServices,
+        });
+        expect(ok).toBe(true);
+    });
+    it("returns false when a requested service is missing from professional services", () => {
+        // Remove INTERIOR_CLEANING config
+        pro = (0, stubs_1.firestoreProfessionalUserPublicDocumentStub)({
+            professionalServices: {
+                [enums_1.ServicesTypes.EXTERIOR_CLEANING]: pro.professionalServices[enums_1.ServicesTypes.EXTERIOR_CLEANING],
+            },
+        });
+        const ok = (0, areAllRequestedProfessionalUserServicesActiveForVehicleType_1.areAllRequestedProfessionalUserServicesActiveForVehicleType)({
+            servicesTypes: [enums_1.ServicesTypes.INTERIOR_CLEANING],
+            vehicleType: enums_1.VehicleTypes.CITY_CAR,
+            professionalServices: pro.professionalServices,
+        });
+        expect(ok).toBe(false);
+    });
+    it("returns false when a service is inactive at service level", () => {
+        pro.professionalServices[enums_1.ServicesTypes.EXTERIOR_CLEANING] =
+            (0, stubs_1.professionalServiceStub)({
+                type: enums_1.ServicesTypes.EXTERIOR_CLEANING,
+                isActive: false,
+                pricingAndDurationByVehicleType: {
+                    [enums_1.VehicleTypes.CITY_CAR]: (0, stubs_1.pricingAndDurationForVehicleStub)({
+                        isActive: true,
+                        durationInMinutes: 30,
+                    }),
+                },
+            });
+        const ok = (0, areAllRequestedProfessionalUserServicesActiveForVehicleType_1.areAllRequestedProfessionalUserServicesActiveForVehicleType)({
+            servicesTypes: [enums_1.ServicesTypes.EXTERIOR_CLEANING],
+            vehicleType: enums_1.VehicleTypes.CITY_CAR,
+            professionalServices: pro.professionalServices,
+        });
+        expect(ok).toBe(false);
+    });
+    it("returns false when per-vehicle config is missing", () => {
+        // Remove CITY_CAR entry for EXTERIOR_CLEANING
+        pro.professionalServices[enums_1.ServicesTypes.EXTERIOR_CLEANING] =
+            (0, stubs_1.professionalServiceStub)({
+                type: enums_1.ServicesTypes.EXTERIOR_CLEANING,
+                isActive: true,
+                pricingAndDurationByVehicleType: {
+                    // CITY_CAR intentionally missing
+                    [enums_1.VehicleTypes.SUV]: (0, stubs_1.pricingAndDurationForVehicleStub)({
+                        isActive: true,
+                        durationInMinutes: 45,
+                    }),
+                },
+            });
+        const ok = (0, areAllRequestedProfessionalUserServicesActiveForVehicleType_1.areAllRequestedProfessionalUserServicesActiveForVehicleType)({
+            servicesTypes: [enums_1.ServicesTypes.EXTERIOR_CLEANING],
+            vehicleType: enums_1.VehicleTypes.CITY_CAR,
+            professionalServices: pro.professionalServices,
+        });
+        expect(ok).toBe(false);
+    });
+    it("returns false when per-vehicle config exists but is inactive", () => {
+        pro.professionalServices[enums_1.ServicesTypes.EXTERIOR_CLEANING] =
+            (0, stubs_1.professionalServiceStub)({
+                type: enums_1.ServicesTypes.EXTERIOR_CLEANING,
+                isActive: true,
+                pricingAndDurationByVehicleType: {
+                    [enums_1.VehicleTypes.CITY_CAR]: (0, stubs_1.pricingAndDurationForVehicleStub)({
+                        isActive: false,
+                        durationInMinutes: 30,
+                    }),
+                },
+            });
+        const ok = (0, areAllRequestedProfessionalUserServicesActiveForVehicleType_1.areAllRequestedProfessionalUserServicesActiveForVehicleType)({
+            servicesTypes: [enums_1.ServicesTypes.EXTERIOR_CLEANING],
+            vehicleType: enums_1.VehicleTypes.CITY_CAR,
+            professionalServices: pro.professionalServices,
+        });
+        expect(ok).toBe(false);
+    });
+    it("dedups service types; duplicates still return true if active", () => {
+        const ok = (0, areAllRequestedProfessionalUserServicesActiveForVehicleType_1.areAllRequestedProfessionalUserServicesActiveForVehicleType)({
+            servicesTypes: [
+                enums_1.ServicesTypes.EXTERIOR_CLEANING,
+                enums_1.ServicesTypes.EXTERIOR_CLEANING, // duplicate
+            ],
+            vehicleType: enums_1.VehicleTypes.CITY_CAR,
+            professionalServices: pro.professionalServices,
+        });
+        expect(ok).toBe(true);
+    });
+    it("returns true for empty service list (vacuously true)", () => {
+        const ok = (0, areAllRequestedProfessionalUserServicesActiveForVehicleType_1.areAllRequestedProfessionalUserServicesActiveForVehicleType)({
+            servicesTypes: [],
+            vehicleType: enums_1.VehicleTypes.CITY_CAR,
+            professionalServices: pro.professionalServices,
+        });
+        expect(ok).toBe(true);
+    });
+});

package/dist/firebase/firestore/utils/services/__tests__/createProfessionalServiceVehicleComboKey.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/firebase/firestore/utils/services/__tests__/createProfessionalServiceVehicleComboKey.test.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const enums_1 = require("../../../enums");
+const createProfessionalServiceVehicleComboKey_1 = require("../createProfessionalServiceVehicleComboKey");
+describe("createProfessionalServiceVehicleComboKey", () => {
+    it("should return a string with the professionalServiceType and vehicleType separated by an underscore", () => {
+        const professionalServiceType = enums_1.ServicesTypes.INTERIOR_CLEANING;
+        const vehicleType = enums_1.VehicleTypes.CITY_CAR;
+        const result = (0, createProfessionalServiceVehicleComboKey_1.createProfessionalServiceVehicleComboKey)(professionalServiceType, vehicleType);
+        expect(result).toBe(`${professionalServiceType}_${vehicleType}`);
+    });
+});

package/dist/firebase/firestore/utils/services/__tests__/createProfessionalServiceVehicleComboKey.util.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/firebase/firestore/utils/services/__tests__/createProfessionalServiceVehicleComboKey.util.test.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const enums_1 = require("../../../enums");
+const createProfessionalServiceVehicleComboKey_util_1 = require("../createProfessionalServiceVehicleComboKey.util");
+describe("createProfessionalServiceVehicleComboKey", () => {
+    it("should return a string with the professionalServiceType and vehicleType separated by an underscore", () => {
+        const professionalServiceType = enums_1.ServicesTypes.INTERIOR_CLEANING;
+        const vehicleType = enums_1.VehicleTypes.CITY_CAR;
+        const result = (0, createProfessionalServiceVehicleComboKey_util_1.createProfessionalServiceVehicleComboKey)(professionalServiceType, vehicleType);
+        expect(result).toBe(`${professionalServiceType}_${vehicleType}`);
+    });
+});

package/dist/firebase/firestore/utils/services/__tests__/getActiveProfessionalServicePricingAndDurationForVehicleOrThrow.util.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/firebase/firestore/utils/services/__tests__/getActiveProfessionalServicePricingAndDurationForVehicleOrThrow.util.test.js

@@ -0,0 +1,225 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const enums_1 = require("../../../../../enums");
+const enums_2 = require("../../../enums");
+const stubs_1 = require("../../stubs");
+const getActiveProfessionalServicePricingAndDurationForVehicleOrThrow_1 = require("../getActiveProfessionalServicePricingAndDurationForVehicleOrThrow");
+const errorCases = [
+    {
+        name: "Should throw an error if the service is not offered by the professional",
+        professionalUserPublicDocument: (0, stubs_1.firestoreProfessionalUserPublicDocumentStub)({
+            professionalServices: {
+                [enums_2.ServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.professionalServiceStub)({
+                    isActive: true,
+                    type: enums_2.ServicesTypes.EXTERIOR_CLEANING,
+                    pricingAndDurationByVehicleType: {
+                        [enums_2.VehicleTypes.SEDAN]: (0, stubs_1.pricingAndDurationForVehicleStub)({
+                            type: enums_2.VehicleTypes.SEDAN,
+                            isActive: true,
+                            pricePreTaxInCents: 2000,
+                            durationInMinutes: 30,
+                            currency: enums_1.SupportedIsoCurrency.EUR,
+                        }),
+                    },
+                }),
+            },
+        }),
+        professionalServiceType: enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT,
+        vehicleType: enums_2.VehicleTypes.SEDAN,
+        error: new Error(`Service “${enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT}” is not offered by this professional.`),
+    },
+    {
+        name: "Should throw an error if the service is not active",
+        professionalUserPublicDocument: (0, stubs_1.firestoreProfessionalUserPublicDocumentStub)({
+            professionalServices: {
+                [enums_2.ServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.professionalServiceStub)({
+                    isActive: false,
+                    type: enums_2.ServicesTypes.EXTERIOR_CLEANING,
+                    pricingAndDurationByVehicleType: {
+                        [enums_2.VehicleTypes.SEDAN]: (0, stubs_1.pricingAndDurationForVehicleStub)({
+                            type: enums_2.VehicleTypes.SEDAN,
+                            isActive: true,
+                            pricePreTaxInCents: 2000,
+                            durationInMinutes: 30,
+                            currency: enums_1.SupportedIsoCurrency.EUR,
+                        }),
+                    },
+                }),
+            },
+        }),
+        professionalServiceType: enums_2.ServicesTypes.EXTERIOR_CLEANING,
+        vehicleType: enums_2.VehicleTypes.SEDAN,
+        error: new Error(`Service “${enums_2.ServicesTypes.EXTERIOR_CLEANING}” is not offered by this professional.`),
+    },
+    {
+        name: "Should throw an error if the vehicle type is not active for the service",
+        professionalUserPublicDocument: (0, stubs_1.firestoreProfessionalUserPublicDocumentStub)({
+            professionalServices: {
+                [enums_2.ServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.professionalServiceStub)({
+                    isActive: true,
+                    type: enums_2.ServicesTypes.EXTERIOR_CLEANING,
+                    pricingAndDurationByVehicleType: {
+                        [enums_2.VehicleTypes.VAN]: (0, stubs_1.pricingAndDurationForVehicleStub)({
+                            type: enums_2.VehicleTypes.VAN,
+                            isActive: false,
+                            pricePreTaxInCents: 2500,
+                            durationInMinutes: 45,
+                            currency: enums_1.SupportedIsoCurrency.EUR,
+                        }),
+                    },
+                }),
+            },
+        }),
+        professionalServiceType: enums_2.ServicesTypes.EXTERIOR_CLEANING,
+        vehicleType: enums_2.VehicleTypes.VAN,
+        error: new Error(`Service “${enums_2.ServicesTypes.EXTERIOR_CLEANING}” is not available for vehicle type “${enums_2.VehicleTypes.VAN}”.`),
+    },
+    {
+        name: "Should throw an error if the service does not have pricing and duration for the vehicle type",
+        professionalUserPublicDocument: (0, stubs_1.firestoreProfessionalUserPublicDocumentStub)({
+            professionalServices: {
+                [enums_2.ServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.professionalServiceStub)({
+                    type: enums_2.ServicesTypes.EXTERIOR_CLEANING,
+                    isActive: true,
+                    pricingAndDurationByVehicleType: {},
+                }),
+            },
+        }),
+        professionalServiceType: enums_2.ServicesTypes.EXTERIOR_CLEANING,
+        vehicleType: enums_2.VehicleTypes.SEDAN,
+        error: new Error(`Service “${enums_2.ServicesTypes.EXTERIOR_CLEANING}” is not available for vehicle type “${enums_2.VehicleTypes.SEDAN}”.`),
+    },
+    {
+        name: "Should throw an error if the service pricing and duration for the vehicle type is missing required pricePreTaxInCents fields",
+        professionalUserPublicDocument: (0, stubs_1.firestoreProfessionalUserPublicDocumentStub)({
+            professionalServices: {
+                [enums_2.ServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.professionalServiceStub)({
+                    type: enums_2.ServicesTypes.EXTERIOR_CLEANING,
+                    pricingAndDurationByVehicleType: {
+                        [enums_2.VehicleTypes.SEDAN]: (0, stubs_1.pricingAndDurationForVehicleStub)({
+                            type: enums_2.VehicleTypes.SEDAN,
+                            isActive: true,
+                            pricePreTaxInCents: undefined,
+                            durationInMinutes: 30,
+                            currency: enums_1.SupportedIsoCurrency.EUR,
+                        }),
+                    },
+                }),
+            },
+        }),
+        professionalServiceType: enums_2.ServicesTypes.EXTERIOR_CLEANING,
+        vehicleType: enums_2.VehicleTypes.SEDAN,
+        error: new Error(`Service “${enums_2.ServicesTypes.EXTERIOR_CLEANING}” is not available for vehicle type “${enums_2.VehicleTypes.SEDAN}”.`),
+    },
+    {
+        name: "Should throw an error if the service pricing and duration for the vehicle type is missing required durationInMinutes fields",
+        professionalUserPublicDocument: (0, stubs_1.firestoreProfessionalUserPublicDocumentStub)({
+            professionalServices: {
+                [enums_2.ServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.professionalServiceStub)({
+                    type: enums_2.ServicesTypes.EXTERIOR_CLEANING,
+                    pricingAndDurationByVehicleType: {
+                        [enums_2.VehicleTypes.SEDAN]: (0, stubs_1.pricingAndDurationForVehicleStub)({
+                            type: enums_2.VehicleTypes.SEDAN,
+                            isActive: true,
+                            pricePreTaxInCents: 2000,
+                            durationInMinutes: undefined,
+                            currency: enums_1.SupportedIsoCurrency.EUR,
+                        }),
+                    },
+                }),
+            },
+        }),
+        professionalServiceType: enums_2.ServicesTypes.EXTERIOR_CLEANING,
+        vehicleType: enums_2.VehicleTypes.SEDAN,
+        error: new Error(`Service “${enums_2.ServicesTypes.EXTERIOR_CLEANING}” is not available for vehicle type “${enums_2.VehicleTypes.SEDAN}”.`),
+    },
+    {
+        name: "Should throw an error if the service pricing and duration for the vehicle type is missing required currency fields",
+        professionalUserPublicDocument: (0, stubs_1.firestoreProfessionalUserPublicDocumentStub)({
+            professionalServices: {
+                [enums_2.ServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.professionalServiceStub)({
+                    type: enums_2.ServicesTypes.EXTERIOR_CLEANING,
+                    pricingAndDurationByVehicleType: {
+                        [enums_2.VehicleTypes.SEDAN]: (0, stubs_1.pricingAndDurationForVehicleStub)({
+                            type: enums_2.VehicleTypes.SEDAN,
+                            isActive: true,
+                            pricePreTaxInCents: 2000,
+                            durationInMinutes: 30,
+                            currency: undefined,
+                        }),
+                    },
+                }),
+            },
+        }),
+        professionalServiceType: enums_2.ServicesTypes.EXTERIOR_CLEANING,
+        vehicleType: enums_2.VehicleTypes.SEDAN,
+        error: new Error(`Service “${enums_2.ServicesTypes.EXTERIOR_CLEANING}” is not available for vehicle type “${enums_2.VehicleTypes.SEDAN}”.`),
+    },
+    {
+        name: "Should throw an error if the service pricing and duration for the vehicle type is missing required type fields",
+        professionalUserPublicDocument: (0, stubs_1.firestoreProfessionalUserPublicDocumentStub)({
+            professionalServices: {
+                [enums_2.ServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.professionalServiceStub)({
+                    type: enums_2.ServicesTypes.EXTERIOR_CLEANING,
+                    pricingAndDurationByVehicleType: {
+                        [enums_2.VehicleTypes.SEDAN]: (0, stubs_1.pricingAndDurationForVehicleStub)({
+                            type: undefined,
+                            isActive: true,
+                            pricePreTaxInCents: 2000,
+                            durationInMinutes: 30,
+                            currency: enums_1.SupportedIsoCurrency.EUR,
+                        }),
+                    },
+                }),
+            },
+        }),
+        professionalServiceType: enums_2.ServicesTypes.EXTERIOR_CLEANING,
+        vehicleType: enums_2.VehicleTypes.SEDAN,
+        error: new Error(`Service “${enums_2.ServicesTypes.EXTERIOR_CLEANING}” is not available for vehicle type “${enums_2.VehicleTypes.SEDAN}”.`),
+    },
+];
+describe("getActiveProfessionalServicePricingAndDurationForVehicleOrThrow", () => {
+    let professionalUserPublicDocument;
+    beforeEach(() => {
+        professionalUserPublicDocument =
+            (0, stubs_1.firestoreProfessionalUserPublicDocumentStub)({
+                professionalServices: {
+                    [enums_2.ServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.professionalServiceStub)({
+                        type: enums_2.ServicesTypes.EXTERIOR_CLEANING,
+                        pricingAndDurationByVehicleType: {
+                            [enums_2.VehicleTypes.SEDAN]: (0, stubs_1.pricingAndDurationForVehicleStub)({
+                                type: enums_2.VehicleTypes.SEDAN,
+                                isActive: true,
+                                pricePreTaxInCents: 2000,
+                                durationInMinutes: 30,
+                                currency: enums_1.SupportedIsoCurrency.EUR,
+                            }),
+                        },
+                    }),
+                },
+            });
+    });
+    it("should return the correct pricing and duration for a valid service and vehicle type (Happy path)", () => {
+        const result = (0, getActiveProfessionalServicePricingAndDurationForVehicleOrThrow_1.getActiveProfessionalServicePricingAndDurationForVehicleOrThrow)({
+            professionalUserPublicDocument,
+            professionalServiceType: enums_2.ServicesTypes.EXTERIOR_CLEANING,
+            vehicleType: enums_2.VehicleTypes.SEDAN,
+        });
+        expect(result).toEqual({
+            isActive: true,
+            durationInMinutes: 30,
+            pricePreTaxInCents: 2000,
+            type: enums_2.VehicleTypes.SEDAN,
+            currency: enums_1.SupportedIsoCurrency.EUR,
+        });
+    });
+    describe("error cases", () => {
+        test.each(errorCases)("should throw error if $name", async ({ professionalUserPublicDocument, professionalServiceType, vehicleType, error, }) => {
+            expect(() => (0, getActiveProfessionalServicePricingAndDurationForVehicleOrThrow_1.getActiveProfessionalServicePricingAndDurationForVehicleOrThrow)({
+                professionalUserPublicDocument,
+                professionalServiceType,
+                vehicleType,
+            })).toThrow(error);
+        });
+    });
+});

package/dist/firebase/firestore/utils/services/__tests__/getActiveServicePricingAndDurationForVehicleOrThrow.test.d.ts

@@ -0,0 +1 @@
+export {};