@emigrate/cli/dist/test-utils.js

Emigrate is a tool for managing database migrations. It is designed to be simple yet support advanced setups, modular and extensible.

import { mock } from 'node:test';
import path from 'node:path';
import assert from 'node:assert';
import { toSerializedError } from './errors.js';
export async function noop() {
    // noop
}
export function getErrorCause(error) {
    if (error?.cause instanceof Error) {
        return error.cause;
    }
    if (typeof error?.cause === 'object' && error.cause !== null) {
        return error.cause;
    }
    return undefined;
}
export function getMockedStorage(historyEntries) {
    return {
        lock: mock.fn(async (migrations) => migrations),
        unlock: mock.fn(async () => {
            // void
        }),
        getHistory: mock.fn(async function* () {
            yield* toEntries(historyEntries);
        }),
        remove: mock.fn(),
        onSuccess: mock.fn(),
        onError: mock.fn(),
        end: mock.fn(),
    };
}
export function getMockedReporter() {
    return {
        onFinished: mock.fn(noop),
        onInit: mock.fn(noop),
        onAbort: mock.fn(noop),
        onCollectedMigrations: mock.fn(noop),
        onLockedMigrations: mock.fn(noop),
        onNewMigration: mock.fn(noop),
        onMigrationStart: mock.fn(noop),
        onMigrationSuccess: mock.fn(noop),
        onMigrationError: mock.fn(noop),
        onMigrationSkip: mock.fn(noop),
    };
}
export function toMigration(cwd, directory, name) {
    return {
        name,
        filePath: `${cwd}/${directory}/${name}`,
        relativeFilePath: `${directory}/${name}`,
        extension: path.extname(name),
        directory,
        cwd,
    };
}
export function toMigrations(cwd, directory, names) {
    return names.map((name) => toMigration(cwd, directory, name));
}
export function toEntry(name, status) {
    if (typeof name !== 'string') {
        return name.status === 'failed' ? name : name;
    }
    if (status === 'failed') {
        return {
            name,
            status,
            date: new Date(),
            error: { name: 'Error', message: 'Failed' },
        };
    }
    return {
        name,
        status: status ?? 'done',
        date: new Date(),
    };
}
export function toEntries(names, status) {
    return names.map((name) => (typeof name === 'string' ? toEntry(name, status) : name));
}
export function assertErrorEqualEnough(actual, expected, message) {
    if (expected === undefined) {
        assert.strictEqual(actual, undefined);
        return;
    }
    const { cause: actualCause, stack: actualStack, ...actualError } = actual instanceof Error ? toSerializedError(actual) : actual ?? {};
    const { cause: expectedCause, stack: expectedStack, ...expectedError } = toSerializedError(expected);
    // @ts-expect-error Ignore
    const { stack: actualCauseStack, ...actualCauseRest } = actualCause ?? {};
    // @ts-expect-error Ignore
    const { stack: expectedCauseStack, ...expectedCauseRest } = expectedCause ?? {};
    assert.deepStrictEqual(actualError, expectedError, message);
    assert.deepStrictEqual(actualCauseRest, expectedCauseRest, message ? `${message} (cause)` : undefined);
}
//# sourceMappingURL=test-utils.js.map