@doctocar/tooling 0.3.1-6 → 0.3.1-7

package/dist/firebase/firestore/utils/address/__tests__/isValidLegalAddress.test.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const enums_1 = require("../../../../../enums");
+const stubs_1 = require("../../stubs");
+const isValidLegalAddress_1 = require("../isValidLegalAddress");
+describe("isValidLegalAddress", () => {
+    let defaultAddress;
+    beforeEach(() => {
+        defaultAddress = (0, stubs_1.legalAddressStub)({
+            line1: "123 Main St",
+            postalCode: "75001",
+            city: "Paris",
+            country: enums_1.SupportedCountryIsoCodes.FRANCE,
+        });
+    });
+    it("should return true when address is valid", () => {
+        const address = (0, stubs_1.legalAddressStub)({
+            ...defaultAddress,
+            line1: "123 Main St",
+            postalCode: "75001",
+            city: "Paris",
+            country: enums_1.SupportedCountryIsoCodes.FRANCE,
+        });
+        expect((0, isValidLegalAddress_1.isValidLegalAddress)({ legalAddress: address })).toBe(true);
+    });
+    it("should return false when address is invalid", () => {
+        const address = (0, stubs_1.legalAddressStub)({
+            ...defaultAddress,
+            line1: undefined,
+        });
+        expect((0, isValidLegalAddress_1.isValidLegalAddress)({ legalAddress: address })).toBe(false);
+    });
+    it("should return false when address is undefined", () => {
+        expect((0, isValidLegalAddress_1.isValidLegalAddress)({ legalAddress: undefined })).toBe(false);
+    });
+    it("should return false when address is missing line1", () => {
+        const address = (0, stubs_1.legalAddressStub)({
+            ...defaultAddress,
+            line1: undefined,
+        });
+        expect((0, isValidLegalAddress_1.isValidLegalAddress)({ legalAddress: address })).toBe(false);
+    });
+    it("should return false when address is missing postalCode", () => {
+        const address = (0, stubs_1.legalAddressStub)({
+            ...defaultAddress,
+            postalCode: undefined,
+        });
+        expect((0, isValidLegalAddress_1.isValidLegalAddress)({ legalAddress: address })).toBe(false);
+    });
+    it("should return false when address is missing city", () => {
+        const address = (0, stubs_1.legalAddressStub)({
+            ...defaultAddress,
+            city: undefined,
+        });
+        expect((0, isValidLegalAddress_1.isValidLegalAddress)({ legalAddress: address })).toBe(false);
+    });
+    it("should return false when address is missing country", () => {
+        const address = (0, stubs_1.legalAddressStub)({
+            ...defaultAddress,
+            country: undefined,
+        });
+        expect((0, isValidLegalAddress_1.isValidLegalAddress)({ legalAddress: address })).toBe(false);
+    });
+    it("should return false when address is missing all fields", () => {
+        const address = (0, stubs_1.legalAddressStub)({
+            line1: undefined,
+            postalCode: undefined,
+            city: undefined,
+            country: undefined,
+        });
+        expect((0, isValidLegalAddress_1.isValidLegalAddress)({ legalAddress: address })).toBe(false);
+    });
+});

package/dist/firebase/firestore/utils/address/index.d.ts

@@ -0,0 +1 @@
+export * from "./isValidLegalAddress";

package/dist/firebase/firestore/utils/{users/errors → address}/index.js

@@ -14,4 +14,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./enums"), exports);
+__exportStar(require("./isValidLegalAddress"), exports);

package/dist/firebase/firestore/utils/address/isValidLegalAddress.d.ts

@@ -0,0 +1,2 @@
+import type { IsValidLegalAddressParams } from "./types";
+export declare function isValidLegalAddress({ legalAddress, }: IsValidLegalAddressParams): boolean;

package/dist/firebase/firestore/utils/address/isValidLegalAddress.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidLegalAddress = isValidLegalAddress;
+function isValidLegalAddress({ legalAddress, }) {
+    if (!legalAddress)
+        return false;
+    return (!!legalAddress.line1 &&
+        !!legalAddress.city &&
+        !!legalAddress.postalCode &&
+        !!legalAddress.country);
+}

package/dist/firebase/firestore/utils/address/types/IsValidLegalAddressParams.type.d.ts

@@ -0,0 +1,4 @@
+import type { LegalAddress } from "../../../types";
+export type IsValidLegalAddressParams = {
+    legalAddress?: LegalAddress;
+};

package/dist/firebase/firestore/utils/address/types/index.d.ts

@@ -0,0 +1 @@
+export * from "./IsValidLegalAddressParams.type";

package/dist/firebase/firestore/{enums/documents → utils/address/types}/index.js

@@ -14,4 +14,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./DocumentValidationStatus.enum"), exports);
+__exportStar(require("./IsValidLegalAddressParams.type"), exports);

package/dist/firebase/firestore/utils/configs/__tests__/getAvailableServicesPublicConfigForVehicleType.test.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const enums_1 = require("../../../enums");
+const stubs_1 = require("../../stubs");
+const getAvailableServicesPublicConfigForVehicleType_1 = require("../getAvailableServicesPublicConfigForVehicleType");
+describe("getAvailableServicesPublicConfigForVehicleType", () => {
+    it("returns empty arrays when no services", () => {
+        const result = (0, getAvailableServicesPublicConfigForVehicleType_1.getAvailableServicesPublicConfigForVehicleType)({
+            countryServicesPublicConfig: {},
+            vehicleType: enums_1.VehicleTypes.SEDAN,
+        });
+        expect(result.availableMainServicesPublicConfigList).toEqual([]);
+        expect(result.availableSubServicesPublicConfigList).toEqual([]);
+    });
+    it("filters out services that are not available globally", () => {
+        const result = (0, getAvailableServicesPublicConfigForVehicleType_1.getAvailableServicesPublicConfigForVehicleType)({
+            countryServicesPublicConfig: {
+                [enums_1.ServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.firestoreServicesPublicConfigStub)({
+                    isAvailable: false,
+                }),
+            },
+            vehicleType: enums_1.VehicleTypes.SEDAN,
+        });
+        expect(result.availableMainServicesPublicConfigList).toEqual([]);
+        expect(result.availableSubServicesPublicConfigList).toEqual([]);
+    });
+    it("filters out services not available for the given vehicle type", () => {
+        const result = (0, getAvailableServicesPublicConfigForVehicleType_1.getAvailableServicesPublicConfigForVehicleType)({
+            countryServicesPublicConfig: {
+                [enums_1.ServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.firestoreServicesPublicConfigStub)({
+                    isAvailable: true,
+                    byVehicleType: {
+                        [enums_1.VehicleTypes.SUV]: {
+                            minimumPriceInCents: 1000,
+                            maximumPriceInCents: 2000,
+                            recommendedPriceInCents: 1500,
+                            durationInMinutes: 60,
+                        },
+                    },
+                }),
+            },
+            vehicleType: enums_1.VehicleTypes.SEDAN,
+        });
+        expect(result.availableMainServicesPublicConfigList).toEqual([]);
+        expect(result.availableSubServicesPublicConfigList).toEqual([]);
+    });
+    it("returns main services correctly", () => {
+        const result = (0, getAvailableServicesPublicConfigForVehicleType_1.getAvailableServicesPublicConfigForVehicleType)({
+            countryServicesPublicConfig: {
+                [enums_1.ServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.firestoreServicesPublicConfigStub)({
+                    isAvailable: true,
+                    type: enums_1.ServicesTypes.EXTERIOR_CLEANING,
+                    byVehicleType: {
+                        [enums_1.VehicleTypes.SEDAN]: {
+                            minimumPriceInCents: 1000,
+                            maximumPriceInCents: 2000,
+                            recommendedPriceInCents: 1500,
+                            durationInMinutes: 60,
+                        },
+                    },
+                }),
+            },
+            vehicleType: enums_1.VehicleTypes.SEDAN,
+        });
+        expect(result.availableMainServicesPublicConfigList).toHaveLength(1);
+        expect(result.availableMainServicesPublicConfigList[0].type).toBe(enums_1.ServicesTypes.EXTERIOR_CLEANING);
+        expect(result.availableSubServicesPublicConfigList).toEqual([]);
+    });
+    it("returns sub services correctly", () => {
+        const result = (0, getAvailableServicesPublicConfigForVehicleType_1.getAvailableServicesPublicConfigForVehicleType)({
+            countryServicesPublicConfig: {
+                [enums_1.ServicesTypes.LEATHER_SEAT_SHAMPOO_AND_TREATMENT]: (0, stubs_1.firestoreServicesPublicConfigStub)({
+                    isAvailable: true,
+                    type: enums_1.ServicesTypes.LEATHER_SEAT_SHAMPOO_AND_TREATMENT,
+                    parentsServices: [enums_1.ServicesTypes.INTERIOR_CLEANING],
+                    byVehicleType: {
+                        [enums_1.VehicleTypes.SEDAN]: {
+                            minimumPriceInCents: 1000,
+                            maximumPriceInCents: 2000,
+                            recommendedPriceInCents: 1500,
+                            durationInMinutes: 60,
+                        },
+                    },
+                }),
+            },
+            vehicleType: enums_1.VehicleTypes.SEDAN,
+        });
+        expect(result.availableMainServicesPublicConfigList).toEqual([]);
+        expect(result.availableSubServicesPublicConfigList).toHaveLength(1);
+        expect(result.availableSubServicesPublicConfigList[0].type).toBe(enums_1.ServicesTypes.LEATHER_SEAT_SHAMPOO_AND_TREATMENT);
+    });
+    it("splits main and sub services correctly", () => {
+        const result = (0, getAvailableServicesPublicConfigForVehicleType_1.getAvailableServicesPublicConfigForVehicleType)({
+            countryServicesPublicConfig: {
+                [enums_1.ServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.firestoreServicesPublicConfigStub)({
+                    isAvailable: true,
+                    parentsServices: undefined,
+                    byVehicleType: {
+                        [enums_1.VehicleTypes.SEDAN]: {
+                            minimumPriceInCents: 1000,
+                            maximumPriceInCents: 2000,
+                            recommendedPriceInCents: 1500,
+                            durationInMinutes: 60,
+                        },
+                    },
+                }),
+                [enums_1.ServicesTypes.LEATHER_SEAT_SHAMPOO_AND_TREATMENT]: (0, stubs_1.firestoreServicesPublicConfigStub)({
+                    isAvailable: true,
+                    parentsServices: [enums_1.ServicesTypes.INTERIOR_CLEANING],
+                    byVehicleType: {
+                        [enums_1.VehicleTypes.SEDAN]: {
+                            minimumPriceInCents: 1000,
+                            maximumPriceInCents: 2000,
+                            recommendedPriceInCents: 1500,
+                            durationInMinutes: 60,
+                        },
+                    },
+                }),
+            },
+            vehicleType: enums_1.VehicleTypes.SEDAN,
+        });
+        expect(result.availableMainServicesPublicConfigList).toHaveLength(1);
+        expect(result.availableSubServicesPublicConfigList).toHaveLength(1);
+    });
+    it("ignores undefined parentsServices (treated as main service)", () => {
+        const result = (0, getAvailableServicesPublicConfigForVehicleType_1.getAvailableServicesPublicConfigForVehicleType)({
+            countryServicesPublicConfig: {
+                [enums_1.ServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.firestoreServicesPublicConfigStub)({
+                    isAvailable: true,
+                    parentsServices: undefined,
+                    byVehicleType: {
+                        [enums_1.VehicleTypes.SEDAN]: {
+                            minimumPriceInCents: 1000,
+                            maximumPriceInCents: 2000,
+                            recommendedPriceInCents: 1500,
+                            durationInMinutes: 60,
+                        },
+                    },
+                }),
+            },
+            vehicleType: enums_1.VehicleTypes.SEDAN,
+        });
+        expect(result.availableMainServicesPublicConfigList).toHaveLength(1);
+        expect(result.availableSubServicesPublicConfigList).toEqual([]);
+    });
+});

package/dist/firebase/firestore/utils/configs/getAvailableServicesPublicConfigForVehicleType.d.ts

@@ -0,0 +1,6 @@
+import type { FirestoreServicesPublicConfig } from "../../types";
+import type { GetAvailableServicesPublicConfigForVehicleTypeParams } from "./types";
+export declare function getAvailableServicesPublicConfigForVehicleType({ countryServicesPublicConfig, vehicleType, }: GetAvailableServicesPublicConfigForVehicleTypeParams): {
+    availableMainServicesPublicConfigList: FirestoreServicesPublicConfig[];
+    availableSubServicesPublicConfigList: FirestoreServicesPublicConfig[];
+};

package/dist/firebase/firestore/utils/configs/getAvailableServicesPublicConfigForVehicleType.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAvailableServicesPublicConfigForVehicleType = getAvailableServicesPublicConfigForVehicleType;
+function getAvailableServicesPublicConfigForVehicleType({ countryServicesPublicConfig, vehicleType, }) {
+    const availableMainServicesPublicConfigList = [];
+    const availableSubServicesPublicConfigList = [];
+    for (const servicePublicConfig of Object.values(countryServicesPublicConfig)) {
+        if (!servicePublicConfig.isAvailable)
+            continue;
+        const servicePublicConfigByVehicleType = servicePublicConfig.byVehicleType[vehicleType];
+        if (!servicePublicConfigByVehicleType)
+            continue;
+        if (!servicePublicConfig.parentsServices?.length) {
+            availableMainServicesPublicConfigList.push(servicePublicConfig);
+        }
+        else {
+            availableSubServicesPublicConfigList.push(servicePublicConfig);
+        }
+    }
+    return {
+        availableMainServicesPublicConfigList,
+        availableSubServicesPublicConfigList,
+    };
+}

package/dist/firebase/firestore/utils/configs/index.d.ts

@@ -0,0 +1 @@
+export * from "./getAvailableServicesPublicConfigForVehicleType";

package/dist/firebase/firestore/utils/configs/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./getAvailableServicesPublicConfigForVehicleType"), exports);

package/dist/firebase/firestore/utils/configs/types/GetAvailableServicesPublicConfigForVehicleTypeParams.type.d.ts

@@ -0,0 +1,6 @@
+import type { VehicleTypes } from "../../../enums";
+import type { CountryServicesPublicConfig } from "../../../types";
+export type GetAvailableServicesPublicConfigForVehicleTypeParams = {
+    countryServicesPublicConfig: CountryServicesPublicConfig;
+    vehicleType: VehicleTypes;
+};

package/dist/firebase/firestore/utils/configs/types/index.d.ts

@@ -0,0 +1 @@
+export * from "./GetAvailableServicesPublicConfigForVehicleTypeParams.type";

package/dist/firebase/firestore/utils/configs/types/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./GetAvailableServicesPublicConfigForVehicleTypeParams.type"), exports);

package/dist/firebase/firestore/utils/dataValidators/company/index.d.ts

@@ -1,3 +1 @@
-export * from "./isCompanyVatValid.util";
-export * from "./isLegalAddressValid.util";
 export * from "./isFrenchCompanyRegistrationValid.util";

package/dist/firebase/firestore/utils/dataValidators/company/index.js

@@ -14,6 +14,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./isCompanyVatValid.util"), exports);
-__exportStar(require("./isLegalAddressValid.util"), exports);
 __exportStar(require("./isFrenchCompanyRegistrationValid.util"), exports);

package/dist/firebase/firestore/utils/dataValidators/index.d.ts

@@ -1,3 +1,3 @@
-export * from "./professionalService";
 export * from "./company";
 export * from "./slots";
+export * from "./services";

package/dist/firebase/firestore/utils/dataValidators/index.js

@@ -14,6 +14,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./professionalService"), exports);
 __exportStar(require("./company"), exports);
 __exportStar(require("./slots"), exports);
+__exportStar(require("./services"), exports);

package/dist/firebase/firestore/utils/dataValidators/services/__tests__/isValidProfessionalService.test.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const enums_1 = require("../../../../../../enums");
+const errors_1 = require("../../../../../../errors");
+const enums_2 = require("../../../../enums");
+const stubs_1 = require("../../../stubs");
+const isValidProfessionalService_1 = require("../isValidProfessionalService");
+const isValidServicePricingAndDurationForVehicle_1 = require("../isValidServicePricingAndDurationForVehicle");
+jest.mock("../isValidServicePricingAndDurationForVehicle");
+describe("isValidProfessionalService", () => {
+    let defaultProps;
+    let isValidServicePricingAndDurationForVehicleMock;
+    let isValidServicePricingAndDurationForVehicleReturnValue;
+    beforeEach(() => {
+        defaultProps = {
+            professionalService: {
+                isActive: true,
+                type: enums_2.ServicesTypes.EXTERIOR_CLEANING,
+                pricingAndDurationByVehicleType: {
+                    [enums_2.VehicleTypes.SEDAN]: {
+                        isActive: true,
+                        type: enums_2.VehicleTypes.SEDAN,
+                        pricePreTaxInCents: 2000,
+                        currency: enums_1.SupportedIsoCurrency.EUR,
+                        durationInMinutes: 30,
+                    },
+                },
+            },
+            countryServicePublicConfig: (0, stubs_1.countryServicesPublicConfigStub)({
+                [enums_2.ServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.firestoreServicesPublicConfigStub)({}),
+            }),
+        };
+        isValidServicePricingAndDurationForVehicleMock =
+            isValidServicePricingAndDurationForVehicle_1.isValidServicePricingAndDurationForVehicle;
+        isValidServicePricingAndDurationForVehicleReturnValue = true;
+        isValidServicePricingAndDurationForVehicleMock.mockImplementation(() => {
+            return isValidServicePricingAndDurationForVehicleReturnValue;
+        });
+    });
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    it("should not throw if is a valid service with empty pricing and empty subservice", async () => {
+        await expect((0, isValidProfessionalService_1.isValidProfessionalService)(defaultProps)).resolves.not.toThrow();
+    });
+    describe("Active", () => {
+        it("should throw if the active field is not a boolean", async () => {
+            defaultProps.professionalService.isActive = "yes";
+            await expect((0, isValidProfessionalService_1.isValidProfessionalService)(defaultProps)).rejects.toThrow(new errors_1.DoctoCarError("Professional service is active is required and must be a boolean", errors_1.DoctoCarValidationErrorCodes.INVALID_SERVICE_IS_ACTIVE));
+            expect(isValidServicePricingAndDurationForVehicleMock).not.toHaveBeenCalled();
+        });
+        it("should throw if the active field is not provided", async () => {
+            defaultProps.professionalService.isActive = undefined;
+            await expect((0, isValidProfessionalService_1.isValidProfessionalService)(defaultProps)).rejects.toThrow(new errors_1.DoctoCarError("Professional service is active is required and must be a boolean", errors_1.DoctoCarValidationErrorCodes.INVALID_SERVICE_IS_ACTIVE));
+            expect(isValidServicePricingAndDurationForVehicleMock).not.toHaveBeenCalled();
+        });
+    });
+    describe("Service type", () => {
+        it("should throw if the service type is not a valid ServicesTypes", async () => {
+            defaultProps.professionalService.type = "INVALID_TYPE";
+            await expect((0, isValidProfessionalService_1.isValidProfessionalService)(defaultProps)).rejects.toThrow();
+            expect(isValidServicePricingAndDurationForVehicleMock).not.toHaveBeenCalled();
+        });
+        it("should throw if the type is not provided", async () => {
+            defaultProps.professionalService.type = undefined;
+            await expect((0, isValidProfessionalService_1.isValidProfessionalService)(defaultProps)).rejects.toThrow();
+            expect(isValidServicePricingAndDurationForVehicleMock).not.toHaveBeenCalled();
+        });
+    });
+    describe("Professional service public config", () => {
+        it("should throw if the professional service public config is not defined for the professional service type", async () => {
+            defaultProps.countryServicePublicConfig = {};
+            await expect((0, isValidProfessionalService_1.isValidProfessionalService)(defaultProps)).rejects.toThrow(new errors_1.DoctoCarError("Professional service public config is not defined for the professional service type", errors_1.DoctoCarValidationErrorCodes.INVALID_SERVICE_TYPE));
+            expect(isValidServicePricingAndDurationForVehicleMock).not.toHaveBeenCalled();
+        });
+    });
+    describe("Price and duration", () => {
+        it("should not throw if isValidServicePricingAndDurationForVehicle return true", async () => {
+            isValidServicePricingAndDurationForVehicleReturnValue = true;
+            isValidServicePricingAndDurationForVehicleMock.mockReturnValue(isValidServicePricingAndDurationForVehicleReturnValue);
+            await expect((0, isValidProfessionalService_1.isValidProfessionalService)(defaultProps)).resolves.not.toThrow();
+            expect(isValidServicePricingAndDurationForVehicleMock).toHaveBeenCalledTimes(1);
+            expect(isValidServicePricingAndDurationForVehicleMock).toHaveBeenCalledWith({
+                servicePublicConfig: defaultProps.countryServicePublicConfig[defaultProps.professionalService.type],
+                servicePricingAndDurationForVehicle: defaultProps.professionalService.pricingAndDurationByVehicleType[enums_2.VehicleTypes.SEDAN],
+            });
+        });
+        it("Should throw if isValidServicePricingAndDurationForVehicle return false", async () => {
+            isValidServicePricingAndDurationForVehicleReturnValue = false;
+            isValidServicePricingAndDurationForVehicleMock.mockReturnValue(isValidServicePricingAndDurationForVehicleReturnValue);
+            await expect((0, isValidProfessionalService_1.isValidProfessionalService)(defaultProps)).rejects.toThrow();
+        });
+    });
+    describe("parentsServices", () => {
+        it("Should throw if a service does not have the parents services indicated in the config", async () => {
+            defaultProps.professionalService = {
+                isActive: true,
+                type: enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT,
+                parentsServices: [],
+                pricingAndDurationByVehicleType: {},
+            };
+            defaultProps.countryServicePublicConfig = (0, stubs_1.countryServicesPublicConfigStub)({
+                [enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT]: (0, stubs_1.firestoreServicesPublicConfigStub)({
+                    parentsServices: [
+                        enums_2.ServicesTypes.INTERIOR_CLEANING,
+                        enums_2.ServicesTypes.INTERIOR_AND_EXTERIOR_CLEANING,
+                    ],
+                }),
+            });
+            await expect((0, isValidProfessionalService_1.isValidProfessionalService)(defaultProps)).rejects.toThrow();
+        });
+        it("Should not throw if a valid service have the parents services indicated in the config", async () => {
+            defaultProps.professionalService = {
+                isActive: true,
+                type: enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT,
+                parentsServices: [
+                    enums_2.ServicesTypes.INTERIOR_CLEANING,
+                    enums_2.ServicesTypes.INTERIOR_AND_EXTERIOR_CLEANING,
+                ],
+                pricingAndDurationByVehicleType: {},
+            };
+            defaultProps.countryServicePublicConfig = (0, stubs_1.countryServicesPublicConfigStub)({
+                [enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT]: (0, stubs_1.firestoreServicesPublicConfigStub)({
+                    parentsServices: [
+                        enums_2.ServicesTypes.INTERIOR_CLEANING,
+                        enums_2.ServicesTypes.INTERIOR_AND_EXTERIOR_CLEANING,
+                    ],
+                }),
+            });
+            await expect((0, isValidProfessionalService_1.isValidProfessionalService)(defaultProps)).resolves.not.toThrow();
+        });
+        it("Should throw if a valid service have the parents services indicated in the config but miss one", async () => {
+            defaultProps.professionalService = {
+                isActive: true,
+                type: enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT,
+                parentsServices: [enums_2.ServicesTypes.INTERIOR_CLEANING],
+                pricingAndDurationByVehicleType: {},
+            };
+            defaultProps.countryServicePublicConfig = (0, stubs_1.countryServicesPublicConfigStub)({
+                [enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT]: (0, stubs_1.firestoreServicesPublicConfigStub)({
+                    parentsServices: [
+                        enums_2.ServicesTypes.INTERIOR_CLEANING,
+                        enums_2.ServicesTypes.INTERIOR_AND_EXTERIOR_CLEANING,
+                    ],
+                }),
+            });
+            await expect((0, isValidProfessionalService_1.isValidProfessionalService)(defaultProps)).rejects.toThrow();
+        });
+        it("Should throw if a valid service have the parents services indicated in the config but have one more", async () => {
+            defaultProps.professionalService = {
+                isActive: true,
+                type: enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT,
+                parentsServices: [
+                    enums_2.ServicesTypes.INTERIOR_CLEANING,
+                    enums_2.ServicesTypes.INTERIOR_AND_EXTERIOR_CLEANING,
+                    enums_2.ServicesTypes.EXTERIOR_CLEANING,
+                ],
+                pricingAndDurationByVehicleType: {},
+            };
+            defaultProps.countryServicePublicConfig = (0, stubs_1.countryServicesPublicConfigStub)({
+                [enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT]: (0, stubs_1.firestoreServicesPublicConfigStub)({
+                    parentsServices: [
+                        enums_2.ServicesTypes.INTERIOR_CLEANING,
+                        enums_2.ServicesTypes.INTERIOR_AND_EXTERIOR_CLEANING,
+                    ],
+                }),
+            });
+            await expect((0, isValidProfessionalService_1.isValidProfessionalService)(defaultProps)).rejects.toThrow();
+        });
+    });
+});