programming-challenges/cli/services/__test__/GitAffected.test.ts

import test from "node:test"
import assert from "node:assert/strict"
import crypto from "node:crypto"

import sinon from "sinon"

import { Challenge } from "../Challenge.js"
import { GitAffected } from "../GitAffected.js"
import { Solution } from "../Solution.js"
import { parseCommandOutput } from "../../utils/parseCommandOutput.js"

const gitAffected = new GitAffected()

await test("services/GitAffected", async (t) => {
  t.afterEach(() => {
    sinon.restore()
  })

  t.beforeEach(() => {
    sinon.stub(crypto, "randomUUID").value(() => {
      return "uuid"
    })
  })

  await t.test("parseCommandOutput", async (t) => {
    await t.test("returns the right output array", async () => {
      assert.deepStrictEqual(parseCommandOutput("1.txt\n 2.txt "), [
        "1.txt",
        "2.txt",
      ])
    })
  })

  await t.test("getAffectedSolutionsFromFiles", async (t) => {
    await t.test("returns the affected solutions", async () => {
      const files = [
        "challenges/hello-world/solutions/javascript/function/solution.js",
        "challenges/is-palindrome/solutions/c/function/input.c",
      ]
      const solutions = await gitAffected.getAffectedSolutionsFromFiles(files)
      assert.deepStrictEqual(solutions, [
        new Solution({
          challenge: new Challenge({ name: "hello-world" }),
          name: "function",
          programmingLanguageName: "javascript",
        }),
        new Solution({
          challenge: new Challenge({ name: "is-palindrome" }),
          name: "function",
          programmingLanguageName: "c",
        }),
      ])
    })

    await t.test(
      "returns the affected solutions from Dockerfile changes",
      async () => {
        const files = ["templates/docker/javascript/Dockerfile"]
        const solutions = await gitAffected.getAffectedSolutionsFromFiles(files)
        assert.deepStrictEqual(
          solutions[0],
          new Solution({
            challenge: new Challenge({ name: "camel-case" }),
            name: "function",
            programmingLanguageName: "javascript",
          }),
        )
        assert.deepStrictEqual(
          solutions[1],
          new Solution({
            challenge: new Challenge({ name: "first-non-repeating-character" }),
            name: "function",
            programmingLanguageName: "javascript",
          }),
        )
      },
    )

    await t.test(
      "returns the affected solutions from Docker template changes",
      async () => {
        const files = ["templates/docker/javascript/package.json"]
        const solutions = await gitAffected.getAffectedSolutionsFromFiles(files)
        assert.deepStrictEqual(
          solutions[0],
          new Solution({
            challenge: new Challenge({ name: "camel-case" }),
            name: "function",
            programmingLanguageName: "javascript",
          }),
        )
        assert.deepStrictEqual(
          solutions[1],
          new Solution({
            challenge: new Challenge({ name: "first-non-repeating-character" }),
            name: "function",
            programmingLanguageName: "javascript",
          }),
        )
      },
    )

    await t.test(
      "returns the affected solutions from input/output files",
      async () => {
        const files = ["challenges/hello-world/test/1/input.txt"]
        const solutions = await gitAffected.getAffectedSolutionsFromFiles(files)
        assert.deepStrictEqual(
          solutions[0],
          new Solution({
            challenge: new Challenge({ name: "hello-world" }),
            name: "function",
            programmingLanguageName: "c",
          }),
        )
        assert.deepStrictEqual(
          solutions[1],
          new Solution({
            challenge: new Challenge({ name: "hello-world" }),
            name: "function",
            programmingLanguageName: "cpp",
          }),
        )
        assert.deepStrictEqual(
          solutions[2],
          new Solution({
            challenge: new Challenge({ name: "hello-world" }),
            name: "function",
            programmingLanguageName: "cs",
          }),
        )
        assert.deepStrictEqual(
          solutions[3],
          new Solution({
            challenge: new Challenge({ name: "hello-world" }),
            name: "function",
            programmingLanguageName: "dart",
          }),
        )
      },
    )
  })
})