@hed-hog/core 0.0.373 → 0.0.374

package/src/file/image-optimization.service.spec.ts

@@ -0,0 +1,283 @@
+import { describe, it, expect, jest, beforeEach, afterEach } from '@jest/globals';
+
+jest.mock('sharp', () => {
+  const instance: any = {
+    metadata: jest.fn(),
+    resize: jest.fn(),
+    webp: jest.fn(),
+    jpeg: jest.fn(),
+    png: jest.fn(),
+    toBuffer: jest.fn(),
+  };
+  const fn: any = jest.fn(() => instance);
+  fn.__instance = instance;
+  return { __esModule: true, default: fn };
+});
+
+import sharp from 'sharp';
+import { ImageOptimizationService } from './image-optimization.service';
+
+const mockSharp = sharp as unknown as jest.Mock & { __instance: any };
+
+const DEFAULT_SETTINGS: Record<string, string | undefined> = {
+  'image-compression-enabled': 'false',
+  'image-compression-quality': undefined,
+  'image-compression-types': undefined,
+  'image-webp-conversion-enabled': 'false',
+  'image-webp-convert-types': undefined,
+  'image-max-dimension': undefined,
+};
+
+const makeService = (settings: Record<string, string | undefined> = {}) => {
+  const merged = { ...DEFAULT_SETTINGS, ...settings };
+  const settingService = {
+    getSettingValues: jest.fn(async () => merged),
+  };
+  const service = new ImageOptimizationService(settingService as any);
+  return { service, settingService, merged };
+};
+
+describe('ImageOptimizationService', () => {
+  beforeEach(() => {
+    const inst = mockSharp.__instance;
+    mockSharp.mockClear();
+    inst.metadata.mockReset();
+    inst.resize.mockReset().mockReturnValue(inst);
+    inst.webp.mockReset().mockReturnValue(inst);
+    inst.jpeg.mockReset().mockReturnValue(inst);
+    inst.png.mockReset().mockReturnValue(inst);
+    inst.toBuffer.mockReset();
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('parseArraySetting (privado)', () => {
+    it('faz parse de JSON array válido', () => {
+      const { service } = makeService();
+      expect((service as any).parseArraySetting('["a","b"]')).toEqual(['a', 'b']);
+    });
+
+    it('retorna [] para undefined', () => {
+      const { service } = makeService();
+      expect((service as any).parseArraySetting(undefined)).toEqual([]);
+    });
+
+    it('retorna [] para JSON inválido', () => {
+      const { service } = makeService();
+      expect((service as any).parseArraySetting('{not json')).toEqual([]);
+    });
+
+    it('retorna [] quando o JSON não é um array', () => {
+      const { service } = makeService();
+      expect((service as any).parseArraySetting('{"a":1}')).toEqual([]);
+    });
+  });
+
+  describe('replaceExtension (privado)', () => {
+    it('troca a extensão preservando o nome base', () => {
+      const { service } = makeService();
+      expect((service as any).replaceExtension('photo.jpg', 'webp')).toBe('photo.webp');
+      expect((service as any).replaceExtension('a.b.png', 'webp')).toBe('a.b.webp');
+      expect((service as any).replaceExtension('noext', 'png')).toBe('noext.png');
+    });
+  });
+
+  describe('pngCompressionLevel (privado)', () => {
+    it('inverte a escala de quality para 0-9', () => {
+      const { service } = makeService();
+      expect((service as any).pngCompressionLevel(100)).toBe(0);
+      expect((service as any).pngCompressionLevel(80)).toBe(2);
+      expect((service as any).pngCompressionLevel(1)).toBe(9);
+    });
+  });
+
+  describe('detectImageMimetype', () => {
+    it('mapeia o format do sharp para o MIME', async () => {
+      const { service } = makeService();
+      mockSharp.__instance.metadata.mockResolvedValue({ format: 'jpeg' });
+      expect(await service.detectImageMimetype(Buffer.from('x'))).toBe('image/jpeg');
+
+      mockSharp.__instance.metadata.mockResolvedValue({ format: 'png' });
+      expect(await service.detectImageMimetype(Buffer.from('x'))).toBe('image/png');
+    });
+
+    it('retorna null para format desconhecido', async () => {
+      const { service } = makeService();
+      mockSharp.__instance.metadata.mockResolvedValue({ format: 'xyz' });
+      expect(await service.detectImageMimetype(Buffer.from('x'))).toBeNull();
+    });
+
+    it('retorna null quando não há format', async () => {
+      const { service } = makeService();
+      mockSharp.__instance.metadata.mockResolvedValue({});
+      expect(await service.detectImageMimetype(Buffer.from('x'))).toBeNull();
+    });
+
+    it('retorna null quando o sharp lança (buffer não é imagem)', async () => {
+      const { service } = makeService();
+      mockSharp.__instance.metadata.mockRejectedValue(new Error('bad'));
+      expect(await service.detectImageMimetype(Buffer.from('x'))).toBeNull();
+    });
+  });
+
+  describe('optimizeBuffer', () => {
+    it('não toca em não-imagens e nem lê settings', async () => {
+      const { service, settingService } = makeService();
+      const buffer = Buffer.from('pdf');
+      const result = await service.optimizeBuffer(buffer, 'application/pdf', 'doc.pdf');
+      expect(result).toEqual({ buffer, mimetype: 'application/pdf', originalname: 'doc.pdf' });
+      expect(settingService.getSettingValues).not.toHaveBeenCalled();
+    });
+
+    it('retorna o original quando não há resize, compressão nem conversão', async () => {
+      const { service } = makeService();
+      const buffer = Buffer.from('img');
+      const result = await service.optimizeBuffer(buffer, 'image/jpeg', 'a.jpg');
+      expect(result).toEqual({ buffer, mimetype: 'image/jpeg', originalname: 'a.jpg' });
+      expect(mockSharp).not.toHaveBeenCalled();
+    });
+
+    it('converte para webp quando habilitado e o tipo está na lista', async () => {
+      const { service } = makeService({
+        'image-webp-conversion-enabled': 'true',
+        'image-webp-convert-types': '["image/jpeg"]',
+        'image-compression-quality': '70',
+      });
+      const out = Buffer.from('webp-bytes');
+      mockSharp.__instance.toBuffer.mockResolvedValue(out);
+
+      const result = await service.optimizeBuffer(Buffer.from('img'), 'image/jpeg', 'photo.jpg');
+
+      expect(result).toEqual({
+        buffer: out,
+        mimetype: 'image/webp',
+        originalname: 'photo.webp',
+      });
+      expect(mockSharp.__instance.webp).toHaveBeenCalledWith({ quality: 70 });
+    });
+
+    it('comprime jpeg mantendo o mesmo mimetype/nome', async () => {
+      const { service } = makeService({
+        'image-compression-enabled': 'true',
+        'image-compression-types': '["image/jpeg"]',
+        'image-compression-quality': '60',
+      });
+      const out = Buffer.from('jpeg-small');
+      mockSharp.__instance.toBuffer.mockResolvedValue(out);
+
+      const result = await service.optimizeBuffer(Buffer.from('img'), 'image/jpeg', 'a.jpg');
+
+      expect(result).toEqual({ buffer: out, mimetype: 'image/jpeg', originalname: 'a.jpg' });
+      expect(mockSharp.__instance.jpeg).toHaveBeenCalledWith({ quality: 60 });
+    });
+
+    it('comprime png usando compressionLevel derivado da quality', async () => {
+      const { service } = makeService({
+        'image-compression-enabled': 'true',
+        'image-compression-types': '["image/png"]',
+        'image-compression-quality': '80',
+      });
+      const out = Buffer.from('png-small');
+      mockSharp.__instance.toBuffer.mockResolvedValue(out);
+
+      const result = await service.optimizeBuffer(Buffer.from('img'), 'image/png', 'a.png');
+
+      expect(result.mimetype).toBe('image/png');
+      // quality 80 -> compressionLevel 2
+      expect(mockSharp.__instance.png).toHaveBeenCalledWith({ compressionLevel: 2 });
+    });
+
+    it('converte bmp/tiff para png', async () => {
+      const { service } = makeService({
+        'image-compression-enabled': 'true',
+        'image-compression-types': '["image/tiff"]',
+      });
+      const out = Buffer.from('png-from-tiff');
+      mockSharp.__instance.toBuffer.mockResolvedValue(out);
+
+      const result = await service.optimizeBuffer(Buffer.from('img'), 'image/tiff', 'scan.tiff');
+
+      expect(result).toEqual({
+        buffer: out,
+        mimetype: 'image/png',
+        originalname: 'scan.png',
+      });
+    });
+
+    it('aplica resize por max-dimension com fit inside', async () => {
+      const { service } = makeService({ 'image-max-dimension': '1024' });
+      const out = Buffer.from('resized');
+      mockSharp.__instance.toBuffer.mockResolvedValue(out);
+
+      const result = await service.optimizeBuffer(Buffer.from('img'), 'image/jpeg', 'a.jpg');
+
+      expect(mockSharp.__instance.resize).toHaveBeenCalledWith({
+        width: 1024,
+        height: 1024,
+        fit: 'inside',
+        withoutEnlargement: true,
+      });
+      expect(result.buffer).toBe(out);
+    });
+
+    it('o alvo preciso (maxWidth/maxHeight) tem prioridade sobre max-dimension', async () => {
+      const { service } = makeService({ 'image-max-dimension': '1024' });
+      mockSharp.__instance.toBuffer.mockResolvedValue(Buffer.from('cropped'));
+
+      await service.optimizeBuffer(Buffer.from('img'), 'image/jpeg', 'a.jpg', {
+        maxWidth: 200,
+        maxHeight: 100,
+      });
+
+      expect(mockSharp.__instance.resize).toHaveBeenCalledWith({
+        width: 200,
+        height: 100,
+        fit: 'cover',
+      });
+    });
+
+    it('formato desconhecido com resize apenas re-encoda o buffer', async () => {
+      const { service } = makeService({ 'image-max-dimension': '500' });
+      const out = Buffer.from('reencoded');
+      mockSharp.__instance.toBuffer.mockResolvedValue(out);
+
+      const result = await service.optimizeBuffer(Buffer.from('img'), 'image/gif', 'a.gif');
+
+      expect(result).toEqual({ buffer: out, mimetype: 'image/gif', originalname: 'a.gif' });
+      expect(mockSharp.__instance.jpeg).not.toHaveBeenCalled();
+      expect(mockSharp.__instance.png).not.toHaveBeenCalled();
+    });
+
+    it('faz fallback para o original quando o sharp lança', async () => {
+      const { service } = makeService({
+        'image-compression-enabled': 'true',
+        'image-compression-types': '["image/jpeg"]',
+      });
+      mockSharp.__instance.toBuffer.mockRejectedValue(new Error('sharp boom'));
+      const warnSpy = jest
+        .spyOn((service as any).logger, 'warn')
+        .mockImplementation(() => undefined);
+      const buffer = Buffer.from('img');
+
+      const result = await service.optimizeBuffer(buffer, 'image/jpeg', 'a.jpg');
+
+      expect(result).toEqual({ buffer, mimetype: 'image/jpeg', originalname: 'a.jpg' });
+      expect(warnSpy).toHaveBeenCalled();
+    });
+
+    it('faz clamp da quality inválida para o default 80', async () => {
+      const { service } = makeService({
+        'image-compression-enabled': 'true',
+        'image-compression-types': '["image/jpeg"]',
+        'image-compression-quality': 'not-a-number',
+      });
+      mockSharp.__instance.toBuffer.mockResolvedValue(Buffer.from('x'));
+
+      await service.optimizeBuffer(Buffer.from('img'), 'image/jpeg', 'a.jpg');
+
+      expect(mockSharp.__instance.jpeg).toHaveBeenCalledWith({ quality: 80 });
+    });
+  });
+});

package/src/file/provider/provider.factory.spec.ts

@@ -0,0 +1,111 @@
+import { describe, it, expect, beforeEach, afterEach, jest } from '@jest/globals';
+
+const s3InitValidation = jest.fn<any>().mockResolvedValue(undefined);
+const localInitValidation = jest.fn<any>().mockResolvedValue(undefined);
+const azureInitValidation = jest.fn<any>().mockResolvedValue(undefined);
+const gcsInitValidation = jest.fn<any>().mockResolvedValue(undefined);
+const spacesInitValidation = jest.fn<any>().mockResolvedValue(undefined);
+
+jest.mock('./s3.provider', () => ({
+  S3Provider: jest.fn().mockImplementation((setting: any) => ({
+    kind: 'S3Provider',
+    setting,
+    initValidation: s3InitValidation,
+  })),
+}));
+
+jest.mock('./local.provider', () => ({
+  LocalProvider: jest.fn().mockImplementation((setting: any, jwtService: any) => ({
+    kind: 'LocalProvider',
+    setting,
+    jwtService,
+    initValidation: localInitValidation,
+  })),
+}));
+
+jest.mock('./azure.provider', () => ({
+  AzureProvider: jest.fn().mockImplementation((setting: any) => ({
+    kind: 'AzureProvider',
+    setting,
+    initValidation: azureInitValidation,
+  })),
+}));
+
+jest.mock('./gcs.provider', () => ({
+  GCSProvider: jest.fn().mockImplementation((setting: any) => ({
+    kind: 'GCSProvider',
+    setting,
+    initValidation: gcsInitValidation,
+  })),
+}));
+
+jest.mock('./spaces.provider', () => ({
+  SpacesProvider: jest.fn().mockImplementation((setting: any) => ({
+    kind: 'SpacesProvider',
+    setting,
+    initValidation: spacesInitValidation,
+  })),
+}));
+
+import { ProviderFactory } from './provider.factory';
+import { EnumProvider } from './provider.enum';
+import { S3Provider } from './s3.provider';
+import { LocalProvider } from './local.provider';
+import { AzureProvider } from './azure.provider';
+import { GCSProvider } from './gcs.provider';
+import { SpacesProvider } from './spaces.provider';
+
+describe('ProviderFactory', () => {
+  const setting = { foo: 'bar' };
+  const jwtService = { sign: jest.fn() } as any;
+
+  afterEach(() => jest.clearAllMocks());
+
+  it('cria S3Provider para EnumProvider.S3 e roda initValidation', async () => {
+    const provider = await ProviderFactory.create(EnumProvider.S3, setting, jwtService);
+    expect(S3Provider).toHaveBeenCalledWith(setting);
+    expect(s3InitValidation).toHaveBeenCalledTimes(1);
+    expect((provider as any).kind).toBe('S3Provider');
+  });
+
+  it('cria LocalProvider para EnumProvider.LOCAL passando o jwtService', async () => {
+    const provider = await ProviderFactory.create(EnumProvider.LOCAL, setting, jwtService);
+    expect(LocalProvider).toHaveBeenCalledWith(setting, jwtService);
+    expect(localInitValidation).toHaveBeenCalledTimes(1);
+    expect((provider as any).kind).toBe('LocalProvider');
+  });
+
+  it('cria AzureProvider para EnumProvider.AZURE', async () => {
+    const provider = await ProviderFactory.create(EnumProvider.AZURE, setting, jwtService);
+    expect(AzureProvider).toHaveBeenCalledWith(setting);
+    expect(azureInitValidation).toHaveBeenCalledTimes(1);
+    expect((provider as any).kind).toBe('AzureProvider');
+  });
+
+  it('cria GCSProvider para EnumProvider.GCS', async () => {
+    const provider = await ProviderFactory.create(EnumProvider.GCS, setting, jwtService);
+    expect(GCSProvider).toHaveBeenCalledWith(setting);
+    expect(gcsInitValidation).toHaveBeenCalledTimes(1);
+    expect((provider as any).kind).toBe('GCSProvider');
+  });
+
+  it('cria SpacesProvider para EnumProvider.SPACES', async () => {
+    const provider = await ProviderFactory.create(EnumProvider.SPACES, setting, jwtService);
+    expect(SpacesProvider).toHaveBeenCalledWith(setting);
+    expect(spacesInitValidation).toHaveBeenCalledTimes(1);
+    expect((provider as any).kind).toBe('SpacesProvider');
+  });
+
+  it('lança erro para tipo de provider não suportado', async () => {
+    await expect(
+      ProviderFactory.create('invalid' as EnumProvider, setting, jwtService),
+    ).rejects.toThrow('Unsupported provider type: invalid');
+  });
+
+  it('propaga erro lançado por initValidation (ex.: configuração inválida)', async () => {
+    s3InitValidation.mockRejectedValueOnce(new Error('missing key'));
+    await expect(
+      ProviderFactory.create(EnumProvider.S3, setting, jwtService),
+    ).rejects.toThrow('missing key');
+  });
+});

package/src/install/install.service.spec.ts

@@ -0,0 +1,139 @@
+import {
+  describe,
+  it,
+  expect,
+  beforeEach,
+  afterEach,
+  jest,
+} from '@jest/globals';
+import { BadRequestException } from '@nestjs/common';
+import { InstallService } from './install.service';
+
+const makeDeps = () => {
+  const security = {
+    randomOpaque: jest.fn().mockReturnValue('rnd'),
+    hashArgon2: jest.fn().mockResolvedValue('hashed'),
+  };
+  const prisma = {
+    setting: { findFirst: jest.fn() },
+    user: { count: jest.fn() },
+    $transaction: jest.fn(),
+  };
+  const configService = { get: jest.fn() };
+  const settingService = { clearCache: jest.fn() };
+  return { security, prisma, configService, settingService };
+};
+
+const makeService = (deps = makeDeps()) => ({
+  service: new InstallService(
+    deps.security as any,
+    deps.prisma as any,
+    deps.configService as any,
+    deps.settingService as any,
+  ),
+  deps,
+});
+
+describe('InstallService', () => {
+  afterEach(() => jest.clearAllMocks());
+
+  describe('normalizeUrl', () => {
+    let service: InstallService;
+    beforeEach(() => {
+      service = makeService().service;
+    });
+    const call = (v: string) => (service as any).normalizeUrl(v);
+
+    it('faz trim e remove barra final', () => {
+      expect(call('  http://x.com/  ')).toBe('http://x.com');
+      expect(call('http://x.com')).toBe('http://x.com');
+      expect(call('http://x.com/path/')).toBe('http://x.com/path');
+    });
+  });
+
+  describe('base64Encode', () => {
+    it('codifica string em base64', () => {
+      const { service } = makeService();
+      expect((service as any).base64Encode('hello')).toBe(
+        Buffer.from('hello').toString('base64'),
+      );
+    });
+  });
+
+  describe('parseEnv', () => {
+    let service: InstallService;
+    beforeEach(() => {
+      service = makeService().service;
+    });
+    const call = (v: string) => (service as any).parseEnv(v);
+
+    it('ignora comentários e linhas sem "="', () => {
+      const result = call('# comment\nFOO=bar\ngarbage\nBAZ=1');
+      expect(result).toEqual({ FOO: 'bar', BAZ: '1' });
+    });
+
+    it('remove aspas envolventes e desescapa aspas internas', () => {
+      const result = call('A="hello world"\nB="a\\"b"');
+      expect(result.A).toBe('hello world');
+      expect(result.B).toBe('a"b');
+    });
+
+    it('preserva "=" no valor', () => {
+      const result = call('URL=postgres://u:p@h/db?x=1');
+      expect(result.URL).toBe('postgres://u:p@h/db?x=1');
+    });
+  });
+
+  describe('checkInstallation', () => {
+    it('true quando setting installed=true (sem contar usuários)', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.setting.findFirst.mockResolvedValue({ value: 'true' });
+      await expect((service as any).checkInstallation()).resolves.toBe(true);
+      expect(deps.prisma.user.count).not.toHaveBeenCalled();
+    });
+
+    it('true quando existem usuários', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.setting.findFirst.mockResolvedValue(null);
+      deps.prisma.user.count.mockResolvedValue(2);
+      await expect((service as any).checkInstallation()).resolves.toBe(true);
+    });
+
+    it('false quando não instalado e sem usuários', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.setting.findFirst.mockResolvedValue({ value: 'false' });
+      deps.prisma.user.count.mockResolvedValue(0);
+      await expect((service as any).checkInstallation()).resolves.toBe(false);
+    });
+  });
+
+  describe('check', () => {
+    it('retorna estado de instalação', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.setting.findFirst.mockResolvedValue({ value: 'true' });
+      await expect(service.check()).resolves.toEqual({
+        success: true,
+        installed: true,
+      });
+    });
+  });
+
+  describe('install', () => {
+    it('lança BadRequest quando já instalado', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.setting.findFirst.mockResolvedValue({ value: 'true' });
+      await expect(
+        service.install({
+          adminUrl: 'http://a',
+          apiUrl: 'http://b',
+          appName: 'App',
+          email: 'e@x.com',
+          password: 'pw',
+          slogan: 's',
+          userName: 'u',
+        } as any),
+      ).rejects.toThrow(BadRequestException);
+      expect(deps.prisma.$transaction).not.toHaveBeenCalled();
+    });
+  });
+});

package/src/integration/services/event-subscriber.registry.spec.ts

@@ -0,0 +1,143 @@
+import { describe, it, expect, beforeEach, jest } from '@jest/globals';
+import { EventSubscriberRegistry } from './event-subscriber.registry';
+import { SubscriberDefinition } from '../types';
+
+const makeDef = (
+  overrides: Partial<SubscriberDefinition> & { eventName: string },
+): SubscriberDefinition => ({
+  consumerName: 'consumer',
+  handler: jest.fn() as any,
+  ...overrides,
+});
+
+describe('EventSubscriberRegistry', () => {
+  let registry: EventSubscriberRegistry;
+
+  beforeEach(() => {
+    registry = new EventSubscriberRegistry();
+  });
+
+  describe('registerHandler / getHandlers', () => {
+    it('cria a lista e retorna o handler registrado', () => {
+      const def = makeDef({ eventName: 'user.created' });
+      registry.registerHandler(def);
+      expect(registry.getHandlers('user.created')).toEqual([def]);
+    });
+
+    it('ordena por prioridade (maior primeiro)', () => {
+      registry.registerHandler(
+        makeDef({ eventName: 'e', consumerName: 'low', priority: 1 }),
+      );
+      registry.registerHandler(
+        makeDef({ eventName: 'e', consumerName: 'high', priority: 10 }),
+      );
+      registry.registerHandler(
+        makeDef({ eventName: 'e', consumerName: 'mid', priority: 5 }),
+      );
+
+      const names = registry.getHandlers('e').map((h) => h.consumerName);
+      expect(names).toEqual(['high', 'mid', 'low']);
+    });
+
+    it('trata prioridade ausente como 0', () => {
+      registry.registerHandler(
+        makeDef({ eventName: 'e', consumerName: 'no-prio' }),
+      );
+      registry.registerHandler(
+        makeDef({ eventName: 'e', consumerName: 'prio', priority: 3 }),
+      );
+      const names = registry.getHandlers('e').map((h) => h.consumerName);
+      expect(names).toEqual(['prio', 'no-prio']);
+    });
+
+    it('retorna array vazio para evento desconhecido', () => {
+      expect(registry.getHandlers('nope')).toEqual([]);
+    });
+  });
+
+  describe('subscribe / subscribeMany', () => {
+    it('subscribe registra com prioridade default 0', () => {
+      const handler = jest.fn() as any;
+      registry.subscribe('e', 'c', handler);
+      const handlers = registry.getHandlers('e');
+      expect(handlers).toHaveLength(1);
+      expect(handlers[0]).toMatchObject({
+        eventName: 'e',
+        consumerName: 'c',
+        priority: 0,
+      });
+    });
+
+    it('subscribeMany registra todos', () => {
+      registry.subscribeMany([
+        makeDef({ eventName: 'a' }),
+        makeDef({ eventName: 'b' }),
+        makeDef({ eventName: 'a', consumerName: 'other' }),
+      ]);
+      expect(registry.getHandlers('a')).toHaveLength(2);
+      expect(registry.getHandlers('b')).toHaveLength(1);
+    });
+  });
+
+  describe('hasHandlers', () => {
+    it('retorna true quando há handlers', () => {
+      registry.subscribe('e', 'c', jest.fn() as any);
+      expect(registry.hasHandlers('e')).toBe(true);
+    });
+
+    it('retorna false para evento inexistente', () => {
+      expect(registry.hasHandlers('missing')).toBe(false);
+    });
+  });
+
+  describe('getEventNames / getHandlerCount', () => {
+    it('retorna nomes de eventos registrados', () => {
+      registry.subscribe('a', 'c', jest.fn() as any);
+      registry.subscribe('b', 'c', jest.fn() as any);
+      expect(registry.getEventNames().sort()).toEqual(['a', 'b']);
+    });
+
+    it('conta todos os handlers em todos os eventos', () => {
+      registry.subscribe('a', 'c1', jest.fn() as any);
+      registry.subscribe('a', 'c2', jest.fn() as any);
+      registry.subscribe('b', 'c3', jest.fn() as any);
+      expect(registry.getHandlerCount()).toBe(3);
+    });
+
+    it('conta zero quando vazio', () => {
+      expect(registry.getHandlerCount()).toBe(0);
+    });
+  });
+
+  describe('removeByConsumerPrefix', () => {
+    it('remove apenas handlers com o prefixo e apaga eventos que ficam vazios', () => {
+      registry.subscribe('a', 'agent:x', jest.fn() as any);
+      registry.subscribe('a', 'other', jest.fn() as any);
+      registry.subscribe('b', 'agent:y', jest.fn() as any);
+
+      registry.removeByConsumerPrefix('agent:');
+
+      expect(registry.getHandlers('a').map((h) => h.consumerName)).toEqual([
+        'other',
+      ]);
+      expect(registry.hasHandlers('b')).toBe(false);
+      expect(registry.getEventNames()).toEqual(['a']);
+    });
+
+    it('não altera nada quando nenhum consumer casa com o prefixo', () => {
+      registry.subscribe('a', 'keep', jest.fn() as any);
+      registry.removeByConsumerPrefix('none:');
+      expect(registry.getHandlerCount()).toBe(1);
+    });
+  });
+
+  describe('clear', () => {
+    it('remove todos os handlers', () => {
+      registry.subscribe('a', 'c', jest.fn() as any);
+      registry.subscribe('b', 'c', jest.fn() as any);
+      registry.clear();
+      expect(registry.getHandlerCount()).toBe(0);
+      expect(registry.getEventNames()).toEqual([]);
+    });
+  });
+});