create-fluxstack 1.0.12 → 1.0.14

package/core/config/__tests__/validator.test.ts

@@ -1,318 +0,0 @@
-/**
- * Tests for Configuration Validator
- */
-
-import { describe, it, expect } from 'vitest'
-import { 
-  validateConfig, 
-  validateConfigStrict,
-  createEnvironmentValidator,
-  validatePartialConfig,
-  getConfigSuggestions
-} from '../validator'
-import { defaultFluxStackConfig } from '../schema'
-import type { FluxStackConfig } from '../schema'
-
-describe('Configuration Validator', () => {
-  describe('validateConfig', () => {
-    it('should validate default configuration successfully', () => {
-      const result = validateConfig(defaultFluxStackConfig)
-      
-      expect(result.valid).toBe(true)
-      expect(result.errors).toHaveLength(0)
-    })
-
-    it('should detect missing required properties', () => {
-      const invalidConfig = {
-        app: { name: 'test' }, // missing version
-        server: defaultFluxStackConfig.server,
-        client: defaultFluxStackConfig.client,
-        build: defaultFluxStackConfig.build,
-        plugins: defaultFluxStackConfig.plugins,
-        logging: defaultFluxStackConfig.logging,
-        monitoring: defaultFluxStackConfig.monitoring
-      } as FluxStackConfig
-
-      const result = validateConfig(invalidConfig)
-      
-      expect(result.valid).toBe(false)
-      expect(result.errors.some(e => e.includes('version'))).toBe(true)
-    })
-
-    it('should detect invalid port numbers', () => {
-      const invalidConfig = {
-        ...defaultFluxStackConfig,
-        server: {
-          ...defaultFluxStackConfig.server,
-          port: 70000 // Invalid port
-        }
-      }
-
-      const result = validateConfig(invalidConfig)
-      
-      expect(result.valid).toBe(false)
-      expect(result.errors.some(e => e.includes('port'))).toBe(true)
-    })
-
-    it('should detect port conflicts', () => {
-      const conflictConfig = {
-        ...defaultFluxStackConfig,
-        server: { ...defaultFluxStackConfig.server, port: 3000 },
-        client: { ...defaultFluxStackConfig.client, port: 3000 }
-      }
-
-      const result = validateConfig(conflictConfig)
-      
-      expect(result.valid).toBe(false)
-      expect(result.errors.some(e => e.includes('different'))).toBe(true)
-    })
-
-    it('should warn about security issues', () => {
-      const insecureConfig = {
-        ...defaultFluxStackConfig,
-        server: {
-          ...defaultFluxStackConfig.server,
-          cors: {
-            ...defaultFluxStackConfig.server.cors,
-            origins: ['*'],
-            credentials: true
-          }
-        }
-      }
-
-      // Mock production environment
-      const originalEnv = process.env.NODE_ENV
-      process.env.NODE_ENV = 'production'
-
-      const result = validateConfig(insecureConfig)
-      
-      expect(result.warnings.some(w => w.includes('wildcard'))).toBe(true)
-
-      // Restore environment
-      process.env.NODE_ENV = originalEnv
-    })
-
-    it('should validate enum values', () => {
-      const invalidConfig = {
-        ...defaultFluxStackConfig,
-        logging: {
-          ...defaultFluxStackConfig.logging,
-          level: 'invalid' as any
-        }
-      }
-
-      const result = validateConfig(invalidConfig)
-      
-      expect(result.valid).toBe(false)
-      expect(result.errors.some(e => e.includes('one of'))).toBe(true)
-    })
-
-    it('should validate array constraints', () => {
-      const invalidConfig = {
-        ...defaultFluxStackConfig,
-        server: {
-          ...defaultFluxStackConfig.server,
-          cors: {
-            ...defaultFluxStackConfig.server.cors,
-            origins: [] // Empty array
-          }
-        }
-      }
-
-      const result = validateConfig(invalidConfig)
-      
-      expect(result.valid).toBe(false)
-      expect(result.errors.some(e => e.includes('at least'))).toBe(true)
-    })
-  })
-
-  describe('validateConfigStrict', () => {
-    it('should not throw for valid configuration', () => {
-      expect(() => {
-        validateConfigStrict(defaultFluxStackConfig)
-      }).not.toThrow()
-    })
-
-    it('should throw for invalid configuration', () => {
-      const invalidConfig = {
-        ...defaultFluxStackConfig,
-        app: { name: '' } // Invalid empty name
-      } as FluxStackConfig
-
-      expect(() => {
-        validateConfigStrict(invalidConfig)
-      }).toThrow()
-    })
-  })
-
-  describe('createEnvironmentValidator', () => {
-    it('should create production validator with additional checks', () => {
-      const prodValidator = createEnvironmentValidator('production')
-      
-      const devConfig = {
-        ...defaultFluxStackConfig,
-        logging: { ...defaultFluxStackConfig.logging, level: 'debug' as const }
-      }
-
-      const result = prodValidator(devConfig)
-      
-      expect(result.warnings.some(w => w.includes('Debug logging'))).toBe(true)
-    })
-
-    it('should create development validator with build warnings', () => {
-      const devValidator = createEnvironmentValidator('development')
-      
-      const prodConfig = {
-        ...defaultFluxStackConfig,
-        build: {
-          ...defaultFluxStackConfig.build,
-          optimization: {
-            ...defaultFluxStackConfig.build.optimization,
-            minify: true
-          }
-        }
-      }
-
-      const result = devValidator(prodConfig)
-      
-      expect(result.warnings.some(w => w.includes('Minification enabled'))).toBe(true)
-    })
-  })
-
-  describe('validatePartialConfig', () => {
-    it('should validate partial configuration against base', () => {
-      const partialConfig = {
-        server: {
-          port: 4000,
-          host: 'localhost',
-          apiPrefix: '/api',
-          cors: {
-            origins: ['*'],
-            methods: ['GET', 'POST'],
-            headers: ['Content-Type'],
-            credentials: false,
-            maxAge: 86400
-          },
-          middleware: []
-        }
-      }
-
-      const result = validatePartialConfig(partialConfig, defaultFluxStackConfig)
-      
-      expect(result.valid).toBe(true)
-    })
-
-    it('should detect conflicts in partial configuration', () => {
-      const partialConfig = {
-        server: {
-          port: 70000, // Invalid port
-          host: 'localhost',
-          apiPrefix: '/api',
-          cors: {
-            origins: ['*'],
-            methods: ['GET', 'POST'],
-            headers: ['Content-Type'],
-            credentials: false,
-            maxAge: 86400
-          },
-          middleware: []
-        }
-      }
-
-      const result = validatePartialConfig(partialConfig, defaultFluxStackConfig)
-      
-      expect(result.valid).toBe(false)
-    })
-  })
-
-  describe('getConfigSuggestions', () => {
-    it('should provide suggestions for improvement', () => {
-      const basicConfig = {
-        ...defaultFluxStackConfig,
-        monitoring: { ...defaultFluxStackConfig.monitoring, enabled: false }
-      }
-
-      const suggestions = getConfigSuggestions(basicConfig)
-      
-      expect(suggestions.some(s => s.includes('monitoring'))).toBe(true)
-    })
-
-    it('should suggest database configuration', () => {
-      const configWithoutDb = {
-        ...defaultFluxStackConfig,
-        database: undefined
-      }
-
-      const suggestions = getConfigSuggestions(configWithoutDb)
-      
-      expect(suggestions.some(s => s.includes('database'))).toBe(true)
-    })
-
-    it('should suggest plugin enablement', () => {
-      const configWithoutPlugins = {
-        ...defaultFluxStackConfig,
-        plugins: { ...defaultFluxStackConfig.plugins, enabled: [] }
-      }
-
-      const suggestions = getConfigSuggestions(configWithoutPlugins)
-      
-      expect(suggestions.some(s => s.includes('plugins'))).toBe(true)
-    })
-  })
-
-  describe('Business Logic Validation', () => {
-    it('should validate plugin conflicts', () => {
-      const conflictConfig = {
-        ...defaultFluxStackConfig,
-        plugins: {
-          enabled: ['logger', 'cors'],
-          disabled: ['logger'], // Conflict: logger is both enabled and disabled
-          config: {}
-        }
-      }
-
-      const result = validateConfig(conflictConfig)
-      
-      expect(result.warnings.some(w => w.includes('both enabled and disabled'))).toBe(true)
-    })
-
-    it('should validate authentication security', () => {
-      const weakAuthConfig = {
-        ...defaultFluxStackConfig,
-        auth: {
-          secret: 'short', // Too short
-          expiresIn: '24h'
-        }
-      }
-
-      const result = validateConfig(weakAuthConfig)
-      
-      expect(result.warnings.some(w => w.includes('too short'))).toBe(true)
-    })
-
-    it('should validate build optimization settings', () => {
-      // Mock production environment
-      const originalEnv = process.env.NODE_ENV
-      process.env.NODE_ENV = 'production'
-
-      const unoptimizedConfig = {
-        ...defaultFluxStackConfig,
-        build: {
-          ...defaultFluxStackConfig.build,
-          optimization: {
-            ...defaultFluxStackConfig.build.optimization,
-            minify: false,
-            treeshake: false
-          }
-        }
-      }
-
-      const result = validateConfig(unoptimizedConfig)
-      
-      expect(result.warnings.some(w => w.includes('minification') || w.includes('tree-shaking'))).toBe(true)
-
-      // Restore environment
-      process.env.NODE_ENV = originalEnv
-    })
-  })
-})

package/core/framework/__tests__/server.test.ts

@@ -1,233 +0,0 @@
-/**
- * Tests for FluxStack Framework Server
- */
-
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
-import { FluxStackFramework } from '../server'
-import type { Plugin } from '../../plugins/types'
-
-// Mock dependencies
-vi.mock('../../config', () => ({
-  getConfigSync: vi.fn(() => ({
-    server: {
-      port: 3000,
-      apiPrefix: '/api',
-      cors: {
-        origins: ['*'],
-        methods: ['GET', 'POST'],
-        headers: ['Content-Type'],
-        credentials: false
-      }
-    },
-    app: {
-      name: 'test-app',
-      version: '1.0.0'
-    }
-  })),
-  getEnvironmentInfo: vi.fn(() => ({
-    isDevelopment: true,
-    isProduction: false,
-    isTest: true,
-    name: 'test'
-  }))
-}))
-
-vi.mock('../../utils/logger', () => ({
-  logger: {
-    framework: vi.fn(),
-    warn: vi.fn(),
-    error: vi.fn(),
-    child: vi.fn(() => ({
-      framework: vi.fn(),
-      warn: vi.fn(),
-      error: vi.fn()
-    }))
-  }
-}))
-
-vi.mock('../../utils/errors/handlers', () => ({
-  createErrorHandler: vi.fn(() => vi.fn())
-}))
-
-vi.mock('elysia', () => ({
-  Elysia: vi.fn(() => ({
-    onRequest: vi.fn().mockReturnThis(),
-    onAfterHandle: vi.fn().mockReturnThis(),
-    onError: vi.fn().mockReturnThis(),
-    options: vi.fn().mockReturnThis(),
-    use: vi.fn().mockReturnThis(),
-    listen: vi.fn((_port, callback) => {
-      if (callback) callback()
-    })
-  }))
-}))
-
-describe('FluxStackFramework', () => {
-  let framework: FluxStackFramework
-
-  beforeEach(() => {
-    framework = new FluxStackFramework()
-  })
-
-  afterEach(() => {
-    vi.clearAllMocks()
-  })
-
-  describe('Constructor', () => {
-    it('should initialize framework with default config', () => {
-      expect(framework).toBeInstanceOf(FluxStackFramework)
-      expect(framework.getContext()).toBeDefined()
-      expect(framework.getApp()).toBeDefined()
-      expect(framework.getPluginRegistry()).toBeDefined()
-    })
-
-    it('should initialize framework with custom config', () => {
-      const customConfig = {
-        server: {
-          port: 4000,
-          host: 'localhost',
-          apiPrefix: '/custom-api',
-          cors: {
-            origins: ['*'],
-            methods: ['GET', 'POST'],
-            headers: ['Content-Type'],
-            credentials: false,
-            maxAge: 86400
-          },
-          middleware: []
-        }
-      }
-      
-      const customFramework = new FluxStackFramework(customConfig)
-      const context = customFramework.getContext()
-      
-      expect(context.config.server.port).toBe(4000)
-      expect(context.config.server.apiPrefix).toBe('/custom-api')
-    })
-
-    it('should set up context correctly', () => {
-      const context = framework.getContext()
-      
-      expect(context.isDevelopment).toBe(true)
-      expect(context.isProduction).toBe(false)
-      expect(context.isTest).toBe(true)
-      expect(context.environment).toBe('test')
-    })
-  })
-
-  describe('Plugin Management', () => {
-    it('should register plugins successfully', () => {
-      const mockPlugin: Plugin = {
-        name: 'test-plugin',
-        setup: vi.fn()
-      }
-
-      expect(() => framework.use(mockPlugin)).not.toThrow()
-      expect(framework.getPluginRegistry().get('test-plugin')).toBe(mockPlugin)
-    })
-
-    it('should throw error when registering duplicate plugin', () => {
-      const mockPlugin: Plugin = {
-        name: 'duplicate-plugin',
-        setup: vi.fn()
-      }
-
-      framework.use(mockPlugin)
-      expect(() => framework.use(mockPlugin)).toThrow()
-    })
-
-    it('should validate plugin dependencies', async () => {
-      const pluginA: Plugin = {
-        name: 'plugin-a',
-        setup: vi.fn()
-      }
-
-      const pluginB: Plugin = {
-        name: 'plugin-b',
-        dependencies: ['plugin-a'],
-        setup: vi.fn()
-      }
-
-      framework.use(pluginA)
-      framework.use(pluginB)
-
-      await expect(framework.start()).resolves.not.toThrow()
-    })
-
-    it('should throw error for missing dependencies', async () => {
-      const pluginWithMissingDep: Plugin = {
-        name: 'plugin-with-missing-dep',
-        dependencies: ['non-existent-plugin'],
-        setup: vi.fn()
-      }
-
-      framework.use(pluginWithMissingDep)
-      await expect(framework.start()).rejects.toThrow()
-    })
-  })
-
-  describe('Lifecycle Management', () => {
-    it('should start framework successfully', async () => {
-      const mockPlugin: Plugin = {
-        name: 'lifecycle-plugin',
-        setup: vi.fn(),
-        onServerStart: vi.fn()
-      }
-
-      framework.use(mockPlugin)
-      await framework.start()
-
-      expect(mockPlugin.setup).toHaveBeenCalled()
-      expect(mockPlugin.onServerStart).toHaveBeenCalled()
-    })
-
-    it('should stop framework successfully', async () => {
-      const mockPlugin: Plugin = {
-        name: 'lifecycle-plugin',
-        setup: vi.fn(),
-        onServerStart: vi.fn(),
-        onServerStop: vi.fn()
-      }
-
-      framework.use(mockPlugin)
-      await framework.start()
-      await framework.stop()
-
-      expect(mockPlugin.onServerStop).toHaveBeenCalled()
-    })
-
-    it('should not start framework twice', async () => {
-      await framework.start()
-      await framework.start() // Should not throw or cause issues
-      
-      // Should log warning about already started
-      const { logger } = await import('../../utils/logger')
-      expect(logger.warn).toHaveBeenCalled()
-    })
-
-    it('should handle plugin setup errors', async () => {
-      const errorPlugin: Plugin = {
-        name: 'error-plugin',
-        setup: vi.fn().mockRejectedValue(new Error('Setup failed'))
-      }
-
-      framework.use(errorPlugin)
-      await expect(framework.start()).rejects.toThrow('Setup failed')
-    })
-  })
-
-  describe('Routes', () => {
-    it('should add routes to the app', () => {
-      const mockRouteModule = { get: vi.fn() }
-      
-      expect(() => framework.routes(mockRouteModule)).not.toThrow()
-    })
-  })
-
-  describe('Error Handling', () => {
-    it('should set up error handling', async () => {
-      const { createErrorHandler } = await import('../../utils/errors/handlers')
-      expect(createErrorHandler).toHaveBeenCalled()
-    })
-  })
-})