programming-challenges/cli/commands/run/__test__/solution.test.ts

import test from 'node:test'
import assert from 'node:assert/strict'
import { PassThrough } from 'node:stream'
import path from 'node:path'

import sinon from 'sinon'
import chalk from 'chalk'

import { cli } from '../../../cli.js'

const input = ['run', 'solution']
const challenge = 'hello-world'
const language = 'c'
const solution = 'function'
const inputPath = path.join(
  process.cwd(),
  'challenges',
  challenge,
  'test',
  '1',
  'input.txt'
)
const inputChallenge = `--challenge=${challenge}`
const inputLanguage = `--language=${language}`
const inputSolution = `--solution=${solution}`
const inputInputPath = `--input-path=${inputPath}`

await test('programming-challenges run solution', async (t) => {
  t.afterEach(() => {
    sinon.restore()
  })

  await t.test('succeeds', async () => {
    sinon.stub(console, 'log').value(() => {})
    const consoleLogSpy = sinon.spy(console, 'log')
    const stream = new PassThrough()
    const exitCode = await cli.run(
      [
        ...input,
        inputChallenge,
        inputSolution,
        inputLanguage,
        inputInputPath,
        '--output'
      ],
      {
        stdin: process.stdin,
        stdout: stream,
        stderr: stream
      }
    )
    stream.end()
    assert.strictEqual(exitCode, 0)
    assert.strictEqual(consoleLogSpy.calledWith(`Hello, world!`), true)
  })

  await t.test("fails with solution that doesn't exist", async () => {
    sinon.stub(console, 'error').value(() => {})
    const consoleErrorSpy = sinon.spy(console, 'error')
    const stream = new PassThrough()
    const invalidSolution = 'invalid'
    const inputInvalidSolution = `--solution=${invalidSolution}`
    const exitCode = await cli.run(
      [
        ...input,
        inputChallenge,
        inputInvalidSolution,
        inputLanguage,
        inputInputPath
      ],
      {
        stdin: process.stdin,
        stdout: stream,
        stderr: stream
      }
    )
    stream.end()
    assert.strictEqual(exitCode, 1)
    assert.strictEqual(
      consoleErrorSpy.calledWith(
        chalk.bold.red('Error:') + ' The solution was not found.'
      ),
      true
    )
  })

  await t.test('fails with invalid language', async () => {
    sinon.stub(console, 'error').value(() => {})
    const consoleErrorSpy = sinon.spy(console, 'error')
    const stream = new PassThrough()
    const invalidLanguage = 'invalid'
    const inputInvalidLanguage = `--language=${invalidLanguage}`
    const exitCode = await cli.run(
      [
        ...input,
        inputChallenge,
        inputSolution,
        inputInvalidLanguage,
        inputInputPath
      ],
      {
        stdin: process.stdin,
        stdout: stream,
        stderr: stream
      }
    )
    stream.end()
    assert.strictEqual(exitCode, 1)
    assert.strictEqual(
      consoleErrorSpy.calledWith(
        chalk.bold.red('Error:') +
          ' This programming language is not supported yet.'
      ),
      true
    )
  })

  await t.test('fails with invalid `input-path`', async () => {
    sinon.stub(console, 'error').value(() => {})
    const consoleErrorSpy = sinon.spy(console, 'error')
    const stream = new PassThrough()
    const invalidInputPath = 'invalid'
    const inputInvalidInputPath = `--input-path=${invalidInputPath}`
    const inputPath = path.resolve(process.cwd(), invalidInputPath)
    const exitCode = await cli.run(
      [
        ...input,
        inputChallenge,
        inputSolution,
        inputLanguage,
        inputInvalidInputPath
      ],
      {
        stdin: process.stdin,
        stdout: stream,
        stderr: stream
      }
    )
    stream.end()
    assert.strictEqual(exitCode, 1)
    assert.strictEqual(
      consoleErrorSpy.calledWith(
        chalk.bold.red('Error:') +
          ` The \`input-path\` doesn't exist: ${inputPath}.`
      ),
      true
    )
  })
})