@stacksjs/ts-cloud-core 0.1.2 → 0.1.6

package/src/errors/index.test.ts

@@ -1,434 +0,0 @@
-/**
- * Error Handling Tests
- */
-
-import { describe, expect, it, beforeEach, afterEach } from 'bun:test'
-import {
-  CloudError,
-  ConfigurationError,
-  CredentialError,
-  DeploymentError,
-  ValidationError,
-  AWSAPIError,
-  ErrorCodes,
-  getErrorDetails,
-  createError,
-  DebugLogger,
-  validateConfiguration,
-  detectMisconfigurations,
-} from './index'
-
-describe('CloudError', () => {
-  it('should create a CloudError with message, code, and solution', () => {
-    const error = new CloudError(
-      'Test error message',
-      'TEST_ERROR',
-      'This is the solution',
-      { detail1: 'value1' },
-    )
-
-    expect(error.message).toBe('Test error message')
-    expect(error.code).toBe('TEST_ERROR')
-    expect(error.solution).toBe('This is the solution')
-    expect(error.details).toEqual({ detail1: 'value1' })
-    expect(error.name).toBe('CloudError')
-  })
-
-  it('should format toString() with solution and details', () => {
-    const error = new CloudError(
-      'Test error',
-      'TEST_ERROR',
-      'Fix it like this',
-      { key: 'value' },
-    )
-
-    const str = error.toString()
-    expect(str).toContain('CloudError [TEST_ERROR]: Test error')
-    expect(str).toContain('💡 Solution: Fix it like this')
-    expect(str).toContain('Details:')
-    expect(str).toContain('key: "value"')
-  })
-
-  it('should work without solution and details', () => {
-    const error = new CloudError('Simple error', 'SIMPLE_ERROR')
-
-    const str = error.toString()
-    expect(str).toBe('CloudError [SIMPLE_ERROR]: Simple error')
-  })
-})
-
-describe('Specialized Error Classes', () => {
-  it('should create ConfigurationError', () => {
-    const error = new ConfigurationError('Config is wrong', 'Fix your config')
-
-    expect(error.name).toBe('ConfigurationError')
-    expect(error.code).toBe('CONFIG_ERROR')
-    expect(error.message).toBe('Config is wrong')
-    expect(error.solution).toBe('Fix your config')
-  })
-
-  it('should create CredentialError', () => {
-    const error = new CredentialError('Bad credentials', 'Update your keys')
-
-    expect(error.name).toBe('CredentialError')
-    expect(error.code).toBe('CREDENTIAL_ERROR')
-    expect(error.message).toBe('Bad credentials')
-  })
-
-  it('should create DeploymentError', () => {
-    const error = new DeploymentError('Deploy failed', 'Check CloudFormation')
-
-    expect(error.name).toBe('DeploymentError')
-    expect(error.code).toBe('DEPLOYMENT_ERROR')
-  })
-
-  it('should create ValidationError', () => {
-    const error = new ValidationError('Invalid input', 'Check your data')
-
-    expect(error.name).toBe('ValidationError')
-    expect(error.code).toBe('VALIDATION_ERROR')
-  })
-
-  it('should create AWSAPIError with status code', () => {
-    const error = new AWSAPIError('API failed', 403, 'Check permissions')
-
-    expect(error.name).toBe('AWSAPIError')
-    expect(error.code).toBe('AWS_API_ERROR')
-    expect(error.statusCode).toBe(403)
-  })
-})
-
-describe('ErrorCodes', () => {
-  it('should have predefined error codes', () => {
-    expect(ErrorCodes.NO_CREDENTIALS).toBeDefined()
-    expect(ErrorCodes.INVALID_CREDENTIALS).toBeDefined()
-    expect(ErrorCodes.MISSING_CONFIG).toBeDefined()
-    expect(ErrorCodes.INVALID_REGION).toBeDefined()
-  })
-
-  it('should provide message and solution for each error code', () => {
-    const error = ErrorCodes.NO_CREDENTIALS
-
-    expect(error.message).toBe('AWS credentials not found')
-    expect(error.solution).toContain('Configure AWS credentials')
-    expect(error.solution).toContain('AWS_ACCESS_KEY_ID')
-  })
-})
-
-describe('getErrorDetails', () => {
-  it('should return error details by code', () => {
-    const details = getErrorDetails('INVALID_CREDENTIALS')
-
-    expect(details.message).toBe('AWS credentials are invalid')
-    expect(details.solution).toContain('AWS_ACCESS_KEY_ID')
-  })
-})
-
-describe('createError', () => {
-  it('should create error from error code', () => {
-    const error = createError('MISSING_CONFIG', { path: '/path/to/config' })
-
-    expect(error.message).toBe('Configuration file not found')
-    expect(error.code).toBe('MISSING_CONFIG')
-    expect(error.solution).toContain('cloud.config.ts')
-    expect(error.details).toEqual({ path: '/path/to/config' })
-  })
-
-  it('should work without additional details', () => {
-    const error = createError('INVALID_REGION')
-
-    expect(error.message).toBe('AWS region is invalid')
-    expect(error.code).toBe('INVALID_REGION')
-    expect(error.details).toBeUndefined()
-  })
-})
-
-describe('DebugLogger', () => {
-  let consoleLog: typeof console.log
-  let consoleWarn: typeof console.warn
-  let consoleError: typeof console.error
-  let logs: string[] = []
-
-  beforeEach(() => {
-    logs = []
-    consoleLog = console.log
-    consoleWarn = console.warn
-    consoleError = console.error
-
-    console.log = (...args: any[]) => logs.push(args.join(' '))
-    console.warn = (...args: any[]) => logs.push(args.join(' '))
-    console.error = (...args: any[]) => logs.push(args.join(' '))
-
-    DebugLogger.setVerbose(false)
-    DebugLogger.setDebug(false)
-  })
-
-  afterEach(() => {
-    console.log = consoleLog
-    console.warn = consoleWarn
-    console.error = consoleError
-  })
-
-  it('should log verbose messages when verbose mode is enabled', () => {
-    DebugLogger.setVerbose(true)
-    DebugLogger.verbose('Verbose message')
-
-    expect(logs).toContain('[VERBOSE] Verbose message')
-  })
-
-  it('should not log verbose messages when verbose mode is disabled', () => {
-    DebugLogger.setVerbose(false)
-    DebugLogger.verbose('Verbose message')
-
-    expect(logs).not.toContain('[VERBOSE] Verbose message')
-  })
-
-  it('should log debug messages when debug mode is enabled', () => {
-    DebugLogger.setDebug(true)
-    DebugLogger.debug('Debug message')
-
-    expect(logs).toContain('[DEBUG] Debug message')
-  })
-
-  it('should not log debug messages when debug mode is disabled', () => {
-    DebugLogger.setDebug(false)
-    DebugLogger.debug('Debug message')
-
-    expect(logs).not.toContain('[DEBUG] Debug message')
-  })
-
-  it('should always log info messages', () => {
-    DebugLogger.info('Info message')
-
-    expect(logs.some(log => log.includes('Info message'))).toBe(true)
-  })
-
-  it('should always log warning messages', () => {
-    DebugLogger.warn('Warning message')
-
-    expect(logs.some(log => log.includes('Warning message'))).toBe(true)
-  })
-
-  it('should always log error messages', () => {
-    DebugLogger.error('Error message')
-
-    expect(logs.some(log => log.includes('Error message'))).toBe(true)
-  })
-
-  it('should log CloudError with formatted output', () => {
-    const error = new CloudError('Test error', 'TEST', 'Test solution')
-    DebugLogger.error('Something failed', error)
-
-    expect(logs.some(log => log.includes('Something failed'))).toBe(true)
-    expect(logs.some(log => log.includes('Test error'))).toBe(true)
-  })
-
-  it('should log stack trace in debug mode', () => {
-    DebugLogger.setDebug(true)
-    const error = new Error('Test error')
-    DebugLogger.error('Failed', error)
-
-    expect(logs.some(log => log.includes('Stack trace'))).toBe(true)
-  })
-
-  it('should log success messages', () => {
-    DebugLogger.success('Success message')
-
-    expect(logs.some(log => log.includes('Success message'))).toBe(true)
-  })
-})
-
-describe('validateConfiguration', () => {
-  it('should throw error if config is null', () => {
-    expect(() => validateConfiguration(null)).toThrow()
-  })
-
-  it('should throw error if config is undefined', () => {
-    expect(() => validateConfiguration(undefined)).toThrow()
-  })
-
-  it('should throw error if project is missing', () => {
-    expect(() => validateConfiguration({})).toThrow(ConfigurationError)
-    expect(() => validateConfiguration({})).toThrow('Missing required field: project')
-  })
-
-  it('should throw error if project.name is missing', () => {
-    expect(() => validateConfiguration({ project: {} })).toThrow(ConfigurationError)
-    expect(() => validateConfiguration({ project: {} })).toThrow('project.name')
-  })
-
-  it('should throw error if project.slug is missing', () => {
-    expect(() => validateConfiguration({ project: { name: 'Test' } })).toThrow(ConfigurationError)
-    expect(() => validateConfiguration({ project: { name: 'Test' } })).toThrow('project.slug')
-  })
-
-  it('should throw error if slug format is invalid', () => {
-    expect(() =>
-      validateConfiguration({
-        project: { name: 'Test', slug: 'Invalid_Slug' },
-      }),
-    ).toThrow(ValidationError)
-  })
-
-  it('should accept valid slug format', () => {
-    expect(() =>
-      validateConfiguration({
-        project: { name: 'Test', slug: 'valid-slug-123' },
-      }),
-    ).not.toThrow()
-  })
-
-  it('should throw error for invalid region', () => {
-    expect(() =>
-      validateConfiguration({
-        project: { name: 'Test', slug: 'test', region: 'invalid-region' },
-      }),
-    ).toThrow('AWS region is invalid')
-  })
-
-  it('should accept valid regions', () => {
-    const validRegions = [
-      'us-east-1',
-      'us-west-2',
-      'eu-west-1',
-      'eu-central-1',
-      'ap-southeast-1',
-    ]
-
-    for (const region of validRegions) {
-      expect(() =>
-        validateConfiguration({
-          project: { name: 'Test', slug: 'test', region },
-        }),
-      ).not.toThrow()
-    }
-  })
-
-  it('should accept config without region', () => {
-    expect(() =>
-      validateConfiguration({
-        project: { name: 'Test', slug: 'test' },
-      }),
-    ).not.toThrow()
-  })
-})
-
-describe('detectMisconfigurations', () => {
-  it('should return empty array for minimal config', () => {
-    const warnings = detectMisconfigurations({
-      project: { name: 'Test', slug: 'test' },
-    })
-
-    expect(Array.isArray(warnings)).toBe(true)
-  })
-
-  it('should warn about production database without Multi-AZ', () => {
-    const warnings = detectMisconfigurations({
-      project: { name: 'Test', slug: 'test' },
-      environments: {
-        production: {},
-      },
-      infrastructure: {
-        database: {
-          postgres: {
-            instanceClass: 'db.t3.micro',
-          },
-        },
-      },
-    })
-
-    expect(warnings).toContain('Production database should use Multi-AZ for high availability')
-  })
-
-  it('should not warn if Multi-AZ is enabled', () => {
-    const warnings = detectMisconfigurations({
-      project: { name: 'Test', slug: 'test' },
-      environments: {
-        production: {},
-      },
-      infrastructure: {
-        database: {
-          postgres: {
-            instanceClass: 'db.t3.micro',
-            multiAZ: true,
-          },
-        },
-      },
-    })
-
-    expect(warnings).not.toContain(
-      'Production database should use Multi-AZ for high availability',
-    )
-  })
-
-  it('should warn about unencrypted storage', () => {
-    const warnings = detectMisconfigurations({
-      project: { name: 'Test', slug: 'test' },
-      infrastructure: {
-        storage: {
-          uploads: {
-            encryption: false,
-          },
-        },
-      },
-    })
-
-    expect(warnings.some(w => w.includes('not encrypted'))).toBe(true)
-  })
-
-  it('should warn about public S3 buckets', () => {
-    const warnings = detectMisconfigurations({
-      project: { name: 'Test', slug: 'test' },
-      infrastructure: {
-        storage: {
-          assets: {
-            public: true,
-          },
-        },
-      },
-    })
-
-    expect(warnings.some(w => w.includes('publicly accessible'))).toBe(true)
-  })
-
-  it('should warn about low backup retention', () => {
-    const warnings = detectMisconfigurations({
-      project: { name: 'Test', slug: 'test' },
-      infrastructure: {
-        database: {
-          postgres: {
-            backupRetentionDays: 3,
-          },
-        },
-      },
-    })
-
-    expect(warnings.some(w => w.includes('backup retention'))).toBe(true)
-  })
-
-  it('should warn about missing monitoring', () => {
-    const warnings = detectMisconfigurations({
-      project: { name: 'Test', slug: 'test' },
-      infrastructure: {
-        compute: {
-          server: {},
-        },
-      },
-    })
-
-    expect(warnings.some(w => w.includes('No monitoring configured'))).toBe(true)
-  })
-
-  it('should not warn if monitoring is configured', () => {
-    const warnings = detectMisconfigurations({
-      project: { name: 'Test', slug: 'test' },
-      infrastructure: {
-        monitoring: {
-          alarms: [],
-        },
-      },
-    })
-
-    expect(warnings).not.toContain('No monitoring configured')
-  })
-})