proby 0.12.0 → 0.13.1

package/README.md

@@ -5,8 +5,10 @@ Test runner for JavaScript runtimes.
 ## What is proby?
 
 A cross-runtime test runner that automatically discovers and runs test files.
-Works with both single repositories and monorepos. Uses `@rcompat/test` for
-writing tests. Works consistently across Node, Deno, and Bun.
+Works with both single repositories and monorepos. Supports TypeScript source
+execution in monorepos without a build step when your packages expose `source`
+entries in `package.json`. Uses `@rcompat/test` for writing tests. Works
+consistently across Node, Deno, and Bun.
 
 ## Installation
 
@@ -42,70 +44,266 @@ Run proby from your project root:
 npx proby
 ```
 
-### Writing tests
+Run a single file:
 
-Create test files with `.spec.ts` or `.spec.js` extension in your `src`
-directory:
+```bash
+npx proby math.spec.ts
+```
 
-```js
-// src/math.spec.ts
-import test from "@rcompat/test";
+Run a single group within a file:
 
-test.case("addition", assert => {
-  assert(1 + 1).equals(2);
-  assert(2 + 2).equals(4);
-});
+```bash
+npx proby math.spec.ts addition
+```
 
-test.case("multiplication", assert => {
-  assert(2 * 3).equals(6);
-  assert(4 * 5).equals(20);
+## How proby resolves source files
+
+Proby relaunches itself with runtime conditions before running tests. By
+default it uses the `source` condition, which lets runtimes resolve package
+`imports` and `exports` to your TypeScript source files instead of built
+JavaScript.
+
+This is especially useful in monorepos where packages depend on each other and
+you want to run tests against source directly.
+
+To use this pattern, expose `source` entries in your packages.
+
+Example:
+
+```json
+{
+  "imports": {
+    "#*": {
+      "source": "./src/*.ts",
+      "default": "./lib/*.js"
+    }
+  },
+  "exports": {
+    ".": {
+      "source": "./src/index.ts",
+      "default": "./lib/index.js"
+    }
+  }
+}
+```
+
+With this setup, proby can run against your TypeScript source without requiring
+an upfront build step.
+
+## Configuration
+
+Create `proby.config.ts` or `proby.config.js` in your project root.
+
+```ts
+import config from "proby/config";
+
+export default config({
+  monorepo: true,
+  packages: "packages",
+  include: ["src"],
+  conditions: ["source"],
 });
 ```
 
-### Test output
+### Config options
 
-Proby displays colored output:
-- Green `o` for passing tests
-- Red `x` for failing tests
+#### `monorepo`
 
+```ts
+boolean
 ```
-oooooxoo
-src/math.spec.ts division
-  expected  5
-  actual    4
+
+Whether proby should scan package directories inside a monorepo.
+
+Default:
+
+```ts
+false
+```
+
+#### `packages`
+
+```ts
+string
+```
+
+Directory containing package folders when `monorepo` is enabled.
+
+Default:
+
+```ts
+"packages"
+```
+
+#### `include`
+
+```ts
+string[]
+```
+
+Directories to scan for spec files.
+
+Default:
+
+```ts
+["src"]
 ```
 
-### Project structure
+#### `conditions`
 
-Proby automatically detects your project structure:
+```ts
+string[]
+```
+
+Runtime conditions used when proby relaunches itself.
+
+Default:
 
-**Single repository:**
+```ts
+["source"]
 ```
+
+## Project structure
+
+Proby automatically detects your project structure.
+
+### Single repository
+
+```text
 my-project/
 ├── src/
 │   ├── utils.ts
-│   ├── utils.spec.ts    # ← Test file
+│   ├── utils.spec.ts
 │   ├── math.ts
-│   └── math.spec.ts     # ← Test file
+│   └── math.spec.ts
 └── package.json
 ```
 
-**Monorepo:**
-```
+### Monorepo
+
+```text
 my-monorepo/
 ├── packages/
 │   ├── core/
 │   │   └── src/
 │   │       ├── index.ts
-│   │       └── index.spec.ts  # ← Test file
+│   │       └── index.spec.ts
 │   └── utils/
 │       └── src/
 │           ├── helpers.ts
-│           └── helpers.spec.ts  # ← Test file
+│           └── helpers.spec.ts
 └── package.json
 ```
 
-### npm scripts
+## Test file conventions
+
+- Files must end with `.spec.ts` or `.spec.js`
+- Files must be in one of the configured include directories
+- Use `@rcompat/test` to write tests
+- Use `test.group` to organize cases into named groups targetable by proby
+
+## Static mock files
+
+Proby supports preloading sibling mock files before a spec file is evaluated.
+This allows module mocks to be registered before the spec's static imports are
+read.
+
+Pair files by matching the spec extension exactly:
+
+- `math.spec.ts` pairs with `math.mock.ts`
+- `math.spec.js` pairs with `math.mock.js`
+
+If a sibling mock file exists, proby loads it before the spec file.
+
+Example:
+
+```ts
+// math.ts
+export function add(a: number, b: number) {
+  return a + b;
+}
+```
+
+```ts
+// math.mock.ts
+import test from "@rcompat/test";
+
+test.mock("./math.ts", () => ({
+  add: (a: number, b: number) => 99,
+}));
+```
+
+```ts
+// math.spec.ts
+import test from "@rcompat/test";
+import { add } from "./math.ts";
+
+test.case("uses the preloaded mock", assert => {
+  assert(add(1, 2)).equals(99);
+});
+```
+
+Static mocks are file-scoped. A mock loaded for one spec file does not leak
+into later spec files.
+
+## Grouping tests
+
+Use `test.group` in your spec files to cluster related cases. Groups can then
+be targeted individually when running proby.
+
+```js
+import test from "@rcompat/test";
+
+test.group("addition", () => {
+  test.case("integers", assert => {
+    assert(1 + 1).equals(2);
+  });
+});
+
+test.group("multiplication", () => {
+  test.case("integers", assert => {
+    assert(2 * 3).equals(6);
+  });
+});
+```
+
+```bash
+npx proby math.spec.ts addition
+```
+
+## Writing tests
+
+Create test files with `.spec.ts` or `.spec.js`:
+
+```js
+import test from "@rcompat/test";
+
+test.case("addition", assert => {
+  assert(1 + 1).equals(2);
+  assert(2 + 2).equals(4);
+});
+
+test.case("multiplication", assert => {
+  assert(2 * 3).equals(6);
+  assert(4 * 5).equals(20);
+});
+```
+
+## Test output
+
+Proby displays colored output:
+
+- Green `o` for passing tests
+- Red `x` for failing tests
+
+```text
+oooooxoo
+src/math.spec.ts division
+  expected  5
+  actual    4
+```
+
+## npm scripts
 
 Add proby to your `package.json`:
 
@@ -123,12 +321,6 @@ Then run:
 npm test
 ```
 
-## Test file conventions
-
-- Files must end with `.spec.ts` or `.spec.js`
-- Files must be in the `src` directory (or `packages/*/src` for monorepos)
-- Use `@rcompat/test` to write tests
-
 ## Examples
 
 ### Basic assertions
@@ -137,17 +329,10 @@ npm test
 import test from "@rcompat/test";
 
 test.case("basic assertions", assert => {
-  // equality
   assert(value).equals(expected);
-
-  // truthiness
   assert(condition).true();
   assert(condition).false();
-
-  // type checking
   assert(value).type<string>();
-
-  // throws
   assert(() => throwingFunction()).throws();
   assert(() => safeFunction()).tries();
 });
@@ -168,7 +353,7 @@ test.case("async operations", async assert => {
 
 ```js
 // src/calculator.ts
-export function add(a: number, b: number) {
+export function add(a, b) {
   return a + b;
 }
 
@@ -186,13 +371,11 @@ test.case("add function", assert => {
 ## Cross-Runtime Compatibility
 
 | Runtime | Supported |
-|---------|-----------|
+| ------- | --------- |
 | Node.js | ✓         |
 | Deno    | ✓         |
 | Bun     | ✓         |
 
-No configuration required — just run `npx proby`.
-
 ## License
 
 MIT

package/lib/Schema.d.ts

@@ -0,0 +1,8 @@
+declare const Schema: import("pema").ObjectType<{
+    monorepo: import("pema").DefaultType<import("pema").BooleanType, false>;
+    packages: import("pema").DefaultType<import("pema").StringType, "packages">;
+    include: import("pema").DefaultType<import("pema").ArrayType<import("pema").StringType>, string[]>;
+    conditions: import("pema").DefaultType<import("pema").ArrayType<import("pema").StringType>, string[]>;
+}>;
+export default Schema;
+//# sourceMappingURL=Schema.d.ts.map

package/lib/Schema.js

@@ -0,0 +1,9 @@
+import p from "pema";
+const Schema = p({
+    monorepo: p.boolean.default(false),
+    packages: p.string.default("packages"),
+    include: p.array(p.string).default(["src"]),
+    conditions: p.array(p.string).default(["source"]),
+});
+export default Schema;
+//# sourceMappingURL=Schema.js.map

package/lib/bin.js

@@ -1,37 +1,51 @@
 #!/usr/bin/env node
-import args from "@rcompat/args";
-import color from "@rcompat/cli/color";
-import print from "@rcompat/cli/print";
+import p from "pema";
+import env from "@rcompat/env";
 import fs from "@rcompat/fs";
-import run from "./run.js";
+import io from "@rcompat/io";
+import is from "@rcompat/is";
+import runtime from "@rcompat/runtime";
+const Schema = p({
+    monorepo: p.boolean.default(false),
+    packages: p.string.default("packages"),
+    include: p.array(p.string).default(["src"]),
+    conditions: p.array(p.string).default(["source"]),
+});
 const root = await fs.project.root();
-const spec_json = root.join("spec.json");
-if (await spec_json.exists()) {
-    //  console.log(`spec.json exists, reading`);
+const ts_config_file = root.join("proby.config.ts");
+const js_config_file = root.join("proby.config.js");
+const user_config = await ts_config_file.exists()
+    ? (await ts_config_file.import("default"))
+    : await js_config_file.exists()
+        ? (await js_config_file.import("default"))
+        : {};
+const { include, packages, conditions, monorepo } = Schema.parse(user_config);
+const conditions_flag = conditions.length > 0
+    ? ` --conditions=${conditions.join(",")}`
+    : "";
+const script = runtime.script;
+const args = runtime.args.join(" ");
+if (!is.defined(env.try("PROBY_RELAUNCHED"))) {
+    await io.spawn(`${runtime.bin} ${conditions_flag} ${script} ${args}`, {
+        inherit: true,
+        env: { ...process.env, PROBY_RELAUNCHED: "1" },
+    });
+    runtime.exit(0);
 }
-else {
-    //  console.log(`spec.json missing, continuing with defaults`);
-}
-const [file] = args;
-const type = await (async (base) => {
-    if (await base.join("packages").exists()) {
-        return "monorepo";
-    }
-    if (await base.join("src").exists()) {
-        return "repo";
-    }
-})(root);
-if (type === "monorepo") {
-    for (const repo of await root.join("packages").list({
+import run from "#run";
+const [file, group] = runtime.args;
+if (monorepo) {
+    for (const repo of await root.join(packages).list({
         filter: info => info.kind === "directory",
     })) {
-        await run(repo.join("src"), repo.name, file);
+        for (const dir of include) {
+            await run(repo.join(dir), repo.name, file, group);
+        }
     }
 }
-else if (type === "repo") {
-    await run(root.join("src"), undefined, file);
-}
 else {
-    print(`${color.red("src")} or ${color.red("packages")} not found\n`);
+    for (const dir of include) {
+        await run(root.join(dir), undefined, file, group);
+    }
 }
 //# sourceMappingURL=bin.js.map

package/lib/config.d.ts

@@ -0,0 +1,9 @@
+import type Schema from "#Schema";
+declare const _default: (input: typeof Schema.input) => {
+    monorepo?: boolean | undefined;
+    packages?: string | undefined;
+    include?: string[] | undefined;
+    conditions?: string[] | undefined;
+} | undefined;
+export default _default;
+//# sourceMappingURL=config.d.ts.map

package/lib/config.js

@@ -0,0 +1,2 @@
+export default (input) => input;
+//# sourceMappingURL=config.js.map

package/lib/fixtures/static-mock/math.d.ts

@@ -0,0 +1,2 @@
+export declare function add(a: number, b: number): number;
+//# sourceMappingURL=math.d.ts.map

package/lib/fixtures/static-mock/math.js

@@ -0,0 +1,4 @@
+export function add(a, b) {
+    return a + b;
+}
+//# sourceMappingURL=math.js.map

package/lib/fixtures/static-mock/math.mock.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=math.mock.d.ts.map

package/lib/fixtures/static-mock/math.mock.js

@@ -0,0 +1,5 @@
+import test from "@rcompat/test";
+test.mock("#fixtures/static-mock/math", () => ({
+    add: (a, b) => 99,
+}));
+//# sourceMappingURL=math.mock.js.map

package/lib/run.d.ts

@@ -1,4 +1,4 @@
 import type { FileRef } from "@rcompat/fs";
-declare const _default: (root: FileRef, subrepo?: string, target?: string) => Promise<void>;
+declare const _default: (root: FileRef, subrepo?: string, target?: string, group?: string) => Promise<void>;
 export default _default;
 //# sourceMappingURL=run.d.ts.map

package/lib/run.js

@@ -44,7 +44,8 @@ async function run_in_worker(spec, env) {
     });
     const context = await env_module.setup?.();
     return new Promise((resolve, reject) => {
-        const worker = new Worker(new URL("./worker.js", import.meta.url), {
+        const worker_url = new URL(import.meta.url.endsWith(".ts") ? "./worker.ts" : "./worker.js", import.meta.url);
+        const worker = new Worker(worker_url, {
             workerData: {
                 spec: spec.path,
                 env: env.path,
@@ -72,7 +73,7 @@ async function run_in_worker(spec, env) {
         });
     });
 }
-export default async (root, subrepo, target) => {
+export default async (root, subrepo, target, group) => {
     const files = await root.list({
         recursive: true,
         filter: info => extensions.some(extension => info.path.endsWith(extension)),
@@ -89,33 +90,41 @@ export default async (root, subrepo, target) => {
             await run_in_worker(file, env_file);
             continue;
         }
+        const mock_file = await file.sibling(file.name.replace(/\.spec\.(ts|js)$/, ".mock.$1")).or(() => null);
         repository.suite(file);
-        await file.import();
-    }
-    for (const suite of repository.next()) {
-        const failed = [];
-        for await (const test of suite.run()) {
-            for (const result of test.results) {
-                if (result.passed) {
-                    print(color.green("o"));
+        const suite = repository.next().next().value;
+        try {
+            if (mock_file !== null)
+                await mock_file.import();
+            await file.import();
+            const failed = [];
+            for await (const test of suite.run()) {
+                if (group !== undefined && test.group !== group)
+                    continue;
+                for (const result of test.results) {
+                    if (result.passed) {
+                        print(color.green("o"));
+                    }
+                    else {
+                        failed.push([test, result]);
+                        print(color.red("x"));
+                    }
                 }
-                else {
-                    failed.push([test, result]);
-                    print(color.red("x"));
+            }
+            await suite.end();
+            if (failed.length > 0) {
+                print("\n");
+                for (const [test, result] of failed) {
+                    print(`${suite.file.debase(root)} ${color.red(test.name)} \n`);
+                    print(`  expected  ${stringify(result.expected)}\n`);
+                    print(`  actual    ${stringify(result.actual)}\n`);
                 }
             }
         }
-        await suite.end();
-        if (failed.length > 0) {
-            print("\n");
-            for (const [test, result] of failed) {
-                print(`${suite.file.debase(root)} ${color.red(test.name)} \n`);
-                print(`  expected  ${stringify(result.expected)}\n`);
-                print(`  actual    ${stringify(result.actual)}\n`);
-            }
+        finally {
+            repository.reset();
         }
     }
     print("\n");
-    repository.reset();
 };
 //# sourceMappingURL=run.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "proby",
-  "version": "0.12.0",
+  "version": "0.13.1",
   "description": "Standard library test runner",
   "bugs": "https://github.com/rcompat/rcompat/issues",
   "license": "MIT",
@@ -16,13 +16,17 @@
     "directory": "packages/proby"
   },
   "dependencies": {
-    "@rcompat/args": "^0.12.0",
-    "@rcompat/cli": "^0.17.0",
-    "@rcompat/fs": "^0.27.1",
-    "@rcompat/assert": "^0.7.0"
+    "pema": "^0.5.0",
+    "@rcompat/assert": "^0.8.0",
+    "@rcompat/cli": "^0.18.0",
+    "@rcompat/env": "^0.17.0",
+    "@rcompat/fs": "^0.28.0",
+    "@rcompat/io": "^0.5.0",
+    "@rcompat/is": "^0.6.0",
+    "@rcompat/runtime": "^0.11.0"
   },
   "peerDependencies": {
-    "@rcompat/test": "^0.11.2"
+    "@rcompat/test": "^0.12.0"
   },
   "peerDependenciesMeta": {
     "@rcompat/test": {
@@ -32,10 +36,16 @@
   "type": "module",
   "imports": {
     "#*": {
-      "apekit": "./src/*.ts",
+      "source": "./src/*.ts",
       "default": "./lib/*.js"
     }
   },
+  "exports": {
+    "./config": {
+      "source": "./src/config.ts",
+      "default": "./lib/config.js"
+    }
+  },
   "scripts": {
     "build": "npm run clean && tsc",
     "clean": "rm -rf ./lib",