feat: expand test coverage and configure comprehensive alerting

- Add unit tests for all core services (identity, intake, finance, dataroom)
- Create integration test framework with shared setup utilities
- Add E2E test suite for complete user workflows
- Add test utilities package (server factory)
- Configure Prometheus alert rules (service health, infrastructure, database, Azure)
- Add alert rules ConfigMap for Kubernetes
- Update Prometheus deployment with alert rules
- Fix tsconfig.json to include test files
- Add tests/tsconfig.json for integration/E2E tests
- Fix server-factory.ts linting issues

tests/README.md

@@ -0,0 +1,91 @@
+# Testing Documentation
+
+**Last Updated**: 2025-01-27  
+**Status**: Test Framework Setup
+
+## Test Structure
+
+```
+tests/
+├── integration/          # Integration tests
+│   ├── setup.ts         # Test context setup
+│   ├── identity-credential-flow.test.ts
+│   └── document-workflow.test.ts
+└── e2e/                  # End-to-end tests
+    └── user-workflows.test.ts
+```
+
+## Running Tests
+
+### All Tests
+```bash
+pnpm test
+```
+
+### Unit Tests Only
+```bash
+pnpm test -- --run unit
+```
+
+### Integration Tests
+```bash
+pnpm test -- --run integration
+```
+
+### E2E Tests
+```bash
+pnpm test -- --run e2e
+```
+
+### With Coverage
+```bash
+pnpm test -- --coverage
+```
+
+## Test Coverage Goals
+
+- **Target**: 80%+ coverage across all services
+- **Current**: Expanding coverage
+- **Priority**: Critical service paths first
+
+## Test Types
+
+### Unit Tests
+- Service-specific tests in `services/*/tests/`
+- Test individual functions and modules
+- Mock external dependencies
+
+### Integration Tests
+- Test service interactions
+- Use test database
+- Test API endpoints
+
+### E2E Tests
+- Test complete user workflows
+- Test across multiple services
+- Test real-world scenarios
+
+## Test Utilities
+
+### Test Context
+- `setupTestContext()` - Initialize all services
+- `teardownTestContext()` - Clean up services
+- `cleanupDatabase()` - Clean test data
+
+### Fixtures
+- Test data factories
+- Mock services
+- Test helpers
+
+## Best Practices
+
+1. **Isolation**: Each test should be independent
+2. **Cleanup**: Always clean up test data
+3. **Mocking**: Mock external services
+4. **Coverage**: Aim for 80%+ coverage
+5. **Speed**: Keep tests fast
+
+---
+
+**Last Updated**: 2025-01-27
+

tests/e2e/user-workflows.test.ts

@@ -0,0 +1,85 @@
+/**
+ * End-to-End Tests: User Workflows
+ * Tests complete user workflows across multiple services
+ */
+
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { setupTestContext, teardownTestContext, cleanupDatabase, TestContext } from '../integration/setup';
+
+describe('User Workflows - E2E', () => {
+  let context: TestContext;
+
+  beforeAll(async () => {
+    context = await setupTestContext();
+    await cleanupDatabase(context.dbPool);
+  });
+
+  afterAll(async () => {
+    await cleanupDatabase(context.dbPool);
+    await teardownTestContext(context);
+  });
+
+  describe('Member Onboarding Workflow', () => {
+    it('should complete full member onboarding flow', async () => {
+      // 1. Create identity
+      const identityResponse = await context.identityService.inject({
+        method: 'POST',
+        url: '/api/v1/identities',
+        payload: {
+          did: 'did:example:member123',
+          eidasLevel: 'substantial',
+        },
+      });
+
+      expect(identityResponse.statusCode).toBe(201);
+      const identity = identityResponse.json();
+
+      // 2. Issue membership credential
+      const credentialResponse = await context.identityService.inject({
+        method: 'POST',
+        url: '/api/v1/credentials/issue',
+        payload: {
+          identityId: identity.id,
+          credentialType: 'membership',
+          claims: {
+            name: 'John Doe',
+            membershipNumber: 'MEMBER-001',
+          },
+        },
+      });
+
+      expect(credentialResponse.statusCode).toBe(201);
+      const credential = credentialResponse.json();
+
+      // 3. Create initial payment
+      const paymentResponse = await context.financeService.inject({
+        method: 'POST',
+        url: '/api/v1/payments',
+        payload: {
+          amount: 10000, // $100.00
+          currency: 'USD',
+          description: 'Membership fee',
+          // Add payment method
+        },
+      });
+
+      expect(paymentResponse.statusCode).toBe(201);
+
+      // Verify complete workflow
+      expect(identity).toHaveProperty('id');
+      expect(credential).toHaveProperty('id');
+    });
+  });
+
+  describe('Document Management Workflow', () => {
+    it('should handle complete document lifecycle', async () => {
+      // 1. Upload document
+      // 2. Process through OCR
+      // 3. Classify document
+      // 4. Store in dataroom
+      // 5. Grant access
+      // Implementation depends on service APIs
+    });
+  });
+});
+

tests/integration/document-workflow.test.ts

@@ -0,0 +1,61 @@
+/**
+ * Integration Test: Document Workflow
+ * Tests document creation, versioning, and workflow
+ */
+
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { setupTestContext, teardownTestContext, cleanupDatabase, TestContext } from './setup';
+
+describe('Document Workflow - Integration', () => {
+  let context: TestContext;
+
+  beforeAll(async () => {
+    context = await setupTestContext();
+    await cleanupDatabase(context.dbPool);
+  });
+
+  afterAll(async () => {
+    await cleanupDatabase(context.dbPool);
+    await teardownTestContext(context);
+  });
+
+  describe('Document Lifecycle', () => {
+    it('should create, update, and version a document', async () => {
+      // 1. Create document via intake service
+      const createResponse = await context.intakeService.inject({
+        method: 'POST',
+        url: '/api/v1/documents',
+        payload: {
+          title: 'Test Document',
+          contentType: 'application/pdf',
+          // Add other required fields
+        },
+      });
+
+      expect(createResponse.statusCode).toBe(201);
+      const document = createResponse.json();
+
+      // 2. Update document
+      const updateResponse = await context.intakeService.inject({
+        method: 'PATCH',
+        url: `/api/v1/documents/${document.id}`,
+        payload: {
+          title: 'Updated Test Document',
+        },
+      });
+
+      expect(updateResponse.statusCode).toBe(200);
+
+      // 3. Check version history
+      const versionsResponse = await context.intakeService.inject({
+        method: 'GET',
+        url: `/api/v1/documents/${document.id}/versions`,
+      });
+
+      expect(versionsResponse.statusCode).toBe(200);
+      const versions = versionsResponse.json();
+      expect(versions).toHaveLength(2); // Original + update
+    });
+  });
+});
+

tests/integration/identity-credential-flow.test.ts

@@ -0,0 +1,63 @@
+/**
+ * Integration Test: Identity Credential Flow
+ * Tests the complete flow of credential issuance and verification
+ */
+
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { setupTestContext, teardownTestContext, cleanupDatabase, TestContext } from './setup';
+
+describe('Identity Credential Flow - Integration', () => {
+  let context: TestContext;
+
+  beforeAll(async () => {
+    context = await setupTestContext();
+    await cleanupDatabase(context.dbPool);
+  });
+
+  afterAll(async () => {
+    await cleanupDatabase(context.dbPool);
+    await teardownTestContext(context);
+  });
+
+  describe('Credential Issuance Flow', () => {
+    it('should issue a verifiable credential end-to-end', async () => {
+      // 1. Create identity
+      const identityResponse = await context.identityService.inject({
+        method: 'POST',
+        url: '/api/v1/identities',
+        payload: {
+          did: 'did:example:123',
+          eidasLevel: 'substantial',
+        },
+      });
+
+      expect(identityResponse.statusCode).toBe(201);
+      const identity = identityResponse.json();
+
+      // 2. Issue credential
+      const credentialResponse = await context.identityService.inject({
+        method: 'POST',
+        url: '/api/v1/credentials/issue',
+        payload: {
+          identityId: identity.id,
+          credentialType: 'membership',
+          claims: {
+            name: 'Test User',
+            membershipNumber: '12345',
+          },
+        },
+      });
+
+      expect(credentialResponse.statusCode).toBe(201);
+      const credential = credentialResponse.json();
+      expect(credential).toHaveProperty('id');
+      expect(credential).toHaveProperty('credentialType', 'membership');
+    });
+
+    it('should verify a credential', async () => {
+      // This would test credential verification
+      // Implementation depends on verifier-sdk
+    });
+  });
+});
+

tests/integration/setup.ts

@@ -0,0 +1,64 @@
+/**
+ * Integration Test Setup
+ * Provides shared utilities and fixtures for integration tests
+ */
+
+import { FastifyInstance } from 'fastify';
+import { getPool } from '@the-order/database';
+
+export interface TestContext {
+  identityService: FastifyInstance;
+  intakeService: FastifyInstance;
+  financeService: FastifyInstance;
+  dataroomService: FastifyInstance;
+  dbPool: ReturnType<typeof getPool>;
+}
+
+export async function setupTestContext(): Promise<TestContext> {
+  // Import services dynamically to avoid circular dependencies
+  const { createServer: createIdentityServer } = await import('../../services/identity/src/index');
+  const { createServer: createIntakeServer } = await import('../../services/intake/src/index');
+  const { createServer: createFinanceServer } = await import('../../services/finance/src/index');
+  const { createServer: createDataroomServer } = await import('../../services/dataroom/src/index');
+
+  const identityService = await createIdentityServer();
+  const intakeService = await createIntakeServer();
+  const financeService = await createFinanceServer();
+  const dataroomService = await createDataroomServer();
+
+  await Promise.all([
+    identityService.ready(),
+    intakeService.ready(),
+    financeService.ready(),
+    dataroomService.ready(),
+  ]);
+
+  const dbPool = getPool({
+    connectionString: process.env.TEST_DATABASE_URL || process.env.DATABASE_URL || '',
+  });
+
+  return {
+    identityService,
+    intakeService,
+    financeService,
+    dataroomService,
+    dbPool,
+  };
+}
+
+export async function teardownTestContext(context: TestContext): Promise<void> {
+  await Promise.all([
+    context.identityService.close(),
+    context.intakeService.close(),
+    context.financeService.close(),
+    context.dataroomService.close(),
+  ]);
+
+  await context.dbPool.end();
+}
+
+export async function cleanupDatabase(pool: ReturnType<typeof getPool>): Promise<void> {
+  // Clean up test data
+  await pool.query('TRUNCATE TABLE credentials, documents, payments, deals CASCADE');
+}
+

tests/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": ".",
+    "types": ["vitest/globals", "node"]
+  },
+  "include": ["**/*.ts"],
+  "exclude": ["node_modules", "dist"]
+}
+