1
resposta

Comparando jeitos diferentes de fazer a mesma coisa

const somaHorasExtras = (salario, valorHorasExtras) => salario + valorHorasExtras;

const calculaDescontos = (salario, descontos) => salario - descontos;

const verifiqueSe = (valor) => {
  const assercoes = {
    ehExatamenteIgualA(esperado) {
      if (valor !== esperado) {
        // eslint-disable-next-line no-throw-literal
        throw {};
      }
    },
  };
  return assercoes;
};

const teste = (titulo, funcaoDeTeste) => {
  try {
    funcaoDeTeste();
    console.log(`${titulo} passou!`);
  } catch {
    console.error(`${titulo} não passou!!!`);
  }
};

teste('somaHorasExtras', () => {
  const esperado = 2500;
  const retornado = somaHorasExtras(2000, 500);

  verifiqueSe(retornado).ehExatamenteIgualA(esperado);
});

teste('calculaDesconto', () => {
  const esperado = 2300;
  const retornado = calculaDescontos(2500, 200);

  verifiqueSe(retornado).ehExatamenteIgualA(esperado);
});
const somaHorasExtras = (salario, valorHorasExtras) => salario + valorHorasExtras;

const calculaDescontos = (salario, descontos) => salario - descontos;

const teste = (titulo, esperado, retornado) => {
  if (esperado === retornado) {
    console.log(`${titulo} passou`);
  } else {
    console.error(`${titulo} não passou`);
  }
};

teste('somaHorasExtras', 2500, somaHorasExtras(2000, 500));

teste('calculaDesconto', 2200, calculaDescontos(2500, 300));

Por que o primeiro jeito é melhor que o segundo se ambos fazem a mesma coisa? Qual a principal vantagem do primeiro jeito em relação ao segundo?

1 resposta

Olá, Luidi! Como vai?

A diferença principal entre os dois jeitos de fazer os testes está na flexibilidade e na clareza proporcionada pelo primeiro método.

Vamos ver isso em mais detalhes:

  1. Flexibilidade: O primeiro método utiliza uma função de asserção (verifiqueSe) que permite criar diferentes tipos de verificações de forma modular. Isso significa que você pode facilmente adicionar novos tipos de asserções (como verificar se um valor é maior que outro, por exemplo) sem precisar modificar a estrutura do teste em si. O segundo método, por outro lado, está limitado a apenas comparar se os valores são iguais.

  2. Clareza e Manutenção: O primeiro método permite que você escreva testes de uma forma que se assemelha mais à linguagem natural, o que pode tornar o código mais fácil de ler e entender. Por exemplo, verifiqueSe(retornado).ehExatamenteIgualA(esperado) é bastante descritivo e deixa claro o que está sendo testado. Isso também facilita a manutenção do código, pois as asserções estão centralizadas em um único lugar.

  3. Tratamento de Erros: O uso de try/catch no primeiro método ajuda a capturar exceções e fornece mensagens de erro claras quando um teste falha. Isso pode ser muito útil para depuração, já que você recebe feedback imediato sobre qual teste não passou e por quê.

Por essas razões, o primeiro método é geralmente considerado melhor, especialmente em projetos maiores onde a flexibilidade e a clareza são essenciais.

Espero ter ajudado e fico à disposição se precisar.

Abraço e bons estudos!

Caso este post tenha lhe ajudado, por favor, marcar como solucionado