import { EventNames } from '../event-names';

describe('EventNames enum', () => {
  it('tiene valores correctos para tenant CRUD', () => {
    expect(EventNames.CreateTenant).toBe('createTenant');
    expect(EventNames.TenantCreated).toBe('tenantCreated');
    expect(EventNames.TenantCreationError).toBe('tenantCreationError');
    expect(EventNames.UpdateTenant).toBe('updateTenant');
    expect(EventNames.TenantUpdated).toBe('tenantUpdated');
    expect(EventNames.TenantUpdateError).toBe('tenantUpdateError');
    expect(EventNames.DeleteTenant).toBe('deleteTenant');
    expect(EventNames.TenantDeleted).toBe('tenantDeleted');
    expect(EventNames.TenantDeletionError).toBe('tenantDeletionError');
  });

  it('tiene valores correctos para tenant registry', () => {
    expect(EventNames.CreateRegistry).toBe('createRegistry');
    expect(EventNames.RegistryCreated).toBe('registryCreated');
    expect(EventNames.RegistryCreationError).toBe('registryCreationError');
    expect(EventNames.UpdateRegistry).toBe('updateRegistry');
    expect(EventNames.RegistryUpdated).toBe('registryUpdated');
    expect(EventNames.RegistryUpdateError).toBe('registryUpdateError');
    expect(EventNames.DeleteRegistry).toBe('deleteRegistry');
    expect(EventNames.RegistryDeleted).toBe('registryDeleted');
    expect(EventNames.RegistryDeletionError).toBe('registryDeletionError');
  });

  it('tiene valores correctos para invitaciones y tokens', () => {
    expect(EventNames.InviteUser).toBe('inviteUser');
    expect(EventNames.UserInvited).toBe('tenantInvited');
    expect(EventNames.UserInviteError).toBe('tenantInviteError');
    expect(EventNames.RemoveUserFromTenant).toBe('removeUserFromTenant');
    expect(EventNames.UserRemovedFromTenant).toBe('userRemovedFromTenant');
    expect(EventNames.UserRemovalFromTenantError).toBe('userRemovalFromTenantError');
    expect(EventNames.AcceptInvite).toBe('acceptInvite');
    expect(EventNames.InviteAccepted).toBe('inviteAccepted');
    expect(EventNames.InviteAcceptError).toBe('inviteAcceptError');
    expect(EventNames.UpdateInvite).toBe('updateInvite');
    expect(EventNames.InviteUpdated).toBe('inviteUpdated');
    expect(EventNames.InviteUpdateError).toBe('inviteUpdateError');
    expect(EventNames.RejectInvite).toBe('rejectInvite');
    expect(EventNames.InviteRejected).toBe('inviteRejected');
    expect(EventNames.InviteRejectError).toBe('inviteRejectError');
    expect(EventNames.CreateToken).toBe('createToken');
    expect(EventNames.TokenCreated).toBe('tokenCreated');
    expect(EventNames.TokenCreationError).toBe('tokenCreationError');
    expect(EventNames.DeleteToken).toBe('deleteToken');
    expect(EventNames.TokenDeleted).toBe('tokenDeleted');
    expect(EventNames.TokenDeletionError).toBe('tokenDeletionError');
  });

  it('tiene valores correctos para user', () => {
    expect(EventNames.CreateUser).toBe('createUser');
    expect(EventNames.UserCreated).toBe('userCreated');
    expect(EventNames.UserCreationError).toBe('userCreationError');
    expect(EventNames.UpdateUser).toBe('updateUser');
    expect(EventNames.UserUpdated).toBe('userUpdated');
    expect(EventNames.UserUpdateError).toBe('userUpdateError');
    expect(EventNames.LoadUser).toBe('loadUser');
    expect(EventNames.UserLoaded).toBe('userLoaded');
    expect(EventNames.UserLoadError).toBe('userLoadError');
    expect(EventNames.DeleteUser).toBe('deleteUser');
    expect(EventNames.UserDeleted).toBe('userDeleted');
    expect(EventNames.UserDeletionError).toBe('userDeletionError');
    expect(EventNames.AuthError).toBe('authError');
  });

  it('tiene valores correctos para account', () => {
    expect(EventNames.CreateAccount).toBe('createAccount');
    expect(EventNames.AccountCreated).toBe('accountCreated');
    expect(EventNames.AccountCreationError).toBe('accountCreationError');
    expect(EventNames.UpdateAccount).toBe('updateAccount');
    expect(EventNames.AccountUpdated).toBe('accountUpdated');
    expect(EventNames.AccountUpdateError).toBe('accountUpdateError');
    expect(EventNames.DeleteAccount).toBe('deleteAccount');
    expect(EventNames.AccountDeleted).toBe('accountDeleted');
    expect(EventNames.AccountDeletionError).toBe('accountDeletionError');
    expect(EventNames.CleanAccount).toBe('cleanAccount');
    expect(EventNames.AccountCleaned).toBe('accountCleaned');
    expect(EventNames.AccountCleanError).toBe('accountCleanError');
  });

  it('tiene valores correctos para environment', () => {
    expect(EventNames.CreateEnvironment).toBe('createEnvironment');
    expect(EventNames.EnvironmentCreated).toBe('environmentCreated');
    expect(EventNames.EnvironmentCreationError).toBe('environmentCreationError');
    expect(EventNames.UpdateEnvironment).toBe('updateEnvironment');
    expect(EventNames.EnvironmentUpdated).toBe('environmentUpdated');
    expect(EventNames.EnvironmentUpdateError).toBe('environmentUpdateError');
    expect(EventNames.DeleteEnvironment).toBe('deleteEnvironment');
    expect(EventNames.EnvironmentDeleted).toBe('environmentDeleted');
    expect(EventNames.EvironmentDeletionError).toBe('environmentDeletionError');
    expect(EventNames.CleanEnvironment).toBe('cleanEnvironment');
    expect(EventNames.EnvironmentCleaned).toBe('environmentCleaned');
    expect(EventNames.EnvironmentCleanError).toBe('environmentCleanError');
    expect(EventNames.ScaleEnvironment).toBe('scaleEnvironmet');
    expect(EventNames.EnvironmentScaled).toBe('environmentScaled');
    expect(EventNames.EnvironmentScaleError).toBe('environmentScaleError');
  });

  it('tiene valores correctos para service', () => {
    expect(EventNames.DeployService).toBe('deployService');
    expect(EventNames.ServiceDeployed).toBe('serviceDeployed');
    expect(EventNames.ServiceDeploymentError).toBe('deploymentError');
    expect(EventNames.UpdateService).toBe('updateService');
    expect(EventNames.ServiceUpdated).toBe('serviceUpdated');
    expect(EventNames.ServiceUpdateError).toBe('serviceUpdateError');
    expect(EventNames.DeleteService).toBe('deleteService');
    expect(EventNames.ServiceDeleted).toBe('serviceDeleted');
    expect(EventNames.ServiceDeletionError).toBe('serviceDeletionError');
    expect(EventNames.RequestLogs).toBe('requestLogs');
    expect(EventNames.RestartService).toBe('restartService');
    expect(EventNames.ServiceRestarted).toBe('serviceRestarted');
    expect(EventNames.ServiceRestartError).toBe('serviceRestartError');
    expect(EventNames.RequestRevisionData).toBe('requestRevisionData');
    expect(EventNames.updateServiceLinks).toBe('updateServiceLinks');
    expect(EventNames.ChangeRevision).toBe('changeRevision');
    expect(EventNames.RevisionChanged).toBe('revisionChanged');
    expect(EventNames.RevisionChangeError).toBe('revisionChangeError');
    expect(EventNames.RestartInstance).toBe('restartInstance');
    expect(EventNames.InstanceRestarted).toBe('instanceRestarted');
    expect(EventNames.InstanceRestartError).toBe('instanceRestartError');
  });

  it('tiene valores correctos para marketplace', () => {
    expect(EventNames.DeployMarketplaceItem).toBe('deployMarketplaceItem');
    expect(EventNames.MarketplaceItemDeployed).toBe('marketplaceItemDeployed');
    expect(EventNames.MarketplaceItemDeploymentError).toBe('marketplaceItemDeploymentError');
    expect(EventNames.UpdateMarketplaceItem).toBe('updateMarketplaceItem');
    expect(EventNames.MarketplaceItemUpdated).toBe('marketplaceItemUpdated');
    expect(EventNames.MarketplaceItemUpdateError).toBe('marketplaceItemUpdateError');
    expect(EventNames.DeleteMarketplaceItem).toBe('deleteMarketplaceItem');
    expect(EventNames.MarketplaceItemDeleted).toBe('marketplaceItemDeleted');
    expect(EventNames.MarketplaceItemDeletionError).toBe('marketplaceItemDeletionError');
    expect(EventNames.LoadMarketplaceItems).toBe('loadMarketplaceItems');
    expect(EventNames.MarketplaceItemsLoaded).toBe('marketplaceItemsLoaded');
    expect(EventNames.LoadMarketplaceSchema).toBe('loadMarketplaceSchema');
    expect(EventNames.MarketplaceSchemaLoaded).toBe('marketplaceSchemaLoaded');
    expect(EventNames.MarketplaceSchemaLoadError).toBe('marketplaceSchemaLoadError');
  });

  it('tiene valores correctos para resource', () => {
    expect(EventNames.CreateResource).toBe('createResource');
    expect(EventNames.ResourceCreated).toBe('resourceCreated');
    expect(EventNames.ResourceCreationError).toBe('resourceCreationError');
    expect(EventNames.UpdateResource).toBe('updateResource');
    expect(EventNames.ResourceUpdated).toBe('resourceUpdated');
    expect(EventNames.ResourceUpdateError).toBe('resourceUpdateError');
    expect(EventNames.DeleteResource).toBe('deleteResource');
    expect(EventNames.ResourceDeleted).toBe('resourceDeleted');
    expect(EventNames.ResourceDeletionError).toBe('resourceDeletionError');
  });

  it('tiene valores correctos para plan', () => {
    expect(EventNames.UpdatePlan).toBe('updatePlan');
    expect(EventNames.PlanUpdated).toBe('planUpdated');
    expect(EventNames.PlanUpdateError).toBe('planUpdateError');
    expect(EventNames.DowngradePlan).toBe('downgradePlan');
    expect(EventNames.PlanDowngraded).toBe('planDowngraded');
    expect(EventNames.PlanDowngradeError).toBe('planDowngradeError');
  });

  it('tiene valores correctos para organization', () => {
    expect(EventNames.CreateOrganization).toBe('createOrganization');
    expect(EventNames.OrganizationCreated).toBe('organizationCreated');
    expect(EventNames.OrganizationCreationError).toBe('organizationCreationError');
    expect(EventNames.UpdateOrganization).toBe('updateOrganization');
    expect(EventNames.OrganizationUpdated).toBe('organizationUpdated');
    expect(EventNames.OrganizationUpdateError).toBe('organizationUpdateError');
    expect(EventNames.DeleteOrganization).toBe('deleteOrganization');
    expect(EventNames.OrganizationDeleted).toBe('organizationDeleted');
    expect(EventNames.OrganizationDeletionError).toBe('organizationDeletionError');
  });

  it('tiene valores correctos para notification', () => {
    expect(EventNames.CreateNotification).toBe('createNotification');
    expect(EventNames.DeleteNotification).toBe('deleteNotification');
    expect(EventNames.NotificationRead).toBe('notificationRead');
  });

  it('tiene valores correctos para planProviders', () => {
    expect(EventNames.LoadPlanProviders).toBe('loadPlanProviders');
    expect(EventNames.PlanProvidersLoaded).toBe('planProvidersLoaded');
    expect(EventNames.PlanProvidersLoadError).toBe('planProvidersLoadError');
  });
});