Configuration and Global Control

/**
 * Configure global test runner settings
 * @param options - Configuration options
 */
function configure(options: ConfigurationOptions): void;

interface ConfigurationOptions {
  /** Default timeout for all tests in milliseconds (default: 30000) */
  timeout?: number;
  /** Exit on first test failure (default: false) */
  bail?: boolean;
  /** Enable solo mode globally (default: false) */
  solo?: boolean;
  /** Show error source information (default: true) */
  source?: boolean;
  /** Show assertions even if stealth is used (default: false) */
  unstealth?: boolean;
  /** Enable coverage reporting (default: false) */
  coverage?: boolean | string;
}

import { configure, test } from "brittle";

// Basic configuration
configure({
  timeout: 10000,  // 10 second default timeout
  bail: true,      // Exit on first failure
  source: true     // Show error source info
});

// Coverage configuration
configure({
  coverage: true           // Enable coverage with default directory
});

configure({
  coverage: "./coverage"   // Enable coverage with custom directory
});

// Development configuration
configure({
  solo: true,      // Enable solo mode globally
  unstealth: true, // Show all assertions even in stealth mode
  source: true     // Enhanced error information
});

/**
 * Pause test execution (new tests will wait)
 */
function pause(): void;

/**
 * Resume test execution
 */
function resume(): void;

import { pause, resume, test } from "brittle";

test("first test", (t) => {
  t.pass("this runs immediately");
});

// Pause execution
pause();

test("second test", (t) => {
  t.pass("this waits until resumed");
});

test("third test", (t) => {
  t.pass("this also waits");
});

// Resume after some condition
setTimeout(() => {
  console.log("Resuming tests...");
  resume();
}, 1000);

import { configure, test } from "brittle";

// ✅ Correct - configure before tests
configure({ timeout: 5000, bail: true });

test("my test", (t) => {
  t.pass("configured correctly");
});

// ❌ Error - too late to configure
// configure({ timeout: 10000 }); // Throws error

configure({ timeout: 5000 }); // 5 second default

// Main tests get default timeout unless overridden
test("main test", (t) => {
  // Has 5 second timeout
  t.pass("main test");
});

// Override default timeout
test("custom timeout", { timeout: 10000 }, (t) => {
  // Has 10 second timeout
  t.pass("custom timeout");
});

// Subtests don't get default timeout unless specified
test("parent test", (t) => {
  t.test("subtest", (st) => {
    // No automatic timeout - runs indefinitely unless parent times out
    st.pass("subtest");
  });
  
  t.test("subtest with timeout", { timeout: 2000 }, (st) => {
    // Has 2 second timeout
    st.pass("timed subtest");
  });
});

configure({ bail: true });

test("first test", (t) => {
  t.pass("this passes");
});

test("failing test", (t) => {
  t.fail("this fails and stops execution");
});

test("never runs", (t) => {
  t.pass("this never executes");
});

// Method 1: Global configuration
configure({ solo: true });

test("regular test", (t) => {
  t.pass("runs in global solo mode");
});

// Method 2: Individual solo tests
import { solo } from "brittle";

solo("focused test", (t) => {
  t.pass("only this runs");
});

test("skipped test", (t) => {
  t.pass("this is skipped");
});

// Method 3: Runtime solo activation
import { solo } from "brittle";

solo(); // Activate solo mode

test("now solo", (t) => {
  t.pass("becomes solo after activation");
});

// Enable basic coverage
configure({ coverage: true });

// Custom coverage directory
configure({ coverage: "./my-coverage" });

// Coverage with other options
configure({
  coverage: "./coverage",
  timeout: 10000,
  bail: false
});

// Enable detailed source info (default)
configure({ source: true });

test("with source", (t) => {
  t.is(1, 2, "this will show file:line info in error");
});

// Disable source info for cleaner output
configure({ source: false });

test("without source", (t) => {
  t.is(1, 2, "this won't show source location");
});

import { stealth } from "brittle";

// Normal behavior - stealth tests hide assertions
stealth("quiet test", (t) => {
  t.pass("hidden assertion");
  t.is(1, 1, "also hidden");
});

// Override stealth mode globally
configure({ unstealth: true });

stealth("no longer quiet", (t) => {
  t.pass("now visible assertion");
  t.is(1, 1, "also now visible");
});

// config.js
import { configure } from "brittle";

configure({
  timeout: 10000,
  bail: false,
  source: true,
  coverage: process.env.COVERAGE ? "./coverage" : false
});

// test.js
import "./config.js"; // Load config first
import test from "brittle";

test("my test", (t) => {
  // Uses configured settings
});

import { configure } from "brittle";

configure({
  timeout: process.env.CI ? 30000 : 10000,
  bail: process.env.CI ? true : false,
  coverage: process.env.COVERAGE || false,
  source: process.env.NODE_ENV !== "production"
});

import { configure } from "brittle";

const config = {
  timeout: 10000,
  source: true
};

if (process.env.DEBUG) {
  config.unstealth = true;
}

if (process.env.FAST_FAIL) {
  config.bail = true;
}

configure(config);