@hed-hog/core 0.0.387 → 0.0.393

package/src/user/user.service.spec.ts

@@ -10,6 +10,7 @@ const makeDeps = () => {
       findMany: jest.fn(),
       update: jest.fn(),
       deleteMany: jest.fn(),
+      count: jest.fn(),
     },
     role: { findUnique: jest.fn(), findMany: jest.fn() },
     role_user: { findFirst: jest.fn(), create: jest.fn(), delete: jest.fn(), findMany: jest.fn() },
@@ -22,7 +23,7 @@ const makeDeps = () => {
   };
   const paginationService = { paginatePrismaModel: jest.fn() };
   const security = { hashArgon2: jest.fn().mockResolvedValue('hashed') };
-  const challenge = { verifyEmail: jest.fn() };
+  const challenge = { sendEmailConfirmationLink: jest.fn() };
   const file = { upload: jest.fn(), delete: jest.fn(), getBuffer: jest.fn() };
   const integrationApi = { publishEvent: jest.fn().mockResolvedValue(undefined) };
   const settingService = { getSettingValues: jest.fn().mockResolvedValue({}) };
@@ -68,7 +69,16 @@ describe('UserService', () => {
       deps.prismaService.user_activity.create.mockResolvedValue({ id: 1 });
       await service.registerUserActivity(5, 'login');
       expect(deps.prismaService.user_activity.create).toHaveBeenCalledWith({
-        data: { user_id: 5, action: 'login' },
+        data: { user_id: 5, action: 'login', actor_user_id: null },
+      });
+    });
+
+    it('grava o ator quem provocou a atividade (simulação de acesso)', async () => {
+      const { service, deps } = makeService();
+      deps.prismaService.user_activity.create.mockResolvedValue({ id: 1 });
+      await service.registerUserActivity(5, 'impersonationStarted', 9);
+      expect(deps.prismaService.user_activity.create).toHaveBeenCalledWith({
+        data: { user_id: 5, action: 'impersonationStarted', actor_user_id: 9 },
       });
     });
   });
@@ -237,6 +247,158 @@ describe('UserService', () => {
     });
   });
 
+  describe('list', () => {
+    const makeListService = () => {
+      const { service, deps } = makeService();
+      deps.prismaService.$transaction.mockResolvedValue([0, 0, 0]);
+      deps.paginationService.paginatePrismaModel.mockResolvedValue({
+        total: 0,
+        data: [],
+      });
+      return { service, deps };
+    };
+
+    const whereOf = (deps: ReturnType<typeof makeDeps>) =>
+      (deps.paginationService.paginatePrismaModel.mock.calls[0][1] as any).where;
+
+    it('não filtra quando o filtro é ausente ou desconhecido', async () => {
+      const { service, deps } = makeListService();
+      await service.list({});
+      expect(whereOf(deps)).toEqual({});
+
+      deps.paginationService.paginatePrismaModel.mockClear();
+      await service.list({}, 'inexistente');
+      expect(whereOf(deps)).toEqual({});
+    });
+
+    it('filtra bloqueados por suspended_until futuro', async () => {
+      const { service, deps } = makeListService();
+      await service.list({}, 'blocked');
+      expect(whereOf(deps).suspended_until.gt).toBeInstanceOf(Date);
+    });
+
+    it('filtra novos pelos últimos 7 dias', async () => {
+      const { service, deps } = makeListService();
+      await service.list({}, 'new');
+      const gte = whereOf(deps).created_at.gte as Date;
+      const diffInDays = (Date.now() - gte.getTime()) / (24 * 60 * 60 * 1000);
+      expect(Math.round(diffInDays)).toBe(7);
+    });
+
+    it('filtra por credencial de senha com reset pendente', async () => {
+      const { service, deps } = makeListService();
+      await service.list({}, 'password-reset');
+      expect(whereOf(deps)).toEqual({
+        user_credential: {
+          some: { type: 'password', requires_reset: true, revoked_at: null },
+        },
+      });
+    });
+
+    it('busca por nome e por qualquer identificador do usuário', async () => {
+      const { service, deps } = makeListService();
+      await service.list({ search: 'joao@hedhog.com' });
+
+      expect(whereOf(deps)).toEqual({
+        OR: [
+          { name: { contains: 'joao@hedhog.com', mode: 'insensitive' } },
+          {
+            user_identifier: {
+              some: {
+                value: { contains: 'joao@hedhog.com', mode: 'insensitive' },
+              },
+            },
+          },
+        ],
+      });
+    });
+
+    it('ignora busca vazia ou só com espaços', async () => {
+      const { service, deps } = makeListService();
+      await service.list({ search: '   ' });
+      expect(whereOf(deps)).toEqual({});
+
+      deps.paginationService.paginatePrismaModel.mockClear();
+      await service.list({ search: '' });
+      expect(whereOf(deps)).toEqual({});
+    });
+
+    it('combina busca e filtro com AND', async () => {
+      const { service, deps } = makeListService();
+      await service.list({ search: 'joao' }, 'blocked');
+
+      const where = whereOf(deps);
+      expect(where.OR).toBeUndefined();
+      expect(where.AND).toHaveLength(2);
+      expect(where.AND[0].suspended_until.gt).toBeInstanceOf(Date);
+      expect(where.AND[1].OR).toHaveLength(2);
+    });
+
+    it('não delega a busca ao searchFields da paginação', async () => {
+      const { service, deps } = makeListService();
+      await service.list({ search: 'joao' });
+
+      const options = deps.paginationService.paginatePrismaModel.mock
+        .calls[0][1] as any;
+      expect(options.searchFields).toBeUndefined();
+    });
+
+    it('deriva requires_password_reset e last_login_at', async () => {
+      const { service, deps } = makeListService();
+      const lastLogin = new Date('2026-07-01T10:00:00Z');
+      deps.paginationService.paginatePrismaModel.mockResolvedValue({
+        total: 3,
+        data: [
+          {
+            id: 1,
+            user_credential: [
+              { type: 'password', requires_reset: true, revoked_at: null },
+            ],
+            user_activity: [{ action: 'login', created_at: lastLogin }],
+          },
+          {
+            id: 2,
+            user_credential: [
+              { type: 'password', requires_reset: true, revoked_at: new Date() },
+            ],
+            user_activity: [],
+          },
+          { id: 3, user_credential: [], user_activity: [] },
+        ],
+      });
+
+      const { paginate } = await service.list({});
+
+      expect(paginate.total).toBe(3);
+      expect(paginate.data.map((u: any) => u.requires_password_reset)).toEqual([
+        true,
+        false,
+        false,
+      ]);
+      expect(paginate.data.map((u: any) => u.last_login_at)).toEqual([
+        lastLogin,
+        null,
+        null,
+      ]);
+    });
+
+    it('traz apenas o último login e credenciais sem hash', async () => {
+      const { service, deps } = makeListService();
+      await service.list({});
+      const { include } = deps.paginationService.paginatePrismaModel.mock
+        .calls[0][1] as any;
+
+      expect(include.user_activity).toEqual({
+        where: { action: 'login' },
+        orderBy: { created_at: 'desc' },
+        take: 1,
+      });
+      expect(include.user_credential.select.hash).toBeUndefined();
+      expect(include.user_credential.select.requires_reset).toBe(true);
+      expect(include.user_session.select.hash).toBeUndefined();
+    });
+  });
+
   describe('listUserActivities', () => {
     it('mapeia atividades com createdAt ISO', async () => {
       const { service, deps } = makeService();
@@ -250,7 +412,29 @@ describe('UserService', () => {
         id: '7',
         action: 'login',
         createdAt: '2026-01-01T00:00:00.000Z',
+        actor: null,
+      });
+    });
+
+    it('resolve o nome do ator numa atividade de simulação de acesso', async () => {
+      const { service, deps } = makeService();
+      deps.prismaService.user.findUnique.mockResolvedValue({ id: 1 });
+      deps.paginationService.paginatePrismaModel.mockResolvedValue({
+        data: [
+          {
+            id: 8,
+            action: 'impersonationStarted',
+            actor_user_id: 42,
+            created_at: new Date('2026-01-01T00:00:00Z'),
+          },
+        ],
+        total: 1,
       });
+      deps.prismaService.user.findMany.mockResolvedValue([{ id: 42, name: 'Operadora' }]);
+
+      const result = await service.listUserActivities('en', 1, {});
+
+      expect(result.data[0].actor).toEqual({ id: 42, name: 'Operadora' });
     });
   });
 });