1
1
mirror of https://github.com/theoludwig/html-w3c-validator.git synced 2025-05-21 23:21:29 +02:00

chore: better Prettier config for easier reviews

This commit is contained in:
2023-10-23 23:21:05 +02:00
parent e3cd809e56
commit 02a5010340
20 changed files with 2487 additions and 2228 deletions

View File

@ -1,23 +1,23 @@
import path from 'node:path'
import fs from 'node:fs'
import path from "node:path"
import fs from "node:fs"
import { Command, Option } from 'clipanion'
import * as typanion from 'typanion'
import chalk from 'chalk'
import ora from 'ora'
import logSymbols from 'log-symbols'
import { Command, Option } from "clipanion"
import * as typanion from "typanion"
import chalk from "chalk"
import ora from "ora"
import logSymbols from "log-symbols"
import type {
ValidationMessageLocationObject,
ParsedJsonAsValidationResults
} from 'html-validator'
import validateHTML from 'html-validator'
import { table } from 'table'
ParsedJsonAsValidationResults,
} from "html-validator"
import validateHTML from "html-validator"
import { table } from "table"
import { isExistingPath } from './utils/isExistingPath.js'
import { isExistingPath } from "./utils/isExistingPath.js"
export const CONFIG_FILE_NAME = '.html-w3c-validatorrc.json'
export const CONFIG_FILE_NAME = ".html-w3c-validatorrc.json"
export const SEVERITIES = ['error', 'warning', 'info'] as const
export const SEVERITIES = ["error", "warning", "info"] as const
export type Severity = (typeof SEVERITIES)[number]
@ -50,16 +50,16 @@ const printResults = (results: Result[]): void => {
export class HTMLValidatorCommand extends Command {
static override usage = {
description:
'CLI for validating multiple html pages using <https://validator.w3.org/>.'
"CLI for validating multiple html pages using <https://validator.w3.org/>.",
}
public currentWorkingDirectory = Option.String(
'--current-working-directory',
"--current-working-directory",
process.cwd(),
{
description: 'The current working directory.',
validator: typanion.isString()
}
description: "The current working directory.",
validator: typanion.isString(),
},
)
public async execute(): Promise<number> {
@ -67,11 +67,11 @@ export class HTMLValidatorCommand extends Command {
try {
if (!(await isExistingPath(configPath))) {
throw new Error(
`No config file found at ${configPath}. Please create "${CONFIG_FILE_NAME}".`
`No config file found at ${configPath}. Please create "${CONFIG_FILE_NAME}".`,
)
}
const configData = await fs.promises.readFile(configPath, {
encoding: 'utf-8'
encoding: "utf-8",
})
let config: Config = { urls: [], files: [] }
let isValidConfig = true
@ -82,52 +82,52 @@ export class HTMLValidatorCommand extends Command {
}
if (!isValidConfig) {
throw new Error(
`Invalid config file at "${configPath}". Please check the JSON syntax.`
`Invalid config file at "${configPath}". Please check the JSON syntax.`,
)
}
if (config.urls != null && !Array.isArray(config.urls)) {
throw new Error(
`Invalid config file at "${configPath}". Please include an array of URLs.`
`Invalid config file at "${configPath}". Please include an array of URLs.`,
)
}
if (config.files != null && !Array.isArray(config.files)) {
throw new Error(
`Invalid config file at "${configPath}". Please include an array of files.`
`Invalid config file at "${configPath}". Please include an array of files.`,
)
}
const urls =
config.urls == null
? []
: config.urls.map((url) => {
return { type: 'url', data: url }
return { type: "url", data: url }
})
const files =
config.files == null
? []
: config.files.map((file) => {
return { type: 'file', data: file }
return { type: "file", data: file }
})
const dataToValidate = [...urls, ...files]
if (dataToValidate.length === 0) {
throw new Error(
`Invalid config file at "${configPath}". Please add URLs or files.`
`Invalid config file at "${configPath}". Please add URLs or files.`,
)
}
const severities: Severity[] = config.severities ?? ['warning', 'error']
const severities: Severity[] = config.severities ?? ["warning", "error"]
for (const severity of severities) {
if (!SEVERITIES.includes(severity)) {
throw new Error(
`Invalid config file at "${configPath}". Please add valid severities (${SEVERITIES.join(
', '
)}).`
", ",
)}).`,
)
}
}
if (severities.length === 0) {
throw new Error(
`Invalid config file at "${configPath}". Please add valid severities (${SEVERITIES.join(
', '
)}).`
", ",
)}).`,
)
}
const errors: Error[] = []
@ -138,31 +138,31 @@ export class HTMLValidatorCommand extends Command {
dataToValidate.map(async ({ data, type }) => {
try {
const options = {
format: 'json' as 'json' | undefined
format: "json" as "json" | undefined,
}
let result: ParsedJsonAsValidationResults | undefined
if (type === 'url') {
if (type === "url") {
result = await validateHTML({
url: data,
isLocal: true,
...options
...options,
})
} else if (type === 'file') {
} else if (type === "file") {
const htmlPath = path.resolve(this.currentWorkingDirectory, data)
if (!(await isExistingPath(htmlPath))) {
throw new Error(
`No file found at "${htmlPath}". Please check the path.`
`No file found at "${htmlPath}". Please check the path.`,
)
}
const html = await fs.promises.readFile(htmlPath, {
encoding: 'utf-8'
encoding: "utf-8",
})
result = await validateHTML({
data: html,
...options
...options,
})
} else {
throw new Error('Invalid type')
throw new Error("Invalid type")
}
const hasErrors = result.messages.some((message) => {
return (
@ -184,8 +184,8 @@ export class HTMLValidatorCommand extends Command {
}
const row: string[] = []
if (message.type === 'info') {
if (message.subType === 'warning') {
if (message.type === "info") {
if (message.subType === "warning") {
row.push(chalk.yellow(message.subType))
} else {
row.push(chalk.blue(message.type))
@ -197,7 +197,7 @@ export class HTMLValidatorCommand extends Command {
const violation = message as ValidationMessageLocationObject
if (violation.extract != null) {
row.push(
`line: ${violation.lastLine}, column: ${violation.firstColumn}-${violation.lastColumn}`
`line: ${violation.lastLine}, column: ${violation.firstColumn}-${violation.lastColumn}`,
)
}
messagesTable.push(row)
@ -212,7 +212,7 @@ export class HTMLValidatorCommand extends Command {
errors.push({ data, messagesTable })
}
}
})
}),
)
if (!isValid) {
loader.fail()
@ -220,22 +220,22 @@ export class HTMLValidatorCommand extends Command {
for (const error of errors) {
console.error(`\n${error.data}`)
console.error(table(error.messagesTable))
console.error('------------------------------')
console.error("------------------------------")
}
console.error()
throw new Error('HTML validation (W3C) failed!')
throw new Error("HTML validation (W3C) failed!")
}
loader.succeed(
`${chalk.bold.green('Success:')} HTML validation (W3C) passed! 🎉`
`${chalk.bold.green("Success:")} HTML validation (W3C) passed! 🎉`,
)
printResults(results)
return 0
} catch (error) {
if (error instanceof Error) {
console.error(`${chalk.bold.red('Error:')} ${error.message}`)
console.error(`${chalk.bold.red("Error:")} ${error.message}`)
} else {
console.error(
`${chalk.bold.red('Error:')} HTML validation (W3C) failed!`
`${chalk.bold.red("Error:")} HTML validation (W3C) failed!`,
)
}
return 1

View File

@ -1,416 +1,416 @@
import test from 'node:test'
import assert from 'node:assert/strict'
import path from 'node:path'
import { PassThrough } from 'node:stream'
import test from "node:test"
import assert from "node:assert/strict"
import path from "node:path"
import { PassThrough } from "node:stream"
import sinon from 'sinon'
import { execa } from 'execa'
import { table } from 'table'
import chalk from 'chalk'
import logSymbols from 'log-symbols'
import sinon from "sinon"
import { execa } from "execa"
import { table } from "table"
import chalk from "chalk"
import logSymbols from "log-symbols"
import { cli } from '../cli.js'
import { cli } from "../cli.js"
import {
HTMLValidatorCommand,
CONFIG_FILE_NAME,
SEVERITIES
} from '../HTMLValidatorCommand.js'
SEVERITIES,
} from "../HTMLValidatorCommand.js"
const FIXTURES_PATH = path.join(process.cwd(), 'src', '__test__', 'fixtures')
const FIXTURES_PATH = path.join(process.cwd(), "src", "__test__", "fixtures")
await test('html-w3c-validator', async (t) => {
await test("html-w3c-validator", async (t) => {
t.afterEach(() => {
sinon.restore()
})
await t.test('should be instance of the command', async () => {
await t.test("should be instance of the command", async () => {
const command = cli.process([])
assert(command instanceof HTMLValidatorCommand)
})
await t.test(
'succeeds and validate the html correctly (example)',
"succeeds and validate the html correctly (example)",
async () => {
const exampleURL = new URL('../../example', import.meta.url)
const exampleURL = new URL("../../example", import.meta.url)
process.chdir(exampleURL.pathname)
await execa('rimraf', ['node_modules'])
await execa('npm', ['install'])
const { exitCode } = await execa('npm', [
'run',
'test:html-w3c-validator'
await execa("rimraf", ["node_modules"])
await execa("npm", ["install"])
const { exitCode } = await execa("npm", [
"run",
"test:html-w3c-validator",
])
assert.strictEqual(exitCode, 0)
}
},
)
await t.test(
'succeeds and validate the html correctly (example without working directory)',
"succeeds and validate the html correctly (example without working directory)",
async () => {
const logs: string[] = []
sinon.stub(console, 'log').value((log: string) => {
sinon.stub(console, "log").value((log: string) => {
logs.push(log)
})
const consoleLogSpy = sinon.spy(console, 'log')
const consoleLogSpy = sinon.spy(console, "log")
const stream = new PassThrough()
const exitCode = await cli.run([], {
stdin: process.stdin,
stdout: stream,
stderr: stream
stderr: stream,
})
stream.end()
assert.strictEqual(exitCode, 0)
assert.strictEqual(
consoleLogSpy.calledWith(
logSymbols.success,
'./example/build/index.html'
"./example/build/index.html",
),
true,
logs.join('\n')
logs.join("\n"),
)
assert.strictEqual(
consoleLogSpy.calledWith(
logSymbols.success,
'./example/build/about.html'
"./example/build/about.html",
),
true,
logs.join('\n')
logs.join("\n"),
)
}
},
)
await t.test(
'succeeds and validate the html correctly (fixture)',
"succeeds and validate the html correctly (fixture)",
async () => {
const workingDirectory = path.join(FIXTURES_PATH, 'success')
const workingDirectory = path.join(FIXTURES_PATH, "success")
const logs: string[] = []
sinon.stub(console, 'log').value((log: string) => {
sinon.stub(console, "log").value((log: string) => {
logs.push(log)
})
const consoleLogSpy = sinon.spy(console, 'log')
const consoleLogSpy = sinon.spy(console, "log")
const stream = new PassThrough()
const exitCode = await cli.run(
[`--current-working-directory=${workingDirectory}`],
{
stdin: process.stdin,
stdout: stream,
stderr: stream
}
stderr: stream,
},
)
stream.end()
assert.strictEqual(exitCode, 0)
assert.strictEqual(
consoleLogSpy.calledWith(logSymbols.success, './build/index.html'),
consoleLogSpy.calledWith(logSymbols.success, "./build/index.html"),
true,
logs.join('\n')
logs.join("\n"),
)
assert.strictEqual(
consoleLogSpy.calledWith(logSymbols.success, './build/about.html'),
consoleLogSpy.calledWith(logSymbols.success, "./build/about.html"),
true,
logs.join('\n')
logs.join("\n"),
)
}
},
)
await t.test('fails with not found config', async () => {
const workingDirectory = path.join(FIXTURES_PATH, 'error-config-not-found')
await t.test("fails with not found config", async () => {
const workingDirectory = path.join(FIXTURES_PATH, "error-config-not-found")
const configPath = path.join(workingDirectory, CONFIG_FILE_NAME)
const errors: string[] = []
sinon.stub(console, 'error').value((error: string) => {
sinon.stub(console, "error").value((error: string) => {
errors.push(error)
})
const consoleErrorSpy = sinon.spy(console, 'error')
const consoleErrorSpy = sinon.spy(console, "error")
const stream = new PassThrough()
const exitCode = await cli.run(
[`--current-working-directory=${workingDirectory}`],
{
stdin: process.stdin,
stdout: stream,
stderr: stream
}
stderr: stream,
},
)
stream.end()
assert.strictEqual(exitCode, 1)
assert.strictEqual(
consoleErrorSpy.calledWith(
chalk.bold.red('Error:') +
` No config file found at ${configPath}. Please create "${CONFIG_FILE_NAME}".`
chalk.bold.red("Error:") +
` No config file found at ${configPath}. Please create "${CONFIG_FILE_NAME}".`,
),
true,
errors.join('\n')
errors.join("\n"),
)
})
await t.test('fails with invalid JSON config', async () => {
await t.test("fails with invalid JSON config", async () => {
const workingDirectory = path.join(
FIXTURES_PATH,
'error-config-invalid-json'
"error-config-invalid-json",
)
const configPath = path.join(workingDirectory, CONFIG_FILE_NAME)
const errors: string[] = []
sinon.stub(console, 'error').value((error: string) => {
sinon.stub(console, "error").value((error: string) => {
errors.push(error)
})
const consoleErrorSpy = sinon.spy(console, 'error')
const consoleErrorSpy = sinon.spy(console, "error")
const stream = new PassThrough()
const exitCode = await cli.run(
[`--current-working-directory=${workingDirectory}`],
{
stdin: process.stdin,
stdout: stream,
stderr: stream
}
stderr: stream,
},
)
stream.end()
assert.strictEqual(exitCode, 1)
assert.strictEqual(
consoleErrorSpy.calledWith(
chalk.bold.red('Error:') +
` Invalid config file at "${configPath}". Please check the JSON syntax.`
chalk.bold.red("Error:") +
` Invalid config file at "${configPath}". Please check the JSON syntax.`,
),
true,
errors.join('\n')
errors.join("\n"),
)
})
await t.test('fails with invalid URLs config', async () => {
await t.test("fails with invalid URLs config", async () => {
const workingDirectory = path.join(
FIXTURES_PATH,
'error-config-invalid-urls'
"error-config-invalid-urls",
)
const configPath = path.join(workingDirectory, CONFIG_FILE_NAME)
const errors: string[] = []
sinon.stub(console, 'error').value((error: string) => {
sinon.stub(console, "error").value((error: string) => {
errors.push(error)
})
const consoleErrorSpy = sinon.spy(console, 'error')
const consoleErrorSpy = sinon.spy(console, "error")
const stream = new PassThrough()
const exitCode = await cli.run(
[`--current-working-directory=${workingDirectory}`],
{
stdin: process.stdin,
stdout: stream,
stderr: stream
}
stderr: stream,
},
)
stream.end()
assert.strictEqual(exitCode, 1)
assert.strictEqual(
consoleErrorSpy.calledWith(
chalk.bold.red('Error:') +
` Invalid config file at "${configPath}". Please include an array of URLs.`
chalk.bold.red("Error:") +
` Invalid config file at "${configPath}". Please include an array of URLs.`,
),
true,
errors.join('\n')
errors.join("\n"),
)
})
await t.test('fails with invalid files config', async () => {
await t.test("fails with invalid files config", async () => {
const workingDirectory = path.join(
FIXTURES_PATH,
'error-config-invalid-files'
"error-config-invalid-files",
)
const configPath = path.join(workingDirectory, CONFIG_FILE_NAME)
const errors: string[] = []
sinon.stub(console, 'error').value((error: string) => {
sinon.stub(console, "error").value((error: string) => {
errors.push(error)
})
const consoleErrorSpy = sinon.spy(console, 'error')
const consoleErrorSpy = sinon.spy(console, "error")
const stream = new PassThrough()
const exitCode = await cli.run(
[`--current-working-directory=${workingDirectory}`],
{
stdin: process.stdin,
stdout: stream,
stderr: stream
}
stderr: stream,
},
)
stream.end()
assert.strictEqual(exitCode, 1)
assert.strictEqual(
consoleErrorSpy.calledWith(
chalk.bold.red('Error:') +
` Invalid config file at "${configPath}". Please include an array of files.`
chalk.bold.red("Error:") +
` Invalid config file at "${configPath}". Please include an array of files.`,
),
true,
errors.join('\n')
errors.join("\n"),
)
})
await t.test('fails with invalid files and urls config', async () => {
await t.test("fails with invalid files and urls config", async () => {
const workingDirectory = path.join(
FIXTURES_PATH,
'error-config-invalid-files-and-urls'
"error-config-invalid-files-and-urls",
)
const configPath = path.join(workingDirectory, CONFIG_FILE_NAME)
const errors: string[] = []
sinon.stub(console, 'error').value((error: string) => {
sinon.stub(console, "error").value((error: string) => {
errors.push(error)
})
const consoleErrorSpy = sinon.spy(console, 'error')
const consoleErrorSpy = sinon.spy(console, "error")
const stream = new PassThrough()
const exitCode = await cli.run(
[`--current-working-directory=${workingDirectory}`],
{
stdin: process.stdin,
stdout: stream,
stderr: stream
}
stderr: stream,
},
)
stream.end()
assert.strictEqual(exitCode, 1)
assert.strictEqual(
consoleErrorSpy.calledWith(
chalk.bold.red('Error:') +
` Invalid config file at "${configPath}". Please add URLs or files.`
chalk.bold.red("Error:") +
` Invalid config file at "${configPath}". Please add URLs or files.`,
),
true,
errors.join('\n')
errors.join("\n"),
)
})
await t.test('fails with invalid severities config', async () => {
await t.test("fails with invalid severities config", async () => {
const workingDirectory = path.join(
FIXTURES_PATH,
'error-config-invalid-severities'
"error-config-invalid-severities",
)
const configPath = path.join(workingDirectory, CONFIG_FILE_NAME)
const errors: string[] = []
sinon.stub(console, 'error').value((error: string) => {
sinon.stub(console, "error").value((error: string) => {
errors.push(error)
})
const consoleErrorSpy = sinon.spy(console, 'error')
const consoleErrorSpy = sinon.spy(console, "error")
const stream = new PassThrough()
const exitCode = await cli.run(
[`--current-working-directory=${workingDirectory}`],
{
stdin: process.stdin,
stdout: stream,
stderr: stream
}
stderr: stream,
},
)
stream.end()
assert.strictEqual(exitCode, 1)
assert.strictEqual(
consoleErrorSpy.calledWith(
chalk.bold.red('Error:') +
chalk.bold.red("Error:") +
` Invalid config file at "${configPath}". Please add valid severities (${SEVERITIES.join(
', '
)}).`
", ",
)}).`,
),
true,
errors.join('\n')
errors.join("\n"),
)
})
await t.test('fails with invalid empty severities config', async () => {
await t.test("fails with invalid empty severities config", async () => {
const workingDirectory = path.join(
FIXTURES_PATH,
'error-config-invalid-severities-empty'
"error-config-invalid-severities-empty",
)
const configPath = path.join(workingDirectory, CONFIG_FILE_NAME)
const errors: string[] = []
sinon.stub(console, 'error').value((error: string) => {
sinon.stub(console, "error").value((error: string) => {
errors.push(error)
})
const consoleErrorSpy = sinon.spy(console, 'error')
const consoleErrorSpy = sinon.spy(console, "error")
const stream = new PassThrough()
const exitCode = await cli.run(
[`--current-working-directory=${workingDirectory}`],
{
stdin: process.stdin,
stdout: stream,
stderr: stream
}
stderr: stream,
},
)
stream.end()
assert.strictEqual(exitCode, 1)
assert.strictEqual(
consoleErrorSpy.calledWith(
chalk.bold.red('Error:') +
chalk.bold.red("Error:") +
` Invalid config file at "${configPath}". Please add valid severities (${SEVERITIES.join(
', '
)}).`
", ",
)}).`,
),
true,
errors.join('\n')
errors.join("\n"),
)
})
await t.test('fails with invalid files paths to check', async () => {
await t.test("fails with invalid files paths to check", async () => {
const workingDirectory = path.join(
FIXTURES_PATH,
'error-invalid-files-paths-to-check'
"error-invalid-files-paths-to-check",
)
const htmlPath = path.resolve(workingDirectory, 'index.html')
const htmlPath = path.resolve(workingDirectory, "index.html")
const errors: string[] = []
sinon.stub(console, 'error').value((error: string) => {
sinon.stub(console, "error").value((error: string) => {
errors.push(error)
})
const consoleErrorSpy = sinon.spy(console, 'error')
const consoleErrorSpy = sinon.spy(console, "error")
const stream = new PassThrough()
const exitCode = await cli.run(
[`--current-working-directory=${workingDirectory}`],
{
stdin: process.stdin,
stdout: stream,
stderr: stream
}
stderr: stream,
},
)
stream.end()
assert.strictEqual(exitCode, 1)
const messagesTable = [
[`No file found at "${htmlPath}". Please check the path.`]
[`No file found at "${htmlPath}". Please check the path.`],
]
assert.strictEqual(
consoleErrorSpy.calledWith(
chalk.bold.red('Error:') + ' HTML validation (W3C) failed!'
chalk.bold.red("Error:") + " HTML validation (W3C) failed!",
),
true,
errors.join('\n')
errors.join("\n"),
)
assert.strictEqual(
consoleErrorSpy.calledWith(table(messagesTable)),
true,
errors.join('\n')
errors.join("\n"),
)
})
await t.test('fails with invalid W3C HTML', async () => {
const workingDirectory = path.join(FIXTURES_PATH, 'error-invalid-w3c-html')
await t.test("fails with invalid W3C HTML", async () => {
const workingDirectory = path.join(FIXTURES_PATH, "error-invalid-w3c-html")
const errors: string[] = []
sinon.stub(console, 'error').value((error: string) => {
sinon.stub(console, "error").value((error: string) => {
errors.push(error)
})
const consoleErrorSpy = sinon.spy(console, 'error')
const consoleErrorSpy = sinon.spy(console, "error")
const stream = new PassThrough()
const exitCode = await cli.run(
[`--current-working-directory=${workingDirectory}`],
{
stdin: process.stdin,
stdout: stream,
stderr: stream
}
stderr: stream,
},
)
stream.end()
assert.strictEqual(exitCode, 1)
const messagesTable = [
[
chalk.yellow('warning'),
'Consider adding a “lang” attribute to the “html” start tag to declare the language of this document.',
'line: 2, column: 16-6'
]
chalk.yellow("warning"),
"Consider adding a “lang” attribute to the “html” start tag to declare the language of this document.",
"line: 2, column: 16-6",
],
]
assert.strictEqual(
consoleErrorSpy.calledWith(
chalk.bold.red('Error:') + ' HTML validation (W3C) failed!'
chalk.bold.red("Error:") + " HTML validation (W3C) failed!",
),
true,
errors.join('\n')
errors.join("\n"),
)
assert.strictEqual(
consoleErrorSpy.calledWith(table(messagesTable)),
true,
errors.join('\n')
errors.join("\n"),
)
})
})

View File

@ -1,12 +1,12 @@
import { Builtins, Cli } from 'clipanion'
import { Builtins, Cli } from "clipanion"
import { HTMLValidatorCommand } from './HTMLValidatorCommand.js'
import { packageJSON } from './packageJSON.js'
import { HTMLValidatorCommand } from "./HTMLValidatorCommand.js"
import { packageJSON } from "./packageJSON.js"
export const cli = new Cli({
binaryLabel: packageJSON.name,
binaryName: packageJSON.name,
binaryVersion: packageJSON.version
binaryVersion: packageJSON.version,
})
cli.register(Builtins.HelpCommand)
cli.register(Builtins.VersionCommand)

View File

@ -1,7 +1,7 @@
#!/usr/bin/env node
import { Cli } from 'clipanion'
import { Cli } from "clipanion"
import { cli } from './cli.js'
import { cli } from "./cli.js"
const [, , ...arguments_] = process.argv

View File

@ -1,5 +1,5 @@
import { readPackage } from 'read-pkg'
import { readPackage } from "read-pkg"
export const packageJSON = await readPackage({
cwd: new URL('..', import.meta.url)
cwd: new URL("..", import.meta.url),
})

View File

@ -1,26 +1,26 @@
import test from 'node:test'
import assert from 'node:assert/strict'
import test from "node:test"
import assert from "node:assert/strict"
import fsMock from 'mock-fs'
import fsMock from "mock-fs"
import { isExistingPath } from '../isExistingPath.js'
import { isExistingPath } from "../isExistingPath.js"
await test('utils/isExistingPath', async (t) => {
await test("utils/isExistingPath", async (t) => {
t.afterEach(() => {
fsMock.restore()
})
await t.test('should return true if the file exists', async () => {
await t.test("should return true if the file exists", async () => {
fsMock({
'/file.txt': ''
"/file.txt": "",
})
assert.strictEqual(await isExistingPath('/file.txt'), true)
assert.strictEqual(await isExistingPath("/file.txt"), true)
})
await t.test("should return false if the file doesn't exists", async () => {
fsMock({
'/file.txt': ''
"/file.txt": "",
})
assert.strictEqual(await isExistingPath('/randomfile.txt'), false)
assert.strictEqual(await isExistingPath("/randomfile.txt"), false)
})
})

View File

@ -1,4 +1,4 @@
import fs from 'node:fs'
import fs from "node:fs"
export const isExistingPath = async (path: string): Promise<boolean> => {
try {