@zohodesk/unit-testing-framework 1.0.0

package/README.md

@@ -0,0 +1,212 @@
+# unit-testing-framework
+
+A modular, Jest-based unit testing package designed to plug into existing CLI pipelines. Runs Jest **programmatically** (no shell execution), supports default + consumer config merging, custom reporters, global setup/teardown, and parallel execution.
+
+---
+
+## Folder Structure
+
+```
+unit-testing-framework/
+├── package.json                        # ESM package with proper exports
+├── index.js                            # Public API entry point
+├── src/
+│   ├── runner/
+│   │   └── jest-runner.js              # Programmatic Jest execution via @jest/core
+│   ├── config/
+│   │   ├── config-loader.js            # Config resolution & deep-merge logic
+│   │   └── default-config.js           # Framework-level default Jest config
+│   ├── reporters/
+│   │   ├── reporter-handler.js         # Reporter resolution (aliases, paths)
+│   │   └── default-reporter.js         # Bundled custom Jest reporter
+│   └── environment/
+│       ├── setup.js                    # Global setup (runs once before suite)
+│       └── teardown.js                 # Global teardown (runs once after suite)
+├── examples/
+│   ├── consumer-cli.js                 # Example integration in existing CLI
+│   └── jest.unit.config.js             # Example consumer config file
+├── .npmignore
+└── README.md
+```
+
+---
+
+## Installation
+
+```bash
+npm install unit-testing-framework
+# jest is a required peer dependency
+npm install --save-dev jest
+```
+
+---
+
+## Quick Start
+
+```js
+import createJestRunner from 'unit-testing-framework';
+
+// Run with defaults - auto-discovers jest.unit.config.js in project root
+const results = await createJestRunner();
+
+process.exitCode = results.numFailedTests > 0 ? 1 : 0;
+```
+
+---
+
+## API
+
+### `createJestRunner(options?)`
+
+| Option | Type | Default | Description |
+|---|---|---|---|
+| `projectRoot` | `string` | `process.cwd()` | Consumer project root |
+| `configPath` | `string` | (auto-discovered) | Path to consumer config file |
+| `inlineConfig` | `object` | `{}` | Inline Jest config overrides (highest priority) |
+| `coverage` | `boolean` | from config | Enable coverage collection |
+| `testFiles` | `string[]` | all | Specific test file patterns |
+| `verbose` | `boolean` | `true` | Verbose output |
+| `maxWorkers` | `number\|string` | `'50%'` | Worker concurrency |
+| `silent` | `boolean` | `false` | Suppress console output |
+| `watch` | `boolean` | `false` | Watch mode |
+
+Returns: `Promise<AggregatedResult>` (Jest results object)
+
+### Named exports
+
+```js
+import {
+  createJestRunner,
+  loadConfig,
+  resolveReporters,
+  globalSetup,
+  globalTeardown,
+} from 'unit-testing-framework';
+```
+
+Sub-path exports:
+```js
+import { loadConfig } from 'unit-testing-framework/config';
+import { resolveReporters } from 'unit-testing-framework/reporters';
+```
+
+---
+
+## Config Priority
+
+```
+inline options  >  consumer config file  >  framework defaults
+```
+
+### Consumer Config File
+
+Place one of these in your project root (auto-discovered in order):
+
+1. `jest.unit.config.js`
+2. `jest.unit.config.mjs`
+3. `jest.unit.config.json`
+
+```js
+// jest.unit.config.js
+export default {
+  roots: ['<rootDir>/tests/unit'],
+  maxWorkers: 4,
+  collectCoverage: true,
+  reporters: ['default', 'framework-default'],
+  testTimeout: 60_000,
+};
+```
+
+### Built-in Reporter Alias
+
+Use `'framework-default'` in the `reporters` array to include the bundled reporter.
+
+---
+
+## Consumer CLI Integration
+
+```js
+// In your existing CLI file
+import createJestRunner from 'unit-testing-framework';
+
+switch (option) {
+  case 'unit-test': {
+    const results = await createJestRunner();
+    process.exitCode = results.numFailedTests > 0 ? 1 : 0;
+    break;
+  }
+
+  case 'unit-test:coverage': {
+    const results = await createJestRunner({ coverage: true });
+    process.exitCode = results.numFailedTests > 0 ? 1 : 0;
+    break;
+  }
+
+  case 'unit-test:watch':
+    await createJestRunner({ watch: true });
+    break;
+}
+```
+
+---
+
+## Consumer Project Structure Example
+
+```
+my-app/
+├── package.json                  # depends on unit-testing-framework
+├── jest.unit.config.js           # optional overrides
+├── cli.js                        # existing CLI with switch/case
+├── src/
+│   └── utils/
+│       └── math.js
+└── tests/
+    └── unit/
+        └── math.test.js
+```
+
+---
+
+## Publishing
+
+```bash
+# 1. Login to npm
+npm login
+
+# 2. Verify package contents
+npm pack --dry-run
+
+# 3. Publish
+npm publish
+
+# For scoped packages:
+npm publish --access public
+```
+
+### Versioning
+
+Follow [semver](https://semver.org/):
+
+```bash
+npm version patch   # 1.0.0 -> 1.0.1  (bug fixes)
+npm version minor   # 1.0.0 -> 1.1.0  (new features, backward-compatible)
+npm version major   # 1.0.0 -> 2.0.0  (breaking changes)
+npm publish
+```
+
+Consumer pins via package.json:
+```json
+{
+  "dependencies": {
+    "unit-testing-framework": "^1.0.0"
+  }
+}
+```
+
+`^1.0.0` allows auto-upgrade for minor/patch. Use exact pinning (`1.0.0`) for strict control.
+
+---
+
+## License
+
+MIT

package/index.js

@@ -0,0 +1,20 @@
+/**
+ * unit-testing-framework
+ *
+ * A modular Jest-based unit testing framework that plugs into
+ * existing CLI pipelines via a single exported function.
+ *
+ * Usage:
+ *   import createJestRunner from 'unit-testing-framework';
+ *   const results = await createJestRunner({ configPath: './jest.config.js' });
+ */
+
+export { default as createJestRunner } from './src/runner/jest-runner.js';
+export { loadConfig } from './src/config/config-loader.js';
+export { resolveReporters } from './src/reporters/reporter-handler.js';
+export { default as globalSetup } from './src/environment/setup.js';
+export { default as globalTeardown } from './src/environment/teardown.js';
+
+// Default export for simple consumer usage:
+//   import createJestRunner from 'unit-testing-framework';
+export { default } from './src/runner/jest-runner.js';

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@zohodesk/unit-testing-framework",
+  "version": "1.0.0",
+  "description": "A modular Jest-based unit testing framework",
+  "type": "module",
+  "main": "./index.js",
+  "exports": {
+    ".": "./index.js",
+    "./config": "./src/config/config-loader.js",
+    "./reporters": "./src/reporters/reporter-handler.js",
+    "./runner": "./src/runner/jest-runner.js"
+  },
+  "files": [
+    "index.js",
+    "src/**/*.js"
+  ],
+  "scripts": {
+    "test": "node --experimental-vm-modules node_modules/.bin/jest",
+    "lint": "eslint src/ index.js"
+  },
+  "keywords": [
+    "jest",
+    "unit-testing",
+    "test-runner",
+    "testing-framework",
+    "programmatic-jest"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@jest/core": "29.7.0",
+    "@jest/types": "29.6.3",
+    "jest-environment-node": "29.7.0"
+  },
+  "peerDependencies": {
+    "jest": "29.7.0"
+  },
+  "peerDependenciesMeta": {
+    "jest": {
+      "optional": false
+    }
+  },
+  "devDependencies": {
+    "jest": "29.7.0"
+  }
+}

package/src/config/config-loader.js

@@ -0,0 +1,137 @@
+/**
+ * config-loader.js
+ *
+ * Responsible for:
+ *  1. Loading the framework default config.
+ *  2. Loading optional consumer-level config (file or inline).
+ *  3. Deep-merging them with consumer config taking priority.
+ *
+ * Merge priority (highest → lowest):
+ *   inline options  >  consumer config file  >  framework defaults
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { pathToFileURL } from 'url';
+import { getDefaultConfig } from './default-config.js';
+
+/**
+ * Deep-merge two plain objects. Arrays are concatenated & de-duped.
+ * `source` values override `target` values.
+ */
+function deepMerge(target, source) {
+  const output = { ...target };
+
+  for (const key of Object.keys(source)) {
+    const srcVal = source[key];
+    const tgtVal = target[key];
+
+    if (srcVal === undefined) continue;
+
+    if (Array.isArray(srcVal) && Array.isArray(tgtVal)) {
+      // Concatenate and de-duplicate
+      output[key] = [...new Set([...tgtVal, ...srcVal])];
+    } else if (
+      srcVal !== null &&
+      typeof srcVal === 'object' &&
+      !Array.isArray(srcVal) &&
+      tgtVal !== null &&
+      typeof tgtVal === 'object' &&
+      !Array.isArray(tgtVal)
+    ) {
+      output[key] = deepMerge(tgtVal, srcVal);
+    } else {
+      output[key] = srcVal;
+    }
+  }
+
+  return output;
+}
+
+/**
+ * Attempt to load a consumer config file.
+ * Supports: .js (ESM), .mjs, .json, .ts (if ts-node is available).
+ *
+ * @param {string} configPath - Absolute path to the config file.
+ * @returns {Promise<object>} Loaded configuration or empty object.
+ */
+async function loadConfigFile(configPath) {
+  if (!fs.existsSync(configPath)) {
+    return {};
+  }
+
+  const ext = path.extname(configPath).toLowerCase();
+
+  if (ext === '.json') {
+    const raw = fs.readFileSync(configPath, 'utf-8');
+    return JSON.parse(raw);
+  }
+
+  // ESM dynamic import works for .js / .mjs
+  const fileUrl = pathToFileURL(configPath).href;
+  const mod = await import(fileUrl);
+  return mod.default ?? mod;
+}
+
+/**
+ * Resolve the consumer config file path.
+ * Search order:
+ *   1. Explicit `configPath` option
+ *   2. `jest.unit.config.js` in project root
+ *   3. `jest.unit.config.mjs` in project root
+ *   4. `jest.unit.config.json` in project root
+ *
+ * @param {string} projectRoot
+ * @param {string} [explicitPath]
+ * @returns {string|null}
+ */
+function resolveConfigFilePath(projectRoot, explicitPath) {
+  if (explicitPath) {
+    const abs = path.isAbsolute(explicitPath)
+      ? explicitPath
+      : path.resolve(projectRoot, explicitPath);
+    return fs.existsSync(abs) ? abs : null;
+  }
+
+  const candidates = [
+    'jest.unit.config.js',
+    'jest.unit.config.mjs',
+    'jest.unit.config.json',
+  ];
+
+  for (const name of candidates) {
+    const full = path.resolve(projectRoot, name);
+    if (fs.existsSync(full)) return full;
+  }
+
+  return null;
+}
+
+/**
+ * Load and merge configuration.
+ *
+ * @param {object} options
+ * @param {string}  options.projectRoot   - Consumer project root (default: process.cwd()).
+ * @param {string} [options.configPath]   - Explicit path to consumer config.
+ * @param {object} [options.inlineConfig] - Inline overrides (highest priority).
+ * @returns {Promise<import('@jest/types').Config.InitialOptions>}
+ */
+export async function loadConfig({
+  projectRoot = process.cwd(),
+  configPath,
+  inlineConfig = {},
+} = {}) {
+  // 1. Framework defaults
+  const defaults = getDefaultConfig(projectRoot);
+
+  // 2. Consumer config file
+  const resolvedPath = resolveConfigFilePath(projectRoot, configPath);
+  const consumerFileConfig = resolvedPath
+    ? await loadConfigFile(resolvedPath)
+    : {};
+
+  // 3. Merge: defaults ← consumer file ← inline
+  const merged = deepMerge(deepMerge(defaults, consumerFileConfig), inlineConfig);
+
+  return merged;
+}

package/src/config/default-config.js

@@ -0,0 +1,77 @@
+/**
+ * default-config.js
+ *
+ * Framework-level default Jest configuration.
+ * Consumer projects can override any of these values
+ * via their own config file or inline options.
+ */
+
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/**
+ * Returns the default Jest configuration object.
+ * Paths are resolved relative to the consumer's project root
+ * (passed at runtime), NOT relative to this package.
+ *
+ * @param {string} projectRoot - Absolute path to the consumer project root.
+ * @returns {import('@jest/types').Config.InitialOptions}
+ */
+export function getDefaultConfig(projectRoot) {
+  return {
+    // --------------- Roots & File Discovery ---------------
+    roots: [path.resolve(projectRoot, 'tests')],
+    testMatch: [
+      '**/*.test.js',
+      '**/*.test.mjs',
+      '**/*.test.ts',
+      '**/*.spec.js',
+      '**/*.spec.mjs',
+      '**/*.spec.ts',
+    ],
+    testPathIgnorePatterns: ['/node_modules/', '/dist/', '/build/'],
+
+    // --------------- Environment ---------------
+    testEnvironment: 'node',
+
+    // --------------- Transform ---------------
+    // ESM-native – no transform needed for plain JS.
+    // Consumer can add ts-jest / babel-jest as needed.
+    transform: {},
+
+    // --------------- Coverage ---------------
+    collectCoverage: false,
+    coverageDirectory: path.resolve(projectRoot, 'coverage'),
+    coverageReporters: ['text', 'lcov', 'clover'],
+    coveragePathIgnorePatterns: ['/node_modules/', '/tests/'],
+
+    // --------------- Reporters ---------------
+    reporters: ['default'],
+
+    // --------------- Parallelism & Performance ---------------
+    maxWorkers: '50%', // Use half of available CPUs
+    maxConcurrency: 5,
+
+    // --------------- Timeouts ---------------
+    testTimeout: 30_000, // 30 seconds per test
+
+    // --------------- Setup Files ---------------
+    // Injects `jest` into globalThis so ESM test files don't need
+    // `import { jest } from '@jest/globals'` manually.
+    setupFiles: [path.resolve(__dirname, '..', 'environment', 'globals-inject.js')],
+
+    // --------------- Global Setup / Teardown ---------------
+    globalSetup: path.resolve(__dirname, '..', 'environment', 'setup.js'),
+    globalTeardown: path.resolve(__dirname, '..', 'environment', 'teardown.js'),
+
+    // --------------- Module Resolution ---------------
+    moduleFileExtensions: ['js', 'mjs', 'ts', 'json', 'node'],
+
+    // --------------- Misc ---------------
+    verbose: true,
+    passWithNoTests: true,
+  };
+}

package/src/environment/globals-inject.js

@@ -0,0 +1,15 @@
+/**
+ * globals-inject.js
+ *
+ * Framework-level setup file that injects Jest globals (like `jest`)
+ * into `globalThis` so that ESM test files can use `jest.fn()`,
+ * `jest.mock()`, etc. without needing an explicit import.
+ *
+ * This file is referenced in the default config's `setupFiles` array.
+ * It runs in the test worker context after the environment is
+ * installed, making `@jest/globals` available.
+ */
+
+import { jest } from '@jest/globals';
+
+globalThis.jest = jest;

package/src/environment/setup.js

@@ -0,0 +1,16 @@
+/**
+ * Global Setup
+ *
+ * Runs once before the entire test suite.
+ * Jest calls this module's default export.
+ *
+ * Consumer projects can override by setting `globalSetup`
+ * in their jest.unit.config.js to their own setup file.
+ */
+
+export default async function globalSetup(_globalConfig) {
+  // Store start timestamp for reporting
+  process.env.__UTL_START_TIME__ = Date.now().toString();
+
+  console.log('[unit-testing-framework] Global setup complete.');
+}

package/src/environment/teardown.js

@@ -0,0 +1,19 @@
+/**
+ * Global Teardown
+ *
+ * Runs once after the entire test suite completes.
+ * Jest calls this module's default export.
+ *
+ * Consumer projects can override by setting `globalTeardown`
+ * in their jest.unit.config.js to their own teardown file.
+ */
+
+export default async function globalTeardown(_globalConfig) {
+  const startTime = Number(process.env.__UTL_START_TIME__ || Date.now());
+  const elapsed = ((Date.now() - startTime) / 1000).toFixed(2);
+
+  console.log(`[unit-testing-framework] Global teardown complete. Total time: ${elapsed}s`);
+
+  // Cleanup environment variable
+  delete process.env.__UTL_START_TIME__;
+}

package/src/reporters/default-reporter.js

@@ -0,0 +1,50 @@
+/**
+ * default-reporter.js
+ *
+ * A lightweight custom Jest reporter that can be bundled with the framework.
+ * Consumer projects can use this as-is or supply their own reporters.
+ *
+ * Jest Reporter interface (class-based):
+ *   - onRunStart(results, options)
+ *   - onTestStart(test)
+ *   - onTestResult(test, testResult, results)
+ *   - onRunComplete(contexts, results)
+ */
+
+export default class DefaultReporter {
+  constructor(globalConfig, _reporterOptions) {
+    this.globalConfig = globalConfig;
+    this._startTime = 0;
+  }
+
+  onRunStart(_results, _options) {
+    this._startTime = Date.now();
+    console.log('\n╔══════════════════════════════════════════╗');
+    console.log('║   Unit Testing Framework – Test Run      ║');
+    console.log('╚══════════════════════════════════════════╝\n');
+  }
+
+  onTestStart(test) {
+    console.log(`  ▶ Running: ${test.path}`);
+  }
+
+  onTestResult(_test, testResult, _aggregatedResults) {
+    const { numPassingTests, numFailingTests, numPendingTests } = testResult;
+    const icon = numFailingTests > 0 ? '✖' : '✔';
+    console.log(
+      `  ${icon}  Passed: ${numPassingTests}  Failed: ${numFailingTests}  Skipped: ${numPendingTests}`
+    );
+  }
+
+  onRunComplete(_contexts, results) {
+    const elapsed = ((Date.now() - this._startTime) / 1000).toFixed(2);
+    const { numPassedTests, numFailedTests, numTotalTests } = results;
+
+    console.log('\n──────────────────────────────────────────');
+    console.log(`  Total:   ${numTotalTests}`);
+    console.log(`  Passed:  ${numPassedTests}`);
+    console.log(`  Failed:  ${numFailedTests}`);
+    console.log(`  Time:    ${elapsed}s`);
+    console.log('──────────────────────────────────────────\n');
+  }
+}

package/src/reporters/reporter-handler.js

@@ -0,0 +1,60 @@
+/**
+ * reporter-handler.js
+ *
+ * Resolves the final reporters array for Jest configuration.
+ *
+ * Supports:
+ *  - 'default'           → Jest built-in default reporter
+ *  - 'framework-default' → This package's DefaultReporter
+ *  - Absolute paths       → Consumer-supplied reporter modules
+ *  - [reporterPath, options] tuples
+ */
+
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const BUILTIN_ALIASES = {
+  'framework-default': path.resolve(__dirname, 'default-reporter.js'),
+};
+
+/**
+ * Resolve a single reporter entry.
+ *
+ * @param {string | [string, object]} entry
+ * @param {string} projectRoot
+ * @returns {string | [string, object]}
+ */
+function resolveEntry(entry, projectRoot) {
+  const isArray = Array.isArray(entry);
+  const name = isArray ? entry[0] : entry;
+  const opts = isArray ? entry[1] : undefined;
+
+  // Check built-in aliases
+  if (BUILTIN_ALIASES[name]) {
+    const resolved = BUILTIN_ALIASES[name];
+    return opts ? [resolved, opts] : resolved;
+  }
+
+  // 'default' and package names are passed through as-is
+  if (name === 'default' || !name.startsWith('.')) {
+    return entry;
+  }
+
+  // Relative paths → resolve from consumer project root
+  const abs = path.resolve(projectRoot, name);
+  return opts ? [abs, opts] : abs;
+}
+
+/**
+ * Resolve the reporters array for final Jest config.
+ *
+ * @param {Array<string | [string, object]>} reporters - Raw reporters from merged config.
+ * @param {string} projectRoot - Consumer project root.
+ * @returns {Array<string | [string, object]>}
+ */
+export function resolveReporters(reporters = ['default'], projectRoot = process.cwd()) {
+  return reporters.map((entry) => resolveEntry(entry, projectRoot));
+}

package/src/runner/jest-runner.js

@@ -0,0 +1,114 @@
+/**
+ * jest-runner.js
+ *
+ * Core module that runs Jest programmatically via @jest/core's runCLI.
+ *
+ * Exported as default from the package's index.js so consumers do:
+ *   import createJestRunner from 'unit-testing-framework';
+ *   await createJestRunner({ projectRoot: process.cwd() });
+ */
+
+import path from 'path';
+import { loadConfig } from '../config/config-loader.js';
+import { resolveReporters } from '../reporters/reporter-handler.js';
+
+/**
+ * @typedef {object} RunnerOptions
+ * @property {string}  [projectRoot]   - Absolute path to the consumer project (default: cwd).
+ * @property {string}  [configPath]    - Path to consumer jest.unit.config.{js,mjs,json}.
+ * @property {object}  [inlineConfig]  - Inline Jest config overrides (highest priority).
+ * @property {boolean} [coverage]      - Enable coverage collection.
+ * @property {string[]} [testFiles]    - Specific test file patterns to run.
+ * @property {boolean} [verbose]       - Verbose output.
+ * @property {number|string} [maxWorkers] - Worker concurrency (e.g. '50%' or 4).
+ * @property {boolean} [silent]        - Suppress console output from tests.
+ * @property {boolean} [watch]         - Run in watch mode.
+ */
+
+/**
+ * Create and execute a Jest test run.
+ *
+ * @param {RunnerOptions} [options={}]
+ * @returns {Promise<import('@jest/core').AggregatedResult>} Jest aggregated results.
+ */
+export default async function createJestRunner(options = {}) {
+  const {
+    projectRoot = process.cwd(),
+    configPath,
+    inlineConfig = {},
+    coverage,
+    testFiles,
+    verbose,
+    maxWorkers,
+    silent,
+    watch = false,
+  } = options;
+
+  // ── 1. Load & merge configuration ──────────────────────────
+  const mergedConfig = await loadConfig({
+    projectRoot,
+    configPath,
+    inlineConfig,
+  });
+
+  // ── 2. Apply CLI-level overrides ───────────────────────────
+  if (coverage !== undefined) mergedConfig.collectCoverage = coverage;
+  if (verbose !== undefined) mergedConfig.verbose = verbose;
+  if (maxWorkers !== undefined) mergedConfig.maxWorkers = maxWorkers;
+  if (silent !== undefined) mergedConfig.silent = silent;
+
+  // ── 3. Resolve reporters ───────────────────────────────────
+  mergedConfig.reporters = resolveReporters(mergedConfig.reporters, projectRoot);
+
+  // ── 4. Build argv for runCLI ───────────────────────────────
+  //    runCLI expects a yargs-like argv object.
+  const argv = buildArgv(mergedConfig, { testFiles, watch, projectRoot });
+
+  // ── 5. Run Jest programmatically ───────────────────────────
+  //    Lazy-import to keep startup fast; @jest/core is heavy.
+  const { runCLI } = await import('@jest/core');
+
+  const { results } = await runCLI(argv, [projectRoot]);
+
+  // ── 6. Return results for the caller to inspect ────────────
+  return results;
+}
+
+/**
+ * Build a yargs-compatible argv object that runCLI understands.
+ *
+ * @param {object} config - Merged Jest config.
+ * @param {object} extra
+ * @param {string[]} [extra.testFiles]
+ * @param {boolean}  [extra.watch]
+ * @param {string}   extra.projectRoot
+ * @returns {object}
+ */
+function buildArgv(config, { testFiles, watch, projectRoot }) {
+  const argv = {
+    // Serialise the config so Jest uses our merged config
+    // instead of searching for jest.config.* files.
+    config: JSON.stringify(config),
+
+    // Project root for resolution
+    rootDir: projectRoot,
+
+    // Flags
+    watch: watch,
+    watchAll: false,
+    ci: process.env.CI === 'true',
+
+    // Pass-through values that CLI users might expect
+    verbose: config.verbose ?? true,
+    collectCoverage: config.collectCoverage ?? false,
+    passWithNoTests: config.passWithNoTests ?? true,
+    maxWorkers: config.maxWorkers ?? '50%',
+    silent: config.silent ?? false,
+
+    // Do not search for config files automatically
+    _: testFiles ?? [],
+    $0: 'unit-testing-framework',
+  };
+
+  return argv;
+}