create-fluxstack 1.0.4 → 1.0.6

package/my-final-test/core/config/__tests__/config-merger.test.ts

@@ -1,657 +0,0 @@
-/**
- * Tests for ConfigMerger and EnvironmentConfigApplier
- * Tests configuration merging with precedence and environment-specific configs
- */
-
-import { describe, test, expect } from 'vitest'
-import { 
-  ConfigMerger, 
-  EnvironmentConfigApplier 
-} from '../env'
-import type { FluxStackConfig } from '../schema'
-
-describe('ConfigMerger', () => {
-  let merger: ConfigMerger
-
-  beforeEach(() => {
-    merger = new ConfigMerger()
-  })
-
-  describe('merge', () => {
-    test('merges simple configurations', () => {
-      const config1 = {
-        config: {
-          app: { name: 'TestApp', version: '1.0.0' },
-          server: { port: 3000 }
-        } as Partial<FluxStackConfig>,
-        source: 'default'
-      }
-
-      const config2 = {
-        config: {
-          app: { version: '2.0.0' },
-          server: { host: 'localhost' }
-        } as Partial<FluxStackConfig>,
-        source: 'file'
-      }
-
-      const result = merger.merge(config1, config2)
-
-      expect(result.app?.name).toBe('TestApp') // from config1
-      expect(result.app?.version).toBe('2.0.0') // overridden by config2
-      expect(result.server?.port).toBe(3000) // from config1
-      expect(result.server?.host).toBe('localhost') // from config2
-    })
-
-    test('respects precedence order', () => {
-      const defaultConfig = {
-        config: {
-          server: { port: 3000, host: 'localhost' }
-        } as Partial<FluxStackConfig>,
-        source: 'default'
-      }
-
-      const fileConfig = {
-        config: {
-          server: { port: 4000 }
-        } as Partial<FluxStackConfig>,
-        source: 'file'
-      }
-
-      const envConfig = {
-        config: {
-          server: { port: 5000 }
-        } as Partial<FluxStackConfig>,
-        source: 'environment'
-      }
-
-      const overrideConfig = {
-        config: {
-          server: { port: 6000 }
-        } as Partial<FluxStackConfig>,
-        source: 'override'
-      }
-
-      const result = merger.merge(defaultConfig, fileConfig, envConfig, overrideConfig)
-
-      // Override should win (highest precedence)
-      expect(result.server?.port).toBe(6000)
-      expect(result.server?.host).toBe('localhost') // from default (not overridden)
-    })
-
-    test('handles nested object merging', () => {
-      const config1 = {
-        config: {
-          server: {
-            cors: {
-              origins: ['http://localhost:3000'],
-              methods: ['GET', 'POST'],
-              credentials: true
-            }
-          }
-        } as Partial<FluxStackConfig>,
-        source: 'default'
-      }
-
-      const config2 = {
-        config: {
-          server: {
-            cors: {
-              origins: ['http://localhost:5173'],
-              headers: ['Content-Type']
-            }
-          }
-        } as Partial<FluxStackConfig>,
-        source: 'environment'
-      }
-
-      const result = merger.merge(config1, config2)
-
-      expect(result.server?.cors?.origins).toEqual(['http://localhost:5173']) // overridden
-      expect(result.server?.cors?.methods).toEqual(['GET', 'POST']) // preserved
-      expect(result.server?.cors?.headers).toEqual(['Content-Type']) // added
-      expect(result.server?.cors?.credentials).toBe(true) // preserved
-    })
-
-    test('handles array replacement (not merging)', () => {
-      const config1 = {
-        config: {
-          plugins: {
-            enabled: ['plugin1', 'plugin2', 'plugin3']
-          }
-        } as Partial<FluxStackConfig>,
-        source: 'default'
-      }
-
-      const config2 = {
-        config: {
-          plugins: {
-            enabled: ['plugin4', 'plugin5']
-          }
-        } as Partial<FluxStackConfig>,
-        source: 'environment'
-      }
-
-      const result = merger.merge(config1, config2)
-
-      // Arrays should be replaced, not merged
-      expect(result.plugins?.enabled).toEqual(['plugin4', 'plugin5'])
-    })
-
-    test('handles null and undefined values', () => {
-      const config1 = {
-        config: {
-          database: {
-            host: 'localhost',
-            port: 5432,
-            ssl: true
-          }
-        } as Partial<FluxStackConfig>,
-        source: 'default'
-      }
-
-      const config2 = {
-        config: {
-          database: {
-            port: null,
-            ssl: undefined
-          }
-        } as any,
-        source: 'environment'
-      }
-
-      const result = merger.merge(config1, config2)
-
-      expect(result.database?.host).toBe('localhost') // preserved
-      expect(result.database?.port).toBe(null) // overridden with null
-      expect(result.database?.ssl).toBe(true) // undefined doesn't override
-    })
-
-    test('merges complex nested structures', () => {
-      const config1 = {
-        config: {
-          monitoring: {
-            enabled: true,
-            metrics: {
-              enabled: true,
-              collectInterval: 5000,
-              httpMetrics: true,
-              systemMetrics: false
-            },
-            profiling: {
-              enabled: false,
-              sampleRate: 0.1
-            }
-          }
-        } as Partial<FluxStackConfig>,
-        source: 'default'
-      }
-
-      const config2 = {
-        config: {
-          monitoring: {
-            metrics: {
-              collectInterval: 10000,
-              systemMetrics: true,
-              customMetrics: true
-            },
-            profiling: {
-              enabled: true,
-              memoryProfiling: true
-            }
-          }
-        } as Partial<FluxStackConfig>,
-        source: 'environment'
-      }
-
-      const result = merger.merge(config1, config2)
-
-      expect(result.monitoring?.enabled).toBe(true) // from config1
-      expect(result.monitoring?.metrics?.enabled).toBe(true) // from config1
-      expect(result.monitoring?.metrics?.collectInterval).toBe(10000) // from config2
-      expect(result.monitoring?.metrics?.httpMetrics).toBe(true) // from config1
-      expect(result.monitoring?.metrics?.systemMetrics).toBe(true) // from config2
-      expect((result.monitoring?.metrics as any)?.customMetrics).toBe(true) // from config2
-      expect(result.monitoring?.profiling?.enabled).toBe(true) // from config2
-      expect(result.monitoring?.profiling?.sampleRate).toBe(0.1) // from config1
-      expect((result.monitoring?.profiling as any)?.memoryProfiling).toBe(true) // from config2
-    })
-
-    test('handles empty configurations', () => {
-      const emptyConfig = {
-        config: {} as Partial<FluxStackConfig>,
-        source: 'default'
-      }
-
-      const config2 = {
-        config: {
-          app: { name: 'TestApp' }
-        } as Partial<FluxStackConfig>,
-        source: 'file'
-      }
-
-      const result = merger.merge(emptyConfig, config2)
-
-      expect(result.app?.name).toBe('TestApp')
-    })
-
-    test('precedence works with same source priority', () => {
-      const config1 = {
-        config: {
-          server: { port: 3000 }
-        } as Partial<FluxStackConfig>,
-        source: 'file'
-      }
-
-      const config2 = {
-        config: {
-          server: { port: 4000 }
-        } as Partial<FluxStackConfig>,
-        source: 'file'
-      }
-
-      const result = merger.merge(config1, config2)
-
-      // Later config should win when precedence is equal
-      expect(result.server?.port).toBe(4000)
-    })
-  })
-})
-
-describe('EnvironmentConfigApplier', () => {
-  let applier: EnvironmentConfigApplier
-
-  beforeEach(() => {
-    applier = new EnvironmentConfigApplier()
-  })
-
-  describe('applyEnvironmentConfig', () => {
-    test('applies environment-specific configuration', () => {
-      const baseConfig: FluxStackConfig = {
-        app: { name: 'TestApp', version: '1.0.0' },
-        server: {
-          port: 3000,
-          host: 'localhost',
-          apiPrefix: '/api',
-          cors: {
-            origins: ['*'],
-            methods: ['GET', 'POST'],
-            headers: ['Content-Type'],
-            credentials: false,
-            maxAge: 86400
-          },
-          middleware: []
-        },
-        client: {
-          port: 5173,
-          proxy: { target: 'http://localhost:3000' },
-          build: {
-            target: 'es2020',
-            outDir: 'dist/client',
-            sourceMaps: true,
-            minify: false
-          }
-        },
-        build: {
-          target: 'bun',
-          outDir: 'dist',
-          clean: true,
-          optimization: {
-            minify: false,
-            compress: false,
-            treeshake: false,
-            splitChunks: false,
-            bundleAnalyzer: false
-          },
-          sourceMaps: true
-        },
-        logging: {
-          level: 'info',
-          format: 'pretty',
-          transports: [
-            { type: 'console', level: 'info', format: 'pretty' }
-          ]
-        },
-        monitoring: {
-          enabled: false,
-          metrics: {
-            enabled: false,
-            collectInterval: 60000,
-            httpMetrics: true,
-            systemMetrics: true,
-            customMetrics: false
-          },
-          profiling: {
-            enabled: false,
-            sampleRate: 0.1,
-            memoryProfiling: false,
-            cpuProfiling: false
-          },
-          exporters: []
-        },
-        plugins: {
-          enabled: [],
-          disabled: [],
-          config: {}
-        },
-        environments: {
-          production: {
-            logging: {
-              level: 'warn',
-              format: 'json'
-            },
-            build: {
-              optimization: {
-                minify: true,
-                compress: true,
-                treeshake: true
-              },
-              sourceMaps: false
-            },
-            monitoring: {
-              enabled: true,
-              metrics: {
-                enabled: true,
-                collectInterval: 30000
-              }
-            }
-          },
-          development: {
-            logging: {
-              level: 'debug'
-            },
-            monitoring: {
-              enabled: false
-            }
-          }
-        }
-      } as FluxStackConfig
-
-      const result = applier.applyEnvironmentConfig(baseConfig, 'production')
-
-      expect(result.logging?.level).toBe('warn') // overridden
-      expect(result.logging?.format).toBe('json') // overridden
-      expect(result.build?.optimization?.minify).toBe(true) // overridden
-      expect(result.build?.optimization?.compress).toBe(true) // overridden
-      expect(result.build?.optimization?.treeshake).toBe(true) // overridden
-      expect(result.build?.sourceMaps).toBe(false) // overridden
-      expect(result.monitoring?.enabled).toBe(true) // overridden
-      expect(result.monitoring?.metrics?.enabled).toBe(true) // overridden
-      expect(result.monitoring?.metrics?.collectInterval).toBe(30000) // overridden
-
-      // Original values should be preserved where not overridden
-      expect(result.app?.name).toBe('TestApp')
-      expect(result.server?.port).toBe(3000)
-    })
-
-    test('applies development environment configuration', () => {
-      const baseConfig: FluxStackConfig = {
-        app: { name: 'TestApp', version: '1.0.0' },
-        server: {
-          port: 3000,
-          host: 'localhost',
-          apiPrefix: '/api',
-          cors: {
-            origins: ['*'],
-            methods: ['GET', 'POST'],
-            headers: ['Content-Type'],
-            credentials: false,
-            maxAge: 86400
-          },
-          middleware: []
-        },
-        client: {
-          port: 5173,
-          proxy: { target: 'http://localhost:3000' },
-          build: {
-            target: 'es2020',
-            outDir: 'dist/client',
-            sourceMaps: true,
-            minify: false
-          }
-        },
-        build: {
-          target: 'bun',
-          outDir: 'dist',
-          clean: true,
-          optimization: {
-            minify: false,
-            compress: false,
-            treeshake: false,
-            splitChunks: false,
-            bundleAnalyzer: false
-          },
-          sourceMaps: true
-        },
-        logging: {
-          level: 'info',
-          format: 'pretty',
-          transports: [
-            { type: 'console', level: 'info', format: 'pretty' }
-          ]
-        },
-        monitoring: {
-          enabled: true,
-          metrics: {
-            enabled: false,
-            collectInterval: 60000,
-            httpMetrics: true,
-            systemMetrics: true,
-            customMetrics: false
-          },
-          profiling: {
-            enabled: false,
-            sampleRate: 0.1,
-            memoryProfiling: false,
-            cpuProfiling: false
-          },
-          exporters: []
-        },
-        plugins: {
-          enabled: [],
-          disabled: [],
-          config: {}
-        },
-        environments: {
-          development: {
-            logging: {
-              level: 'debug'
-            },
-            monitoring: {
-              enabled: false
-            }
-          }
-        }
-      } as FluxStackConfig
-
-      const result = applier.applyEnvironmentConfig(baseConfig, 'development')
-
-      expect(result.logging?.level).toBe('debug') // overridden
-      expect(result.monitoring?.enabled).toBe(false) // overridden
-      expect(result.app?.name).toBe('TestApp') // preserved
-    })
-
-    test('returns original config when environment not found', () => {
-      const baseConfig: FluxStackConfig = {
-        app: { name: 'TestApp', version: '1.0.0' },
-        server: {
-          port: 3000,
-          host: 'localhost',
-          apiPrefix: '/api',
-          cors: {
-            origins: ['*'],
-            methods: ['GET', 'POST'],
-            headers: ['Content-Type'],
-            credentials: false,
-            maxAge: 86400
-          },
-          middleware: []
-        },
-        client: {
-          port: 5173,
-          proxy: { target: 'http://localhost:3000' },
-          build: {
-            target: 'es2020',
-            outDir: 'dist/client',
-            sourceMaps: true,
-            minify: false
-          }
-        },
-        build: {
-          target: 'bun',
-          outDir: 'dist',
-          clean: true,
-          optimization: {
-            minify: false,
-            compress: false,
-            treeshake: false,
-            splitChunks: false,
-            bundleAnalyzer: false
-          },
-          sourceMaps: true
-        },
-        logging: {
-          level: 'info',
-          format: 'pretty',
-          transports: [
-            { type: 'console', level: 'info', format: 'pretty' }
-          ]
-        },
-        monitoring: {
-          enabled: false,
-          metrics: {
-            enabled: false,
-            collectInterval: 60000,
-            httpMetrics: true,
-            systemMetrics: true,
-            customMetrics: false
-          },
-          profiling: {
-            enabled: false,
-            sampleRate: 0.1,
-            memoryProfiling: false,
-            cpuProfiling: false
-          },
-          exporters: []
-        },
-        plugins: {
-          enabled: [],
-          disabled: [],
-          config: {}
-        }
-      } as FluxStackConfig
-
-      const result = applier.applyEnvironmentConfig(baseConfig, 'nonexistent')
-
-      expect(result).toBe(baseConfig) // Should return the same object
-    })
-  })
-
-  describe('getAvailableEnvironments', () => {
-    test('returns available environments', () => {
-      const config = {
-        environments: {
-          development: {},
-          production: {},
-          staging: {},
-          test: {}
-        }
-      } as FluxStackConfig
-
-      const environments = applier.getAvailableEnvironments(config)
-
-      expect(environments).toEqual(['development', 'production', 'staging', 'test'])
-    })
-
-    test('returns empty array when no environments defined', () => {
-      const config = {} as FluxStackConfig
-
-      const environments = applier.getAvailableEnvironments(config)
-
-      expect(environments).toEqual([])
-    })
-  })
-
-  describe('validateEnvironmentConfig', () => {
-    test('validates production environment requirements', () => {
-      const config = {
-        server: { port: 3000 },
-        logging: { level: 'info' as const },
-        monitoring: { enabled: false },
-        environments: {
-          production: {
-            logging: { level: 'debug' as const }, // Invalid for production
-            monitoring: { enabled: false } // Invalid for production
-          }
-        }
-      } as FluxStackConfig
-
-      const result = applier.validateEnvironmentConfig(config, 'production')
-
-      expect(result.valid).toBe(false)
-      expect(result.errors).toContain('Production environment should not use debug logging')
-      expect(result.errors).toContain('Production environment should enable monitoring')
-    })
-
-    test('validates port conflicts', () => {
-      const config = {
-        server: { port: 3000 },
-        environments: {
-          staging: {
-            server: { port: 3000 } // Same as base - conflict
-          }
-        }
-      } as FluxStackConfig
-
-      const result = applier.validateEnvironmentConfig(config, 'staging')
-
-      expect(result.valid).toBe(false)
-      expect(result.errors).toContain('Environment staging uses same port as base configuration')
-    })
-
-    test('allows port conflicts in development', () => {
-      const config = {
-        server: { port: 3000 },
-        environments: {
-          development: {
-            server: { port: 3000 } // Same as base - allowed in development
-          }
-        }
-      } as FluxStackConfig
-
-      const result = applier.validateEnvironmentConfig(config, 'development')
-
-      expect(result.valid).toBe(true)
-      expect(result.errors).toHaveLength(0)
-    })
-
-    test('passes validation for valid production config', () => {
-      const config = {
-        server: { port: 3000 },
-        logging: { level: 'info' as const },
-        monitoring: { enabled: false },
-        environments: {
-          production: {
-            server: { port: 8080 }, // Different port
-            logging: { level: 'warn' as const }, // Valid for production
-            monitoring: { enabled: true } // Valid for production
-          }
-        }
-      } as FluxStackConfig
-
-      const result = applier.validateEnvironmentConfig(config, 'production')
-
-      expect(result.valid).toBe(true)
-      expect(result.errors).toHaveLength(0)
-    })
-
-    test('returns valid for non-existent environment', () => {
-      const config = {} as FluxStackConfig
-
-      const result = applier.validateEnvironmentConfig(config, 'nonexistent')
-
-      expect(result.valid).toBe(true)
-      expect(result.errors).toHaveLength(0)
-    })
-  })
-})