@designliquido/delegua/bibliotecas/testes/modulo-testes.js

Linguagem de programação simples e moderna usando português estruturado.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.construirModuloDeTestes = construirModuloDeTestes;
const erro_de_assertiva_1 = require("../../excecoes/erro-de-assertiva");
const funcao_padrao_1 = require("../../interpretador/estruturas/funcao-padrao");
const modulo_1 = require("../../interpretador/estruturas/modulo");
const modulo_afirmar_1 = require("./modulo-afirmar");
function simboloAtual(interpretador) {
    return {
        hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
        linha: interpretador.linhaDeclaracaoAtual,
    };
}
function construirModuloDeTestes(interpretador, registro) {
    const modulo = new modulo_1.DeleguaModulo('testes');
    modulo.componentes['afirmar'] = (0, modulo_afirmar_1.construirModuloAfirmar)();
    async function executarTeste(nome, fn) {
        const inicio = Date.now();
        const emDeclaracaoTenteAnterior = interpretador.emDeclaracaoTente;
        interpretador.emDeclaracaoTente = true;
        for (const escopo of registro.pilhaEscopos) {
            for (const h of escopo.antesDeCada) {
                await h.chamar(interpretador, [], null);
            }
        }
        try {
            await fn.chamar(interpretador, [], null);
            registro.resultados.push({
                nomeSuite: registro.suiteAtual,
                nomeTeste: nome,
                status: 'passou',
                tempoMs: Date.now() - inicio,
            });
        }
        catch (e) {
            registro.resultados.push({
                nomeSuite: registro.suiteAtual,
                nomeTeste: nome,
                status: 'falhou',
                mensagemErro: e.mensagem || e.message || String(e),
                tempoMs: Date.now() - inicio,
            });
        }
        finally {
            for (const escopo of [...registro.pilhaEscopos].reverse()) {
                for (const h of escopo.depoisDeCada) {
                    await h.chamar(interpretador, [], null);
                }
            }
            interpretador.emDeclaracaoTente = emDeclaracaoTenteAnterior;
        }
    }
    async function executarGrupo(nome, fn) {
        const suiteAnterior = registro.suiteAtual;
        registro.suiteAtual = suiteAnterior ? `${suiteAnterior} > ${nome}` : nome;
        const escopo = {
            antesDeCada: [],
            antesDeTodos: [],
            depoisDeCada: [],
            depoisDeTodos: [],
            itensColetados: [],
            temApenas: false,
        };
        registro.pilhaEscopos.push(escopo);
        const modoColetarAnterior = registro.modoColeta;
        registro.modoColeta = true;
        const emDeclaracaoTenteAnterior = interpretador.emDeclaracaoTente;
        interpretador.emDeclaracaoTente = true;
        try {
            await fn.chamar(interpretador, [], null);
            registro.modoColeta = modoColetarAnterior;
            for (const h of escopo.antesDeTodos) {
                await h.chamar(interpretador, [], null);
            }
            for (const item of escopo.itensColetados) {
                if (escopo.temApenas && !item.apenas)
                    continue;
                if (item.pular) {
                    if (item.tipo === 'teste') {
                        registro.resultados.push({
                            nomeSuite: registro.suiteAtual,
                            nomeTeste: item.nome,
                            status: 'pulado',
                            tempoMs: 0,
                        });
                    }
                    continue;
                }
                if (item.tipo === 'teste') {
                    await executarTeste(item.nome, item.fn);
                }
                else {
                    await executarGrupo(item.nome, item.fn);
                }
            }
            for (const h of escopo.depoisDeTodos) {
                await h.chamar(interpretador, [], null);
            }
        }
        finally {
            registro.pilhaEscopos.pop();
            registro.modoColeta = modoColetarAnterior;
            registro.suiteAtual = suiteAnterior;
            interpretador.emDeclaracaoTente = emDeclaracaoTenteAnterior;
        }
    }
    function coletarOuExecutar(tipo, nome, fn, pular, apenas) {
        if (registro.modoColeta && registro.pilhaEscopos.length > 0) {
            const escopoAtual = registro.pilhaEscopos[registro.pilhaEscopos.length - 1];
            if (apenas)
                escopoAtual.temApenas = true;
            escopoAtual.itensColetados.push({ tipo, nome, fn, pular, apenas });
            return Promise.resolve();
        }
        if (pular) {
            if (tipo === 'teste') {
                registro.resultados.push({
                    nomeSuite: registro.suiteAtual,
                    nomeTeste: nome,
                    status: 'pulado',
                    tempoMs: 0,
                });
            }
            return Promise.resolve();
        }
        return tipo === 'teste' ? executarTeste(nome, fn) : executarGrupo(nome, fn);
    }
    const grupoFn = new funcao_padrao_1.FuncaoPadrao(2, async function (_visitante, nomeRaw, funcaoRaw) {
        const nome = interpretador.resolverValor(nomeRaw);
        const fn = interpretador.resolverValor(funcaoRaw);
        return coletarOuExecutar('grupo', nome, fn, false, false);
    });
    grupoFn['pular'] = new funcao_padrao_1.FuncaoPadrao(2, async function (_visitante, nomeRaw, funcaoRaw) {
        const nome = interpretador.resolverValor(nomeRaw);
        const fn = interpretador.resolverValor(funcaoRaw);
        return coletarOuExecutar('grupo', nome, fn, true, false);
    });
    grupoFn['apenas'] = new funcao_padrao_1.FuncaoPadrao(2, async function (_visitante, nomeRaw, funcaoRaw) {
        const nome = interpretador.resolverValor(nomeRaw);
        const fn = interpretador.resolverValor(funcaoRaw);
        return coletarOuExecutar('grupo', nome, fn, false, true);
    });
    modulo.componentes['grupo'] = grupoFn;
    const testeFn = new funcao_padrao_1.FuncaoPadrao(2, async function (_visitante, nomeRaw, funcaoRaw) {
        const nome = interpretador.resolverValor(nomeRaw);
        const fn = interpretador.resolverValor(funcaoRaw);
        return coletarOuExecutar('teste', nome, fn, false, false);
    });
    testeFn['pular'] = new funcao_padrao_1.FuncaoPadrao(2, async function (_visitante, nomeRaw, funcaoRaw) {
        const nome = interpretador.resolverValor(nomeRaw);
        const fn = interpretador.resolverValor(funcaoRaw);
        return coletarOuExecutar('teste', nome, fn, true, false);
    });
    testeFn['apenas'] = new funcao_padrao_1.FuncaoPadrao(2, async function (_visitante, nomeRaw, funcaoRaw) {
        const nome = interpretador.resolverValor(nomeRaw);
        const fn = interpretador.resolverValor(funcaoRaw);
        return coletarOuExecutar('teste', nome, fn, false, true);
    });
    modulo.componentes['teste'] = testeFn;
    function registrarHook(campo) {
        return new funcao_padrao_1.FuncaoPadrao(1, function (_visitante, funcaoRaw) {
            const fn = interpretador.resolverValor(funcaoRaw);
            if (registro.pilhaEscopos.length > 0) {
                registro.pilhaEscopos[registro.pilhaEscopos.length - 1][campo].push(fn);
            }
            return Promise.resolve(null);
        });
    }
    modulo.componentes['antesDeCada'] = registrarHook('antesDeCada');
    modulo.componentes['antesDeTodos'] = registrarHook('antesDeTodos');
    modulo.componentes['depoisDeCada'] = registrarHook('depoisDeCada');
    modulo.componentes['depoisDeTodos'] = registrarHook('depoisDeTodos');
    modulo.componentes['lancarErro'] = new funcao_padrao_1.FuncaoPadrao(1, function (_visitante, mensagemRaw) {
        const mensagem = interpretador.resolverValor(mensagemRaw);
        return Promise.reject(new erro_de_assertiva_1.ErroDeAssertiva(simboloAtual(interpretador), String(mensagem)));
    });
    return modulo;
}
//# sourceMappingURL=modulo-testes.js.map