track-cli 4.0.3 → 4.1.0-rc1

package/esm/test/shared/config_test.js

@@ -0,0 +1,57 @@
+import * as dntShim from "../../_dnt.test_shims.js";
+import * as config from "../../src/shared/config.js";
+import { MissingConfigFile } from "../../src/shared/errors.js";
+import { assertEquals, assertRejects } from "../../deps/deno.land/std@0.195.0/testing/asserts.js";
+import { afterEach, beforeEach, describe, it } from "../../deps/deno.land/std@0.195.0/testing/bdd.js";
+import { TrackApp } from "../../src/shared/types.js";
+const testConfig = {
+    app: TrackApp.Test,
+    baseUrl: "https://app.tracks.run",
+    orgName: "anorg",
+    basicAuth: {
+        username: "user",
+        password: "pass",
+    },
+    token: "SECRET_TOKEN",
+    applicantExamId: 100,
+    challengeId: 200,
+    challengeResultId: 300,
+    cookies: {
+        PLAY_SESSION: "session",
+    },
+    programmingLanguage: 10,
+};
+describe("save()", () => {
+    let dir;
+    beforeEach(async () => {
+        dir = await dntShim.Deno.makeTempDir();
+    });
+    afterEach(async () => {
+        await dntShim.Deno.remove(dir, { recursive: true });
+    });
+    it("should save config to file with json format", async () => {
+        const path = `${dir}/config.json`;
+        await config.save(testConfig, { path });
+        const actual = new TextDecoder().decode(await dntShim.Deno.readFile(path));
+        assertEquals(JSON.parse(actual), testConfig);
+    });
+});
+describe("load()", () => {
+    let dir;
+    beforeEach(async () => {
+        dir = await dntShim.Deno.makeTempDir();
+    });
+    afterEach(async () => {
+        await dntShim.Deno.remove(dir, { recursive: true });
+    });
+    it("should save config to file with json format", async () => {
+        const path = `${dir}/config.json`;
+        await dntShim.Deno.writeFile(path, new TextEncoder().encode(JSON.stringify(testConfig)));
+        const actual = await config.load({ path });
+        assertEquals(actual, testConfig);
+    });
+    it("should throw error if config file does not exist", async () => {
+        const path = `${dir}/config.json`;
+        await assertRejects(async () => await config.load({ path }), MissingConfigFile);
+    });
+});

package/esm/test/shared/file_test.d.ts

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

package/esm/test/shared/file_test.js

@@ -0,0 +1,265 @@
+import * as dntShim from "../../_dnt.test_shims.js";
+import * as file from "../../src/shared/file.js";
+import { assertEquals, assertObjectMatch } from "../../deps/deno.land/std@0.195.0/testing/asserts.js";
+import { afterAll, afterEach, beforeAll, beforeEach, describe, it, } from "../../deps/deno.land/std@0.195.0/testing/bdd.js";
+async function prepareFiles(dir, files) {
+    for (const [name, content] of Object.entries(files)) {
+        if (typeof content === "string") {
+            await dntShim.Deno.writeTextFile(`${dir}/${name}`, content);
+        }
+        else {
+            await dntShim.Deno.mkdir(`${dir}/${name}`);
+            await prepareFiles(`${dir}/${name}`, content);
+        }
+    }
+}
+describe("pathsToFilenameSet()", () => {
+    let dir;
+    const files = {
+        "a.txt": "hello",
+        "b": {
+            "c.txt": "world",
+            "d": {
+                "e.txt": "foo",
+            },
+        },
+    };
+    beforeAll(async () => {
+        dir = await dntShim.Deno.makeTempDir();
+        await prepareFiles(dir, files);
+    });
+    afterAll(async () => {
+        await dntShim.Deno.remove(dir, { recursive: true });
+    });
+    it("should list only existing files without options", async () => {
+        const result = await file.pathsToFilenameSet(["a.txt", "b/c.txt", "b/d", "x/y", "z.txt"], { root: dir });
+        assertEquals(result, new Set(["a.txt", "b/c.txt"]));
+    });
+    it("should search files recursively with recursive = true", async () => {
+        const result = await file.pathsToFilenameSet(["a.txt", "b", "x/y", "z.txt"], { recursive: true, root: dir });
+        assertEquals(result, new Set(["a.txt", "b/c.txt", "b/d/e.txt"]));
+    });
+    it("should search files recursively and list non-existing files and directories with recursive = true and allowNonExistent = true", async () => {
+        const result = await file.pathsToFilenameSet(["a.txt", "b", "x/y", "z.txt"], { recursive: true, allowNonExistent: true, root: dir });
+        assertEquals(result, new Set(["a.txt", "b/c.txt", "b/d/e.txt", "x/y", "z.txt"]));
+    });
+    it("should support absolute paths", async () => {
+        const result = await file.pathsToFilenameSet([`${dir}/a.txt`, `${dir}/b`, `${dir}/x/y`, `${dir}/z.txt`], { recursive: true, allowNonExistent: true, root: dir });
+        assertEquals(result, new Set(["a.txt", "b/c.txt", "b/d/e.txt", "x/y", "z.txt"]));
+    });
+    it("should support only paths with root", async () => {
+        const anotherDir = await dntShim.Deno.makeTempDir();
+        await prepareFiles(anotherDir, files);
+        const result = await file.pathsToFilenameSet([`${dir}/a.txt`, `${anotherDir}/z.txt`], { recursive: true, allowNonExistent: true, root: dir });
+        assertEquals(result, new Set(["a.txt"]));
+    });
+});
+describe("stat()", () => {
+    let dir;
+    const files = {
+        "a.txt": "hello",
+        "b": {
+            "c.txt": "world",
+        },
+    };
+    beforeAll(async () => {
+        dir = await dntShim.Deno.makeTempDir();
+        await prepareFiles(dir, files);
+    });
+    afterAll(async () => {
+        await dntShim.Deno.remove(dir, { recursive: true });
+    });
+    it("should return stat of file", async () => {
+        const result = await file.stat(`${dir}/a.txt`);
+        assertObjectMatch(result, {
+            isFile: true,
+            isDirectory: false,
+        });
+    });
+    it("should return stat of directory", async () => {
+        const result = await file.stat(`${dir}/b`);
+        assertObjectMatch(result, {
+            isFile: false,
+            isDirectory: true,
+        });
+    });
+    it("should return null if file does not exist", async () => {
+        const result = await file.stat(`${dir}/x.txt`);
+        assertEquals(result, null);
+    });
+    it("should support subdirectories", async () => {
+        const result = await file.stat(`${dir}/b/c.txt`);
+        assertObjectMatch(result, {
+            isFile: true,
+            isDirectory: false,
+        });
+    });
+});
+describe("isEmptyDirectory()", () => {
+    let dir;
+    const files = {
+        "a.txt": "hello",
+        "b": {
+            "c.txt": "world",
+        },
+        "d": {},
+    };
+    beforeAll(async () => {
+        dir = await dntShim.Deno.makeTempDir();
+        await prepareFiles(dir, files);
+    });
+    afterAll(async () => {
+        await dntShim.Deno.remove(dir, { recursive: true });
+    });
+    it("should return ture if directory is empty", async () => {
+        const result = await file.isEmptyDirectory(`${dir}/d`);
+        assertEquals(result, true);
+    });
+    it("should return false if directory is not empty", async () => {
+        const result = await file.isEmptyDirectory(`${dir}/b`);
+        assertEquals(result, false);
+    });
+    it("should return false if directory nor file does not exist", async () => {
+        const result = await file.isEmptyDirectory(`${dir}/x`);
+        assertEquals(result, false);
+    });
+    it("should return false if path is a file", async () => {
+        const result = await file.isEmptyDirectory(`${dir}/a.txt`);
+        assertEquals(result, false);
+    });
+});
+describe("getAllDirFiles()", () => {
+    let dir;
+    const files = {
+        "a.txt": "hello",
+        "b": {
+            "c.txt": "world",
+        },
+        "d": {},
+    };
+    beforeAll(async () => {
+        dir = await dntShim.Deno.makeTempDir();
+        await prepareFiles(dir, files);
+    });
+    afterAll(async () => {
+        await dntShim.Deno.remove(dir, { recursive: true });
+    });
+});
+describe("untgz()", () => {
+    it("should extract tar.gz file", async () => {
+        const input = `
+      1f8b 0800 0000 0000 0003 edd5 df0a 8230
+      1c86 e11d 7715 5e81 6eee dff5 440a 4586
+      6046 75f7 b9a1 d091 d4c1 26d1 fb30 1c8c.
+      813f f8e0 5b59 89e4 e4c4 4b19 76e5 edbc
+      1b1f cf67 4219 e38c 9261 09a9 c23d 51d8
+      f4a3 0971 bb8e fba1 28c4 e5f4 dcaf dd6b
+      fac3 b91d 724c 9455 591d dbae ebcb f131
+      26fb 4708 d819 b392 bf5b f2d7 deaa 29ff
+      5a5a 270a 996c a237 7f9e 7f4c 7fb7 f514
+      d84a 59dd fba1 6b92 be02 b1ff adfd a4ff
+      b5f7 d3b9 52da d2ff 592c f9c7 6fa2 57e0
+      abfe 8ff9 ebda 28fa 3f87 983b fd0f 0000
+      0000 0000 0000 0000 3fef 0500 d28d ca00
+      2800 00
+    `
+            .replaceAll(" ", "")
+            .match(/.{2}/g)
+            ?.map((byte) => parseInt(byte, 16));
+        const expected = [
+            { name: "hello.txt", content: "hello\n" },
+            { name: "world/world.txt", content: "world\n" },
+        ];
+        const dir = await dntShim.Deno.makeTempDir();
+        await file.untgz(new Uint8Array(input), dir);
+        for (const { name, content } of expected) {
+            const actual = await dntShim.Deno.readTextFile(`${dir}/${name}`);
+            assertEquals(actual, content);
+        }
+        await dntShim.Deno.remove(dir, { recursive: true });
+    });
+});
+describe("toNixStyle()", () => {
+    describe("on Windows", () => {
+        const originalSeparator = file._internals.SEP;
+        beforeAll(() => {
+            file._internals.SEP = "/";
+        });
+        afterAll(() => {
+            file._internals.SEP = originalSeparator;
+        });
+        it("should return path with forward slashes", () => {
+            assertEquals(file.toNixStyle("a\\b\\c"), "a/b/c");
+            assertEquals(file.toNixStyle("a/b/c"), "a/b/c");
+            assertEquals(file.toNixStyle("a\\b/c"), "a/b/c");
+        });
+    });
+    describe("on Linux and macOS", () => {
+        const originalSeparator = file._internals.SEP;
+        beforeAll(() => {
+            file._internals.SEP = "/";
+        });
+        afterAll(() => {
+            file._internals.SEP = originalSeparator;
+        });
+        it("should return path with forward slashes", () => {
+            assertEquals(file.toNixStyle("a\\b\\c"), "a/b/c");
+            assertEquals(file.toNixStyle("a/b/c"), "a/b/c");
+            assertEquals(file.toNixStyle("a\\b/c"), "a/b/c");
+        });
+    });
+});
+describe("toNativeStyle()", () => {
+    describe("on Windows", () => {
+        const originalSeparator = file._internals.SEP;
+        beforeAll(() => {
+            file._internals.SEP = "\\";
+        });
+        afterAll(() => {
+            file._internals.SEP = originalSeparator;
+        });
+        it("should return path with forward slashes", () => {
+            assertEquals(file.toNativeStyle("a\\b\\c"), "a\\b\\c");
+            assertEquals(file.toNativeStyle("a/b/c"), "a\\b\\c");
+            assertEquals(file.toNativeStyle("a\\b/c"), "a\\b\\c");
+        });
+    });
+    describe("on Linux and macOS", () => {
+        const originalSeparator = file._internals.SEP;
+        beforeAll(() => {
+            file._internals.SEP = "/";
+        });
+        afterAll(() => {
+            file._internals.SEP = originalSeparator;
+        });
+        it("should return path with forward slashes", () => {
+            assertEquals(file.toNativeStyle("a\\b\\c"), "a/b/c");
+            assertEquals(file.toNativeStyle("a/b/c"), "a/b/c");
+            assertEquals(file.toNativeStyle("a\\b/c"), "a/b/c");
+        });
+    });
+});
+describe("getUniqueDirName()", () => {
+    let dir;
+    const files = {
+        "foo": {},
+        "foo_1": {},
+        "foo_2": {},
+        "bar": {},
+    };
+    beforeEach(async () => {
+        dir = await dntShim.Deno.makeTempDir();
+        await prepareFiles(dir, files);
+    });
+    afterEach(async () => {
+        await dntShim.Deno.remove(dir, { recursive: true });
+    });
+    it("should return unique name", async () => {
+        const actual = await file.getUniqueDirName("bar", { root: dir });
+        assertEquals(actual, "bar_1");
+    });
+    it("should return unique name with counter > 1 if the candidate exists", async () => {
+        const actual = await file.getUniqueDirName("foo", { root: dir });
+        assertEquals(actual, "foo_3");
+    });
+});

package/esm/test/shared/mod_test.d.ts

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

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");
+    });
+});