@rsdk/cli.core 5.7.0-next.2 → 6.0.0-next.0

package/test/commands/command.with-all.ts

@@ -0,0 +1,93 @@
+import {
+  Command,
+  CommandVariation,
+  IRunnable,
+  Option,
+  ValueOption,
+  SubCommand,
+} from '@rsdk/cli.common';
+import { StringParser } from '@rsdk/common';
+import { LoggerFactory } from '@rsdk/logging';
+
+@SubCommand('first-subcommand', {
+  description: 'First subcommand example',
+})
+class FirstSubCommand implements IRunnable {
+  async run(
+    @Option('flag', { description: 'test flag option' })
+    flag: boolean,
+  ): Promise<void> {
+    const logger = LoggerFactory.create(FirstSubCommand);
+
+    logger.info(`First subcommand executed with flag: ${flag}`);
+  }
+}
+
+@SubCommand('second-subcommand', {
+  description: 'Second subcommand example',
+})
+class SecondSubCommand implements IRunnable {
+  async run(
+    @ValueOption('value', new StringParser(), {
+      description: 'test value option',
+      defaultValue: 'test',
+    })
+    value: string,
+
+    @Option('flag', { description: 'test flag option' })
+    flag: boolean,
+  ): Promise<void> {
+    const logger = LoggerFactory.create(SecondSubCommand);
+
+    logger.info(
+      `Second subcommand executed with value: ${value} and flag: ${flag}`,
+    );
+  }
+}
+
+@CommandVariation('with-variations:first', {
+  description: 'First variation example',
+})
+class FirstVariation implements IRunnable {
+  async run(
+    @Option('flag', { description: 'test flag option' })
+    flag: boolean,
+  ): Promise<void> {
+    const logger = LoggerFactory.create(WithAll);
+
+    logger.info(`First variation executed with flag: ${flag}`);
+  }
+}
+
+@CommandVariation('with-variations:second', {
+  description: 'Second variation example',
+})
+class SecondVariation implements IRunnable {
+  async run(
+    @ValueOption('value', new StringParser(), {
+      description: 'test value option',
+      defaultValue: 'test',
+    })
+    value: string,
+
+    @Option('flag', { description: 'test flag option' })
+    flag: boolean,
+  ): Promise<void> {
+    const logger = LoggerFactory.create(WithAll);
+
+    logger.info(
+      `Second variation executed with value: ${value} and flag: ${flag}`,
+    );
+  }
+}
+
+@Command('with-all', {
+  description: 'Test command with subcommands and variations',
+  subcommands: [FirstSubCommand, SecondSubCommand],
+  variations: [FirstVariation, SecondVariation],
+})
+export default class WithAll implements IRunnable {
+  async run(): Promise<void> {
+    console.log('Main command executed');
+  }
+}

package/test/commands/command.with-subcommands.ts

@@ -0,0 +1,55 @@
+import {
+  Command,
+  IRunnable,
+  Option,
+  ValueOption,
+  SubCommand,
+} from '@rsdk/cli.common';
+import { StringParser } from '@rsdk/common';
+import { LoggerFactory } from '@rsdk/logging';
+
+@SubCommand('first', {
+  description: 'First subcommand example',
+})
+class FirstSubCommand implements IRunnable {
+  async run(
+    @Option('flag', { description: 'test flag option' })
+    flag: boolean,
+  ): Promise<void> {
+    const logger = LoggerFactory.create(WithSubCommands);
+
+    logger.info(`First subcommand executed with flag: ${flag}`);
+  }
+}
+
+@SubCommand('subcommand-1', {
+  description: 'Second subcommand example',
+})
+class SecondSubCommand implements IRunnable {
+  async run(
+    @ValueOption('value', new StringParser(), {
+      description: 'test value option',
+      defaultValue: 'test',
+    })
+    value: string,
+
+    @Option('flag', { description: 'test flag option' })
+    flag: boolean,
+  ): Promise<void> {
+    const logger = LoggerFactory.create(WithSubCommands);
+
+    logger.info(
+      `Second subcommand executed with value: ${value} and flag: ${flag}`,
+    );
+  }
+}
+
+@Command('with-subcommands', {
+  description: 'Test command with subcommands',
+  subcommands: [FirstSubCommand, SecondSubCommand],
+})
+export default class WithSubCommands implements IRunnable {
+  async run(): Promise<void> {
+    console.log('Main command executed');
+  }
+}

package/test/commands/command.with-variations.ts

@@ -0,0 +1,55 @@
+import {
+  Command,
+  CommandVariation,
+  IRunnable,
+  Option,
+  ValueOption,
+} from '@rsdk/cli.common';
+import { StringParser } from '@rsdk/common';
+import { LoggerFactory } from '@rsdk/logging';
+
+@CommandVariation('with-variations:first', {
+  description: 'First variation example',
+})
+class FirstVariation implements IRunnable {
+  async run(
+    @Option('flag', { description: 'test flag option' })
+    flag: boolean,
+  ): Promise<void> {
+    const logger = LoggerFactory.create(WithVariations);
+
+    logger.info(`First subcommand executed with flag: ${flag}`);
+  }
+}
+
+@CommandVariation('with-variations:second', {
+  description: 'Second variation example',
+})
+class SecondVariation implements IRunnable {
+  async run(
+    @ValueOption('value', new StringParser(), {
+      description: 'test value option',
+      defaultValue: 'test',
+    })
+    value: string,
+
+    @Option('flag', { description: 'test flag option' })
+    flag: boolean,
+  ): Promise<void> {
+    const logger = LoggerFactory.create(WithVariations);
+
+    logger.info(
+      `Second subcommand executed with value: ${value} and flag: ${flag}`,
+    );
+  }
+}
+
+@Command('with-variations', {
+  description: 'Test command with subcommands',
+  variations: [FirstVariation, SecondVariation],
+})
+export default class WithVariations implements IRunnable {
+  async run(): Promise<void> {
+    console.log('Main command executed');
+  }
+}

package/test/commands/js/command.single.js

@@ -0,0 +1,47 @@
+/* eslint-disable unicorn/no-abusive-eslint-disable */
+/* eslint-disable */
+
+'use strict';
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var SingleCommand_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+const cli_common_1 = require("@rsdk/cli.common");
+const common_1 = require("@rsdk/common");
+const logging_1 = require("@rsdk/logging");
+let SingleCommand = SingleCommand_1 = class SingleCommand {
+    async execute(message, verbose) {
+        const logger = logging_1.LoggerFactory.create(SingleCommand_1);
+        if (verbose) {
+            logger.info('Command parameters:');
+            logger.info(`message: ${message}`);
+            logger.info(`verbose: ${verbose}`);
+        }
+        logger.info(message);
+    }
+};
+__decorate([
+    __param(0, (0, cli_common_1.ValueOption)('message', new common_1.StringParser(), {
+        description: 'Message to log',
+        defaultValue: 'Hello World!',
+        alias: 'm',
+    })),
+    __param(1, (0, cli_common_1.Option)('verbose', { description: 'Verbose output' })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Boolean]),
+    __metadata("design:returntype", Promise)
+], SingleCommand.prototype, "execute", null);
+SingleCommand = SingleCommand_1 = __decorate([
+    (0, cli_common_1.Command)('single-command', 'Test command that logs parameters')
+], SingleCommand);
+exports.default = SingleCommand;

package/test/commands-resolver.spec.ts

@@ -0,0 +1,125 @@
+import { MetadataRegistry } from '@rsdk/cli.common';
+import type { ILogger } from '@rsdk/logging';
+import { Command } from 'commander';
+
+import { CommandResolver } from '../src/resolvers/command.resolver';
+import { OptionsResolver } from '../src/resolvers/options.resolver';
+
+import SingleCommand from './commands/command.single';
+import WithSubCommands from './commands/command.with-subcommands';
+
+describe('CommandResolver', () => {
+  let commandResolver: CommandResolver;
+  let logger: ILogger;
+  let mockEnv: any;
+
+  beforeEach(() => {
+    logger = { trace: jest.fn(), warn: jest.fn() } as any;
+    mockEnv = {
+      optional: jest.fn(),
+      required: jest.fn(),
+      isSet: jest.fn(),
+    };
+
+    const optionsResolver = new OptionsResolver(mockEnv, logger);
+
+    commandResolver = new CommandResolver(optionsResolver, logger);
+
+    jest.clearAllMocks();
+  });
+
+  afterEach(() => {
+    mockEnv.optional.mockClear();
+    mockEnv.required.mockClear();
+    mockEnv.isSet.mockClear();
+  });
+
+  describe('resolve', () => {
+    it('should create basic command without options', () => {
+      // Act
+      const result = commandResolver.resolve(SingleCommand);
+
+      // Assert
+      expect(result).toBeInstanceOf(Command);
+      const metadata = MetadataRegistry.getCommand(SingleCommand);
+
+      expect(metadata).toBeDefined();
+      expect(result.name()).toBe(metadata.name);
+      expect(result.description()).toBe(metadata.description);
+    });
+
+    it('should create command with options', () => {
+      // Act
+      const result = commandResolver.resolve(SingleCommand);
+
+      // Assert
+      expect(result).toBeInstanceOf(Command);
+      const options = MetadataRegistry.getOptions(SingleCommand);
+
+      expect(options).toBeDefined();
+      expect(result.options).toHaveLength(options.size);
+
+      // Verify each option matches the metadata
+      for (const [_, optionMeta] of options.entries()) {
+        const option = result.options.find((opt) =>
+          opt.flags.includes(`--${optionMeta.name}`),
+        );
+
+        expect(option).toBeDefined();
+
+        if (optionMeta.alias) {
+          expect(option!.flags).toContain(`-${optionMeta.alias}`);
+        }
+      }
+    });
+
+    it('should create command with subcommands', () => {
+      // Act
+      const metadata = MetadataRegistry.getCommand(WithSubCommands);
+
+      const command = commandResolver.resolve(
+        WithSubCommands,
+        metadata.subcommands,
+      );
+
+      // Assert
+      expect(command).toBeInstanceOf(Command);
+      expect(metadata.subcommands.length).toBe(2);
+      expect(command.commands).toHaveLength(metadata.subcommands.length);
+
+      // Verify each subcommand matches the metadata
+      for (const SubcommandClass of metadata.subcommands!) {
+        const subMeta = MetadataRegistry.getRunnable(SubcommandClass);
+        const subcommand = command.commands.find(
+          (cmd) => cmd.name() === subMeta.name,
+        );
+
+        expect(subcommand).toBeDefined();
+        expect(subcommand!.description()).toBe(subMeta.description);
+      }
+    });
+
+    it('should create command that executes with correct parameters', async () => {
+      // Arrange
+      const runMock = jest.fn();
+      const originalRun = SingleCommand.prototype.run;
+
+      SingleCommand.prototype.run = runMock;
+
+      mockEnv.optional
+        .mockReturnValueOnce({ key: 'MESSAGE', value: 'Test message' })
+        .mockReturnValueOnce({ key: 'VERBOSE', value: true });
+
+      // Act
+      const result = commandResolver.resolve(SingleCommand);
+
+      await result.parseAsync(['node', 'test']);
+
+      // Assert
+      expect(runMock).toHaveBeenCalledWith('Test message', true);
+
+      // Cleanup
+      SingleCommand.prototype.run = originalRun;
+    });
+  });
+});

package/test/loaders.spec.ts

@@ -0,0 +1,61 @@
+import path from 'node:path';
+
+import { LocalPathLoader, PkgLoader } from '../src/loaders/implementations';
+
+import SingleCommand from './commands/command.single';
+
+describe('Loaders', () => {
+  describe('LocalPathLoader', () => {
+    let loader: LocalPathLoader;
+
+    beforeEach(() => {
+      loader = new LocalPathLoader();
+    });
+
+    it('should load commands from a JavaScript file', async () => {
+      const filePath = path.join(__dirname, './commands/js/command.single.js');
+      const command = await loader.load(filePath);
+
+      /* When loading from JS files, we can't use strict equality (.toBe)
+       * because the loaded function is a new instance.
+       * Instead, we verify the function name and prototype match
+       */
+      expect(command.name).toBe(SingleCommand.name);
+      expect(command.prototype).toEqual(SingleCommand.prototype);
+    });
+
+    it('should load commands from a TypeScript file', async () => {
+      const filePath = path.join(__dirname, './commands/command.single.ts');
+      const command = await loader.load(filePath);
+
+      expect(command).toBe(SingleCommand);
+    });
+
+    it('should throw error when file not found', async () => {
+      const filePath = 'non-existent-file.ts';
+
+      await expect(loader.load(filePath)).rejects.toThrow(
+        'Error loading command from file',
+      );
+    });
+  });
+
+  describe('PkgLoader', () => {
+    let loader: PkgLoader;
+
+    beforeEach(() => {
+      loader = new PkgLoader('@rsdk/cli');
+    });
+
+    it('should throw error when package not found', async () => {
+      await expect(loader.load('non-existent-command')).rejects.toThrow(
+        'Error loading package, try install it: yarn add -D @rsdk/cli.cmd.non-existent-command',
+      );
+    });
+
+    /**
+     * TODO: Как бы написать этот тест без моков
+     */
+    xit('should load commands from a package', async () => {});
+  });
+});

package/test/options-resolver.spec.ts

@@ -0,0 +1,119 @@
+import type { OptionMetadata } from '@rsdk/cli.common';
+import { NumberParser } from '@rsdk/common';
+import type { Env } from '@rsdk/env';
+import type { ILogger } from '@rsdk/logging';
+
+import { OptionsResolver } from '../src/resolvers/options.resolver';
+
+describe('OptionsResolver', () => {
+  let optionsResolver: OptionsResolver;
+  let mockLogger: jest.Mocked<ILogger>;
+  let mockEnv: jest.Mocked<Env>;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    /**
+     * TODO: Заменить на noopLogger, когда он вольётся в develop
+     */
+    mockLogger = {
+      warn: jest.fn(),
+      debug: jest.fn(),
+      error: jest.fn(),
+      info: jest.fn(),
+      trace: jest.fn(),
+    } as unknown as jest.Mocked<ILogger>;
+
+    mockEnv = {
+      optional: jest.fn(),
+      required: jest.fn(),
+    } as unknown as jest.Mocked<Env>;
+
+    optionsResolver = new OptionsResolver(mockEnv, mockLogger);
+  });
+
+  describe('resolve', () => {
+    it('should prioritize environment variable over flag and default value', () => {
+      const optionMetadata: OptionMetadata<number> = {
+        name: 'test-option',
+        description: 'Test option',
+        parser: new NumberParser(),
+        defaultValue: 1,
+      };
+
+      mockEnv.optional.mockReturnValue({ value: 42, key: 'TEST_OPTION' });
+
+      const result = optionsResolver.resolve(optionMetadata, {
+        testOption: 10,
+      });
+
+      expect(result).toBe(42);
+    });
+
+    it('should use flag value when env variable is not set', () => {
+      const optionMetadata: OptionMetadata<number> = {
+        name: 'test-option',
+        description: 'Test option',
+        parser: new NumberParser(),
+        defaultValue: 1,
+      };
+
+      // eslint-disable-next-line unicorn/no-useless-undefined
+      mockEnv.optional.mockReturnValue(undefined);
+
+      const result = optionsResolver.resolve(optionMetadata, {
+        testOption: 10,
+      });
+
+      expect(result).toBe(10);
+    });
+
+    it('should use default value when neither env nor flag is provided', () => {
+      const optionMetadata: OptionMetadata<number> = {
+        name: 'test-option',
+        description: 'Test option',
+        parser: new NumberParser(),
+        defaultValue: 1,
+      };
+
+      // eslint-disable-next-line unicorn/no-useless-undefined
+      mockEnv.optional.mockReturnValue(undefined);
+
+      const result = optionsResolver.resolve(optionMetadata, {});
+
+      expect(result).toBe(1);
+    });
+
+    it('should handle boolean flags without parser', () => {
+      const optionMetadata: OptionMetadata<boolean> = {
+        name: 'test-flag',
+        description: 'Test flag',
+        defaultValue: false,
+      };
+
+      // eslint-disable-next-line unicorn/no-useless-undefined
+      mockEnv.optional.mockReturnValue(undefined);
+
+      const result = optionsResolver.resolve(optionMetadata, {
+        testFlag: true,
+      });
+
+      expect(result).toBe(true);
+    });
+
+    it('should handle undefined default value', () => {
+      const optionMetadata: OptionMetadata<number> = {
+        name: 'test-option',
+        description: 'Test option',
+        parser: new NumberParser(),
+      };
+
+      // eslint-disable-next-line unicorn/no-useless-undefined
+      mockEnv.optional.mockReturnValue(undefined);
+
+      const result = optionsResolver.resolve(optionMetadata, {});
+
+      expect(result).toBeUndefined();
+    });
+  });
+});