@hed-hog/tag 0.0.366 → 0.0.370

package/hedhog/frontend/app/page.tsx.ejs

@@ -558,6 +558,7 @@ export default function TagPage() {
                 statusContent={draftStatusContent}
                 cancelLabel={t('cancel')}
                 onCancel={() => {
+                  clearDraft();
                   setIsSheetOpen(false);
                   setEditingTagId(null);
                 }}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hed-hog/tag",
-  "version": "0.0.366",
+  "version": "0.0.370",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "dependencies": {
@@ -10,9 +10,9 @@
     "@nestjs/jwt": "^11",
     "@nestjs/mapped-types": "*",
     "@hed-hog/api-prisma": "0.0.6",
-    "@hed-hog/core": "0.0.366",
-    "@hed-hog/api-pagination": "0.0.7",
     "@hed-hog/api": "0.0.8",
+    "@hed-hog/api-pagination": "0.0.7",
+    "@hed-hog/core": "0.0.370",
     "@hed-hog/api-locale": "0.0.14"
   },
   "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/tag",
     "build": "tsc --project tsconfig.production.json",
     "patch": "npx ts-node ../../scripts/patch.ts libraries/tag",

package/src/tag.service.spec.ts

@@ -0,0 +1,187 @@
+jest.mock('@hed-hog/api-locale', () => ({
+  getLocaleText: jest.fn((_key: string, _locale: string, fallback: string) => fallback ?? 'Error'),
+}));
+
+import { BadRequestException } from '@nestjs/common';
+import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
+import { TagService } from './tag.service';
+
+describe('TagService', () => {
+  let prisma: any;
+  let service: TagService;
+
+  beforeEach(() => {
+    prisma = {
+      tag: {
+        findMany: jest.fn().mockResolvedValue([]),
+        findUnique: jest.fn(),
+        count: jest.fn().mockResolvedValue(0),
+        create: jest.fn(),
+        update: jest.fn(),
+        delete: jest.fn(),
+      },
+    };
+    service = new TagService(prisma as any);
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('list', () => {
+    it('retorna dados paginados', async () => {
+      prisma.tag.findMany.mockResolvedValue([{ id: 1, slug: 'promo', color: '#ff0000', status: 'active' }]);
+      prisma.tag.count.mockResolvedValue(1);
+
+      const result = await service.list({ skip: 0, take: 10, search: '' });
+
+      expect(result.total).toBe(1);
+      expect(result.data).toHaveLength(1);
+      expect(result.page).toBe(1);
+      expect(result.lastPage).toBe(1);
+    });
+
+    it('calcula página e lastPage corretamente', async () => {
+      prisma.tag.findMany.mockResolvedValue([]);
+      prisma.tag.count.mockResolvedValue(25);
+
+      const result = await service.list({ skip: 10, take: 10, search: '' });
+
+      expect(result.page).toBe(2);
+      expect(result.lastPage).toBe(3);
+      expect(result.prev).toBe(1);
+      expect(result.next).toBe(3);
+    });
+
+    it('aplica filtro de busca no where quando search fornecido', async () => {
+      prisma.tag.findMany.mockResolvedValue([]);
+      prisma.tag.count.mockResolvedValue(0);
+
+      await service.list({ skip: 0, take: 10, search: 'sale' });
+
+      const [call] = prisma.tag.findMany.mock.calls;
+      expect(call[0].where).toMatchObject({ OR: expect.any(Array) });
+    });
+
+    it('não aplica filtro quando search vazio', async () => {
+      prisma.tag.findMany.mockResolvedValue([]);
+      prisma.tag.count.mockResolvedValue(0);
+
+      await service.list({ skip: 0, take: 10, search: '' });
+
+      const [call] = prisma.tag.findMany.mock.calls;
+      expect(call[0].where).toEqual({});
+    });
+  });
+
+  describe('getStats', () => {
+    it('retorna contagens por status', async () => {
+      prisma.tag.count
+        .mockResolvedValueOnce(10)
+        .mockResolvedValueOnce(7)
+        .mockResolvedValueOnce(3);
+
+      const result = await service.getStats();
+
+      expect(result).toEqual({ total: 10, active: 7, inactive: 3 });
+    });
+  });
+
+  describe('create', () => {
+    it('lança BadRequestException para cor inválida', async () => {
+      await expect(
+        service.create('en', { slug: 'test', color: 'red', status: 'active' } as any),
+      ).rejects.toThrow(BadRequestException);
+    });
+
+    it('lança BadRequestException para cor sem #', async () => {
+      await expect(
+        service.create('en', { slug: 'test', color: 'ff0000' } as any),
+      ).rejects.toThrow(BadRequestException);
+    });
+
+    it('cria tag com cor hexadecimal válida de 6 dígitos', async () => {
+      const created = { id: 1, slug: 'promo', color: '#ff0000', status: 'active' };
+      prisma.tag.create.mockResolvedValue(created);
+
+      const result = await service.create('en', { slug: 'promo', color: '#ff0000' } as any);
+
+      expect(prisma.tag.create).toHaveBeenCalledWith(
+        expect.objectContaining({ data: expect.objectContaining({ slug: 'promo', color: '#ff0000' }) }),
+      );
+      expect(result).toMatchObject({ id: 1 });
+    });
+
+    it('cria tag com cor hexadecimal válida de 3 dígitos', async () => {
+      prisma.tag.create.mockResolvedValue({ id: 2, slug: 'sale', color: '#f00', status: 'active' });
+
+      const result = await service.create('en', { slug: 'sale', color: '#f00' } as any);
+
+      expect(result).toMatchObject({ id: 2 });
+    });
+
+    it('usa status active como padrão', async () => {
+      prisma.tag.create.mockResolvedValue({ id: 1, slug: 'x', color: '#aabbcc', status: 'active' });
+
+      await service.create('en', { slug: 'x', color: '#aabbcc' } as any);
+
+      expect(prisma.tag.create).toHaveBeenCalledWith(
+        expect.objectContaining({ data: expect.objectContaining({ status: 'active' }) }),
+      );
+    });
+  });
+
+  describe('getById', () => {
+    it('retorna tag quando encontrada', async () => {
+      prisma.tag.findUnique.mockResolvedValue({ id: 1, slug: 'promo', color: '#ff0000' });
+
+      const result = await service.getById(1, 'en');
+
+      expect(result).toMatchObject({ id: 1 });
+    });
+
+    it('lança BadRequestException quando tag não existe', async () => {
+      prisma.tag.findUnique.mockResolvedValue(null);
+
+      await expect(service.getById(999, 'en')).rejects.toThrow(BadRequestException);
+    });
+  });
+
+  describe('update', () => {
+    it('lança BadRequestException quando tag não existe', async () => {
+      prisma.tag.findUnique.mockResolvedValue(null);
+
+      await expect(service.update(999, { slug: 'x' }, 'en')).rejects.toThrow(BadRequestException);
+    });
+
+    it('atualiza campos fornecidos', async () => {
+      prisma.tag.findUnique.mockResolvedValue({ id: 1, slug: 'old', color: '#ff0000' });
+      prisma.tag.update.mockResolvedValue({ id: 1, slug: 'new', color: '#ff0000' });
+
+      const result = await service.update(1, { slug: 'new' }, 'en');
+
+      expect(prisma.tag.update).toHaveBeenCalledWith(
+        expect.objectContaining({ where: { id: 1 } }),
+      );
+      expect(result).toMatchObject({ id: 1, slug: 'new' });
+    });
+  });
+
+  describe('delete', () => {
+    it('lança BadRequestException quando tag não existe', async () => {
+      prisma.tag.findUnique.mockResolvedValue(null);
+
+      await expect(service.delete(999, 'en')).rejects.toThrow(BadRequestException);
+    });
+
+    it('deleta tag quando encontrada', async () => {
+      prisma.tag.findUnique.mockResolvedValue({ id: 1, slug: 'promo' });
+      prisma.tag.delete.mockResolvedValue({ id: 1 });
+
+      const result = await service.delete(1, 'en');
+
+      expect(prisma.tag.delete).toHaveBeenCalledWith({ where: { id: 1 } });
+      expect(result).toMatchObject({ id: 1 });
+    });
+  });
+});