@stacksjs/ts-cloud-core 0.1.3 → 0.1.7

package/test/monitoring.test.ts

@@ -1,634 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import { Monitoring } from '../src/modules/monitoring'
-import { TemplateBuilder } from '../src/template-builder'
-import type { EnvironmentType } from '@stacksjs/ts-cloud-types'
-
-const slug = 'test-app'
-const environment: EnvironmentType = 'development'
-
-describe('monitoring Module - Alarms', () => {
-  test('should create a basic CloudWatch alarm', () => {
-    const { alarm, logicalId } = Monitoring.createAlarm({
-      slug,
-      environment,
-      metricName: 'CPUUtilization',
-      namespace: 'AWS/EC2',
-      threshold: 80,
-      comparisonOperator: 'GreaterThanThreshold',
-    })
-
-    expect(alarm.Type).toBe('AWS::CloudWatch::Alarm')
-    expect(alarm.Properties?.AlarmName).toContain('test-app')
-    expect(alarm.Properties?.MetricName).toBe('CPUUtilization')
-    expect(alarm.Properties?.Namespace).toBe('AWS/EC2')
-    expect(alarm.Properties?.Threshold).toBe(80)
-    expect(alarm.Properties?.ComparisonOperator).toBe('GreaterThanThreshold')
-    expect(alarm.Properties?.Statistic).toBe('Average')
-    expect(alarm.Properties?.Period).toBe(300)
-    expect(alarm.Properties?.EvaluationPeriods).toBe(1)
-    expect(logicalId).toBeTruthy()
-  })
-
-  test('should create an alarm with custom configuration', () => {
-    const { alarm } = Monitoring.createAlarm({
-      slug,
-      environment,
-      alarmName: 'custom-alarm',
-      metricName: 'RequestCount',
-      namespace: 'AWS/ApplicationELB',
-      statistic: 'Sum',
-      period: 60,
-      evaluationPeriods: 3,
-      threshold: 1000,
-      comparisonOperator: 'GreaterThanOrEqualToThreshold',
-      treatMissingData: 'breaching',
-      datapointsToAlarm: 2,
-    })
-
-    expect(alarm.Properties?.AlarmName).toBe('custom-alarm')
-    expect(alarm.Properties?.Statistic).toBe('Sum')
-    expect(alarm.Properties?.Period).toBe(60)
-    expect(alarm.Properties?.EvaluationPeriods).toBe(3)
-    expect(alarm.Properties?.TreatMissingData).toBe('breaching')
-    expect(alarm.Properties?.DatapointsToAlarm).toBe(2)
-  })
-
-  test('should create an alarm with SNS actions', () => {
-    const snsTopicArn = 'arn:aws:sns:us-east-1:123456789012:my-topic'
-
-    const { alarm } = Monitoring.createAlarm({
-      slug,
-      environment,
-      metricName: 'Errors',
-      namespace: 'AWS/Lambda',
-      threshold: 5,
-      comparisonOperator: 'GreaterThanThreshold',
-      alarmActions: [snsTopicArn],
-      okActions: [snsTopicArn],
-    })
-
-    expect(alarm.Properties?.AlarmActions).toEqual([snsTopicArn])
-    expect(alarm.Properties?.OKActions).toEqual([snsTopicArn])
-  })
-
-  test('should create an alarm with dimensions', () => {
-    const { alarm } = Monitoring.createAlarm({
-      slug,
-      environment,
-      metricName: 'CPUUtilization',
-      namespace: 'AWS/EC2',
-      threshold: 80,
-      comparisonOperator: 'GreaterThanThreshold',
-      dimensions: {
-        InstanceId: 'i-1234567890abcdef0',
-        AutoScalingGroupName: 'my-asg',
-      },
-    })
-
-    expect(alarm.Properties?.Dimensions).toHaveLength(2)
-    expect(alarm.Properties?.Dimensions?.[0]).toEqual({
-      Name: 'InstanceId',
-      Value: 'i-1234567890abcdef0',
-    })
-    expect(alarm.Properties?.Dimensions?.[1]).toEqual({
-      Name: 'AutoScalingGroupName',
-      Value: 'my-asg',
-    })
-  })
-
-  test('should create a composite alarm', () => {
-    const { alarm, logicalId } = Monitoring.createCompositeAlarm({
-      slug,
-      environment,
-      alarmRule: 'ALARM(Alarm1) OR ALARM(Alarm2)',
-      alarmActions: ['arn:aws:sns:us-east-1:123456789012:my-topic'],
-    })
-
-    expect(alarm.Type).toBe('AWS::CloudWatch::CompositeAlarm')
-    expect(alarm.Properties?.AlarmName).toContain('test-app')
-    expect(alarm.Properties?.AlarmRule).toBe('ALARM(Alarm1) OR ALARM(Alarm2)')
-    expect(alarm.Properties?.AlarmActions).toHaveLength(1)
-    expect(logicalId).toBeTruthy()
-  })
-})
-
-describe('monitoring Module - Common Alarm Types', () => {
-  test('should create high CPU alarm', () => {
-    const alarmConfig = Monitoring.AlarmTypes.highCpu(
-      slug,
-      environment,
-      'i-1234567890abcdef0',
-      90,
-    )
-
-    expect(alarmConfig.metricName).toBe('CPUUtilization')
-    expect(alarmConfig.namespace).toBe('AWS/EC2')
-    expect(alarmConfig.threshold).toBe(90)
-    expect(alarmConfig.dimensions?.InstanceId).toBe('i-1234567890abcdef0')
-  })
-
-  test('should create Lambda errors alarm', () => {
-    const alarmConfig = Monitoring.AlarmTypes.lambdaErrors(
-      slug,
-      environment,
-      'my-function',
-      10,
-      'arn:aws:sns:us-east-1:123456789012:alerts',
-    )
-
-    expect(alarmConfig.metricName).toBe('Errors')
-    expect(alarmConfig.namespace).toBe('AWS/Lambda')
-    expect(alarmConfig.threshold).toBe(10)
-    expect(alarmConfig.dimensions?.FunctionName).toBe('my-function')
-    expect(alarmConfig.alarmActions).toContain('arn:aws:sns:us-east-1:123456789012:alerts')
-  })
-
-  test('should create API Gateway 5xx errors alarm', () => {
-    const alarmConfig = Monitoring.AlarmTypes.apiGateway5xxErrors(
-      slug,
-      environment,
-      'my-api',
-      5,
-    )
-
-    expect(alarmConfig.metricName).toBe('5XXError')
-    expect(alarmConfig.namespace).toBe('AWS/ApiGateway')
-    expect(alarmConfig.threshold).toBe(5)
-  })
-
-  test('should create DynamoDB throttles alarm', () => {
-    const alarmConfig = Monitoring.AlarmTypes.dynamoDBThrottles(
-      slug,
-      environment,
-      'my-table',
-      3,
-    )
-
-    expect(alarmConfig.metricName).toBe('UserErrors')
-    expect(alarmConfig.namespace).toBe('AWS/DynamoDB')
-    expect(alarmConfig.threshold).toBe(3)
-    expect(alarmConfig.dimensions?.TableName).toBe('my-table')
-  })
-
-  test('should create RDS CPU alarm', () => {
-    const alarmConfig = Monitoring.AlarmTypes.rdsCpu(
-      slug,
-      environment,
-      'my-db-instance',
-      75,
-    )
-
-    expect(alarmConfig.metricName).toBe('CPUUtilization')
-    expect(alarmConfig.namespace).toBe('AWS/RDS')
-    expect(alarmConfig.threshold).toBe(75)
-    expect(alarmConfig.dimensions?.DBInstanceIdentifier).toBe('my-db-instance')
-  })
-
-  test('should create SQS queue depth alarm', () => {
-    const alarmConfig = Monitoring.AlarmTypes.sqsQueueDepth(
-      slug,
-      environment,
-      'my-queue',
-      200,
-    )
-
-    expect(alarmConfig.metricName).toBe('ApproximateNumberOfMessagesVisible')
-    expect(alarmConfig.namespace).toBe('AWS/SQS')
-    expect(alarmConfig.threshold).toBe(200)
-    expect(alarmConfig.dimensions?.QueueName).toBe('my-queue')
-  })
-})
-
-describe('monitoring Module - Dashboards', () => {
-  test('should create a CloudWatch dashboard', () => {
-    const widgets = [
-      Monitoring.DashboardWidgets.metric(
-        0,
-        0,
-        12,
-        6,
-        [
-          ['AWS/EC2', 'CPUUtilization', { InstanceId: 'i-1234567890abcdef0' }],
-        ],
-        'CPU Utilization',
-      ),
-      Monitoring.DashboardWidgets.text(
-        12,
-        0,
-        12,
-        6,
-        '# Dashboard Title\nThis is a test dashboard',
-      ),
-    ]
-
-    const { dashboard, logicalId } = Monitoring.createDashboard({
-      slug,
-      environment,
-      widgets,
-    })
-
-    expect(dashboard.Type).toBe('AWS::CloudWatch::Dashboard')
-    expect(dashboard.Properties?.DashboardName).toContain('test-app')
-    expect(dashboard.Properties?.DashboardBody).toBeTruthy()
-    expect(logicalId).toBeTruthy()
-
-    const dashboardBody = JSON.parse(dashboard.Properties!.DashboardBody)
-    expect(dashboardBody.widgets).toHaveLength(2)
-    expect(dashboardBody.widgets[0].type).toBe('metric')
-    expect(dashboardBody.widgets[1].type).toBe('text')
-  })
-
-  test('should create metric widget', () => {
-    const widget = Monitoring.DashboardWidgets.metric(
-      0,
-      0,
-      12,
-      6,
-      [
-        ['AWS/Lambda', 'Invocations', { FunctionName: 'my-function' }],
-        ['AWS/Lambda', 'Errors', { FunctionName: 'my-function' }],
-      ],
-      'Lambda Metrics',
-    )
-
-    expect(widget.type).toBe('metric')
-    expect(widget.x).toBe(0)
-    expect(widget.y).toBe(0)
-    expect(widget.width).toBe(12)
-    expect(widget.height).toBe(6)
-    expect(widget.properties.title).toBe('Lambda Metrics')
-    expect(widget.properties.metrics).toHaveLength(2)
-  })
-
-  test('should create text widget', () => {
-    const widget = Monitoring.DashboardWidgets.text(
-      0,
-      0,
-      24,
-      2,
-      '# Production Dashboard',
-    )
-
-    expect(widget.type).toBe('text')
-    expect(widget.properties.markdown).toBe('# Production Dashboard')
-  })
-
-  test('should create log widget', () => {
-    const widget = Monitoring.DashboardWidgets.log(
-      0,
-      0,
-      24,
-      6,
-      ['/aws/lambda/my-function', '/aws/lambda/another-function'],
-      'Recent Logs',
-    )
-
-    expect(widget.type).toBe('log')
-    expect(widget.properties.title).toBe('Recent Logs')
-    expect(widget.properties.query).toContain('/aws/lambda/my-function')
-  })
-})
-
-describe('monitoring Module - Log Groups', () => {
-  test('should create a CloudWatch log group', () => {
-    const { logGroup, logicalId } = Monitoring.createLogGroup({
-      slug,
-      environment,
-    })
-
-    expect(logGroup.Type).toBe('AWS::Logs::LogGroup')
-    expect(logGroup.Properties?.LogGroupName).toContain('test-app')
-    expect(logicalId).toBeTruthy()
-  })
-
-  test('should create a log group with retention', () => {
-    const { logGroup } = Monitoring.createLogGroup({
-      slug,
-      environment,
-      retentionInDays: Monitoring.RetentionPeriods.ONE_WEEK,
-    })
-
-    expect(logGroup.Properties?.RetentionInDays).toBe(7)
-  })
-
-  test('should create a log group with KMS encryption', () => {
-    const kmsKeyId = 'arn:aws:kms:us-east-1:123456789012:key/12345678-1234-1234-1234-123456789012'
-
-    const { logGroup } = Monitoring.createLogGroup({
-      slug,
-      environment,
-      kmsKeyId,
-    })
-
-    expect(logGroup.Properties?.KmsKeyId).toBe(kmsKeyId)
-  })
-
-  test('should create a log group with custom name', () => {
-    const { logGroup } = Monitoring.createLogGroup({
-      slug,
-      environment,
-      logGroupName: '/aws/lambda/custom-function',
-      retentionInDays: Monitoring.RetentionPeriods.ONE_MONTH,
-    })
-
-    expect(logGroup.Properties?.LogGroupName).toBe('/aws/lambda/custom-function')
-    expect(logGroup.Properties?.RetentionInDays).toBe(30)
-  })
-})
-
-describe('monitoring Module - Log Streams', () => {
-  test('should create a CloudWatch log stream', () => {
-    const { logGroup, logicalId: logGroupId } = Monitoring.createLogGroup({
-      slug,
-      environment,
-    })
-
-    const { logStream, logicalId } = Monitoring.createLogStream(logGroupId, {
-      slug,
-      environment,
-    })
-
-    expect(logStream.Type).toBe('AWS::Logs::LogStream')
-    expect(logStream.Properties?.LogStreamName).toContain('test-app')
-    expect(logicalId).toBeTruthy()
-  })
-
-  test('should create a log stream with custom name', () => {
-    const { logicalId: logGroupId } = Monitoring.createLogGroup({
-      slug,
-      environment,
-    })
-
-    const { logStream } = Monitoring.createLogStream(logGroupId, {
-      slug,
-      environment,
-      logStreamName: 'custom-stream',
-    })
-
-    expect(logStream.Properties?.LogStreamName).toBe('custom-stream')
-  })
-})
-
-describe('monitoring Module - Metric Filters', () => {
-  test('should create a metric filter', () => {
-    const { logicalId: logGroupId } = Monitoring.createLogGroup({
-      slug,
-      environment,
-    })
-
-    const { metricFilter, logicalId } = Monitoring.createMetricFilter(logGroupId, {
-      slug,
-      environment,
-      filterPattern: Monitoring.FilterPatterns.errors,
-      metricTransformations: [
-        {
-          metricName: 'ErrorCount',
-          metricNamespace: 'MyApp',
-          metricValue: '1',
-        },
-      ],
-    })
-
-    expect(metricFilter.Type).toBe('AWS::Logs::MetricFilter')
-    expect(metricFilter.Properties?.FilterPattern).toBe(Monitoring.FilterPatterns.errors)
-    expect(metricFilter.Properties?.MetricTransformations).toHaveLength(1)
-    expect(metricFilter.Properties?.MetricTransformations?.[0].MetricName).toBe('ErrorCount')
-    expect(logicalId).toBeTruthy()
-  })
-
-  test('should create a metric filter with custom pattern', () => {
-    const { logicalId: logGroupId } = Monitoring.createLogGroup({
-      slug,
-      environment,
-    })
-
-    const { metricFilter } = Monitoring.createMetricFilter(logGroupId, {
-      slug,
-      environment,
-      filterPattern: Monitoring.FilterPatterns.http5xx,
-      metricTransformations: [
-        {
-          metricName: '5xxErrors',
-          metricNamespace: 'API',
-          metricValue: '1',
-          defaultValue: 0,
-        },
-      ],
-    })
-
-    expect(metricFilter.Properties?.FilterPattern).toBe(Monitoring.FilterPatterns.http5xx)
-    expect(metricFilter.Properties?.MetricTransformations?.[0].DefaultValue).toBe(0)
-  })
-
-  test('should create a metric filter with multiple transformations', () => {
-    const { logicalId: logGroupId } = Monitoring.createLogGroup({
-      slug,
-      environment,
-    })
-
-    const { metricFilter } = Monitoring.createMetricFilter(logGroupId, {
-      slug,
-      environment,
-      filterPattern: Monitoring.FilterPatterns.all,
-      metricTransformations: [
-        {
-          metricName: 'TotalRequests',
-          metricNamespace: 'API',
-          metricValue: '1',
-        },
-        {
-          metricName: 'ResponseTime',
-          metricNamespace: 'API',
-          metricValue: '$.duration',
-          unit: 'Milliseconds',
-        },
-      ],
-    })
-
-    expect(metricFilter.Properties?.MetricTransformations).toHaveLength(2)
-  })
-})
-
-describe('monitoring Module - Filter Patterns', () => {
-  test('should have predefined filter patterns', () => {
-    expect(Monitoring.FilterPatterns.errors).toBe('[time, request_id, event_type = ERROR*, ...]')
-    expect(Monitoring.FilterPatterns.all).toBe('')
-    expect(Monitoring.FilterPatterns.http4xx).toBe('[..., status_code = 4*, ...]')
-    expect(Monitoring.FilterPatterns.http5xx).toBe('[..., status_code = 5*, ...]')
-  })
-
-  test('should create JSON field filter pattern', () => {
-    const pattern = Monitoring.FilterPatterns.jsonField('level', 'ERROR')
-    expect(pattern).toBe('{ $.level = "ERROR" }')
-  })
-
-  test('should create HTTP status filter pattern', () => {
-    const pattern = Monitoring.FilterPatterns.httpStatus(404)
-    expect(pattern).toBe('[..., status_code = 404, ...]')
-  })
-})
-
-describe('monitoring Module - Retention Periods', () => {
-  test('should have common retention periods', () => {
-    expect(Monitoring.RetentionPeriods.ONE_DAY).toBe(1)
-    expect(Monitoring.RetentionPeriods.ONE_WEEK).toBe(7)
-    expect(Monitoring.RetentionPeriods.ONE_MONTH).toBe(30)
-    expect(Monitoring.RetentionPeriods.ONE_YEAR).toBe(365)
-    expect(Monitoring.RetentionPeriods.NEVER_EXPIRE).toBeUndefined()
-  })
-})
-
-describe('monitoring Module - Integration with TemplateBuilder', () => {
-  test('should add alarm to template', () => {
-    const builder = new TemplateBuilder()
-
-    const { alarm, logicalId } = Monitoring.createAlarm({
-      slug,
-      environment,
-      metricName: 'CPUUtilization',
-      namespace: 'AWS/EC2',
-      threshold: 80,
-      comparisonOperator: 'GreaterThanThreshold',
-    })
-
-    builder.addResource(logicalId, alarm)
-
-    const template = builder.build()
-
-    expect(template.Resources[logicalId]).toBeDefined()
-    expect(template.Resources[logicalId].Type).toBe('AWS::CloudWatch::Alarm')
-  })
-
-  test('should add dashboard to template', () => {
-    const builder = new TemplateBuilder()
-
-    const { dashboard, logicalId } = Monitoring.createDashboard({
-      slug,
-      environment,
-      widgets: [
-        Monitoring.DashboardWidgets.metric(
-          0,
-          0,
-          12,
-          6,
-          [['AWS/EC2', 'CPUUtilization']],
-        ),
-      ],
-    })
-
-    builder.addResource(logicalId, dashboard)
-
-    const template = builder.build()
-
-    expect(template.Resources[logicalId]).toBeDefined()
-    expect(template.Resources[logicalId].Type).toBe('AWS::CloudWatch::Dashboard')
-  })
-
-  test('should add log group and metric filter to template', () => {
-    const builder = new TemplateBuilder()
-
-    const { logGroup, logicalId: logGroupId } = Monitoring.createLogGroup({
-      slug,
-      environment,
-      retentionInDays: Monitoring.RetentionPeriods.ONE_WEEK,
-    })
-
-    const { metricFilter, logicalId: filterId } = Monitoring.createMetricFilter(logGroupId, {
-      slug,
-      environment,
-      filterPattern: Monitoring.FilterPatterns.errors,
-      metricTransformations: [
-        {
-          metricName: 'ErrorCount',
-          metricNamespace: 'MyApp',
-          metricValue: '1',
-        },
-      ],
-    })
-
-    builder.addResource(logGroupId, logGroup)
-    builder.addResource(filterId, metricFilter)
-
-    const template = builder.build()
-
-    expect(template.Resources[logGroupId]).toBeDefined()
-    expect(template.Resources[logGroupId].Type).toBe('AWS::Logs::LogGroup')
-    expect(template.Resources[filterId]).toBeDefined()
-    expect(template.Resources[filterId].Type).toBe('AWS::Logs::MetricFilter')
-  })
-
-  test('should create complete monitoring stack', () => {
-    const builder = new TemplateBuilder()
-
-    // Create log group
-    const { logGroup, logicalId: logGroupId } = Monitoring.createLogGroup({
-      slug,
-      environment,
-      logGroupName: '/aws/lambda/my-function',
-      retentionInDays: Monitoring.RetentionPeriods.ONE_MONTH,
-    })
-
-    // Create metric filter
-    const { metricFilter, logicalId: filterId } = Monitoring.createMetricFilter(logGroupId, {
-      slug,
-      environment,
-      filterPattern: Monitoring.FilterPatterns.errors,
-      metricTransformations: [
-        {
-          metricName: 'ErrorCount',
-          metricNamespace: 'MyApp/Lambda',
-          metricValue: '1',
-        },
-      ],
-    })
-
-    // Create alarm from metric filter
-    const { alarm, logicalId: alarmId } = Monitoring.createAlarm({
-      slug,
-      environment,
-      alarmName: 'lambda-errors',
-      metricName: 'ErrorCount',
-      namespace: 'MyApp/Lambda',
-      threshold: 5,
-      comparisonOperator: 'GreaterThanThreshold',
-      evaluationPeriods: 2,
-    })
-
-    // Create dashboard
-    const { dashboard, logicalId: dashboardId } = Monitoring.createDashboard({
-      slug,
-      environment,
-      widgets: [
-        Monitoring.DashboardWidgets.metric(
-          0,
-          0,
-          12,
-          6,
-          [['MyApp/Lambda', 'ErrorCount']],
-          'Lambda Errors',
-        ),
-        Monitoring.DashboardWidgets.log(
-          0,
-          6,
-          12,
-          6,
-          ['/aws/lambda/my-function'],
-          'Recent Errors',
-        ),
-      ],
-    })
-
-    builder.addResource(logGroupId, logGroup)
-    builder.addResource(filterId, metricFilter)
-    builder.addResource(alarmId, alarm)
-    builder.addResource(dashboardId, dashboard)
-
-    const template = builder.build()
-
-    expect(Object.keys(template.Resources)).toHaveLength(4)
-    expect(template.Resources[logGroupId].Type).toBe('AWS::Logs::LogGroup')
-    expect(template.Resources[filterId].Type).toBe('AWS::Logs::MetricFilter')
-    expect(template.Resources[alarmId].Type).toBe('AWS::CloudWatch::Alarm')
-    expect(template.Resources[dashboardId].Type).toBe('AWS::CloudWatch::Dashboard')
-  })
-})