@designliquido/foles/testes/modificadores/valor-numerico.test.js

Linguagem de folhas de estilo para documentos em geral em português

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const avaliador_sintatico_1 = require("../../fontes/avaliador-sintatico");
const importador_1 = require("../../fontes/importador");
const lexador_1 = require("../../fontes/lexador");
const superclasse_1 = require("../../fontes/modificadores/superclasse");
const foles_1 = __importDefault(require("../../fontes/tipos-de-simbolos/foles"));
const serializadores_1 = require("../../fontes/serializadores");
const valor_numerico_1 = require("../listas/valor-numerico");
const declaracoes_1 = require("../../fontes/declaracoes");
describe('Testando Seletores que recebem VALOR NUMÉRICO sem quantificador', () => {
    describe('Testes Unitários', () => {
        let lexador;
        let importador;
        let avaliador;
        let tradutor;
        beforeEach(() => {
            lexador = new lexador_1.Lexador();
            importador = new importador_1.Importador(lexador);
            avaliador = new avaliador_sintatico_1.AvaliadorSintatico(importador);
            tradutor = new serializadores_1.Serializador();
        });
        it('Casos de sucesso - Lexador, Avaliador e Tradutor', () => {
            for (let index = 0; index < valor_numerico_1.ValorNumerico.length; index += 1) {
                const seletor = new superclasse_1.SeletorModificador(valor_numerico_1.ValorNumerico[index], '1');
                // Lexador
                const resultadoLexador = lexador.mapear([
                    "corpo {",
                    `${valor_numerico_1.ValorNumerico[index]}: ${seletor['valor']};`,
                    "}"
                ]);
                expect(resultadoLexador.simbolos).toHaveLength(7);
                expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
                    expect.objectContaining({ tipo: foles_1.default.NUMERO }),
                ]));
                // Avaliador Sintático
                const resultadoAvaliadorSintatico = avaliador.analisar(resultadoLexador.simbolos);
                // O Avaliador deve montar um objeto com os devidos nomes FolEs e CSS
                expect(resultadoAvaliadorSintatico.length).toBeGreaterThanOrEqual(1);
                const primeiroResultado = resultadoAvaliadorSintatico[0];
                expect(primeiroResultado).toBeInstanceOf(declaracoes_1.BlocoDeclaracao);
                const primeiroResultadoTipado = primeiroResultado;
                expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
                expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(seletor['nomeFoles']);
                expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(seletor['propriedadeCss']);
                // Tradutor
                const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
                expect(resultadoTradutor).toContain(seletor['propriedadeCss']);
            }
        });
        it('Casos de Falha - Lexador, Avaliador e Tradutor', () => {
            for (let index = 0; index < Object.keys(valor_numerico_1.ValorNumericoApenas).length; index += 1) {
                // Lexador - valor numérico não informado
                const resultadoLexador = lexador.mapear([
                    "lmht {",
                    `${valor_numerico_1.ValorNumericoApenas[index]}: ;`,
                    "}"
                ]);
                expect(resultadoLexador.simbolos).not.toEqual(expect.arrayContaining([
                    expect.objectContaining({ tipo: foles_1.default.NUMERO }),
                ]));
                // Tentando passar um quantificador para os modificadores (o que não deve ser permitido)
                const novoLexador = lexador.mapear([
                    "lmht {",
                    `${valor_numerico_1.ValorNumericoApenas[index]}: 15px;`,
                    "}"
                ]);
                // Avaliador Sintático - Erro esperado como retorno
                const regex = /[~çáéíóúÁÉÍÓÚ]/;
                if (!regex.test(valor_numerico_1.ValorNumericoApenas[index]) && regex.test(valor_numerico_1.ValorNumericoApenas[index + 1])) {
                    expect(() => {
                        avaliador.analisar(novoLexador.simbolos);
                    }).toThrow(`A propriedade '${valor_numerico_1.ValorNumericoApenas[index + 1]}' aceita somente valores numéricos. O quantificador 'px' é inválido para esta operação.`);
                }
                else {
                    expect(() => {
                        avaliador.analisar(novoLexador.simbolos);
                    }).toThrow(`A propriedade '${valor_numerico_1.ValorNumericoApenas[index]}' aceita somente valores numéricos. O quantificador 'px' é inválido para esta operação.`);
                }
                // Tradutor - Não deve traduzir devido ao erro do Avaliador Sintático
                expect(() => {
                    tradutor.serializar(avaliador.analisar(novoLexador.simbolos));
                }).toHaveLength(0);
            }
        });
        it('Casos de falha - Modificadores que só aceitam zero ou um como valor numérico', () => {
            for (let index = 0; index < valor_numerico_1.ValorNumericoZeroUm.length; index += 1) {
                // Lexador
                const resultadoLexador = lexador.mapear([
                    "corpo {",
                    `${valor_numerico_1.ValorNumericoZeroUm[index]}: 2;`,
                    "}"
                ]);
                expect(() => {
                    avaliador.analisar(resultadoLexador.simbolos);
                }).toThrowError(`Propriedade '${valor_numerico_1.ValorNumericoZeroUm[index]}' com valor 2 inválido. O valor deve estar entre 0 e 1 ou ser um dos valores:`);
            }
        });
        it('Caso de Sucesso - Valor numérico atribuído por meio de variável', () => {
            for (let index = 0; index < valor_numerico_1.ValorNumerico.length; index += 1) {
                const seletor = new superclasse_1.SeletorModificador(valor_numerico_1.ValorNumerico[index], '1');
                // Lexador
                const resultadoLexador = lexador.mapear([
                    `$numero-padrao: 1;`,
                    "lmht {",
                    `${valor_numerico_1.ValorNumerico[index]}: $numero-padrao;`,
                    "}"
                ]);
                // O Lexador deve montar o objeto de acordo, sem retornar erros.
                expect(resultadoLexador.simbolos).toHaveLength(13);
                expect(resultadoLexador.erros).toHaveLength(0);
                // O mapeamento deve conter o tipo variável
                expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
                    expect.objectContaining({ tipo: foles_1.default.VARIAVEL }),
                ]));
                // Avaliador Sintático
                const resultadoAvaliadorSintatico = avaliador.analisar(resultadoLexador.simbolos);
                // O Avaliador deve montar um objeto com os devidos nomes FolEs e CSS
                expect(resultadoAvaliadorSintatico.length).toBeGreaterThanOrEqual(1);
                // O primeiro item do mapeamento deve ser a declaração da variável
                const primeiroResultado = resultadoAvaliadorSintatico[0];
                expect(primeiroResultado).toBeInstanceOf(declaracoes_1.DeclaracaoVariavel);
                // O segundo item do mapeamento deve conter as devidas traduções
                const segundoResultado = resultadoAvaliadorSintatico[1];
                const segundoResultadoTipado = segundoResultado;
                expect(segundoResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
                expect(segundoResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(seletor['nomeFoles']);
                expect(segundoResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(seletor['propriedadeCss']);
                // Tradutor
                const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
                expect(resultadoTradutor).toContain(seletor['propriedadeCss']);
                expect(resultadoTradutor).toContain('1');
            }
        });
    });
});
describe('Testando Seletores que recebem VALOR NUMÉRICO com ou sem quantificador', () => {
    describe('Testes Unitários', () => {
        let lexador;
        let importador;
        let avaliador;
        let tradutor;
        beforeEach(() => {
            lexador = new lexador_1.Lexador();
            importador = new importador_1.Importador(lexador);
            avaliador = new avaliador_sintatico_1.AvaliadorSintatico(importador);
            tradutor = new serializadores_1.Serializador();
        });
        it('Casos de sucesso - valor numérico apenas - Lexador, Avaliador e Tradutor', () => {
            for (let index = 0; index < valor_numerico_1.ValorNumericoComQuantificador.length; index += 1) {
                const seletor = new superclasse_1.SeletorModificador(valor_numerico_1.ValorNumericoComQuantificador[index], '1');
                // Lexador
                const resultadoLexador = lexador.mapear([
                    "corpo {",
                    `${valor_numerico_1.ValorNumericoComQuantificador[index]}: ${seletor['valor']};`,
                    "}"
                ]);
                expect(resultadoLexador.simbolos).toHaveLength(7);
                expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
                    expect.objectContaining({ tipo: foles_1.default.NUMERO }),
                ]));
                // Avaliador Sintático                
                const resultadoAvaliadorSintatico = avaliador.analisar(resultadoLexador.simbolos);
                expect(resultadoAvaliadorSintatico.length).toBeGreaterThanOrEqual(1);
                const primeiroResultado = resultadoAvaliadorSintatico[0];
                expect(primeiroResultado).toBeInstanceOf(declaracoes_1.BlocoDeclaracao);
                const primeiroResultadoTipado = primeiroResultado;
                expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
                expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(seletor['nomeFoles']);
                expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(seletor['propriedadeCss']);
                // Tradutor
                const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
                expect(resultadoTradutor).toContain(seletor['propriedadeCss']);
            }
        });
        it('Casos de Sucesso - valor numérico com quantificador - Lexador, Avaliador e Tradutor', () => {
            for (let index = 0; index < valor_numerico_1.ValorNumericoComQuantificador.length; index += 1) {
                const excecoes = ['fatiar-imagem-borda', 'opacidade'];
                let seletor;
                if (excecoes.includes(valor_numerico_1.ValorNumericoComQuantificador[index])) {
                    seletor = new superclasse_1.SeletorModificador(valor_numerico_1.ValorNumericoComQuantificador[index], '15', '%');
                }
                else {
                    seletor = new superclasse_1.SeletorModificador(valor_numerico_1.ValorNumericoComQuantificador[index], '15', 'px');
                }
                // Lexador
                const resultadoLexador = lexador.mapear([
                    "corpo {",
                    `${valor_numerico_1.ValorNumericoComQuantificador[index]}: ${seletor['valor']}${seletor['quantificador']};`,
                    "}"
                ]);
                expect(resultadoLexador.simbolos).toHaveLength(8);
                expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
                    expect.objectContaining({ tipo: foles_1.default.NUMERO }),
                    expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
                ]));
                // Avaliador Sintático                
                const resultadoAvaliadorSintatico = avaliador.analisar(resultadoLexador.simbolos);
                expect(resultadoAvaliadorSintatico.length).toBeGreaterThanOrEqual(1);
                const primeiroResultado = resultadoAvaliadorSintatico[0];
                expect(primeiroResultado).toBeInstanceOf(declaracoes_1.BlocoDeclaracao);
                const primeiroResultadoTipado = primeiroResultado;
                expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
                expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(seletor['nomeFoles']);
                expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(seletor['propriedadeCss']);
                // Tradutor
                const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
                expect(resultadoTradutor).toContain(seletor['propriedadeCss']);
            }
        });
        it('Casos de Falha - valor numérico com quantificador - Lexador, Avaliador e Tradutor', () => {
            for (let index = 0; index < valor_numerico_1.ValorNumericoComQuantificador.length; index += 1) {
                // Lexador
                const resultadoLexador = lexador.mapear([
                    "lmht {",
                    `${valor_numerico_1.ValorNumericoComQuantificador[index]}: ;`,
                    "}"
                ]);
                expect(resultadoLexador.simbolos).not.toEqual(expect.arrayContaining([
                    expect.objectContaining({ tipo: foles_1.default.NUMERO }),
                    expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
                ]));
                // Causar erro de digitação
                const seletorIncorreto = valor_numerico_1.ValorNumericoComQuantificador[index].replace(valor_numerico_1.ValorNumericoComQuantificador[index][0], '');
                const novoLexador = lexador.mapear([
                    "lmht {",
                    `${seletorIncorreto}: 1.5;`,
                    "}"
                ]);
                // Avaliador Sintático - Erro esperado como retorno
                expect(() => {
                    avaliador.analisar(novoLexador.simbolos);
                }).toThrow(`O seletor '${seletorIncorreto}' não existe.`);
                // // Tradutor - Não deve traduzir devido ao erro do Avaliador Sintático
                expect(() => {
                    tradutor.serializar(avaliador.analisar(novoLexador.simbolos));
                }).toHaveLength(0);
            }
        });
    });
});
//# sourceMappingURL=valor-numerico.test.js.map