interface TestEnvironment {
  // Infrastructure
  database: {
    type: 'postgresql'
    version: '14.0'
    mode: 'isolated' // Each test gets its own schema
  }

  redis: {
    version: '6.2'
    mode: 'dedicated' // Each test gets its own instance
  }

  // EHR Providers
  ehrProviders: {
    mock: {
      epic: MockEpicServer
      cerner: MockCernerServer
      allscripts: MockAllscriptsServer
    }
    sandbox: {
      epic: string // Sandbox URLs
      cerner: string
      allscripts: string
    }
  }

  // Services
  services: {
    audit: HIPAACompliantAuditService
    security: SecurityService
    metrics: MetricsService
    plugins: PluginService
  }
}

describe('Cross-Service Integration', () => {
  describe('EHR Integration -> Webhook Service', () => {
    it('should trigger webhooks on EHR updates', async () => {
      // Setup webhook
      const webhook = await setupTestWebhook({
        events: ['patient:updated'],
      })

      // Update patient in EHR
      await ehrService.updatePatient(testPatient)

      // Verify webhook triggered
      await expectWebhookTriggered(webhook, {
        event: 'patient:updated',
        data: testPatient,
      })
    })
  })

  describe('Plugin Service -> EHR Integration', () => {
    it('should allow plugins to access EHR data', async () => {
      // Install and enable test plugin
      const plugin = await installTestPlugin('ehr-access-plugin')

      // Plugin attempts to read patient data
      const result = await plugin.executeOperation('readPatient')

      // Verify correct data access and audit logging
      expect(result.patient).toBeDefined()
      await expectAuditLog({
        action: 'patient:read',
        actor: plugin.id,
      })
    })
  })
})

describe('Performance Tests', () => {
  describe('Concurrent Operations', () => {
    it('should handle multiple concurrent EHR operations', async () => {
      const operations = Array(100)
        .fill(null)
        .map(() => ehrService.getPatient(generateTestId()))

      const startTime = Date.now()
      await Promise.all(operations)
      const duration = Date.now() - startTime

      expect(duration).toBeLessThan(5000) // 5 seconds max
    })

    it('should maintain performance with multiple active plugins', async () => {
      // Enable multiple plugins
      const plugins = await Promise.all(
        Array(10)
          .fill(null)
          .map(() => installTestPlugin()),
      )

      // Measure operation performance
      const result = await measurePerformance(() =>
        ehrService.searchPatients({ limit: 100 }),
      )

      expect(result.duration).toBeLessThan(1000) // 1 second max
      expect(result.memoryUsage).toBeLessThan(512 * 1024 * 1024) // 512MB max
    })
  })

  describe('Load Testing', () => {
    it('should handle sustained high load', async () => {
      const metrics = await runLoadTest({
        duration: '1h',
        rps: 100, // requests per second
        operations: ['getPatient', 'searchPatients', 'updatePatient'],
      })

      expect(metrics.p95ResponseTime).toBeLessThan(200) // 200ms
      expect(metrics.errorRate).toBeLessThan(0.001) // 0.1% max
      expect(metrics.successRate).toBeGreaterThan(0.999) // 99.9% min
    })
  })
})

describe('Security Tests', () => {
  describe('Authentication & Authorization', () => {
    it('should enforce proper authentication', async () => {
      // Attempt unauthorized access
      await expect(
        ehrService.getPatient(testPatientId, { token: null }),
      ).rejects.toThrow('UNAUTHORIZED')

      // Attempt access with invalid token
      await expect(
        ehrService.getPatient(testPatientId, { token: 'invalid' }),
      ).rejects.toThrow('INVALID_TOKEN')

      // Verify audit logging of attempts
      await expectAuditLog({
        action: 'authentication:failed',
        count: 2,
      })
    })

    it('should enforce permission boundaries', async () => {
      // Create restricted user
      const user = await createTestUser({
        permissions: ['patients:read'],
      })

      // Attempt authorized operation
      await expect(
        ehrService.getPatient(testPatientId, { user }),
      ).resolves.toBeDefined()

      // Attempt unauthorized operation
      await expect(
        ehrService.updatePatient(testPatient, { user }),
      ).rejects.toThrow('FORBIDDEN')
    })
  })

  describe('Plugin Security', () => {
    it('should enforce plugin sandbox boundaries', async () => {
      const plugin = await installTestPlugin('malicious-plugin')

      // Attempt to access file system
      await expect(
        plugin.executeOperation('readFile', '/etc/passwd'),
      ).rejects.toThrow('SANDBOX_VIOLATION')

      // Attempt to make unauthorized network calls
      await expect(
        plugin.executeOperation('httpRequest', 'https://evil.com'),
      ).rejects.toThrow('NETWORK_RESTRICTED')

      // Verify security events logged
      await expectSecurityLog({
        type: 'SECURITY_VIOLATION',
        source: plugin.id,
        count: 2,
      })
    })
  })
})

describe('HIPAA Compliance', () => {
  describe('Audit Logging', () => {
    it('should log all PHI access', async () => {
      // Perform various PHI operations
      await ehrService.getPatient(testPatientId)
      await ehrService.updatePatient(testPatient)
      await ehrService.searchPatients({ name: 'test' })

      // Verify audit logs
      const logs = await auditService.getLogs()
      expect(logs).toContainEqual(
        expect.objectContaining({
          action: 'phi:access',
          resource: 'patient',
          user: expect.any(String),
          timestamp: expect.any(Date),
          details: expect.any(Object),
        }),
      )
    })
  })

  describe('Data Protection', () => {
    it('should enforce data encryption', async () => {
      // Verify data encrypted at rest
      const dbData = await rawQueryDatabase('SELECT * FROM patients')
      expect(dbData.name).not.toEqual(testPatient.name)
      expect(dbData.ssn).not.toEqual(testPatient.ssn)

      // Verify data encrypted in transit
      const networkData = await captureNetworkTraffic(() =>
        ehrService.getPatient(testPatientId),
      )
      expect(networkData).not.toContain(testPatient.name)
      expect(networkData).not.toContain(testPatient.ssn)
    })
  })
})

interface TestData {
  // Test patients with various scenarios
  patients: {
    basic: Patient
    withAppointments: Patient
    withMedicalHistory: Patient
    deceased: Patient
  }

  // Test providers
  providers: {
    doctor: Provider
    nurse: Provider
    admin: Provider
  }

  // Test organizations
  organizations: {
    hospital: Organization
    clinic: Organization
  }
}

// Test data helpers
const testData = {
  async setup() {
    // Create test data
    await setupTestData()
  },

  async cleanup() {
    // Clean up test data
    await cleanupTestData()
  },

  async reset() {
    // Reset to initial state
    await resetTestData()
  },
}

const testUtils = {
  // Mock EHR providers
  mocks: {
    epic: new MockEpicServer(),
    cerner: new MockCernerServer(),
    allscripts: new MockAllscriptsServer(),
  },

  // Performance measurement
  performance: {
    async measure(operation: () => Promise<any>) {
      const metrics = await measurePerformance(operation)
      return metrics
    },

    async runLoadTest(config: LoadTestConfig) {
      const results = await runLoadTest(config)
      return results
    },
  },

  // Security testing
  security: {
    async captureNetworkTraffic(operation: () => Promise<any>) {
      const traffic = await captureNetworkTraffic(operation)
      return traffic
    },

    async auditLogs() {
      const logs = await auditService.getLogs()
      return logs
    },
  },
}

# .github/workflows/integration-tests.yml
name: Integration Tests

on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main, develop]

jobs:
  integration-tests:
    runs-on: ubuntu-latest

    services:
      postgres:
        image: postgres:14
        env:
          POSTGRES_PASSWORD: test
        options: >-
          --health-cmd pg_isready
          --health-interval 10s
          --health-timeout 5s
          --health-retries 5

      redis:
        image: redis:6
        options: >-
          --health-cmd "redis-cli ping"
          --health-interval 10s
          --health-timeout 5s
          --health-retries 5

    steps:
      - uses: actions/checkout@v2

      - name: Setup Node.js
        uses: actions/setup-node@v2
        with:
          node-version: '16'

      - name: Install dependencies
        run: npm ci

      - name: Run integration tests
        run: npm run test:integration
        env:
          DATABASE_URL: postgresql://postgres:test@localhost:5432/test
          REDIS_URL: redis://localhost:6379
          TEST_MODE: true

interface TestReport {
  summary: {
    total: number
    passed: number
    failed: number
    skipped: number
    duration: number
  }

  details: {
    testName: string
    status: 'passed' | 'failed' | 'skipped'
    duration: number
    error?: {
      message: string
      stack: string
    }
  }[]

  performance: {
    averageResponseTime: number
    p95ResponseTime: number
    maxResponseTime: number
    requestsPerSecond: number
  }

  coverage: {
    lines: number
    functions: number
    branches: number
    statements: number
  }
}