@probitas/probitas

import { assertThrows } from "@std/assert";
import { alter } from "@core/errorutil/alter";

console.log(alter(() => 1, "err2")); // 1
assertThrows(() => alter(() => { throw "err1" }, "err2"), "err2"); // "err2" is thrown

import { assertThrows } from "@std/assert";
import { alterElse } from "@core/errorutil/alter-else";

console.log(alterElse(() => 1, () => "err")); // 1
assertThrows(() => alterElse(() => { throw "err" }, (err) => "new " + err), "new err"); // "new err" is thrown

Usage

import { assertSpyCall, spy } from "@std/testing/mock";

const func = spy((a: number, b: number) => a + b);

func(3, 4);
func(5, 6);

// asserts each call made to the spy function.
assertSpyCall(func, 0, { args: [3, 4], returned: 7 });
assertSpyCall(func, 1, { args: [5, 6], returned: 11 });

Usage

import { assertSpyCallArg, spy } from "@std/testing/mock";

const func = spy((a: number, b: number) => a + b);

func(3, 4);
func(5, 6);

// asserts each call made to the spy function.
assertSpyCallArg(func, 0, 0, 3);
assertSpyCallArg(func, 0, 1, 4);
assertSpyCallArg(func, 1, 0, 5);
assertSpyCallArg(func, 1, 1, 6);

Usage

import { assertSpyCallArgs, spy } from "@std/testing/mock";

const func = spy((a: number, b: number) => a + b);

func(3, 4);
func(5, 6);

// asserts each call made to the spy function.
assertSpyCallArgs(func, 0, [3, 4]);
assertSpyCallArgs(func, 1, [5, 6]);

Usage

import { assertSpyCallAsync, spy } from "@std/testing/mock";

const func = spy((a: number, b: number) => new Promise((resolve) => {
  setTimeout(() => resolve(a + b), 100)
}));

await func(3, 4);
await func(5, 6);

// asserts each call made to the spy function.
await assertSpyCallAsync(func, 0, { args: [3, 4], returned: 7 });
await assertSpyCallAsync(func, 1, { args: [5, 6], returned: 11 });

Usage

import { assertSpyCalls, spy } from "@std/testing/mock";

const func = spy();

func();
func();

assertSpyCalls(func, 2);

import { attempt } from "@core/errorutil/attempt";

console.log(attempt(() => 1)); // [undefined, 1]
console.log(attempt(() => { throw "err" })); // ["err", undefined]

import { expect } from "./expect.ts";

// Falls back to expectAnything (chainable @std/expect) for other values
expect(42).toBe(42).toBeGreaterThan(40);
expect("hello world").toContain("world");
expect({ a: 1, b: 2 }).toMatchObject({ a: 1 });

Usage

import { mockSession, restore, stub } from "@std/testing/mock";
import { assertEquals, assertNotEquals } from "@std/assert";

const setTimeout = globalThis.setTimeout;
const id = mockSession();

stub(globalThis, "setTimeout");

assertNotEquals(globalThis.setTimeout, setTimeout);

restore(id);

assertEquals(globalThis.setTimeout, setTimeout);

Usage

import { mockSessionAsync, restore, stub } from "@std/testing/mock";
import { assertEquals, assertNotEquals } from "@std/assert";

const setTimeout = globalThis.setTimeout;
const session = mockSessionAsync(async () => {
  stub(globalThis, "setTimeout");
  assertNotEquals(globalThis.setTimeout, setTimeout);
});

await session();

assertEquals(globalThis.setTimeout, setTimeout); // stub is restored

Usage

import { resolvesNext } from "@std/testing/mock";
import { assertEquals, assertRejects } from "@std/assert";

const func = resolvesNext([1, 2, new Error("foo"), 3]);
assertEquals(await func(), 1);
assertEquals(await func(), 2);
assertRejects(() => func(), Error, "foo");
assertEquals(await func(), 3);

Usage

import { mockSession, restore, stub } from "@std/testing/mock";
import { assertEquals, assertNotEquals } from "@std/assert";

const setTimeout = globalThis.setTimeout;

stub(globalThis, "setTimeout");

assertNotEquals(globalThis.setTimeout, setTimeout);

restore();

assertEquals(globalThis.setTimeout, setTimeout);

Usage

import { returnsArg } from "@std/testing/mock";
import { assertEquals } from "@std/assert";

const func = returnsArg(1);
assertEquals(func(1, 2, 3), 2);

Usage

import { returnsArgs } from "@std/testing/mock";
import { assertEquals } from "@std/assert";

const func = returnsArgs();
assertEquals(func(1, 2, 3), [1, 2, 3]);

Usage

import { returnsNext } from "@std/testing/mock";
import { assertEquals, assertThrows } from "@std/assert";

const func = returnsNext([1, 2, new Error("foo"), 3]);
assertEquals(func(), 1);
assertEquals(func(), 2);
assertThrows(() => func(), Error, "foo");
assertEquals(func(), 3);

Usage

import { returnsThis } from "@std/testing/mock";
import { assertEquals } from "@std/assert";

const func = returnsThis();
const obj = { func };
assertEquals(obj.func(), obj);

Basic scenario with type-safe step chaining

import { scenario } from "@probitas/builder";

// Mock user service for example
const createUser = (_data: { email: string }) =>
  Promise.resolve({ id: "user-123" });
const verifyEmail = (_userId: string) => Promise.resolve();

export default scenario("User Registration")
  .step("Create user", async () => {
    const user = await createUser({ email: "test@example.com" });
    return { userId: user.id };
  })
  .step("Verify email", async (ctx) => {
    // ctx.previous is typed as { userId: string }
    await verifyEmail(ctx.previous.userId);
  })
  .build();

Scenario with tags for filtering

import { scenario } from "@probitas/builder";

scenario("Payment Integration", {
  tags: ["integration", "payment", "slow"],
  stepOptions: { timeout: 60000 }  // 1 minute timeout for all steps
})
  .step("Process payment", async () => {
    return { success: true };
  })
  .build();

// Run with: probitas run -s "tag:payment"

Scenario with resources and setup

import { scenario } from "@probitas/builder";

// Mock Database for example
const Database = {
  connect: () =>
    Promise.resolve({
      rollback: () => {},
      insert: (_data: { id: number }) => {},
      query: (_sql: string) => [{ id: 1 }],
    }),
};

scenario("Database Test")
  .resource("db", async () => await Database.connect())
  .setup((ctx) => {
    // Run migrations
    return () => ctx.resources.db.rollback();
  })
  .step("Insert data", (ctx) => ctx.resources.db.insert({ id: 1 }))
  .step("Query data", (ctx) => ctx.resources.db.query("SELECT * FROM users"))
  .build();

Usage

import {
  assertSpyCall,
  assertSpyCalls,
  spy,
} from "@std/testing/mock";

const func = spy();

func();
func(1);
func(2, 3);

assertSpyCalls(func, 3);

// asserts each call made to the spy function.
assertSpyCall(func, 0, { args: [] });
assertSpyCall(func, 1, { args: [1] });
assertSpyCall(func, 2, { args: [2, 3] });

Usage

import { stub, assertSpyCalls } from "@std/testing/mock";

const obj = {
  method() {
    // some inconventient feature for testing
  },
};

const methodStub = stub(obj, "method");

for (const _ of Array(5)) {
  obj.method();
}

assertSpyCalls(methodStub, 5);