Skip to content

Modificadores ​

Firmatest.skip(name: string, callback: () => void): void
Firmatest.only(name: string, callback: () => void): void
Firmatest.todo(name: string): void
Firmadescribe.skip(name: string, callback: () => void): void
Firmadescribe.only(name: string, callback: () => void): void

test.skip lista una prueba como omitida sin ejecutarla; su callback aún debe compilar. describe.skip omite todas las pruebas de la suite, y los hooks de la suite no se ejecutan.

test.todo(name) lista una prueba que aún no se ha escrito. Las pruebas omitidas y los todos se cuentan por separado en el resumen.

it acepta los mismos modificadores, al igual que un import con alias, por ejemplo import { test as check } from "tyrus:test". test.concurrent y test.fails aún no están implementados y se informan como errores de compilación.

tyrus
import { describe, it, test, expect } from "tyrus:test";

describe("parser", () => {
    it("runs", () => {
        expect(1).toBe(1);
    });

    test.skip("waits for the new grammar", () => {
        expect(1).toBe(2);
    });

    test.todo("reports unicode columns");
});

describe.skip("legacy format", () => {
    it("is not run", () => {
        expect(1).toBe(2);
    });
});

Enfoque con .only ​

Cuando alguna prueba o suite de un programa está enfocada con .only, solo se ejecutan las pruebas enfocadas y las demás cuentan como omitidas. .skip prevalece sobre .only: enfocar nunca ejecuta una prueba que se omitió a propósito.

tyrus
import { it, expect } from "tyrus:test";

it("is left out while another test is focused", () => {
    expect(1).toBe(1);
});

it.only("is the only test that runs", () => {
    expect(2).toBe(2);
});

Una prueba por caso ​

test.each(name, cases, callback) registra una prueba por caso, con los nombres name [0], name [1], y así sucesivamente. El callback recibe un caso; escrito en línea, el tipo de su parámetro se infiere de los casos. Los casos deben ser un literal de array, porque se despliegan al compilar el programa.

tyrus
import { describe, test, expect } from "tyrus:test";

const clamp = (value: i32, low: i32, high: i32): i32 => {
    if (value < low) {
        return low;
    }
    if (value > high) {
        return high;
    }
    return value;
};

describe("clamp", () => {
    test.each("keeps a value in range", [0, 5, 10], (value: i32) => {
        expect(clamp(value, 0, 10)).toBe(value);
    });
});