docs/examples/6-testing-examples.ts - gitverse - tm-project/rbac-react-system

docs/examples/6-testing-examples.ts
387 строк11 KB
Artem
add testcases
30 ноя 2025, 17:50
30 ноя 2025, 17:500e29268
/**
 * Примеры тестирования RBAC компонентов
 *
 * Этот файл демонстрирует:
 * - Unit тесты для use cases
 * - Integration тесты для сервисов
 * - Hook тесты с React Testing Library
 * - Mock setup для тестов
 */

import {
  CheckPermissionUseCase,
  CheckRoleUseCase,
  AuthorizationService,
  MockUserRepository,
  MockPermissionRepository,
  MockRoleRepository,
  User,
  Permission,
  Role,
} from 'rbac-react-system'

// ============================================================================
// Example 1: Unit тесты для CheckPermissionUseCase
// ============================================================================

export async function testCheckPermissionUseCase() {
  console.log('=== Testing CheckPermissionUseCase ===')

  // Setup
  const permissions: Permission[] = [
    { id: 'p1', resource: 'users', action: 'read' },
    { id: 'p2', resource: 'users', action: 'write' },
    { id: 'p3', resource: 'posts', action: 'delete' },
  ]

  const roles: Role[] = [
    {
      id: 'editor',
      name: 'Editor',
      permissions: [permissions[0], permissions[1]], // read, write
    },
  ]

  const users: User[] = [
    {
      id: 'user-1',
      roles: ['editor'],
      permissions: [],
      attributes: {},
    },
  ]

  const userRepo = new MockUserRepository(users)
  const permissionRepo = new MockPermissionRepository(permissions)
  const roleRepo = new MockRoleRepository(roles)

  const useCase = new CheckPermissionUseCase(userRepo, permissionRepo, roleRepo)

  // Test cases
  console.log(
    'Test 1: User with role should have inherited permissions',
    await useCase.execute('user-1', 'users', 'read') // должно быть true
  )

  console.log(
    'Test 2: User should not have permission they dont have',
    await useCase.execute('user-1', 'posts', 'delete') // должно быть false
  )

  console.log(
    'Test 3: Non-existent user should return false',
    await useCase.execute('non-existent', 'users', 'read') // должно быть false
  )
}

// ============================================================================
// Example 2: Unit тесты для CheckRoleUseCase
// ============================================================================

export async function testCheckRoleUseCase() {
  console.log('\n=== Testing CheckRoleUseCase ===')

  const roles: Role[] = [
    {
      id: 'user',
      name: 'User',
      permissions: [],
    },
    {
      id: 'editor',
      name: 'Editor',
      permissions: [],
      inheritedRoles: ['user'],
    },
    {
      id: 'admin',
      name: 'Admin',
      permissions: [],
      inheritedRoles: ['editor'],
    },
  ]

  const users: User[] = [
    {
      id: 'admin-user',
      roles: ['admin'],
      permissions: [],
      attributes: {},
    },
  ]

  const userRepo = new MockUserRepository(users)
  const roleRepo = new MockRoleRepository(roles)

  const useCase = new CheckRoleUseCase(userRepo, roleRepo)

  // Test cases
  console.log(
    'Test 1: User should have direct role',
    await useCase.execute('admin-user', 'admin') // должно быть true
  )

  console.log(
    'Test 2: User should have inherited role',
    await useCase.execute('admin-user', 'editor') // должно быть true
  )

  console.log(
    'Test 3: User should have transitive inherited role',
    await useCase.execute('admin-user', 'user') // должно быть true
  )

  console.log(
    'Test 4: User should not have role they dont have',
    await useCase.execute('admin-user', 'moderator') // должно быть false
  )

  // Test getAllEffectiveRoles
  const effectiveRoles = await useCase.getAllEffectiveRoles('admin-user')
  console.log('Test 5: getAllEffectiveRoles should return all roles', effectiveRoles)
}

// ============================================================================
// Example 3: Integration тесты для AuthorizationService
// ============================================================================

export async function testAuthorizationService() {
  console.log('\n=== Testing AuthorizationService ===')

  // Setup complete system
  const permissions: Permission[] = [
    { id: 'p1', resource: 'users', action: 'read' },
    { id: 'p2', resource: 'users', action: 'write' },
    { id: 'p3', resource: 'users', action: 'delete' },
    { id: 'p4', resource: 'posts', action: 'read' },
  ]

  const roles: Role[] = [
    {
      id: 'viewer',
      name: 'Viewer',
      permissions: [permissions[0], permissions[3]], // users:read, posts:read
    },
    {
      id: 'editor',
      name: 'Editor',
      permissions: [permissions[1]], // users:write
      inheritedRoles: ['viewer'],
    },
    {
      id: 'admin',
      name: 'Admin',
      permissions: [permissions[2]], // users:delete
      inheritedRoles: ['editor'],
    },
  ]

  const users: User[] = [
    {
      id: 'admin',
      roles: ['admin'],
      permissions: [],
      attributes: { name: 'Admin User' },
    },
    {
      id: 'editor',
      roles: ['editor'],
      permissions: [],
      attributes: { name: 'Editor User' },
    },
  ]

  const userRepo = new MockUserRepository(users)
  const permissionRepo = new MockPermissionRepository(permissions)
  const roleRepo = new MockRoleRepository(roles)

  const service = new AuthorizationService(
    new CheckPermissionUseCase(userRepo, permissionRepo, roleRepo),
    new CheckRoleUseCase(userRepo, roleRepo)
  )

  // Get users
  const adminUser = (await userRepo.findUserById('admin'))!
  const editorUser = (await userRepo.findUserById('editor'))!

  // Test canAccess
  console.log('Test 1: Admin should access users:delete',
    await service.canAccess('users', 'delete', adminUser))

  console.log('Test 2: Editor should not access users:delete',
    await service.canAccess('users', 'delete', editorUser))

  // Test hasRole
  console.log('Test 3: Admin should have admin role',
    await service.hasRole('admin', adminUser))

  console.log('Test 4: Editor should have inherited viewer role',
    await service.hasRole('viewer', editorUser))

  // Test hasPermission
  console.log('Test 5: Admin should have users:delete permission',
    await service.hasPermission('users:delete', adminUser))

  // Test effective permissions
  const adminPerms = await service.getUserEffectivePermissions(adminUser)
  console.log('Test 6: Admin effective permissions', adminPerms)

  // Test effective roles
  const editorRoles = await service.getUserEffectiveRoles(editorUser)
  console.log('Test 7: Editor effective roles', editorRoles)
}

// ============================================================================
// Example 4: Test с условиями (Conditions)
// ============================================================================

export async function testWithConditions() {
  console.log('\n=== Testing with Conditions ===')

  const permissions: Permission[] = [
    {
      id: 'p1',
      resource: 'documents',
      action: 'read',
      conditions: [
        {
          id: 'dept-check',
          type: 'attribute-based',
          field: 'department',
          operator: 'equals',
          value: 'HR',
        },
      ],
    },
  ]

  const roles: Role[] = [
    {
      id: 'hr-manager',
      name: 'HR Manager',
      permissions: permissions,
    },
  ]

  const users: User[] = [
    {
      id: 'hr-user',
      roles: ['hr-manager'],
      permissions: [],
      attributes: { department: 'HR' },
    },
    {
      id: 'sales-user',
      roles: ['hr-manager'],
      permissions: [],
      attributes: { department: 'Sales' },
    },
  ]

  const userRepo = new MockUserRepository(users)
  const permissionRepo = new MockPermissionRepository(permissions)
  const roleRepo = new MockRoleRepository(roles)

  const useCase = new CheckPermissionUseCase(userRepo, permissionRepo, roleRepo)

  // Test cases
  console.log(
    'Test 1: HR user should access documents:read (condition met)',
    await useCase.execute('hr-user', 'documents', 'read') // должно быть true
  )

  console.log(
    'Test 2: Sales user should not access documents:read (condition not met)',
    await useCase.execute('sales-user', 'documents', 'read') // должно быть false
  )
}

// ============================================================================
// Example 5: Mock setup для тестов
// ============================================================================

export function createTestEnvironment() {
  console.log('\n=== Creating Test Environment ===')

  // Создаем базовые данные для тестирования
  const testPermissions: Permission[] = [
    { id: 'create', resource: 'posts', action: 'create' },
    { id: 'read', resource: 'posts', action: 'read' },
    { id: 'update', resource: 'posts', action: 'update' },
    { id: 'delete', resource: 'posts', action: 'delete' },
  ]

  const testRoles: Role[] = [
    {
      id: 'author',
      name: 'Author',
      permissions: [testPermissions[0], testPermissions[1]], // create, read
    },
    {
      id: 'moderator',
      name: 'Moderator',
      permissions: [testPermissions[3]], // delete
      inheritedRoles: ['author'],
    },
  ]

  const testUsers: User[] = [
    {
      id: 'test-author',
      roles: ['author'],
      permissions: [],
      attributes: { name: 'Test Author', createdAt: new Date() },
    },
    {
      id: 'test-moderator',
      roles: ['moderator'],
      permissions: [],
      attributes: { name: 'Test Moderator', createdAt: new Date() },
    },
  ]

  const userRepository = new MockUserRepository(testUsers)
  const permissionRepository = new MockPermissionRepository(testPermissions)
  const roleRepository = new MockRoleRepository(testRoles)

  console.log('✅ Test environment created')
  console.log(`- Users: ${testUsers.length}`)
  console.log(`- Roles: ${testRoles.length}`)
  console.log(`- Permissions: ${testPermissions.length}`)

  return {
    userRepository,
    permissionRepository,
    roleRepository,
    testUsers,
    testRoles,
    testPermissions,
  }
}

// ============================================================================
// Example 6: Запуск всех тестов
// ============================================================================

export async function runAllTests() {
  console.log('Starting RBAC Tests...\n')

  try {
    await testCheckPermissionUseCase()
    await testCheckRoleUseCase()
    await testAuthorizationService()
    await testWithConditions()
    createTestEnvironment()

    console.log('\n✅ All tests completed!')
  } catch (error) {
    console.error('❌ Test failed:', error)
  }
}

// Запустите это, если выполняется как скрипт
if (typeof window === 'undefined') {
  runAllTests()
}

export default { runAllTests }