@designliquido/foles
Version:
Linguagem de folhas de estilo para documentos em geral em português
318 lines • 17.8 kB
JavaScript
"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 foles_1 = __importDefault(require("../../fontes/tipos-de-simbolos/foles"));
const serializadores_1 = require("../../fontes/serializadores");
const declaracoes_1 = require("../../fontes/declaracoes");
describe('Testando Suporte a VARIÁVEIS', () => {
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 - Atribuição de variável com valor QUALITATIVO', () => {
// Lexador
const resultadoLexador = lexador.mapear([
"$cor-secundaria: branco;",
"corpo {",
"cor-barra-rolagem: $cor-secundaria;",
"}"
]);
// O Lexador deve montar um objeto de comprimento 13 sem retornar nenhum erro
expect(resultadoLexador.simbolos).toHaveLength(13);
expect(resultadoLexador.erros).toHaveLength(0);
// O Lexador deve reconhecer a variável declarada
expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
expect.objectContaining({ tipo: foles_1.default.VARIAVEL }),
]));
// O Lexador não deve encontrar qualquer número ou quantificador na operação
expect(resultadoLexador.simbolos).not.toEqual(expect.arrayContaining([
expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
expect.objectContaining({ tipo: foles_1.default.NUMERO }),
]));
// O Lexador deve classificar o valor recebido como QUALITATIVO
expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
expect.objectContaining({ tipo: foles_1.default.QUALITATIVO }),
]));
// Avaliador Sintático
const resultadoAvaliadorSintatico = avaliador.analisar(resultadoLexador.simbolos);
expect(resultadoAvaliadorSintatico.length).toBeGreaterThanOrEqual(1);
// O primeiro item do Avaliador deve ser a declaração de variável
const primeiroResultado = resultadoAvaliadorSintatico[0];
expect(primeiroResultado).toBeInstanceOf(declaracoes_1.DeclaracaoVariavel);
const primeiroResultadoTipado = primeiroResultado;
expect(primeiroResultadoTipado.nome).toBe('cor-secundaria');
// O segundo item do Avaliador deve ser o bloco de declaração com os modificadores
const segundoResultado = resultadoAvaliadorSintatico[1];
expect(segundoResultado).toBeInstanceOf(declaracoes_1.BlocoDeclaracao);
const segundoResultadoTipado = segundoResultado;
expect(segundoResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
// Serializador deve traduzir de acordo o valor qualitativo
const resultadoSerializador = tradutor.serializar(resultadoAvaliadorSintatico);
expect(resultadoSerializador).toContain('body');
expect(resultadoSerializador).toContain('scrollbar-color');
expect(resultadoSerializador).toContain('white;');
});
it('Caso de sucesso - Atribuição de variável com valor NUMÉRICO', () => {
// Lexador
const resultadoLexador = lexador.mapear([
"$valor-indice: 0;",
"corpo {",
"indice-z: $valor-indice;",
"}"
]);
// O Lexador deve montar um objeto de comprimento 13 sem retornar nenhum erro
expect(resultadoLexador.simbolos).toHaveLength(13);
expect(resultadoLexador.erros).toHaveLength(0);
// O Lexador deve reconhecer a variável declarada
expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
expect.objectContaining({ tipo: foles_1.default.VARIAVEL }),
]));
// O Lexador não deve encontrar qualitativos na operação
expect(resultadoLexador.simbolos).not.toEqual(expect.arrayContaining([
expect.objectContaining({ tipo: foles_1.default.QUALITATIVO }),
]));
// O Lexador deve classificar o valor recebido como NUMERO
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);
// O primeiro item do Avaliador deve ser a declaração de variável
const primeiroResultado = resultadoAvaliadorSintatico[0];
expect(primeiroResultado).toBeInstanceOf(declaracoes_1.DeclaracaoVariavel);
const primeiroResultadoTipado = primeiroResultado;
expect(primeiroResultadoTipado.nome).toBe('valor-indice');
// O segundo item do Avaliador deve ser o bloco de declaração com os modificadores
const segundoResultado = resultadoAvaliadorSintatico[1];
expect(segundoResultado).toBeInstanceOf(declaracoes_1.BlocoDeclaracao);
const segundoResultadoTipado = segundoResultado;
expect(segundoResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
// Serializador deve traduzir de acordo
const resultadoSerializador = tradutor.serializar(resultadoAvaliadorSintatico);
expect(resultadoSerializador).toContain('body');
expect(resultadoSerializador).toContain('z-index');
expect(resultadoSerializador).toContain('0;');
});
it('Caso de sucesso - Atribuição de variável com valor numérico COM QUANTIFICADOR', () => {
// Lexador
const resultadoLexador = lexador.mapear([
"$valor-recuo: 12px;",
"corpo {",
"recuo-direito: $valor-recuo;",
"}"
]);
// O Lexador deve montar um objeto de comprimento 14 sem retornar nenhum erro
expect(resultadoLexador.simbolos).toHaveLength(14);
expect(resultadoLexador.erros).toHaveLength(0);
// O Lexador deve reconhecer a variável declarada
expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
expect.objectContaining({ tipo: foles_1.default.VARIAVEL }),
]));
// O Lexador não deve encontrar qualitativos na operação
expect(resultadoLexador.simbolos).not.toEqual(expect.arrayContaining([
expect.objectContaining({ tipo: foles_1.default.QUALITATIVO }),
]));
// O Lexador deve classificar o valor recebido como NUMERO e QUANTIFICADOR
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);
// O primeiro item do Avaliador deve ser a declaração de variável
const primeiroResultado = resultadoAvaliadorSintatico[0];
expect(primeiroResultado).toBeInstanceOf(declaracoes_1.DeclaracaoVariavel);
const primeiroResultadoTipado = primeiroResultado;
expect(primeiroResultadoTipado.nome).toBe('valor-recuo');
// O segundo item do Avaliador deve ser o bloco de declaração com os modificadores
const segundoResultado = resultadoAvaliadorSintatico[1];
expect(segundoResultado).toBeInstanceOf(declaracoes_1.BlocoDeclaracao);
const segundoResultadoTipado = segundoResultado;
expect(segundoResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
// Serializador deve traduzir de acordo
const resultadoSerializador = tradutor.serializar(resultadoAvaliadorSintatico);
expect(resultadoSerializador).toContain('body');
expect(resultadoSerializador).toContain('padding-right');
expect(resultadoSerializador).toContain('12px;');
});
it('Caso de sucesso - Atribuição de variável com MÉTODOS DE COR', () => {
const valoresMetodo = [
'rgb(31, 120, 50)',
'rgba(31, 120, 50)',
'hsl(50, 80%, 40%)',
'hsla(50, 80%, 40%)',
];
for (let index = 0; index < valoresMetodo.length; index += 1) {
// Lexador
const resultadoLexador = lexador.mapear([
`$cor-padrao: ${valoresMetodo[index]};`,
"corpo {",
"sombra-caixa: $cor-padrao;",
"}"
]);
// O Lexador deve montar um objeto de comprimento 14 ou 20 sem retornar nenhum erro
if (index <= 1) {
expect(resultadoLexador.simbolos).toHaveLength(20);
}
else {
expect(resultadoLexador.simbolos).toHaveLength(22);
}
expect(resultadoLexador.erros).toHaveLength(0);
// O Lexador deve reconhecer a variável declarada
expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
expect.objectContaining({ tipo: foles_1.default.VARIAVEL }),
]));
// O Lexador não deve encontrar qualitativos, números ou quantificadores na operação
expect(resultadoLexador.simbolos).not.toEqual(expect.arrayContaining([
expect.objectContaining({ tipo: foles_1.default.QUALITATIVO }),
expect.objectContaining({ tipo: foles_1.default.NUMERO }),
expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
]));
// O Lexador deve classificar o valor recebido como METODO
expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
expect.objectContaining({ tipo: foles_1.default.METODO }),
]));
// Avaliador Sintático
const resultadoAvaliadorSintatico = avaliador.analisar(resultadoLexador.simbolos);
expect(resultadoAvaliadorSintatico.length).toBeGreaterThanOrEqual(1);
// O primeiro item do Avaliador deve ser a declaração de variável
const primeiroResultado = resultadoAvaliadorSintatico[0];
expect(primeiroResultado).toBeInstanceOf(declaracoes_1.DeclaracaoVariavel);
const primeiroResultadoTipado = primeiroResultado;
expect(primeiroResultadoTipado.nome).toBe('cor-padrao');
// O segundo item do Avaliador deve ser o bloco de declaração com os modificadores
const segundoResultado = resultadoAvaliadorSintatico[1];
expect(segundoResultado).toBeInstanceOf(declaracoes_1.BlocoDeclaracao);
const segundoResultadoTipado = segundoResultado;
expect(segundoResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
// Serializador deve traduzir de acordo
const resultadoSerializador = tradutor.serializar(resultadoAvaliadorSintatico);
expect(resultadoSerializador).toContain('body');
expect(resultadoSerializador).toContain('box-shadow');
expect(resultadoSerializador).toContain(valoresMetodo[index]);
}
});
it('Caso de sucesso - Atribuição de variável com MÉTODOS GERAIS', () => {
const valoresMetodo = [
{
foles: 'borrar(4px)',
css: 'blur(4px)'
},
{
foles: 'brilho(50%)',
css: 'brightness(50%)'
},
{
foles: 'contraste(50%)',
css: 'contrast(50%)'
},
{
foles: 'escala-cinza(30%)',
css: 'grayscale(30%)'
},
{
foles: 'rotacionar-matiz(90deg)',
css: 'hue-rotate(90deg)'
},
{
foles: 'inverter(50%)',
css: 'invert(50%)'
},
{
foles: 'opacar(50%)',
css: 'opacity(50%)'
},
{
foles: 'saturar(10%)',
css: 'saturate(10%)'
},
{
foles: 'sepia(60%)',
css: 'sepia(60%)'
},
];
for (let index = 0; index < valoresMetodo.length; index += 1) {
// Lexador
const resultadoLexador = lexador.mapear([
`$metodo-padrao: ${valoresMetodo[index].foles};`,
"corpo {",
"filtro-fundo: $metodo-padrao;",
"}"
]);
// O Lexador deve montar um objeto de acordo, sem retornar nenhum erro
expect(resultadoLexador.erros).toHaveLength(0);
// O Lexador deve reconhecer a variável declarada, o método, o número e o quantificador
expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
expect.objectContaining({ tipo: foles_1.default.VARIAVEL }),
expect.objectContaining({ tipo: foles_1.default.METODO }),
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);
// O primeiro item do Avaliador deve ser a declaração de variável
const primeiroResultado = resultadoAvaliadorSintatico[0];
expect(primeiroResultado).toBeInstanceOf(declaracoes_1.DeclaracaoVariavel);
const primeiroResultadoTipado = primeiroResultado;
expect(primeiroResultadoTipado.nome).toBe('metodo-padrao');
// O segundo item do Avaliador deve ser o bloco de declaração com os modificadores
const segundoResultado = resultadoAvaliadorSintatico[1];
expect(segundoResultado).toBeInstanceOf(declaracoes_1.BlocoDeclaracao);
const segundoResultadoTipado = segundoResultado;
expect(segundoResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
// Serializador deve traduzir de acordo
const resultadoSerializador = tradutor.serializar(resultadoAvaliadorSintatico);
expect(resultadoSerializador).toContain('body');
expect(resultadoSerializador).toContain('backdrop-filter');
expect(resultadoSerializador).toContain(valoresMetodo[index].css);
}
});
it('Caso de falha - Atribuição de variável com valor inválido', () => {
// Lexador
const resultadoLexador = lexador.mapear([
"$cor-secundaria: branc;",
"corpo {",
"cor-barra-rolagem: $cor-secundaria;",
"}"
]);
// Avaliador Sintático
const resultadoAvaliadorSintatico = avaliador.analisar(resultadoLexador.simbolos);
// Serializador deve retornar erro de valor inválido antes de traduzir
expect(() => {
tradutor.serializar(resultadoAvaliadorSintatico);
}).toThrow(`Propriedade 'cor-barra-rolagem' com valor branc inválido`);
});
it('Caso de falha - Declaração de variável após atribuição (fora de ordem)', () => {
// Lexador
const resultadoLexador = lexador.mapear([
"corpo {",
"cor-barra-rolagem: $cor-secundaria;",
"}",
"$cor-secundaria: branco;",
]);
// Avaliador Sintático
const resultadoAvaliadorSintatico = avaliador.analisar(resultadoLexador.simbolos);
// Serializador deve retornar erro de valor inválido antes de traduzir
expect(() => {
tradutor.serializar(resultadoAvaliadorSintatico);
}).toThrow(`A variável 'cor-secundaria' deve ser declarada antes da atribuição de valor.`);
;
});
});
});
//# sourceMappingURL=suporte-variaveis.test.js.map