@simplens/onboard 1.0.8 → 1.0.10

package/src/__tests__/errors.test.ts

@@ -1,188 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-    OnboardingError,
-    DockerNotInstalledError,
-    DockerNotRunningError,
-    DockerPermissionError,
-    DockerComposeError,
-    FileSystemError,
-    DirectoryNotWritableError,
-    isOnboardingError,
-    formatErrorForUser,
-} from '../types/errors.js';
-
-describe('error types', () => {
-    describe('OnboardingError', () => {
-        it('should create error with code and message', () => {
-            const error = new OnboardingError('TEST_CODE', 'Test message');
-
-            expect(error.code).toBe('TEST_CODE');
-            expect(error.message).toBe('Test message');
-            expect(error.name).toBe('OnboardingError');
-        });
-
-        it('should include troubleshooting when provided', () => {
-            const error = new OnboardingError(
-                'TEST_CODE',
-                'Test message',
-                'Try this fix'
-            );
-
-            expect(error.troubleshooting).toBe('Try this fix');
-        });
-
-        it('should have proper stack trace', () => {
-            const error = new OnboardingError('TEST', 'message');
-
-            expect(error.stack).toBeDefined();
-            expect(error.stack).toContain('OnboardingError');
-        });
-    });
-
-    describe('DockerNotInstalledError', () => {
-        it('should have correct message and troubleshooting', () => {
-            const error = new DockerNotInstalledError();
-
-            expect(error.message).toContain('not installed');
-            expect(error.troubleshooting).toContain('https://docs.docker.com/get-docker/');
-            expect(error.name).toBe('DockerNotInstalledError');
-        });
-    });
-
-    describe('DockerNotRunningError', () => {
-        it('should have correct message and troubleshooting', () => {
-            const error = new DockerNotRunningError();
-
-            expect(error.message).toContain('not running');
-            expect(error.troubleshooting).toContain('Docker daemon');
-            expect(error.name).toBe('DockerNotRunningError');
-        });
-    });
-
-    describe('DockerPermissionError', () => {
-        it('should have correct message and troubleshooting', () => {
-            const error = new DockerPermissionError();
-
-            expect(error.message).toContain('Permission denied');
-            expect(error.troubleshooting).toContain('usermod');
-            expect(error.name).toBe('DockerPermissionError');
-        });
-    });
-
-    describe('DockerComposeError', () => {
-        it('should include operation in message', () => {
-            const error = new DockerComposeError('start services');
-
-            expect(error.message).toContain('start services');
-            expect(error.name).toBe('DockerComposeError');
-        });
-
-        it('should use custom troubleshooting when provided', () => {
-            const error = new DockerComposeError('pull images', 'Check network connection');
-
-            expect(error.troubleshooting).toBe('Check network connection');
-        });
-
-        it('should have default troubleshooting', () => {
-            const error = new DockerComposeError('operation');
-
-            expect(error.troubleshooting).toContain('docker compose logs');
-            expect(error.troubleshooting).toContain('docker-compose logs');
-        });
-    });
-
-    describe('FileSystemError', () => {
-        it('should include path in error', () => {
-            const error = new FileSystemError(
-                'Cannot write',
-                '/path/to/file',
-                'Check permissions'
-            );
-
-            expect(error.path).toBe('/path/to/file');
-            expect(error.troubleshooting).toBe('Check permissions');
-        });
-    });
-
-    describe('DirectoryNotWritableError', () => {
-        it('should include path in message and error', () => {
-            const error = new DirectoryNotWritableError('/opt/app');
-
-            expect(error.message).toContain('/opt/app');
-            expect(error.path).toBe('/opt/app');
-            expect(error.troubleshooting).toContain('permissions');
-        });
-    });
-
-    describe('isOnboardingError', () => {
-        it('should return true for OnboardingError instances', () => {
-            const error = new OnboardingError('CODE', 'message');
-
-            expect(isOnboardingError(error)).toBe(true);
-        });
-
-        it('should return true for subclasses of OnboardingError', () => {
-            const error = new DockerNotInstalledError();
-
-            expect(isOnboardingError(error)).toBe(true);
-        });
-
-        it('should return false for regular Error', () => {
-            const error = new Error('regular error');
-
-            expect(isOnboardingError(error)).toBe(false);
-        });
-
-        it('should return false for non-error values', () => {
-            expect(isOnboardingError('string')).toBe(false);
-            expect(isOnboardingError(null)).toBe(false);
-            expect(isOnboardingError(undefined)).toBe(false);
-            expect(isOnboardingError({})).toBe(false);
-        });
-    });
-
-    describe('formatErrorForUser', () => {
-        it('should format OnboardingError with troubleshooting', () => {
-            const error = new OnboardingError(
-                'TEST',
-                'Something went wrong',
-                'Try this fix'
-            );
-
-            const formatted = formatErrorForUser(error);
-
-            expect(formatted).toContain('❌ Something went wrong');
-            expect(formatted).toContain('💡 Troubleshooting:');
-            expect(formatted).toContain('Try this fix');
-        });
-
-        it('should format OnboardingError without troubleshooting', () => {
-            const error = new OnboardingError('TEST', 'Something went wrong');
-
-            const formatted = formatErrorForUser(error);
-
-            expect(formatted).toBe('❌ Something went wrong');
-            expect(formatted).not.toContain('Troubleshooting');
-        });
-
-        it('should format regular Error', () => {
-            const error = new Error('Regular error message');
-
-            const formatted = formatErrorForUser(error);
-
-            expect(formatted).toContain('Unexpected error');
-            expect(formatted).toContain('Regular error message');
-        });
-
-        it('should handle non-Error values', () => {
-            const formatted = formatErrorForUser('some string');
-
-            expect(formatted).toBe('❌ An unknown error occurred');
-        });
-
-        it('should handle null/undefined', () => {
-            expect(formatErrorForUser(null)).toBe('❌ An unknown error occurred');
-            expect(formatErrorForUser(undefined)).toBe('❌ An unknown error occurred');
-        });
-    });
-});

package/src/__tests__/infra-prompts.test.ts

@@ -1,56 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-
-// Mock @clack/prompts
-vi.mock('@clack/prompts', () => ({
-    multiselect: vi.fn(),
-    spinner: vi.fn(() => ({
-        start: vi.fn(),
-        stop: vi.fn(),
-        error: vi.fn(),
-        message: vi.fn(),
-    })),
-}));
-
-// Mock the ui.js module
-vi.mock('../ui.js', () => ({
-    handleCancel: vi.fn(),
-}));
-
-import { multiselect } from '@clack/prompts';
-import { promptInfraServicesWithBasePath } from '../infra.js';
-
-describe('promptInfraServicesWithBasePath', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-
-    it('includes nginx when allowNginx is true', async () => {
-        const mockMultiselect = vi.mocked(multiselect);
-        mockMultiselect.mockResolvedValue(['mongo', 'redis', 'nginx']);
-
-        const result = await promptInfraServicesWithBasePath({ allowNginx: true, defaultNginx: true });
-
-        // Should include nginx in options
-        const callArgs = mockMultiselect.mock.calls[0][0] as any;
-        const values = callArgs.options.map((o: any) => o.value);
-        expect(values).toContain('nginx');
-        expect(callArgs.initialValues).toContain('nginx');
-        expect(callArgs.initialValues).not.toContain('kafka-ui');
-
-        expect(result).toContain('nginx');
-    });
-
-    it('excludes nginx when allowNginx is false', async () => {
-        const mockMultiselect = vi.mocked(multiselect);
-        mockMultiselect.mockResolvedValue(['mongo', 'redis']);
-
-        const result = await promptInfraServicesWithBasePath({ allowNginx: false });
-
-        // Should NOT include nginx in options
-        const callArgs = mockMultiselect.mock.calls[0][0] as any;
-        const values = callArgs.options.map((o: any) => o.value);
-        expect(values).not.toContain('nginx');
-
-        expect(result).not.toContain('nginx');
-    });
-});

package/src/__tests__/infra.test.ts

@@ -1,30 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { buildAppComposeContent } from '../infra.js';
-
-describe('infra app compose generation', () => {
-    it('does not include nginx when disabled', () => {
-        const compose = buildAppComposeContent(false);
-        expect(compose).not.toContain('  nginx:');
-    });
-
-    it('includes nginx service when enabled', () => {
-        const compose = buildAppComposeContent(true);
-        expect(compose).toContain('  nginx:');
-        expect(compose).toContain('./nginx.conf:/etc/nginx/conf.d/default.conf:ro');
-    });
-
-    it('does not include certbot services when ssl is disabled', () => {
-        const compose = buildAppComposeContent(true, { includeSsl: false });
-        expect(compose).not.toContain('  certbot:');
-        expect(compose).not.toContain('  certbot-renew:');
-    });
-
-    it('includes certbot services and volumes when ssl is enabled', () => {
-        const compose = buildAppComposeContent(false, { includeSsl: true });
-        expect(compose).toContain('  nginx:');
-        expect(compose).toContain('  certbot:');
-        expect(compose).toContain('  certbot-renew:');
-        expect(compose).toContain('certbot-etc:');
-        expect(compose).toContain('certbot-www:');
-    });
-});

package/src/__tests__/utils.test.ts

@@ -1,142 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { promises as fs } from 'fs';
-import os from 'os';
-import path from 'path';
-import {
-    fileExists,
-    writeFile,
-    readFile,
-    appendFile,
-} from '../utils.js';
-
-describe('utils - file operations', () => {
-    let tempDir: string;
-
-    beforeEach(async () => {
-        // Create a temporary directory for tests
-        tempDir = path.join(os.tmpdir(), `onboard-test-${Date.now()}`);
-        await fs.mkdir(tempDir, { recursive: true });
-    });
-
-    afterEach(async () => {
-        // Clean up temporary directory
-        try {
-            await fs.rm(tempDir, { recursive: true, force: true });
-        } catch (error) {
-            // Ignore cleanup errors
-        }
-    });
-
-    describe('fileExists', () => {
-        it('should return true for existing file', async () => {
-            const filePath = path.join(tempDir, 'test.txt');
-            await fs.writeFile(filePath, 'content');
-
-            expect(await fileExists(filePath)).toBe(true);
-        });
-
-        it('should return false for non-existing file', async () => {
-            const filePath = path.join(tempDir, 'nonexistent.txt');
-
-            expect(await fileExists(filePath)).toBe(false);
-        });
-
-        it('should return true for existing directory', async () => {
-            expect(await fileExists(tempDir)).toBe(true);
-        });
-    });
-
-    describe('writeFile', () => {
-        it('should write content to file', async () => {
-            const filePath = path.join(tempDir, 'write-test.txt');
-            const content = 'Hello, World!';
-
-            await writeFile(filePath, content);
-
-            const written = await fs.readFile(filePath, 'utf-8');
-            expect(written).toBe(content);
-        });
-
-        it('should create parent directories if they do not exist', async () => {
-            const filePath = path.join(tempDir, 'nested', 'dir', 'file.txt');
-            const content = 'Nested content';
-
-            await writeFile(filePath, content);
-
-            expect(await fileExists(filePath)).toBe(true);
-            const written = await fs.readFile(filePath, 'utf-8');
-            expect(written).toBe(content);
-        });
-
-        it('should overwrite existing file', async () => {
-            const filePath = path.join(tempDir, 'overwrite.txt');
-            
-            await fs.writeFile(filePath, 'original');
-            await writeFile(filePath, 'new content');
-
-            const written = await fs.readFile(filePath, 'utf-8');
-            expect(written).toBe('new content');
-        });
-    });
-
-    describe('readFile', () => {
-        it('should read file content', async () => {
-            const filePath = path.join(tempDir, 'read-test.txt');
-            const content = 'File content to read';
-            await fs.writeFile(filePath, content);
-
-            const read = await readFile(filePath);
-
-            expect(read).toBe(content);
-        });
-
-        it('should throw error for non-existing file', async () => {
-            const filePath = path.join(tempDir, 'nonexistent.txt');
-
-            await expect(readFile(filePath)).rejects.toThrow();
-        });
-
-        it('should handle UTF-8 content', async () => {
-            const filePath = path.join(tempDir, 'utf8.txt');
-            const content = 'Hello 世界 🌍';
-            await fs.writeFile(filePath, content);
-
-            const read = await readFile(filePath);
-
-            expect(read).toBe(content);
-        });
-    });
-
-    describe('appendFile', () => {
-        it('should append content to existing file', async () => {
-            const filePath = path.join(tempDir, 'append-test.txt');
-            await fs.writeFile(filePath, 'Line 1\n');
-
-            await appendFile(filePath, 'Line 2\n');
-
-            const content = await fs.readFile(filePath, 'utf-8');
-            expect(content).toBe('Line 1\nLine 2\n');
-        });
-
-        it('should create file if it does not exist', async () => {
-            const filePath = path.join(tempDir, 'new-append.txt');
-
-            await appendFile(filePath, 'First line\n');
-
-            expect(await fileExists(filePath)).toBe(true);
-            const content = await fs.readFile(filePath, 'utf-8');
-            expect(content).toBe('First line\n');
-        });
-
-        it('should handle multiple appends', async () => {
-            const filePath = path.join(tempDir, 'multi-append.txt');
-
-            await appendFile(filePath, 'Line 1\n');
-            await appendFile(filePath, 'Line 2\n');
-            await appendFile(filePath, 'Line 3\n');
-
-            const content = await fs.readFile(filePath, 'utf-8');
-            expect(content).toBe('Line 1\nLine 2\nLine 3\n');
-        });
-    });
-});

package/src/__tests__/validators.test.ts

@@ -1,221 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { 
-    checkDockerInstalled, 
-    checkDockerRunning,
-    detectOS,
-    validatePrerequisites,
-    validateEnvValue,
-    validatePublicDomain,
-    validateEmailAddress
-} from '../validators.js';
-import {
-    DockerNotInstalledError,
-    DockerNotRunningError,
-    DockerPermissionError
-} from '../types/errors.js';
-
-// Mock execa
-vi.mock('execa', () => ({
-    execa: vi.fn(),
-}));
-
-// Mock utils
-vi.mock('../utils.js', () => ({
-    logError: vi.fn(),
-    logSuccess: vi.fn(),
-    logWarning: vi.fn(),
-}));
-
-import { execa } from 'execa';
-
-describe('validators', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-
-    describe('checkDockerInstalled', () => {
-        it('should not throw when docker is installed', async () => {
-            vi.mocked(execa).mockResolvedValueOnce({
-                stdout: 'Docker version 24.0.0',
-                stderr: '',
-            } as any);
-
-            await expect(checkDockerInstalled()).resolves.not.toThrow();
-        });
-
-        it('should throw DockerNotInstalledError when docker is not installed', async () => {
-            vi.mocked(execa).mockRejectedValueOnce(new Error('Command not found'));
-
-            await expect(checkDockerInstalled()).rejects.toThrow(DockerNotInstalledError);
-        });
-    });
-
-    describe('checkDockerRunning', () => {
-        it('should not throw when docker daemon is running', async () => {
-            vi.mocked(execa).mockResolvedValueOnce({
-                stdout: 'CONTAINER ID   IMAGE',
-                stderr: '',
-            } as any);
-
-            await expect(checkDockerRunning()).resolves.not.toThrow();
-        });
-
-        it('should throw DockerPermissionError on permission denied', async () => {
-            const error = new Error('permission denied while trying to connect');
-            vi.mocked(execa).mockRejectedValueOnce(error);
-
-            await expect(checkDockerRunning()).rejects.toThrow(DockerPermissionError);
-        });
-
-        it('should throw DockerNotRunningError when daemon is not running', async () => {
-            const error = new Error('Cannot connect to the Docker daemon');
-            vi.mocked(execa).mockRejectedValueOnce(error);
-
-            await expect(checkDockerRunning()).rejects.toThrow(DockerNotRunningError);
-        });
-
-        it('should throw DockerNotRunningError on generic docker error', async () => {
-            const error = new Error('Some other docker error');
-            vi.mocked(execa).mockRejectedValueOnce(error);
-
-            await expect(checkDockerRunning()).rejects.toThrow(DockerNotRunningError);
-        });
-    });
-
-    describe('detectOS', () => {
-        const originalPlatform = process.platform;
-
-        afterEach(() => {
-            Object.defineProperty(process, 'platform', {
-                value: originalPlatform
-            });
-        });
-
-        it('should detect Windows', () => {
-            Object.defineProperty(process, 'platform', {
-                value: 'win32'
-            });
-            expect(detectOS()).toBe('windows');
-        });
-
-        it('should detect macOS', () => {
-            Object.defineProperty(process, 'platform', {
-                value: 'darwin'
-            });
-            expect(detectOS()).toBe('darwin');
-        });
-
-        it('should detect Linux', () => {
-            Object.defineProperty(process, 'platform', {
-                value: 'linux'
-            });
-            expect(detectOS()).toBe('linux');
-        });
-
-        it('should default to Linux for unknown platforms', () => {
-            Object.defineProperty(process, 'platform', {
-                value: 'freebsd'
-            });
-            expect(detectOS()).toBe('linux');
-        });
-    });
-
-    describe('validateEnvValue', () => {
-        describe('URL validation', () => {
-            it('should reject empty MongoDB URI', () => {
-                expect(validateEnvValue('MONGO_URI', '')).toBe(false);
-            });
-
-            it('should reject MongoDB URI without proper format', () => {
-                expect(validateEnvValue('MONGO_URI', 'localhost:27017')).toBe(false);
-            });
-
-            it('should accept valid MongoDB URI', () => {
-                expect(validateEnvValue('MONGO_URI', 'mongodb://localhost:27017')).toBe(true);
-            });
-
-            it('should reject Redis URL without proper format', () => {
-                expect(validateEnvValue('REDIS_URL', 'localhost:6379')).toBe(false);
-            });
-
-            it('should accept valid Redis URL', () => {
-                expect(validateEnvValue('REDIS_URL', 'redis://localhost:6379')).toBe(true);
-            });
-        });
-
-        describe('Port validation', () => {
-            it('should reject negative ports', () => {
-                expect(validateEnvValue('PORT', '-1')).toBe(false);
-            });
-
-            it('should reject zero port', () => {
-                expect(validateEnvValue('PORT', '0')).toBe(false);
-            });
-
-            it('should reject ports > 65535', () => {
-                expect(validateEnvValue('PORT', '65536')).toBe(false);
-            });
-
-            it('should accept valid ports', () => {
-                expect(validateEnvValue('PORT', '3000')).toBe(true);
-                expect(validateEnvValue('API_PORT', '8080')).toBe(true);
-            });
-
-            it('should reject non-numeric ports', () => {
-                expect(validateEnvValue('PORT', 'abc')).toBe(false);
-            });
-        });
-
-        describe('Security fields validation', () => {
-            it('should reject short API keys', () => {
-                expect(validateEnvValue('API_KEY', 'short')).toBe(false);
-            });
-
-            it('should reject short passwords', () => {
-                expect(validateEnvValue('PASSWORD', '1234567')).toBe(false);
-            });
-
-            it('should reject short secrets', () => {
-                expect(validateEnvValue('AUTH_SECRET', 'abc')).toBe(false);
-            });
-
-            it('should accept API keys with 8+ characters', () => {
-                expect(validateEnvValue('API_KEY', 'verylongapikey123')).toBe(true);
-            });
-
-            it('should accept passwords with 8+ characters', () => {
-                expect(validateEnvValue('PASSWORD', 'password123')).toBe(true);
-            });
-        });
-
-        describe('General validation', () => {
-            it('should accept valid non-special values', () => {
-                expect(validateEnvValue('SOME_VAR', 'some-value')).toBe(true);
-            });
-        });
-    });
-
-    describe('validatePublicDomain', () => {
-        it('accepts valid public domains', () => {
-            expect(validatePublicDomain('example.com')).toBe(true);
-            expect(validatePublicDomain('app.example.com')).toBe(true);
-        });
-
-        it('rejects urls or malformed values', () => {
-            expect(validatePublicDomain('https://example.com')).not.toBe(true);
-            expect(validatePublicDomain('example')).not.toBe(true);
-            expect(validatePublicDomain('example.com/path')).not.toBe(true);
-        });
-    });
-
-    describe('validateEmailAddress', () => {
-        it('accepts valid email addresses', () => {
-            expect(validateEmailAddress('admin@example.com')).toBe(true);
-        });
-
-        it('rejects invalid email values', () => {
-            expect(validateEmailAddress('admin@')).not.toBe(true);
-            expect(validateEmailAddress('not-an-email')).not.toBe(true);
-        });
-    });
-});