@hed-hog/core 0.0.371 → 0.0.374

package/src/role/guards/role.guard.spec.ts

@@ -0,0 +1,157 @@
+import { describe, it, expect, beforeEach, afterEach, jest } from '@jest/globals';
+import {
+  ForbiddenException,
+  RequestMethod,
+  UnauthorizedException,
+} from '@nestjs/common';
+import { METHOD_METADATA } from '@nestjs/common/constants';
+import { IS_PUBLIC_KEY, WITH_NO_ROLE, WITH_ROLE } from '@hed-hog/api';
+import { RoleGuard } from './role.guard';
+
+const CTRL = 'CTRL';
+const HANDLER = 'HANDLER';
+
+const makeContext = (request: any) => ({
+  getHandler: () => HANDLER,
+  getClass: () => CTRL,
+  switchToHttp: () => ({ getRequest: () => request }),
+});
+
+const makeDeps = () => {
+  const reflector = { getAllAndOverride: jest.fn(), get: jest.fn() };
+  const prisma = {
+    route: { count: jest.fn() },
+    user_credential: { findFirst: jest.fn() },
+  };
+  return { reflector, prisma };
+};
+
+const makeService = (deps = makeDeps()) => ({
+  guard: new RoleGuard(deps.reflector as any, deps.prisma as any),
+  deps,
+});
+
+const setMeta = (
+  reflector: any,
+  meta: { public?: boolean; withRole?: boolean; withNoRole?: boolean },
+) => {
+  reflector.getAllAndOverride.mockImplementation((key: any) => {
+    if (key === IS_PUBLIC_KEY) return meta.public;
+    if (key === WITH_ROLE) return meta.withRole;
+    if (key === WITH_NO_ROLE) return meta.withNoRole;
+    return undefined;
+  });
+};
+
+const setPath = (
+  reflector: any,
+  controllerPath: string,
+  methodPath: string,
+  method: RequestMethod,
+) => {
+  reflector.get.mockImplementation((key: any, target: any) => {
+    if (key === 'path') return target === CTRL ? controllerPath : methodPath;
+    if (key === METHOD_METADATA) return method;
+    return undefined;
+  });
+};
+
+describe('RoleGuard', () => {
+  afterEach(() => jest.clearAllMocks());
+
+  it('permite rota pública', async () => {
+    const { guard, deps } = makeService();
+    setMeta(deps.reflector, { public: true });
+    await expect(
+      guard.canActivate(makeContext({ headers: {} }) as any),
+    ).resolves.toBe(true);
+  });
+
+  it('permite withNoRole', async () => {
+    const { guard, deps } = makeService();
+    setMeta(deps.reflector, { withNoRole: true });
+    await expect(
+      guard.canActivate(makeContext({ headers: {} }) as any),
+    ).resolves.toBe(true);
+  });
+
+  it('permite quando não há withRole', async () => {
+    const { guard, deps } = makeService();
+    setMeta(deps.reflector, {});
+    await expect(
+      guard.canActivate(makeContext({ headers: {} }) as any),
+    ).resolves.toBe(true);
+  });
+
+  it('nega sem token quando withRole', async () => {
+    const { guard, deps } = makeService();
+    setMeta(deps.reflector, { withRole: true });
+    setPath(deps.reflector, 'user', 'list', RequestMethod.GET);
+    const request = { headers: {} };
+    await expect(guard.canActivate(makeContext(request) as any)).rejects.toThrow(
+      UnauthorizedException,
+    );
+  });
+
+  it('permite quando rota autorizada e sem reset pendente', async () => {
+    const { guard, deps } = makeService();
+    setMeta(deps.reflector, { withRole: true });
+    setPath(deps.reflector, 'user', '', RequestMethod.GET);
+    deps.prisma.route.count.mockResolvedValue(1);
+    deps.prisma.user_credential.findFirst.mockResolvedValue(null);
+    const request = {
+      headers: { authorization: 'Bearer tok' },
+      auth: { sub: 3 },
+    };
+    await expect(guard.canActivate(makeContext(request) as any)).resolves.toBe(
+      true,
+    );
+    expect(deps.prisma.route.count).toHaveBeenCalledWith(
+      expect.objectContaining({ where: expect.objectContaining({ url: '/user' }) }),
+    );
+  });
+
+  it('nega (Forbidden) quando rota não autorizada', async () => {
+    const { guard, deps } = makeService();
+    setMeta(deps.reflector, { withRole: true });
+    setPath(deps.reflector, 'user', 'secret', RequestMethod.POST);
+    deps.prisma.route.count.mockResolvedValue(0);
+    const request = {
+      headers: { authorization: 'Bearer tok' },
+      auth: { sub: 3 },
+    };
+    await expect(guard.canActivate(makeContext(request) as any)).rejects.toThrow(
+      ForbiddenException,
+    );
+  });
+
+  it('nega quando há reset de senha pendente em rota não permitida', async () => {
+    const { guard, deps } = makeService();
+    setMeta(deps.reflector, { withRole: true });
+    setPath(deps.reflector, 'user', 'list', RequestMethod.GET);
+    deps.prisma.route.count.mockResolvedValue(1);
+    deps.prisma.user_credential.findFirst.mockResolvedValue({ id: 1 });
+    const request = {
+      headers: { authorization: 'Bearer tok' },
+      auth: { sub: 3 },
+    };
+    await expect(guard.canActivate(makeContext(request) as any)).rejects.toThrow(
+      UnauthorizedException,
+    );
+  });
+
+  it('permite reset pendente em rota liberada (PUT /profile/change-password)', async () => {
+    const { guard, deps } = makeService();
+    setMeta(deps.reflector, { withRole: true });
+    setPath(deps.reflector, 'profile', 'change-password', RequestMethod.PUT);
+    deps.prisma.route.count.mockResolvedValue(1);
+    deps.prisma.user_credential.findFirst.mockResolvedValue({ id: 1 });
+    const request = {
+      headers: { authorization: 'Bearer tok' },
+      auth: { sub: 3 },
+    };
+    await expect(guard.canActivate(makeContext(request) as any)).resolves.toBe(
+      true,
+    );
+  });
+});

package/src/role/role.service.spec.ts

@@ -0,0 +1,179 @@
+import { describe, it, expect, beforeEach, afterEach, jest } from '@jest/globals';
+import { BadRequestException, NotFoundException } from '@nestjs/common';
+import { RoleService } from './role.service';
+
+const makeDeps = () => {
+  const prismaService = {
+    role: { findUnique: jest.fn(), findMany: jest.fn(), deleteMany: jest.fn(), count: jest.fn() },
+    role_user: { deleteMany: jest.fn(), createMany: jest.fn() },
+    role_screen: { deleteMany: jest.fn(), createMany: jest.fn() },
+    role_route: { deleteMany: jest.fn(), createMany: jest.fn() },
+    role_menu: { deleteMany: jest.fn(), createMany: jest.fn() },
+    $queryRaw: jest.fn(),
+  };
+  const paginationService = { paginate: jest.fn().mockResolvedValue({ data: [] }) };
+  const localeService = { getByCode: jest.fn() };
+  const integrationApi = { publishEvent: jest.fn().mockResolvedValue(undefined) };
+  return { prismaService, paginationService, localeService, integrationApi };
+};
+
+const makeService = (deps = makeDeps()) => ({
+  service: new RoleService(
+    deps.prismaService as any,
+    deps.paginationService as any,
+    deps.localeService as any,
+    deps.integrationApi as any,
+  ),
+  deps,
+});
+
+describe('RoleService', () => {
+  afterEach(() => jest.clearAllMocks());
+
+  describe('updateUsers', () => {
+    it('recria vínculos de usuários', async () => {
+      const { service, deps } = makeService();
+      deps.prismaService.role_user.createMany.mockResolvedValue({ count: 2 });
+      const result = await service.updateUsers(3, { ids: [1, 2] } as any);
+      expect(deps.prismaService.role_user.deleteMany).toHaveBeenCalledWith({
+        where: { role_id: 3 },
+      });
+      expect(deps.prismaService.role_user.createMany).toHaveBeenCalledWith({
+        data: [
+          { role_id: 3, user_id: 1 },
+          { role_id: 3, user_id: 2 },
+        ],
+        skipDuplicates: true,
+      });
+      expect(result).toEqual({ count: 2 });
+    });
+  });
+
+  describe('listRoutes', () => {
+    it('busca contains por padrão', async () => {
+      const { service, deps } = makeService();
+      await service.listRoutes(1, {} as any, 'abc');
+      const opts = deps.paginationService.paginate.mock.calls[0][2];
+      expect(opts.where.url).toEqual({ contains: 'abc' });
+    });
+
+    it('busca startsWith / endsWith', async () => {
+      const { service, deps } = makeService();
+      await service.listRoutes(1, {} as any, 'abc', 'startsWith');
+      expect(
+        deps.paginationService.paginate.mock.calls[0][2].where.url,
+      ).toEqual({ startsWith: 'abc' });
+
+      await service.listRoutes(1, {} as any, 'abc', 'endsWith');
+      expect(
+        deps.paginationService.paginate.mock.calls[1][2].where.url,
+      ).toEqual({ endsWith: 'abc' });
+    });
+
+    it('filtra método específico mas ignora "all"', async () => {
+      const { service, deps } = makeService();
+      await service.listRoutes(1, {} as any, undefined, undefined, 'POST');
+      expect(deps.paginationService.paginate.mock.calls[0][2].where.method).toBe(
+        'POST',
+      );
+
+      await service.listRoutes(1, {} as any, undefined, undefined, 'all');
+      expect(
+        deps.paginationService.paginate.mock.calls[1][2].where,
+      ).not.toHaveProperty('method');
+    });
+  });
+
+  describe('get', () => {
+    it('lança NotFound quando role ausente', async () => {
+      const { service, deps } = makeService();
+      deps.prismaService.role.findUnique.mockResolvedValue(null);
+      await expect(service.get(9)).rejects.toThrow(NotFoundException);
+    });
+
+    it('reduz role_locale em mapa por código', async () => {
+      const { service, deps } = makeService();
+      deps.prismaService.role.findUnique.mockResolvedValue({
+        id: 1,
+        slug: 'admin',
+        role_locale: [
+          { name: 'Admin', description: 'd', locale: { code: 'en' } },
+          { name: 'Adm', description: 'dp', locale: { code: 'pt' } },
+        ],
+      });
+      const result = await service.get(1);
+      expect(result.locale).toEqual({
+        en: { name: 'Admin', description: 'd' },
+        pt: { name: 'Adm', description: 'dp' },
+      });
+    });
+  });
+
+  describe('list', () => {
+    it('lança quando locale inexistente', async () => {
+      const { service, deps } = makeService();
+      deps.localeService.getByCode.mockResolvedValue(null);
+      await expect(
+        service.list({ search: '', take: 10, skip: 0 }, 'zz'),
+      ).rejects.toThrow('not found');
+    });
+
+    it('calcula paginação e normaliza available_locales', async () => {
+      const { service, deps } = makeService();
+      deps.localeService.getByCode.mockResolvedValue({ id: 1 });
+      deps.prismaService.$queryRaw.mockResolvedValue([
+        { role_id: 1, available_locales: null },
+      ]);
+      deps.prismaService.role.count.mockResolvedValue(25);
+
+      const result = await service.list({ search: '', take: 10, skip: 0 }, 'en');
+
+      expect(result.total).toBe(25);
+      expect(result.page).toBe(1);
+      expect(result.lastPage).toBe(3);
+      expect(result.prev).toBeNull();
+      expect(result.next).toBe(2);
+      expect(result.data[0].available_locales).toEqual([]);
+    });
+
+    it('usa branch de busca quando search preenchido', async () => {
+      const { service, deps } = makeService();
+      deps.localeService.getByCode.mockResolvedValue({ id: 1 });
+      deps.prismaService.$queryRaw.mockResolvedValue([]);
+      deps.prismaService.role.count.mockResolvedValue(0);
+
+      const result = await service.list({ search: 'adm', take: 10, skip: 10 }, 'en');
+      expect(result.page).toBe(2);
+      expect(result.lastPage).toBe(1);
+      expect(result.next).toBeNull();
+    });
+  });
+
+  describe('delete', () => {
+    it('lança BadRequest sem ids', async () => {
+      const { service } = makeService();
+      await expect(service.delete({ ids: null } as any)).rejects.toThrow(
+        BadRequestException,
+      );
+    });
+
+    it('lança NotFound quando algum id não existe', async () => {
+      const { service, deps } = makeService();
+      deps.prismaService.role.findMany.mockResolvedValue([{ id: 1 }]);
+      await expect(service.delete({ ids: [1, 2] } as any)).rejects.toThrow(
+        NotFoundException,
+      );
+    });
+
+    it('remove roles e publica evento', async () => {
+      const { service, deps } = makeService();
+      deps.prismaService.role.findMany.mockResolvedValue([{ id: 1 }, { id: 2 }]);
+      deps.prismaService.role.deleteMany.mockResolvedValue({ count: 2 });
+      const result = await service.delete({ ids: [1, 2] } as any);
+      expect(result).toEqual({ count: 2 });
+      expect(deps.integrationApi.publishEvent).toHaveBeenCalledWith(
+        expect.objectContaining({ eventName: 'core.role.deleted' }),
+      );
+    });
+  });
+});