chore(tests): more unit tests, increasing code coverage

Author: doublecompile

src/output.ts

@@ -190,14 +190,19 @@ export class Output implements OutputHelper {
     stdout: WriteStream,
     stderr: WriteStream,
     spinner: Spinner,
-    logger: StreamLogger,
-    chalkInstance: ChalkInstance,
+    logger?: StreamLogger,
+    chalkInstance: ChalkInstance = chalk,
   ) {
+    this.#chalk = chalkInstance;
     this.#stdout = stdout;
     this.#stderr = stderr;
+    this.#logger =
+      logger ||
+      new StreamLogger({
+        colors: chalkInstance,
+        stream: stderr,
+      });
     this.#spinner = spinner;
-    this.#logger = logger;
-    this.#chalk = chalkInstance;
   }
 
   public get spinner(): Spinner {

test/output.test.ts

@@ -2,6 +2,8 @@ import { EOL } from "os";
 import { WriteStream } from "tty";
 import { jest } from "@jest/globals";
 import chalk from "chalk";
+import { LogLevel } from "../src/io/logs.js";
+import { Spinner } from "../src/io/spinner.js";
 import { Output } from "../src/output.js";
 
 describe("Output", () => {
@@ -43,6 +45,26 @@ describe("Output", () => {
     });
   });
 
+  describe("#disableColor", () => {
+    test("should disable color on the chalk instance", () => {
+      const object = Output.create({});
+      object.disableColor();
+      expect(object.colors.level).toStrictEqual(0);
+    });
+  });
+
+  describe("#setLogLevel", () => {
+    test("should behave as expected", () => {
+      const stderr = new WriteStream(2);
+      const writeSpy = jest.spyOn(stderr, "write").mockReturnValue(true);
+      const object = Output.create({ stderr });
+      const expected = LogLevel.SILENT;
+      object.setLogLevel(expected);
+      object.log.warn("Message");
+      expect(writeSpy).not.toHaveBeenCalled();
+    });
+  });
+
   describe("#fail", () => {
     it("should do its thing", async function () {
       try {
@@ -59,6 +81,22 @@ describe("Output", () => {
   });
 
   describe("#loading", () => {
+    test("should behave as expected", () => {
+      const stdout = new WriteStream(1);
+      const stderr = new WriteStream(2);
+      const spinner: Spinner = {
+        succeed: () => {},
+        fail: () => {},
+        disable: () => {},
+        during: (p) => p,
+      };
+      const spy = jest.spyOn(spinner, "disable");
+      const object = new Output(stdout, stderr, spinner);
+      expect(object.spinner).toBe(spinner);
+      object.disableSpinner();
+      expect(spy).toHaveBeenCalledTimes(1);
+    });
+
     test("should return the resolved value", async () => {
       const stderr = new WriteStream(2);
       jest.spyOn(stderr, "write").mockImplementation(() => true);

test/program.test.ts

@@ -1,9 +1,62 @@
+import { WriteStream } from "tty";
 import { jest } from "@jest/globals";
 import { StreamLogger } from "../src/io/logs";
 import { Output } from "../src/output";
 import { Program } from "../src/program";
 
 describe("Program", () => {
+  describe("#constructor", () => {
+    // To ensure that Commander is using the stdout stream we provide it.
+    test("uses the stdout stream", async () => {
+      const stdout = new WriteStream(1);
+      const stderr = new WriteStream(2);
+      const outSpy = jest.spyOn(stdout, "write").mockImplementation(() => true);
+      const output = Output.create({ stdout, stderr });
+      const obj = new Program(output, "Example").exitOverride(() => {
+        throw new Error("Fake!");
+      });
+
+      // Commander invokes `process.exit()` when you ask for the help screen.
+      // To avoid that, we use the `.exitOverride()` method to throw an `Error`.
+      // We might as well expect that `Error`.
+      await expect(async () => {
+        await obj.parseAsync(["--help"], { from: "user" });
+      }).rejects.toThrow({ name: "Error", message: "Fake!" });
+
+      // Expect the stdout.write method was called with the Help screen
+      expect(outSpy).toHaveBeenCalledTimes(1);
+      expect(outSpy).toHaveBeenCalledWith(expect.stringMatching("Example"));
+    });
+
+    // To ensure that Commander is using the stderr stream we provide it.
+    test("uses the stderr stream", async () => {
+      const stdout = new WriteStream(1);
+      const stderr = new WriteStream(2);
+      const errSpy = jest.spyOn(stderr, "write").mockImplementation(() => true);
+      const output = Output.create({ stdout, stderr });
+
+      const option = "non-existent";
+      const obj = new Program(output, "Example")
+        .showHelpAfterError(true)
+        .exitOverride(() => {
+          throw new Error("Fake!");
+        });
+
+      // Commander invokes `process.exit()` when you specify a nonexistent
+      // option. To avoid that, we use the `.exitOverride()` method to throw an
+      // `Error`. We might as well expect that `Error`.
+      await expect(async () => {
+        await obj.parseAsync([`--${option}`], { from: "user" });
+      }).rejects.toThrow({ name: "Error", message: "Fake!" });
+
+      // Expect the stderr.write method was called with the unrecognized option
+      expect(errSpy).toHaveBeenCalledTimes(3);
+      expect(errSpy).toHaveBeenCalledWith(
+        expect.stringMatching(`unknown option '--${option}'`),
+      );
+    });
+  });
+
   describe("#log", () => {
     test("behaves as expected", () => {
       const output = Output.create({});
@@ -48,6 +101,32 @@ describe("Program", () => {
       await obj.parseAsync([]);
     });
 
+    // To ensure that Commander is using the stderr stream we provide it.
+    test("uses the stderr stream", async () => {
+      const stdout = new WriteStream(1);
+      const stderr = new WriteStream(2);
+      const errSpy = jest.spyOn(stderr, "write").mockImplementation(() => true);
+      const output = Output.create({ stdout, stderr });
+
+      const expected = "Lorem ipsum dolor sit amet";
+
+      // Commander invokes `process.exit()` when you ask for the help screen.
+      // To avoid that, we use the `.exitOverride()` method to throw an `Error`.
+      const obj: Program<[], {}> = new Program(output)
+        .action(() => obj.error(expected))
+        .exitOverride(() => {
+          throw new Error("Fake!");
+        });
+      // We might as well expect that `Error`.
+      await expect(async () => {
+        await obj.parseAsync([]);
+      }).rejects.toThrow({ name: "Error", message: "Fake!" });
+
+      // Expect the stderr.write method was called with the unrecognized option
+      expect(errSpy).toHaveBeenCalledTimes(1);
+      expect(errSpy).toHaveBeenCalledWith(expect.stringMatching(expected));
+    });
+
     test("fails on error", async () => {
       const output = Output.create({});
       const obj = new Program(output);