@blackcode_sa/metaestetics-api 1.11.3 → 1.12.0

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

@@ -1,358 +0,0 @@
-import { ProductService } from "../product.service";
-import { Product } from "../../types/product.types";
-import {
-  collection,
-  doc,
-  getDoc,
-  getDocs,
-  addDoc,
-  updateDoc,
-  query,
-  where,
-  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("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"> = {
-    name: "Test Product",
-    description: "Test Description",
-    brandId: BRAND_ID,
-    technologyId: TECHNOLOGY_ID,
-    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
-      );
-
-      expect(collection).toHaveBeenCalledWith(
-        mockDb,
-        CATEGORIES_COLLECTION,
-        CATEGORY_ID,
-        SUBCATEGORIES_COLLECTION,
-        SUBCATEGORY_ID,
-        TECHNOLOGIES_COLLECTION,
-        TECHNOLOGY_ID,
-        PRODUCTS_COLLECTION
-      );
-
-      expect(collection).toHaveBeenCalledWith(
-        mockDb,
-        BRANDS_COLLECTION,
-        BRAND_ID,
-        PRODUCTS_COLLECTION
-      );
-
-      expect(addDoc).toHaveBeenCalledTimes(2);
-      expect(result).toEqual(
-        expect.objectContaining({
-          id: mockDocRef.id,
-          ...mockProduct,
-          createdAt: expect.any(Date),
-          updatedAt: expect.any(Date),
-        })
-      );
-    });
-  });
-
-  describe("update", () => {
-    it("treba da ažurira proizvod u obe kolekcije", async () => {
-      const PRODUCT_ID = "test-product-id";
-      const updateData = { name: "Updated Product" };
-
-      // Mock za technology kolekciju
-      (collection as jest.Mock).mockReturnValue("collection-ref");
-      (doc as jest.Mock).mockReturnValue("doc-ref");
-      (updateDoc as jest.Mock).mockResolvedValue(undefined);
-
-      // Mock za brand kolekciju (collectionGroup query)
-      (collectionGroup as jest.Mock).mockReturnValue("collection-group-ref");
-      (query as jest.Mock).mockReturnValue("filtered-query");
-      (where as jest.Mock).mockReturnValue("where-clause");
-      (getDocs as jest.Mock).mockResolvedValue({
-        docs: [
-          {
-            ref: "brand-doc-ref",
-            id: PRODUCT_ID,
-            data: () => ({
-              ...mockProduct,
-              ...updateData,
-              createdAt: new Date(),
-              updatedAt: new Date(),
-            }),
-          },
-        ],
-      });
-
-      // Mock za getById
-      (getDoc as jest.Mock).mockResolvedValue({
-        exists: () => true,
-        id: PRODUCT_ID,
-        data: () => ({
-          ...mockProduct,
-          ...updateData,
-          createdAt: new Date(),
-          updatedAt: new Date(),
-        }),
-      });
-
-      const result = await service.update(
-        CATEGORY_ID,
-        SUBCATEGORY_ID,
-        TECHNOLOGY_ID,
-        PRODUCT_ID,
-        updateData
-      );
-
-      // Provera poziva za technology kolekciju
-      expect(collection).toHaveBeenCalledWith(
-        mockDb,
-        CATEGORIES_COLLECTION,
-        CATEGORY_ID,
-        SUBCATEGORIES_COLLECTION,
-        SUBCATEGORY_ID,
-        TECHNOLOGIES_COLLECTION,
-        TECHNOLOGY_ID,
-        PRODUCTS_COLLECTION
-      );
-
-      // Provera poziva za brand kolekciju
-      expect(collectionGroup).toHaveBeenCalledWith(mockDb, PRODUCTS_COLLECTION);
-      expect(query).toHaveBeenCalledWith(
-        "collection-group-ref",
-        "where-clause"
-      );
-      expect(where).toHaveBeenCalledWith("id", "==", PRODUCT_ID);
-
-      expect(updateDoc).toHaveBeenCalledTimes(2);
-      expect(result).toEqual(
-        expect.objectContaining({
-          id: PRODUCT_ID,
-          ...mockProduct,
-          ...updateData,
-          updatedAt: expect.any(Date),
-        })
-      );
-    });
-  });
-
-  describe("delete", () => {
-    it("treba da izvrši soft delete proizvoda u obe kolekcije", async () => {
-      const PRODUCT_ID = "test-product-id";
-
-      // Mock za technology kolekciju
-      (collection as jest.Mock).mockReturnValue("collection-ref");
-      (doc as jest.Mock).mockReturnValue("doc-ref");
-      (updateDoc as jest.Mock).mockResolvedValue(undefined);
-
-      // Mock za brand kolekciju (collectionGroup query)
-      (collectionGroup as jest.Mock).mockReturnValue("collection-group-ref");
-      (query as jest.Mock).mockReturnValue("filtered-query");
-      (where as jest.Mock).mockReturnValue("where-clause");
-      (getDocs as jest.Mock).mockResolvedValue({
-        docs: [
-          {
-            ref: "brand-doc-ref",
-            id: PRODUCT_ID,
-            data: () => ({
-              ...mockProduct,
-              isActive: false,
-              createdAt: new Date(),
-              updatedAt: new Date(),
-            }),
-          },
-        ],
-      });
-
-      // Mock za getById
-      (getDoc as jest.Mock).mockResolvedValue({
-        exists: () => true,
-        id: PRODUCT_ID,
-        data: () => ({
-          ...mockProduct,
-          isActive: false,
-          createdAt: new Date(),
-          updatedAt: new Date(),
-        }),
-      });
-
-      await service.delete(
-        CATEGORY_ID,
-        SUBCATEGORY_ID,
-        TECHNOLOGY_ID,
-        PRODUCT_ID
-      );
-
-      // Provera poziva za technology kolekciju
-      expect(collection).toHaveBeenCalledWith(
-        mockDb,
-        CATEGORIES_COLLECTION,
-        CATEGORY_ID,
-        SUBCATEGORIES_COLLECTION,
-        SUBCATEGORY_ID,
-        TECHNOLOGIES_COLLECTION,
-        TECHNOLOGY_ID,
-        PRODUCTS_COLLECTION
-      );
-
-      // Provera poziva za brand kolekciju
-      expect(collectionGroup).toHaveBeenCalledWith(mockDb, PRODUCTS_COLLECTION);
-      expect(query).toHaveBeenCalledWith(
-        "collection-group-ref",
-        "where-clause"
-      );
-      expect(where).toHaveBeenCalledWith("id", "==", PRODUCT_ID);
-
-      expect(updateDoc).toHaveBeenCalledTimes(2);
-      expect(updateDoc).toHaveBeenCalledWith(
-        "doc-ref",
-        expect.objectContaining({
-          isActive: false,
-          updatedAt: expect.any(Date),
-        })
-      );
-    });
-  });
-
-  describe("getById", () => {
-    it("treba da vrati proizvod po ID-u", async () => {
-      const PRODUCT_ID = "test-product-id";
-
-      (collection as jest.Mock).mockReturnValue("collection-ref");
-      (doc as jest.Mock).mockReturnValue("doc-ref");
-      (getDoc as jest.Mock).mockResolvedValue({
-        exists: () => true,
-        id: PRODUCT_ID,
-        data: () => ({
-          ...mockProduct,
-          createdAt: new Date(),
-          updatedAt: new Date(),
-        }),
-      });
-
-      const result = await service.getById(
-        CATEGORY_ID,
-        SUBCATEGORY_ID,
-        TECHNOLOGY_ID,
-        PRODUCT_ID
-      );
-
-      expect(result).toBeDefined();
-      expect(result?.id).toBe(PRODUCT_ID);
-    });
-
-    it("treba da vrati null ako proizvod ne postoji", async () => {
-      const PRODUCT_ID = "non-existent-id";
-
-      (collection as jest.Mock).mockReturnValue("collection-ref");
-      (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,
-        PRODUCT_ID
-      );
-
-      expect(result).toBeNull();
-    });
-  });
-
-  describe("getAllByTechnology", () => {
-    it("treba da vrati sve aktivne proizvode za tehnologiju", async () => {
-      const mockDocs = [
-        {
-          id: "prod-1",
-          data: () => ({
-            ...mockProduct,
-            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(query).toHaveBeenCalledWith("collection-ref", "where-clause");
-      expect(where).toHaveBeenCalledWith("isActive", "==", true);
-      expect(results).toHaveLength(1);
-    });
-  });
-
-  describe("getAllByBrand", () => {
-    it("treba da vrati sve aktivne proizvode za brend", async () => {
-      const mockDocs = [
-        {
-          id: "prod-1",
-          data: () => ({
-            ...mockProduct,
-            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(query).toHaveBeenCalledWith("collection-ref", "where-clause");
-      expect(where).toHaveBeenCalledWith("isActive", "==", true);
-      expect(results).toHaveLength(1);
-    });
-  });
-});

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

@@ -1,226 +0,0 @@
-import { RequirementService } from "../requirement.service";
-import {
-  Requirement,
-  RequirementType,
-  TimeUnit,
-} from "../../types/requirement.types";
-import {
-  collection,
-  doc,
-  getDoc,
-  getDocs,
-  addDoc,
-  updateDoc,
-  query,
-  where,
-} from "firebase/firestore";
-
-// Mock Firebase Firestore
-jest.mock("firebase/firestore");
-
-// Dodati na vrh fajla
-jest.mock("../../../config/firebase", () => ({
-  getFirebaseInstance: jest.fn().mockResolvedValue({
-    db: {},
-    auth: {},
-  }),
-}));
-
-const COLLECTION = "backoffice_requirements";
-
-describe("RequirementService", () => {
-  let service: RequirementService;
-  const mockDb = {} as any;
-
-  // Test data
-  const mockRequirement: Omit<Requirement, "id" | "createdAt" | "updatedAt"> = {
-    name: "Test Requirement",
-    description: "Test Description",
-    type: RequirementType.PRE,
-    timeframe: {
-      duration: 2,
-      unit: TimeUnit.HOURS,
-      notifyAt: [1, 2],
-    },
-    importance: "high",
-    isActive: true,
-  };
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-    service = new RequirementService();
-  });
-
-  describe("create", () => {
-    it("treba da kreira novi zahtev", async () => {
-      const mockDocRef = { id: "test-id" };
-      (collection as jest.Mock).mockReturnValue("requirements-collection");
-      (addDoc as jest.Mock).mockResolvedValue(mockDocRef);
-
-      const result = await service.create(mockRequirement);
-
-      expect(collection).toHaveBeenCalledWith(mockDb, COLLECTION);
-      expect(addDoc).toHaveBeenCalledWith(
-        "requirements-collection",
-        expect.objectContaining({
-          ...mockRequirement,
-          createdAt: expect.any(Date),
-          updatedAt: expect.any(Date),
-        })
-      );
-      expect(result).toEqual({
-        id: "test-id",
-        ...mockRequirement,
-        createdAt: expect.any(Date),
-        updatedAt: expect.any(Date),
-      });
-    });
-
-    it("treba da baci grešku ako kreiranje ne uspe", async () => {
-      (collection as jest.Mock).mockReturnValue("requirements-collection");
-      (addDoc as jest.Mock).mockRejectedValue(new Error("Firebase Error"));
-
-      await expect(service.create(mockRequirement)).rejects.toThrow(
-        "Firebase Error"
-      );
-    });
-  });
-
-  describe("getAll", () => {
-    it("treba da vrati sve aktivne zahteve", async () => {
-      const mockDocs = [
-        {
-          id: "req-1",
-          data: () => ({ ...mockRequirement }),
-        },
-        {
-          id: "req-2",
-          data: () => ({ ...mockRequirement }),
-        },
-      ];
-
-      (collection as jest.Mock).mockReturnValue("requirements-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.getAll();
-
-      expect(collection).toHaveBeenCalledWith(mockDb, COLLECTION);
-      expect(query).toHaveBeenCalledWith(
-        "requirements-collection",
-        "where-clause"
-      );
-      expect(where).toHaveBeenCalledWith("isActive", "==", true);
-      expect(results).toHaveLength(2);
-      expect(results[0]).toEqual({
-        id: "req-1",
-        ...mockRequirement,
-      });
-    });
-  });
-
-  describe("getById", () => {
-    it("treba da vrati zahtev po ID-u", async () => {
-      const mockDoc = {
-        exists: () => true,
-        data: () => ({ ...mockRequirement }),
-        id: "test-id",
-      };
-
-      (collection as jest.Mock).mockReturnValue("requirements-collection");
-      (doc as jest.Mock).mockReturnValue("doc-ref");
-      (getDoc as jest.Mock).mockResolvedValue(mockDoc);
-
-      const result = await service.getById("test-id");
-
-      expect(collection).toHaveBeenCalledWith(mockDb, COLLECTION);
-      expect(doc).toHaveBeenCalledWith("requirements-collection", "test-id");
-      expect(result).toEqual({
-        id: "test-id",
-        ...mockRequirement,
-      });
-    });
-
-    it("treba da vrati null ako zahtev ne postoji", async () => {
-      const mockDoc = {
-        exists: () => false,
-      };
-
-      (collection as jest.Mock).mockReturnValue("requirements-collection");
-      (doc as jest.Mock).mockReturnValue("doc-ref");
-      (getDoc as jest.Mock).mockResolvedValue(mockDoc);
-
-      const result = await service.getById("non-existent-id");
-
-      expect(result).toBeNull();
-    });
-  });
-
-  describe("update", () => {
-    it("treba da ažurira postojeći zahtev", async () => {
-      const updateData = {
-        name: "Updated Name",
-        description: "Updated Description",
-      };
-
-      (collection as jest.Mock).mockReturnValue("requirements-collection");
-      (doc as jest.Mock).mockReturnValue("doc-ref");
-      (updateDoc as jest.Mock).mockResolvedValue(undefined);
-
-      await service.update("test-id", updateData);
-
-      expect(collection).toHaveBeenCalledWith(mockDb, COLLECTION);
-      expect(doc).toHaveBeenCalledWith("requirements-collection", "test-id");
-      expect(updateDoc).toHaveBeenCalledWith(
-        "doc-ref",
-        expect.objectContaining({
-          ...updateData,
-          updatedAt: expect.any(Date),
-        })
-      );
-    });
-
-    it("treba da baci grešku ako ažuriranje ne uspe", async () => {
-      (collection as jest.Mock).mockReturnValue("requirements-collection");
-      (doc as jest.Mock).mockReturnValue("doc-ref");
-      (updateDoc as jest.Mock).mockRejectedValue(new Error("Update Failed"));
-
-      await expect(
-        service.update("test-id", { name: "New Name" })
-      ).rejects.toThrow("Update Failed");
-    });
-  });
-
-  describe("getAllByType", () => {
-    it("treba da vrati sve zahteve određenog tipa", async () => {
-      const mockDocs = [
-        {
-          id: "req-1",
-          data: () => ({ ...mockRequirement, type: RequirementType.PRE }),
-        },
-        {
-          id: "req-2",
-          data: () => ({ ...mockRequirement, type: RequirementType.PRE }),
-        },
-      ];
-
-      (collection as jest.Mock).mockReturnValue("requirements-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.getAllByType(RequirementType.PRE);
-
-      expect(query).toHaveBeenCalledWith(
-        "requirements-collection",
-        "where-clause",
-        "where-clause"
-      );
-      expect(where).toHaveBeenCalledWith("type", "==", RequirementType.PRE);
-      expect(where).toHaveBeenCalledWith("isActive", "==", true);
-      expect(results).toHaveLength(2);
-      expect(results[0].type).toBe(RequirementType.PRE);
-    });
-  });
-});