quicklify 0.1.0

package/tests/integration/hetzner.test.ts

@@ -0,0 +1,274 @@
+import axios from 'axios';
+import { HetznerProvider } from '../../src/providers/hetzner';
+
+const mockedAxios = axios as jest.Mocked<typeof axios>;
+
+describe('HetznerProvider', () => {
+  let provider: HetznerProvider;
+
+  beforeEach(() => {
+    provider = new HetznerProvider('test-api-token');
+    jest.clearAllMocks();
+  });
+
+  describe('properties', () => {
+    it('should have name "hetzner"', () => {
+      expect(provider.name).toBe('hetzner');
+    });
+
+    it('should have displayName "Hetzner Cloud"', () => {
+      expect(provider.displayName).toBe('Hetzner Cloud');
+    });
+  });
+
+  describe('getRegions', () => {
+    it('should return an array of regions', () => {
+      const regions = provider.getRegions();
+      expect(Array.isArray(regions)).toBe(true);
+      expect(regions.length).toBeGreaterThan(0);
+    });
+
+    it('should include Nuremberg (nbg1)', () => {
+      const regions = provider.getRegions();
+      const nbg = regions.find(r => r.id === 'nbg1');
+      expect(nbg).toBeDefined();
+      expect(nbg!.name).toBe('Nuremberg');
+    });
+
+    it('should include Falkenstein (fsn1)', () => {
+      const regions = provider.getRegions();
+      const fsn = regions.find(r => r.id === 'fsn1');
+      expect(fsn).toBeDefined();
+      expect(fsn!.name).toBe('Falkenstein');
+    });
+
+    it('should include Helsinki (hel1)', () => {
+      const regions = provider.getRegions();
+      const hel = regions.find(r => r.id === 'hel1');
+      expect(hel).toBeDefined();
+    });
+
+    it('should include Ashburn (ash)', () => {
+      const regions = provider.getRegions();
+      const ash = regions.find(r => r.id === 'ash');
+      expect(ash).toBeDefined();
+    });
+
+    it('should have id, name, and location for every region', () => {
+      const regions = provider.getRegions();
+      regions.forEach(region => {
+        expect(region.id).toBeTruthy();
+        expect(region.name).toBeTruthy();
+        expect(region.location).toBeTruthy();
+      });
+    });
+  });
+
+  describe('getServerSizes', () => {
+    it('should return an array of server sizes', () => {
+      const sizes = provider.getServerSizes();
+      expect(Array.isArray(sizes)).toBe(true);
+      expect(sizes.length).toBeGreaterThan(0);
+    });
+
+    it('should have exactly one recommended option', () => {
+      const sizes = provider.getServerSizes();
+      const recommended = sizes.filter(s => s.recommended);
+      expect(recommended).toHaveLength(1);
+    });
+
+    it('should have CAX11 as the recommended option', () => {
+      const sizes = provider.getServerSizes();
+      const cax11 = sizes.find(s => s.id === 'cax11');
+      expect(cax11).toBeDefined();
+      expect(cax11!.recommended).toBe(true);
+      expect(cax11!.vcpu).toBe(2);
+      expect(cax11!.ram).toBe(4);
+    });
+
+    it('should have valid specs for every size', () => {
+      const sizes = provider.getServerSizes();
+      sizes.forEach(size => {
+        expect(size.id).toBeTruthy();
+        expect(size.name).toBeTruthy();
+        expect(size.vcpu).toBeGreaterThan(0);
+        expect(size.ram).toBeGreaterThan(0);
+        expect(size.disk).toBeGreaterThan(0);
+        expect(size.price).toBeTruthy();
+      });
+    });
+
+    it('should include both ARM64 (CAX) and x86 (CPX) options', () => {
+      const sizes = provider.getServerSizes();
+      const arm = sizes.filter(s => s.id.startsWith('cax'));
+      const x86 = sizes.filter(s => s.id.startsWith('cpx'));
+      expect(arm.length).toBeGreaterThan(0);
+      expect(x86.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('validateToken', () => {
+    it('should return true for a valid token', async () => {
+      mockedAxios.get.mockResolvedValueOnce({ data: { servers: [] } });
+
+      const result = await provider.validateToken('valid-token');
+
+      expect(result).toBe(true);
+      expect(mockedAxios.get).toHaveBeenCalledWith(
+        'https://api.hetzner.cloud/v1/servers',
+        expect.objectContaining({
+          headers: { Authorization: 'Bearer valid-token' },
+        })
+      );
+    });
+
+    it('should return false for an invalid token', async () => {
+      mockedAxios.get.mockRejectedValueOnce(new Error('Unauthorized'));
+
+      const result = await provider.validateToken('bad-token');
+
+      expect(result).toBe(false);
+    });
+
+    it('should return false on network error', async () => {
+      mockedAxios.get.mockRejectedValueOnce(new Error('ECONNREFUSED'));
+
+      const result = await provider.validateToken('any-token');
+
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('createServer', () => {
+    const serverConfig = {
+      name: 'test-server',
+      size: 'cax11',
+      region: 'nbg1',
+      cloudInit: '#!/bin/bash\necho hello',
+    };
+
+    it('should create a server and return result', async () => {
+      mockedAxios.post.mockResolvedValueOnce({
+        data: {
+          server: {
+            id: 12345,
+            public_net: { ipv4: { ip: '1.2.3.4' } },
+            status: 'initializing',
+          },
+        },
+      });
+
+      const result = await provider.createServer(serverConfig);
+
+      expect(result.id).toBe('12345');
+      expect(result.ip).toBe('1.2.3.4');
+      expect(result.status).toBe('initializing');
+    });
+
+    it('should send correct request payload to Hetzner API', async () => {
+      mockedAxios.post.mockResolvedValueOnce({
+        data: {
+          server: {
+            id: 1,
+            public_net: { ipv4: { ip: '10.0.0.1' } },
+            status: 'initializing',
+          },
+        },
+      });
+
+      await provider.createServer(serverConfig);
+
+      expect(mockedAxios.post).toHaveBeenCalledWith(
+        'https://api.hetzner.cloud/v1/servers',
+        {
+          name: 'test-server',
+          server_type: 'cax11',
+          location: 'nbg1',
+          image: 'ubuntu-24.04',
+          user_data: serverConfig.cloudInit,
+        },
+        expect.objectContaining({
+          headers: expect.objectContaining({
+            Authorization: 'Bearer test-api-token',
+            'Content-Type': 'application/json',
+          }),
+        })
+      );
+    });
+
+    it('should throw with API error message on failure', async () => {
+      mockedAxios.post.mockRejectedValueOnce({
+        response: {
+          data: {
+            error: { message: 'server_limit_exceeded' },
+          },
+        },
+      });
+
+      await expect(provider.createServer(serverConfig)).rejects.toThrow(
+        'Failed to create server: server_limit_exceeded'
+      );
+    });
+
+    it('should throw with generic message on network error', async () => {
+      mockedAxios.post.mockRejectedValueOnce(new Error('Network Error'));
+
+      await expect(provider.createServer(serverConfig)).rejects.toThrow(
+        'Failed to create server: Network Error'
+      );
+    });
+
+    it('should throw on timeout', async () => {
+      mockedAxios.post.mockRejectedValueOnce(new Error('timeout of 30000ms exceeded'));
+
+      await expect(provider.createServer(serverConfig)).rejects.toThrow(
+        'Failed to create server: timeout of 30000ms exceeded'
+      );
+    });
+  });
+
+  describe('getServerStatus', () => {
+    it('should return "running" for a running server', async () => {
+      mockedAxios.get.mockResolvedValueOnce({
+        data: { server: { status: 'running' } },
+      });
+
+      const status = await provider.getServerStatus('12345');
+
+      expect(status).toBe('running');
+    });
+
+    it('should return "initializing" for a new server', async () => {
+      mockedAxios.get.mockResolvedValueOnce({
+        data: { server: { status: 'initializing' } },
+      });
+
+      const status = await provider.getServerStatus('12345');
+
+      expect(status).toBe('initializing');
+    });
+
+    it('should call correct API endpoint with server ID', async () => {
+      mockedAxios.get.mockResolvedValueOnce({
+        data: { server: { status: 'running' } },
+      });
+
+      await provider.getServerStatus('99999');
+
+      expect(mockedAxios.get).toHaveBeenCalledWith(
+        'https://api.hetzner.cloud/v1/servers/99999',
+        expect.objectContaining({
+          headers: { Authorization: 'Bearer test-api-token' },
+        })
+      );
+    });
+
+    it('should throw on error', async () => {
+      mockedAxios.get.mockRejectedValueOnce(new Error('Not Found'));
+
+      await expect(provider.getServerStatus('00000')).rejects.toThrow(
+        'Failed to get server status: Not Found'
+      );
+    });
+  });
+});

package/tests/unit/cloudInit.test.ts

@@ -0,0 +1,53 @@
+import { getCoolifyCloudInit } from '../../src/utils/cloudInit';
+
+describe('getCoolifyCloudInit', () => {
+  it('should return a bash script starting with shebang', () => {
+    const script = getCoolifyCloudInit('test-server');
+    expect(script.startsWith('#!/bin/bash')).toBe(true);
+  });
+
+  it('should include set -e for error handling', () => {
+    const script = getCoolifyCloudInit('test-server');
+    expect(script).toContain('set -e');
+  });
+
+  it('should include the server name in the output', () => {
+    const script = getCoolifyCloudInit('my-coolify');
+    expect(script).toContain('my-coolify');
+  });
+
+  it('should include Coolify install command', () => {
+    const script = getCoolifyCloudInit('test');
+    expect(script).toContain('curl -fsSL https://cdn.coollabs.io/coolify/install.sh | bash');
+  });
+
+  it('should include system update step', () => {
+    const script = getCoolifyCloudInit('test');
+    expect(script).toContain('apt-get update -y');
+  });
+
+  it('should include service wait step', () => {
+    const script = getCoolifyCloudInit('test');
+    expect(script).toContain('sleep 30');
+  });
+
+  it('should handle different server names correctly', () => {
+    const script1 = getCoolifyCloudInit('server-alpha');
+    const script2 = getCoolifyCloudInit('production-01');
+
+    expect(script1).toContain('server-alpha');
+    expect(script1).not.toContain('production-01');
+    expect(script2).toContain('production-01');
+    expect(script2).not.toContain('server-alpha');
+  });
+
+  it('should include completion message', () => {
+    const script = getCoolifyCloudInit('test');
+    expect(script).toContain('Coolify installation completed');
+  });
+
+  it('should mention port 8000 for access', () => {
+    const script = getCoolifyCloudInit('test');
+    expect(script).toContain('8000');
+  });
+});

package/tests/unit/logger.test.ts

@@ -0,0 +1,76 @@
+import { logger, createSpinner } from '../../src/utils/logger';
+
+describe('logger', () => {
+  let consoleSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+  });
+
+  afterEach(() => {
+    consoleSpy.mockRestore();
+  });
+
+  it('should log info messages', () => {
+    logger.info('test info');
+    expect(consoleSpy).toHaveBeenCalledTimes(1);
+    expect(consoleSpy).toHaveBeenCalledWith(expect.any(String), 'test info');
+  });
+
+  it('should log success messages', () => {
+    logger.success('task done');
+    expect(consoleSpy).toHaveBeenCalledTimes(1);
+    expect(consoleSpy).toHaveBeenCalledWith(expect.any(String), 'task done');
+  });
+
+  it('should log error messages', () => {
+    logger.error('something failed');
+    expect(consoleSpy).toHaveBeenCalledTimes(1);
+    expect(consoleSpy).toHaveBeenCalledWith(expect.any(String), 'something failed');
+  });
+
+  it('should log warning messages', () => {
+    logger.warning('be careful');
+    expect(consoleSpy).toHaveBeenCalledTimes(1);
+    expect(consoleSpy).toHaveBeenCalledWith(expect.any(String), 'be careful');
+  });
+
+  it('should log title with empty lines before and after', () => {
+    logger.title('My Title');
+    expect(consoleSpy).toHaveBeenCalledTimes(3);
+  });
+
+  it('should log step messages', () => {
+    logger.step('doing something');
+    expect(consoleSpy).toHaveBeenCalledTimes(1);
+    expect(consoleSpy).toHaveBeenCalledWith(expect.any(String), 'doing something');
+  });
+});
+
+describe('createSpinner', () => {
+  it('should create a spinner with given text', () => {
+    const spinner = createSpinner('Loading...');
+    expect(spinner).toBeDefined();
+  });
+
+  it('should return spinner with start method', () => {
+    const spinner = createSpinner('Loading...');
+    expect(typeof spinner.start).toBe('function');
+  });
+
+  it('should return spinner with succeed method', () => {
+    const spinner = createSpinner('Loading...');
+    expect(typeof spinner.succeed).toBe('function');
+  });
+
+  it('should return spinner with fail method', () => {
+    const spinner = createSpinner('Loading...');
+    expect(typeof spinner.fail).toBe('function');
+  });
+
+  it('should allow chaining start', () => {
+    const spinner = createSpinner('Loading...');
+    const result = spinner.start();
+    expect(result).toBe(spinner);
+  });
+});

package/tests/unit/prompts.test.ts

@@ -0,0 +1,220 @@
+import inquirer from 'inquirer';
+import { getDeploymentConfig, confirmDeployment } from '../../src/utils/prompts';
+import type { CloudProvider } from '../../src/providers/base';
+
+const mockedInquirer = inquirer as jest.Mocked<typeof inquirer>;
+
+const mockProvider: CloudProvider = {
+  name: 'hetzner',
+  displayName: 'Hetzner Cloud',
+  validateToken: jest.fn(),
+  getRegions: () => [
+    { id: 'nbg1', name: 'Nuremberg', location: 'Germany' },
+    { id: 'fsn1', name: 'Falkenstein', location: 'Germany' },
+  ],
+  getServerSizes: () => [
+    { id: 'cax11', name: 'CAX11', vcpu: 2, ram: 4, disk: 40, price: '€3.85/mo', recommended: true },
+    { id: 'cpx11', name: 'CPX11', vcpu: 2, ram: 2, disk: 40, price: '€4.15/mo' },
+  ],
+  createServer: jest.fn(),
+  getServerStatus: jest.fn(),
+};
+
+describe('getDeploymentConfig', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should return deployment config from user input', async () => {
+    mockedInquirer.prompt.mockResolvedValueOnce({
+      apiToken: 'my-token',
+      region: 'nbg1',
+      size: 'cax11',
+      serverName: 'my-server',
+    });
+
+    const config = await getDeploymentConfig(mockProvider);
+
+    expect(config.provider).toBe('hetzner');
+    expect(config.apiToken).toBe('my-token');
+    expect(config.region).toBe('nbg1');
+    expect(config.serverSize).toBe('cax11');
+    expect(config.serverName).toBe('my-server');
+  });
+
+  it('should trim apiToken whitespace', async () => {
+    mockedInquirer.prompt.mockResolvedValueOnce({
+      apiToken: '  token-with-spaces  ',
+      region: 'nbg1',
+      size: 'cax11',
+      serverName: 'server',
+    });
+
+    const config = await getDeploymentConfig(mockProvider);
+    expect(config.apiToken).toBe('token-with-spaces');
+  });
+
+  it('should trim serverName whitespace', async () => {
+    mockedInquirer.prompt.mockResolvedValueOnce({
+      apiToken: 'token',
+      region: 'nbg1',
+      size: 'cax11',
+      serverName: '  my-server  ',
+    });
+
+    const config = await getDeploymentConfig(mockProvider);
+    expect(config.serverName).toBe('my-server');
+  });
+
+  it('should pass correct prompt config with regions and sizes', async () => {
+    mockedInquirer.prompt.mockResolvedValueOnce({
+      apiToken: 'token',
+      region: 'nbg1',
+      size: 'cax11',
+      serverName: 'server',
+    });
+
+    await getDeploymentConfig(mockProvider);
+
+    const promptConfig = mockedInquirer.prompt.mock.calls[0][0] as any[];
+
+    // Check password prompt for API token
+    expect(promptConfig[0].type).toBe('password');
+    expect(promptConfig[0].name).toBe('apiToken');
+
+    // Check region list has choices from provider
+    expect(promptConfig[1].type).toBe('list');
+    expect(promptConfig[1].choices).toHaveLength(2);
+
+    // Check size list has recommended marker
+    expect(promptConfig[2].type).toBe('list');
+    const sizeChoices = promptConfig[2].choices;
+    const recommendedChoice = sizeChoices.find((c: any) => c.name.includes('Recommended'));
+    expect(recommendedChoice).toBeDefined();
+
+    // Check server name input with default
+    expect(promptConfig[3].type).toBe('input');
+    expect(promptConfig[3].default).toBe('coolify-server');
+  });
+
+  describe('apiToken validator', () => {
+    let validateToken: (input: string) => string | true;
+
+    beforeEach(async () => {
+      mockedInquirer.prompt.mockResolvedValueOnce({
+        apiToken: 'x', region: 'nbg1', size: 'cax11', serverName: 's',
+      });
+      await getDeploymentConfig(mockProvider);
+      const promptConfig = mockedInquirer.prompt.mock.calls[0][0] as any[];
+      validateToken = promptConfig[0].validate;
+    });
+
+    it('should accept valid token', () => {
+      expect(validateToken('valid-api-token')).toBe(true);
+    });
+
+    it('should reject empty string', () => {
+      expect(validateToken('')).toBe('API token is required');
+    });
+
+    it('should reject whitespace-only string', () => {
+      expect(validateToken('   ')).toBe('API token is required');
+    });
+  });
+
+  describe('serverName validator', () => {
+    let validateName: (input: string) => string | true;
+
+    beforeEach(async () => {
+      mockedInquirer.prompt.mockResolvedValueOnce({
+        apiToken: 'x', region: 'nbg1', size: 'cax11', serverName: 's',
+      });
+      await getDeploymentConfig(mockProvider);
+      const promptConfig = mockedInquirer.prompt.mock.calls[0][0] as any[];
+      validateName = promptConfig[3].validate;
+    });
+
+    it('should accept valid lowercase name', () => {
+      expect(validateName('coolify-server')).toBe(true);
+    });
+
+    it('should accept name with numbers', () => {
+      expect(validateName('server-01')).toBe(true);
+    });
+
+    it('should reject empty string', () => {
+      expect(validateName('')).toBe('Server name is required');
+    });
+
+    it('should reject whitespace-only string', () => {
+      expect(validateName('   ')).toBe('Server name is required');
+    });
+
+    it('should reject uppercase letters', () => {
+      expect(validateName('MyServer')).toBe('Server name must contain only lowercase letters, numbers, and hyphens');
+    });
+
+    it('should reject underscores', () => {
+      expect(validateName('my_server')).toBe('Server name must contain only lowercase letters, numbers, and hyphens');
+    });
+
+    it('should reject dots', () => {
+      expect(validateName('server.com')).toBe('Server name must contain only lowercase letters, numbers, and hyphens');
+    });
+
+    it('should reject spaces', () => {
+      expect(validateName('my server')).toBe('Server name must contain only lowercase letters, numbers, and hyphens');
+    });
+  });
+});
+
+describe('confirmDeployment', () => {
+  let consoleSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+    jest.clearAllMocks();
+  });
+
+  afterEach(() => {
+    consoleSpy.mockRestore();
+  });
+
+  it('should return true when user confirms', async () => {
+    mockedInquirer.prompt.mockResolvedValueOnce({ confirm: true });
+
+    const result = await confirmDeployment(
+      { provider: 'hetzner', apiToken: 'x', region: 'nbg1', serverSize: 'cax11', serverName: 'server' },
+      mockProvider,
+    );
+
+    expect(result).toBe(true);
+  });
+
+  it('should return false when user declines', async () => {
+    mockedInquirer.prompt.mockResolvedValueOnce({ confirm: false });
+
+    const result = await confirmDeployment(
+      { provider: 'hetzner', apiToken: 'x', region: 'nbg1', serverSize: 'cax11', serverName: 'server' },
+      mockProvider,
+    );
+
+    expect(result).toBe(false);
+  });
+
+  it('should print deployment summary with correct details', async () => {
+    mockedInquirer.prompt.mockResolvedValueOnce({ confirm: true });
+
+    await confirmDeployment(
+      { provider: 'hetzner', apiToken: 'x', region: 'nbg1', serverSize: 'cax11', serverName: 'my-server' },
+      mockProvider,
+    );
+
+    const output = consoleSpy.mock.calls.map((c: any[]) => c.join(' ')).join('\n');
+    expect(output).toContain('Hetzner Cloud');
+    expect(output).toContain('Nuremberg');
+    expect(output).toContain('CAX11');
+    expect(output).toContain('€3.85/mo');
+    expect(output).toContain('my-server');
+  });
+});

package/tests/unit/validators.test.ts

@@ -0,0 +1,63 @@
+describe('Server name validation', () => {
+  const serverNameRegex = /^[a-z0-9-]+$/;
+
+  it('should accept valid lowercase server names', () => {
+    expect(serverNameRegex.test('coolify-server')).toBe(true);
+    expect(serverNameRegex.test('my-server-1')).toBe(true);
+    expect(serverNameRegex.test('server')).toBe(true);
+  });
+
+  it('should accept numeric-only names', () => {
+    expect(serverNameRegex.test('123')).toBe(true);
+    expect(serverNameRegex.test('1-2-3')).toBe(true);
+  });
+
+  it('should accept hyphenated names', () => {
+    expect(serverNameRegex.test('my-cool-server')).toBe(true);
+    expect(serverNameRegex.test('a-b-c')).toBe(true);
+  });
+
+  it('should reject names with uppercase letters', () => {
+    expect(serverNameRegex.test('MyServer')).toBe(false);
+    expect(serverNameRegex.test('COOLIFY')).toBe(false);
+    expect(serverNameRegex.test('Server')).toBe(false);
+  });
+
+  it('should reject names with spaces', () => {
+    expect(serverNameRegex.test('my server')).toBe(false);
+    expect(serverNameRegex.test(' server')).toBe(false);
+  });
+
+  it('should reject names with special characters', () => {
+    expect(serverNameRegex.test('server!')).toBe(false);
+    expect(serverNameRegex.test('server@1')).toBe(false);
+    expect(serverNameRegex.test('server.com')).toBe(false);
+    expect(serverNameRegex.test('server_name')).toBe(false);
+    expect(serverNameRegex.test('server#1')).toBe(false);
+  });
+
+  it('should reject empty strings', () => {
+    expect(serverNameRegex.test('')).toBe(false);
+  });
+});
+
+describe('API token validation', () => {
+  const isTokenValid = (input: string) => {
+    if (!input || input.trim().length === 0) return false;
+    return true;
+  };
+
+  it('should accept non-empty tokens', () => {
+    expect(isTokenValid('abc123')).toBe(true);
+    expect(isTokenValid('some-long-api-token-here')).toBe(true);
+  });
+
+  it('should reject empty tokens', () => {
+    expect(isTokenValid('')).toBe(false);
+  });
+
+  it('should reject whitespace-only tokens', () => {
+    expect(isTokenValid('   ')).toBe(false);
+    expect(isTokenValid('\t')).toBe(false);
+  });
+});