@kumori/aurora-backend-handler 1.1.41 → 1.1.43

package/test/event-helper.test.ts

@@ -1,152 +1,537 @@
-
 import EventHelper from '../event-helper';
-import { EventNames } from './../event-names';
+import { EventNames } from '../event-names';
+
+const makeMockHandler = () => ({
+  publish: jest.fn(),
+  subscribe: jest.fn(),
+  unsubscribe: jest.fn(),
+});
 
 beforeEach(() => {
   jest.clearAllMocks();
 });
 
-describe('EventHelper', () => {
-  const dummyGlobalEventHandler = {
-    publish: jest.fn(),
-    subscribe: jest.fn(),
-    unsubscribe: jest.fn(),
-  };
-  
-  const eventHelper = new EventHelper(dummyGlobalEventHandler);
+describe('EventHelper - createEvent defensive branches', () => {
+  it('log error cuando globalEventHandler es null', () => {
+    const consoleSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+    const helper = new EventHelper(null as any);
+    try { helper.tenant.publish.creation({} as any); } catch {}
+    expect(consoleSpy).toHaveBeenCalled();
+    consoleSpy.mockRestore();
+  });
 
+  it('log error cuando subscribe no existe en el handler', () => {
+    const consoleSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+    const handler = { publish: jest.fn(), unsubscribe: jest.fn() } as any;
+    const helper = new EventHelper(handler);
+    try { helper.tenant.subscribe.creation(() => {}); } catch {}
+    expect(consoleSpy).toHaveBeenCalled();
+    consoleSpy.mockRestore();
+  });
+});
 
-  // --- Tenant ---
-  describe('Tenant events', () => {
-    test('tenant.publish.creation llama a globalEventHandler.publish con el nombre de evento correcto y payload', () => {
-      const payload = { id: 'tenant1', name: 'Tenant One' };
-      const spy = jest.spyOn(eventHelper.globalEventHandler, 'publish');
-      eventHelper.tenant.publish.creation(payload as any);
-      expect(spy).toHaveBeenCalledWith(EventNames.CreateTenant, payload);
+describe('EventHelper - Tenant events', () => {
+  const handler = makeMockHandler();
+  const helper = new EventHelper(handler);
+
+  const events: Array<{ method: string; eventName: EventNames }> = [
+    { method: 'creation', eventName: EventNames.CreateTenant },
+    { method: 'created', eventName: EventNames.TenantCreated },
+    { method: 'creationError', eventName: EventNames.TenantCreationError },
+    { method: 'update', eventName: EventNames.UpdateTenant },
+    { method: 'updated', eventName: EventNames.TenantUpdated },
+    { method: 'updateError', eventName: EventNames.TenantUpdateError },
+    { method: 'delete', eventName: EventNames.DeleteTenant },
+    { method: 'deleted', eventName: EventNames.TenantDeleted },
+    { method: 'deletionError', eventName: EventNames.TenantDeletionError },
+    { method: 'createRegistry', eventName: EventNames.CreateRegistry },
+    { method: 'registryCreated', eventName: EventNames.RegistryCreated },
+    { method: 'registryCreationError', eventName: EventNames.RegistryCreationError },
+    { method: 'updateRegistry', eventName: EventNames.UpdateRegistry },
+    { method: 'registryUpdated', eventName: EventNames.RegistryUpdated },
+    { method: 'registryUpdateError', eventName: EventNames.RegistryUpdateError },
+    { method: 'deleteRegistry', eventName: EventNames.DeleteRegistry },
+    { method: 'registryDeleted', eventName: EventNames.RegistryDeleted },
+    { method: 'registryDeletionError', eventName: EventNames.RegistryDeletionError },
+    { method: 'inviteUser', eventName: EventNames.InviteUser },
+    { method: 'userInvited', eventName: EventNames.UserInvited },
+    { method: 'inviteError', eventName: EventNames.UserInviteError },
+    { method: 'removeUser', eventName: EventNames.RemoveUserFromTenant },
+    { method: 'userRemoved', eventName: EventNames.UserRemovedFromTenant },
+    { method: 'removeUserError', eventName: EventNames.UserRemovalFromTenantError },
+    { method: 'acceptInvite', eventName: EventNames.AcceptInvite },
+    { method: 'inviteAccepted', eventName: EventNames.InviteAccepted },
+    { method: 'acceptInviteError', eventName: EventNames.InviteAcceptError },
+    { method: 'updateInvite', eventName: EventNames.UpdateInvite },
+    { method: 'inviteUpdated', eventName: EventNames.InviteUpdated },
+    { method: 'inviteUpdateError', eventName: EventNames.InviteUpdateError },
+    { method: 'rejectInvite', eventName: EventNames.RejectInvite },
+    { method: 'inviteRejected', eventName: EventNames.InviteRejected },
+    { method: 'inviteRejectError', eventName: EventNames.InviteRejectError },
+    { method: 'createToken', eventName: EventNames.CreateToken },
+    { method: 'tokenCreated', eventName: EventNames.TokenCreated },
+    { method: 'tokenCreationError', eventName: EventNames.TokenCreationError },
+    { method: 'deleteToken', eventName: EventNames.DeleteToken },
+    { method: 'tokenDeleted', eventName: EventNames.TokenDeleted },
+    { method: 'tokenDeletionError', eventName: EventNames.TokenDeletionError },
+  ];
+
+  events.forEach(({ method, eventName }) => {
+    it(`tenant.publish.${method} usa ${eventName}`, () => {
+      jest.clearAllMocks();
+      const payload = {};
+      (helper.tenant.publish as any)[method](payload);
+      expect(handler.publish).toHaveBeenCalledWith(eventName, payload);
     });
 
-    test('tenant.subscribe.creation llama a globalEventHandler.subscribe con el nombre de evento correcto y callback', () => {
-      const callback = jest.fn();
-      const spy = jest.spyOn(eventHelper.globalEventHandler, 'subscribe');
-      eventHelper.tenant.subscribe.creation(callback);
-      expect(spy).toHaveBeenCalledWith(EventNames.CreateTenant, callback);
+    it(`tenant.subscribe.${method} usa ${eventName}`, () => {
+      jest.clearAllMocks();
+      const cb = jest.fn();
+      (helper.tenant.subscribe as any)[method](cb);
+      expect(handler.subscribe).toHaveBeenCalledWith(eventName, cb);
     });
 
-    test('tenant.unsubscribe.creation llama a globalEventHandler.unsubscribe con el nombre de evento correcto y callback', () => {
-      const callback = jest.fn();
-      const spy = jest.spyOn(eventHelper.globalEventHandler, 'unsubscribe');
-      eventHelper.tenant.unsubscribe.creation(callback);
-      expect(spy).toHaveBeenCalledWith(EventNames.CreateTenant, callback);
+    it(`tenant.unsubscribe.${method} usa ${eventName}`, () => {
+      jest.clearAllMocks();
+      const cb = jest.fn();
+      (helper.tenant.unsubscribe as any)[method](cb);
+      expect(handler.unsubscribe).toHaveBeenCalledWith(eventName, cb);
     });
   });
+});
+
+describe('EventHelper - User events', () => {
+  const handler = makeMockHandler();
+  const helper = new EventHelper(handler);
+
+  const events: Array<{ method: string; eventName: EventNames }> = [
+    { method: 'creation', eventName: EventNames.CreateUser },
+    { method: 'created', eventName: EventNames.UserCreated },
+    { method: 'creationError', eventName: EventNames.UserCreationError },
+    { method: 'update', eventName: EventNames.UpdateUser },
+    { method: 'updated', eventName: EventNames.UserUpdated },
+    { method: 'updateError', eventName: EventNames.UserUpdateError },
+    { method: 'load', eventName: EventNames.LoadUser },
+    { method: 'loaded', eventName: EventNames.UserLoaded },
+    { method: 'loadError', eventName: EventNames.UserLoadError },
+    { method: 'delete', eventName: EventNames.DeleteUser },
+    { method: 'deleted', eventName: EventNames.UserDeleted },
+    { method: 'deletionError', eventName: EventNames.UserDeletionError },
+    { method: 'authError', eventName: EventNames.AuthError },
+  ];
 
-  // --- User ---
-  describe('User events', () => {
-    test('user.publish.creation llama a globalEventHandler.publish con el nombre de evento correcto y payload', () => {
-      const payload = { id: 'user1', username: 'john.doe' };
-      const spy = jest.spyOn(eventHelper.globalEventHandler, 'publish');
-      eventHelper.user.publish.creation(payload as any);
-      expect(spy).toHaveBeenCalledWith(EventNames.CreateUser, payload);
+  events.forEach(({ method, eventName }) => {
+    it(`user.publish.${method} usa ${eventName}`, () => {
+      jest.clearAllMocks();
+      (helper.user.publish as any)[method]({});
+      expect(handler.publish).toHaveBeenCalledWith(eventName, {});
     });
 
-    test('user.subscribe.creation llama a globalEventHandler.subscribe con el nombre de evento correcto y callback', () => {
-      const callback = jest.fn();
-      const spy = jest.spyOn(eventHelper.globalEventHandler, 'subscribe');
-      eventHelper.user.subscribe.creation(callback);
-      expect(spy).toHaveBeenCalledWith(EventNames.CreateUser, callback);
+    it(`user.subscribe.${method} usa ${eventName}`, () => {
+      jest.clearAllMocks();
+      const cb = jest.fn();
+      (helper.user.subscribe as any)[method](cb);
+      expect(handler.subscribe).toHaveBeenCalledWith(eventName, cb);
+    });
+
+    it(`user.unsubscribe.${method} usa ${eventName}`, () => {
+      jest.clearAllMocks();
+      const cb = jest.fn();
+      (helper.user.unsubscribe as any)[method](cb);
+      expect(handler.unsubscribe).toHaveBeenCalledWith(eventName, cb);
     });
   });
+});
 
-  // --- Account ---
-  describe('Account events', () => {
-    test('account.publish.creation llama a globalEventHandler.publish con el nombre de evento correcto y payload', () => {
-      const payload = { id: 'acc1', name: 'Account One' };
-      const spy = jest.spyOn(eventHelper.globalEventHandler, 'publish');
-      eventHelper.account.publish.creation(payload as any);
-      expect(spy).toHaveBeenCalledWith(EventNames.CreateAccount, payload);
+describe('EventHelper - Account events', () => {
+  const handler = makeMockHandler();
+  const helper = new EventHelper(handler);
+
+  const events: Array<{ method: string; eventName: EventNames }> = [
+    { method: 'creation', eventName: EventNames.CreateAccount },
+    { method: 'created', eventName: EventNames.AccountCreated },
+    { method: 'creationError', eventName: EventNames.AccountCreationError },
+    { method: 'update', eventName: EventNames.UpdateAccount },
+    { method: 'updated', eventName: EventNames.AccountUpdated },
+    { method: 'updateError', eventName: EventNames.AccountUpdateError },
+    { method: 'delete', eventName: EventNames.DeleteAccount },
+    { method: 'deleted', eventName: EventNames.AccountDeleted },
+    { method: 'deletionError', eventName: EventNames.AccountDeletionError },
+    { method: 'clean', eventName: EventNames.CleanAccount },
+    { method: 'cleaned', eventName: EventNames.AccountCleaned },
+    { method: 'cleanError', eventName: EventNames.AccountCleanError },
+  ];
+
+  events.forEach(({ method, eventName }) => {
+    it(`account.publish.${method} usa ${eventName}`, () => {
+      jest.clearAllMocks();
+      (helper.account.publish as any)[method]({});
+      expect(handler.publish).toHaveBeenCalledWith(eventName, {});
+    });
+
+    it(`account.subscribe.${method} usa ${eventName}`, () => {
+      jest.clearAllMocks();
+      const cb = jest.fn();
+      (helper.account.subscribe as any)[method](cb);
+      expect(handler.subscribe).toHaveBeenCalledWith(eventName, cb);
+    });
+
+    it(`account.unsubscribe.${method} usa ${eventName}`, () => {
+      jest.clearAllMocks();
+      const cb = jest.fn();
+      (helper.account.unsubscribe as any)[method](cb);
+      expect(handler.unsubscribe).toHaveBeenCalledWith(eventName, cb);
     });
   });
+});
+
+describe('EventHelper - Environment events', () => {
+  const handler = makeMockHandler();
+  const helper = new EventHelper(handler);
 
-  // --- Environment ---
-  describe('Environment events', () => {
-    test('environment.publish.creation llama a globalEventHandler.publish con el nombre de evento correcto y payload', () => {
-      const payload = { id: 'env1', name: 'Environment One' };
-      const spy = jest.spyOn(eventHelper.globalEventHandler, 'publish');
-      eventHelper.environment.publish.creation(payload as any);
-      expect(spy).toHaveBeenCalledWith(EventNames.CreateEnvironment, payload);
+  const events: Array<{ method: string; eventName: EventNames }> = [
+    { method: 'creation', eventName: EventNames.CreateEnvironment },
+    { method: 'created', eventName: EventNames.EnvironmentCreated },
+    { method: 'creationError', eventName: EventNames.EnvironmentCreationError },
+    { method: 'update', eventName: EventNames.UpdateEnvironment },
+    { method: 'updated', eventName: EventNames.EnvironmentUpdated },
+    { method: 'updateError', eventName: EventNames.EnvironmentUpdateError },
+    { method: 'delete', eventName: EventNames.DeleteEnvironment },
+    { method: 'deleted', eventName: EventNames.EnvironmentDeleted },
+    { method: 'deletionError', eventName: EventNames.EvironmentDeletionError },
+    { method: 'clean', eventName: EventNames.CleanEnvironment },
+    { method: 'cleaned', eventName: EventNames.EnvironmentCleaned },
+    { method: 'cleanError', eventName: EventNames.EnvironmentCleanError },
+    { method: 'scale', eventName: EventNames.ScaleEnvironment },
+    { method: 'scaled', eventName: EventNames.EnvironmentScaled },
+    { method: 'scaleError', eventName: EventNames.EnvironmentScaleError },
+  ];
+
+  events.forEach(({ method, eventName }) => {
+    it(`environment.publish.${method} usa ${eventName}`, () => {
+      jest.clearAllMocks();
+      (helper.environment.publish as any)[method]({});
+      expect(handler.publish).toHaveBeenCalledWith(eventName, {});
+    });
+
+    it(`environment.subscribe.${method} usa ${eventName}`, () => {
+      jest.clearAllMocks();
+      const cb = jest.fn();
+      (helper.environment.subscribe as any)[method](cb);
+      expect(handler.subscribe).toHaveBeenCalledWith(eventName, cb);
+    });
+
+    it(`environment.unsubscribe.${method} usa ${eventName}`, () => {
+      jest.clearAllMocks();
+      const cb = jest.fn();
+      (helper.environment.unsubscribe as any)[method](cb);
+      expect(handler.unsubscribe).toHaveBeenCalledWith(eventName, cb);
     });
   });
+});
 
-  // --- Service ---
-  describe('Service events', () => {
-    test('service.publish.deploy llama a globalEventHandler.publish con el nombre de evento correcto y payload', () => {
-      const payload = { id: 'svc1', name: 'Service One' };
-      const spy = jest.spyOn(eventHelper.globalEventHandler, 'publish');
-      eventHelper.service.publish.deploy(payload as any);
-      expect(spy).toHaveBeenCalledWith(EventNames.DeployService, payload);
+describe('EventHelper - Service events', () => {
+  const handler = makeMockHandler();
+  const helper = new EventHelper(handler);
+
+  const events: Array<{ method: string; eventName: EventNames }> = [
+    { method: 'deploy', eventName: EventNames.DeployService },
+    { method: 'deployed', eventName: EventNames.ServiceDeployed },
+    { method: 'deploymentError', eventName: EventNames.ServiceDeploymentError },
+    { method: 'update', eventName: EventNames.UpdateService },
+    { method: 'updated', eventName: EventNames.ServiceUpdated },
+    { method: 'updateError', eventName: EventNames.ServiceUpdateError },
+    { method: 'delete', eventName: EventNames.DeleteService },
+    { method: 'deleted', eventName: EventNames.ServiceDeleted },
+    { method: 'deletionError', eventName: EventNames.ServiceDeletionError },
+    { method: 'requestLogs', eventName: EventNames.RequestLogs },
+    { method: 'restart', eventName: EventNames.RestartService },
+    { method: 'restarted', eventName: EventNames.ServiceRestarted },
+    { method: 'restartError', eventName: EventNames.ServiceRestartError },
+    { method: 'requestRevisionData', eventName: EventNames.RequestRevisionData },
+    { method: 'updateServiceLinks', eventName: EventNames.updateServiceLinks },
+    { method: 'changeRevision', eventName: EventNames.ChangeRevision },
+    { method: 'revisionChanged', eventName: EventNames.RevisionChanged },
+    { method: 'revisionChangeError', eventName: EventNames.RevisionChangeError },
+    { method: 'restartInstance', eventName: EventNames.RestartInstance },
+    { method: 'instanceRestarted', eventName: EventNames.InstanceRestarted },
+    { method: 'instanceRestartError', eventName: EventNames.InstanceRestartError },
+  ];
+
+  events.forEach(({ method, eventName }) => {
+    it(`service.publish.${method} usa ${eventName}`, () => {
+      jest.clearAllMocks();
+      (helper.service.publish as any)[method]({});
+      expect(handler.publish).toHaveBeenCalledWith(eventName, {});
+    });
+
+    it(`service.subscribe.${method} usa ${eventName}`, () => {
+      jest.clearAllMocks();
+      const cb = jest.fn();
+      (helper.service.subscribe as any)[method](cb);
+      expect(handler.subscribe).toHaveBeenCalledWith(eventName, cb);
+    });
+
+    it(`service.unsubscribe.${method} usa ${eventName}`, () => {
+      jest.clearAllMocks();
+      const cb = jest.fn();
+      (helper.service.unsubscribe as any)[method](cb);
+      expect(handler.unsubscribe).toHaveBeenCalledWith(eventName, cb);
     });
   });
+});
+
+describe('EventHelper - Marketplace events', () => {
+  const handler = makeMockHandler();
+  const helper = new EventHelper(handler);
+
+  const events: Array<{ method: string; eventName: EventNames }> = [
+    { method: 'deployItem', eventName: EventNames.DeployMarketplaceItem },
+    { method: 'itemDeployed', eventName: EventNames.MarketplaceItemDeployed },
+    { method: 'deploymentError', eventName: EventNames.MarketplaceItemDeploymentError },
+    { method: 'updateItem', eventName: EventNames.UpdateMarketplaceItem },
+    { method: 'itemUpdated', eventName: EventNames.MarketplaceItemUpdated },
+    { method: 'updateError', eventName: EventNames.MarketplaceItemUpdateError },
+    { method: 'deleteItem', eventName: EventNames.DeleteMarketplaceItem },
+    { method: 'itemDeleted', eventName: EventNames.MarketplaceItemDeleted },
+    { method: 'deletionError', eventName: EventNames.MarketplaceItemDeletionError },
+    { method: 'loadItems', eventName: EventNames.LoadMarketplaceItems },
+    { method: 'itemsLoaded', eventName: EventNames.MarketplaceItemsLoaded },
+    { method: 'loadSchema', eventName: EventNames.LoadMarketplaceSchema },
+    { method: 'schemaLoaded', eventName: EventNames.MarketplaceSchemaLoaded },
+    { method: 'schemaLoadError', eventName: EventNames.MarketplaceSchemaLoadError },
+  ];
+
+  events.forEach(({ method, eventName }) => {
+    it(`marketplace.publish.${method} usa ${eventName}`, () => {
+      jest.clearAllMocks();
+      (helper.marketplace.publish as any)[method]({});
+      expect(handler.publish).toHaveBeenCalledWith(eventName, {});
+    });
+
+    it(`marketplace.subscribe.${method} usa ${eventName}`, () => {
+      jest.clearAllMocks();
+      const cb = jest.fn();
+      (helper.marketplace.subscribe as any)[method](cb);
+      expect(handler.subscribe).toHaveBeenCalledWith(eventName, cb);
+    });
 
-  // --- Marketplace ---
-  describe('Marketplace events', () => {
-    test('marketplace.publish.deployItem llama a globalEventHandler.publish con el nombre de evento correcto y payload', () => {
-      const payload = { id: 'mkt1', name: 'Marketplace Item' };
-      const spy = jest.spyOn(eventHelper.globalEventHandler, 'publish');
-      eventHelper.marketplace.publish.deployItem(payload as any);
-      expect(spy).toHaveBeenCalledWith(EventNames.DeployMarketplaceItem, payload);
+    it(`marketplace.unsubscribe.${method} usa ${eventName}`, () => {
+      jest.clearAllMocks();
+      const cb = jest.fn();
+      (helper.marketplace.unsubscribe as any)[method](cb);
+      expect(handler.unsubscribe).toHaveBeenCalledWith(eventName, cb);
     });
   });
+});
+
+describe('EventHelper - Resource events', () => {
+  const handler = makeMockHandler();
+  const helper = new EventHelper(handler);
 
-  // --- Resource ---
-  describe('Resource events', () => {
-    test('resource.publish.creation llama a globalEventHandler.publish con el nombre de evento correcto y payload', () => {
-      const payload = { id: 'res1', name: 'Resource One' };
-      const spy = jest.spyOn(eventHelper.globalEventHandler, 'publish');
-      eventHelper.resource.publish.creation(payload as any);
-      expect(spy).toHaveBeenCalledWith(EventNames.CreateResource, payload);
+  const events: Array<{ method: string; eventName: EventNames }> = [
+    { method: 'creation', eventName: EventNames.CreateResource },
+    { method: 'created', eventName: EventNames.ResourceCreated },
+    { method: 'creationError', eventName: EventNames.ResourceCreationError },
+    { method: 'update', eventName: EventNames.UpdateResource },
+    { method: 'updated', eventName: EventNames.ResourceUpdated },
+    { method: 'updateError', eventName: EventNames.ResourceUpdateError },
+    { method: 'delete', eventName: EventNames.DeleteResource },
+    { method: 'deleted', eventName: EventNames.ResourceDeleted },
+    { method: 'deletionError', eventName: EventNames.ResourceDeletionError },
+  ];
+
+  events.forEach(({ method, eventName }) => {
+    it(`resource.publish.${method} usa ${eventName}`, () => {
+      jest.clearAllMocks();
+      (helper.resource.publish as any)[method]({});
+      expect(handler.publish).toHaveBeenCalledWith(eventName, {});
+    });
+
+    it(`resource.subscribe.${method} usa ${eventName}`, () => {
+      jest.clearAllMocks();
+      const cb = jest.fn();
+      (helper.resource.subscribe as any)[method](cb);
+      expect(handler.subscribe).toHaveBeenCalledWith(eventName, cb);
+    });
+
+    it(`resource.unsubscribe.${method} usa ${eventName}`, () => {
+      jest.clearAllMocks();
+      const cb = jest.fn();
+      (helper.resource.unsubscribe as any)[method](cb);
+      expect(handler.unsubscribe).toHaveBeenCalledWith(eventName, cb);
     });
   });
+});
 
-  // --- Plan (payload de tipo string) ---
-  describe('Plan events', () => {
-    test('plan.publish.upgrade llama a globalEventHandler.publish con el nombre de evento correcto y payload', () => {
-      const payload = 'Upgrade Data';
-      const spy = jest.spyOn(eventHelper.globalEventHandler, 'publish');
-      eventHelper.plan.publish.upgrade(payload);
-      expect(spy).toHaveBeenCalledWith(EventNames.UpdatePlan, payload);
+describe('EventHelper - Plan events', () => {
+  const handler = makeMockHandler();
+  const helper = new EventHelper(handler);
+
+  const events: Array<{ method: string; eventName: EventNames }> = [
+    { method: 'upgrade', eventName: EventNames.UpdatePlan },
+    { method: 'upgraded', eventName: EventNames.PlanUpdated },
+    { method: 'upgradeError', eventName: EventNames.PlanUpdateError },
+    { method: 'downgrade', eventName: EventNames.DowngradePlan },
+    { method: 'downgraded', eventName: EventNames.PlanDowngraded },
+    { method: 'downgradeError', eventName: EventNames.PlanDowngradeError },
+  ];
+
+  events.forEach(({ method, eventName }) => {
+    it(`plan.publish.${method} usa ${eventName}`, () => {
+      jest.clearAllMocks();
+      (helper.plan.publish as any)[method]('test');
+      expect(handler.publish).toHaveBeenCalledWith(eventName, 'test');
+    });
+
+    it(`plan.subscribe.${method} usa ${eventName}`, () => {
+      jest.clearAllMocks();
+      const cb = jest.fn();
+      (helper.plan.subscribe as any)[method](cb);
+      expect(handler.subscribe).toHaveBeenCalledWith(eventName, cb);
+    });
+
+    it(`plan.unsubscribe.${method} usa ${eventName}`, () => {
+      jest.clearAllMocks();
+      const cb = jest.fn();
+      (helper.plan.unsubscribe as any)[method](cb);
+      expect(handler.unsubscribe).toHaveBeenCalledWith(eventName, cb);
     });
   });
+});
+
+describe('EventHelper - Organization events', () => {
+  const handler = makeMockHandler();
+  const helper = new EventHelper(handler);
+
+  const events: Array<{ method: string; eventName: EventNames }> = [
+    { method: 'creation', eventName: EventNames.CreateOrganization },
+    { method: 'created', eventName: EventNames.OrganizationCreated },
+    { method: 'creationError', eventName: EventNames.OrganizationCreationError },
+    { method: 'update', eventName: EventNames.UpdateOrganization },
+    { method: 'updated', eventName: EventNames.OrganizationUpdated },
+    { method: 'updateError', eventName: EventNames.OrganizationUpdateError },
+    { method: 'delete', eventName: EventNames.DeleteOrganization },
+    { method: 'deleted', eventName: EventNames.OrganizationDeleted },
+    { method: 'deletionError', eventName: EventNames.OrganizationDeletionError },
+  ];
+
+  events.forEach(({ method, eventName }) => {
+    it(`organization.publish.${method} usa ${eventName}`, () => {
+      jest.clearAllMocks();
+      (helper.organization.publish as any)[method]({});
+      expect(handler.publish).toHaveBeenCalledWith(eventName, {});
+    });
+
+    it(`organization.subscribe.${method} usa ${eventName}`, () => {
+      jest.clearAllMocks();
+      const cb = jest.fn();
+      (helper.organization.subscribe as any)[method](cb);
+      expect(handler.subscribe).toHaveBeenCalledWith(eventName, cb);
+    });
 
-  // --- Organization ---
-  describe('Organization events', () => {
-    test('organization.publish.creation llama a globalEventHandler.publish con el nombre de evento correcto y payload', () => {
-      const payload = { id: 'org1', name: 'Organization One' };
-      const spy = jest.spyOn(eventHelper.globalEventHandler, 'publish');
-      eventHelper.organization.publish.creation(payload as any);
-      expect(spy).toHaveBeenCalledWith(EventNames.CreateOrganization, payload);
+    it(`organization.unsubscribe.${method} usa ${eventName}`, () => {
+      jest.clearAllMocks();
+      const cb = jest.fn();
+      (helper.organization.unsubscribe as any)[method](cb);
+      expect(handler.unsubscribe).toHaveBeenCalledWith(eventName, cb);
     });
   });
+});
+
+describe('EventHelper - Notification events', () => {
+  const handler = makeMockHandler();
+  const helper = new EventHelper(handler);
 
-  // --- PlanProviders ---
-  describe('PlanProviders events', () => {
-    test('planProviders.publish.getPlans llama a globalEventHandler.publish con el nombre de evento correcto', () => {
-      const spy = jest.spyOn(eventHelper.globalEventHandler, 'publish');
-      eventHelper.planProviders.publish.loadPlans();
-      expect(spy).toHaveBeenCalledWith(EventNames.LoadPlanProviders, undefined);
+  const events: Array<{ method: string; eventName: EventNames }> = [
+    { method: 'creation', eventName: EventNames.CreateNotification },
+    { method: 'deletion', eventName: EventNames.DeleteNotification },
+    { method: 'read', eventName: EventNames.NotificationRead },
+  ];
+
+  events.forEach(({ method, eventName }) => {
+    it(`notification.publish.${method} usa ${eventName}`, () => {
+      jest.clearAllMocks();
+      (helper.notification.publish as any)[method]({});
+      expect(handler.publish).toHaveBeenCalledWith(eventName, {});
     });
 
-    test('planProviders.subscribe.getPlans llama a globalEventHandler.subscribe con el nombre de evento correcto y callback', () => {
-      const callback = jest.fn();
-      const spy = jest.spyOn(eventHelper.globalEventHandler, 'subscribe');
-      eventHelper.planProviders.subscribe.loadPlans(callback);
-      expect(spy).toHaveBeenCalledWith(EventNames.LoadPlanProviders, callback);
+    it(`notification.subscribe.${method} usa ${eventName}`, () => {
+      jest.clearAllMocks();
+      const cb = jest.fn();
+      (helper.notification.subscribe as any)[method](cb);
+      expect(handler.subscribe).toHaveBeenCalledWith(eventName, cb);
     });
 
-    test('planProviders.unsubscribe.getPlans llama a globalEventHandler.unsubscribe con el nombre de evento correcto y callback', () => {
-      const callback = jest.fn();
-      const spy = jest.spyOn(eventHelper.globalEventHandler, 'unsubscribe');
-      eventHelper.planProviders.unsubscribe.loadPlans(callback);
-      expect(spy).toHaveBeenCalledWith(EventNames.LoadPlanProviders, callback);
+    it(`notification.unsubscribe.${method} usa ${eventName}`, () => {
+      jest.clearAllMocks();
+      const cb = jest.fn();
+      (helper.notification.unsubscribe as any)[method](cb);
+      expect(handler.unsubscribe).toHaveBeenCalledWith(eventName, cb);
     });
   });
 });
+
+describe('EventHelper - PlanProviders events', () => {
+  const handler = makeMockHandler();
+  const helper = new EventHelper(handler);
+
+  it('planProviders.publish.loadPlans usa LoadPlanProviders', () => {
+    helper.planProviders.publish.loadPlans();
+    expect(handler.publish).toHaveBeenCalledWith(EventNames.LoadPlanProviders, undefined);
+  });
+
+  it('planProviders.publish.plansLoaded usa PlanProvidersLoaded', () => {
+    jest.clearAllMocks();
+    helper.planProviders.publish.plansLoaded([]);
+    expect(handler.publish).toHaveBeenCalledWith(EventNames.PlanProvidersLoaded, []);
+  });
+
+  it('planProviders.publish.loadError usa PlanProvidersLoadError', () => {
+    jest.clearAllMocks();
+    helper.planProviders.publish.loadError();
+    expect(handler.publish).toHaveBeenCalledWith(EventNames.PlanProvidersLoadError, undefined);
+  });
+
+  it('planProviders.subscribe.loadPlans usa LoadPlanProviders', () => {
+    jest.clearAllMocks();
+    const cb = jest.fn();
+    helper.planProviders.subscribe.loadPlans(cb);
+    expect(handler.subscribe).toHaveBeenCalledWith(EventNames.LoadPlanProviders, cb);
+  });
+
+  it('planProviders.subscribe.plansLoaded usa PlanProvidersLoaded', () => {
+    jest.clearAllMocks();
+    const cb = jest.fn();
+    helper.planProviders.subscribe.plansLoaded(cb);
+    expect(handler.subscribe).toHaveBeenCalledWith(EventNames.PlanProvidersLoaded, cb);
+  });
+
+  it('planProviders.subscribe.loadError usa PlanProvidersLoadError', () => {
+    jest.clearAllMocks();
+    const cb = jest.fn();
+    helper.planProviders.subscribe.loadError(cb);
+    expect(handler.subscribe).toHaveBeenCalledWith(EventNames.PlanProvidersLoadError, cb);
+  });
+
+  it('planProviders.unsubscribe.loadPlans usa LoadPlanProviders', () => {
+    jest.clearAllMocks();
+    const cb = jest.fn();
+    helper.planProviders.unsubscribe.loadPlans(cb);
+    expect(handler.unsubscribe).toHaveBeenCalledWith(EventNames.LoadPlanProviders, cb);
+  });
+
+  it('planProviders.unsubscribe.plansLoaded usa PlanProvidersLoaded', () => {
+    jest.clearAllMocks();
+    const cb = jest.fn();
+    helper.planProviders.unsubscribe.plansLoaded(cb);
+    expect(handler.unsubscribe).toHaveBeenCalledWith(EventNames.PlanProvidersLoaded, cb);
+  });
+
+  it('planProviders.unsubscribe.loadError usa PlanProvidersLoadError', () => {
+    jest.clearAllMocks();
+    const cb = jest.fn();
+    helper.planProviders.unsubscribe.loadError(cb);
+    expect(handler.unsubscribe).toHaveBeenCalledWith(EventNames.PlanProvidersLoadError, cb);
+  });
+});