@hed-hog/category 0.0.366 → 0.0.370

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hed-hog/category",
-  "version": "0.0.366",
+  "version": "0.0.370",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "dependencies": {
@@ -9,11 +9,11 @@
     "@nestjs/core": "^11",
     "@nestjs/jwt": "^11",
     "@nestjs/mapped-types": "*",
+    "@hed-hog/core": "0.0.370",
     "@hed-hog/api-locale": "0.0.14",
-    "@hed-hog/api-prisma": "0.0.6",
+    "@hed-hog/api-pagination": "0.0.7",
     "@hed-hog/api": "0.0.8",
-    "@hed-hog/core": "0.0.366",
-    "@hed-hog/api-pagination": "0.0.7"
+    "@hed-hog/api-prisma": "0.0.6"
   },
   "exports": {
     ".": {
@@ -29,6 +29,7 @@
   ],
   "scripts": {
     "lint": "eslint \"{src,apps,libs,test}/**/*.ts\"",
+    "test": "jest --config jest.config.ts --runInBand",
     "prebuild": "pnpm --dir ../.. exec ts-node ./scripts/build-dependencies.ts libraries/category",
     "build": "tsc --project tsconfig.production.json",
     "patch": "npx ts-node ../../scripts/patch.ts libraries/category",

package/src/category.service.spec.ts

@@ -0,0 +1,259 @@
+jest.mock('@hed-hog/api', () => ({
+  itemTranslations: jest.fn((_key: string, item: any) => item),
+}));
+jest.mock('@hed-hog/api-locale', () => ({
+  getLocaleText: jest.fn((_key: string, _locale: string, fallback: string) => fallback ?? 'Error'),
+  LocaleService: class {},
+}));
+
+import { BadRequestException, NotFoundException } from '@nestjs/common';
+import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
+import { CategoryService } from './category.service';
+
+const makeLocaleService = (overrides: Partial<Record<string, jest.Mock>> = {}) => ({
+  getByCode: jest.fn().mockResolvedValue({ id: 1, code: 'en' }),
+  ...overrides,
+});
+
+describe('CategoryService', () => {
+  let prisma: any;
+  let pagination: any;
+  let localeService: any;
+  let service: CategoryService;
+
+  beforeEach(() => {
+    prisma = {
+      category: {
+        count: jest.fn().mockResolvedValue(0),
+        findUnique: jest.fn(),
+        findMany: jest.fn().mockResolvedValue([]),
+        create: jest.fn(),
+        update: jest.fn(),
+        delete: jest.fn(),
+      },
+      category_locale: {
+        findFirst: jest.fn(),
+        create: jest.fn().mockResolvedValue({}),
+        update: jest.fn().mockResolvedValue({}),
+      },
+      createInsensitiveSearch: jest.fn().mockReturnValue([]),
+    };
+
+    pagination = {
+      paginate: jest.fn().mockResolvedValue({ data: [], total: 0 }),
+    };
+
+    localeService = makeLocaleService();
+    service = new CategoryService(prisma as any, pagination as any, localeService as any);
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('getStats', () => {
+    it('retorna total, totalActive, totalInactive, totalRoot', async () => {
+      prisma.category.count
+        .mockResolvedValueOnce(20)
+        .mockResolvedValueOnce(15)
+        .mockResolvedValueOnce(5)
+        .mockResolvedValueOnce(8);
+
+      const result = await service.getStats();
+
+      expect(result).toEqual({ total: 20, totalActive: 15, totalInactive: 5, totalRoot: 8 });
+    });
+  });
+
+  describe('getById', () => {
+    it('retorna categoria quando encontrada', async () => {
+      prisma.category.findUnique.mockResolvedValue({
+        id: 1,
+        slug: 'tech',
+        category_locale: [],
+      });
+
+      const result = await service.getById('en', 1);
+
+      expect(result).toMatchObject({ id: 1, slug: 'tech' });
+    });
+
+    it('lança NotFoundException quando categoria não existe', async () => {
+      prisma.category.findUnique.mockResolvedValue(null);
+
+      await expect(service.getById('en', 999)).rejects.toThrow(NotFoundException);
+    });
+  });
+
+  describe('getRootCategories', () => {
+    it('lança BadRequestException quando locale não existe', async () => {
+      localeService.getByCode.mockResolvedValue(null);
+
+      await expect(service.getRootCategories('xx')).rejects.toThrow(BadRequestException);
+    });
+
+    it('retorna categorias raiz mapeadas', async () => {
+      prisma.category.findMany.mockResolvedValue([
+        { id: 1, slug: 'tech', category_locale: [] },
+        { id: 2, slug: 'news', category_locale: [] },
+      ]);
+
+      const result = await service.getRootCategories('en');
+
+      expect(result).toHaveLength(2);
+    });
+  });
+
+  describe('getByParent', () => {
+    it('lança BadRequestException quando locale não existe', async () => {
+      localeService.getByCode.mockResolvedValue(null);
+
+      await expect(service.getByParent('1', 'xx')).rejects.toThrow(BadRequestException);
+    });
+
+    it('lança NotFoundException quando não há filhos', async () => {
+      prisma.category.findMany.mockResolvedValue([]);
+
+      await expect(service.getByParent('1', 'en')).rejects.toThrow(NotFoundException);
+    });
+
+    it('retorna categorias filhas mapeadas', async () => {
+      prisma.category.findMany.mockResolvedValue([
+        { id: 3, slug: 'phones', category_locale: [] },
+      ]);
+
+      const result = await service.getByParent('1', 'en');
+
+      expect(result).toHaveLength(1);
+    });
+  });
+
+  describe('delete', () => {
+    it('lança NotFoundException quando categoria não existe', async () => {
+      prisma.category.findUnique.mockResolvedValue(null);
+
+      await expect(service.delete(999, 'en')).rejects.toThrow(NotFoundException);
+    });
+
+    it('deleta categoria quando encontrada', async () => {
+      prisma.category.findUnique.mockResolvedValue({ id: 1, slug: 'tech' });
+      prisma.category.delete.mockResolvedValue({ id: 1 });
+
+      const result = await service.delete(1, 'en');
+
+      expect(prisma.category.delete).toHaveBeenCalledWith({ where: { id: 1 } });
+      expect(result).toMatchObject({ id: 1 });
+    });
+  });
+
+  describe('create', () => {
+    it('lança BadRequestException quando locale está vazio', async () => {
+      await expect(
+        service.create('en', { slug: 'test', locale: {} } as any),
+      ).rejects.toThrow(BadRequestException);
+    });
+
+    it('lança BadRequestException quando categoria pai não existe', async () => {
+      prisma.category.findUnique.mockResolvedValue(null);
+
+      await expect(
+        service.create('en', {
+          slug: 'test',
+          category_id: 999,
+          locale: { en: { name: 'Test' } },
+        } as any),
+      ).rejects.toThrow(BadRequestException);
+    });
+
+    it('lança BadRequestException quando locale código não existe', async () => {
+      prisma.category.findUnique.mockResolvedValue(null);
+      prisma.category.create.mockResolvedValue({ id: 1, slug: 'test' });
+      localeService.getByCode.mockResolvedValue(null);
+
+      await expect(
+        service.create('en', { slug: 'test', locale: { xx: { name: 'Test' } } } as any),
+      ).rejects.toThrow(BadRequestException);
+    });
+
+    it('cria categoria e entradas de locale', async () => {
+      prisma.category.create.mockResolvedValue({ id: 1, slug: 'test' });
+
+      const result = await service.create('en', {
+        slug: 'test',
+        locale: { en: { name: 'Test' } },
+      } as any);
+
+      expect(prisma.category.create).toHaveBeenCalledWith(
+        expect.objectContaining({ data: expect.objectContaining({ slug: 'test' }) }),
+      );
+      expect(prisma.category_locale.create).toHaveBeenCalled();
+      expect(result).toMatchObject({ id: 1 });
+    });
+  });
+
+  describe('update', () => {
+    it('lança NotFoundException quando categoria não existe', async () => {
+      prisma.category.findUnique.mockResolvedValue(null);
+
+      await expect(service.update('en', 999, { slug: 'x' } as any)).rejects.toThrow(
+        NotFoundException,
+      );
+    });
+
+    it('lança BadRequestException quando categoria pai não existe', async () => {
+      prisma.category.findUnique
+        .mockResolvedValueOnce({ id: 1, slug: 'test' })
+        .mockResolvedValueOnce(null);
+
+      await expect(
+        service.update('en', 1, { category_id: 999 } as any),
+      ).rejects.toThrow(BadRequestException);
+    });
+
+    it('atualiza categoria e retorna resultado via getById', async () => {
+      prisma.category.findUnique
+        .mockResolvedValueOnce({ id: 1, slug: 'old' })
+        .mockResolvedValueOnce({ id: 1, slug: 'new', category_locale: [] });
+      prisma.category.update.mockResolvedValue({ id: 1 });
+
+      const result = await service.update('en', 1, { slug: 'new' } as any);
+
+      expect(prisma.category.update).toHaveBeenCalledWith(
+        expect.objectContaining({ where: { id: 1 } }),
+      );
+      expect(result).toMatchObject({ id: 1 });
+    });
+
+    it('atualiza entrada de locale existente', async () => {
+      prisma.category.findUnique
+        .mockResolvedValueOnce({ id: 1, slug: 'test' })
+        .mockResolvedValueOnce({ id: 1, slug: 'test', category_locale: [] });
+      prisma.category.update.mockResolvedValue({ id: 1 });
+      prisma.category_locale.findFirst.mockResolvedValue({ id: 5 });
+
+      await service.update('en', 1, {
+        slug: 'test',
+        locale: { en: { name: 'Updated' } },
+      } as any);
+
+      expect(prisma.category_locale.update).toHaveBeenCalledWith(
+        expect.objectContaining({ where: { id: 5 }, data: { name: 'Updated' } }),
+      );
+    });
+
+    it('cria nova entrada de locale quando não existe', async () => {
+      prisma.category.findUnique
+        .mockResolvedValueOnce({ id: 1, slug: 'test' })
+        .mockResolvedValueOnce({ id: 1, slug: 'test', category_locale: [] });
+      prisma.category.update.mockResolvedValue({ id: 1 });
+      prisma.category_locale.findFirst.mockResolvedValue(null);
+
+      await service.update('en', 1, {
+        slug: 'test',
+        locale: { en: { name: 'New Locale' } },
+      } as any);
+
+      expect(prisma.category_locale.create).toHaveBeenCalled();
+    });
+  });
+});