@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]

// HTTP response
const httpRes = await http.get("/users");
expect(httpRes).toBeSuccessful().toHaveContentContaining({ users: [] });

// GraphQL response
const gqlRes = await graphql.query("{ users { id name } }");
expect(gqlRes).toBeSuccessful().toHaveContent();

// SQL query result
const sqlRes = await db.query("SELECT * FROM users");
expect(sqlRes).toBeSuccessful().toHaveCount(10);

// MongoDB result
const mongoRes = await mongo.find({ status: "active" });
expect(mongoRes).toBeSuccessful().toHaveLength(10);

// Falls back to expectAnything (chainable @std/expect) for other values
expect(42).toBe(42).toBeGreaterThan(40);

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";

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

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

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

Scenario with resources and setup

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(...))
  .step("Query data", (ctx) => ctx.resources.db.query(...))
  .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);