@poetora/cli 0.1.8 → 0.1.10

package/src/commands/__tests__/base.command.test.ts

@@ -1,139 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { CliError, ValidationError } from '../../errors/index.js';
-import type { ILogger } from '../../utils/index.js';
-import { BaseCommand } from '../base.command.js';
-
-// Test command implementation
-class TestCommand extends BaseCommand {
-  readonly name = 'test';
-  readonly description = 'Test command';
-
-  public validateCalled = false;
-  public executeCalled = false;
-
-  protected override async validate(options: { value: string }): Promise<void> {
-    this.validateCalled = true;
-    if (!options.value) {
-      throw new ValidationError('value is required');
-    }
-  }
-
-  protected override async execute(options: { value: string }): Promise<string> {
-    this.executeCalled = true;
-    return `executed with ${options.value}`;
-  }
-}
-
-describe('BaseCommand', () => {
-  let mockLogger: ILogger;
-  let command: TestCommand;
-
-  beforeEach(() => {
-    mockLogger = {
-      info: vi.fn(),
-      success: vi.fn(),
-      error: vi.fn(),
-      warn: vi.fn(),
-      log: vi.fn(),
-      spinner: vi.fn(),
-      logColor: vi.fn(),
-      logBold: vi.fn(),
-      logSeparator: vi.fn(),
-      logNewLine: vi.fn(),
-      logHeader: vi.fn(),
-    };
-    command = new TestCommand(mockLogger);
-  });
-
-  describe('run', () => {
-    it('should execute command successfully', async () => {
-      const result = await command.run({ value: 'test' });
-
-      expect(command.validateCalled).toBe(true);
-      expect(command.executeCalled).toBe(true);
-      expect(result).toBe('executed with test');
-    });
-
-    it('should validate before execute', async () => {
-      const callOrder: string[] = [];
-
-      // Use type assertion to bypass protected access for testing
-      (command as unknown as { validate: typeof command.validate }).validate = vi.fn(async () => {
-        callOrder.push('validate');
-      });
-      (command as unknown as { execute: typeof command.execute }).execute = vi.fn(async () => {
-        callOrder.push('execute');
-        return 'result';
-      });
-
-      await command.run({ value: 'test' });
-
-      expect(callOrder).toEqual(['validate', 'execute']);
-    });
-
-    it('should handle validation errors', async () => {
-      await expect(command.run({ value: '' })).rejects.toThrow(ValidationError);
-
-      expect(command.validateCalled).toBe(true);
-      expect(command.executeCalled).toBe(false);
-      expect(mockLogger.error).toHaveBeenCalledWith('value is required');
-    });
-
-    it('should handle execution errors', async () => {
-      (command as unknown as { execute: typeof command.execute }).execute = vi
-        .fn()
-        .mockRejectedValue(new Error('execution failed'));
-
-      await expect(command.run({ value: 'test' })).rejects.toThrow('execution failed');
-
-      expect(mockLogger.error).toHaveBeenCalledWith('execution failed');
-    });
-
-    it('should handle CliError specially', async () => {
-      const cliError = new CliError('CLI error message', 'TEST_ERROR', 1);
-      (command as unknown as { execute: typeof command.execute }).execute = vi
-        .fn()
-        .mockRejectedValue(cliError);
-
-      await expect(command.run({ value: 'test' })).rejects.toThrow(cliError);
-
-      expect(mockLogger.error).toHaveBeenCalledWith('CLI error message');
-    });
-
-    it('should handle unknown errors', async () => {
-      (command as unknown as { execute: typeof command.execute }).execute = vi
-        .fn()
-        .mockRejectedValue('string error');
-
-      await expect(command.run({ value: 'test' })).rejects.toBe('string error');
-
-      expect(mockLogger.error).toHaveBeenCalledWith('An unexpected error occurred');
-      expect(mockLogger.logColor).toHaveBeenCalledWith('string error', 'gray');
-    });
-
-    it('should show stack trace in debug mode', async () => {
-      const originalDebug = process.env.DEBUG;
-      process.env.DEBUG = 'true';
-
-      const error = new Error('test error');
-      (command as unknown as { execute: typeof command.execute }).execute = vi
-        .fn()
-        .mockRejectedValue(error);
-
-      await expect(command.run({ value: 'test' })).rejects.toThrow(error);
-
-      expect(mockLogger.logColor).toHaveBeenCalledWith(error.stack ?? '', 'gray');
-      process.env.DEBUG = originalDebug;
-    });
-  });
-
-  describe('command metadata', () => {
-    it('should have name property', () => {
-      expect(command.name).toBe('test');
-    });
-
-    it('should have description property', () => {
-      expect(command.description).toBe('Test command');
-    });
-  });
-});

package/src/commands/__tests__/dev.command.test.ts

@@ -1,241 +0,0 @@
-import * as previewing from '@poetora/previewing';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { InvalidEnvironmentError } from '../../errors/index.js';
-import type { PortService, VersionService } from '../../services/index.js';
-import type { DevOptions } from '../../types/index.js';
-import type { ILogger } from '../../utils/index.js';
-import { DevCommand } from '../dev.command.js';
-
-vi.mock('@poetora/previewing', async () => {
-  const actual = await vi.importActual<typeof import('@poetora/previewing')>('@poetora/previewing');
-  return {
-    ...actual,
-    dev: vi.fn(),
-  };
-});
-
-describe('DevCommand', () => {
-  let mockLogger: ILogger;
-  let mockVersionService: VersionService;
-  let mockPortService: PortService;
-  let command: DevCommand;
-  const devSpy = vi.mocked(previewing.dev);
-
-  beforeEach(() => {
-    mockLogger = {
-      info: vi.fn(),
-      success: vi.fn(),
-      error: vi.fn(),
-      warn: vi.fn(),
-      log: vi.fn(),
-      spinner: vi.fn(),
-      logColor: vi.fn(),
-      logBold: vi.fn(),
-      logSeparator: vi.fn(),
-      logNewLine: vi.fn(),
-      logHeader: vi.fn(),
-    };
-
-    mockVersionService = {
-      checkNodeVersion: vi.fn(),
-      getCliVersion: vi.fn(),
-      parseNodeVersion: vi.fn(),
-      getClientVersion: vi.fn(),
-      getVersions: vi.fn(),
-      getLatestCliVersion: vi.fn(),
-      isVersionUpToDate: vi.fn(),
-      validateNodeVersion: vi.fn(),
-    } as unknown as VersionService;
-
-    mockPortService = {
-      findAvailablePort: vi.fn(),
-    } as unknown as PortService;
-
-    command = new DevCommand(mockLogger, mockVersionService, mockPortService, 'poet');
-
-    vi.clearAllMocks();
-  });
-
-  describe('validate', () => {
-    it('should pass validation for supported Node version', async () => {
-      vi.mocked(mockVersionService.checkNodeVersion).mockReturnValue({
-        isValid: true,
-        hasWarning: false,
-      });
-
-      await expect(command.validate({} as DevOptions)).resolves.not.toThrow();
-
-      expect(mockVersionService.checkNodeVersion).toHaveBeenCalled();
-    });
-
-    it('should show warning for below recommended version', async () => {
-      vi.mocked(mockVersionService.checkNodeVersion).mockReturnValue({
-        isValid: true,
-        hasWarning: true,
-        message: 'Node.js 20.17.0 recommended',
-      });
-
-      await command.validate({} as DevOptions);
-
-      expect(mockLogger.warn).toHaveBeenCalledWith('Node.js 20.17.0 recommended');
-    });
-
-    it('should throw error for unsupported Node version', async () => {
-      vi.mocked(mockVersionService.checkNodeVersion).mockReturnValue({
-        isValid: false,
-        hasWarning: false,
-        message: 'Node.js 18.0.0 or higher required',
-      });
-
-      await expect(command.validate({} as DevOptions)).rejects.toThrow(InvalidEnvironmentError);
-    });
-  });
-
-  describe('execute', () => {
-    it('should start dev server with default options', async () => {
-      vi.mocked(mockPortService.findAvailablePort).mockResolvedValue(3000);
-      vi.mocked(mockVersionService.getCliVersion).mockReturnValue('1.0.0');
-      devSpy.mockResolvedValue(undefined);
-
-      const options: DevOptions = {};
-
-      await command.execute(options);
-
-      expect(mockPortService.findAvailablePort).toHaveBeenCalledWith(undefined);
-      expect(mockVersionService.getCliVersion).toHaveBeenCalled();
-      expect(devSpy).toHaveBeenCalledWith({
-        _: [],
-        $0: 'poet',
-        port: 3000,
-        open: true,
-        localSchema: false,
-        clientVersion: undefined,
-        groups: undefined,
-        disableOpenapi: false,
-        packageName: 'poet',
-        cliVersion: '1.0.0',
-      });
-    });
-
-    it('should use specified port', async () => {
-      vi.mocked(mockPortService.findAvailablePort).mockResolvedValue(5000);
-      vi.mocked(mockVersionService.getCliVersion).mockReturnValue('1.0.0');
-      devSpy.mockResolvedValue(undefined);
-
-      const options: DevOptions = { port: 5000 };
-
-      await command.execute(options);
-
-      expect(mockPortService.findAvailablePort).toHaveBeenCalledWith(5000);
-      expect(devSpy).toHaveBeenCalledWith(
-        expect.objectContaining({
-          port: 5000,
-        })
-      );
-    });
-
-    it('should respect open option', async () => {
-      vi.mocked(mockPortService.findAvailablePort).mockResolvedValue(3000);
-      vi.mocked(mockVersionService.getCliVersion).mockReturnValue('1.0.0');
-      devSpy.mockResolvedValue(undefined);
-
-      const options: DevOptions = { open: false };
-
-      await command.execute(options);
-
-      expect(devSpy).toHaveBeenCalledWith(
-        expect.objectContaining({
-          open: false,
-        })
-      );
-    });
-
-    it('should pass all options correctly', async () => {
-      vi.mocked(mockPortService.findAvailablePort).mockResolvedValue(4000);
-      vi.mocked(mockVersionService.getCliVersion).mockReturnValue('2.0.0');
-      devSpy.mockResolvedValue(undefined);
-
-      const options: DevOptions = {
-        port: 4000,
-        open: false,
-        localSchema: true,
-        clientVersion: '1.5.0',
-        groups: ['admin', 'user'],
-        disableOpenapi: true,
-      };
-
-      await command.execute(options);
-
-      expect(devSpy).toHaveBeenCalledWith({
-        _: [],
-        $0: 'poet',
-        port: 4000,
-        open: false,
-        localSchema: true,
-        clientVersion: '1.5.0',
-        groups: ['admin', 'user'],
-        disableOpenapi: true,
-        packageName: 'poet',
-        cliVersion: '2.0.0',
-      });
-    });
-
-    it('should handle when port service finds alternative port', async () => {
-      vi.mocked(mockPortService.findAvailablePort).mockResolvedValue(3001);
-      vi.mocked(mockVersionService.getCliVersion).mockReturnValue('1.0.0');
-      devSpy.mockResolvedValue(undefined);
-
-      const options: DevOptions = { port: 3000 };
-
-      await command.execute(options);
-
-      expect(devSpy).toHaveBeenCalledWith(
-        expect.objectContaining({
-          port: 3001, // Alternative port found
-        })
-      );
-    });
-  });
-
-  describe('run (integration)', () => {
-    it('should execute full flow successfully', async () => {
-      vi.mocked(mockVersionService.checkNodeVersion).mockReturnValue({
-        isValid: true,
-        hasWarning: false,
-      });
-      vi.mocked(mockPortService.findAvailablePort).mockResolvedValue(3000);
-      vi.mocked(mockVersionService.getCliVersion).mockReturnValue('1.0.0');
-      devSpy.mockResolvedValue(undefined);
-
-      await command.run({ port: 3000 });
-
-      expect(mockVersionService.checkNodeVersion).toHaveBeenCalled();
-      expect(mockPortService.findAvailablePort).toHaveBeenCalled();
-      expect(devSpy).toHaveBeenCalled();
-    });
-
-    it('should fail at validation stage for unsupported Node version', async () => {
-      vi.mocked(mockVersionService.checkNodeVersion).mockReturnValue({
-        isValid: false,
-        hasWarning: false,
-        message: 'Unsupported Node.js version',
-      });
-
-      await expect(command.run({})).rejects.toThrow(InvalidEnvironmentError);
-
-      // Should not reach execute stage
-      expect(mockPortService.findAvailablePort).not.toHaveBeenCalled();
-      expect(devSpy).not.toHaveBeenCalled();
-    });
-  });
-
-  describe('metadata', () => {
-    it('should have correct name', () => {
-      expect(command.name).toBe('dev');
-    });
-
-    it('should have correct description', () => {
-      expect(command.description).toBe('initialize a local preview environment');
-    });
-  });
-});

package/src/commands/__tests__/init.command.test.ts

@@ -1,281 +0,0 @@
-import { input, select } from '@inquirer/prompts';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { ValidationError } from '../../errors/index.js';
-import type { TemplateService } from '../../services/template.service.js';
-import type { InitOptions } from '../../types/index.js';
-import type { ILogger } from '../../utils/index.js';
-import { InitCommand } from '../init.command.js';
-
-vi.mock('@inquirer/prompts');
-
-describe('InitCommand', () => {
-  let command: InitCommand;
-  let mockLogger: ILogger;
-  let mockTemplateService: TemplateService;
-
-  beforeEach(() => {
-    mockLogger = {
-      info: vi.fn(),
-      success: vi.fn(),
-      error: vi.fn(),
-      warn: vi.fn(),
-      spinner: vi.fn().mockReturnValue({
-        start: vi.fn(),
-        succeed: vi.fn(),
-        fail: vi.fn(),
-        stop: vi.fn(),
-      }),
-      log: vi.fn(),
-      logColor: vi.fn(),
-      logBold: vi.fn(),
-      logSeparator: vi.fn(),
-      logNewLine: vi.fn(),
-      logHeader: vi.fn(),
-    };
-
-    mockTemplateService = {
-      checkDirectory: vi.fn(),
-      getAvailableThemes: vi.fn(),
-      installTemplate: vi.fn(),
-    } as unknown as TemplateService;
-
-    command = new InitCommand(mockLogger, mockTemplateService);
-  });
-
-  afterEach(() => {
-    vi.clearAllMocks();
-  });
-
-  describe('run - empty directory', () => {
-    beforeEach(() => {
-      vi.mocked(mockTemplateService.checkDirectory).mockResolvedValue({
-        exists: true,
-        hasContents: false,
-      });
-
-      vi.mocked(mockTemplateService.getAvailableThemes).mockReturnValue(['ora', 'sol']);
-
-      vi.mocked(input).mockResolvedValue('My Project');
-      vi.mocked(select).mockResolvedValue('ora');
-      vi.mocked(mockTemplateService.installTemplate).mockResolvedValue(undefined);
-    });
-
-    it('should install template directly for empty directory', async () => {
-      const options: InitOptions = {
-        directory: '.',
-      };
-
-      await command.run(options);
-
-      expect(mockTemplateService.checkDirectory).toHaveBeenCalledWith('.');
-      expect(input).toHaveBeenCalled();
-      expect(select).toHaveBeenCalled();
-      expect(mockTemplateService.installTemplate).toHaveBeenCalledWith({
-        directory: '.',
-        projectName: 'My Project',
-        theme: 'ora',
-      });
-      expect(mockLogger.success).toHaveBeenCalledWith('Documentation Setup!');
-    });
-
-    it('should use directory name as default project name', async () => {
-      vi.mocked(input).mockResolvedValue('my-docs');
-
-      const options: InitOptions = {
-        directory: 'my-docs',
-      };
-
-      await command.run(options);
-
-      expect(input).toHaveBeenCalledWith({
-        message: 'Project Name',
-        default: 'my-docs',
-      });
-    });
-
-    it('should use "Poetora" as default for current directory', async () => {
-      vi.mocked(input).mockResolvedValue('Poetora');
-
-      const options: InitOptions = {
-        directory: '.',
-      };
-
-      await command.run(options);
-
-      expect(input).toHaveBeenCalledWith({
-        message: 'Project Name',
-        default: 'Poetora',
-      });
-    });
-  });
-
-  describe('run - non-empty directory', () => {
-    beforeEach(() => {
-      vi.mocked(mockTemplateService.checkDirectory).mockResolvedValue({
-        exists: true,
-        hasContents: true,
-      });
-
-      vi.mocked(mockTemplateService.getAvailableThemes).mockReturnValue(['quartz']);
-      vi.mocked(input).mockResolvedValue('My Project');
-      vi.mocked(mockTemplateService.installTemplate).mockResolvedValue(undefined);
-    });
-
-    it('should cancel installation when user chooses cancel', async () => {
-      vi.mocked(select).mockResolvedValueOnce('cancel');
-
-      const options: InitOptions = {
-        directory: 'existing-dir',
-      };
-
-      await command.run(options);
-
-      expect(mockLogger.info).toHaveBeenCalledWith('Installation cancelled');
-      expect(mockTemplateService.installTemplate).not.toHaveBeenCalled();
-    });
-
-    it('should overwrite when user chooses overwrite', async () => {
-      vi.mocked(select)
-        .mockResolvedValueOnce('overwrite') // directory choice
-        .mockResolvedValueOnce('ora'); // theme choice
-
-      const options: InitOptions = {
-        directory: 'existing-dir',
-      };
-
-      await command.run(options);
-
-      expect(mockTemplateService.installTemplate).toHaveBeenCalledWith({
-        directory: 'existing-dir',
-        projectName: 'My Project',
-        theme: 'ora',
-      });
-    });
-
-    it('should create subdirectory when user chooses subdir', async () => {
-      vi.mocked(select)
-        .mockResolvedValueOnce('subdir') // directory choice
-        .mockResolvedValueOnce('ora'); // theme choice
-
-      vi.mocked(input)
-        .mockResolvedValueOnce('docs') // subdirectory name
-        .mockResolvedValueOnce('My Project'); // project name
-
-      const options: InitOptions = {
-        directory: '.',
-      };
-
-      await command.run(options);
-
-      expect(input).toHaveBeenCalledWith({
-        message: 'Subdirectory name:',
-        default: 'docs',
-      });
-
-      expect(mockTemplateService.installTemplate).toHaveBeenCalledWith({
-        directory: 'docs',
-        projectName: 'My Project',
-        theme: 'ora',
-      });
-    });
-
-    it('should combine parent dir with subdir when not current directory', async () => {
-      vi.mocked(select).mockResolvedValueOnce('subdir').mockResolvedValueOnce('ora');
-
-      vi.mocked(input).mockResolvedValueOnce('docs').mockResolvedValueOnce('My Project');
-
-      const options: InitOptions = {
-        directory: 'parent',
-      };
-
-      await command.run(options);
-
-      expect(mockTemplateService.installTemplate).toHaveBeenCalledWith({
-        directory: 'parent/docs',
-        projectName: 'My Project',
-        theme: 'ora',
-      });
-    });
-
-    it('should throw ValidationError for empty subdirectory name', async () => {
-      vi.mocked(select).mockResolvedValue('subdir');
-      vi.mocked(input).mockResolvedValue('   '); // empty with spaces
-
-      const options: InitOptions = {
-        directory: '.',
-      };
-
-      await expect(command.run(options)).rejects.toThrow(ValidationError);
-      await expect(command.run(options)).rejects.toThrow('Subdirectory name cannot be empty');
-    });
-  });
-
-  describe('theme selection', () => {
-    beforeEach(() => {
-      vi.mocked(mockTemplateService.checkDirectory).mockResolvedValue({
-        exists: true,
-        hasContents: false,
-      });
-
-      vi.mocked(input).mockResolvedValue('My Project');
-      vi.mocked(mockTemplateService.installTemplate).mockResolvedValue(undefined);
-    });
-
-    it('should display all available themes', async () => {
-      vi.mocked(mockTemplateService.getAvailableThemes).mockReturnValue(['ora', 'sol', 'custom']);
-
-      vi.mocked(select).mockResolvedValue('sol');
-
-      const options: InitOptions = {
-        directory: '.',
-      };
-
-      await command.run(options);
-
-      expect(select).toHaveBeenCalledWith({
-        message: 'Theme',
-        choices: [
-          { name: 'ora', value: 'ora' },
-          { name: 'sol', value: 'sol' },
-          { name: 'custom', value: 'custom' },
-        ],
-      });
-    });
-  });
-
-  describe('onboarding message', () => {
-    beforeEach(() => {
-      vi.mocked(mockTemplateService.checkDirectory).mockResolvedValue({
-        exists: true,
-        hasContents: false,
-      });
-
-      vi.mocked(mockTemplateService.getAvailableThemes).mockReturnValue(['ora']);
-      vi.mocked(input).mockResolvedValue('My Project');
-      vi.mocked(select).mockResolvedValue('ora');
-      vi.mocked(mockTemplateService.installTemplate).mockResolvedValue(undefined);
-    });
-
-    it('should show cd command for subdirectory installation', async () => {
-      const options: InitOptions = {
-        directory: 'docs',
-      };
-
-      await command.run(options);
-
-      expect(mockLogger.log).toHaveBeenCalledWith('  cd docs');
-      expect(mockLogger.log).toHaveBeenCalledWith('  poet dev');
-    });
-
-    it('should not show cd command for current directory', async () => {
-      const options: InitOptions = {
-        directory: '.',
-      };
-
-      await command.run(options);
-
-      expect(mockLogger.log).not.toHaveBeenCalledWith(expect.stringContaining('cd'));
-      expect(mockLogger.log).toHaveBeenCalledWith('  poet dev');
-    });
-  });
-});

package/src/commands/__tests__/utils.ts

@@ -1,20 +0,0 @@
-import { cli } from '../../cli';
-
-/**
- * Programmatically set arguments and execute the CLI script
- *
- * @param {...string} args - Additional command arguments.
- */
-export async function runCommand(...args: string[]) {
-  process.argv = ['node', 'cli', ...args];
-  return cli({ packageName: 'poet' });
-}
-
-export const mockValidOpenApiDocument = {
-  openapi: '3.0.0',
-  info: {
-    title: 'Test API',
-    version: '1.0.0',
-  },
-  components: {},
-};