@cspell/cspell-tools/dist/test/TestHelper.js

Tools to assist with the development of cSpell

import assert from 'node:assert';
import { mkdirSync, promises as fs, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
import * as path from 'node:path';
import { fileURLToPath } from 'node:url';
import { expect } from 'vitest';
const _dirname = test_dirname(import.meta.url);
const packageRoot = path.join(_dirname, '../..');
const repoRoot = path.join(packageRoot, '../..');
const tempDirBase = path.join(packageRoot, 'temp');
const repoSamples = path.join(repoRoot, 'packages/Samples');
export function createTestHelper(testFilenameUrl) {
    testFilenameUrl && assert(testFilenameUrl.startsWith('file:'));
    const testFilename = testFilenameUrl && test_filename(testFilenameUrl);
    return new TestHelperImpl(testFilename || expect.getState().testPath || 'test');
}
const fixtureDir = path.join(packageRoot, 'fixtures');
class TestHelperImpl {
    packageRoot = packageRoot;
    repoRoot = repoRoot;
    tempDir;
    fixtureDir;
    testCounter = new Map();
    constructor(testFilename) {
        this.tempDir = path.join(tempDirBase, path.relative(packageRoot, testFilename));
        this.fixtureDir = fixtureDir;
    }
    beginTest() {
        const currentTestName = this.getRawTestName();
        const prev = this.testCounter.get(currentTestName) || 0;
        this.testCounter.set(currentTestName, prev + 1);
    }
    getRawTestName() {
        return expect.getState().currentTestName || '';
    }
    getCurrentTestName() {
        const currentTestName = this.getRawTestName();
        const counter = this.testCounter.get(currentTestName);
        return `${currentTestName}${counter ? ' ' + counter : ''}`;
    }
    /**
     * delete the contents of the temp directory for the current test.
     */
    clearTempDir() {
        rmSync(this.resolveTemp(), { force: true, recursive: true });
    }
    /**
     * resolve a path relative to the
     * @param parts
     * @returns
     */
    resolveTemp(...parts) {
        const currentTestName = this.getCurrentTestName();
        const testName = currentTestName.replaceAll(/[^\w_.-]/g, '_');
        return path.resolve(this.tempDir, testName, ...parts);
    }
    /**
     * make a directory. It is ok to make the same directory multiple times.
     * @param parts
     */
    mkdir(...parts) {
        const pTemp = this.resolveTemp(...parts);
        mkdirSync(pTemp, { recursive: true });
    }
    /**
     * Copy files from src to dest
     * @param src - glob
     * @param dest - directory or file
     */
    cpFileSync(src, dest) {
        const srcT = this.resolveTemp(src);
        const dstT = this.resolveTemp(dest);
        cpFileSync(srcT, dstT);
    }
    /**
     * resolve a path to the fixtures.
     * @param parts
     * @returns
     */
    resolveFixture(...parts) {
        return path.resolve(this.fixtureDir, ...parts);
    }
    resolveSample(...parts) {
        return path.resolve(repoSamples, ...parts);
    }
    /**
     * calc a path relative to the package temp directory.
     * @param parts - optional path segments
     * @returns
     */
    packageTemp(...parts) {
        return path.resolve(tempDirBase, ...parts);
    }
    createTempDir = this.mkdir;
    async fileExists(path) {
        try {
            await fs.stat(path);
            return true;
        }
        catch {
            return false;
        }
    }
}
export function resolvePathToFixture(...segments) {
    return path.resolve(fixtureDir, ...segments);
}
export function test_dirname(importMetaUrl) {
    return fileURLToPath(new URL('.', importMetaUrl));
}
export function test_filename(importMetaUrl) {
    return fileURLToPath(importMetaUrl);
}
function cpFileSync(srcFile, dst) {
    const statDst = statSync(dst, { throwIfNoEntry: false });
    if (statDst && statDst.isDirectory()) {
        dst = path.join(dst, path.basename(srcFile));
    }
    const buf = readFileSync(srcFile);
    writeFileSync(dst, buf);
}
//# sourceMappingURL=TestHelper.js.map