suthep 1.0.0

package/src/utils/__tests__/config-loader.test.ts

@@ -0,0 +1,419 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest'
+import fs from 'fs-extra'
+import yaml from 'js-yaml'
+import { loadConfig, saveConfig } from '../config-loader'
+import type { DeployConfig } from '../../types/config'
+
+// Mock fs-extra
+vi.mock('fs-extra', () => ({
+  default: {
+    readFile: vi.fn(),
+    writeFile: vi.fn(),
+    pathExists: vi.fn(),
+  },
+}))
+
+// Mock js-yaml
+vi.mock('js-yaml', () => ({
+  default: {
+    load: vi.fn(),
+    dump: vi.fn(),
+  },
+}))
+
+describe('config-loader', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  describe('loadConfig', () => {
+    it('should load and parse a valid config file', async () => {
+      const mockConfig: DeployConfig = {
+        project: {
+          name: 'test-project',
+          version: '1.0.0',
+        },
+        services: [
+          {
+            name: 'api',
+            port: 3000,
+            domains: ['api.example.com'],
+          },
+        ],
+        nginx: {
+          configPath: '/etc/nginx/sites-available',
+          reloadCommand: 'sudo nginx -t && sudo systemctl reload nginx',
+        },
+        certbot: {
+          email: 'admin@example.com',
+          staging: false,
+        },
+        deployment: {
+          strategy: 'rolling',
+          healthCheckTimeout: 30000,
+        },
+      }
+
+      vi.mocked(fs.readFile).mockResolvedValue('mock yaml content' as any)
+      vi.mocked(yaml.load).mockReturnValue(mockConfig)
+
+      const result = await loadConfig('suthep.yml')
+
+      expect(fs.readFile).toHaveBeenCalledWith('suthep.yml', 'utf8')
+      expect(yaml.load).toHaveBeenCalledWith('mock yaml content')
+      expect(result).toEqual(mockConfig)
+    })
+
+    it('should throw error if config file cannot be read', async () => {
+      vi.mocked(fs.readFile).mockRejectedValue(new Error('File not found'))
+
+      await expect(loadConfig('nonexistent.yml')).rejects.toThrow(
+        'Failed to load configuration from nonexistent.yml: File not found'
+      )
+    })
+
+    it('should throw error if project name is missing', async () => {
+      const invalidConfig = {
+        services: [
+          {
+            name: 'api',
+            port: 3000,
+            domains: ['api.example.com'],
+          },
+        ],
+      }
+
+      vi.mocked(fs.readFile).mockResolvedValue('mock yaml content' as any)
+      vi.mocked(yaml.load).mockReturnValue(invalidConfig)
+
+      await expect(loadConfig('suthep.yml')).rejects.toThrow(
+        'Configuration must include project.name'
+      )
+    })
+
+    it('should throw error if services array is missing', async () => {
+      const invalidConfig = {
+        project: {
+          name: 'test-project',
+          version: '1.0.0',
+        },
+      }
+
+      vi.mocked(fs.readFile).mockResolvedValue('mock yaml content' as any)
+      vi.mocked(yaml.load).mockReturnValue(invalidConfig)
+
+      await expect(loadConfig('suthep.yml')).rejects.toThrow(
+        'Configuration must include at least one service'
+      )
+    })
+
+    it('should throw error if service name is missing', async () => {
+      const invalidConfig = {
+        project: {
+          name: 'test-project',
+          version: '1.0.0',
+        },
+        services: [
+          {
+            port: 3000,
+            domains: ['api.example.com'],
+          },
+        ],
+      }
+
+      vi.mocked(fs.readFile).mockResolvedValue('mock yaml content' as any)
+      vi.mocked(yaml.load).mockReturnValue(invalidConfig)
+
+      await expect(loadConfig('suthep.yml')).rejects.toThrow('Each service must have a name')
+    })
+
+    it('should throw error if service port is missing', async () => {
+      const invalidConfig = {
+        project: {
+          name: 'test-project',
+          version: '1.0.0',
+        },
+        services: [
+          {
+            name: 'api',
+            domains: ['api.example.com'],
+          },
+        ],
+      }
+
+      vi.mocked(fs.readFile).mockResolvedValue('mock yaml content' as any)
+      vi.mocked(yaml.load).mockReturnValue(invalidConfig)
+
+      await expect(loadConfig('suthep.yml')).rejects.toThrow('Service api must have a port')
+    })
+
+    it('should throw error if service domains are missing', async () => {
+      const invalidConfig = {
+        project: {
+          name: 'test-project',
+          version: '1.0.0',
+        },
+        services: [
+          {
+            name: 'api',
+            port: 3000,
+          },
+        ],
+      }
+
+      vi.mocked(fs.readFile).mockResolvedValue('mock yaml content' as any)
+      vi.mocked(yaml.load).mockReturnValue(invalidConfig)
+
+      await expect(loadConfig('suthep.yml')).rejects.toThrow(
+        'Service api must have at least one domain'
+      )
+    })
+
+    it('should throw error if port conflict exists', async () => {
+      const invalidConfig = {
+        project: {
+          name: 'test-project',
+          version: '1.0.0',
+        },
+        services: [
+          {
+            name: 'api',
+            port: 3000,
+            domains: ['api.example.com'],
+          },
+          {
+            name: 'web',
+            port: 3000,
+            domains: ['web.example.com'],
+          },
+        ],
+      }
+
+      vi.mocked(fs.readFile).mockResolvedValue('mock yaml content' as any)
+      vi.mocked(yaml.load).mockReturnValue(invalidConfig)
+
+      await expect(loadConfig('suthep.yml')).rejects.toThrow(
+        'Port conflict: Service "web" uses port 3000'
+      )
+    })
+
+    it('should throw error if duplicate service names exist', async () => {
+      const invalidConfig = {
+        project: {
+          name: 'test-project',
+          version: '1.0.0',
+        },
+        services: [
+          {
+            name: 'api',
+            port: 3000,
+            domains: ['api.example.com'],
+          },
+          {
+            name: 'api',
+            port: 3001,
+            domains: ['api2.example.com'],
+          },
+        ],
+      }
+
+      vi.mocked(fs.readFile).mockResolvedValue('mock yaml content' as any)
+      vi.mocked(yaml.load).mockReturnValue(invalidConfig)
+
+      await expect(loadConfig('suthep.yml')).rejects.toThrow(
+        'Duplicate service name: "api" is used multiple times'
+      )
+    })
+
+    it('should throw error if Docker container name conflict exists', async () => {
+      const invalidConfig = {
+        project: {
+          name: 'test-project',
+          version: '1.0.0',
+        },
+        services: [
+          {
+            name: 'api',
+            port: 3000,
+            domains: ['api.example.com'],
+            docker: {
+              container: 'my-container',
+              port: 80,
+            },
+          },
+          {
+            name: 'web',
+            port: 3001,
+            domains: ['web.example.com'],
+            docker: {
+              container: 'my-container',
+              port: 80,
+            },
+          },
+        ],
+      }
+
+      vi.mocked(fs.readFile).mockResolvedValue('mock yaml content' as any)
+      vi.mocked(yaml.load).mockReturnValue(invalidConfig)
+
+      await expect(loadConfig('suthep.yml')).rejects.toThrow(
+        'Docker container name conflict'
+      )
+    })
+
+    it('should set default nginx config if missing', async () => {
+      const configWithoutNginx = {
+        project: {
+          name: 'test-project',
+          version: '1.0.0',
+        },
+        services: [
+          {
+            name: 'api',
+            port: 3000,
+            domains: ['api.example.com'],
+          },
+        ],
+      }
+
+      vi.mocked(fs.readFile).mockResolvedValue('mock yaml content' as any)
+      vi.mocked(yaml.load).mockReturnValue(configWithoutNginx)
+
+      const result = await loadConfig('suthep.yml')
+
+      expect(result.nginx).toEqual({
+        configPath: '/etc/nginx/sites-available',
+        reloadCommand: 'sudo nginx -t && sudo systemctl reload nginx',
+      })
+    })
+
+    it('should set default certbot config if missing', async () => {
+      const configWithoutCertbot = {
+        project: {
+          name: 'test-project',
+          version: '1.0.0',
+        },
+        services: [
+          {
+            name: 'api',
+            port: 3000,
+            domains: ['api.example.com'],
+          },
+        ],
+      }
+
+      vi.mocked(fs.readFile).mockResolvedValue('mock yaml content' as any)
+      vi.mocked(yaml.load).mockReturnValue(configWithoutCertbot)
+
+      const result = await loadConfig('suthep.yml')
+
+      expect(result.certbot).toEqual({
+        email: '',
+        staging: false,
+      })
+    })
+
+    it('should set default deployment config if missing', async () => {
+      const configWithoutDeployment = {
+        project: {
+          name: 'test-project',
+          version: '1.0.0',
+        },
+        services: [
+          {
+            name: 'api',
+            port: 3000,
+            domains: ['api.example.com'],
+          },
+        ],
+      }
+
+      vi.mocked(fs.readFile).mockResolvedValue('mock yaml content' as any)
+      vi.mocked(yaml.load).mockReturnValue(configWithoutDeployment)
+
+      const result = await loadConfig('suthep.yml')
+
+      expect(result.deployment).toEqual({
+        strategy: 'rolling',
+        healthCheckTimeout: 30000,
+      })
+    })
+  })
+
+  describe('saveConfig', () => {
+    it('should save config to YAML file', async () => {
+      const config: DeployConfig = {
+        project: {
+          name: 'test-project',
+          version: '1.0.0',
+        },
+        services: [
+          {
+            name: 'api',
+            port: 3000,
+            domains: ['api.example.com'],
+          },
+        ],
+        nginx: {
+          configPath: '/etc/nginx/sites-available',
+          reloadCommand: 'sudo nginx -t && sudo systemctl reload nginx',
+        },
+        certbot: {
+          email: 'admin@example.com',
+          staging: false,
+        },
+        deployment: {
+          strategy: 'rolling',
+          healthCheckTimeout: 30000,
+        },
+      }
+
+      const mockYamlContent = 'project:\n  name: test-project\n'
+      vi.mocked(yaml.dump).mockReturnValue(mockYamlContent)
+      vi.mocked(fs.writeFile).mockResolvedValue(undefined as any)
+
+      await saveConfig('suthep.yml', config)
+
+      expect(yaml.dump).toHaveBeenCalledWith(config, {
+        indent: 2,
+        lineWidth: 120,
+        noRefs: true,
+      })
+      expect(fs.writeFile).toHaveBeenCalledWith('suthep.yml', mockYamlContent, 'utf8')
+    })
+
+    it('should throw error if file write fails', async () => {
+      const config: DeployConfig = {
+        project: {
+          name: 'test-project',
+          version: '1.0.0',
+        },
+        services: [
+          {
+            name: 'api',
+            port: 3000,
+            domains: ['api.example.com'],
+          },
+        ],
+        nginx: {
+          configPath: '/etc/nginx/sites-available',
+          reloadCommand: 'sudo nginx -t && sudo systemctl reload nginx',
+        },
+        certbot: {
+          email: 'admin@example.com',
+          staging: false,
+        },
+        deployment: {
+          strategy: 'rolling',
+          healthCheckTimeout: 30000,
+        },
+      }
+
+      vi.mocked(yaml.dump).mockReturnValue('mock yaml')
+      vi.mocked(fs.writeFile).mockRejectedValue(new Error('Permission denied'))
+
+      await expect(saveConfig('suthep.yml', config)).rejects.toThrow('Permission denied')
+    })
+  })
+})
+

package/src/utils/__tests__/deployment.test.ts

@@ -0,0 +1,243 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest'
+import {
+  performHealthCheck,
+  deployService,
+  waitForService,
+} from '../deployment'
+import type { ServiceConfig, DeploymentConfig } from '../../types/config'
+import type { ZeroDowntimeContainerInfo } from '../docker'
+
+// Mock global fetch
+const mockFetch = vi.fn()
+global.fetch = mockFetch
+
+describe('deployment', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  describe('performHealthCheck', () => {
+    it('should return true if health check succeeds', async () => {
+      mockFetch.mockResolvedValue({
+        ok: true,
+        status: 200,
+      } as Response)
+
+      const result = await performHealthCheck('http://localhost:3000/health', 1000)
+
+      expect(mockFetch).toHaveBeenCalledWith('http://localhost:3000/health', {
+        method: 'GET',
+        signal: expect.any(AbortSignal),
+      })
+      expect(result).toBe(true)
+    })
+
+    it('should return false if health check fails with non-ok status', async () => {
+      mockFetch.mockResolvedValue({
+        ok: false,
+        status: 500,
+      } as Response)
+
+      const result = await performHealthCheck('http://localhost:3000/health', 1000)
+
+      expect(result).toBe(false)
+    })
+
+    it('should retry on network errors until timeout', async () => {
+      mockFetch.mockRejectedValue(new Error('Network error'))
+
+      const result = await performHealthCheck('http://localhost:3000/health', 3000)
+
+      expect(result).toBe(false)
+      expect(mockFetch).toHaveBeenCalled() // Should have made multiple attempts
+    })
+  })
+
+  describe('deployService', () => {
+    it('should use rolling deployment strategy', async () => {
+      const service: ServiceConfig = {
+        name: 'api',
+        port: 3000,
+        domains: ['api.example.com'],
+        healthCheck: {
+          path: '/health',
+          interval: 30,
+        },
+      }
+
+      const deploymentConfig: DeploymentConfig = {
+        strategy: 'rolling',
+        healthCheckTimeout: 30000,
+      }
+
+      const tempInfo: ZeroDowntimeContainerInfo = {
+        tempContainerName: 'api-new',
+        tempPort: 13000,
+        oldContainerExists: true,
+      }
+
+      mockFetch.mockResolvedValue({
+        ok: true,
+        status: 200,
+      } as Response)
+
+      await deployService(service, deploymentConfig, tempInfo)
+
+      expect(mockFetch).toHaveBeenCalledWith('http://localhost:13000/health', expect.any(Object))
+    })
+
+    it('should use blue-green deployment strategy', async () => {
+      const service: ServiceConfig = {
+        name: 'api',
+        port: 3000,
+        domains: ['api.example.com'],
+        healthCheck: {
+          path: '/health',
+          interval: 30,
+        },
+      }
+
+      const deploymentConfig: DeploymentConfig = {
+        strategy: 'blue-green',
+        healthCheckTimeout: 30000,
+      }
+
+      const tempInfo: ZeroDowntimeContainerInfo = {
+        tempContainerName: 'api-new',
+        tempPort: 13000,
+        oldContainerExists: true,
+      }
+
+      mockFetch.mockResolvedValue({
+        ok: true,
+        status: 200,
+      } as Response)
+
+      await deployService(service, deploymentConfig, tempInfo)
+
+      expect(mockFetch).toHaveBeenCalledWith('http://localhost:13000/health', expect.any(Object))
+    })
+
+    it('should throw error for unknown deployment strategy', async () => {
+      const service: ServiceConfig = {
+        name: 'api',
+        port: 3000,
+        domains: ['api.example.com'],
+      }
+
+      const deploymentConfig = {
+        strategy: 'unknown' as any,
+        healthCheckTimeout: 30000,
+      }
+
+      await expect(deployService(service, deploymentConfig)).rejects.toThrow(
+        'Unknown deployment strategy: unknown'
+      )
+    })
+
+    it('should skip health check if no health check configured', async () => {
+      const service: ServiceConfig = {
+        name: 'api',
+        port: 3000,
+        domains: ['api.example.com'],
+      }
+
+      const deploymentConfig: DeploymentConfig = {
+        strategy: 'rolling',
+        healthCheckTimeout: 30000,
+      }
+
+      await deployService(service, deploymentConfig, null)
+
+      expect(mockFetch).not.toHaveBeenCalled()
+    })
+
+    it('should throw error if health check fails during rolling deployment', async () => {
+      const service: ServiceConfig = {
+        name: 'api',
+        port: 3000,
+        domains: ['api.example.com'],
+        healthCheck: {
+          path: '/health',
+          interval: 30,
+        },
+      }
+
+      const deploymentConfig: DeploymentConfig = {
+        strategy: 'rolling',
+        healthCheckTimeout: 1000, // Shorter timeout for test
+      }
+
+      const tempInfo: ZeroDowntimeContainerInfo = {
+        tempContainerName: 'api-new',
+        tempPort: 13000,
+        oldContainerExists: true,
+      }
+
+      mockFetch.mockResolvedValue({
+        ok: false,
+        status: 500,
+      } as Response)
+
+      await expect(deployService(service, deploymentConfig, tempInfo)).rejects.toThrow(
+        'Service api failed health check on temporary container during rolling deployment'
+      )
+    }, 10000) // Increase test timeout
+  })
+
+  describe('waitForService', () => {
+    it('should wait for service with health check', async () => {
+      const service: ServiceConfig = {
+        name: 'api',
+        port: 3000,
+        domains: ['api.example.com'],
+        healthCheck: {
+          path: '/health',
+          interval: 30,
+        },
+      }
+
+      mockFetch.mockResolvedValue({
+        ok: true,
+        status: 200,
+      } as Response)
+
+      const result = await waitForService(service, 5000)
+
+      expect(mockFetch).toHaveBeenCalledWith('http://localhost:3000/health', expect.any(Object))
+      expect(result).toBe(true)
+    })
+
+    it('should return true after delay if no health check configured', async () => {
+      const service: ServiceConfig = {
+        name: 'api',
+        port: 3000,
+        domains: ['api.example.com'],
+      }
+
+      const result = await waitForService(service, 5000)
+
+      expect(mockFetch).not.toHaveBeenCalled()
+      expect(result).toBe(true)
+    }, 10000) // Increase test timeout to account for 5 second delay
+
+    it('should return false if health check times out', async () => {
+      const service: ServiceConfig = {
+        name: 'api',
+        port: 3000,
+        domains: ['api.example.com'],
+        healthCheck: {
+          path: '/health',
+          interval: 30,
+        },
+      }
+
+      mockFetch.mockRejectedValue(new Error('Network error'))
+
+      const result = await waitForService(service, 1000)
+
+      expect(result).toBe(false)
+    })
+  })
+})
+