create-ripple 0.1.0

package/tests/unit/prompts.test.js

@@ -0,0 +1,207 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import * as prompts from 'prompts';
+
+// Mock prompts module
+vi.mock('prompts', () => ({
+	default: vi.fn()
+}));
+
+// Mock kleur colors
+vi.mock('kleur/colors', () => ({
+	red: vi.fn((text) => text)
+}));
+
+// Mock process.exit
+const mockExit = vi.fn();
+Object.defineProperty(process, 'exit', {
+	value: mockExit,
+	writable: true
+});
+
+// Mock console.log
+const mockConsoleLog = vi.fn();
+global.console = { ...console, log: mockConsoleLog };
+
+import {
+	promptProjectName,
+	promptTemplate,
+	promptOverwrite,
+	promptPackageManager,
+	promptTypeScript,
+	promptGitInit
+} from '../../src/lib/prompts.js';
+
+describe('Prompts', () => {
+	beforeEach(() => {
+		vi.clearAllMocks();
+	});
+
+	afterEach(() => {
+		vi.resetAllMocks();
+	});
+
+	describe('promptProjectName', () => {
+		it('should return project name when valid input provided', async () => {
+			prompts.default.mockResolvedValue({ projectName: 'my-app' });
+
+			const result = await promptProjectName();
+			expect(result).toBe('my-app');
+			expect(prompts.default).toHaveBeenCalledWith({
+				type: 'text',
+				name: 'projectName',
+				message: 'What is your project named?',
+				initial: 'my-ripple-app',
+				validate: expect.any(Function)
+			});
+		});
+
+		it('should use custom default name', async () => {
+			prompts.default.mockResolvedValue({ projectName: 'custom-app' });
+
+			await promptProjectName('custom-default');
+			expect(prompts.default).toHaveBeenCalledWith(
+				expect.objectContaining({
+					initial: 'custom-default'
+				})
+			);
+		});
+
+		it('should exit when user cancels', async () => {
+			prompts.default.mockResolvedValue({});
+
+			await promptProjectName();
+			expect(mockExit).toHaveBeenCalledWith(1);
+			expect(mockConsoleLog).toHaveBeenCalledWith('✖ Operation cancelled');
+		});
+
+		it('should validate project name input', async () => {
+			prompts.default.mockResolvedValue({ projectName: 'valid-name' });
+
+			await promptProjectName();
+			const call = prompts.default.mock.calls[0][0];
+			const validate = call.validate;
+
+			expect(validate('valid-name')).toBe(true);
+			expect(validate('Invalid Name!')).toBe(
+				'Project name can only contain lowercase letters, numbers, hyphens, dots, and underscores'
+			);
+		});
+	});
+
+	describe('promptTemplate', () => {
+		it('should return selected template', async () => {
+			prompts.default.mockResolvedValue({ template: 'basic' });
+
+			const result = await promptTemplate();
+			expect(result).toBe('basic');
+			expect(prompts.default).toHaveBeenCalledWith({
+				type: 'select',
+				name: 'template',
+				message: 'Which template would you like to use?',
+				choices: expect.any(Array),
+				initial: 0
+			});
+		});
+
+		it('should exit when user cancels', async () => {
+			prompts.default.mockResolvedValue({});
+
+			await promptTemplate();
+			expect(mockExit).toHaveBeenCalledWith(1);
+			expect(mockConsoleLog).toHaveBeenCalledWith('✖ Operation cancelled');
+		});
+	});
+
+	describe('promptOverwrite', () => {
+		it('should return overwrite decision', async () => {
+			prompts.default.mockResolvedValue({ overwrite: true });
+
+			const result = await promptOverwrite('test-project');
+			expect(result).toBe(true);
+			expect(prompts.default).toHaveBeenCalledWith({
+				type: 'confirm',
+				name: 'overwrite',
+				message: 'Directory "test-project" already exists. Continue anyway?',
+				initial: false
+			});
+		});
+
+		it('should exit when user cancels', async () => {
+			prompts.default.mockResolvedValue({});
+
+			await promptOverwrite('test-project');
+			expect(mockExit).toHaveBeenCalledWith(1);
+		});
+	});
+
+	describe('promptPackageManager', () => {
+		it('should return selected package manager', async () => {
+			prompts.default.mockResolvedValue({ packageManager: 'pnpm' });
+
+			const result = await promptPackageManager();
+			expect(result).toBe('pnpm');
+			expect(prompts.default).toHaveBeenCalledWith({
+				type: 'select',
+				name: 'packageManager',
+				message: 'Which package manager would you like to use?',
+				choices: [
+					{ title: 'npm', value: 'npm', description: 'Use npm for dependency management' },
+					{ title: 'yarn', value: 'yarn', description: 'Use Yarn for dependency management' },
+					{ title: 'pnpm', value: 'pnpm', description: 'Use pnpm for dependency management' }
+				],
+				initial: 0
+			});
+		});
+
+		it('should exit when user cancels', async () => {
+			prompts.default.mockResolvedValue({});
+
+			await promptPackageManager();
+			expect(mockExit).toHaveBeenCalledWith(1);
+		});
+	});
+
+	describe('promptTypeScript', () => {
+		it('should return TypeScript preference', async () => {
+			prompts.default.mockResolvedValue({ typescript: false });
+
+			const result = await promptTypeScript();
+			expect(result).toBe(false);
+			expect(prompts.default).toHaveBeenCalledWith({
+				type: 'confirm',
+				name: 'typescript',
+				message: 'Would you like to use TypeScript?',
+				initial: true
+			});
+		});
+
+		it('should exit when user cancels', async () => {
+			prompts.default.mockResolvedValue({});
+
+			await promptTypeScript();
+			expect(mockExit).toHaveBeenCalledWith(1);
+		});
+	});
+
+	describe('promptGitInit', () => {
+		it('should return Git initialization preference', async () => {
+			prompts.default.mockResolvedValue({ gitInit: false });
+
+			const result = await promptGitInit();
+			expect(result).toBe(false);
+			expect(prompts.default).toHaveBeenCalledWith({
+				type: 'confirm',
+				name: 'gitInit',
+				message: 'Initialize a new Git repository?',
+				initial: true
+			});
+		});
+
+		it('should exit when user cancels', async () => {
+			prompts.default.mockResolvedValue({});
+
+			await promptGitInit();
+			expect(mockExit).toHaveBeenCalledWith(1);
+		});
+	});
+});

package/tests/unit/templates.test.js

@@ -0,0 +1,163 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { existsSync } from 'node:fs';
+import {
+	getTemplate,
+	getTemplateNames,
+	getTemplateChoices,
+	validateTemplate,
+	getTemplatePath,
+} from '../../src/lib/templates.js';
+
+// Mock the constants
+vi.mock('../../src/constants.js', () => ({
+	TEMPLATES: [
+		{
+			name: 'basic',
+			display: 'Basic Ripple App',
+			description: 'A minimal Ripple application with Vite and TypeScript'
+		},
+		{
+			name: 'advanced',
+			display: 'Advanced Ripple App',
+			description: 'A full-featured Ripple application'
+		}
+	],
+	TEMPLATES_DIR: '/mock/templates'
+}));
+
+// Mock fs.existsSync - ensure consistent behavior across environments
+vi.mock('node:fs', () => {
+	const mockFn = vi.fn();
+	return {
+		default: {
+			existsSync: mockFn
+		},
+		existsSync: mockFn
+	};
+});
+
+describe('getTemplate', () => {
+	it('should return template by name', () => {
+		const template = getTemplate('basic');
+		expect(template).toEqual({
+			name: 'basic',
+			display: 'Basic Ripple App',
+			description: 'A minimal Ripple application with Vite and TypeScript'
+		});
+	});
+
+	it('should return null for non-existent template', () => {
+		const template = getTemplate('non-existent');
+		expect(template).toBeNull();
+	});
+
+	it('should return null for undefined template name', () => {
+		const template = getTemplate();
+		expect(template).toBeNull();
+	});
+});
+
+describe('getTemplateNames', () => {
+	it('should return array of template names', () => {
+		const names = getTemplateNames();
+		expect(names).toEqual(['basic', 'advanced']);
+	});
+
+	it('should return array even if no templates exist', () => {
+		const names = getTemplateNames();
+		expect(Array.isArray(names)).toBe(true);
+	});
+});
+
+describe('getTemplateChoices', () => {
+	it('should return formatted choices for prompts', () => {
+		const choices = getTemplateChoices();
+		expect(choices).toEqual([
+			{
+				title: 'Basic Ripple App',
+				description: 'A minimal Ripple application with Vite and TypeScript',
+				value: 'basic'
+			},
+			{
+				title: 'Advanced Ripple App',
+				description: 'A full-featured Ripple application',
+				value: 'advanced'
+			}
+		]);
+	});
+
+	it('should return array even if templates are defined', () => {
+		const choices = getTemplateChoices();
+		expect(Array.isArray(choices)).toBe(true);
+		expect(choices.length).toBeGreaterThan(0);
+	});
+});
+
+describe('validateTemplate', () => {
+	beforeEach(() => {
+		vi.clearAllMocks();
+		// Reset the mock to a default state for CI compatibility
+		const mockExistsSync = vi.mocked(existsSync);
+		mockExistsSync.mockReturnValue(false);
+	});
+
+	it('should return true for valid existing template', () => {
+		const mockExistsSync = vi.mocked(existsSync);
+		mockExistsSync.mockReturnValue(true);
+		const isValid = validateTemplate('basic');
+		expect(isValid).toBe(true);
+		expect(mockExistsSync).toHaveBeenCalledWith('/mock/templates/basic');
+	});
+
+	it('should return false for valid template that does not exist on filesystem', () => {
+		const mockExistsSync = vi.mocked(existsSync);
+		mockExistsSync.mockReturnValue(false);
+		const isValid = validateTemplate('basic');
+		expect(isValid).toBe(false);
+	});
+
+	it('should return false for invalid template name', () => {
+		const mockExistsSync = vi.mocked(existsSync);
+		const isValid = validateTemplate('non-existent');
+		expect(isValid).toBe(false);
+		expect(mockExistsSync).not.toHaveBeenCalled();
+	});
+
+	it('should return false for undefined template name', () => {
+		const mockExistsSync = vi.mocked(existsSync);
+		const isValid = validateTemplate();
+		expect(isValid).toBe(false);
+		expect(mockExistsSync).not.toHaveBeenCalled();
+	});
+
+	it('should return false for null template name', () => {
+		const mockExistsSync = vi.mocked(existsSync);
+		const isValid = validateTemplate(null);
+		expect(isValid).toBe(false);
+		expect(mockExistsSync).not.toHaveBeenCalled();
+	});
+
+	it('should return false for empty string template name', () => {
+		const mockExistsSync = vi.mocked(existsSync);
+		const isValid = validateTemplate('');
+		expect(isValid).toBe(false);
+		expect(mockExistsSync).not.toHaveBeenCalled();
+	});
+});
+
+describe('getTemplatePath', () => {
+	it('should return correct template path', () => {
+		const path = getTemplatePath('basic');
+		expect(path).toBe('/mock/templates/basic');
+	});
+
+	it('should return path even for non-existent template', () => {
+		const path = getTemplatePath('non-existent');
+		expect(path).toBe('/mock/templates/non-existent');
+	});
+
+	it('should handle special characters in template name', () => {
+		const path = getTemplatePath('my-template.name');
+		expect(path).toBe('/mock/templates/my-template.name');
+	});
+});

package/tests/unit/validation.test.js

@@ -0,0 +1,192 @@
+import { describe, it, expect } from 'vitest';
+import { validateProjectName, sanitizeDirectoryName, validateDirectoryPath } from '../../src/lib/validation.js';
+
+describe('validateProjectName', () => {
+	it('should validate correct project names', () => {
+		const validNames = [
+			'my-app',
+			'my.app',
+			'my_app',
+			'myapp',
+			'my-awesome-app',
+			'app123',
+			'a',
+			'a'.repeat(214) // max length
+		];
+
+		validNames.forEach(name => {
+			const result = validateProjectName(name);
+			expect(result.valid).toBe(true);
+			expect(result.message).toBe('');
+		});
+	});
+
+	it('should reject invalid project names', () => {
+		const invalidCases = [
+			{ name: '', expectedMessage: 'Project name cannot be empty' },
+			{ name: '   ', expectedMessage: 'Project name cannot be empty' },
+			{ name: null, expectedMessage: 'Project name is required' },
+			{ name: undefined, expectedMessage: 'Project name is required' },
+			{ name: 123, expectedMessage: 'Project name is required' },
+			{ name: 'a'.repeat(215), expectedMessage: 'Project name must be less than 214 characters' }
+		];
+
+		invalidCases.forEach(({ name, expectedMessage }) => {
+			const result = validateProjectName(name);
+			expect(result.valid).toBe(false);
+			expect(result.message).toBe(expectedMessage);
+		});
+	});
+
+	it('should reject names with invalid characters', () => {
+		const invalidNames = [
+			'My-App', // uppercase
+			'my app', // space
+			'my@app', // special character
+			'my/app', // slash
+			'my\\app', // backslash
+			'my:app', // colon
+			'my*app', // asterisk
+			'my?app', // question mark
+			'my"app', // quote
+			'my<app', // less than
+			'my>app' // greater than
+		];
+
+		invalidNames.forEach(name => {
+			const result = validateProjectName(name);
+			expect(result.valid).toBe(false);
+			expect(result.message).toBe(
+				'Project name can only contain lowercase letters, numbers, hyphens, dots, and underscores'
+			);
+		});
+	});
+
+	it('should reject names starting with dot or underscore', () => {
+		const invalidNames = ['.my-app', '_my-app'];
+
+		invalidNames.forEach(name => {
+			const result = validateProjectName(name);
+			expect(result.valid).toBe(false);
+			expect(result.message).toBe('Project name cannot start with a dot or underscore');
+		});
+	});
+
+	it('should reject names ending with dot', () => {
+		const result = validateProjectName('my-app.');
+		expect(result.valid).toBe(false);
+		expect(result.message).toBe('Project name cannot end with a dot');
+	});
+
+	it('should reject names with consecutive dots', () => {
+		const result = validateProjectName('my..app');
+		expect(result.valid).toBe(false);
+		expect(result.message).toBe('Project name cannot contain consecutive dots');
+	});
+
+	it('should reject reserved names', () => {
+		const reservedNames = [
+			'node_modules',
+			'favicon.ico',
+			'con',
+			'prn',
+			'aux',
+			'nul',
+			'com1',
+			'com2',
+			'lpt1',
+			'lpt9'
+		];
+
+		reservedNames.forEach(name => {
+			const result = validateProjectName(name);
+			expect(result.valid).toBe(false);
+			expect(result.message).toBe(`"${name}" is a reserved name and cannot be used`);
+		});
+	});
+
+	it('should handle case insensitive reserved names', () => {
+		const result = validateProjectName('con'); // use lowercase since validation requires lowercase
+		expect(result.valid).toBe(false);
+		expect(result.message).toBe('"con" is a reserved name and cannot be used');
+	});
+});
+
+describe('sanitizeDirectoryName', () => {
+	it('should sanitize directory names correctly', () => {
+		const testCases = [
+			{ input: 'My App', expected: 'my-app' },
+			{ input: 'my@app#name', expected: 'my-app-name' },
+			{ input: '---my-app---', expected: 'my-app' },
+			{ input: 'my___app', expected: 'my-app' },
+			{ input: 'MY-APP', expected: 'my-app' },
+			{ input: 'app123!@#', expected: 'app123' },
+			{ input: '   spaces   ', expected: 'spaces' },
+			{ input: 'special$%^chars', expected: 'special-chars' }
+		];
+
+		testCases.forEach(({ input, expected }) => {
+			const result = sanitizeDirectoryName(input);
+			expect(result).toBe(expected);
+		});
+	});
+
+	it('should handle edge cases', () => {
+		expect(sanitizeDirectoryName('')).toBe('');
+		expect(sanitizeDirectoryName('---')).toBe('');
+		expect(sanitizeDirectoryName('123')).toBe('123');
+		expect(sanitizeDirectoryName('a')).toBe('a');
+	});
+});
+
+describe('validateDirectoryPath', () => {
+	it('should validate correct directory paths', () => {
+		const validPaths = [
+			'my-app',
+			'./my-app',
+			'../my-app',
+			'path/to/my-app',
+			'/home/user/projects/my-app'
+		];
+
+		validPaths.forEach(path => {
+			const result = validateDirectoryPath(path);
+			expect(result.valid).toBe(true);
+			expect(result.message).toBe('');
+		});
+	});
+
+	it('should reject invalid directory paths', () => {
+		const invalidCases = [
+			{ path: '', expectedMessage: 'Directory path is required' },
+			{ path: null, expectedMessage: 'Directory path is required' },
+			{ path: undefined, expectedMessage: 'Directory path is required' },
+			{ path: 123, expectedMessage: 'Directory path is required' },
+			{ path: '/', expectedMessage: 'Cannot create project in root directory' }
+		];
+
+		invalidCases.forEach(({ path, expectedMessage }) => {
+			const result = validateDirectoryPath(path);
+			expect(result.valid).toBe(false);
+			expect(result.message).toBe(expectedMessage);
+		});
+	});
+
+	it('should reject paths with invalid characters', () => {
+		const invalidPaths = [
+			'my<app',
+			'my>app',
+			'my:app',
+			'my"app',
+			'my|app',
+			'my?app',
+			'my*app'
+		];
+
+		invalidPaths.forEach(path => {
+			const result = validateDirectoryPath(path);
+			expect(result.valid).toBe(false);
+			expect(result.message).toBe('Directory path contains invalid characters');
+		});
+	});
+});

package/vitest.config.js

@@ -0,0 +1,22 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+	test: {
+		include: ['tests/**/*.test.js'],
+		environment: 'node',
+		globals: true,
+		coverage: {
+			provider: 'v8',
+			reporter: ['text', 'json', 'html'],
+			exclude: [
+				'node_modules/',
+				'tests/',
+				'coverage/',
+				'**/*.test.js',
+				'**/*.config.js'
+			]
+		},
+		testTimeout: 30000, // 30 seconds for integration tests
+		hookTimeout: 10000 // 10 seconds for setup/teardown
+	}
+});