@doctocar/tooling 0.3.1-4 → 0.3.1-40

package/dist/firebase/firestore/utils/dataValidators/professionalService/__tests__/isValidServicePricingAndDurationForVehicle.test.d.ts

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

package/dist/firebase/firestore/utils/dataValidators/professionalService/__tests__/isValidServicePricingAndDurationForVehicle.test.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const enums_1 = require("../../../../../../enums");
+const constants_1 = require("../../../../constants");
+const enums_2 = require("../../../../enums");
+const stubs_1 = require("../../../stubs");
+const isValidServicePricingAndDurationForVehicle_1 = require("../isValidServicePricingAndDurationForVehicle");
+describe("isValidServicePricingAndDurationForVehicle", () => {
+    let defaultProps;
+    let minimumPriceInCents;
+    let maximumPriceInCents;
+    let durationInMinutes;
+    beforeEach(() => {
+        minimumPriceInCents = constants_1.PROFESSIONAL_SERVICE_MINIMUM_PRICE_INCREMENT_IN_CENTS;
+        maximumPriceInCents =
+            constants_1.PROFESSIONAL_SERVICE_MINIMUM_PRICE_INCREMENT_IN_CENTS * 10;
+        durationInMinutes =
+            constants_1.PROFESSIONAL_SERVICE_MINIMUM_DURATION_INCREMENT_IN_MINUTES;
+        defaultProps = {
+            servicePublicConfig: (0, stubs_1.firestoreServicesPublicConfigStub)({
+                byVehicleType: {
+                    [enums_2.VehicleTypes.CITY_CAR]: {
+                        durationInMinutes: durationInMinutes,
+                        minimumPriceInCents: minimumPriceInCents,
+                        maximumPriceInCents: maximumPriceInCents,
+                        recommendedPriceInCents: maximumPriceInCents,
+                    },
+                    [enums_2.VehicleTypes.SUV]: {
+                        durationInMinutes: durationInMinutes,
+                        minimumPriceInCents: minimumPriceInCents,
+                        maximumPriceInCents: maximumPriceInCents,
+                        recommendedPriceInCents: maximumPriceInCents,
+                    },
+                    [enums_2.VehicleTypes.MOTORCYCLE]: {
+                        durationInMinutes: durationInMinutes,
+                        minimumPriceInCents: minimumPriceInCents,
+                        maximumPriceInCents: maximumPriceInCents,
+                        recommendedPriceInCents: maximumPriceInCents,
+                    },
+                    [enums_2.VehicleTypes.SEDAN]: {
+                        durationInMinutes: durationInMinutes,
+                        minimumPriceInCents: minimumPriceInCents,
+                        maximumPriceInCents: maximumPriceInCents,
+                        recommendedPriceInCents: maximumPriceInCents,
+                    },
+                    [enums_2.VehicleTypes.PICKUP_TRUCK]: {
+                        durationInMinutes: durationInMinutes,
+                        minimumPriceInCents: minimumPriceInCents,
+                        maximumPriceInCents: maximumPriceInCents,
+                        recommendedPriceInCents: maximumPriceInCents,
+                    },
+                    [enums_2.VehicleTypes.VAN]: {
+                        durationInMinutes: durationInMinutes,
+                        minimumPriceInCents: minimumPriceInCents,
+                        maximumPriceInCents: maximumPriceInCents,
+                        recommendedPriceInCents: maximumPriceInCents,
+                    },
+                },
+            }),
+            servicePricingAndDurationForVehicle: {
+                isActive: true,
+                type: enums_2.VehicleTypes.CITY_CAR,
+                pricePreTaxInCents: minimumPriceInCents,
+                currency: enums_1.SupportedIsoCurrency.EUR,
+                durationInMinutes: durationInMinutes,
+            },
+        };
+    });
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    it("should return true if pricing is valid for service", () => {
+        expect((0, isValidServicePricingAndDurationForVehicle_1.isValidServicePricingAndDurationForVehicle)(defaultProps)).toBe(true);
+    });
+    it("Should return false if active is not a boolean", () => {
+        defaultProps.servicePricingAndDurationForVehicle.isActive =
+            "Not a boolean";
+        expect((0, isValidServicePricingAndDurationForVehicle_1.isValidServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
+    });
+    it("Should return false if service public config is not defined for the vehicle type", () => {
+        defaultProps.servicePublicConfig.byVehicleType = {
+            [enums_2.VehicleTypes.CITY_CAR]: undefined,
+        };
+        expect((0, isValidServicePricingAndDurationForVehicle_1.isValidServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
+    });
+    it("Should return false if pricePreTaxInCents is not a number", () => {
+        defaultProps.servicePricingAndDurationForVehicle.pricePreTaxInCents =
+            "Not a number";
+        expect((0, isValidServicePricingAndDurationForVehicle_1.isValidServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
+    });
+    it("Should return false if pricePreTaxInCents is less than the service minimum", () => {
+        defaultProps.servicePricingAndDurationForVehicle.pricePreTaxInCents =
+            minimumPriceInCents -
+                constants_1.PROFESSIONAL_SERVICE_MINIMUM_PRICE_INCREMENT_IN_CENTS;
+        expect((0, isValidServicePricingAndDurationForVehicle_1.isValidServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
+    });
+    it("Should return false if pricePreTaxInCents is more than PROFESSIONAL_SERVICE_MAXIMUM_PRICE_IN_CENTS", () => {
+        defaultProps.servicePricingAndDurationForVehicle.pricePreTaxInCents =
+            maximumPriceInCents +
+                constants_1.PROFESSIONAL_SERVICE_MINIMUM_PRICE_INCREMENT_IN_CENTS;
+        expect((0, isValidServicePricingAndDurationForVehicle_1.isValidServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
+    });
+    it("Should return false if pricePreTaxInCents is not a multiple of PROFESSIONAL_SERVICE_MINIMUM_PRICE_INCREMENT_IN_CENTS", () => {
+        defaultProps.servicePricingAndDurationForVehicle.pricePreTaxInCents =
+            maximumPriceInCents - 1;
+        expect((0, isValidServicePricingAndDurationForVehicle_1.isValidServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
+    });
+    it("Should return false if SupportedIsoCurrency is not a valid currency", () => {
+        defaultProps.servicePricingAndDurationForVehicle.currency =
+            "Not a valid currency";
+        expect((0, isValidServicePricingAndDurationForVehicle_1.isValidServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
+    });
+    it("Should return false if durationInMinutes is not a number", () => {
+        defaultProps.servicePricingAndDurationForVehicle.durationInMinutes =
+            "Not a number";
+        expect((0, isValidServicePricingAndDurationForVehicle_1.isValidServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
+    });
+    it("Should return false if durationInMinutes is less than the duration for the service", () => {
+        defaultProps.servicePricingAndDurationForVehicle.durationInMinutes =
+            durationInMinutes -
+                constants_1.PROFESSIONAL_SERVICE_MINIMUM_DURATION_INCREMENT_IN_MINUTES;
+        expect((0, isValidServicePricingAndDurationForVehicle_1.isValidServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
+    });
+    it("Should return false if durationInMinutes is more than the duration for the service", () => {
+        defaultProps.servicePricingAndDurationForVehicle.durationInMinutes =
+            durationInMinutes +
+                constants_1.PROFESSIONAL_SERVICE_MINIMUM_DURATION_INCREMENT_IN_MINUTES;
+        expect((0, isValidServicePricingAndDurationForVehicle_1.isValidServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
+    });
+    it("Should return false if the type is not a valid vehicle type", () => {
+        defaultProps.servicePricingAndDurationForVehicle.type =
+            "Not a vehicle type";
+        expect((0, isValidServicePricingAndDurationForVehicle_1.isValidServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
+    });
+});

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

@@ -1,4 +1,3 @@
-export * from "./isValidProfessionalServicePricingAndDurationForVehicle";
+export * from "./isValidServicePricingAndDurationForVehicle";
 export * from "./isValidProfessionalService";
-export * from "./isValidVehicleForProfessionalService";
 export * from "./isValidProfessionalServiceType";

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

@@ -14,7 +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("./isValidProfessionalServicePricingAndDurationForVehicle"), exports);
+__exportStar(require("./isValidServicePricingAndDurationForVehicle"), exports);
 __exportStar(require("./isValidProfessionalService"), exports);
-__exportStar(require("./isValidVehicleForProfessionalService"), exports);
 __exportStar(require("./isValidProfessionalServiceType"), exports);

package/dist/firebase/firestore/utils/dataValidators/professionalService/isValidProfessionalService.js

@@ -3,15 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.isValidProfessionalService = isValidProfessionalService;
 const errors_1 = require("../../../../../errors");
 const enums_1 = require("../../../enums");
-const isValidProfessionalServicePricingAndDurationForVehicle_1 = require("./isValidProfessionalServicePricingAndDurationForVehicle");
-const isValidVehicleForProfessionalService_1 = require("./isValidVehicleForProfessionalService");
+const isValidServicePricingAndDurationForVehicle_1 = require("./isValidServicePricingAndDurationForVehicle");
 async function isValidProfessionalService({ professionalService, countryProfessionalServicePublicConfig, }) {
     if (professionalService.isActive === undefined ||
         typeof professionalService.isActive !== "boolean") {
         throw new errors_1.DoctoCarError("Professional service is active is required and must be a boolean", errors_1.DoctoCarValidationErrorCodes.INVALID_SERVICE_IS_ACTIVE);
     }
     if (professionalService.type === undefined ||
-        !Object.values(enums_1.ProfessionalServicesTypes).includes(professionalService.type)) {
+        !Object.values(enums_1.ServicesTypes).includes(professionalService.type)) {
         throw new errors_1.DoctoCarError("Professional service type is required and must be a valid professional service type", errors_1.DoctoCarValidationErrorCodes.INVALID_SERVICE_TYPE);
     }
     const professionalServicePublicConfig = countryProfessionalServicePublicConfig[professionalService.type];
@@ -19,16 +18,10 @@ async function isValidProfessionalService({ professionalService, countryProfessi
         throw new errors_1.DoctoCarError("Professional service public config is not defined for the professional service type", errors_1.DoctoCarValidationErrorCodes.INVALID_SERVICE_TYPE);
     }
     if (professionalService.pricingAndDurationByVehicleType !== undefined) {
-        for (const [vehicleType, pricingAndDuration] of Object.entries(professionalService.pricingAndDurationByVehicleType)) {
-            if (!(0, isValidVehicleForProfessionalService_1.isValidVehicleForProfessionalService)({
-                vehicleType,
-                professionalServicePublicConfig,
-            })) {
-                throw new errors_1.DoctoCarError("Vehicle type is not valid for the professional service", errors_1.DoctoCarValidationErrorCodes.INVALID_SERVICE_VEHICLE_TYPE);
-            }
-            if (!(0, isValidProfessionalServicePricingAndDurationForVehicle_1.isValidProfessionalServicePricingAndDurationForVehicle)({
-                professionalServicePublicConfig: professionalServicePublicConfig,
-                servicePricingAndDuration: pricingAndDuration,
+        for (const pricingAndDuration of Object.values(professionalService.pricingAndDurationByVehicleType)) {
+            if (!(0, isValidServicePricingAndDurationForVehicle_1.isValidServicePricingAndDurationForVehicle)({
+                servicePublicConfig: professionalServicePublicConfig,
+                servicePricingAndDurationForVehicle: pricingAndDuration,
             })) {
                 throw new errors_1.DoctoCarError("Pricing and duration for vehicle type is not valid for the professional service", errors_1.DoctoCarValidationErrorCodes.INVALID_SERVICE_VEHICLE_TYPE_PRICING_AND_DURATION);
             }

package/dist/firebase/firestore/utils/dataValidators/professionalService/isValidProfessionalServiceType.d.ts

@@ -1,2 +1,2 @@
-import { ProfessionalServicesTypes } from "../../../enums";
-export declare function isValidProfessionalServiceType(professionalServiceType: string): professionalServiceType is ProfessionalServicesTypes;
+import { ServicesTypes } from "../../../enums";
+export declare function isValidProfessionalServiceType(professionalServiceType: string): professionalServiceType is ServicesTypes;

package/dist/firebase/firestore/utils/dataValidators/professionalService/isValidProfessionalServiceType.js

@@ -3,5 +3,5 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.isValidProfessionalServiceType = isValidProfessionalServiceType;
 const enums_1 = require("../../../enums");
 function isValidProfessionalServiceType(professionalServiceType) {
-    return Object.values(enums_1.ProfessionalServicesTypes).includes(professionalServiceType);
+    return Object.values(enums_1.ServicesTypes).includes(professionalServiceType);
 }

package/dist/firebase/firestore/utils/dataValidators/professionalService/isValidServicePricingAndDurationForVehicle.d.ts

@@ -0,0 +1,2 @@
+import type { IsValidServicePricingAndDurationForVehicleParams } from "./types";
+export declare function isValidServicePricingAndDurationForVehicle({ servicePricingAndDurationForVehicle, servicePublicConfig, }: IsValidServicePricingAndDurationForVehicleParams): boolean;

package/dist/firebase/firestore/utils/dataValidators/professionalService/isValidServicePricingAndDurationForVehicle.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidServicePricingAndDurationForVehicle = isValidServicePricingAndDurationForVehicle;
+const enums_1 = require("../../../../../enums");
+const constants_1 = require("../../../constants");
+const enums_2 = require("../../../enums");
+function isValidServicePricingAndDurationForVehicle({ servicePricingAndDurationForVehicle, servicePublicConfig, }) {
+    const servicePublicConfigByVehicleType = servicePublicConfig.byVehicleType;
+    const servicePublicConfigForVehicle = servicePublicConfigByVehicleType[servicePricingAndDurationForVehicle.type];
+    return (servicePublicConfigForVehicle !== undefined &&
+        typeof servicePricingAndDurationForVehicle.isActive === "boolean" &&
+        Object.values(enums_2.VehicleTypes).includes(servicePricingAndDurationForVehicle.type) &&
+        typeof servicePricingAndDurationForVehicle.pricePreTaxInCents ===
+            "number" &&
+        servicePricingAndDurationForVehicle.pricePreTaxInCents >=
+            servicePublicConfigForVehicle.minimumPriceInCents &&
+        servicePricingAndDurationForVehicle.pricePreTaxInCents <=
+            servicePublicConfigForVehicle.maximumPriceInCents &&
+        servicePricingAndDurationForVehicle.pricePreTaxInCents %
+            constants_1.PROFESSIONAL_SERVICE_MINIMUM_PRICE_INCREMENT_IN_CENTS ===
+            0 &&
+        Object.values(enums_1.SupportedIsoCurrency).includes(servicePricingAndDurationForVehicle.currency) &&
+        typeof servicePricingAndDurationForVehicle.durationInMinutes === "number" &&
+        servicePricingAndDurationForVehicle.durationInMinutes ==
+            servicePublicConfigForVehicle.durationInMinutes &&
+        servicePricingAndDurationForVehicle.durationInMinutes %
+            constants_1.PROFESSIONAL_SERVICE_MINIMUM_DURATION_INCREMENT_IN_MINUTES ===
+            0);
+}

package/dist/firebase/firestore/utils/dataValidators/professionalService/types/IsValidProfessionalServiceParams.type.d.ts

@@ -1,6 +1,6 @@
-import type { ProfessionalServicesTypes } from "../../../../enums";
+import type { ServicesTypes } from "../../../../enums";
 import type { CountryServicesPublicConfig, ProfessionalService } from "../../../../types";
 export type IsValidProfessionalServiceParams = {
-    professionalService: ProfessionalService<ProfessionalServicesTypes>;
+    professionalService: ProfessionalService<ServicesTypes>;
     countryProfessionalServicePublicConfig: CountryServicesPublicConfig;
 };

package/dist/firebase/firestore/utils/dataValidators/professionalService/types/IsValidServicePricingAndDurationForVehicleParams.type.d.ts

@@ -0,0 +1,5 @@
+import type { FirestoreServicesPublicConfig, ServicePricingAndDurationForVehicle } from "../../../../types";
+export type IsValidServicePricingAndDurationForVehicleParams = {
+    servicePricingAndDurationForVehicle: ServicePricingAndDurationForVehicle;
+    servicePublicConfig: FirestoreServicesPublicConfig;
+};

package/dist/firebase/firestore/utils/dataValidators/professionalService/types/IsValidServicePricingAndDurationForVehicleParams.type.js

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

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

@@ -1,3 +1,3 @@
 export * from "./IsValidProfessionalServiceParams.type";
-export * from "./IsValidProfessionalServicePricingAndDurationForVehicleParams.type";
+export * from "./IsValidServicePricingAndDurationForVehicleParams.type";
 export * from "./IsValidVehicleForProfessionalServiceParams.type";

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

@@ -15,5 +15,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./IsValidProfessionalServiceParams.type"), exports);
-__exportStar(require("./IsValidProfessionalServicePricingAndDurationForVehicleParams.type"), exports);
+__exportStar(require("./IsValidServicePricingAndDurationForVehicleParams.type"), exports);
 __exportStar(require("./IsValidVehicleForProfessionalServiceParams.type"), exports);

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

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

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 = {
+            providerService: {
+                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.providerService.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.providerService.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.providerService.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.providerService.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.providerService.type],
+                servicePricingAndDurationForVehicle: defaultProps.providerService.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.providerService = {
+                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.providerService = {
+                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.providerService = {
+                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.providerService = {
+                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();
+        });
+    });
+});

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

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

package/dist/firebase/firestore/utils/dataValidators/services/__tests__/isValidProviderService.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 isValidProviderService_1 = require("../isValidProviderService");
+const isValidServicePricingAndDurationForVehicle_1 = require("../isValidServicePricingAndDurationForVehicle");
+jest.mock("../isValidServicePricingAndDurationForVehicle");
+describe("isValidProviderService", () => {
+    let defaultProps;
+    let isValidServicePricingAndDurationForVehicleMock;
+    let isValidServicePricingAndDurationForVehicleReturnValue;
+    beforeEach(() => {
+        defaultProps = {
+            providerService: {
+                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, isValidProviderService_1.isValidProviderService)(defaultProps)).resolves.not.toThrow();
+    });
+    describe("Active", () => {
+        it("should throw if the active field is not a boolean", async () => {
+            defaultProps.providerService.isActive = "yes";
+            await expect((0, isValidProviderService_1.isValidProviderService)(defaultProps)).rejects.toThrow(new errors_1.DoctoCarError("Provider service isActive 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.providerService.isActive = undefined;
+            await expect((0, isValidProviderService_1.isValidProviderService)(defaultProps)).rejects.toThrow(new errors_1.DoctoCarError("Provider service isActive 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.providerService.type = "INVALID_TYPE";
+            await expect((0, isValidProviderService_1.isValidProviderService)(defaultProps)).rejects.toThrow();
+            expect(isValidServicePricingAndDurationForVehicleMock).not.toHaveBeenCalled();
+        });
+        it("should throw if the type is not provided", async () => {
+            defaultProps.providerService.type = undefined;
+            await expect((0, isValidProviderService_1.isValidProviderService)(defaultProps)).rejects.toThrow();
+            expect(isValidServicePricingAndDurationForVehicleMock).not.toHaveBeenCalled();
+        });
+    });
+    describe("Country services public config", () => {
+        it("should throw if there is no public config entry for the provider service type", async () => {
+            defaultProps.countryServicePublicConfig = {};
+            await expect((0, isValidProviderService_1.isValidProviderService)(defaultProps)).rejects.toThrow(new errors_1.DoctoCarError("Country services public config has no entry for this provider 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, isValidProviderService_1.isValidProviderService)(defaultProps)).resolves.not.toThrow();
+            expect(isValidServicePricingAndDurationForVehicleMock).toHaveBeenCalledTimes(1);
+            expect(isValidServicePricingAndDurationForVehicleMock).toHaveBeenCalledWith({
+                servicePublicConfig: defaultProps.countryServicePublicConfig[defaultProps.providerService.type],
+                servicePricingAndDurationForVehicle: defaultProps.providerService.pricingAndDurationByVehicleType[enums_2.VehicleTypes.SEDAN],
+            });
+        });
+        it("Should throw if isValidServicePricingAndDurationForVehicle return false", async () => {
+            isValidServicePricingAndDurationForVehicleReturnValue = false;
+            isValidServicePricingAndDurationForVehicleMock.mockReturnValue(isValidServicePricingAndDurationForVehicleReturnValue);
+            await expect((0, isValidProviderService_1.isValidProviderService)(defaultProps)).rejects.toThrow();
+        });
+    });
+    describe("parentsServices", () => {
+        it("Should throw if a service does not have the parents services indicated in the config", async () => {
+            defaultProps.providerService = {
+                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, isValidProviderService_1.isValidProviderService)(defaultProps)).rejects.toThrow();
+        });
+        it("Should not throw if a valid service have the parents services indicated in the config", async () => {
+            defaultProps.providerService = {
+                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, isValidProviderService_1.isValidProviderService)(defaultProps)).resolves.not.toThrow();
+        });
+        it("Should throw if a valid service have the parents services indicated in the config but miss one", async () => {
+            defaultProps.providerService = {
+                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, isValidProviderService_1.isValidProviderService)(defaultProps)).rejects.toThrow();
+        });
+        it("Should throw if a valid service have the parents services indicated in the config but have one more", async () => {
+            defaultProps.providerService = {
+                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, isValidProviderService_1.isValidProviderService)(defaultProps)).rejects.toThrow();
+        });
+    });
+});

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

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