poku 1.5.1 → 1.6.0

package/README.md

@@ -12,6 +12,8 @@
 [ql-image]: https://img.shields.io/github/actions/workflow/status/wellwelwel/poku/codeql.yml?event=push&style=flat&label=Code%20QL&branch=main
 [license-url]: https://github.com/wellwelwel/poku/blob/main/LICENSE
 [license-image]: https://img.shields.io/npm/l/poku.svg?maxAge=2592000&color=9c88ff&label=License
+[downloads-image]: https://img.shields.io/npm/dt/poku.svg?&color=FFC312&label=Downloads
+[downloads-url]: https://npmjs.org/package/poku
 
 # Poku
 
@@ -27,20 +29,20 @@
 [![TypeScript Version][typescript-version-image]][typescript-url]
 [![GitHub Workflow Status (with event)][ci-image]][ci-url]
 [![GitHub Workflow Status (with event)][ql-image]][ql-url]
+[![NPM Downloads][downloads-image]][downloads-url]
 [![License][license-image]][license-url]
 
 Enjoying **Poku**? Consider giving him a star ⭐️
 
 ---
 
-🐷 [**Documentation Website**](https://poku.dev) • 🔬 [**Compare Poku with the Most Popular Test Runners**](https://poku.dev/docs/comparing)
+🐷 [**Documentation Website**](https://poku.dev) • 🔬 [**Compare Poku with the Most Popular Test Runners**](https://poku.dev/docs/comparing) • 🧪 [**Examples**](https://poku.dev/docs/category/examples)
 
 ---
 
 ## Why Poku?
 
-Don't worry about `describe`, `it`, `beforeEach` and everything else 🚀 <br/>
-After all, you don't need to learn what you already know ([**see why**](https://poku.dev/docs/examples/beforeEach)) ✨
+Let's make `describe`, `beforeEach` and everything else easier 🚀 <br/>
 
 - Supports **ESM** and **CJS**
 - Designed to be highly intuitive
@@ -65,6 +67,12 @@ After all, you don't need to learn what you already know ([**see why**](https://
 
 ---
 
+## Examples
+
+- See real example usages in [**Examples**](https://poku.dev/docs/category/examples) section for **Poku**'s + **Mock**, **Virutal DOM** and more.
+
+---
+
 ## Overview
 
 ### `poku`
@@ -117,47 +125,58 @@ import { poku } from 'npm:poku';
 
 ## Quick Start
 
-### CLI
+### `poku`
+
+#### CLI
+
+> Try to set the flag `--parallel` before the target path 🚀
 
 > <img src=".github/assets/readme/node-js.svg" width="24" />
 
 ```bash
-npx poku targetDir
+npx poku targetPath
+npx poku targetPathA,targetPathB
 ```
 
 > <img src=".github/assets/readme/bun.svg" width="24" />
 
 ```bash
-bun poku targetDir
+bun poku targetPath
+bun poku targetPathA,targetPathB
 ```
 
 > <img src=".github/assets/readme/deno.svg" width="24" />
 
 ```bash
-deno run npm:poku targetDir
+deno run npm:poku targetPath
+deno run npm:poku targetPathA,targetPathB
 ```
 
-### API (_In-code_)
+#### API (_In-code_)
 
-#### Node.js, TypeScript (Node.js) and Bun
+##### Node.js, TypeScript (Node.js) and Bun
 
 ```ts
 import { poku } from 'poku';
 
-await poku(['targetDir']);
+await poku(['targetPath']);
 ```
 
-#### Deno
+##### Deno
 
 ```ts
 import { poku } from 'npm:poku';
 
-await poku(['targetDir']);
+await poku(['targetPath']);
 ```
 
+### `assert`
+
+Use it exactly as it's for **Node.js** 💚
+
 ---
 
-To see the detailed documentation, please visit the [**Documentation**](https://poku.dev/docs/category/documentation) section in the [**Poku**'s website](https://poku.dev).
+To see the detailed documentation, please visit the [**Documentation**](https://poku.dev/docs/category/documentation) and [**Examples**](https://poku.dev/docs/category/examples) sections in the [**Poku**'s website](https://poku.dev).
 
 ---
 

package/lib/@types/poku.d.ts

@@ -50,4 +50,32 @@ export type Configs = {
      * @default 'node'
      */
     platform?: 'node' | 'bun' | 'deno';
+    /**
+     * You can use this option to run a **callback** or a **file** before each test file on your suite.
+     *
+     * Ex.:
+     *
+     * ```ts
+     * beforeEach(prepare)
+     * ```
+     *
+     * ```ts
+     * beforeEach('/tools/prepare.ts')
+     * ```
+     */
+    beforeEach?: () => unknown | Promise<unknown>;
+    /**
+     * You can use this option to run a **callback** or a **file** after each test file on your suite.
+     *
+     * Ex.:
+     *
+     * ```ts
+     * afterEach(cleanup)
+     * ```
+     *
+     * ```ts
+     * afterEach('/tools/cleanup.ts')
+     * ```
+     */
+    afterEach?: () => unknown | Promise<unknown>;
 } & ListFilesConfigs;

package/lib/helpers/format.d.ts

@@ -4,6 +4,7 @@ export declare const format: {
     bold: (value: string) => string;
     underline: (value: string) => string;
     info: (value: string) => string;
+    italic: (value: string) => string;
     success: (value: string) => string;
     fail: (value: string) => string;
     bg: (bg: number, text: string) => string;

package/lib/helpers/format.js

@@ -11,6 +11,7 @@ exports.format = {
     bold: (value) => `\x1b[1m${value}\x1b[0m`,
     underline: (value) => `\x1b[4m${value}\x1b[0m`,
     info: (value) => `\x1b[94m${value}\x1b[0m`,
+    italic: (value) => `\x1b[3m${value}\x1b[0m`,
     success: (value) => `\x1b[32m${value}\x1b[0m`,
     fail: (value) => `\x1b[91m${value}\x1b[0m`,
     bg: (bg, text) => {

package/lib/index.d.ts

@@ -1,6 +1,8 @@
 export { poku } from './modules/poku.js';
 export { exit } from './modules/exit.js';
 export { assert } from './modules/assert.js';
+export { assertPromise } from './modules/assert-promise.js';
+export { beforeEach, afterEach } from './modules/each.js';
 export { publicListFiles as listFiles } from './modules/list-files.js';
 export type { Code } from './@types/code.ts';
 export type { Configs } from './@types/poku.ts';

package/lib/index.js

@@ -1,11 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.listFiles = exports.assert = exports.exit = exports.poku = void 0;
+exports.listFiles = exports.afterEach = exports.beforeEach = exports.assertPromise = exports.assert = exports.exit = exports.poku = void 0;
 var poku_js_1 = require("./modules/poku.js");
 Object.defineProperty(exports, "poku", { enumerable: true, get: function () { return poku_js_1.poku; } });
 var exit_js_1 = require("./modules/exit.js");
 Object.defineProperty(exports, "exit", { enumerable: true, get: function () { return exit_js_1.exit; } });
 var assert_js_1 = require("./modules/assert.js");
 Object.defineProperty(exports, "assert", { enumerable: true, get: function () { return assert_js_1.assert; } });
+var assert_promise_js_1 = require("./modules/assert-promise.js");
+Object.defineProperty(exports, "assertPromise", { enumerable: true, get: function () { return assert_promise_js_1.assertPromise; } });
+var each_js_1 = require("./modules/each.js");
+Object.defineProperty(exports, "beforeEach", { enumerable: true, get: function () { return each_js_1.beforeEach; } });
+Object.defineProperty(exports, "afterEach", { enumerable: true, get: function () { return each_js_1.afterEach; } });
 var list_files_js_1 = require("./modules/list-files.js");
 Object.defineProperty(exports, "listFiles", { enumerable: true, get: function () { return list_files_js_1.publicListFiles; } });

package/lib/modules/assert-promise.d.ts

@@ -0,0 +1,31 @@
+/// <reference types="node" />
+import * as nodeAssert from 'node:assert';
+import { ParseAssertionOptions } from '../helpers/parseAsssetion.js';
+declare function doesNotReject(block: (() => Promise<unknown>) | Promise<unknown>, message?: string | Error): Promise<void>;
+declare function doesNotReject(block: (() => Promise<unknown>) | Promise<unknown>, error: nodeAssert.AssertPredicate, message?: string | Error): Promise<void>;
+declare function doesNotThrow(block: () => unknown, message?: string | ParseAssertionOptions['message']): void;
+declare function doesNotThrow(block: () => unknown, error: nodeAssert.AssertPredicate, message?: ParseAssertionOptions['message']): void;
+declare function throws(block: () => unknown, message?: ParseAssertionOptions['message']): void;
+declare function throws(block: () => unknown, error: nodeAssert.AssertPredicate, message?: ParseAssertionOptions['message']): void;
+declare function rejects(block: (() => Promise<unknown>) | Promise<unknown>, message?: string | Error): Promise<void>;
+declare function rejects(block: (() => Promise<unknown>) | Promise<unknown>, error: nodeAssert.AssertPredicate, message?: string | Error): Promise<void>;
+export declare const assertPromise: ((value: unknown, message?: ParseAssertionOptions['message']) => Promise<void>) & {
+    ok: (value: unknown, message?: ParseAssertionOptions['message']) => Promise<void>;
+    equal: (actual: unknown, expected: unknown, message?: ParseAssertionOptions['message']) => Promise<void>;
+    deepEqual: (actual: unknown, expected: unknown, message?: ParseAssertionOptions['message']) => Promise<void>;
+    strictEqual: (actual: unknown, expected: unknown, message?: ParseAssertionOptions['message']) => Promise<void>;
+    deepStrictEqual: (actual: unknown, expected: unknown, message?: ParseAssertionOptions['message']) => Promise<void>;
+    doesNotMatch: (value: string, regExp: RegExp, message?: ParseAssertionOptions['message']) => Promise<void>;
+    doesNotReject: typeof doesNotReject;
+    throws: typeof throws;
+    doesNotThrow: typeof doesNotThrow;
+    notEqual: (actual: unknown, expected: unknown, message?: ParseAssertionOptions['message']) => Promise<void>;
+    notDeepEqual: (actual: unknown, expected: unknown, message?: ParseAssertionOptions['message']) => Promise<void>;
+    notStrictEqual: (actual: unknown, expected: unknown, message?: ParseAssertionOptions['message']) => Promise<void>;
+    notDeepStrictEqual: (actual: unknown, expected: unknown, message?: ParseAssertionOptions['message']) => Promise<void>;
+    match: (value: string, regExp: RegExp, message?: ParseAssertionOptions['message']) => Promise<void>;
+    ifError: (value: unknown) => Promise<void>;
+    fail: (message?: ParseAssertionOptions['message']) => void;
+    rejects: typeof rejects;
+};
+export {};

package/lib/modules/assert-promise.js

@@ -0,0 +1,357 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertPromise = void 0;
+const nodeAssert = __importStar(require("assert"));
+const parseAsssetion_js_1 = require("../helpers/parseAsssetion.js");
+const assert_js_1 = require("./assert.js");
+const ok = (value, message) => __awaiter(void 0, void 0, void 0, function* () {
+    if (assert_js_1.each.before)
+        yield assert_js_1.each.before();
+    (0, parseAsssetion_js_1.parseAssertion)(() => nodeAssert.ok(value), { message });
+    if (assert_js_1.each.after)
+        yield assert_js_1.each.after();
+});
+const equal = (actual, expected, message) => __awaiter(void 0, void 0, void 0, function* () {
+    if (assert_js_1.each.before)
+        yield assert_js_1.each.before();
+    (0, parseAsssetion_js_1.parseAssertion)(() => nodeAssert.equal(actual, expected), { message });
+    if (assert_js_1.each.after)
+        yield assert_js_1.each.after();
+});
+const deepEqual = (actual, expected, message) => __awaiter(void 0, void 0, void 0, function* () {
+    if (assert_js_1.each.before)
+        yield assert_js_1.each.before();
+    (0, parseAsssetion_js_1.parseAssertion)(() => nodeAssert.deepEqual(actual, expected), {
+        message,
+    });
+    if (assert_js_1.each.after)
+        yield assert_js_1.each.after();
+});
+const strictEqual = (actual, expected, message) => __awaiter(void 0, void 0, void 0, function* () {
+    if (assert_js_1.each.before)
+        yield assert_js_1.each.before();
+    (0, parseAsssetion_js_1.parseAssertion)(() => nodeAssert.strictEqual(actual, expected), {
+        message,
+    });
+    if (assert_js_1.each.after)
+        yield assert_js_1.each.after();
+});
+const deepStrictEqual = (actual, expected, message) => __awaiter(void 0, void 0, void 0, function* () {
+    if (assert_js_1.each.before)
+        yield assert_js_1.each.before();
+    (0, parseAsssetion_js_1.parseAssertion)(() => nodeAssert.deepStrictEqual(actual, expected), {
+        message,
+    });
+    if (assert_js_1.each.after)
+        yield assert_js_1.each.after();
+});
+const doesNotMatch = (value, regExp, message) => __awaiter(void 0, void 0, void 0, function* () {
+    if (assert_js_1.each.before)
+        yield assert_js_1.each.before();
+    (0, parseAsssetion_js_1.parseAssertion)(() => nodeAssert.doesNotMatch(value, regExp), {
+        message,
+    });
+    if (assert_js_1.each.after)
+        yield assert_js_1.each.after();
+});
+function doesNotReject(block, errorOrMessage, message) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (typeof errorOrMessage === 'function' ||
+            errorOrMessage instanceof RegExp ||
+            typeof errorOrMessage === 'object') {
+            try {
+                if (assert_js_1.each.before)
+                    yield assert_js_1.each.before();
+                yield nodeAssert.doesNotReject(block, errorOrMessage);
+                if (assert_js_1.each.after)
+                    yield assert_js_1.each.after();
+            }
+            catch (error) {
+                (0, parseAsssetion_js_1.parseAssertion)(() => {
+                    throw error;
+                }, {
+                    message,
+                    defaultMessage: 'Got unwanted rejection',
+                    hideDiff: true,
+                    throw: true,
+                });
+            }
+        }
+        else {
+            try {
+                if (assert_js_1.each.before)
+                    yield assert_js_1.each.before();
+                yield nodeAssert.doesNotReject(block);
+                if (assert_js_1.each.after)
+                    yield assert_js_1.each.after();
+            }
+            catch (error_1) {
+                (0, parseAsssetion_js_1.parseAssertion)(() => {
+                    throw error_1;
+                }, {
+                    message: typeof errorOrMessage === 'string' ? errorOrMessage : undefined,
+                    defaultMessage: 'Got unwanted rejection',
+                    hideDiff: true,
+                    throw: true,
+                });
+            }
+        }
+    });
+}
+function doesNotThrow(block, errorOrMessage, message) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (typeof errorOrMessage === 'function' ||
+            errorOrMessage instanceof RegExp ||
+            typeof errorOrMessage === 'object') {
+            try {
+                if (assert_js_1.each.before)
+                    yield assert_js_1.each.before();
+                nodeAssert.doesNotThrow(block, errorOrMessage, message);
+                if (assert_js_1.each.after)
+                    yield assert_js_1.each.after();
+            }
+            catch (error) {
+                (0, parseAsssetion_js_1.parseAssertion)(() => {
+                    throw error;
+                }, {
+                    message: message,
+                    defaultMessage: 'Expected function not to throw',
+                    hideDiff: true,
+                    throw: true,
+                });
+            }
+        }
+        else {
+            const msg = typeof errorOrMessage === 'string' ? errorOrMessage : undefined;
+            try {
+                if (assert_js_1.each.before)
+                    yield assert_js_1.each.before();
+                nodeAssert.doesNotThrow(block, msg);
+                if (assert_js_1.each.after)
+                    yield assert_js_1.each.after();
+            }
+            catch (error) {
+                (0, parseAsssetion_js_1.parseAssertion)(() => {
+                    throw error;
+                }, {
+                    message: msg,
+                    defaultMessage: 'Expected function not to throw',
+                    hideDiff: true,
+                    throw: true,
+                });
+            }
+        }
+    });
+}
+function throws(block, errorOrMessage, message) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (typeof errorOrMessage === 'function' ||
+            errorOrMessage instanceof RegExp ||
+            typeof errorOrMessage === 'object') {
+            try {
+                if (assert_js_1.each.before)
+                    yield assert_js_1.each.before();
+                nodeAssert.throws(block, errorOrMessage, message);
+                if (assert_js_1.each.after)
+                    yield assert_js_1.each.after();
+            }
+            catch (error) {
+                (0, parseAsssetion_js_1.parseAssertion)(() => {
+                    throw error;
+                }, {
+                    message: message,
+                    defaultMessage: 'Expected function to throw',
+                    hideDiff: true,
+                });
+            }
+        }
+        else {
+            const msg = typeof errorOrMessage === 'string' ? errorOrMessage : undefined;
+            try {
+                if (assert_js_1.each.before)
+                    yield assert_js_1.each.before();
+                nodeAssert.throws(block, message);
+                if (assert_js_1.each.after)
+                    yield assert_js_1.each.after();
+            }
+            catch (error) {
+                (0, parseAsssetion_js_1.parseAssertion)(() => {
+                    throw error;
+                }, {
+                    message: msg,
+                    defaultMessage: 'Expected function to throw',
+                    hideDiff: true,
+                });
+            }
+        }
+    });
+}
+const notEqual = (actual, expected, message) => __awaiter(void 0, void 0, void 0, function* () {
+    if (assert_js_1.each.before)
+        yield assert_js_1.each.before();
+    (0, parseAsssetion_js_1.parseAssertion)(() => nodeAssert.notEqual(actual, expected), {
+        message,
+    });
+    if (assert_js_1.each.after)
+        yield assert_js_1.each.after();
+});
+const notDeepEqual = (actual, expected, message) => __awaiter(void 0, void 0, void 0, function* () {
+    if (assert_js_1.each.before)
+        yield assert_js_1.each.before();
+    (0, parseAsssetion_js_1.parseAssertion)(() => nodeAssert.notDeepEqual(actual, expected), {
+        message,
+    });
+    if (assert_js_1.each.after)
+        yield assert_js_1.each.after();
+});
+const notStrictEqual = (actual, expected, message) => __awaiter(void 0, void 0, void 0, function* () {
+    if (assert_js_1.each.before)
+        yield assert_js_1.each.before();
+    (0, parseAsssetion_js_1.parseAssertion)(() => nodeAssert.notStrictEqual(actual, expected), {
+        message,
+    });
+    if (assert_js_1.each.after)
+        yield assert_js_1.each.after();
+});
+const notDeepStrictEqual = (actual, expected, message) => __awaiter(void 0, void 0, void 0, function* () {
+    if (assert_js_1.each.before)
+        yield assert_js_1.each.before();
+    (0, parseAsssetion_js_1.parseAssertion)(() => nodeAssert.notDeepStrictEqual(actual, expected), {
+        message,
+    });
+    if (assert_js_1.each.after)
+        yield assert_js_1.each.after();
+});
+const match = (value, regExp, message) => __awaiter(void 0, void 0, void 0, function* () {
+    if (assert_js_1.each.before)
+        yield assert_js_1.each.before();
+    (0, parseAsssetion_js_1.parseAssertion)(() => nodeAssert.match(value, regExp), { message });
+    if (assert_js_1.each.after)
+        yield assert_js_1.each.after();
+});
+const ifError = (value) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        if (assert_js_1.each.before)
+            yield assert_js_1.each.before();
+        nodeAssert.ifError(value);
+        if (assert_js_1.each.after)
+            yield assert_js_1.each.after();
+    }
+    catch (error) {
+        (0, parseAsssetion_js_1.parseAssertion)(() => {
+            throw error;
+        }, {
+            defaultMessage: 'Expected no error, but received an error',
+            hideDiff: true,
+            throw: true,
+        });
+    }
+});
+const fail = (message) => {
+    try {
+        nodeAssert.fail(message);
+    }
+    catch (error) {
+        (0, parseAsssetion_js_1.parseAssertion)(() => {
+            throw error;
+        }, {
+            message,
+            defaultMessage: 'Test failed intentionally',
+            hideDiff: true,
+        });
+    }
+};
+function rejects(block, errorOrMessage, message) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (typeof errorOrMessage === 'function' ||
+            errorOrMessage instanceof RegExp ||
+            typeof errorOrMessage === 'object') {
+            try {
+                if (assert_js_1.each.before)
+                    yield assert_js_1.each.before();
+                yield nodeAssert.rejects(block, errorOrMessage);
+                if (assert_js_1.each.after)
+                    yield assert_js_1.each.after();
+            }
+            catch (error) {
+                (0, parseAsssetion_js_1.parseAssertion)(() => {
+                    throw error;
+                }, {
+                    message,
+                    defaultMessage: 'Expected promise to be rejected with specified error',
+                    hideDiff: true,
+                });
+            }
+        }
+        else {
+            const msg = typeof errorOrMessage === 'string' ? errorOrMessage : undefined;
+            try {
+                if (assert_js_1.each.before)
+                    yield assert_js_1.each.before();
+                yield nodeAssert.rejects(block);
+                if (assert_js_1.each.after)
+                    yield assert_js_1.each.after();
+            }
+            catch (error_1) {
+                (0, parseAsssetion_js_1.parseAssertion)(() => {
+                    throw error_1;
+                }, {
+                    message: msg,
+                    defaultMessage: 'Expected promise to be rejected',
+                    hideDiff: true,
+                });
+            }
+        }
+    });
+}
+exports.assertPromise = Object.assign((value, message) => ok(value, message), {
+    ok,
+    equal,
+    deepEqual,
+    strictEqual,
+    deepStrictEqual,
+    doesNotMatch,
+    doesNotReject,
+    throws,
+    doesNotThrow,
+    notEqual,
+    notDeepEqual,
+    notStrictEqual,
+    notDeepStrictEqual,
+    match,
+    ifError,
+    fail,
+    rejects,
+});

package/lib/modules/assert.d.ts

@@ -1,6 +1,11 @@
 /// <reference types="node" />
 import * as nodeAssert from 'node:assert';
 import { ParseAssertionOptions } from '../helpers/parseAsssetion.js';
+type Each = {
+    before?: undefined | (() => unknown);
+    after?: undefined | (() => unknown);
+};
+export declare const each: Each;
 declare function doesNotReject(block: (() => Promise<unknown>) | Promise<unknown>, message?: string | Error): Promise<void>;
 declare function doesNotReject(block: (() => Promise<unknown>) | Promise<unknown>, error: nodeAssert.AssertPredicate, message?: string | Error): Promise<void>;
 declare function doesNotThrow(block: () => unknown, message?: string | ParseAssertionOptions['message']): void;

package/lib/modules/assert.js

@@ -32,29 +32,59 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.assert = void 0;
+exports.assert = exports.each = void 0;
 const nodeAssert = __importStar(require("assert"));
 const parseAsssetion_js_1 = require("../helpers/parseAsssetion.js");
-const ok = (value, message) => (0, parseAsssetion_js_1.parseAssertion)(() => nodeAssert.ok(value), { message });
-const equal = (actual, expected, message) => (0, parseAsssetion_js_1.parseAssertion)(() => nodeAssert.equal(actual, expected), { message });
-const deepEqual = (actual, expected, message) => (0, parseAsssetion_js_1.parseAssertion)(() => nodeAssert.deepEqual(actual, expected), { message });
-const strictEqual = (actual, expected, message) => (0, parseAsssetion_js_1.parseAssertion)(() => nodeAssert.strictEqual(actual, expected), { message });
-const deepStrictEqual = (actual, expected, message) => (0, parseAsssetion_js_1.parseAssertion)(() => nodeAssert.deepStrictEqual(actual, expected), {
-    message,
-});
-const doesNotMatch = (value, regExp, message) => (0, parseAsssetion_js_1.parseAssertion)(() => nodeAssert.doesNotMatch(value, regExp), {
-    message,
-    actual: 'Value',
-    expected: 'RegExp',
-    defaultMessage: 'Value should not match regExp',
-});
+exports.each = {
+    before: undefined,
+    after: undefined,
+};
+const ok = (value, message) => {
+    exports.each.before && exports.each.before();
+    (0, parseAsssetion_js_1.parseAssertion)(() => nodeAssert.ok(value), { message });
+    exports.each.after && exports.each.after();
+};
+const equal = (actual, expected, message) => {
+    exports.each.before && exports.each.before();
+    (0, parseAsssetion_js_1.parseAssertion)(() => nodeAssert.equal(actual, expected), { message });
+    exports.each.after && exports.each.after();
+};
+const deepEqual = (actual, expected, message) => {
+    exports.each.before && exports.each.before();
+    (0, parseAsssetion_js_1.parseAssertion)(() => nodeAssert.deepEqual(actual, expected), { message });
+    exports.each.after && exports.each.after();
+};
+const strictEqual = (actual, expected, message) => {
+    exports.each.before && exports.each.before();
+    (0, parseAsssetion_js_1.parseAssertion)(() => nodeAssert.strictEqual(actual, expected), { message });
+    exports.each.after && exports.each.after();
+};
+const deepStrictEqual = (actual, expected, message) => {
+    exports.each.before && exports.each.before();
+    (0, parseAsssetion_js_1.parseAssertion)(() => nodeAssert.deepStrictEqual(actual, expected), {
+        message,
+    });
+    exports.each.after && exports.each.after();
+};
+const doesNotMatch = (value, regExp, message) => {
+    exports.each.before && exports.each.before();
+    (0, parseAsssetion_js_1.parseAssertion)(() => nodeAssert.doesNotMatch(value, regExp), {
+        message,
+        actual: 'Value',
+        expected: 'RegExp',
+        defaultMessage: 'Value should not match regExp',
+    });
+    exports.each.after && exports.each.after();
+};
 function doesNotReject(block, errorOrMessage, message) {
     return __awaiter(this, void 0, void 0, function* () {
         if (typeof errorOrMessage === 'function' ||
             errorOrMessage instanceof RegExp ||
             typeof errorOrMessage === 'object') {
             try {
-                return yield nodeAssert.doesNotReject(block, errorOrMessage);
+                exports.each.before && exports.each.before();
+                yield nodeAssert.doesNotReject(block, errorOrMessage);
+                exports.each.after && exports.each.after();
             }
             catch (error) {
                 (0, parseAsssetion_js_1.parseAssertion)(() => {
@@ -69,7 +99,9 @@ function doesNotReject(block, errorOrMessage, message) {
         }
         else {
             try {
-                return yield nodeAssert.doesNotReject(block);
+                exports.each.before && exports.each.before();
+                yield nodeAssert.doesNotReject(block);
+                exports.each.after && exports.each.after();
             }
             catch (error_1) {
                 (0, parseAsssetion_js_1.parseAssertion)(() => {
@@ -89,7 +121,9 @@ function doesNotThrow(block, errorOrMessage, message) {
         errorOrMessage instanceof RegExp ||
         typeof errorOrMessage === 'object') {
         try {
+            exports.each.before && exports.each.before();
             nodeAssert.doesNotThrow(block, errorOrMessage, message);
+            exports.each.after && exports.each.after();
         }
         catch (error) {
             (0, parseAsssetion_js_1.parseAssertion)(() => {
@@ -105,7 +139,9 @@ function doesNotThrow(block, errorOrMessage, message) {
     else {
         const msg = typeof errorOrMessage === 'string' ? errorOrMessage : undefined;
         try {
+            exports.each.before && exports.each.before();
             nodeAssert.doesNotThrow(block, msg);
+            exports.each.after && exports.each.after();
         }
         catch (error) {
             (0, parseAsssetion_js_1.parseAssertion)(() => {
@@ -124,7 +160,9 @@ function throws(block, errorOrMessage, message) {
         errorOrMessage instanceof RegExp ||
         typeof errorOrMessage === 'object') {
         try {
+            exports.each.before && exports.each.before();
             nodeAssert.throws(block, errorOrMessage, message);
+            exports.each.after && exports.each.after();
         }
         catch (error) {
             (0, parseAsssetion_js_1.parseAssertion)(() => {
@@ -139,7 +177,9 @@ function throws(block, errorOrMessage, message) {
     else {
         const msg = typeof errorOrMessage === 'string' ? errorOrMessage : undefined;
         try {
+            exports.each.before && exports.each.before();
             nodeAssert.throws(block, message);
+            exports.each.after && exports.each.after();
         }
         catch (error) {
             (0, parseAsssetion_js_1.parseAssertion)(() => {
@@ -152,25 +192,47 @@ function throws(block, errorOrMessage, message) {
         }
     }
 }
-const notEqual = (actual, expected, message) => (0, parseAsssetion_js_1.parseAssertion)(() => nodeAssert.notEqual(actual, expected), {
-    message,
-});
-const notDeepEqual = (actual, expected, message) => (0, parseAsssetion_js_1.parseAssertion)(() => nodeAssert.notDeepEqual(actual, expected), { message });
-const notStrictEqual = (actual, expected, message) => (0, parseAsssetion_js_1.parseAssertion)(() => nodeAssert.notStrictEqual(actual, expected), {
-    message,
-});
-const notDeepStrictEqual = (actual, expected, message) => (0, parseAsssetion_js_1.parseAssertion)(() => nodeAssert.notDeepStrictEqual(actual, expected), {
-    message,
-});
-const match = (value, regExp, message) => (0, parseAsssetion_js_1.parseAssertion)(() => nodeAssert.match(value, regExp), {
-    message,
-    actual: 'Value',
-    expected: 'RegExp',
-    defaultMessage: 'Value should match regExp',
-});
+const notEqual = (actual, expected, message) => {
+    exports.each.before && exports.each.before();
+    (0, parseAsssetion_js_1.parseAssertion)(() => nodeAssert.notEqual(actual, expected), {
+        message,
+    });
+    exports.each.after && exports.each.after();
+};
+const notDeepEqual = (actual, expected, message) => {
+    exports.each.before && exports.each.before();
+    (0, parseAsssetion_js_1.parseAssertion)(() => nodeAssert.notDeepEqual(actual, expected), { message });
+    exports.each.after && exports.each.after();
+};
+const notStrictEqual = (actual, expected, message) => {
+    exports.each.before && exports.each.before();
+    (0, parseAsssetion_js_1.parseAssertion)(() => nodeAssert.notStrictEqual(actual, expected), {
+        message,
+    });
+    exports.each.after && exports.each.after();
+};
+const notDeepStrictEqual = (actual, expected, message) => {
+    exports.each.before && exports.each.before();
+    (0, parseAsssetion_js_1.parseAssertion)(() => nodeAssert.notDeepStrictEqual(actual, expected), {
+        message,
+    });
+    exports.each.after && exports.each.after();
+};
+const match = (value, regExp, message) => {
+    exports.each.before && exports.each.before();
+    (0, parseAsssetion_js_1.parseAssertion)(() => nodeAssert.match(value, regExp), {
+        message,
+        actual: 'Value',
+        expected: 'RegExp',
+        defaultMessage: 'Value should match regExp',
+    });
+    exports.each.after && exports.each.after();
+};
 const ifError = (value) => {
     try {
+        exports.each.before && exports.each.before();
         nodeAssert.ifError(value);
+        exports.each.after && exports.each.after();
     }
     catch (error) {
         (0, parseAsssetion_js_1.parseAssertion)(() => {
@@ -202,7 +264,9 @@ function rejects(block, errorOrMessage, message) {
             errorOrMessage instanceof RegExp ||
             typeof errorOrMessage === 'object') {
             try {
-                return yield nodeAssert.rejects(block, errorOrMessage);
+                exports.each.before && exports.each.before();
+                yield nodeAssert.rejects(block, errorOrMessage);
+                exports.each.after && exports.each.after();
             }
             catch (error) {
                 (0, parseAsssetion_js_1.parseAssertion)(() => {
@@ -217,7 +281,9 @@ function rejects(block, errorOrMessage, message) {
         else {
             const msg = typeof errorOrMessage === 'string' ? errorOrMessage : undefined;
             try {
-                return yield nodeAssert.rejects(block);
+                exports.each.before && exports.each.before();
+                yield nodeAssert.rejects(block);
+                exports.each.after && exports.each.after();
             }
             catch (error_1) {
                 (0, parseAsssetion_js_1.parseAssertion)(() => {

package/lib/modules/each.d.ts

@@ -0,0 +1,50 @@
+type Control = {
+    pause: () => void;
+    continue: () => void;
+    reset: () => void;
+};
+/**
+ * - ✅ Handling **global** and **external** services (_preparing a database, for example_)
+ * - ✅ It's made for **exclusive use** in combination with **Poku**'s **`assert`** methods
+ * - ❌ Changing local variables values and states ([_use a mock instead_](https://poku.dev/docs/category/mock))
+ *
+ * ---
+ *
+ * ### Available methos:
+ *
+ * ```ts
+ * import { assert, beforeEach } from 'poku';
+ *
+ * const before = beforeEach(() => {
+ *   // preparing an external or global state
+ * };
+ *
+ * before.pause();
+ * before.continue();
+ * before.reset();
+ * ```
+ */
+export declare const beforeEach: (callback: () => unknown) => Control;
+/**
+ * - ✅ Handling **global** and **external** services (_preparing a database, for example_)
+ * - ✅ It's made for **exclusive use** in combination with **Poku**'s **`assert`** methods
+ * - ❌ Changing local variables values and states ([_use a mock instead_](https://poku.dev/docs/category/mock))
+ *
+ * ---
+ *
+ * ### Available methos:
+ *
+ * ```ts
+ * import { assert, afterEach } from 'poku';
+ *
+ * const after = afterEach(() => {
+ *   // cleanup an external or global state
+ * };
+ *
+ * after.pause();
+ * after.continue();
+ * after.reset();
+ * ```
+ */
+export declare const afterEach: (callback: () => unknown) => Control;
+export {};

package/lib/modules/each.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.afterEach = exports.beforeEach = void 0;
+const assert_js_1 = require("../modules/assert.js");
+const status = {
+    before: true,
+    after: true,
+};
+/**
+ * - ✅ Handling **global** and **external** services (_preparing a database, for example_)
+ * - ✅ It's made for **exclusive use** in combination with **Poku**'s **`assert`** methods
+ * - ❌ Changing local variables values and states ([_use a mock instead_](https://poku.dev/docs/category/mock))
+ *
+ * ---
+ *
+ * ### Available methos:
+ *
+ * ```ts
+ * import { assert, beforeEach } from 'poku';
+ *
+ * const before = beforeEach(() => {
+ *   // preparing an external or global state
+ * };
+ *
+ * before.pause();
+ * before.continue();
+ * before.reset();
+ * ```
+ */
+const beforeEach = (callback) => {
+    assert_js_1.each.before = () => {
+        if (status.before)
+            callback();
+    };
+    const pause = () => {
+        status.before = false;
+    };
+    const continueFunc = () => {
+        status.before = true;
+    };
+    const reset = () => {
+        assert_js_1.each.before = undefined;
+    };
+    return { pause, continue: continueFunc, reset };
+};
+exports.beforeEach = beforeEach;
+/**
+ * - ✅ Handling **global** and **external** services (_preparing a database, for example_)
+ * - ✅ It's made for **exclusive use** in combination with **Poku**'s **`assert`** methods
+ * - ❌ Changing local variables values and states ([_use a mock instead_](https://poku.dev/docs/category/mock))
+ *
+ * ---
+ *
+ * ### Available methos:
+ *
+ * ```ts
+ * import { assert, afterEach } from 'poku';
+ *
+ * const after = afterEach(() => {
+ *   // cleanup an external or global state
+ * };
+ *
+ * after.pause();
+ * after.continue();
+ * after.reset();
+ * ```
+ */
+const afterEach = (callback) => {
+    assert_js_1.each.after = () => {
+        if (status.after)
+            callback();
+    };
+    const pause = () => {
+        status.after = false;
+    };
+    const continueFunc = () => {
+        status.after = true;
+    };
+    const reset = () => {
+        assert_js_1.each.after = undefined;
+    };
+    return { pause, continue: continueFunc, reset };
+};
+exports.afterEach = afterEach;

package/lib/modules/list-files.d.ts

@@ -1,5 +1,7 @@
 import type { Configs } from '../@types/list-files.js';
 export declare const sanitizePath: (input: string, ensureTarget?: boolean) => string;
 export declare const escapeRegExp: (string: string) => string;
+export declare const isFile: (fullPath: string) => boolean;
+export declare const isDir: (fullPath: string) => boolean;
 export declare const listFiles: (dirPath: string, files?: string[], configs?: Configs) => string[];
 export declare const publicListFiles: (targetDir: string, configs?: Configs) => string[];

package/lib/modules/list-files.js

@@ -4,7 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.publicListFiles = exports.listFiles = exports.escapeRegExp = exports.sanitizePath = void 0;
+exports.publicListFiles = exports.listFiles = exports.isDir = exports.isFile = exports.escapeRegExp = exports.sanitizePath = void 0;
 const node_process_1 = __importDefault(require("process"));
 const node_fs_1 = __importDefault(require("fs"));
 const node_path_1 = __importDefault(require("path"));
@@ -19,6 +19,10 @@ const sanitizePath = (input, ensureTarget) => {
 exports.sanitizePath = sanitizePath;
 const escapeRegExp = (string) => string.replace(/[.*{}[\]\\]/g, '\\$&');
 exports.escapeRegExp = escapeRegExp;
+const isFile = (fullPath) => node_fs_1.default.statSync(fullPath).isFile();
+exports.isFile = isFile;
+const isDir = (fullPath) => node_fs_1.default.statSync(fullPath).isDirectory();
+exports.isDir = isDir;
 const envFilter = ((_a = node_process_1.default.env.FILTER) === null || _a === void 0 ? void 0 : _a.trim())
     ? new RegExp((0, exports.escapeRegExp)(node_process_1.default.env.FILTER), 'i')
     : null;
@@ -41,7 +45,7 @@ const listFiles = (dirPath, files = [], configs) => {
             continue;
         if (exclude && exclude.some((regex) => regex.test(fullPath)))
             continue;
-        if (node_fs_1.default.statSync(fullPath).isDirectory())
+        if ((0, exports.isDir)(fullPath))
             (0, exports.listFiles)(fullPath, files, configs);
         else if (filter.test(fullPath))
             files.push(fullPath);

package/lib/modules/poku.d.ts

@@ -1,6 +1,6 @@
 import { Code } from '../@types/code.js';
 import { Configs } from '../@types/poku.js';
-export declare function poku(targetDirs: string | string[], configs: Configs & {
+export declare function poku(targetPaths: string | string[], configs: Configs & {
     noExit: true;
 }): Promise<Code>;
-export declare function poku(targetDirs: string | string[], configs?: Configs): Promise<void>;
+export declare function poku(targetPaths: string | string[], configs?: Configs): Promise<void>;

package/lib/modules/poku.js

@@ -19,10 +19,10 @@ const logs_js_1 = require("../helpers/logs.js");
 const hr_js_1 = require("../helpers/hr.js");
 const run_test_file_js_1 = require("../services/run-test-file.js");
 const indentation_js_1 = require("../helpers/indentation.js");
-function poku(targetDirs, configs) {
+function poku(targetPaths, configs) {
     return __awaiter(this, void 0, void 0, function* () {
         let code = 0;
-        const prepareDirs = (0, force_array_js_1.forceArray)(targetDirs);
+        const prepareDirs = (0, force_array_js_1.forceArray)(targetPaths);
         const dirs = prepareDirs.length > 0 ? prepareDirs : ['./'];
         const showLogs = !(0, logs_js_1.isQuiet)(configs);
         if (configs === null || configs === void 0 ? void 0 : configs.parallel) {

package/lib/services/each.d.ts

@@ -0,0 +1,3 @@
+import { Configs } from '../@types/poku.js';
+export declare const beforeEach: (fileRelative: string, configs?: Configs) => Promise<boolean>;
+export declare const afterEach: (fileRelative: string, configs?: Configs) => Promise<boolean>;

package/lib/services/each.js

@@ -0,0 +1,44 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.afterEach = exports.beforeEach = void 0;
+const node_os_1 = require("os");
+const format_js_1 = require("../helpers/format.js");
+const eachCore = (type, fileRelative, configs) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    if (typeof (configs === null || configs === void 0 ? void 0 : configs[type]) !== 'function')
+        return true;
+    const functionName = (_a = configs[type]) === null || _a === void 0 ? void 0 : _a.name;
+    console.log(`    ${format_js_1.format.dim(format_js_1.format.info('◯'))} ${format_js_1.format.dim(format_js_1.format.italic(`${configs[type]}: ${functionName !== configs[type] ? functionName : 'anonymous function'}`))}`);
+    try {
+        yield ((_b = configs[type]) === null || _b === void 0 ? void 0 : _b.call(configs));
+        return true;
+    }
+    catch (error) {
+        console.log(format_js_1.format.bold(format_js_1.format.fail(`    ✘ ${type} callback failed ${format_js_1.format.dim(`› ${configs[type]}`)}`)));
+        console.log(format_js_1.format.fail(`      ├─ Who's trying to run this ${type}?${node_os_1.EOL}      │ └─ ${format_js_1.format.underline(fileRelative)}`));
+        error instanceof Error &&
+            console.log(format_js_1.format.fail(`      ├─ Message:${node_os_1.EOL}      │ └─ ${error.message}`));
+        return false;
+    }
+});
+const beforeEach = (fileRelative, configs) => __awaiter(void 0, void 0, void 0, function* () {
+    if (configs === null || configs === void 0 ? void 0 : configs.beforeEach)
+        return yield eachCore('beforeEach', fileRelative, configs);
+    return true;
+});
+exports.beforeEach = beforeEach;
+const afterEach = (fileRelative, configs) => __awaiter(void 0, void 0, void 0, function* () {
+    if (configs === null || configs === void 0 ? void 0 : configs.afterEach)
+        return yield eachCore('afterEach', fileRelative, configs);
+    return true;
+});
+exports.afterEach = afterEach;

package/lib/services/run-test-file.d.ts

@@ -1,8 +1,7 @@
 import { Configs } from '../@types/poku.js';
-type FileResults = {
+export type FileResults = {
     success: string[];
     fail: string[];
 };
 export declare const fileResults: FileResults;
 export declare const runTestFile: (filePath: string, configs?: Configs) => Promise<boolean>;
-export {};

package/lib/services/run-test-file.js

@@ -1,4 +1,13 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -13,11 +22,12 @@ const indentation_js_1 = require("../helpers/indentation.js");
 const format_js_1 = require("../helpers/format.js");
 const logs_js_1 = require("../helpers/logs.js");
 const remove_repeats_js_1 = require("../helpers/remove-repeats.js");
+const each_js_1 = require("./each.js");
 exports.fileResults = {
     success: [],
     fail: [],
 };
-const runTestFile = (filePath, configs) => new Promise((resolve) => {
+const runTestFile = (filePath, configs) => new Promise((resolve) => __awaiter(void 0, void 0, void 0, function* () {
     const runtimeOptions = (0, runner_js_1.runner)(filePath, configs);
     const runtime = runtimeOptions.shift();
     const runtimeArguments = runtimeOptions.length > 1 ? [...runtimeOptions, filePath] : [filePath];
@@ -60,6 +70,9 @@ const runTestFile = (filePath, configs) => new Promise((resolve) => {
         showLogs &&
             console.log(`${indentation_js_1.indentation.test}${format_js_1.format.info(format_js_1.format.dim('●'))} ${format_js_1.format.dim(fileRelative)}`);
     }
+    if (!(yield (0, each_js_1.beforeEach)(fileRelative, configs)))
+        return false;
+    // Export spawn helper is not an option
     const child = (0, node_child_process_1.spawn)(runtime, runtimeArguments, {
         stdio: ['inherit', 'pipe', 'pipe'],
         shell: false,
@@ -67,20 +80,22 @@ const runTestFile = (filePath, configs) => new Promise((resolve) => {
     });
     child.stdout.on('data', stdOut);
     child.stderr.on('data', stdOut);
-    child.on('close', (code) => {
+    child.on('close', (code) => __awaiter(void 0, void 0, void 0, function* () {
         if (showLogs)
             log();
+        if (!(yield (0, each_js_1.afterEach)(fileRelative, configs)))
+            return false;
         const result = code === 0;
         if (result)
             exports.fileResults.success.push(fileRelative);
         else
             exports.fileResults.fail.push(fileRelative);
         resolve(result);
-    });
+    }));
     child.on('error', (err) => {
         console.log(`Failed to start test: ${filePath}`, err);
         exports.fileResults.fail.push(fileRelative);
         resolve(false);
     });
-});
+}));
 exports.runTestFile = runTestFile;

package/lib/services/run-tests.js

@@ -31,13 +31,14 @@ const runTests = (dir, configs) => __awaiter(void 0, void 0, void 0, function* (
     const cwd = node_process_1.default.cwd();
     const testDir = node_path_1.default.join(cwd, (0, list_files_js_1.sanitizePath)(dir));
     const currentDir = node_path_1.default.relative(cwd, testDir);
-    const files = (0, list_files_js_1.listFiles)(testDir, undefined, configs);
+    const isFile = (0, list_files_js_1.isFile)(testDir);
+    const files = isFile ? [testDir] : (0, list_files_js_1.listFiles)(testDir, undefined, configs);
     const totalTests = files.length;
     const showLogs = !(0, logs_js_1.isQuiet)(configs);
     let passed = true;
     if (showLogs) {
         (0, hr_js_1.hr)();
-        console.log(`${format_js_1.format.bold('Directory:')} ${format_js_1.format.underline(`./${currentDir}`)}${node_os_1.EOL}`);
+        console.log(`${format_js_1.format.bold(isFile ? 'File:' : 'Directory:')} ${format_js_1.format.underline(`./${currentDir}`)}${node_os_1.EOL}`);
     }
     for (let i = 0; i < files.length; i++) {
         const filePath = files[i];
@@ -66,7 +67,7 @@ exports.runTests = runTests;
 const runTestsParallel = (dir, configs) => __awaiter(void 0, void 0, void 0, function* () {
     const cwd = node_process_1.default.cwd();
     const testDir = node_path_1.default.join(cwd, dir);
-    const files = (0, list_files_js_1.listFiles)(testDir, undefined, configs);
+    const files = (0, list_files_js_1.isFile)(dir) ? [dir] : (0, list_files_js_1.listFiles)(testDir, undefined, configs);
     const promises = files.map((filePath) => __awaiter(void 0, void 0, void 0, function* () {
         const testPassed = yield (0, run_test_file_js_1.runTestFile)(filePath, configs);
         if (!testPassed) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "poku",
-  "version": "1.5.1",
+  "version": "1.6.0",
   "description": "🐷 Poku brings human-friendly testing and assertion to Node.js, Bun & Deno at the same time.",
   "main": "./lib/index.js",
   "scripts": {