@ackplus/nest-auth 0.1.50 → 1.1.0

package/test/role.service.spec.ts

@@ -0,0 +1,418 @@
+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

@@ -0,0 +1,218 @@
+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);
+        });
+    });
+});