Testing¶

describe('Cross-Tenant Isolation', () => {
  let orgAService: SnapshotsService;
  let orgBService: SnapshotsService;

  beforeEach(() => {
    // Zwei isolierte Tenant-Kontexte aufsetzen
    orgAService = createServiceWithTenant('org-a-uuid');
    orgBService = createServiceWithTenant('org-b-uuid');
  });

  it('should not allow Org B to access Org A snapshots', async () => {
    // Org A erstellt einen Snapshot
    const snapshot = await orgAService.create({ ... });

    // Org B versucht darauf zuzugreifen
    await expect(
      orgBService.findOne(snapshot.id),
    ).rejects.toThrow('TENANT_ACCESS_DENIED');
  });
});

describe('SnapshotsService', () => {
  let service: SnapshotsService;
  let mockRepository: jest.Mocked<Repository<Snapshot>>;
  let mockVendorRegistry: jest.Mocked<VendorAdapterRegistry>;

  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      providers: [
        SnapshotsService,
        {
          provide: getRepositoryToken(Snapshot),
          useValue: {
            find: jest.fn(),
            findOne: jest.fn(),
            save: jest.fn(),
            delete: jest.fn(),
          },
        },
        {
          provide: VendorAdapterRegistry,
          useValue: {
            getAdapter: jest.fn(),
          },
        },
      ],
    }).compile();

    service = module.get<SnapshotsService>(SnapshotsService);
    mockRepository = module.get(getRepositoryToken(Snapshot));
    mockVendorRegistry = module.get(VendorAdapterRegistry);
  });

  it('should create a snapshot', async () => {
    const mockAdapter = {
      captureConfiguration: jest.fn().mockResolvedValue([
        { resourceType: 'microsoft.entra.users', data: {}, itemCount: 10, capturedAt: new Date() },
      ]),
    };
    mockVendorRegistry.getAdapter.mockReturnValue(mockAdapter as any);
    mockRepository.save.mockResolvedValue({ id: 'uuid', status: 'completed' } as any);

    const result = await service.create({ vendorTenantId: 'tenant-uuid' });

    expect(result.status).toBe('completed');
    expect(mockAdapter.captureConfiguration).toHaveBeenCalled();
  });
});

describe('RolesGuard', () => {
  it('should allow SUPER_ADMIN to access TENANT_ADMIN endpoint', () => {
    const guard = new RolesGuard(reflector);
    const context = createMockContext({ user: { role: UserRole.SUPER_ADMIN } });

    expect(guard.canActivate(context)).toBe(true);
  });

  it('should deny VIEWER from accessing TENANT_ADMIN endpoint', () => {
    const guard = new RolesGuard(reflector);
    const context = createMockContext({ user: { role: UserRole.VIEWER } });

    expect(guard.canActivate(context)).toBe(false);
  });
});

it('should handle async zlib compression', async () => {
  const data = Buffer.from(JSON.stringify({ test: true }));
  const compressed = await gzipAsync(data);
  const decompressed = await gunzipAsync(compressed);

  expect(JSON.parse(decompressed.toString())).toEqual({ test: true });
});

import { test, expect } from '@playwright/test';

test('user can log in and view dashboard', async ({ page }) => {
  await page.goto('/');
  await page.fill('[data-testid="email"]', 'admin@tcm.local');
  await page.fill('[data-testid="password"]', 'Admin123!TCM');
  await page.click('[data-testid="login-button"]');

  await expect(page).toHaveURL('/dashboard');
  await expect(page.locator('h1')).toContainText('Dashboard');
});

describe('BaselinesService', () => {
  describe('evaluate()', () => {
    it('should return 100% compliance when all rules pass', async () => { ... });
    it('should calculate weighted score based on rule severity', async () => { ... });
    it('should mark rules as not-applicable when resource type missing', async () => { ... });
    it('should throw if baseline does not exist', async () => { ... });
  });
});