task-script-support-cli 0.1.1 → 0.2.3

package/assets/yargs-template/task-runner/tests/commands/verify.test.ts

@@ -0,0 +1,42 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { describe, it, expect, vi } from "vitest";
+import PrintBanner from "../../src/tasks/print-banner";
+import CheckEnv from "../../src/tasks/check-env";
+import { container } from "tsyringe";
+import { CommandService } from "task-script-support";
+import { AppStateData, CLIArgs } from "../../src/types/state";
+
+// Mock the tasks and their run methods
+vi.mock("../../src/tasks/print-banner", () => {
+  const PrintBannerMock = vi.fn();
+  PrintBannerMock.prototype.run = vi.fn();
+  return { default: PrintBannerMock };
+});
+
+vi.mock("../../src/tasks/check-env", () => {
+  const CheckEnvMock = vi.fn();
+  CheckEnvMock.prototype.run = vi.fn();
+  return { default: CheckEnvMock };
+});
+
+describe("verify command", () => {
+  it("should run PrintBanner and then CheckEnv", async () => {
+    const tasks = [PrintBanner, CheckEnv];
+    container.register("Args", { useValue: [] });
+
+    // when
+    await new CommandService<AppStateData, CLIArgs>().runTasks(
+      tasks,
+      {} as CLIArgs,
+    );
+
+    expect(PrintBanner).toHaveBeenCalled();
+    expect(CheckEnv).toHaveBeenCalled();
+
+    const printBannerInstance = (PrintBanner as any).mock.instances[0];
+    const checkEnvInstance = (CheckEnv as any).mock.instances[0];
+
+    expect(printBannerInstance.run).toHaveBeenCalled();
+    expect(checkEnvInstance.run).toHaveBeenCalled();
+  });
+});

package/assets/yargs-template/task-runner/tests/services/spawn-service.test.ts

@@ -0,0 +1,132 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { SpawnService } from "../../src/services/spawn-service";
+import childProcess from "node:child_process";
+import { fail } from "node:assert";
+
+const hoisted = vi.hoisted(() => {
+  return {
+    spawn: vi.fn(),
+  };
+});
+
+vi.mock("node:child_process", async (importOriginal) => {
+  const mod = await importOriginal<typeof import("node:child_process")>();
+  return {
+    ...mod,
+    default: {
+      ...mod,
+      execSync: vi.fn(),
+      exec: vi.fn(),
+    },
+    spawn: hoisted.spawn,
+  };
+});
+
+describe("SpawnService", () => {
+  let spawnService: SpawnService;
+
+  beforeEach(() => {
+    spawnService = new SpawnService();
+    vi.resetAllMocks();
+  });
+
+  describe("execSync", () => {
+    it("should call execSync with the correct command", () => {
+      const command = "ls -la";
+      (childProcess.execSync as any).mockReturnValue("output");
+      const result = spawnService.execSync(command);
+      expect(childProcess.execSync).toHaveBeenCalledWith(command);
+      expect(result).toBe("output");
+    });
+
+    it("should throw an error if execSync throws", () => {
+      const command = "invalid command";
+      (childProcess.execSync as any).mockImplementation(() => {
+        throw new Error("error");
+      });
+      expect(() => spawnService.execSync(command)).toThrow("error");
+    });
+  });
+
+  describe("exec", () => {
+    it("should call exec with the correct command", async () => {
+      const command = "ls -la";
+      const mockedCallback = (
+        _cmd: string,
+        callback: (err: Error | null, stdout?: string, stderr?: string) => void,
+      ) => {
+        callback(null, "output", undefined);
+      };
+      (childProcess.exec as any).mockReturnValue("output");
+      (childProcess.exec as any).mockImplementation(mockedCallback);
+      const { stdout: result } = await spawnService.exec(command);
+      expect(childProcess.exec).toHaveBeenCalledWith(
+        command,
+        expect.anything(),
+      );
+      expect(result).toBe("output");
+      expect(command).toBeTruthy();
+    });
+
+    it("should throw an error if exec throws", async () => {
+      const command = "invalid command";
+      (childProcess.exec as any).mockImplementation(
+        (
+          _cmd: string,
+          callback: (
+            err: Error | null,
+            stdout?: string,
+            stderr?: string,
+          ) => void,
+        ) => {
+          callback(new Error("error"), undefined, undefined);
+        },
+      );
+
+      try {
+        await spawnService.exec(command);
+        fail("should not get past errors");
+      } catch (err) {
+        expect((err as Error).message).toBe("error");
+      }
+    });
+  });
+
+  describe("backgroundExec", () => {
+    it("should call spawn with the correct command and args", () => {
+      const command = "node";
+      const args = ["script.js"];
+      const mockChildProcess = { unref: vi.fn() };
+      hoisted.spawn.mockReturnValue(mockChildProcess);
+      spawnService.backgroundExec(command, args);
+      expect(hoisted.spawn).toHaveBeenCalledWith(command, args, {
+        detached: true,
+        stdio: "ignore",
+      });
+      expect(mockChildProcess.unref).toHaveBeenCalled();
+    });
+  });
+
+  describe("isProcessCompleted", () => {
+    it("should return false if process.kill succeeds", () => {
+      const pid = 123;
+      const mockKill = vi.spyOn(process, "kill").mockImplementation(() => true);
+      const result = spawnService.isProcessCompleted(pid);
+      expect(result).toBe(false);
+      expect(mockKill).toHaveBeenCalledWith(pid, 0);
+      mockKill.mockRestore();
+    });
+
+    it("should return true if process.kill throws", () => {
+      const pid = 123;
+      const mockKill = vi.spyOn(process, "kill").mockImplementation(() => {
+        throw new Error("error");
+      });
+      const result = spawnService.isProcessCompleted(pid);
+      expect(result).toBe(true);
+      expect(mockKill).toHaveBeenCalledWith(pid, 0);
+      mockKill.mockRestore();
+    });
+  });
+});

package/assets/yargs-template/task-runner/tests/services/util-service.test.ts

@@ -0,0 +1,36 @@
+import { describe, it, expect } from "vitest";
+import { UtilService } from "../../src/services/util-service";
+import pkgJson from "../../package.json";
+
+describe("UtilService", () => {
+  describe("titleize", () => {
+    it("should capitalize the first letter of a string", () => {
+      const utilService = new UtilService();
+      expect(utilService.titleize("hello")).toBe("Hello");
+    });
+
+    it("should return an empty string if given an empty string", () => {
+      const utilService = new UtilService();
+      expect(utilService.titleize("")).toBe("");
+    });
+
+    it("should handle single character strings", () => {
+      const utilService = new UtilService();
+      expect(utilService.titleize("a")).toBe("A");
+    });
+  });
+
+  describe("getAppName", () => {
+    it("should return the application name from package.json", () => {
+      const utilService = new UtilService();
+      expect(utilService.getAppName()).toBe(pkgJson.name);
+    });
+  });
+
+  describe("getAppVersion", () => {
+    it("should return the application version from package.json", () => {
+      const utilService = new UtilService();
+      expect(utilService.getAppVersion()).toBe(pkgJson.version);
+    });
+  });
+});

package/assets/yargs-template/task-runner/tests/setup.ts

@@ -0,0 +1 @@
+import "reflect-metadata";

package/assets/yargs-template/task-runner/tests/tasks/check-env.test.ts

@@ -0,0 +1,30 @@
+import { describe, it, expect, vi } from "vitest";
+import CheckEnv from "../../src/tasks/check-env";
+import { LogService } from "../../src/services/log-service";
+import { CommandService } from "task-script-support";
+import { AppStateData, CLIArgs } from "../../src/types/state";
+
+describe("CheckEnv", () => {
+  it("should set environmentValidated to true", async () => {
+    const mockLogService = {
+      info: vi.fn(),
+      debug: vi.fn(),
+    } as unknown as LogService;
+    const mockCommandService = {
+      setData: vi.fn((state, data) => ({
+        ...state,
+        data: { ...state.data, ...data },
+      })),
+    } as unknown as CommandService<AppStateData, CLIArgs>;
+
+    const checkEnv = Object.create(CheckEnv.prototype);
+    checkEnv._commandService = mockCommandService;
+    checkEnv._logService = mockLogService;
+    checkEnv.state = { id: "test", args: [], data: {} };
+    await checkEnv.run();
+    expect(mockLogService.info).toHaveBeenCalledWith(
+      "Running Check Environment",
+    );
+    expect(checkEnv.state.data.environmentValidated).toBe(true);
+  });
+});

package/assets/yargs-template/task-runner/tsconfig.json

@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    "rootDir": ".",
+    "sourceRoot": "./src",
+    "outDir": "./dist",
+    "module": "node16",
+    "target": "esnext",
+    "lib": ["esnext"],
+    "types": ["node", "vitest"],
+    "sourceMap": true,
+    "declaration": true,
+    "declarationMap": true,
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+    "strict": true,
+    "jsx": "react-jsx",
+    "resolveJsonModule": true,
+    "esModuleInterop": true,
+    "isolatedModules": true,
+    "noUncheckedSideEffectImports": true,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "moduleDetection": "force",
+    "skipLibCheck": true
+  },
+  "exclude": ["node_modules", "dist", "tests"]
+}

package/assets/yargs-template/task-runner/vitest.config.ts

@@ -0,0 +1,14 @@
+const { defineConfig, configDefaults } = require("vitest/config");
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: "node",
+    setupFiles: "./tests/setup.ts",
+    exclude: [...configDefaults.exclude],
+    coverage: {
+      provider: "v8",
+      reporter: ["text", "json", "html"],
+    },
+  },
+});

package/dist/assets/yargs-template/task-runner/.prettierignore

@@ -0,0 +1,3 @@
+# Ignore artifacts:
+build
+coverage

package/dist/assets/yargs-template/task-runner/.prettierrc

@@ -0,0 +1 @@
+{}

package/dist/assets/yargs-template/task-runner/.vscode/launch.json

@@ -0,0 +1,34 @@
+{
+  // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "Start Verify --Env 'test'",
+      "request": "launch",
+      "runtimeArgs": ["start", "verify", "-d"],
+      "runtimeExecutable": "npm",
+      "skipFiles": ["<node_internals>/**"],
+      "type": "node"
+    },
+
+    {
+      "name": "Launch with Random Banner Font",
+      "request": "launch",
+      "runtimeArgs": ["start", "verify", "-d", "--rf"],
+      "runtimeExecutable": "npm",
+      "skipFiles": ["<node_internals>/**"],
+      "type": "node"
+    },
+
+    {
+      "type": "node",
+      "request": "launch",
+      "name": "Launch Program 2",
+      "skipFiles": ["<node_internals>/**"],
+      "program": "${workspaceFolder}/dist/src/index.js",
+      "preLaunchTask": "tsc: build - tsconfig.json",
+      "outFiles": ["${workspaceFolder}/dist/**/*.js"],
+      "args": ["verify"]
+    }
+  ]
+}

package/dist/assets/yargs-template/task-runner/eslint.config.ts

@@ -0,0 +1,11 @@
+import eslint from "@eslint/js";
+import { defineConfig, globalIgnores } from "eslint/config";
+import tseslint from "typescript-eslint";
+
+export default defineConfig([
+  {
+    extends: [eslint.configs.recommended, tseslint.configs.recommended],
+    files: ["./src/**/*.ts", "./tests/**/*.ts"],
+  },
+  globalIgnores(["dist/*"]),
+]);

package/dist/assets/yargs-template/task-runner/install-link.sh

@@ -0,0 +1,21 @@
+#!/bin/bash
+
+SOURCE_LN=$(echo `pwd`/task-runner)
+DEST_DIR="$HOME/.scripts"
+DEST_LN="$DEST_DIR/task-runner"
+
+npm i
+
+npm run build
+
+mkdir -p "$DEST_DIR"
+
+echo "Creating SymLink:"
+echo "  $SOURCE_LN -> $DEST_LN"
+
+ln -s "$SOURCE_LN" "$DEST_LN"
+
+echo 'Installed local client as task-runner'
+echo;
+echo 'Try: task-runner -h'
+echo;