track-cli 4.0.3 → 4.1.0-rc2

package/esm/test/shared/mod_test.js

@@ -0,0 +1,353 @@
+import * as dntShim from "../../_dnt.test_shims.js";
+import * as mod from "../../src/shared/mod.js";
+import { FileListType } from "../../src/shared/types.js";
+import { assertEquals, assertStringIncludes } from "../../deps/deno.land/std@0.195.0/testing/asserts.js";
+import { describe, it } from "../../deps/deno.land/std@0.195.0/testing/bdd.js";
+import { assertSpyCall, restore, returnsNext, stub } from "../../deps/deno.land/std@0.195.0/testing/mock.js";
+import * as colors from "../../deps/deno.land/std@0.195.0/fmt/colors.js";
+describe("HttpStatus", () => {
+    // deno-fmt-ignore
+    const testcases = [
+        { code: 200, isSuccess: true, isClientError: false, isServerError: false },
+        { code: 201, isSuccess: true, isClientError: false, isServerError: false },
+        { code: 400, isSuccess: false, isClientError: true, isServerError: false },
+        { code: 403, isSuccess: false, isClientError: true, isServerError: false },
+        { code: 500, isSuccess: false, isClientError: false, isServerError: true },
+        { code: 503, isSuccess: false, isClientError: false, isServerError: true },
+    ];
+    describe("HttpStatus.isSuccess(x: number)", () => {
+        testcases.forEach(({ code, isSuccess }) => {
+            it(`should return ${isSuccess} for ${code}`, () => {
+                assertEquals(mod.HttpStatus.isSuccess(code), isSuccess);
+            });
+        });
+    });
+    describe("HttpStatus.isClientError(x: number)", () => {
+        testcases.forEach(({ code, isClientError }) => {
+            it(`should return ${isClientError} for ${code}`, () => {
+                assertEquals(mod.HttpStatus.isClientError(code), isClientError);
+            });
+        });
+    });
+    describe("HttpStatus.isServerError(x: number)", () => {
+        testcases.forEach(({ code, isServerError }) => {
+            it(`should return ${isServerError} for ${code}`, () => {
+                assertEquals(mod.HttpStatus.isServerError(code), isServerError);
+            });
+        });
+    });
+    it("HttpStatus for Response should work", () => {
+        testcases.forEach((testcase) => {
+            const response = new dntShim.Response("hello", { status: testcase.code });
+            assertEquals(mod.HttpStatus.isSuccess(response), testcase.isSuccess);
+            assertEquals(mod.HttpStatus.isClientError(response), testcase.isClientError);
+            assertEquals(mod.HttpStatus.isServerError(response), testcase.isServerError);
+        });
+    });
+});
+describe("Prompt.select()", () => {
+    describe(".select()", () => {
+        const items = ["a", "b", "c"];
+        // deno-fmt-ignore-start
+        const testcases = [
+            { input: "1", expected: 0, message: "should return selected item index (0 start) - 1" },
+            { input: "2", expected: 1, message: "should return selected item index (0 start) - 2" },
+            { input: "3", expected: 2, message: "should return selected item index (0 start) - 3" },
+            { input: "4", expected: undefined, message: "should return undefined if input is out of range" },
+            { input: null, expected: undefined, message: "should return undefined for empty input" },
+            { input: "x", expected: undefined, message: "should return undefined for invalid input" },
+        ];
+        testcases.forEach(({ input, expected, message }) => {
+            it(message, () => {
+                const promptSpy = stub(mod._internals, "prompt", returnsNext([input]));
+                const actual = mod.Prompt.select("Select one", items);
+                assertEquals(actual, expected);
+                assertSpyCall(promptSpy, 0, {
+                    args: ["Select one\n[1] a\n[2] b\n[3] c\n> "],
+                });
+                restore();
+            });
+        });
+    });
+});
+describe("printTimeLeft()", () => {
+    const noColor = (x) => x;
+    // deno-fmt-ignore
+    const testcases = [
+        { input: 0, expected: "0s", color: colors.red },
+        { input: 1, expected: "1s", color: colors.red },
+        { input: 59, expected: "59s", color: colors.red },
+        { input: 60, expected: "1m", color: colors.red },
+        { input: 300, expected: "5m", color: colors.red },
+        { input: 301, expected: "5m 1s", color: colors.yellow },
+        { input: 3599, expected: "59m 59s", color: colors.yellow },
+        { input: 3600, expected: "1h", color: colors.yellow },
+        { input: -1, expected: "The exam deadline has not yet been started", color: noColor },
+        { input: -2, expected: "The exam deadline has passed", color: noColor },
+    ];
+    testcases.forEach(({ input, expected, color }) => {
+        it(`should print collect time for ${input} second(s)`, () => {
+            const consoleSpy = stub(console, "log");
+            mod.printTimeLeft(input);
+            const actual = consoleSpy.calls.flatMap((call) => call.args).join("\n");
+            assertStringIncludes(actual, color(expected));
+            restore();
+        });
+    });
+});
+describe("listFileNames()", () => {
+    const context = {
+        settings: {
+            files: {
+                "test": {
+                    "settings.json": false,
+                    "basic.js": false,
+                    "basic_testcases.json": false,
+                    "in": {
+                        "basic": {
+                            "1.in": false,
+                            "2.in": false,
+                        },
+                    },
+                    "out": {
+                        "basic": {
+                            "1.out": false,
+                            "2.out": false,
+                        },
+                    },
+                },
+                "readme.md": true,
+                "Cargo.toml": true,
+                "src": {
+                    "main.rs": true,
+                },
+            },
+            hiddenFiles: [
+                "test/in/secret/1.in",
+                "test/in/secret/2.in",
+                "test/out/secret/1.out",
+                "test/out/secret/2.out",
+                "test/secret_testcases.json",
+                "test/secret.js",
+            ],
+            testExcludes: [],
+            images: [],
+            build: ["cargo build --release"],
+            test: "cargo test",
+            mainFile: "src/main.rs",
+            allowNewFile: true,
+            languages: ["rust"],
+            initialize: [],
+        },
+        answers: {
+            build: ["cargo build --release"],
+            appCommand: "./target/release/main",
+            mainFile: "src/main.rs",
+            addedFiles: ["src/lib.rs"],
+            fileVersions: {},
+        },
+    };
+    const testcases = [
+        {
+            target: "public files",
+            type: FileListType.All,
+            expected: [
+                "Cargo.toml",
+                "readme.md",
+                "src/lib.rs",
+                "src/main.rs",
+                "test/basic.js",
+                "test/basic_testcases.json",
+                "test/in/basic/1.in",
+                "test/in/basic/2.in",
+                "test/out/basic/1.out",
+                "test/out/basic/2.out",
+                "test/settings.json",
+            ],
+        },
+        {
+            target: "readonly public files",
+            type: FileListType.ReadOnlyChallengeFiles,
+            expected: [
+                "test/basic.js",
+                "test/basic_testcases.json",
+                "test/in/basic/1.in",
+                "test/in/basic/2.in",
+                "test/out/basic/1.out",
+                "test/out/basic/2.out",
+                "test/settings.json",
+            ],
+        },
+        {
+            target: "editable files",
+            type: FileListType.EditableChallengeFiles,
+            expected: [
+                "Cargo.toml",
+                "readme.md",
+                "src/main.rs",
+            ],
+        },
+        {
+            target: "public files",
+            type: FileListType.UserAddedFiles,
+            expected: [
+                "src/lib.rs",
+            ],
+        },
+        {
+            target: "public files",
+            type: FileListType.Editable,
+            expected: [
+                "Cargo.toml",
+                "readme.md",
+                "src/lib.rs",
+                "src/main.rs",
+            ],
+        },
+    ];
+    testcases.forEach(({ target, type, expected }) => {
+        const flt = (Object.entries(FileListType).find(([_, v]) => v === type) ?? ["", 0])[0];
+        it(`should list all ${target} with FileListType.${flt}`, () => {
+            const actual = mod.listFileNames(context, type);
+            actual.sort();
+            assertEquals(actual, expected);
+        });
+    });
+});
+describe("SnakeCase", () => {
+    describe(".to()", () => {
+        it("should convert string correctly", () => {
+            assertEquals(mod.SnakeCase.to("helloWorld"), "hello_world");
+        });
+        it("should keep string as is if it is already snake case", () => {
+            assertEquals(mod.SnakeCase.to("hello_world"), "hello_world");
+        });
+        it("should accept empty object", () => {
+            assertEquals(mod.SnakeCase.to({}), {});
+        });
+        it("should convert object correctly", () => {
+            assertEquals(mod.SnakeCase.to({
+                helloWorld: "foo",
+            }), {
+                hello_world: "foo",
+            });
+        });
+        it("should keep object as is if it is already snake case", () => {
+            // @ts-ignore key of the object may change
+            assertEquals(mod.SnakeCase.to({
+                hello_world: "foo",
+            }), {
+                hello_world: "foo",
+            });
+        });
+        it("should keep object values as is", () => {
+            // @ts-ignore key of the object may change
+            assertEquals(mod.SnakeCase.to({
+                helloWorld: "helloWorld",
+                another_world: "anotherWorld",
+            }), {
+                hello_world: "helloWorld",
+                another_world: "anotherWorld",
+            });
+        });
+        it("should keep array as is", () => {
+            assertEquals(mod.SnakeCase.to(["helloWorld", "another_world"]), ["helloWorld", "another_world"]);
+            assertEquals(mod.SnakeCase.to({
+                helloWorld: ["helloWorld", "another_world"],
+            }), {
+                hello_world: ["helloWorld", "another_world"],
+            });
+        });
+        it("should treat nested object correctly", () => {
+            assertEquals(mod.SnakeCase.to({
+                helloWorld: {
+                    anotherWorld: "fooBar",
+                },
+            }), {
+                hello_world: {
+                    another_world: "fooBar",
+                },
+            });
+        });
+        it("should ignore primitive types other than strings", () => {
+            assertEquals(mod.SnakeCase.to(1), 1);
+            assertEquals(mod.SnakeCase.to(true), true);
+            assertEquals(mod.SnakeCase.to(undefined), undefined);
+            assertEquals(mod.SnakeCase.to(null), null);
+        });
+    });
+    describe(".from()", () => {
+        it("should convert string correctly", () => {
+            assertEquals(mod.SnakeCase.from("hello_world"), "helloWorld");
+        });
+        it("should keep string as is if it is already camelCase", () => {
+            assertEquals(mod.SnakeCase.from("helloWorld"), "helloWorld");
+        });
+        it("should accept empty object", () => {
+            assertEquals(mod.SnakeCase.to({}), {});
+        });
+        it("should convert object correctly", () => {
+            assertEquals(mod.SnakeCase.from({
+                hello_world: "foo",
+            }), {
+                helloWorld: "foo",
+            });
+        });
+        it("should keep object as is if it is already camelCase", () => {
+            // @ts-ignore key of the object may change
+            assertEquals(mod.SnakeCase.from({
+                helloWorld: "foo",
+            }), {
+                helloWorld: "foo",
+            });
+        });
+        it("should keep object values as is", () => {
+            // @ts-ignore key of the object may change
+            assertEquals(mod.SnakeCase.from({
+                helloWorld: "hello_world",
+                another_world: "another_world",
+            }), {
+                helloWorld: "hello_world",
+                anotherWorld: "another_world",
+            });
+        });
+        it("should keep array as is", () => {
+            assertEquals(mod.SnakeCase.from(["helloWorld", "another_world"]), ["helloWorld", "another_world"]);
+            assertEquals(mod.SnakeCase.from({
+                hello_world: ["helloWorld", "another_world"],
+            }), {
+                helloWorld: ["helloWorld", "another_world"],
+            });
+        });
+        it("should treat nested object correctly", () => {
+            assertEquals(mod.SnakeCase.from({
+                hello_world: {
+                    another_world: "foo_bar",
+                },
+            }), {
+                helloWorld: {
+                    anotherWorld: "foo_bar",
+                },
+            });
+        });
+        it("should ignore primitive types other than strings", () => {
+            assertEquals(mod.SnakeCase.from(1), 1);
+            assertEquals(mod.SnakeCase.from(true), true);
+            assertEquals(mod.SnakeCase.from(undefined), undefined);
+            assertEquals(mod.SnakeCase.from(null), null);
+        });
+    });
+});
+describe("scoreRatio() (Inner method)", () => {
+    it("should return `N/A` if `track run` is never executed", () => {
+        assertStringIncludes(mod._internals.scoreRatio(undefined, 10), "N/A");
+    });
+    it("should return `N/A` for challenges without open testcase", () => {
+        assertStringIncludes(mod._internals.scoreRatio(undefined, undefined), "N/A");
+    });
+    it("should return score if `track run` is once after executed", () => {
+        assertStringIncludes(mod._internals.scoreRatio(0, 10), "0/10");
+        assertStringIncludes(mod._internals.scoreRatio(5, 10), "5/10");
+        assertStringIncludes(mod._internals.scoreRatio(10, 10), "10/10");
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "track-cli",
-  "version": "4.0.3",
+  "version": "4.1.0-rc2",
   "description": "A CLI for interacting with tracks.run and running code tests on track's servers",
   "repository": {
     "type": "git",

package/test_runner.js

@@ -0,0 +1,186 @@
+const pc = require("picocolors");
+const process = require("process");
+const { pathToFileURL } = require("url");
+const { testDefinitions } = require("@deno/shim-deno/test-internals");
+const filePaths = [
+    "src/track/test.js",
+    "test/shared/config_test.js",
+    "test/shared/file_test.js",
+    "test/shared/mod_test.js",
+];
+async function main() {
+    const testContext = {
+        process,
+        pc,
+    };
+    for (const [i, filePath] of filePaths.entries()) {
+        if (i > 0) {
+            console.log("");
+        }
+        const esmPath = "./esm/" + filePath;
+        console.log("\nRunning tests in " + pc.underline(esmPath) + "...\n");
+        process.chdir(__dirname + "/esm");
+        const esmTestContext = {
+            origin: pathToFileURL(filePath).toString(),
+            ...testContext,
+        };
+        await import(esmPath);
+        await runTestDefinitions(testDefinitions.splice(0, testDefinitions.length), esmTestContext);
+    }
+}
+async function runTestDefinitions(testDefinitions, options) {
+    const testFailures = [];
+    for (const definition of testDefinitions) {
+        options.process.stdout.write("test " + definition.name + " ...");
+        if (definition.ignore) {
+            options.process.stdout.write(` ${options.pc.gray("ignored")}\n`);
+            continue;
+        }
+        const context = getTestContext(definition, undefined);
+        let pass = false;
+        try {
+            await definition.fn(context);
+            if (context.hasFailingChild) {
+                testFailures.push({
+                    name: definition.name,
+                    err: new Error("Had failing test step.")
+                });
+            }
+            else {
+                pass = true;
+            }
+        }
+        catch (err) {
+            testFailures.push({
+                name: definition.name,
+                err
+            });
+        }
+        const testStepOutput = context.getOutput();
+        if (testStepOutput.length > 0) {
+            options.process.stdout.write(testStepOutput);
+        }
+        else {
+            options.process.stdout.write(" ");
+        }
+        options.process.stdout.write(getStatusText(pass ? "ok" : "fail"));
+        options.process.stdout.write("\n");
+    }
+    if (testFailures.length > 0) {
+        options.process.stdout.write("\nFAILURES");
+        for (const failure of testFailures) {
+            options.process.stdout.write("\n\n");
+            options.process.stdout.write(failure.name + "\n");
+            options.process.stdout.write(indentText((failure.err?.stack ?? failure.err).toString(), 1));
+        }
+        options.process.exit(1);
+    }
+    function getTestContext(definition, parent) {
+        return {
+            name: definition.name,
+            parent,
+            origin: options.origin,
+            /** @type {any} */ err: undefined,
+            status: "ok",
+            children: [],
+            get hasFailingChild() {
+                return this.children.some((c) => c.status === "fail" || c.status === "pending");
+            },
+            getOutput() {
+                let output = "";
+                if (this.parent) {
+                    output += "test " + this.name + " ...";
+                }
+                if (this.children.length > 0) {
+                    output += "\n" + this.children.map((c) => indentText(c.getOutput(), 1)).join("\n") + "\n";
+                }
+                else if (!this.err) {
+                    output += " ";
+                }
+                if (this.parent && this.err) {
+                    output += "\n";
+                }
+                if (this.err) {
+                    output += indentText((this.err.stack ?? this.err).toString(), 1);
+                    if (this.parent) {
+                        output += "\n";
+                    }
+                }
+                if (this.parent) {
+                    output += getStatusText(this.status);
+                }
+                return output;
+            },
+            async step(nameOrTestDefinition, fn) {
+                const definition = getDefinition();
+                const context = getTestContext(definition, this);
+                context.status = "pending";
+                this.children.push(context);
+                if (definition.ignore) {
+                    context.status = "ignored";
+                    return false;
+                }
+                try {
+                    await definition.fn(context);
+                    context.status = "ok";
+                    if (context.hasFailingChild) {
+                        context.status = "fail";
+                        return false;
+                    }
+                    return true;
+                }
+                catch (err) {
+                    context.status = "fail";
+                    context.err = err;
+                    return false;
+                }
+                /** @returns {TestDefinition} */ function getDefinition() {
+                    if (typeof nameOrTestDefinition === "string") {
+                        if (!(fn instanceof Function)) {
+                            throw new TypeError("Expected function for second argument.");
+                        }
+                        return {
+                            name: nameOrTestDefinition,
+                            fn
+                        };
+                    }
+                    else if (typeof nameOrTestDefinition === "object") {
+                        return nameOrTestDefinition;
+                    }
+                    else {
+                        throw new TypeError("Expected a test definition or name and function.");
+                    }
+                }
+            }
+        };
+    }
+    function getStatusText(status) {
+        switch (status) {
+            case "ok":
+                return options.pc.green(status);
+            case "fail":
+            case "pending":
+                return options.pc.red(status);
+            case "ignored":
+                return options.pc.gray(status);
+            default:
+                {
+                    const _assertNever = status;
+                    return status;
+                }
+        }
+    }
+    function indentText(text, indentLevel) {
+        if (text === undefined) {
+            text = "[undefined]";
+        }
+        else if (text === null) {
+            text = "[null]";
+        }
+        else {
+            text = text.toString();
+        }
+        return text.split(/\r?\n/).map((line) => "  ".repeat(indentLevel) + line).join("\n");
+    }
+}
+main();