@designliquido/foles/testes/modificadores/cores.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 cores_1 = require("../listas/cores");
const declaracoes_1 = require("../../fontes/declaracoes");
const cores_2 = require("../../fontes/modificadores/atributos/cores");
describe('Testando Seletores que recebem COR como atributo', () => {
    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('Caso de Sucesso - Cor válida', () => {
            for (let index = 0; index < cores_1.Cores.length; index += 1) {
                const seletor = new superclasse_1.SeletorModificador(cores_1.Cores[index], 'castanho');
                // Lexador
                const resultadoLexador = lexador.mapear([
                    "lmht {",
                    `${cores_1.Cores[index]}: ${seletor['valor']};`,
                    "}"
                ]);
                expect(resultadoLexador.simbolos).toHaveLength(7);
                expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
                    expect.objectContaining({ tipo: foles_1.default.QUALITATIVO }),
                ]));
                // 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']);
                expect(resultadoTradutor).toContain("brown;");
            }
        });
        it('Caso de Sucesso - Código #HEX', () => {
            for (let index = 0; index < cores_1.Cores.length; index += 1) {
                // Lexador
                const resultadoLexador = lexador.mapear([
                    "lmht {",
                    `${cores_1.Cores[index]}: #f015ca;`,
                    "}"
                ]);
                expect(resultadoLexador.simbolos).toHaveLength(8);
                expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
                    expect.objectContaining({ tipo: foles_1.default.METODO }),
                ]));
                // 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].propriedadeCss).toStrictEqual(cores_1.CoresNomeFolEs[cores_1.Cores[index]]);
                // Tradutor
                const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
                expect(resultadoTradutor).toContain(cores_1.CoresNomeFolEs[cores_1.Cores[index]]);
                expect(resultadoTradutor).toContain("#f015ca;");
            }
        });
        it('Caso de Sucesso - Valor RGB válido', () => {
            for (let index = 0; index < cores_1.Cores.length; index += 1) {
                // Lexador
                const resultadoLexador = lexador.mapear([
                    "lmht {",
                    `${cores_1.Cores[index]}: rgb(34, 12, 64);`,
                    "}"
                ]);
                // O objeto terá length 14 pois cada parâmetro é identificado separadamente
                expect(resultadoLexador.simbolos).toHaveLength(14);
                expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
                    expect.objectContaining({ tipo: foles_1.default.METODO }),
                ]));
                // 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].propriedadeCss).toStrictEqual(cores_1.CoresNomeFolEs[cores_1.Cores[index]]);
                // Tradutor
                const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
                expect(resultadoTradutor).toContain(cores_1.CoresNomeFolEs[cores_1.Cores[index]]);
                expect(resultadoTradutor).toContain("rgb(34, 12, 64);");
            }
        });
        it('Caso de Falha - Valor RGBA válido', () => {
            for (let index = 0; index < cores_1.Cores.length; index += 1) {
                // Lexador
                const resultadoLexador = lexador.mapear([
                    "lmht {",
                    `${cores_1.Cores[index]}: rgba(34, 64, 300);`,
                    "}"
                ]);
                // O objeto terá length 14 pois cada parâmetro é identificado separadamente
                expect(resultadoLexador.simbolos).toHaveLength(14);
                expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
                    expect.objectContaining({ tipo: foles_1.default.METODO }),
                ]));
                // 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].propriedadeCss).toStrictEqual(cores_1.CoresNomeFolEs[cores_1.Cores[index]]);
                // Tradutor
                const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
                expect(resultadoTradutor).toContain(cores_1.CoresNomeFolEs[cores_1.Cores[index]]);
                expect(resultadoTradutor).toContain("rgba(34, 64, 300);");
            }
        });
        it('Caso de Falha - Seletores não existentes', () => {
            for (let index = 0; index < cores_1.Cores.length; index += 1) {
                // Lexador - cor não informada
                const resultadoLexador = lexador.mapear([
                    "lmht {",
                    `${cores_1.Cores[index]}: ;`,
                    "}"
                ]);
                expect(resultadoLexador.simbolos).not.toEqual(expect.arrayContaining([
                    expect.objectContaining({ tipo: foles_1.default.METODO }),
                ]));
                // Causar erro de digitação
                const seletorIncorreto = cores_1.Cores[index].replace(cores_1.Cores[index][0], '');
                const novoLexador = lexador.mapear([
                    "lmht {",
                    `${seletorIncorreto}: rgb(34, 12, 64);`,
                    "}"
                ]);
                // 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);
            }
        });
        it('Caso de Sucesso - Valor HSL válido', () => {
            for (let index = 0; index < cores_1.Cores.length; index += 1) {
                // Lexador
                const resultadoLexador = lexador.mapear([
                    "lmht {",
                    `${cores_1.Cores[index]}: hsl(34, 50%, 120%);`,
                    "}"
                ]);
                expect(resultadoLexador.simbolos).toHaveLength(16);
                expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
                    expect.objectContaining({ tipo: foles_1.default.METODO }),
                ]));
                // 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].propriedadeCss).toStrictEqual(cores_1.CoresNomeFolEs[cores_1.Cores[index]]);
                // Tradutor
                const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
                expect(resultadoTradutor).toContain(cores_1.CoresNomeFolEs[cores_1.Cores[index]]);
                expect(resultadoTradutor).toContain("hsl(34, 50%, 120%);");
            }
        });
        it('Caso de Sucesso - Valor HSLA válido', () => {
            for (let index = 0; index < cores_1.Cores.length; index += 1) {
                // Lexador
                const resultadoLexador = lexador.mapear([
                    "lmht {",
                    `${cores_1.Cores[index]}: hsla(34, 50%, 120%);`,
                    "}"
                ]);
                expect(resultadoLexador.simbolos).toHaveLength(16);
                expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
                    expect.objectContaining({ tipo: foles_1.default.METODO }),
                ]));
                // 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].propriedadeCss).toStrictEqual(cores_1.CoresNomeFolEs[cores_1.Cores[index]]);
                // Tradutor
                const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
                expect(resultadoTradutor).toContain(cores_1.CoresNomeFolEs[cores_1.Cores[index]]);
                expect(resultadoTradutor).toContain("hsla(34, 50%, 120%);");
            }
        });
        it('Caso de Sucesso - Cores atribuídas por meio de variável', () => {
            const coresFolEs = Object.keys(cores_2.cores);
            const coresCss = Object.values(cores_2.cores);
            for (let index = 0; index < coresFolEs.length; index += 1) {
                // Lexador
                const resultadoLexador = lexador.mapear([
                    `$cor-padrao: ${coresFolEs[index]};`,
                    "lmht {",
                    'cor-fundo: $cor-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);
                const primeiroResultado = resultadoAvaliadorSintatico[0];
                expect(primeiroResultado).toBeInstanceOf(declaracoes_1.DeclaracaoVariavel);
                const segundoResultado = resultadoAvaliadorSintatico[1];
                const segundoResultadoTipado = segundoResultado;
                expect(segundoResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
                expect(segundoResultadoTipado.modificadores[0].nomeFoles).toStrictEqual('cor-fundo');
                expect(segundoResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual('background-color');
                // Tradutor
                const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
                expect(resultadoTradutor).toContain(coresCss[index]);
            }
        });
    });
});
//# sourceMappingURL=cores.test.js.map