@ackplus/nest-auth 1.1.1 → 1.1.5

package/test/role.service.spec.ts

@@ -1,418 +0,0 @@
-import { DataSource, Repository } from 'typeorm';
-import { RoleService } from '../src/lib/role/services/role.service';
-import { NestAuthRole } from '../src/lib/role/entities/role.entity';
-import { NestAuthTenant } from '../src/lib/tenant/entities/tenant.entity';
-import { getRepositoryToken } from '@nestjs/typeorm';
-import { createTestApp } from './test.setup';
-import { ConflictException, NotFoundException } from '@nestjs/common';
-import { DEFAULT_GUARD_NAME } from '../src/lib/auth.constants';
-
-describe('RoleService', () => {
-    let service: RoleService;
-    let roleRepository: Repository<NestAuthRole>;
-    let tenantRepository: Repository<NestAuthTenant>;
-    let dataSource: DataSource;
-    let tenant1: NestAuthTenant;
-    let tenant2: NestAuthTenant;
-
-    beforeEach(async () => {
-        const app = await createTestApp();
-
-        service = app.get<RoleService>(RoleService);
-        dataSource = app.get<DataSource>(DataSource);
-        roleRepository = dataSource.getRepository(NestAuthRole);
-        tenantRepository = dataSource.getRepository(NestAuthTenant);
-
-        // Create test tenants
-        [tenant1, tenant2] = await tenantRepository.save([
-            { name: 'Tenant 1', domain: 'tenant-1' },
-            { name: 'Tenant 2', domain: 'tenant-2' }
-        ]);
-    });
-
-    afterEach(async () => {
-        // Clean up database after each test
-        await dataSource.synchronize(true);
-    });
-
-    afterAll(async () => {
-        // Close the connection after all tests
-        await dataSource.destroy();
-    });
-
-    describe('createRole', () => {
-        it('should create a new role successfully', async () => {
-            const result = await service.createRole('test-role', DEFAULT_GUARD_NAME, tenant1.id);
-
-            expect(result).toBeDefined();
-            expect(result.name).toBe('test-role');
-            expect(result.guard).toBe(DEFAULT_GUARD_NAME);
-            expect(result.tenantId).toBe(tenant1.id);
-            expect(result.isSystem).toBe(false);
-        });
-
-        it('should throw ConflictException if role already exists', async () => {
-            await service.createRole('test-role', DEFAULT_GUARD_NAME, tenant1.id);
-
-            await expect(
-                service.createRole('test-role', DEFAULT_GUARD_NAME, tenant1.id)
-            ).rejects.toThrow(ConflictException);
-        });
-
-        it('should throw ConflictException if role name conflicts with system role', async () => {
-            await service.createRole('system-role', DEFAULT_GUARD_NAME, null, true);
-
-            await expect(
-                service.createRole('system-role', DEFAULT_GUARD_NAME, tenant1.id)
-            ).rejects.toThrow(ConflictException);
-        });
-    });
-
-    describe('getRoleById', () => {
-        it('should return role by id', async () => {
-            const role = await service.createRole('test-role', DEFAULT_GUARD_NAME, tenant1.id);
-
-            const result = await service.getRoleById(role.id);
-
-            expect(result).toBeDefined();
-            expect(result?.id).toBe(role.id);
-            expect(result?.name).toBe('test-role');
-        });
-
-        it('should return null if role not found', async () => {
-            const result = await service.getRoleById('non-existent-id');
-
-            expect(result).toBeNull();
-        });
-    });
-
-    describe('getRoleByName', () => {
-        it('should return role by name and guard', async () => {
-            await service.createRole('test-role', DEFAULT_GUARD_NAME, tenant1.id);
-
-            const result = await service.getRoleByName('test-role', DEFAULT_GUARD_NAME, tenant1.id);
-
-            expect(result).toBeDefined();
-            expect(result?.name).toBe('test-role');
-            expect(result?.guard).toBe(DEFAULT_GUARD_NAME);
-            expect(result?.tenantId).toBe(tenant1.id);
-        });
-
-        it('should return null if role not found', async () => {
-            const result = await service.getRoleByName('non-existent', DEFAULT_GUARD_NAME, tenant1.id);
-
-            expect(result).toBeNull();
-        });
-    });
-
-    describe('getRolesByGuard', () => {
-        it('should return roles by guard', async () => {
-            await service.createRole('test-role-1', DEFAULT_GUARD_NAME, tenant1.id);
-            await service.createRole('test-role-2', DEFAULT_GUARD_NAME, tenant1.id);
-
-            const result = await service.getRolesByGuard(DEFAULT_GUARD_NAME, tenant1.id);
-
-            expect(result).toHaveLength(2);
-            expect(result[0].guard).toBe(DEFAULT_GUARD_NAME);
-            expect(result[1].guard).toBe(DEFAULT_GUARD_NAME);
-        });
-
-        it('should return empty array if guard is not provided', async () => {
-            const result = await service.getRolesByGuard('');
-
-            expect(result).toEqual([]);
-        });
-    });
-
-    describe('getRolesByTenant', () => {
-        it('should return roles by tenant including system roles', async () => {
-            await service.createRole('system-role', DEFAULT_GUARD_NAME, null, true);
-            await service.createRole('tenant-role-1', DEFAULT_GUARD_NAME, tenant1.id);
-            await service.createRole('tenant-role-2', DEFAULT_GUARD_NAME, tenant1.id);
-
-            const result = await service.getRolesByTenant(tenant1.id);
-
-            expect(result).toHaveLength(3);
-            expect(result.some(role => role.name === 'system-role')).toBe(true);
-            expect(result.some(role => role.name === 'tenant-role-1')).toBe(true);
-            expect(result.some(role => role.name === 'tenant-role-2')).toBe(true);
-        });
-
-        it('should return empty array if tenantId is not provided', async () => {
-            const result = await service.getRolesByTenant('');
-
-            expect(result).toEqual([]);
-        });
-    });
-
-    describe('updateRole', () => {
-        it('should update role successfully', async () => {
-            const role = await service.createRole('test-role', DEFAULT_GUARD_NAME, tenant1.id);
-
-            const result = await service.updateRole(role.id, { name: 'updated-role' });
-
-            expect(result.name).toBe('updated-role');
-        });
-
-        it('should throw NotFoundException if role not found', async () => {
-            await expect(
-                service.updateRole('non-existent-id', { name: 'updated-role' })
-            ).rejects.toThrow(NotFoundException);
-        });
-
-        it('should throw BadRequestException if trying to update system role', async () => {
-            const systemRole = await service.createRole('system-role', DEFAULT_GUARD_NAME, null, true);
-
-            await expect(
-                service.updateRole(systemRole.id, { name: 'updated-role' })
-            ).rejects.toThrow('Cannot update system role');
-        });
-    });
-
-    describe('updateRolePermissions', () => {
-        it('should update role permissions successfully', async () => {
-            const role = await service.createRole('test-role', DEFAULT_GUARD_NAME, tenant1.id);
-
-            const result = await service.updateRolePermissions(role.id, ['permission-1', 'permission-2']);
-
-            expect(result).toBeDefined();
-            expect(result.permissions).toHaveLength(2);
-            expect(result.permissions).toContain('permission-1');
-            expect(result.permissions).toContain('permission-2');
-        });
-
-        it('should throw NotFoundException if role not found', async () => {
-            await expect(
-                service.updateRolePermissions('non-existent-id', ['permission-1'])
-            ).rejects.toThrow(NotFoundException);
-        });
-
-        it('should throw BadRequestException if trying to update system role permissions', async () => {
-            const systemRole = await service.createRole('system-role', DEFAULT_GUARD_NAME, null, true);
-
-            await expect(
-                service.updateRolePermissions(systemRole.id, ['permission-1'])
-            ).rejects.toThrow('Cannot update system role');
-        });
-    });
-
-    describe('deleteRole', () => {
-        it('should delete role successfully', async () => {
-            const role = await service.createRole('test-role', DEFAULT_GUARD_NAME, tenant1.id);
-
-            await service.deleteRole(role.id);
-
-            const deletedRole = await service.getRoleById(role.id);
-            expect(deletedRole).toBeNull();
-        });
-
-        it('should throw NotFoundException if role not found', async () => {
-            await expect(
-                service.deleteRole('non-existent-id')
-            ).rejects.toThrow(NotFoundException);
-        });
-
-        it('should throw BadRequestException if trying to delete system role', async () => {
-            const systemRole = await service.createRole('system-role', DEFAULT_GUARD_NAME, null, true);
-
-            await expect(
-                service.deleteRole(systemRole.id)
-            ).rejects.toThrow('Cannot delete system role');
-        });
-    });
-
-    describe('deleteSystemRole', () => {
-        it('should delete system role successfully', async () => {
-            const systemRole = await service.createRole('system-role', DEFAULT_GUARD_NAME, null, true);
-
-            await service.deleteSystemRole(systemRole.id);
-
-            const deletedRole = await service.getRoleById(systemRole.id);
-            expect(deletedRole).toBeNull();
-        });
-
-        it('should not throw error if role not found', async () => {
-            await expect(service.deleteSystemRole('non-existent-id')).resolves.not.toThrow();
-        });
-
-        it('should not delete if role is not a system role', async () => {
-            const role = await service.createRole('test-role', DEFAULT_GUARD_NAME, tenant1.id);
-
-            await service.deleteSystemRole(role.id);
-
-            const existingRole = await service.getRoleById(role.id);
-            expect(existingRole).toBeDefined();
-        });
-    });
-
-    describe('Multiple Tenants and Guards', () => {
-        it('should allow same role name across different tenants', async () => {
-            // Create role in tenant-1
-            const role1 = await service.createRole('admin', DEFAULT_GUARD_NAME, tenant1.id);
-            expect(role1.name).toBe('admin');
-            expect(role1.tenantId).toBe(tenant1.id);
-
-            // Create same role in tenant-2
-            const role2 = await service.createRole('admin', DEFAULT_GUARD_NAME, tenant2.id);
-            expect(role2.name).toBe('admin');
-            expect(role2.tenantId).toBe(tenant2.id);
-
-            // Verify both roles exist
-            const roles = await service.getRolesByGuard(DEFAULT_GUARD_NAME, tenant1.id);
-            expect(roles).toHaveLength(1);
-            expect(roles[0].name).toBe('admin');
-            expect(roles[0].tenantId).toBe(tenant1.id);
-        });
-
-        it('should allow same role name across different guards in same tenant', async () => {
-            // Create role with web guard
-            const webRole = await service.createRole('admin', 'web', tenant1.id);
-            expect(webRole.name).toBe('admin');
-            expect(webRole.guard).toBe('web');
-
-            // Create same role with api guard
-            const apiRole = await service.createRole('admin', 'api', tenant1.id);
-            expect(apiRole.name).toBe('admin');
-            expect(apiRole.guard).toBe('api');
-
-            // Verify both roles exist
-            const webRoles = await service.getRolesByGuard('web', tenant1.id);
-            expect(webRoles).toHaveLength(1);
-            expect(webRoles[0].name).toBe('admin');
-
-            const apiRoles = await service.getRolesByGuard('api', tenant1.id);
-            expect(apiRoles).toHaveLength(1);
-            expect(apiRoles[0].name).toBe('admin');
-        });
-
-        it('should prevent role name conflicts within same tenant and guard', async () => {
-            // Create initial role
-            await service.createRole('admin', 'web', tenant1.id);
-
-            // Try to create same role in same tenant and guard
-            await expect(
-                service.createRole('admin', 'web', tenant1.id)
-            ).rejects.toThrow(ConflictException);
-        });
-
-        it('should prevent role name conflicts with system roles across all tenants', async () => {
-            // Create system role
-            await service.createRole('super-admin', DEFAULT_GUARD_NAME, null, true);
-
-            // Try to create same role in different tenants
-            await expect(
-                service.createRole('super-admin', DEFAULT_GUARD_NAME, tenant1.id)
-            ).rejects.toThrow(ConflictException);
-
-            await expect(
-                service.createRole('super-admin', DEFAULT_GUARD_NAME, tenant2.id)
-            ).rejects.toThrow(ConflictException);
-        });
-    });
-
-    describe('Role Update Restrictions', () => {
-        it('should prevent updating system role properties', async () => {
-            const systemRole = await service.createRole('system-role', DEFAULT_GUARD_NAME, null, true);
-
-            // Try to update various properties
-            await expect(
-                service.updateRole(systemRole.id, { name: 'new-name' })
-            ).rejects.toThrow('Cannot update system role');
-
-            await expect(
-                service.updateRole(systemRole.id, { guard: 'new-guard' })
-            ).rejects.toThrow('Cannot update system role');
-
-            await expect(
-                service.updateRole(systemRole.id, { isSystem: false })
-            ).rejects.toThrow('Cannot update system role');
-
-            await expect(
-                service.updateRole(systemRole.id, { tenantId: tenant1.id })
-            ).rejects.toThrow('Cannot update system role');
-        });
-
-        it('should prevent updating role to conflict with existing roles', async () => {
-            // Create two roles
-            const role1 = await service.createRole('role1', 'web', tenant1.id);
-            await service.createRole('role2', 'web', tenant1.id);
-
-            // Try to update role1 to conflict with role2
-            await expect(
-                service.updateRole(role1.id, { name: 'role2' })
-            ).rejects.toThrow(ConflictException);
-        });
-
-        it('should prevent updating role to conflict with system roles', async () => {
-            // Create system role
-            await service.createRole('system-role', DEFAULT_GUARD_NAME, null, true);
-
-            // Create regular role
-            const regularRole = await service.createRole('regular-role', DEFAULT_GUARD_NAME, tenant1.id);
-
-            // Try to update regular role to system role name
-            await expect(
-                service.updateRole(regularRole.id, { name: 'system-role' })
-            ).rejects.toThrow(ConflictException);
-        });
-
-        it('should allow updating role name to a new unique name', async () => {
-            const role = await service.createRole('old-name', 'web', tenant1.id);
-
-            const updatedRole = await service.updateRole(role.id, { name: 'new-name' });
-
-            expect(updatedRole.name).toBe('new-name');
-            expect(updatedRole.guard).toBe('web');
-            expect(updatedRole.tenantId).toBe(tenant1.id);
-        });
-
-        it('should allow updating role guard if name remains unique', async () => {
-            const role = await service.createRole('admin', 'web', tenant1.id);
-
-            const updatedRole = await service.updateRole(role.id, { guard: 'api' });
-
-            expect(updatedRole.name).toBe('admin');
-            expect(updatedRole.guard).toBe('api');
-            expect(updatedRole.tenantId).toBe(tenant1.id);
-        });
-    });
-
-    describe('Role Permissions Management', () => {
-        it('should handle permissions across multiple tenants', async () => {
-            // Create roles in different tenants
-            const role1 = await service.createRole('admin', 'web', tenant1.id);
-            const role2 = await service.createRole('admin', 'web', tenant2.id);
-
-            // Update permissions for each role
-            const updatedRole1 = await service.updateRolePermissions(role1.id, ['permission-1', 'permission-2']);
-            const updatedRole2 = await service.updateRolePermissions(role2.id, ['permission-3', 'permission-4']);
-
-            // Verify permissions are set correctly
-            expect(updatedRole1.permissions).toHaveLength(2);
-            expect(updatedRole1.permissions).toContain('permission-1');
-            expect(updatedRole1.permissions).toContain('permission-2');
-
-            expect(updatedRole2.permissions).toHaveLength(2);
-            expect(updatedRole2.permissions).toContain('permission-3');
-            expect(updatedRole2.permissions).toContain('permission-4');
-        });
-
-        it('should prevent updating permissions for system roles', async () => {
-            const systemRole = await service.createRole('system-role', DEFAULT_GUARD_NAME, null, true);
-
-            await expect(
-                service.updateRolePermissions(systemRole.id, ['permission-1'])
-            ).rejects.toThrow('Cannot update system role');
-        });
-
-        it('should allow updating permissions for regular roles', async () => {
-            const role = await service.createRole('regular-role', 'web', tenant1.id);
-
-            const updatedRole = await service.updateRolePermissions(role.id, ['permission-1', 'permission-2']);
-
-            expect(updatedRole.permissions).toHaveLength(2);
-            expect(updatedRole.permissions).toContain('permission-1');
-            expect(updatedRole.permissions).toContain('permission-2');
-        });
-    });
-});

package/test/tenant.service.spec.ts

@@ -1,218 +0,0 @@
-import { DataSource, Repository } from 'typeorm';
-import { TenantService } from '../src/lib/tenant/services/tenant.service';
-import { NestAuthTenant } from '../src/lib/tenant/entities/tenant.entity';
-import { getRepositoryToken } from '@nestjs/typeorm';
-import { createTestApp } from './test.setup';
-import { ConflictException, NotFoundException } from '@nestjs/common';
-
-describe('TenantService', () => {
-    let service: TenantService;
-    let tenantRepository: Repository<NestAuthTenant>;
-    let dataSource: DataSource;
-
-    beforeEach(async () => {
-        const app = await createTestApp();
-
-        service = app.get<TenantService>(TenantService);
-        dataSource = app.get<DataSource>(DataSource);
-        tenantRepository = dataSource.getRepository(NestAuthTenant);
-    });
-
-    afterEach(async () => {
-        // Clean up database after each test
-        await dataSource.synchronize(true);
-    });
-
-    afterAll(async () => {
-        // Close the connection after all tests
-        await dataSource.destroy();
-    });
-
-    describe('createTenant', () => {
-        it('should create a new tenant successfully', async () => {
-            const createData = {
-                name: 'Test Tenant',
-                domain: 'test.example.com',
-                description: 'Test tenant description'
-            };
-
-            const result = await service.createTenant(createData);
-
-            expect(result).toBeDefined();
-            expect(result.name).toBe(createData.name);
-            expect(result.domain).toBe(createData.domain);
-            expect(result.description).toBe(createData.description);
-            expect(result.isActive).toBe(true);
-            expect(result.metadata).toEqual({});
-        });
-
-        it('should throw ConflictException if tenant with same domain exists', async () => {
-            const createData = {
-                name: 'Test Tenant',
-                domain: 'test.example.com'
-            };
-
-            await service.createTenant(createData);
-
-            await expect(service.createTenant(createData)).rejects.toThrow(ConflictException);
-        });
-    });
-
-    describe('getTenantById', () => {
-        it('should return tenant by id', async () => {
-            const tenant = await service.createTenant({
-                name: 'Test Tenant',
-                domain: 'test.example.com'
-            });
-
-            const result = await service.getTenantById(tenant.id);
-
-            expect(result).toBeDefined();
-            expect(result?.id).toBe(tenant.id);
-            expect(result?.name).toBe('Test Tenant');
-        });
-
-        it('should return null if tenant not found', async () => {
-            const result = await service.getTenantById('non-existent-id');
-
-            expect(result).toBeNull();
-        });
-    });
-
-    describe('getTenantByDomain', () => {
-        it('should return tenant by domain', async () => {
-            const tenant = await service.createTenant({
-                name: 'Test Tenant',
-                domain: 'test.example.com'
-            });
-
-            const result = await service.getTenantByDomain('test.example.com');
-
-            expect(result).toBeDefined();
-            expect(result?.domain).toBe('test.example.com');
-            expect(result?.id).toBe(tenant.id);
-        });
-
-        it('should return null if tenant not found', async () => {
-            const result = await service.getTenantByDomain('non-existent.com');
-
-            expect(result).toBeNull();
-        });
-    });
-
-    describe('updateTenant', () => {
-        it('should update tenant successfully', async () => {
-            const tenant = await service.createTenant({
-                name: 'Test Tenant',
-                domain: 'test.example.com'
-            });
-
-            const updateData = {
-                name: 'Updated Tenant',
-                description: 'Updated description'
-            };
-
-            const result = await service.updateTenant(tenant.id, updateData);
-
-            expect(result.name).toBe(updateData.name);
-            expect(result.description).toBe(updateData.description);
-            expect(result.domain).toBe('test.example.com'); // Domain should remain unchanged
-        });
-
-        it('should throw NotFoundException if tenant not found', async () => {
-            await expect(
-                service.updateTenant('non-existent-id', { name: 'Updated Tenant' })
-            ).rejects.toThrow(NotFoundException);
-        });
-    });
-
-    describe('deleteTenant', () => {
-        it('should delete tenant successfully', async () => {
-            const tenant = await service.createTenant({
-                name: 'Test Tenant',
-                domain: 'test.example.com'
-            });
-
-            await service.deleteTenant(tenant.id);
-
-            const deletedTenant = await service.getTenantById(tenant.id);
-            expect(deletedTenant).toBeNull();
-        });
-
-        it('should throw NotFoundException if tenant not found', async () => {
-            await expect(
-                service.deleteTenant('non-existent-id')
-            ).rejects.toThrow(NotFoundException);
-        });
-    });
-
-    describe('updateTenantStatus', () => {
-        it('should update tenant status successfully', async () => {
-            const tenant = await service.createTenant({
-                name: 'Test Tenant',
-                domain: 'test.example.com'
-            });
-
-            const result = await service.updateTenantStatus(tenant.id, false);
-
-            expect(result.isActive).toBe(false);
-        });
-
-        it('should throw NotFoundException if tenant not found', async () => {
-            await expect(
-                service.updateTenantStatus('non-existent-id', false)
-            ).rejects.toThrow(NotFoundException);
-        });
-    });
-
-    describe('updateTenantMetadata', () => {
-        it('should update tenant metadata successfully', async () => {
-            const tenant = await service.createTenant({
-                name: 'Test Tenant',
-                domain: 'test.example.com'
-            });
-
-            const metadata = { key: 'value', nested: { data: 'test' } };
-            const result = await service.updateTenantMetadata(tenant.id, metadata);
-
-            expect(result.metadata).toEqual(metadata);
-        });
-
-        it('should throw NotFoundException if tenant not found', async () => {
-            await expect(
-                service.updateTenantMetadata('non-existent-id', { key: 'value' })
-            ).rejects.toThrow(NotFoundException);
-        });
-    });
-
-    describe('Multiple Tenants', () => {
-        it('should allow multiple tenants with different domains', async () => {
-            const tenant1 = await service.createTenant({
-                name: 'Tenant 1',
-                domain: 'tenant1.example.com'
-            });
-
-            const tenant2 = await service.createTenant({
-                name: 'Tenant 2',
-                domain: 'tenant2.example.com'
-            });
-
-            expect(tenant1.id).not.toBe(tenant2.id);
-            expect(tenant1.domain).not.toBe(tenant2.domain);
-        });
-
-        it('should prevent duplicate domains across tenants', async () => {
-            await service.createTenant({
-                name: 'Tenant 1',
-                domain: 'example.com'
-            });
-
-            await expect(
-                service.createTenant({
-                    name: 'Tenant 2',
-                    domain: 'example.com'
-                })
-            ).rejects.toThrow(ConflictException);
-        });
-    });
-});