test(cli-core): add unit tests for CliFs, CliDockerComposeYaml, CliService, and other core services

Author: Romakita

packages/cli-core/src/fn/command.spec.ts

@@ -0,0 +1,75 @@
+import {injectable} from "@tsed/di";
+
+import type {CommandOptions} from "../interfaces/CommandOptions.js";
+import type {CommandProvider} from "../interfaces/CommandProvider.js";
+import {command} from "./command.js";
+
+vi.mock("@tsed/di", () => ({
+  injectable: vi.fn()
+}));
+
+describe("command()", () => {
+  const createBuilder = () =>
+    ({
+      type: vi.fn().mockReturnThis(),
+      set: vi.fn().mockReturnThis(),
+      factory: vi.fn().mockReturnThis()
+    }) as any;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("should register a functional command via factory", () => {
+    const builder = createBuilder();
+    vi.mocked(injectable).mockReturnValue(builder);
+
+    const handler: CommandProvider["$exec"] = vi.fn();
+    const prompt: CommandProvider["$prompt"] = vi.fn();
+    const options: CommandOptions = {
+      name: "test",
+      description: "description",
+      handler,
+      prompt
+    };
+
+    command(options);
+
+    expect(injectable).toHaveBeenCalledWith(Symbol.for("COMMAND_test"));
+    expect(builder.type).toHaveBeenCalledWith("command");
+    expect(builder.set).toHaveBeenCalledWith("command", options);
+    expect(builder.factory).toHaveBeenCalledTimes(1);
+
+    const registeredFactory = builder.factory.mock.calls[0][0];
+    const result = registeredFactory();
+
+    expect(result).toMatchObject({
+      ...options,
+      $exec: handler,
+      $prompt: prompt
+    });
+    expect(result.handler).toBe(handler);
+  });
+
+  it("should register a class-based command with provided token", () => {
+    const builder = createBuilder();
+    vi.mocked(injectable).mockReturnValue(builder);
+
+    class TestCommand implements CommandProvider {
+      $exec(): any {}
+    }
+
+    const options: CommandOptions = {
+      name: "test-class",
+      description: "description",
+      token: TestCommand
+    };
+
+    command(options);
+
+    expect(injectable).toHaveBeenCalledWith(TestCommand);
+    expect(builder.type).toHaveBeenCalledWith("command");
+    expect(builder.set).toHaveBeenCalledWith("command", options);
+    expect(builder.factory).not.toHaveBeenCalled();
+  });
+});

packages/cli-core/src/fn/command.ts

@@ -4,9 +4,9 @@ import {type FactoryTokenProvider, injectable, type TokenProvider} from "@tsed/d
 import type {CommandOptions} from "../interfaces/CommandOptions.js";
 import type {CommandProvider} from "../interfaces/index.js";
 
-export function command(options: CommandOptions) {
+export function command<Input>(options: CommandOptions<Input>) {
   if (!options.token) {
-    return injectable<FactoryTokenProvider<CommandProvider>>(Symbol.for(`COMMAND_${options.name}`) as any)
+    return injectable<FactoryTokenProvider<CommandProvider<Input>>>(Symbol.for(`COMMAND_${options.name}`) as any)
       .type("command")
       .set("command", options)
       .factory(() => {
@@ -18,5 +18,5 @@ export function command(options: CommandOptions) {
       });
   }
 
-  return injectable<Type<CommandProvider>>(options.token).type("command").set("command", options);
+  return injectable<Type<CommandProvider<Input>>>(options.token).type("command").set("command", options);
 }

packages/cli-core/src/interfaces/CommandMetadata.ts

@@ -1,6 +1,6 @@
 import type {BaseCommandOptions, CommandArg, CommandOpts} from "./CommandOptions.js";
 
-export interface CommandMetadata extends BaseCommandOptions {
+export interface CommandMetadata extends BaseCommandOptions<any> {
   /**
    * CommandProvider arguments
    */

packages/cli-core/src/interfaces/CommandOptions.ts

@@ -1,7 +1,10 @@
 import {Type} from "@tsed/core";
 import type {TokenProvider} from "@tsed/di";
+import type {JsonSchema} from "@tsed/schema";
+import type {Answers} from "inquirer";
 
-import type {CommandProvider} from "./CommandProvider.js";
+import type {CommandProvider, QuestionOptions} from "./CommandProvider.js";
+import type {Tasks} from "./Tasks.js";
 
 export interface CommandArg {
   /**
@@ -54,7 +57,7 @@ export interface CommandOpts {
   customParser?: (value: any) => any;
 }
 
-export interface BaseCommandOptions {
+export interface BaseCommandOptions<Input> {
   /**
    * name commands
    */
@@ -71,6 +74,9 @@ export interface BaseCommandOptions {
   args?: {
     [key: string]: CommandArg;
   };
+
+  inputSchema?: JsonSchema<Input> | (() => JsonSchema<Input>);
+
   /**
    * CommandProvider options
    */
@@ -85,17 +91,17 @@ export interface BaseCommandOptions {
   disableReadUpPkg?: boolean;
 }
 
-interface FunctionalCommandOptions extends BaseCommandOptions {
-  prompt?: CommandProvider["$prompt"];
-  handler: CommandProvider["$exec"];
+interface FunctionalCommandOptions<Input> extends BaseCommandOptions<Input> {
+  prompt?<T extends Answers = Answers>(initialOptions: Partial<Input>): QuestionOptions<T> | Promise<QuestionOptions<T>>;
+  handler: (data: Input) => Tasks | Promise<Tasks> | any | Promise<any>;
 
   [key: string]: any;
 }
 
-interface ClassCommandOptions extends BaseCommandOptions {
-  token: TokenProvider<CommandProvider>;
+interface ClassCommandOptions<Input> extends BaseCommandOptions<Input> {
+  token: TokenProvider<CommandProvider<Input>>;
 
   [key: string]: any;
 }
 
-export type CommandOptions = ClassCommandOptions | FunctionalCommandOptions;
+export type CommandOptions<Input> = ClassCommandOptions<Input> | FunctionalCommandOptions<Input>;

packages/cli-core/src/services/CliDockerComposeYaml.spec.ts

@@ -0,0 +1,162 @@
+// @ts-ignore
+import {CliPlatformTest} from "@tsed/cli-testing";
+
+import {CliDockerComposeYaml} from "./CliDockerComposeYaml.js";
+import {CliFs} from "./CliFs.js";
+import {CliYaml} from "./CliYaml.js";
+import {ProjectPackageJson} from "./ProjectPackageJson.js";
+
+describe("CliDockerComposeYaml", () => {
+  beforeEach(() => CliPlatformTest.create());
+  afterEach(() => CliPlatformTest.reset());
+
+  async function createService(deps: Partial<Record<string, any>> = {}) {
+    const cliYaml = deps.cliYaml || {
+      read: vi.fn().mockResolvedValue({}),
+      write: vi.fn().mockResolvedValue(undefined)
+    };
+    const fs = deps.fs || {
+      exists: vi.fn().mockReturnValue(true),
+      findUpFile: vi.fn().mockReturnValue(undefined)
+    };
+    const projectPkg = deps.projectPkg || ({dir: "/project"} as ProjectPackageJson);
+
+    const service = await CliPlatformTest.invoke<CliDockerComposeYaml>(CliDockerComposeYaml, [
+      {
+        token: CliYaml,
+        use: cliYaml
+      },
+      {
+        token: CliFs,
+        use: fs
+      },
+      {
+        token: ProjectPackageJson,
+        use: projectPkg
+      }
+    ]);
+
+    return {service, cliYaml, fs, projectPkg};
+  }
+
+  describe("read()", () => {
+    it("should read docker-compose.yml from project root when it exists", async () => {
+      const {service, cliYaml, fs} = await createService();
+
+      const result = await service.read();
+
+      expect(fs.exists).toHaveBeenCalledWith("docker-compose.yml");
+      expect(cliYaml.read).toHaveBeenCalledWith("docker-compose.yml");
+      expect(result).toEqual({});
+    });
+
+    it("should return an empty object when no docker-compose file is found", async () => {
+      const fs = {
+        exists: vi.fn().mockReturnValue(false),
+        findUpFile: vi.fn().mockReturnValue(undefined)
+      };
+      const {service, cliYaml} = await createService({fs});
+
+      const result = await service.read();
+
+      expect(fs.findUpFile).toHaveBeenCalled();
+      expect(cliYaml.read).not.toHaveBeenCalled();
+      expect(result).toEqual({});
+    });
+  });
+
+  describe("write()", () => {
+    it("should write to the discovered docker-compose file", async () => {
+      const cliYaml = {
+        read: vi.fn(),
+        write: vi.fn().mockResolvedValue(undefined)
+      };
+      const fs = {
+        exists: vi.fn(),
+        findUpFile: vi.fn().mockReturnValue("/repo/docker-compose.yml")
+      };
+      const {service} = await createService({cliYaml, fs});
+      const payload = {services: {}};
+
+      await service.write(payload);
+
+      expect(cliYaml.write).toHaveBeenCalledWith("/repo/docker-compose.yml", payload);
+    });
+
+    it("should fallback to project dir when docker-compose file does not exist yet", async () => {
+      const cliYaml = {
+        read: vi.fn(),
+        write: vi.fn().mockResolvedValue(undefined)
+      };
+      const fs = {
+        exists: vi.fn(),
+        findUpFile: vi.fn().mockReturnValue(undefined)
+      };
+      const projectPkg = {dir: "/repo"} as ProjectPackageJson;
+      const {service} = await createService({cliYaml, fs, projectPkg});
+      const payload = {services: {}};
+
+      await service.write(payload);
+
+      expect(cliYaml.write).toHaveBeenCalledWith("/repo/docker-compose.yml", payload);
+    });
+  });
+
+  describe("addDatabaseService()", () => {
+    it("should append a postgres service and persist the file", async () => {
+      const cliYaml = {
+        read: vi.fn().mockResolvedValue({services: {}}),
+        write: vi.fn().mockResolvedValue(undefined)
+      };
+      const fs = {
+        exists: vi.fn().mockReturnValue(true),
+        findUpFile: vi.fn()
+      };
+      const {service} = await createService({cliYaml, fs});
+
+      await service.addDatabaseService("OrdersDb", "postgres");
+
+      expect(cliYaml.write).toHaveBeenCalledTimes(1);
+      const [, dockerCompose] = cliYaml.write.mock.calls[0];
+      expect(dockerCompose).toEqual({
+        services: {
+          orders_db: {
+            image: "postgres:9.6.1",
+            ports: ["5432:5432"],
+            volumes: ["./pgdata:/var/lib/postgresql/data"],
+            environment: {
+              POSTGRES_USER: "test",
+              POSTGRES_PASSWORD: "test",
+              POSTGRES_DB: "test"
+            }
+          }
+        }
+      });
+    });
+
+    it("should append a mongodb service definition when requested", async () => {
+      const cliYaml = {
+        read: vi.fn().mockResolvedValue({services: {}}),
+        write: vi.fn().mockResolvedValue(undefined)
+      };
+      const fs = {
+        exists: vi.fn().mockReturnValue(true),
+        findUpFile: vi.fn()
+      };
+      const {service} = await createService({cliYaml, fs});
+
+      await service.addDatabaseService("Analytics", "mongodb");
+
+      expect(cliYaml.write).toHaveBeenCalledTimes(1);
+      const [, dockerCompose] = cliYaml.write.mock.calls[0];
+      expect(dockerCompose).toEqual({
+        services: {
+          analytics: {
+            image: "mongo:5.0.8",
+            ports: ["27017:27017"]
+          }
+        }
+      });
+    });
+  });
+});