feat: update product service test

Author: JanetHugarcia

src/lib/utils.tests.ts

@@ -2,13 +2,15 @@ import { vi } from "vitest";
 
 import type { Category } from "@/models/category.model";
 import type { Order, OrderDetails, OrderItem } from "@/models/order.model";
-import type { Product } from "@/models/product.model";
+import type { ProductVariantValue } from "@/models/product.model";
 import type { User } from "@/models/user.model";
 
 import type {
   OrderItem as PrismaOrderItem,
   Order as PrismaOrder,
   Product as PrismaProduct,
+  VariantAttributeValue as PrismaVariantAttributeValue,
+
 } from "@/../generated/prisma/client";
 import type { Session } from "react-router";
 
@@ -53,38 +55,40 @@ export const createMockSession = (userId: number | null): Session => ({
   unset: vi.fn(),
 });
 
-export const createTestProduct = (overrides?: Partial<Product>): Product => ({
+export const createTestDBProduct = (
+  overrides?: Partial<PrismaProduct> & { variantAttributeValues?: PrismaVariantAttributeValue[] }
+): PrismaProduct & { variantAttributeValues: PrismaVariantAttributeValue[] } => ({
   id: 1,
   title: "Test Product",
   imgSrc: "/test-image.jpg",
   alt: "Test alt text",
-  price: 100,
   description: "Test description",
   categoryId: 1,
   isOnSale: false,
   features: ["Feature 1", "Feature 2"],
   createdAt: new Date(),
   updatedAt: new Date(),
+  variantAttributeValues: overrides?.variantAttributeValues ?? [createTestDBVariantAttributeValue()],
   ...overrides,
 });
 
-export const createTestDBProduct = (
-  overrides?: Partial<PrismaProduct>
-): PrismaProduct => ({
+// --- FRONTEND PRODUCT ---
+export const createTestProduct = (overrides?: Partial<ProductVariantValue>): ProductVariantValue => ({
   id: 1,
   title: "Test Product",
   imgSrc: "/test-image.jpg",
   alt: "Test alt text",
-  price: new Decimal(100),
   description: "Test description",
   categoryId: 1,
   isOnSale: false,
   features: ["Feature 1", "Feature 2"],
   createdAt: new Date(),
   updatedAt: new Date(),
+  variantAttributeValues: [createTestDBVariantAttributeValue()],
   ...overrides,
 });
 
+
 export const createTestCategory = (
   overrides?: Partial<Category>
 ): Category => ({
@@ -99,6 +103,19 @@ export const createTestCategory = (
   ...overrides,
 });
 
+export const createTestDBVariantAttributeValue = (
+  overrides?: Partial<PrismaVariantAttributeValue>
+): PrismaVariantAttributeValue => ({
+  id: 1,
+  attributeId: 1,
+  productId: 1,
+  value: "Default",
+  price: new Decimal(100),
+  createdAt: new Date(),
+  updatedAt: new Date(),
+  ...overrides,
+});
+
 export const createTestOrderDetails = (
   overrides: Partial<OrderDetails> = {}
 ): OrderDetails => ({

src/services/product.service.test.ts

@@ -1,13 +1,19 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
+import { vi, describe, it, expect, beforeEach } from "vitest";
+
 
 import { prisma as mockPrisma } from "@/db/prisma";
-import { createTestCategory, createTestDBProduct } from "@/lib/utils.tests";
-import type { Category } from "@/models/category.model";
+import {
+  createTestCategory,
+  createTestDBProduct,
+  createTestDBVariantAttributeValue,
+} from "@/lib/utils.tests";
 
 import { getCategoryBySlug } from "./category.service";
-import { getProductById, getProductsByCategorySlug } from "./product.service";
+import { getProductsByCategorySlug, getProductById } from "./product.service";
+
+import type { Category } from "generated/prisma/client";
 
-import type { Product as PrismaProduct } from "@/../generated/prisma/client";
+import { Decimal } from "@/../generated/prisma/internal/prismaNamespace";
 
 vi.mock("@/db/prisma", () => ({
   prisma: {
@@ -18,7 +24,6 @@ vi.mock("@/db/prisma", () => ({
   },
 }));
 
-// Mock category service
 vi.mock("./category.service");
 
 describe("Product Service", () => {
@@ -27,93 +32,82 @@ describe("Product Service", () => {
   });
 
   describe("getProductsByCategorySlug", () => {
-    it("should return products for a valid category slug", async () => {
-      // Step 1: Setup - Create test data with valid category and products
+    it("should return products for a valid category slug with prices as numbers", async () => {
       const testCategory = createTestCategory();
-      const mockedProducts: PrismaProduct[] = [
+
+      const mockedProducts = [
         createTestDBProduct({ id: 1, categoryId: testCategory.id }),
-        createTestDBProduct({
-          id: 2,
-          title: "Test Product 2",
-          categoryId: testCategory.id,
-        }),
+        createTestDBProduct({ id: 2, categoryId: testCategory.id }),
       ];
 
-      // Step 2: Mock - Configure responses
       vi.mocked(getCategoryBySlug).mockResolvedValue(testCategory);
-
       vi.mocked(mockPrisma.product.findMany).mockResolvedValue(mockedProducts);
 
-      // Step 3: Call service function
       const products = await getProductsByCategorySlug(testCategory.slug);
 
-      // Step 4: Verify expected behavior
       expect(getCategoryBySlug).toHaveBeenCalledWith(testCategory.slug);
       expect(mockPrisma.product.findMany).toHaveBeenCalledWith({
         where: { categoryId: testCategory.id },
+        include: { variantAttributeValues: true },
       });
+
+      // Comprobamos que los precios se transforman a number
       expect(products).toEqual(
         mockedProducts.map((product) => ({
           ...product,
-          price: product.price.toNumber(),
+          price: product.variantAttributeValues[0].price.toNumber(),
         }))
       );
     });
-
     it("should throw error when category slug does not exist", async () => {
-      // Step 1: Setup - Create test data for non-existent category
       const invalidSlug = "invalid-slug";
-
-      // Step 2: Mock - Configure error response
       const errorMessage = `Category with slug "${invalidSlug}" not found`;
-      vi.mocked(getCategoryBySlug).mockRejectedValue(new Error(errorMessage));
 
-      // Step 3: Call service function
-      const getProducts = getProductsByCategorySlug(
-        invalidSlug as Category["slug"]
-      );
+      vi.mocked(getCategoryBySlug).mockRejectedValue(new Error(errorMessage));
 
-      // Step 4: Verify expected behavior
-      await expect(getProducts).rejects.toThrow(errorMessage);
+      await expect(getProductsByCategorySlug(invalidSlug as Category["slug"])).rejects.toThrow(errorMessage);
       expect(mockPrisma.product.findMany).not.toHaveBeenCalled();
     });
   });
 
   describe("getProductById", () => {
-    it("should return product for valid ID", async () => {
-      // Step 1: Setup - Create test data for existing product
-      const testProduct = createTestDBProduct();
+    it("should return product for valid ID with prices as numbers", async () => {
+      const testProduct = createTestDBProduct({
+        id: 1,
+        variantAttributeValues: [
+          createTestDBVariantAttributeValue({ price: new Decimal(120) }),
+          createTestDBVariantAttributeValue({ id: 2, price: new Decimal(150) }),
+        ],
+      });
 
-      // Step 2: Mock - Configure Prisma response
       vi.mocked(mockPrisma.product.findUnique).mockResolvedValue(testProduct);
 
-      // Step 3: Call service function
       const result = await getProductById(testProduct.id);
 
-      // Step 4: Verify expected behavior
       expect(mockPrisma.product.findUnique).toHaveBeenCalledWith({
         where: { id: testProduct.id },
+        include: { variantAttributeValues: { include: { variantAttribute: true } } },
       });
+
+      // Se espera que el producto devuelto tenga minPrice y maxPrice correctamente calculados
       expect(result).toEqual({
         ...testProduct,
-        price: testProduct.price.toNumber(),
+        variantAttributeValues: testProduct.variantAttributeValues.map((v) => ({
+          ...v,
+          price: v.price.toNumber(),
+        })),
       });
     });
 
     it("should throw error when product does not exist", async () => {
-      // Step 1: Setup - Configure ID for non-existent product
       const nonExistentId = 999;
 
-      // Step 2: Mock - Configure null response from Prisma
       vi.mocked(mockPrisma.product.findUnique).mockResolvedValue(null);
 
-      // Step 3: Call service function
-      const productPromise = getProductById(nonExistentId);
-
-      // Step 4: Verify expected behavior
-      await expect(productPromise).rejects.toThrow("Product not found");
+      await expect(getProductById(nonExistentId)).rejects.toThrow("Product not found");
       expect(mockPrisma.product.findUnique).toHaveBeenCalledWith({
         where: { id: nonExistentId },
+        include: { variantAttributeValues: { include: { variantAttribute: true } } },
       });
     });
   });