@stacksjs/ts-cloud-core 0.1.1

package/src/observability/observability.test.ts

@@ -0,0 +1,782 @@
+import { describe, expect, it, beforeEach } from 'bun:test'
+import {
+  XRayManager,
+  xrayManager,
+  MetricsManager,
+  metricsManager,
+  LogsManager,
+  logsManager,
+  SyntheticsManager,
+  syntheticsManager,
+} from '.'
+
+describe('X-Ray Manager', () => {
+  let manager: XRayManager
+
+  beforeEach(() => {
+    manager = new XRayManager()
+  })
+
+  describe('Configuration Creation', () => {
+    it('should create Lambda X-Ray configuration', () => {
+      const config = manager.createLambdaConfig({
+        functionName: 'my-function',
+        samplingRate: 0.2,
+      })
+
+      expect(config.id).toContain('xray-config')
+      expect(config.name).toBe('my-function-xray')
+      expect(config.serviceName).toBe('my-function')
+      expect(config.samplingRate).toBe(0.2)
+      expect(config.enableActiveTracing).toBe(true)
+    })
+
+    it('should use default sampling rate for Lambda', () => {
+      const config = manager.createLambdaConfig({
+        functionName: 'my-function',
+      })
+
+      expect(config.samplingRate).toBe(0.1)
+    })
+
+    it('should create ECS X-Ray configuration', () => {
+      const config = manager.createECSConfig({
+        serviceName: 'web-service',
+        clusterName: 'production',
+        samplingRate: 0.15,
+      })
+
+      expect(config.serviceName).toBe('production/web-service')
+      expect(config.samplingRate).toBe(0.15)
+    })
+
+    it('should create API Gateway X-Ray configuration', () => {
+      const config = manager.createAPIGatewayConfig({
+        apiName: 'my-api',
+        stage: 'prod',
+      })
+
+      expect(config.serviceName).toBe('my-api/prod')
+      expect(config.samplingRate).toBe(0.05)
+    })
+  })
+
+  describe('Sampling Rules', () => {
+    it('should create high-priority sampling rule', () => {
+      const rule = manager.createHighPrioritySamplingRule({
+        ruleName: 'critical-endpoints',
+        serviceName: 'api',
+        urlPath: '/api/critical/*',
+      })
+
+      expect(rule.id).toContain('sampling-rule')
+      expect(rule.priority).toBe(100)
+      expect(rule.fixedRate).toBe(1.0)
+      expect(rule.reservoirSize).toBe(100)
+      expect(rule.urlPath).toBe('/api/critical/*')
+    })
+
+    it('should create error sampling rule', () => {
+      const rule = manager.createErrorSamplingRule('my-service')
+
+      expect(rule.ruleName).toBe('my-service-errors')
+      expect(rule.priority).toBe(200)
+      expect(rule.fixedRate).toBe(1.0)
+      expect(rule.urlPath).toBe('/error/*')
+    })
+
+    it('should create default sampling rule', () => {
+      const rule = manager.createDefaultSamplingRule('my-service', 0.1)
+
+      expect(rule.ruleName).toBe('my-service-default')
+      expect(rule.priority).toBe(1000)
+      expect(rule.fixedRate).toBe(0.1)
+    })
+  })
+
+  describe('CloudFormation Generation', () => {
+    it('should generate Lambda X-Ray CloudFormation', () => {
+      const config = manager.createLambdaConfig({
+        functionName: 'my-function',
+      })
+
+      const cf = manager.generateLambdaXRayCF(config)
+
+      expect(cf.TracingConfig.Mode).toBe('Active')
+    })
+
+    it('should generate API Gateway X-Ray CloudFormation', () => {
+      const config = manager.createAPIGatewayConfig({
+        apiName: 'my-api',
+        stage: 'prod',
+      })
+
+      const cf = manager.generateAPIGatewayXRayCF(config)
+
+      expect(cf.TracingEnabled).toBe(true)
+    })
+
+    it('should generate ECS X-Ray sidecar CloudFormation', () => {
+      const cf = manager.generateECSXRaySidecarCF()
+
+      expect(cf.Name).toBe('xray-daemon')
+      expect(cf.Image).toContain('xray')
+      expect(cf.PortMappings).toHaveLength(1)
+      expect(cf.PortMappings[0].ContainerPort).toBe(2000)
+    })
+
+    it('should generate sampling rule CloudFormation', () => {
+      const rule = manager.createHighPrioritySamplingRule({
+        ruleName: 'test-rule',
+        serviceName: 'api',
+        urlPath: '/test/*',
+      })
+
+      const cf = manager.generateSamplingRuleCF(rule)
+
+      expect(cf.Type).toBe('AWS::XRay::SamplingRule')
+      expect(cf.Properties.SamplingRule.RuleName).toBe('test-rule')
+      expect(cf.Properties.SamplingRule.Priority).toBe(100)
+    })
+  })
+
+  describe('Data Management', () => {
+    it('should retrieve config by id', () => {
+      const config = manager.createLambdaConfig({
+        functionName: 'my-function',
+      })
+
+      const retrieved = manager.getConfig(config.id)
+
+      expect(retrieved).toEqual(config)
+    })
+
+    it('should list all configs', () => {
+      manager.createLambdaConfig({ functionName: 'func1' })
+      manager.createECSConfig({ serviceName: 'svc1', clusterName: 'cluster1' })
+
+      const configs = manager.listConfigs()
+
+      expect(configs).toHaveLength(2)
+    })
+
+    it('should clear all data', () => {
+      manager.createLambdaConfig({ functionName: 'func1' })
+      manager.createHighPrioritySamplingRule({
+        ruleName: 'rule1',
+        serviceName: 'svc1',
+        urlPath: '/test',
+      })
+
+      manager.clear()
+
+      expect(manager.listConfigs()).toHaveLength(0)
+      expect(manager.listSamplingRules()).toHaveLength(0)
+    })
+  })
+
+  it('should use global instance', () => {
+    expect(xrayManager).toBeInstanceOf(XRayManager)
+  })
+})
+
+describe('Metrics Manager', () => {
+  let manager: MetricsManager
+
+  beforeEach(() => {
+    manager = new MetricsManager()
+  })
+
+  describe('Metric Creation', () => {
+    it('should create business metric', () => {
+      const metric = manager.createBusinessMetric({
+        name: 'OrdersPlaced',
+        namespace: 'MyApp/Business',
+        unit: 'Count',
+      })
+
+      expect(metric.id).toContain('metric')
+      expect(metric.name).toBe('OrdersPlaced')
+      expect(metric.unit).toBe('Count')
+      expect(metric.dimensions).toHaveLength(2)
+      expect(metric.dimensions?.[0].name).toBe('Environment')
+      expect(metric.dimensions?.[1].value).toBe('Business')
+    })
+
+    it('should create application metric', () => {
+      const metric = manager.createApplicationMetric({
+        name: 'CacheHits',
+        namespace: 'MyApp/Application',
+        unit: 'Count',
+        serviceName: 'api',
+      })
+
+      expect(metric.dimensions?.[0].value).toBe('api')
+      expect(metric.dimensions?.[1].value).toBe('Application')
+    })
+
+    it('should create performance metric', () => {
+      const metric = manager.createPerformanceMetric({
+        name: 'DatabaseQueryTime',
+        namespace: 'MyApp/Performance',
+        operation: 'getUserById',
+      })
+
+      expect(metric.unit).toBe('Milliseconds')
+      expect(metric.dimensions?.[0].value).toBe('getUserById')
+    })
+
+    it('should create error metric', () => {
+      const metric = manager.createErrorMetric({
+        name: 'ValidationErrors',
+        namespace: 'MyApp/Errors',
+        errorType: 'ValidationError',
+      })
+
+      expect(metric.unit).toBe('Count')
+      expect(metric.dimensions?.[0].value).toBe('ValidationError')
+    })
+  })
+
+  describe('Alarm Creation', () => {
+    it('should create error rate alarm', () => {
+      const metric = manager.createErrorMetric({
+        name: 'Errors',
+        namespace: 'MyApp',
+        errorType: 'All',
+      })
+
+      const alarm = manager.createErrorRateAlarm({
+        metricId: metric.id,
+        name: 'HighErrorRate',
+        threshold: 10,
+        snsTopicArn: 'arn:aws:sns:us-east-1:123456789012:alerts',
+      })
+
+      expect(alarm.id).toContain('alarm')
+      expect(alarm.name).toBe('HighErrorRate')
+      expect(alarm.threshold).toBe(10)
+      expect(alarm.comparisonOperator).toBe('GreaterThanThreshold')
+      expect(alarm.statistic).toBe('Sum')
+      expect(alarm.alarmActions).toContain('arn:aws:sns:us-east-1:123456789012:alerts')
+    })
+
+    it('should create latency alarm', () => {
+      const metric = manager.createPerformanceMetric({
+        name: 'ResponseTime',
+        namespace: 'MyApp',
+        operation: 'apiCall',
+      })
+
+      const alarm = manager.createLatencyAlarm({
+        metricId: metric.id,
+        name: 'HighLatency',
+        thresholdMs: 1000,
+      })
+
+      expect(alarm.threshold).toBe(1000)
+      expect(alarm.statistic).toBe('Average')
+    })
+
+    it('should create throughput alarm', () => {
+      const metric = manager.createBusinessMetric({
+        name: 'Requests',
+        namespace: 'MyApp',
+        unit: 'Count',
+      })
+
+      const alarm = manager.createThroughputAlarm({
+        metricId: metric.id,
+        name: 'LowThroughput',
+        minimumThreshold: 100,
+      })
+
+      expect(alarm.comparisonOperator).toBe('LessThanThreshold')
+      expect(alarm.threshold).toBe(100)
+    })
+
+    it('should throw error for non-existent metric', () => {
+      expect(() => {
+        manager.createAlarm('non-existent', {
+          name: 'Test',
+          comparisonOperator: 'GreaterThanThreshold',
+          evaluationPeriods: 1,
+          threshold: 10,
+          period: 60,
+          statistic: 'Average',
+        })
+      }).toThrow('Metric not found')
+    })
+  })
+
+  describe('CloudFormation Generation', () => {
+    it('should generate alarm CloudFormation', () => {
+      const metric = manager.createBusinessMetric({
+        name: 'Orders',
+        namespace: 'MyApp',
+        unit: 'Count',
+      })
+
+      const alarm = manager.createErrorRateAlarm({
+        metricId: metric.id,
+        name: 'HighOrders',
+        threshold: 100,
+      })
+
+      const cf = manager.generateAlarmCF(metric, alarm)
+
+      expect(cf.Type).toBe('AWS::CloudWatch::Alarm')
+      expect(cf.Properties.AlarmName).toBe('HighOrders')
+      expect(cf.Properties.MetricName).toBe('Orders')
+      expect(cf.Properties.Namespace).toBe('MyApp')
+      expect(cf.Properties.Threshold).toBe(100)
+    })
+
+    it('should generate composite alarm CloudFormation', () => {
+      const alarm = manager.createCompositeAlarm({
+        name: 'CriticalIssues',
+        description: 'Multiple critical conditions',
+        alarmRule: 'ALARM(HighErrors) OR ALARM(HighLatency)',
+      })
+
+      const cf = manager.generateCompositeAlarmCF(alarm)
+
+      expect(cf.Type).toBe('AWS::CloudWatch::CompositeAlarm')
+      expect(cf.Properties.AlarmRule).toContain('ALARM(HighErrors)')
+    })
+
+    it('should generate dashboard widget', () => {
+      const metric = manager.createBusinessMetric({
+        name: 'Revenue',
+        namespace: 'MyApp/Business',
+        unit: 'Count',
+      })
+
+      const widget = manager.generateDashboardWidget(metric)
+
+      expect(widget.type).toBe('metric')
+      expect(widget.properties.metrics[0]).toContain('Revenue')
+      expect(widget.properties.title).toBe('Revenue')
+    })
+  })
+
+  it('should use global instance', () => {
+    expect(metricsManager).toBeInstanceOf(MetricsManager)
+  })
+})
+
+describe('Logs Manager', () => {
+  let manager: LogsManager
+
+  beforeEach(() => {
+    manager = new LogsManager()
+  })
+
+  describe('Log Group Creation', () => {
+    it('should create Lambda log group', () => {
+      const group = manager.createLambdaLogGroup('my-function', 14)
+
+      expect(group.id).toContain('log-group')
+      expect(group.name).toBe('/aws/lambda/my-function')
+      expect(group.retentionDays).toBe(14)
+    })
+
+    it('should use default retention for Lambda', () => {
+      const group = manager.createLambdaLogGroup('my-function')
+
+      expect(group.retentionDays).toBe(7)
+    })
+
+    it('should create ECS log group', () => {
+      const group = manager.createECSLogGroup({
+        clusterName: 'production',
+        serviceName: 'web',
+        retentionDays: 30,
+      })
+
+      expect(group.name).toBe('/ecs/production/web')
+      expect(group.retentionDays).toBe(30)
+    })
+
+    it('should create API Gateway log group', () => {
+      const group = manager.createAPIGatewayLogGroup('my-api', 'prod', 30)
+
+      expect(group.name).toBe('/aws/apigateway/my-api/prod')
+      expect(group.retentionDays).toBe(30)
+    })
+
+    it('should create application log group', () => {
+      const group = manager.createApplicationLogGroup({
+        appName: 'myapp',
+        environment: 'production',
+        retentionDays: 90,
+        kmsKeyId: 'arn:aws:kms:us-east-1:123456789012:key/12345',
+      })
+
+      expect(group.name).toBe('/application/myapp/production')
+      expect(group.kmsKeyId).toBe('arn:aws:kms:us-east-1:123456789012:key/12345')
+    })
+  })
+
+  describe('Metric Filters', () => {
+    it('should create error count filter', () => {
+      const group = manager.createLambdaLogGroup('my-function')
+      const filter = manager.createErrorCountFilter(group.id, 'MyApp')
+
+      expect(filter.id).toContain('filter')
+      expect(filter.name).toBe('ErrorCount')
+      expect(filter.filterPattern).toContain('ERROR')
+      expect(filter.metricTransformations[0].metricName).toBe('ErrorCount')
+      expect(filter.metricTransformations[0].metricNamespace).toBe('MyApp')
+    })
+
+    it('should create latency filter', () => {
+      const group = manager.createLambdaLogGroup('my-function')
+      const filter = manager.createLatencyFilter(group.id, 'MyApp')
+
+      expect(filter.name).toBe('Latency')
+      expect(filter.metricTransformations[0].metricName).toBe('ResponseTime')
+      expect(filter.metricTransformations[0].unit).toBe('Milliseconds')
+    })
+
+    it('should create custom pattern filter', () => {
+      const group = manager.createLambdaLogGroup('my-function')
+      const filter = manager.createCustomPatternFilter({
+        logGroupId: group.id,
+        name: 'CustomMetric',
+        pattern: '[time, request_id, event_type = CUSTOM, ...]',
+        metricName: 'CustomEvents',
+        namespace: 'MyApp',
+      })
+
+      expect(filter.name).toBe('CustomMetric')
+      expect(filter.filterPattern).toContain('CUSTOM')
+    })
+
+    it('should throw error for non-existent log group', () => {
+      expect(() => {
+        manager.createMetricFilter('non-existent', {
+          name: 'Test',
+          filterPattern: 'ERROR',
+          metricTransformations: [],
+        })
+      }).toThrow('Log group not found')
+    })
+  })
+
+  describe('Subscription Filters', () => {
+    it('should create Kinesis subscription', () => {
+      const group = manager.createLambdaLogGroup('my-function')
+      const subscription = manager.createKinesisSubscription({
+        logGroupId: group.id,
+        kinesisStreamArn: 'arn:aws:kinesis:us-east-1:123456789012:stream/logs',
+        roleArn: 'arn:aws:iam::123456789012:role/LogsToKinesis',
+        filterPattern: '[level = ERROR, ...]',
+      })
+
+      expect(subscription.id).toContain('subscription')
+      expect(subscription.name).toBe('KinesisSubscription')
+      expect(subscription.destinationArn).toContain('kinesis')
+      expect(subscription.filterPattern).toBe('[level = ERROR, ...]')
+      expect(subscription.distribution).toBe('Random')
+    })
+
+    it('should create Lambda subscription', () => {
+      const group = manager.createLambdaLogGroup('my-function')
+      const subscription = manager.createLambdaSubscription({
+        logGroupId: group.id,
+        lambdaFunctionArn: 'arn:aws:lambda:us-east-1:123456789012:function:process-logs',
+      })
+
+      expect(subscription.name).toBe('LambdaSubscription')
+      expect(subscription.destinationArn).toContain('lambda')
+      expect(subscription.distribution).toBe('ByLogStream')
+    })
+  })
+
+  describe('Log Insights Queries', () => {
+    it('should create error analysis query', () => {
+      const query = manager.createErrorAnalysisQuery(['/aws/lambda/my-function'])
+
+      expect(query.id).toContain('query')
+      expect(query.name).toBe('Error Analysis')
+      expect(query.query).toContain('ERROR')
+      expect(query.query).toContain('stats count()')
+    })
+
+    it('should create latency analysis query', () => {
+      const query = manager.createLatencyAnalysisQuery(['/aws/lambda/my-function'])
+
+      expect(query.name).toBe('Latency Analysis')
+      expect(query.query).toContain('@duration')
+      expect(query.query).toContain('avg(@duration)')
+    })
+
+    it('should create top errors query', () => {
+      const query = manager.createTopErrorsQuery(['/aws/lambda/my-function'])
+
+      expect(query.name).toBe('Top Errors')
+      expect(query.query).toContain('limit 20')
+    })
+  })
+
+  describe('CloudFormation Generation', () => {
+    it('should generate log group CloudFormation', () => {
+      const group = manager.createLambdaLogGroup('my-function', 30)
+      const cf = manager.generateLogGroupCF(group)
+
+      expect(cf.Type).toBe('AWS::Logs::LogGroup')
+      expect(cf.Properties.LogGroupName).toBe('/aws/lambda/my-function')
+      expect(cf.Properties.RetentionInDays).toBe(30)
+    })
+
+    it('should generate metric filter CloudFormation', () => {
+      const group = manager.createLambdaLogGroup('my-function')
+      const filter = manager.createErrorCountFilter(group.id, 'MyApp')
+      const cf = manager.generateMetricFilterCF(group, filter)
+
+      expect(cf.Type).toBe('AWS::Logs::MetricFilter')
+      expect(cf.Properties.FilterName).toBe('ErrorCount')
+      expect(cf.Properties.LogGroupName).toBe('/aws/lambda/my-function')
+    })
+
+    it('should generate subscription filter CloudFormation', () => {
+      const group = manager.createLambdaLogGroup('my-function')
+      const subscription = manager.createKinesisSubscription({
+        logGroupId: group.id,
+        kinesisStreamArn: 'arn:aws:kinesis:us-east-1:123456789012:stream/logs',
+        roleArn: 'arn:aws:iam::123456789012:role/LogsToKinesis',
+      })
+      const cf = manager.generateSubscriptionFilterCF(subscription)
+
+      expect(cf.Type).toBe('AWS::Logs::SubscriptionFilter')
+      expect(cf.Properties.DestinationArn).toContain('kinesis')
+    })
+
+    it('should generate query definition CloudFormation', () => {
+      const query = manager.createErrorAnalysisQuery(['/aws/lambda/my-function'])
+      const cf = manager.generateQueryDefinitionCF(query)
+
+      expect(cf.Type).toBe('AWS::Logs::QueryDefinition')
+      expect(cf.Properties.Name).toBe('Error Analysis')
+    })
+  })
+
+  it('should use global instance', () => {
+    expect(logsManager).toBeInstanceOf(LogsManager)
+  })
+})
+
+describe('Synthetics Manager', () => {
+  let manager: SyntheticsManager
+
+  beforeEach(() => {
+    manager = new SyntheticsManager()
+  })
+
+  describe('Runtime Versions', () => {
+    it('should have latest runtime versions', () => {
+      expect(SyntheticsManager.RuntimeVersions.NODEJS_PUPPETEER_4_0).toBe('syn-nodejs-puppeteer-4.0')
+      expect(SyntheticsManager.RuntimeVersions.PYTHON_SELENIUM_1_3).toBe('syn-python-selenium-1.3')
+    })
+  })
+
+  describe('Canary Creation', () => {
+    it('should create heartbeat canary', () => {
+      const canary = manager.createHeartbeatCanary({
+        name: 'website-heartbeat',
+        url: 'https://example.com',
+        interval: 5,
+        s3Bucket: 'canary-artifacts',
+      })
+
+      expect(canary.id).toContain('canary')
+      expect(canary.name).toBe('website-heartbeat')
+      expect(canary.description).toContain('https://example.com')
+      expect(canary.schedule.expression).toBe('rate(5 minutes)')
+      expect(canary.code.type).toBe('script')
+      expect(canary.code.script).toContain('heartbeat')
+      expect(canary.artifactS3Location).toContain('s3://canary-artifacts')
+    })
+
+    it('should create API monitoring canary', () => {
+      const canary = manager.createAPICanary({
+        name: 'api-monitor',
+        baseUrl: 'https://api.example.com',
+        endpoints: [
+          { path: '/health', method: 'GET', expectedStatus: 200 },
+          { path: '/users', method: 'GET', expectedStatus: 200 },
+        ],
+        interval: 10,
+        s3Bucket: 'canary-artifacts',
+      })
+
+      expect(canary.name).toBe('api-monitor')
+      expect(canary.code.script).toContain('/health')
+      expect(canary.code.script).toContain('/users')
+      expect(canary.runConfig?.timeoutInSeconds).toBe(120)
+    })
+
+    it('should create visual regression canary', () => {
+      const canary = manager.createVisualRegressionCanary({
+        name: 'homepage-visual',
+        url: 'https://example.com',
+        screenshotName: 'homepage',
+        interval: 60,
+        s3Bucket: 'canary-artifacts',
+      })
+
+      expect(canary.name).toBe('homepage-visual')
+      expect(canary.code.script).toContain('screenshot')
+      expect(canary.code.script).toContain('homepage.png')
+      expect(canary.runConfig?.memoryInMB).toBe(1024)
+    })
+
+    it('should create workflow canary', () => {
+      const canary = manager.createWorkflowCanary({
+        name: 'user-login-flow',
+        description: 'Test user login workflow',
+        steps: [
+          {
+            description: 'Navigate to login page',
+            url: 'https://example.com/login',
+          },
+          {
+            description: 'Submit login form',
+            url: 'https://example.com/login',
+            actions: [
+              { type: 'type', selector: '#username', value: 'testuser' },
+              { type: 'type', selector: '#password', value: 'testpass' },
+              { type: 'click', selector: '#submit' },
+            ],
+          },
+        ],
+        interval: 15,
+        s3Bucket: 'canary-artifacts',
+      })
+
+      expect(canary.name).toBe('user-login-flow')
+      expect(canary.code.script).toContain('Navigate to login page')
+      expect(canary.code.script).toContain('page.type')
+      expect(canary.code.script).toContain('page.click')
+      expect(canary.runConfig?.timeoutInSeconds).toBe(180)
+    })
+  })
+
+  describe('Alarm Creation', () => {
+    it('should create canary alarm', () => {
+      const canary = manager.createHeartbeatCanary({
+        name: 'test',
+        url: 'https://example.com',
+        interval: 5,
+        s3Bucket: 'bucket',
+      })
+
+      const alarm = manager.createAlarm(canary.id, {
+        name: 'CanaryFailure',
+        metric: 'SuccessPercent',
+        threshold: 90,
+        evaluationPeriods: 2,
+        snsTopicArn: 'arn:aws:sns:us-east-1:123456789012:alerts',
+      })
+
+      expect(alarm.id).toContain('alarm')
+      expect(alarm.name).toBe('CanaryFailure')
+      expect(alarm.metric).toBe('SuccessPercent')
+      expect(canary.alarms).toHaveLength(1)
+    })
+
+    it('should throw error for non-existent canary', () => {
+      expect(() => {
+        manager.createAlarm('non-existent', {
+          name: 'Test',
+          metric: 'SuccessPercent',
+          threshold: 90,
+          evaluationPeriods: 2,
+        })
+      }).toThrow('Canary not found')
+    })
+  })
+
+  describe('CloudFormation Generation', () => {
+    it('should generate canary CloudFormation with script', () => {
+      const canary = manager.createHeartbeatCanary({
+        name: 'test',
+        url: 'https://example.com',
+        interval: 5,
+        s3Bucket: 'bucket',
+      })
+
+      const cf = manager.generateCanaryCF(canary)
+
+      expect(cf.Type).toBe('AWS::Synthetics::Canary')
+      expect(cf.Properties.Name).toBe('test')
+      expect(cf.Properties.Code.Handler).toBe('index.handler')
+      expect(cf.Properties.Code.Script).toBeDefined()
+      expect(cf.Properties.Schedule.Expression).toBe('rate(5 minutes)')
+      expect(cf.Properties.StartCanaryAfterCreation).toBe(true)
+    })
+
+    it('should generate canary execution role CloudFormation', () => {
+      const cf = manager.generateCanaryRoleCF()
+
+      expect(cf.Type).toBe('AWS::IAM::Role')
+      expect(cf.Properties.ManagedPolicyArns).toContain(
+        'arn:aws:iam::aws:policy/CloudWatchSyntheticsFullAccess'
+      )
+      expect(cf.Properties.Policies[0].PolicyName).toBe('CanaryS3Policy')
+    })
+  })
+
+  describe('Data Management', () => {
+    it('should retrieve canary by id', () => {
+      const canary = manager.createHeartbeatCanary({
+        name: 'test',
+        url: 'https://example.com',
+        interval: 5,
+        s3Bucket: 'bucket',
+      })
+
+      const retrieved = manager.getCanary(canary.id)
+
+      expect(retrieved).toEqual(canary)
+    })
+
+    it('should list all canaries', () => {
+      manager.createHeartbeatCanary({
+        name: 'test1',
+        url: 'https://example.com',
+        interval: 5,
+        s3Bucket: 'bucket',
+      })
+      manager.createAPICanary({
+        name: 'test2',
+        baseUrl: 'https://api.example.com',
+        endpoints: [{ path: '/health', method: 'GET', expectedStatus: 200 }],
+        interval: 10,
+        s3Bucket: 'bucket',
+      })
+
+      const canaries = manager.listCanaries()
+
+      expect(canaries).toHaveLength(2)
+    })
+
+    it('should clear all data', () => {
+      manager.createHeartbeatCanary({
+        name: 'test',
+        url: 'https://example.com',
+        interval: 5,
+        s3Bucket: 'bucket',
+      })
+
+      manager.clear()
+
+      expect(manager.listCanaries()).toHaveLength(0)
+    })
+  })
+
+  it('should use global instance', () => {
+    expect(syntheticsManager).toBeInstanceOf(SyntheticsManager)
+  })
+})