@blackcode_sa/metaestetics-api 1.10.0 → 1.11.1

package/src/backoffice/services/__tests__/technology.service.test.ts

@@ -1,1097 +0,0 @@
-import { TechnologyService } from "../technology.service";
-import { Technology } from "../../types/technology.types";
-import {
-  collection,
-  doc,
-  getDoc,
-  getDocs,
-  addDoc,
-  updateDoc,
-  query,
-  where,
-  arrayUnion,
-  arrayRemove,
-} from "firebase/firestore";
-import { DEFAULT_CERTIFICATION_REQUIREMENT } from "../../../backoffice/constants/certification.constants";
-import { ProductService } from "../product.service";
-import { Product } from "../../types/product.types";
-import { RequirementType, TimeUnit } from "../../types/requirement.types";
-import {
-  CertificationLevel,
-  CertificationSpecialty,
-} from "../../types/static/certification.types";
-import { BlockingCondition } from "../../types/static/blocking-condition.types";
-import { Contraindication } from "../../types/static/contraindication.types";
-import { TreatmentBenefit } from "../../types/static/treatment-benefit.types";
-import { collectionGroup } from "firebase/firestore";
-
-jest.mock("firebase/firestore");
-jest.mock("../../../config/firebase", () => ({
-  getFirebaseInstance: jest.fn().mockResolvedValue({
-    db: {},
-    auth: {},
-  }),
-}));
-
-// Konstante za kolekcije
-const CATEGORIES_COLLECTION = "backoffice_categories";
-const SUBCATEGORIES_COLLECTION = "subcategories";
-const TECHNOLOGIES_COLLECTION = "technologies";
-const PRODUCTS_COLLECTION = "products";
-const BRANDS_COLLECTION = "backoffice_brands";
-
-// Mock baze podataka
-const mockDb = {} as any;
-
-describe("TechnologyService", () => {
-  let service: TechnologyService;
-  const CATEGORY_ID = "test-category-id";
-  const SUBCATEGORY_ID = "test-subcategory-id";
-
-  const mockTechnology: Omit<Technology, "id" | "createdAt" | "updatedAt"> = {
-    name: "Test Technology",
-    description: "Test Description",
-    subcategoryId: SUBCATEGORY_ID,
-    isActive: true,
-    requirements: {
-      pre: [],
-      post: [],
-    },
-    blockingConditions: [],
-    contraindications: [],
-    benefits: [],
-    certificationRequirement: DEFAULT_CERTIFICATION_REQUIREMENT,
-  };
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-    service = new TechnologyService();
-  });
-
-  describe("create", () => {
-    it("treba da kreira novu tehnologiju", async () => {
-      const mockDocRef = { id: "test-id" };
-      (collection as jest.Mock).mockReturnValue("technologies-collection");
-      (addDoc as jest.Mock).mockResolvedValue(mockDocRef);
-
-      const result = await service.create(
-        CATEGORY_ID,
-        SUBCATEGORY_ID,
-        mockTechnology
-      );
-
-      expect(collection).toHaveBeenCalledWith(
-        mockDb,
-        CATEGORIES_COLLECTION,
-        CATEGORY_ID,
-        SUBCATEGORIES_COLLECTION,
-        SUBCATEGORY_ID,
-        TECHNOLOGIES_COLLECTION
-      );
-      expect(addDoc).toHaveBeenCalledWith(
-        "technologies-collection",
-        expect.objectContaining({
-          ...mockTechnology,
-          createdAt: expect.any(Date),
-          updatedAt: expect.any(Date),
-        })
-      );
-    });
-  });
-
-  describe("getAllBySubcategoryId", () => {
-    it("treba da vrati sve aktivne tehnologije za podkategoriju", async () => {
-      const mockDocs = [
-        {
-          id: "tech-1",
-          data: () => ({
-            ...mockTechnology,
-            createdAt: new Date(),
-            updatedAt: new Date(),
-          }),
-        },
-      ];
-
-      (collection as jest.Mock).mockReturnValue("technologies-collection");
-      (query as jest.Mock).mockReturnValue("filtered-query");
-      (where as jest.Mock).mockReturnValue("where-clause");
-      (getDocs as jest.Mock).mockResolvedValue({ docs: mockDocs });
-
-      const results = await service.getAllBySubcategoryId(
-        CATEGORY_ID,
-        SUBCATEGORY_ID
-      );
-
-      expect(collection).toHaveBeenCalledWith(
-        mockDb,
-        CATEGORIES_COLLECTION,
-        CATEGORY_ID,
-        SUBCATEGORIES_COLLECTION,
-        SUBCATEGORY_ID,
-        TECHNOLOGIES_COLLECTION
-      );
-      expect(query).toHaveBeenCalledWith(
-        "technologies-collection",
-        "where-clause"
-      );
-      expect(where).toHaveBeenCalledWith("isActive", "==", true);
-    });
-  });
-
-  describe("update", () => {
-    it("treba da ažurira postojeću tehnologiju", async () => {
-      const TECHNOLOGY_ID = "test-tech-id";
-      const updateData = { name: "Updated Technology" };
-
-      (collection as jest.Mock).mockReturnValue("technologies-collection");
-      (doc as jest.Mock).mockReturnValue("doc-ref");
-      (updateDoc as jest.Mock).mockResolvedValue(undefined);
-      (getDoc as jest.Mock).mockResolvedValue({
-        exists: () => true,
-        id: TECHNOLOGY_ID,
-        data: () => ({
-          ...mockTechnology,
-          ...updateData,
-          createdAt: new Date(),
-          updatedAt: new Date(),
-        }),
-      });
-
-      await service.update(
-        CATEGORY_ID,
-        SUBCATEGORY_ID,
-        TECHNOLOGY_ID,
-        updateData
-      );
-
-      expect(collection).toHaveBeenCalledWith(
-        mockDb,
-        CATEGORIES_COLLECTION,
-        CATEGORY_ID,
-        SUBCATEGORIES_COLLECTION,
-        SUBCATEGORY_ID,
-        TECHNOLOGIES_COLLECTION
-      );
-      expect(updateDoc).toHaveBeenCalledWith(
-        "doc-ref",
-        expect.objectContaining({
-          ...updateData,
-          updatedAt: expect.any(Date),
-        })
-      );
-    });
-  });
-
-  describe("addRequirement", () => {
-    it("treba da doda novi zahtev tehnologiji", async () => {
-      const TECHNOLOGY_ID = "test-tech-id";
-      const mockRequirement = {
-        id: "req-1",
-        type: RequirementType.PRE,
-        name: "Test Requirement",
-        description: "Test Description",
-        timeframe: {
-          duration: 2,
-          unit: TimeUnit.HOURS,
-          notifyAt: [1, 2],
-        },
-        importance: "high" as const,
-        isActive: true,
-        createdAt: new Date(),
-        updatedAt: new Date(),
-      };
-
-      (collection as jest.Mock).mockReturnValue("technologies-collection");
-      (doc as jest.Mock).mockReturnValue("doc-ref");
-      (updateDoc as jest.Mock).mockResolvedValue(undefined);
-      (getDoc as jest.Mock).mockResolvedValue({
-        exists: () => true,
-        id: TECHNOLOGY_ID,
-        data: () => ({
-          ...mockTechnology,
-          requirements: {
-            pre: [mockRequirement],
-            post: [],
-          },
-          createdAt: new Date(),
-          updatedAt: new Date(),
-        }),
-      });
-
-      const result = await service.addRequirement(
-        CATEGORY_ID,
-        SUBCATEGORY_ID,
-        TECHNOLOGY_ID,
-        mockRequirement
-      );
-
-      expect(updateDoc).toHaveBeenCalledWith(
-        "doc-ref",
-        expect.objectContaining({
-          [`requirements.${
-            mockRequirement.type === RequirementType.PRE ? "pre" : "post"
-          }`]: arrayUnion(mockRequirement),
-          updatedAt: expect.any(Date),
-        })
-      );
-
-      if (result) {
-        expect(result.requirements.pre).toContainEqual(mockRequirement);
-      } else {
-        fail("Technology should exist");
-      }
-    });
-  });
-
-  describe("removeRequirement", () => {
-    it("treba da ukloni zahtev iz tehnologije", async () => {
-      const TECHNOLOGY_ID = "test-tech-id";
-      const mockRequirement = {
-        id: "req-1",
-        type: RequirementType.PRE,
-        name: "Test Requirement",
-        description: "Test Description",
-        timeframe: {
-          duration: 2,
-          unit: TimeUnit.HOURS,
-          notifyAt: [1, 2],
-        },
-        importance: "high" as const,
-        isActive: true,
-        createdAt: new Date(),
-        updatedAt: new Date(),
-      };
-
-      (collection as jest.Mock).mockReturnValue("technologies-collection");
-      (doc as jest.Mock).mockReturnValue("doc-ref");
-      (updateDoc as jest.Mock).mockResolvedValue(undefined);
-      (getDoc as jest.Mock).mockResolvedValue({
-        exists: () => true,
-        id: TECHNOLOGY_ID,
-        data: () => ({
-          ...mockTechnology,
-          requirements: {
-            pre: [],
-            post: [],
-          },
-          createdAt: new Date(),
-          updatedAt: new Date(),
-        }),
-      });
-
-      await service.removeRequirement(
-        CATEGORY_ID,
-        SUBCATEGORY_ID,
-        TECHNOLOGY_ID,
-        mockRequirement
-      );
-
-      expect(updateDoc).toHaveBeenCalledWith(
-        "doc-ref",
-        expect.objectContaining({
-          "requirements.pre": expect.not.arrayContaining([mockRequirement]),
-          updatedAt: expect.any(Date),
-        })
-      );
-    });
-  });
-
-  describe("getRequirements", () => {
-    it("treba da vrati sve zahteve za tehnologiju", async () => {
-      const TECHNOLOGY_ID = "test-tech-id";
-      const mockRequirements = {
-        pre: [
-          {
-            id: "req-1",
-            type: RequirementType.PRE,
-            name: "Pre Requirement",
-          },
-        ],
-        post: [
-          {
-            id: "req-2",
-            type: RequirementType.POST,
-            name: "Post Requirement",
-          },
-        ],
-      };
-
-      (collection as jest.Mock).mockReturnValue("technologies-collection");
-      (doc as jest.Mock).mockReturnValue("doc-ref");
-      (getDoc as jest.Mock).mockResolvedValue({
-        exists: () => true,
-        id: TECHNOLOGY_ID,
-        data: () => ({
-          ...mockTechnology,
-          requirements: mockRequirements,
-          createdAt: new Date(),
-          updatedAt: new Date(),
-        }),
-      });
-
-      const result = await service.getRequirements(
-        CATEGORY_ID,
-        SUBCATEGORY_ID,
-        TECHNOLOGY_ID
-      );
-
-      expect(result).toHaveLength(2);
-      expect(result).toEqual([
-        ...mockRequirements.pre,
-        ...mockRequirements.post,
-      ]);
-    });
-
-    it("treba da vrati zahteve filtirane po tipu", async () => {
-      const TECHNOLOGY_ID = "test-tech-id";
-      const mockRequirements = {
-        pre: [
-          {
-            id: "req-1",
-            type: RequirementType.PRE,
-            name: "Pre Requirement",
-          },
-        ],
-        post: [
-          {
-            id: "req-2",
-            type: RequirementType.POST,
-            name: "Post Requirement",
-          },
-        ],
-      };
-
-      (collection as jest.Mock).mockReturnValue("technologies-collection");
-      (doc as jest.Mock).mockReturnValue("doc-ref");
-      (getDoc as jest.Mock).mockResolvedValue({
-        exists: () => true,
-        id: TECHNOLOGY_ID,
-        data: () => ({
-          ...mockTechnology,
-          requirements: mockRequirements,
-          createdAt: new Date(),
-          updatedAt: new Date(),
-        }),
-      });
-
-      const result = await service.getRequirements(
-        CATEGORY_ID,
-        SUBCATEGORY_ID,
-        TECHNOLOGY_ID,
-        RequirementType.PRE
-      );
-
-      expect(result).toHaveLength(1);
-      expect(result).toEqual(mockRequirements.pre);
-    });
-  });
-
-  describe("getBlockingConditions", () => {
-    it("treba da vrati sve blokirajuće uslove za tehnologiju", async () => {
-      const TECHNOLOGY_ID = "test-tech-id";
-      const mockBlockingConditions = [
-        BlockingCondition.PREGNANCY,
-        BlockingCondition.BREASTFEEDING,
-      ];
-
-      (collection as jest.Mock).mockReturnValue("technologies-collection");
-      (doc as jest.Mock).mockReturnValue("doc-ref");
-      (getDoc as jest.Mock).mockResolvedValue({
-        exists: () => true,
-        id: TECHNOLOGY_ID,
-        data: () => ({
-          ...mockTechnology,
-          blockingConditions: mockBlockingConditions,
-          createdAt: new Date(),
-          updatedAt: new Date(),
-        }),
-      });
-
-      const result = await service.getBlockingConditions(
-        CATEGORY_ID,
-        SUBCATEGORY_ID,
-        TECHNOLOGY_ID
-      );
-
-      expect(result).toEqual(mockBlockingConditions);
-    });
-  });
-
-  describe("getContraindications", () => {
-    it("treba da vrati sve kontraindikacije za tehnologiju", async () => {
-      const TECHNOLOGY_ID = "test-tech-id";
-      const mockContraindications = [
-        Contraindication.SENSITIVE_SKIN,
-        Contraindication.RECENT_TANNING,
-      ];
-
-      (collection as jest.Mock).mockReturnValue("technologies-collection");
-      (doc as jest.Mock).mockReturnValue("doc-ref");
-      (getDoc as jest.Mock).mockResolvedValue({
-        exists: () => true,
-        id: TECHNOLOGY_ID,
-        data: () => ({
-          ...mockTechnology,
-          contraindications: mockContraindications,
-          createdAt: new Date(),
-          updatedAt: new Date(),
-        }),
-      });
-
-      const result = await service.getContraindications(
-        CATEGORY_ID,
-        SUBCATEGORY_ID,
-        TECHNOLOGY_ID
-      );
-
-      expect(result).toEqual(mockContraindications);
-    });
-  });
-
-  describe("getBenefits", () => {
-    it("treba da vrati sve benefite za tehnologiju", async () => {
-      const TECHNOLOGY_ID = "test-tech-id";
-      const mockBenefits = [
-        TreatmentBenefit.WRINKLE_REDUCTION,
-        TreatmentBenefit.SKIN_TIGHTENING,
-      ];
-
-      (collection as jest.Mock).mockReturnValue("technologies-collection");
-      (doc as jest.Mock).mockReturnValue("doc-ref");
-      (getDoc as jest.Mock).mockResolvedValue({
-        exists: () => true,
-        id: TECHNOLOGY_ID,
-        data: () => ({
-          ...mockTechnology,
-          benefits: mockBenefits,
-          createdAt: new Date(),
-          updatedAt: new Date(),
-        }),
-      });
-
-      const result = await service.getBenefits(
-        CATEGORY_ID,
-        SUBCATEGORY_ID,
-        TECHNOLOGY_ID
-      );
-
-      expect(result).toEqual(mockBenefits);
-    });
-  });
-
-  describe("updateCertificationRequirement", () => {
-    it("treba da ažurira zahteve sertifikacije za tehnologiju", async () => {
-      const TECHNOLOGY_ID = "test-tech-id";
-      const newCertificationRequirement = {
-        minimumLevel: CertificationLevel.SPECIALIST,
-        requiredSpecialties: [
-          CertificationSpecialty.LASER,
-          CertificationSpecialty.INJECTABLES,
-        ],
-      };
-
-      (collection as jest.Mock).mockReturnValue("technologies-collection");
-      (doc as jest.Mock).mockReturnValue("doc-ref");
-      (updateDoc as jest.Mock).mockResolvedValue(undefined);
-      (getDoc as jest.Mock).mockResolvedValue({
-        exists: () => true,
-        id: TECHNOLOGY_ID,
-        data: () => ({
-          ...mockTechnology,
-          certificationRequirement: newCertificationRequirement,
-          createdAt: new Date(),
-          updatedAt: new Date(),
-        }),
-      });
-
-      const result = await service.updateCertificationRequirement(
-        CATEGORY_ID,
-        SUBCATEGORY_ID,
-        TECHNOLOGY_ID,
-        newCertificationRequirement
-      );
-
-      expect(updateDoc).toHaveBeenCalledWith(
-        "doc-ref",
-        expect.objectContaining({
-          certificationRequirement: newCertificationRequirement,
-          updatedAt: expect.any(Date),
-        })
-      );
-
-      if (result) {
-        expect(result.certificationRequirement).toEqual(
-          newCertificationRequirement
-        );
-      } else {
-        fail("Technology should exist");
-      }
-    });
-  });
-
-  describe("getCertificationRequirement", () => {
-    it("treba da vrati zahteve sertifikacije za tehnologiju", async () => {
-      const TECHNOLOGY_ID = "test-tech-id";
-
-      (collection as jest.Mock).mockReturnValue("technologies-collection");
-      (doc as jest.Mock).mockReturnValue("doc-ref");
-      (getDoc as jest.Mock).mockResolvedValue({
-        exists: () => true,
-        id: TECHNOLOGY_ID,
-        data: () => ({
-          ...mockTechnology,
-          createdAt: new Date(),
-          updatedAt: new Date(),
-        }),
-      });
-
-      const result = await service.getCertificationRequirement(
-        CATEGORY_ID,
-        SUBCATEGORY_ID,
-        TECHNOLOGY_ID
-      );
-
-      expect(result).toEqual(DEFAULT_CERTIFICATION_REQUIREMENT);
-    });
-
-    it("treba da vrati null ako tehnologija ne postoji", async () => {
-      const TECHNOLOGY_ID = "non-existent-id";
-
-      (collection as jest.Mock).mockReturnValue("technologies-collection");
-      (doc as jest.Mock).mockReturnValue("doc-ref");
-      (getDoc as jest.Mock).mockResolvedValue({
-        exists: () => false,
-      });
-
-      const result = await service.getCertificationRequirement(
-        CATEGORY_ID,
-        SUBCATEGORY_ID,
-        TECHNOLOGY_ID
-      );
-
-      expect(result).toBeNull();
-    });
-  });
-
-  describe("delete", () => {
-    it("treba da izvrši soft delete tehnologije", async () => {
-      const TECHNOLOGY_ID = "test-tech-id";
-
-      (collection as jest.Mock).mockReturnValue("technologies-collection");
-      (doc as jest.Mock).mockReturnValue("doc-ref");
-      (updateDoc as jest.Mock).mockResolvedValue(undefined);
-      (getDoc as jest.Mock).mockResolvedValue({
-        exists: () => true,
-        id: TECHNOLOGY_ID,
-        data: () => ({
-          ...mockTechnology,
-          isActive: false,
-          createdAt: new Date(),
-          updatedAt: new Date(),
-        }),
-      });
-
-      await service.delete(CATEGORY_ID, SUBCATEGORY_ID, TECHNOLOGY_ID);
-
-      expect(updateDoc).toHaveBeenCalledWith(
-        "doc-ref",
-        expect.objectContaining({
-          isActive: false,
-          updatedAt: expect.any(Date),
-        })
-      );
-    });
-  });
-
-  describe("getById", () => {
-    it("treba da vrati tehnologiju po ID-u", async () => {
-      const TECHNOLOGY_ID = "test-tech-id";
-
-      (collection as jest.Mock).mockReturnValue("technologies-collection");
-      (doc as jest.Mock).mockReturnValue("doc-ref");
-      (getDoc as jest.Mock).mockResolvedValue({
-        exists: () => true,
-        id: TECHNOLOGY_ID,
-        data: () => ({
-          ...mockTechnology,
-          createdAt: new Date(),
-          updatedAt: new Date(),
-        }),
-      });
-
-      const result = await service.getById(
-        CATEGORY_ID,
-        SUBCATEGORY_ID,
-        TECHNOLOGY_ID
-      );
-
-      expect(result).toBeDefined();
-      expect(result?.id).toBe(TECHNOLOGY_ID);
-    });
-
-    it("treba da vrati null ako tehnologija ne postoji", async () => {
-      const TECHNOLOGY_ID = "non-existent-id";
-
-      (collection as jest.Mock).mockReturnValue("technologies-collection");
-      (doc as jest.Mock).mockReturnValue("doc-ref");
-      (getDoc as jest.Mock).mockResolvedValue({
-        exists: () => false,
-      });
-
-      const result = await service.getById(
-        CATEGORY_ID,
-        SUBCATEGORY_ID,
-        TECHNOLOGY_ID
-      );
-
-      expect(result).toBeNull();
-    });
-  });
-
-  describe("updateRequirement", () => {
-    it("treba da ažurira postojeći zahtev", async () => {
-      const TECHNOLOGY_ID = "test-tech-id";
-      const baseRequirement = {
-        id: "req-1",
-        type: RequirementType.PRE,
-        name: "Test Requirement",
-        description: "Test Description",
-        timeframe: {
-          duration: 2,
-          unit: TimeUnit.HOURS,
-          notifyAt: [1, 2],
-        },
-        importance: "high" as const,
-        isActive: true,
-        createdAt: new Date(),
-        updatedAt: new Date(),
-      };
-
-      const oldRequirement = {
-        ...baseRequirement,
-        name: "Old Name",
-      };
-      const newRequirement = {
-        ...baseRequirement,
-        name: "New Name",
-      };
-
-      (collection as jest.Mock).mockReturnValue("technologies-collection");
-      (doc as jest.Mock).mockReturnValue("doc-ref");
-      (updateDoc as jest.Mock).mockResolvedValue(undefined);
-      (getDoc as jest.Mock).mockResolvedValue({
-        exists: () => true,
-        id: TECHNOLOGY_ID,
-        data: () => ({
-          ...mockTechnology,
-          requirements: {
-            pre: [newRequirement],
-            post: [],
-          },
-          createdAt: new Date(),
-          updatedAt: new Date(),
-        }),
-      });
-
-      const result = await service.updateRequirement(
-        CATEGORY_ID,
-        SUBCATEGORY_ID,
-        TECHNOLOGY_ID,
-        oldRequirement,
-        newRequirement
-      );
-
-      expect(updateDoc).toHaveBeenCalledTimes(2); // Jednom za remove, jednom za add
-      if (result) {
-        expect(result.requirements.pre).toContainEqual(newRequirement);
-        expect(result.requirements.pre).not.toContainEqual(oldRequirement);
-      } else {
-        fail("Technology should exist");
-      }
-    });
-  });
-
-  describe("addBlockingCondition", () => {
-    it("treba da doda blokirajući uslov tehnologiji", async () => {
-      const TECHNOLOGY_ID = "test-tech-id";
-      const condition = BlockingCondition.PREGNANCY;
-
-      (collection as jest.Mock).mockReturnValue("technologies-collection");
-      (doc as jest.Mock).mockReturnValue("doc-ref");
-      (updateDoc as jest.Mock).mockResolvedValue(undefined);
-      (getDoc as jest.Mock).mockResolvedValue({
-        exists: () => true,
-        id: TECHNOLOGY_ID,
-        data: () => ({
-          ...mockTechnology,
-          blockingConditions: [condition],
-          createdAt: new Date(),
-          updatedAt: new Date(),
-        }),
-      });
-
-      const result = await service.addBlockingCondition(
-        CATEGORY_ID,
-        SUBCATEGORY_ID,
-        TECHNOLOGY_ID,
-        condition
-      );
-
-      expect(updateDoc).toHaveBeenCalledWith(
-        "doc-ref",
-        expect.objectContaining({
-          blockingConditions: arrayUnion(condition),
-          updatedAt: expect.any(Date),
-        })
-      );
-      if (result) {
-        expect(result.blockingConditions).toContain(condition);
-      } else {
-        fail("Technology should exist");
-      }
-    });
-  });
-
-  describe("removeBlockingCondition", () => {
-    it("treba da ukloni blokirajući uslov iz tehnologije", async () => {
-      const TECHNOLOGY_ID = "test-tech-id";
-      const condition = BlockingCondition.PREGNANCY;
-
-      (collection as jest.Mock).mockReturnValue("technologies-collection");
-      (doc as jest.Mock).mockReturnValue("doc-ref");
-      (updateDoc as jest.Mock).mockResolvedValue(undefined);
-      (getDoc as jest.Mock).mockResolvedValue({
-        exists: () => true,
-        id: TECHNOLOGY_ID,
-        data: () => ({
-          ...mockTechnology,
-          blockingConditions: [],
-          createdAt: new Date(),
-          updatedAt: new Date(),
-        }),
-      });
-
-      const result = await service.removeBlockingCondition(
-        CATEGORY_ID,
-        SUBCATEGORY_ID,
-        TECHNOLOGY_ID,
-        condition
-      );
-
-      expect(updateDoc).toHaveBeenCalledWith(
-        "doc-ref",
-        expect.objectContaining({
-          blockingConditions: arrayRemove(condition),
-          updatedAt: expect.any(Date),
-        })
-      );
-      if (result) {
-        expect(result.blockingConditions).not.toContain(condition);
-      } else {
-        fail("Technology should exist");
-      }
-    });
-  });
-
-  describe("addContraindication", () => {
-    it("treba da doda kontraindikaciju tehnologiji", async () => {
-      const TECHNOLOGY_ID = "test-tech-id";
-      const contraindication = Contraindication.SENSITIVE_SKIN;
-
-      (collection as jest.Mock).mockReturnValue("technologies-collection");
-      (doc as jest.Mock).mockReturnValue("doc-ref");
-      (updateDoc as jest.Mock).mockResolvedValue(undefined);
-      (getDoc as jest.Mock).mockResolvedValue({
-        exists: () => true,
-        id: TECHNOLOGY_ID,
-        data: () => ({
-          ...mockTechnology,
-          contraindications: [contraindication],
-          createdAt: new Date(),
-          updatedAt: new Date(),
-        }),
-      });
-
-      const result = await service.addContraindication(
-        CATEGORY_ID,
-        SUBCATEGORY_ID,
-        TECHNOLOGY_ID,
-        contraindication
-      );
-
-      expect(updateDoc).toHaveBeenCalledWith(
-        "doc-ref",
-        expect.objectContaining({
-          contraindications: arrayUnion(contraindication),
-          updatedAt: expect.any(Date),
-        })
-      );
-      if (result) {
-        expect(result.contraindications).toContain(contraindication);
-      } else {
-        fail("Technology should exist");
-      }
-    });
-  });
-
-  describe("removeContraindication", () => {
-    it("treba da ukloni kontraindikaciju iz tehnologije", async () => {
-      const TECHNOLOGY_ID = "test-tech-id";
-      const contraindication = Contraindication.SENSITIVE_SKIN;
-
-      (collection as jest.Mock).mockReturnValue("technologies-collection");
-      (doc as jest.Mock).mockReturnValue("doc-ref");
-      (updateDoc as jest.Mock).mockResolvedValue(undefined);
-      (getDoc as jest.Mock).mockResolvedValue({
-        exists: () => true,
-        id: TECHNOLOGY_ID,
-        data: () => ({
-          ...mockTechnology,
-          contraindications: [],
-          createdAt: new Date(),
-          updatedAt: new Date(),
-        }),
-      });
-
-      const result = await service.removeContraindication(
-        CATEGORY_ID,
-        SUBCATEGORY_ID,
-        TECHNOLOGY_ID,
-        contraindication
-      );
-
-      expect(updateDoc).toHaveBeenCalledWith(
-        "doc-ref",
-        expect.objectContaining({
-          contraindications: arrayRemove(contraindication),
-          updatedAt: expect.any(Date),
-        })
-      );
-      if (result) {
-        expect(result.contraindications).not.toContain(contraindication);
-      } else {
-        fail("Technology should exist");
-      }
-    });
-  });
-
-  describe("addBenefit", () => {
-    it("treba da doda benefit tehnologiji", async () => {
-      const TECHNOLOGY_ID = "test-tech-id";
-      const benefit = TreatmentBenefit.WRINKLE_REDUCTION;
-
-      (collection as jest.Mock).mockReturnValue("technologies-collection");
-      (doc as jest.Mock).mockReturnValue("doc-ref");
-      (updateDoc as jest.Mock).mockResolvedValue(undefined);
-      (getDoc as jest.Mock).mockResolvedValue({
-        exists: () => true,
-        id: TECHNOLOGY_ID,
-        data: () => ({
-          ...mockTechnology,
-          benefits: [benefit],
-          createdAt: new Date(),
-          updatedAt: new Date(),
-        }),
-      });
-
-      const result = await service.addBenefit(
-        CATEGORY_ID,
-        SUBCATEGORY_ID,
-        TECHNOLOGY_ID,
-        benefit
-      );
-
-      expect(updateDoc).toHaveBeenCalledWith(
-        "doc-ref",
-        expect.objectContaining({
-          benefits: arrayUnion(benefit),
-          updatedAt: expect.any(Date),
-        })
-      );
-      if (result) {
-        expect(result.benefits).toContain(benefit);
-      } else {
-        fail("Technology should exist");
-      }
-    });
-  });
-
-  describe("removeBenefit", () => {
-    it("treba da ukloni benefit iz tehnologije", async () => {
-      const TECHNOLOGY_ID = "test-tech-id";
-      const benefit = TreatmentBenefit.WRINKLE_REDUCTION;
-
-      (collection as jest.Mock).mockReturnValue("technologies-collection");
-      (doc as jest.Mock).mockReturnValue("doc-ref");
-      (updateDoc as jest.Mock).mockResolvedValue(undefined);
-      (getDoc as jest.Mock).mockResolvedValue({
-        exists: () => true,
-        id: TECHNOLOGY_ID,
-        data: () => ({
-          ...mockTechnology,
-          benefits: [],
-          createdAt: new Date(),
-          updatedAt: new Date(),
-        }),
-      });
-
-      const result = await service.removeBenefit(
-        CATEGORY_ID,
-        SUBCATEGORY_ID,
-        TECHNOLOGY_ID,
-        benefit
-      );
-
-      expect(updateDoc).toHaveBeenCalledWith(
-        "doc-ref",
-        expect.objectContaining({
-          benefits: arrayRemove(benefit),
-          updatedAt: expect.any(Date),
-        })
-      );
-      if (result) {
-        expect(result.benefits).not.toContain(benefit);
-      } else {
-        fail("Technology should exist");
-      }
-    });
-  });
-});
-
-describe("ProductService", () => {
-  let service: ProductService;
-  const CATEGORY_ID = "test-category-id";
-  const SUBCATEGORY_ID = "test-subcategory-id";
-  const TECHNOLOGY_ID = "test-technology-id";
-  const BRAND_ID = "test-brand-id";
-
-  const mockProduct: Omit<
-    Product,
-    "id" | "createdAt" | "updatedAt" | "brandId" | "technologyId"
-  > = {
-    name: "Test Product",
-    description: "Test Description",
-    isActive: true,
-  };
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-    service = new ProductService();
-  });
-
-  describe("create", () => {
-    it("treba da kreira novi proizvod u obe kolekcije", async () => {
-      const mockDocRef = { id: "test-id" };
-      (collection as jest.Mock).mockReturnValue("collection-ref");
-      (addDoc as jest.Mock).mockResolvedValue(mockDocRef);
-
-      const result = await service.create(
-        CATEGORY_ID,
-        SUBCATEGORY_ID,
-        TECHNOLOGY_ID,
-        BRAND_ID,
-        mockProduct
-      );
-
-      // Provera kreiranja u technology kolekciji
-      expect(collection).toHaveBeenCalledWith(
-        mockDb,
-        CATEGORIES_COLLECTION,
-        CATEGORY_ID,
-        SUBCATEGORIES_COLLECTION,
-        SUBCATEGORY_ID,
-        TECHNOLOGIES_COLLECTION,
-        TECHNOLOGY_ID,
-        PRODUCTS_COLLECTION
-      );
-
-      // Provera kreiranja u brand kolekciji
-      expect(collection).toHaveBeenCalledWith(
-        mockDb,
-        BRANDS_COLLECTION,
-        BRAND_ID,
-        PRODUCTS_COLLECTION
-      );
-
-      expect(addDoc).toHaveBeenCalledTimes(2);
-    });
-  });
-
-  describe("getAllByTechnology", () => {
-    it("treba da vrati sve aktivne proizvode za tehnologiju", async () => {
-      const mockDocs = [
-        {
-          id: "prod-1",
-          data: () => ({
-            ...mockProduct,
-            brandId: BRAND_ID,
-            technologyId: TECHNOLOGY_ID,
-            createdAt: new Date(),
-            updatedAt: new Date(),
-          }),
-        },
-      ];
-
-      (collection as jest.Mock).mockReturnValue("collection-ref");
-      (query as jest.Mock).mockReturnValue("filtered-query");
-      (where as jest.Mock).mockReturnValue("where-clause");
-      (getDocs as jest.Mock).mockResolvedValue({ docs: mockDocs });
-
-      const results = await service.getAllByTechnology(
-        CATEGORY_ID,
-        SUBCATEGORY_ID,
-        TECHNOLOGY_ID
-      );
-
-      expect(collection).toHaveBeenCalledWith(
-        mockDb,
-        CATEGORIES_COLLECTION,
-        CATEGORY_ID,
-        SUBCATEGORIES_COLLECTION,
-        SUBCATEGORY_ID,
-        TECHNOLOGIES_COLLECTION,
-        TECHNOLOGY_ID,
-        PRODUCTS_COLLECTION
-      );
-      expect(query).toHaveBeenCalledWith("collection-ref", "where-clause");
-      expect(where).toHaveBeenCalledWith("isActive", "==", true);
-    });
-  });
-
-  describe("getAllByBrand", () => {
-    it("treba da vrati sve aktivne proizvode za brend", async () => {
-      const mockDocs = [
-        {
-          id: "prod-1",
-          data: () => ({
-            ...mockProduct,
-            brandId: BRAND_ID,
-            technologyId: TECHNOLOGY_ID,
-            categoryId: CATEGORY_ID,
-            subcategoryId: SUBCATEGORY_ID,
-            createdAt: new Date(),
-            updatedAt: new Date(),
-          }),
-        },
-      ];
-
-      (collection as jest.Mock).mockReturnValue("collection-ref");
-      (query as jest.Mock).mockReturnValue("filtered-query");
-      (where as jest.Mock).mockReturnValue("where-clause");
-      (getDocs as jest.Mock).mockResolvedValue({ docs: mockDocs });
-
-      const results = await service.getAllByBrand(BRAND_ID);
-
-      expect(collection).toHaveBeenCalledWith(
-        mockDb,
-        BRANDS_COLLECTION,
-        BRAND_ID,
-        PRODUCTS_COLLECTION
-      );
-      expect(query).toHaveBeenCalledWith("collection-ref", "where-clause");
-      expect(where).toHaveBeenCalledWith("isActive", "==", true);
-    });
-  });
-
-  // Nastavak u sledećem delu...
-});