@palmares/tests
Version:
This defines a default test framework testing stuff inside of the framework
497 lines (485 loc) • 17.3 kB
JavaScript
var __defProp = Object.defineProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
// src/expect.ts
function getExpect(value, testAdapter, isNot = false, isEventually = false) {
return new Proxy({}, {
get: /* @__PURE__ */ __name((_, prop) => {
if (prop === "toBe") return (expected, customData) => isEventually ? new Promise((resolve, reject) => {
Promise.resolve(value).then((value2) => {
try {
resolve(testAdapter.expect.toBe(value2, expected, isNot, customData));
} catch (error) {
reject(error);
}
}).catch(reject);
}) : testAdapter.expect.toBe(value, expected, isNot, customData);
else if (prop === "toEqual") return (expected, customData) => isEventually ? new Promise((resolve, reject) => {
Promise.resolve(value).then((value2) => {
try {
resolve(testAdapter.expect.toEqual(value2, expected, isNot, customData));
} catch (error) {
reject(error);
}
}).catch(reject);
}) : testAdapter.expect.toEqual(value, expected, isNot, customData);
else if (prop === "toStrictEqual") return (expected, customData) => isEventually ? new Promise((resolve, reject) => {
Promise.resolve(value).then((value2) => {
try {
resolve(testAdapter.expect.toStrictEqual(value2, expected, isNot, customData));
} catch (error) {
reject(error);
}
}).catch(reject);
}) : testAdapter.expect.toStrictEqual(value, expected, isNot, customData);
else if (prop === "toBeInstanceOf") return (expected, customData) => isEventually ? new Promise((resolve, reject) => {
Promise.resolve(value).then((value2) => {
try {
resolve(testAdapter.expect.toBeInstanceOf(value2, expected, isNot, customData));
} catch (error) {
reject(error);
}
}).catch(reject);
}) : testAdapter.expect.toBeInstanceOf(value, expected, isNot, customData);
else if (prop === "toBeDefined") return (customData) => isEventually ? new Promise((resolve, reject) => {
Promise.resolve(value).then((value2) => {
try {
resolve(testAdapter.expect.toBeDefined(value2, isNot, customData));
} catch (error) {
reject(error);
}
}).catch(reject);
}) : testAdapter.expect.toBeDefined(value, isNot, customData);
else if (prop === "toHaveBeenCalled") return (customData) => isEventually ? new Promise((resolve, reject) => {
Promise.resolve(value).then((value2) => {
try {
resolve(testAdapter.expect.toHaveBeenCalled(value2, isNot, customData));
} catch (error) {
reject(error);
}
}).catch(reject);
}) : testAdapter.expect.toHaveBeenCalled(value, isNot, customData);
else if (prop === "toHaveBeenCalledTimes") return (expected, customData) => isEventually ? new Promise((resolve, reject) => {
Promise.resolve(value).then((value2) => {
try {
resolve(testAdapter.expect.toHaveBeenCalledTimes(value2, isNot, customData));
} catch (error) {
reject(error);
}
}).catch(reject);
}) : testAdapter.expect.toHaveBeenCalledTimes(expected, isNot, customData);
else if (prop === "toHaveBeenCalledWith") return (args, customData) => isEventually ? new Promise((resolve, reject) => {
Promise.resolve(value).then((value2) => {
try {
resolve(testAdapter.expect.toHaveBeenCalledWith(value2, args, isNot, customData));
} catch (error) {
reject(error);
}
}).catch(reject);
}) : testAdapter.expect.toHaveBeenCalledWith(value, args, isNot, customData);
else if (prop === "toHaveReturned") return (customData) => isEventually ? new Promise((resolve, reject) => {
Promise.resolve(value).then((value2) => {
try {
resolve(testAdapter.expect.toHaveReturned(value2, isNot, customData));
} catch (error) {
reject(error);
}
}).catch(reject);
}) : testAdapter.expect.toHaveReturned(value, isNot, customData);
else if (prop === "toHaveReturnedTimes") return (expected, customData) => isEventually ? new Promise((resolve, reject) => {
Promise.resolve(value).then((value2) => {
try {
resolve(testAdapter.expect.toHaveReturnedTimes(value2, expected, isNot, customData));
} catch (error) {
reject(error);
}
}).catch(reject);
}) : testAdapter.expect.toHaveReturnedTimes(value, expected, isNot, customData);
if (prop === "not") return getExpect(value, testAdapter, true, false);
if (prop === "eventually") return getExpect(value, testAdapter, isNot, true);
throw new Error(`Expect.${String(prop)} is not a function`);
}, "get")
});
}
__name(getExpect, "getExpect");
// src/utils.ts
async function setTestAdapter(adapter, withCustomProps = false) {
globalThis.$PTestAdapter = adapter;
if (withCustomProps) {
await adapter.getCustomProps().then((props) => {
globalThis.$PTestAdapterCustomProps = props;
});
}
}
__name(setTestAdapter, "setTestAdapter");
function getTestAdapter() {
if (!globalThis.$PTestAdapter) {
throw new Error("Test adapter not set");
}
return globalThis.$PTestAdapter;
}
__name(getTestAdapter, "getTestAdapter");
function getTestAdapterCustomProps() {
if (!globalThis.$PTestAdapterCustomProps) {
throw new Error("Test adapter custom props not set");
}
return globalThis.$PTestAdapterCustomProps;
}
__name(getTestAdapterCustomProps, "getTestAdapterCustomProps");
// src/functions.ts
function describe(descriptionName, callback, customArgs) {
const defaultTestAdapter = getTestAdapter();
const custom = getTestAdapterCustomProps();
defaultTestAdapter.functions.getDescribe(descriptionName, () => {
return callback({
test,
beforeEach,
afterEach,
custom
});
}, customArgs);
}
__name(describe, "describe");
function test(testName, callback, customArgs) {
const defaultTestAdapter = getTestAdapter();
defaultTestAdapter.functions.getTest(testName, async () => Promise.resolve(callback({
expect,
custom: await defaultTestAdapter.getCustomProps()
})), customArgs);
}
__name(test, "test");
function beforeEach(callback, customArgs) {
const defaultTestAdapter = getTestAdapter();
defaultTestAdapter.functions.getBeforeEach(async () => Promise.resolve(callback({
custom: await defaultTestAdapter.getCustomProps()
})), customArgs);
}
__name(beforeEach, "beforeEach");
function afterEach(callback, customArgs) {
const defaultTestAdapter = getTestAdapter();
defaultTestAdapter.functions.getAfterEach(async () => Promise.resolve(callback({
custom: await defaultTestAdapter.getCustomProps()
})), customArgs);
}
__name(afterEach, "afterEach");
function beforeAll(callback, customArgs) {
const defaultTestAdapter = getTestAdapter();
defaultTestAdapter.functions.getBeforeAll(async () => Promise.resolve(callback({
custom: await defaultTestAdapter.getCustomProps()
})), customArgs);
}
__name(beforeAll, "beforeAll");
function afterAll(callback, customArgs) {
const defaultTestAdapter = getTestAdapter();
defaultTestAdapter.functions.getAfterAll(async () => Promise.resolve(callback({
custom: await defaultTestAdapter.getCustomProps()
})), customArgs);
}
__name(afterAll, "afterAll");
function expect(value) {
return getExpect(value, getTestAdapter());
}
__name(expect, "expect");
// src/adapter/expect.ts
var TestExpectAdapter = class {
static {
__name(this, "TestExpectAdapter");
}
toBe(_value, _expected, _isNot, _customData) {
throw new Error("Not implemented");
}
toEqual(_value, _expected, _isNot, _customData) {
throw new Error("Not implemented");
}
toStrictEqual(_value, _expected, _isNot, _customData) {
throw new Error("Not implemented");
}
toBeDefined(_value, _isNot, _customData) {
throw new Error("Not implemented");
}
toBeInstanceOf(__value, _expected, _isNot, _customData) {
throw new Error("Not implemented");
}
toHaveBeenCalled(_value, _isNot, _customData) {
throw new Error("Not implemented");
}
// eslint-disable-next-line ts/require-await
async toHaveBeenCalledTimes(_value, _isNot, _customData) {
throw new Error("Not implemented");
}
// eslint-disable-next-line ts/require-await
async toHaveBeenCalledWith(_value, _args, _isNot, _customData) {
throw new Error("Not implemented");
}
// eslint-disable-next-line ts/require-await
async toHaveReturned(_value, _isNot, _customData) {
throw new Error("Not implemented");
}
// eslint-disable-next-line ts/require-await
async toHaveReturnedTimes(_value, _expected, _isNot, _customData) {
throw new Error("Not implemented");
}
};
// src/adapter/functions.ts
var TestFunctionsAdapter = class {
static {
__name(this, "TestFunctionsAdapter");
}
/**
* Should run a callback inside a describe function from your test framework.
*
* @example
* ```typescript
* import { TestFunctionsAdapter } from '@palmares/tests';
*
* export default class JestTestFunctionsAdapter extends TestFunctionsAdapter {
* getDescribe(descriptionName: string, callback: () => void): void {
* const describe = require('@jest/globals').describe;
* describe(descriptionName, () => {
* callback();
* });
* }
* }
* ```
*
* @param descriptionName - The name of the description
* @param callback - The callback that should be called inside the describe function
*/
getDescribe(_descriptionName, _callback, _customData) {
throw new Error("Not implemented");
}
/**
* Should run a async callback function inside a `test` or `it` function from your test framework.
*
* @example
* ```typescript
* import { TestFunctionsAdapter } from '@palmares/tests';
*
* export default class JestTestFunctionsAdapter extends TestFunctionsAdapter {
* getTest(descriptionName: string, callback: () => Promise<void>): void {
* const test = require('@jest/globals').test;
* test(descriptionName, async () => {
* await callback();
* });
* }
* }
* ```
*
* @param testName - The name of the test
* @param callback - The callback that should be called inside the test function
*/
getTest(_testName, _callback, _customData) {
throw new Error("Not implemented");
}
/**
* Should run a callback inside a beforeEach function from your test framework.
*
* @example
* ```typescript
* import { TestFunctionsAdapter } from '@palmares/tests';
*
* export default class JestTestFunctionsAdapter extends TestFunctionsAdapter {
* getBeforeEach(callback: () => Promise<void>): void {
* const beforeEach = require('@jest/globals').beforeEach;
* beforeEach(async () => {
* await callback();
* });
* }
* }
* ```
*
* @param callback - The callback that should be called inside the beforeEach function
*/
getBeforeEach(_callback, _customData) {
throw new Error("Not implemented");
}
/**
* Should run a callback inside a afterEach function from your test framework.
*
* @example
* ```typescript
* import { TestFunctionsAdapter } from '@palmares/tests';
*
* export default class JestTestFunctionsAdapter extends TestFunctionsAdapter {
* getAfterEach(callback: () => Promise<void>): void {
* const afterEach = require('@jest/globals').afterEach;
* afterEach(async () => {
* await callback();
* });
* }
* }
* ```
*
* @param callback - The callback that should be called inside the beforeEach function
*/
getAfterEach(_callback, _customData) {
throw new Error("Not implemented");
}
/**
* Should run a callback inside a beforeAll function from your test framework.
*
* @example
* ```typescript
* import { TestFunctionsAdapter } from '@palmares/tests';
*
* export default class JestTestFunctionsAdapter extends TestFunctionsAdapter {
* getBeforeAll(callback: () => Promise<void>): void {
* const beforeAll = require('@jest/globals').beforeAll;
* beforeAll(async () => {
* await callback();
* });
* }
* }
* ```
*
* @param callback - The callback that should be called inside the beforeEach function
*/
getBeforeAll(_callback, _customData) {
throw new Error("Not implemented");
}
/**
* Should run a callback inside an afterAll function from your test framework.
*
* @example
* ```typescript
* import { TestFunctionsAdapter } from '@palmares/tests';
*
* export default class JestTestFunctionsAdapter extends TestFunctionsAdapter {
* getAfterAll(callback: () => Promise<void>): void {
* const afterAll = require('@jest/globals').afterAll;
* afterAll(async () => {
* await callback();
* });
* }
* }
* ```
*
* @param callback - The callback that should be called inside the beforeEach function
*/
getAfterAll(_callback, _customData) {
throw new Error("Not implemented");
}
};
// src/adapter/index.ts
var TestAdapter = class {
static {
__name(this, "TestAdapter");
}
functions = new TestFunctionsAdapter();
expect = new TestExpectAdapter();
// eslint-disable-next-line ts/require-await
async getCustomProps() {
throw new Error("Not implemented");
}
/** Should return */
// eslint-disable-next-line ts/require-await
async run(_filesToRun, _globalSetupFunctionBody, _std) {
throw new Error("Not implemented");
}
};
// src/runner.ts
import { initializeDomains } from "@palmares/core";
async function run(settingsPath) {
try {
const settings = await import(settingsPath);
let defaultSettings = settings.default;
if ("default" in defaultSettings) defaultSettings = defaultSettings.default;
defaultSettings.$$test = true;
await initializeDomains(defaultSettings, {
ignoreCache: true,
ignoreCommands: true
});
} catch (e) {
console.error("Error initializing domains", e);
}
}
__name(run, "run");
async function runIndependently(adapterLocation) {
const adapter = await import(adapterLocation).catch((e) => {
console.error("Error importing adapter", e);
});
const testAdapter = new adapter.default();
setTestAdapter(testAdapter);
}
__name(runIndependently, "runIndependently");
// src/independent.ts
async function testIndependently(adapterLocation, std2, filesToTest2) {
const adapterLocationFileUrl = std2.files.getPathToFileURL(adapterLocation);
const actualAdapterLocation = await std2.os.platform() === "windows" && adapterLocationFileUrl.startsWith("file:") === false ? `file:/${adapterLocationFileUrl}` : adapterLocationFileUrl;
const adapter = await import(actualAdapterLocation).catch((e) => {
console.error("Error importing adapter", e);
});
const testAdapter = new adapter.default();
setTestAdapter(testAdapter);
return testAdapter.run(filesToTest2, `require('@palmares/tests').runIndependently('${actualAdapterLocation}');`, {
mkdir: std2.files.makeDirectory,
join: std2.files.join,
writeFile: std2.files.writeFile,
removeFile: std2.files.removeFile
});
}
__name(testIndependently, "testIndependently");
// src/domain.ts
import { domain } from "@palmares/core";
// src/commands/test.ts
import { std } from "@palmares/core";
var filesToTest = [];
async function test2(domains, settings) {
for (const domain2 of domains) {
if (domain2.getTests) {
const testFilesOrTestFile = domain2.getTests();
if (Array.isArray(testFilesOrTestFile)) filesToTest.push(...testFilesOrTestFile);
else filesToTest.push(testFilesOrTestFile);
}
}
const newTestAdapter = new settings.testAdapter();
await setTestAdapter(newTestAdapter);
return newTestAdapter.run(filesToTest, `import { run } from '@palmares/tests';
await run('${await std.os.platform() === "windows" ? "file:/" : ""}${std.files.getPathToFileURL(settings.settingsLocation)}');`, {
mkdir: std.files.makeDirectory,
join: std.files.join,
writeFile: std.files.writeFile,
removeFile: std.files.removeFile
});
}
__name(test2, "test");
// src/domain.ts
var testDomainModifier = domain("@palmares/tests", "", {});
var testDomain = domain("@palmares/tests", "", {
commands: {
test: {
description: "Run the tests in your palmares application",
keywordArgs: void 0,
positionalArgs: void 0,
handler: /* @__PURE__ */ __name((args) => {
test2(args.domains, args.settings);
}, "handler")
}
},
// eslint-disable-next-line ts/require-await
load: /* @__PURE__ */ __name(async (settings) => {
if (settings.$$test) {
const adapterInstance = new settings.testAdapter();
await setTestAdapter(adapterInstance, true);
}
}, "load")
});
export {
TestAdapter,
testDomain as TestDomain,
TestExpectAdapter,
TestFunctionsAdapter,
afterAll,
afterEach,
beforeAll,
beforeEach,
testDomain as default,
describe,
getTestAdapter,
run,
runIndependently,
setTestAdapter,
test,
test2 as testCommand,
testDomainModifier,
testIndependently
};