nehoid/dist/src/utils/test-utils.js

Advanced unique ID generation utility with multi-layer encoding, collision detection, and context-aware features

export function describe(name, fn) {
    console.log(`\n🔍 ${name}`);
    fn();
}
export function test(name, fn) {
    try {
        const result = fn();
        if (result instanceof Promise) {
            result
                .then(() => console.log(`✅ ${name}`))
                .catch(err => console.error(`❌ ${name}\n   ${err.message}`));
        }
        else {
            console.log(`✅ ${name}`);
        }
    }
    catch (err) {
        console.error(`❌ ${name}\n   ${err.message}`);
    }
}
export function expect(actual) {
    const actualNum = typeof actual === 'number' ? actual : Number(actual);
    return {
        toBe: (expected) => {
            if (actual !== expected) {
                throw new Error(`Expected ${expected} but got ${actual}`);
            }
        },
        toEqual: (expected) => {
            if (JSON.stringify(actual) !== JSON.stringify(expected)) {
                throw new Error(`Expected ${JSON.stringify(expected)} but got ${JSON.stringify(actual)}`);
            }
        },
        toBeTruthy: () => {
            if (!actual) {
                throw new Error(`Expected ${actual} to be truthy`);
            }
        },
        toBeFalsy: () => {
            if (actual) {
                throw new Error(`Expected ${actual} to be falsy`);
            }
        },
        toMatch: (regex) => {
            if (!regex.test(String(actual))) {
                throw new Error(`Expected ${actual} to match ${regex}`);
            }
        },
        toHaveLength: (length) => {
            const actualLength = actual.length;
            if (actualLength !== length) {
                throw new Error(`Expected length ${length} but got ${actualLength}`);
            }
        },
        toContain: (item) => {
            if (!actual.includes(item)) {
                throw new Error(`Expected ${actual} to contain ${item}`);
            }
        },
        toBeGreaterThan: (expected) => {
            if (actualNum <= expected) {
                throw new Error(`Expected ${actual} to be greater than ${expected}`);
            }
        },
        toThrow: (expected) => {
            try {
                actual();
                throw new Error('Expected function to throw');
            }
            catch (err) {
                if (expected) {
                    const errorMessage = err.message;
                    if (expected instanceof RegExp) {
                        if (!expected.test(errorMessage)) {
                            throw new Error(`Expected error message to match ${expected} but got "${errorMessage}"`);
                        }
                    }
                    else if (errorMessage !== expected) {
                        throw new Error(`Expected error message "${expected}" but got "${errorMessage}"`);
                    }
                }
            }
        }
    };
}
//# sourceMappingURL=test-utils.js.map