track-cli 4.0.3 → 4.1.0-rc2

package/esm/src/track/test.js

@@ -1,11 +1,11 @@
-import { ExamCanceled, ExamExpired, ExamSubmitted, ExamUnread, InvalidChallengeId, OtherError, } from "../shared/errors.js";
+import { ExamCanceled, ExamExpired, ExamSubmitted, ExamUnread, InvalidChallengeId, OtherError, UnsupportedChallenge, } from "../shared/errors.js";
 import { HttpStatus } from "../shared/mod.js";
 import { ChallengeStyle, } from "../shared/types.js";
 import { FormType, TrackClientBase, } from "./client.js";
 // @ts-ignore: has no exported member
 import { CookieJar, fetch } from "node-fetch-cookies";
 export class TestClient extends TrackClientBase {
-    constructor(baseUrl, orgName, token, challengeId, basic, cookies) {
+    constructor(baseUrl, orgName, token, challengeId, basic, cookies, applicantExamId, challengeResultId) {
         super(baseUrl, basic, cookies);
         Object.defineProperty(this, "orgName", {
             enumerable: true,
@@ -40,6 +40,8 @@ export class TestClient extends TrackClientBase {
         this.orgName = orgName;
         this.token = token;
         this.challengeId = challengeId;
+        this.applicantExamId = applicantExamId ?? 0;
+        this.resultId = challengeResultId ?? 0;
     }
     config() {
         return {
@@ -69,6 +71,9 @@ export class TestClient extends TrackClientBase {
         if (!challenge) {
             throw new InvalidChallengeId(this.challengeId);
         }
+        else if (!this.isChallengeSupported(challenge)) {
+            throw new UnsupportedChallenge(this.challengeId);
+        }
         this.applicantExamId = applicantExam.id;
         this.resultId = result?.id || 0;
         return challenge;
@@ -98,14 +103,24 @@ export class TestClient extends TrackClientBase {
         return examSession.challengesSets
             .flatMap((s) => s.challenges)
             .map((esc) => toChallengeSession(esc, result))
-            .find((c) => c.challengeId === this.challengeId &&
-            (c.style === ChallengeStyle.Development ||
-                c.style === ChallengeStyle.Algorithm));
+            .find((c) => c.challengeId === this.challengeId);
+    }
+    isChallengeSupported(c) {
+        return (c.style === ChallengeStyle.Development ||
+            c.style === ChallengeStyle.Algorithm ||
+            c.style === ChallengeStyle.Function ||
+            c.style === ChallengeStyle.Frontend);
     }
     async languages() {
         return (await this._get(`/api/enum/challenges/programminglanguages`))
             .map(toProgrammingLanguageInfo);
     }
+    async frontendTemplates() {
+        return await this._get(`/api/dock-public/v2/consumer/frontend-templates`);
+    }
+    async frontendTemplate(code) {
+        return await this._get(`/api/dock-public/v2/consumer/frontend-templates/${code}`);
+    }
     async start() {
         return await this._put(`/api/applicants/exams/${this.applicantExamId}/results/${this.resultId}/start`, FormType.URLEncoded, {
             takenBy: 3, // 3 = LocalMachine
@@ -121,6 +136,12 @@ export class TestClient extends TrackClientBase {
             programmingLanguage: language,
         }); // ChallengeResult
     }
+    async updateFrontendTemplate(seriesCode) {
+        return await this._post(`/api/applicants/exams/${this.applicantExamId}/results/${this.resultId}/frontend/switch-frontend-template`, FormType.JSON, {
+            seriesCode,
+            forceReset: true,
+        });
+    }
     async timeLeft() {
         return await this._get(`/api/applicants/exams/${this.applicantExamId}/results/${this.resultId}/timeleft`);
     }
@@ -171,6 +192,8 @@ function toChallengeSession(esc, result) {
         timeLimitMinutes: esc.timeLimitMinutes,
         displayOrder: esc.displayOrder,
         programmingLanguages: esc.programmingLanguages,
+        allowedTemplateSeriesCodes: esc.frontendStyleConfig
+            ?.allowedTemplateSeriesCodes,
         localCodingAllowed: esc.localExamEnabled,
         openTestcases: esc.openTestcases,
         result,

package/esm/src/track/training.d.ts

@@ -1,5 +1,5 @@
 import { TrackTrainingConfigPart } from "../shared/config.js";
-import { ChallengeResult, ChallengeSession, CodingContext, ProgrammingLanguage, ProgrammingLanguageInfo, SaveFilesRequest } from "../shared/types.js";
+import { ChallengeResult, ChallengeSession, CodingContext, FrontendTemplateInfo, ProgrammingLanguage, ProgrammingLanguageInfo, SaveFilesRequest } from "../shared/types.js";
 import { BasicAuth, TrackClient, TrackClientBase } from "./client.js";
 export declare class TrainingClient extends TrackClientBase implements TrackClient {
     private orgName;
@@ -13,9 +13,12 @@ export declare class TrainingClient extends TrackClientBase implements TrackClie
     startChallengeSession(): Promise<ChallengeSession>;
     continueChallengeSession(): Promise<ChallengeSession>;
     languages(): Promise<ProgrammingLanguageInfo[]>;
+    frontendTemplates(): Promise<FrontendTemplateInfo[]>;
+    frontendTemplate(_code: string): Promise<FrontendTemplateInfo>;
     start(): Promise<ChallengeResult>;
     prepare(): Promise<ChallengeResult>;
     updateLanguage(language: ProgrammingLanguage): Promise<void>;
+    updateFrontendTemplate(_templateCode: string): Promise<void>;
     timeLeft(): Promise<number>;
     context(): Promise<CodingContext>;
     presigned(files: string[]): Promise<{

package/esm/src/track/training.js

@@ -74,6 +74,12 @@ export class TrainingClient extends TrackClientBase {
         return (await this._get(`/cli/languages`))
             .map(toProgrammingLanguageInfo);
     }
+    frontendTemplates() {
+        throw new OtherError("Frontend templates are not supported in training mode");
+    }
+    frontendTemplate(_code) {
+        throw new OtherError("Frontend templates are not supported in training mode");
+    }
     async start() {
         return await this._put(`/api/train/${this.klassId}/challenges/results/${this.klassResultId}/start`, FormType.JSON, {
             takenBy: 3, // 3 = LocalMachine
@@ -87,6 +93,9 @@ export class TrainingClient extends TrackClientBase {
             lang: language,
         });
     }
+    updateFrontendTemplate(_templateCode) {
+        throw new OtherError("Frontend templates are not supported in training mode");
+    }
     async timeLeft() {
         return await this._get(`/api/train/${this.klassId}/challenges/results/${this.klassResultId}/timeleft`);
     }

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

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

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 {};