Skip to content

Modificadores ​

Assinaturatest.skip(name: string, callback: () => void): void
Assinaturatest.only(name: string, callback: () => void): void
Assinaturatest.todo(name: string): void
Assinaturadescribe.skip(name: string, callback: () => void): void
Assinaturadescribe.only(name: string, callback: () => void): void

test.skip lista um teste como ignorado sem executá-lo; o seu callback ainda precisa compilar. describe.skip ignora todos os testes da suíte, e os hooks da suíte não executam.

test.todo(name) lista um teste que ainda não foi escrito. Testes ignorados e todos são contados separadamente no resumo.

it aceita os mesmos modificadores, assim como um import com alias, por exemplo import { test as check } from "tyrus:test". test.concurrent e test.fails ainda não estão implementados e são reportados como erros de compilação.

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);
    });
});

Foco com .only ​

Quando algum teste ou suíte de um programa está focado com .only, só os testes focados executam e os demais contam como ignorados. .skip prevalece sobre .only: focar nunca executa um teste que foi ignorado de 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);
});

Um teste por caso ​

test.each(name, cases, callback) registra um teste por caso, com os nomes name [0], name [1] e assim por diante. O callback recebe um caso; escrito inline, o tipo do parâmetro é inferido a partir dos casos. Os casos precisam ser um literal de array, porque são desdobrados quando o programa é compilado.

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);
    });
});