Advance with coverage

src/output.ts

@@ -1,9 +1,9 @@
-import { Output, OutputExporter } from "./types";
+import { Output } from "./types";
 import { execStdout } from "./utils/exec";
 import * as core from "@actions/core";
 
-export class Outputs implements OutputExporter {
-    public async outputs(): Promise<Output[]> {
+export class Outputs {
+    public static async outputs(): Promise<Output[]> {
         return Promise.resolve([
             await Outputs.rustc(),
             await Outputs.rustcHash(),

src/toolchain_install.ts

@@ -146,7 +146,7 @@ export const installToolchainCommand = new Command()
 
         core.info(await rustup.activeToolchain());
 
-        (await new Outputs().outputs()).forEach((output) => {
+        (await Outputs.outputs()).forEach((output) => {
             core.setOutput(output.name, output.value);
         });
     });

src/types.ts

@@ -55,16 +55,3 @@ export interface Output {
     name: string;
     value: string;
 }
-
-/**
- * `Output` defines simple interface to provide a list of outputs that the action exports.
- */
-export interface OutputExporter {
-    /**
-     * Creates a list of outputs that will be exported by the GitHub action.
-     *
-     * The signature includes async as some outputs require async code to be retrieved.
-     * @return{Promise<Output[]>}
-     */
-    outputs(): Promise<Output[]>;
-}

tests/installers/rustup_init.test.ts

@@ -5,6 +5,7 @@ import { RustUpInit } from "../../src/installers/rustup_init";
 import process from "process";
 
 jest.mock("@actions/exec");
+jest.mock("@actions/core");
 jest.mock("@actions/tool-cache", () => ({
     downloadTool: jest.fn().mockReturnValue("some path"),
 }));

tests/output.test.ts

@@ -92,7 +92,7 @@ describe("Outputs tests", () => {
         );
 
         expect(
-            (await new Outputs().outputs())
+            (await Outputs.outputs())
                 .map((output) => {
                     return output.value;
                 })

tests/toolchain_install.test.ts

@@ -0,0 +1,79 @@
+import { installToolchainCommand } from "../src/toolchain_install";
+import { RustUp } from "../src/installers/rustup";
+import * as semver from "semver";
+import { Outputs } from "../src/output";
+import * as mockedCore from "@actions/core";
+
+jest.mock("@actions/exec", () => ({
+    exec: jest.fn(),
+}));
+jest.mock("@actions/core", () => ({
+    debug: jest.fn(),
+    startGroup: jest.fn(),
+    endGroup: jest.fn(),
+    info: jest.fn(),
+    error: jest.fn(),
+    setOutput: jest.fn(),
+}));
+jest.mock("../src/installers/rustup", () => ({
+    RustUp: {
+        getOrInstall: jest.fn(),
+    },
+}));
+jest.mock("../src/output", () => ({
+    Outputs: {
+        outputs: jest.fn(),
+    },
+}));
+
+describe("Tests of toolchain command", () => {
+    const originalEnv = process.env;
+
+    afterEach(() => {
+        process.env = originalEnv;
+        jest.resetAllMocks();
+    });
+
+    test("Outputs", async () => {
+        process.env.INPUT_PROFILE = "minim";
+
+        const obj = {
+            supportProfiles: jest.fn(async (): Promise<boolean> => {
+                return Promise.resolve(true);
+            }),
+            supportComponents: jest.fn(async (): Promise<boolean> => {
+                return Promise.resolve(true);
+            }),
+            setProfile: jest.fn(),
+            installToolchain: jest.fn(async (): Promise<number> => {
+                return Promise.resolve(0);
+            }),
+            version: jest.fn((): Promise<semver.SemVer> => {
+                return Promise.resolve(semver.parse("2.2.2") as semver.SemVer);
+            }),
+            selfUpdate: jest.fn(),
+            activeToolchain: jest.fn().mockReturnValue("active toolchain"),
+        };
+        (RustUp.getOrInstall as jest.Mock).mockImplementation(async () => {
+            return Promise.resolve(obj);
+        });
+        (Outputs.outputs as jest.Mock).mockReturnValue(
+            Promise.resolve([
+                {
+                    name: "rustc",
+                    value: "version",
+                },
+            ]),
+        );
+
+        installToolchainCommand
+            .hook("postAction", () => {
+                expect(mockedCore.setOutput).toHaveBeenCalledTimes(1);
+                expect(mockedCore.setOutput).toHaveBeenCalledWith(
+                    "rustc",
+                    "version",
+                );
+            })
+            .parse([]);
+    });
+});