Forem: Júlio Guedes

Não corra. Pode doer.

Júlio Guedes — Mon, 12 Jul 2021 17:02:58 +0000

Nós temos um grande potencial dentro de cada um de nós, e muitas vezes escolhemos o curso superior tentando atingir o máximo que somos capazes, e também provar que somos. Experimentamos novas áreas, aprendemos coisas novas, nos dispomos como voluntários, pesquisamos, desenvolvemos e analisamos coisas.

É engraçado perceber que tudo isso acontece naquele minúsculo espaço, entre nós e o computador. Nós lemos, tentamos, assistimos aulas, perguntamos e, acima de tudo, nos esforçamos. Até conseguirmos. Quantas vezes não repetimos esse ciclo num único dia?

Durante a jornada da graduação, enfrentamos problemas, e começamos a buscar liberdades e alívios. Problemas financeiros, com a família, com amigos, de saúde, entre tantos outros. Alguns veem no estudo e no trabalho uma fuga, já que essa realidade não é confrontada no ambiente profissional ou universitário. Urge a necessidade de se formar, como primeiro passo pra libertação.

Mas para se formar bem, é preciso experiência, afinal, que empresa legal e que pode pagar um salário bacana iria contratar um recém-formado com currículo em branco? Ainda nos primeiros períodos do curso, surge a necessidade de preencher o currículo com monitorias, pesquisas, projetos e estágios. Mesmo que, a princípio, sejam voluntários. Tudo isso sem baixar as notas.

A cada dia que passa, enxergamos o quanto é difícil. Aos poucos se vai abdicando pequenas coisas: assistir um filme com a família, fazer as refeições no mesmo horário, encontrar com os amigos, conversar com eles sobre coisas além da universidade. Seus hobbies se transformam em estudos, já que você ainda não conseguiu o tão sonhado estágio que vai garantir algumas portas abertas depois. A cada mês ou semestre, novas coisas começam a deixadas de lado: dormir bem, praticar exercícios ou esportes, a relação com seus amigos, e até um relacionamento.

É claro que nessa jornada você conseguiu muita coisa, afinal, nenhum esforço grande assim passa despercebido pelo mundo, principalmente quando você quer ser notado. Você consegue oportunidades em estágios, projetos ou pesquisas, e é exemplar em cada um deles. Então, começa a se questionar porquê não é notado por aqueles que você queria. E aposta mais coisas nessa busca.

Não é mais um problema trabalhar e estudar à noite, nos finais de semana e feriados. É o que precisa ser feito. A carga é grande demais pra não fazê-lo. E, diminuindo a carga, você sabe que não chegará onde quer.

Cada vez é um fator a mais, um estresse a mais, que surge de uma oportunidade boa demais pra negar. E aceitamos a vida assim. Por um ou dois anos, vai valer a pena esse sacrifício. É um investimento no futuro.

As decepções começam a aparecer, suas expectativas de ser notado continuam não se cumprindo a cada dia, e essa carga de trabalho tão pesada se transforma no seu dia. Você acorda e dorme para cumprir o que acha que os outros esperam de você, adiando a esperança de que vai dar certo. Cada vez mais você acumula rejeições nos estágios dos sonhos. Não desiste de lutar. E meses se passam.

Até que você quebra.

Você está cansado. Olha para o lado e seus amigos, que antes se divertiam tanto juntos, não estão diariamente ao seu lado. Não estão ao seu lado há algum tempo, e você sequer tinha notado. Você não está satisfeito com seu corpo, sua aparência. Pensa em fazer outra coisa pra desestressar, mas o que fazer? Você deixou seus hobbies pra trás há muito tempo.

Estar no computador começa a causar dor, e aos poucos você começa a abdicar de algumas das obrigações. Mesmo sem ter alcançado nada do que imaginava ser possível. Sair de um projeto, não se inscrever em mais uma monitoria. Surge o medo de se formar e estar desempregado, seu pior pesadelo.

Mas existe a possibilidade de continuar na universidade, numa pós graduação, e extender esse tempo de se decidir. Com suas notas e seus esforços, deve ser possível. Mas foi pra isso que você lutou tanto? Pra continuar no mesmo lugar que você está? Sabendo que uma vez ouviu que "a pós-graduação é onde ficam aqueles que não conseguem um emprego"?

Você sabe que isso não é verdade. Mas você correu demais. Esqueceu de aproveitar a graduação. Viver o dia a dia de um projeto, de uma monitoria. Divertir-se com seus amigos, ao invés de tentar agarrar o mundo com seus braços. Esqueceu de cursar uma disciplina e conversar com o professor após a aula, sobre como aquele conteúdo se aplica num problema, mesmo que você não fosse fazê-lo. Sua curiosidade e seu interesse sumiram, pois não havia mais tempo para novas coisas.

Aos poucos, você foi murchando. E, só agora, percebeu que estava murcho.

Não é possível voltar no tempo e reparar tudo, você sabe muito bem. Mas sempre é possível reconsiderar o que está fazendo agora, ponderar melhor e entender suas prioridades. Saúde, tempo, amigos, rir, sorrir, brincar. Assistir um filme ruim só pra dizer que é ruim mesmo, e então rir com seus amigos por vocês terem escolhido passar por isso. Se reaproximar daqueles que importam, das coisas que te faziam sorrir.

A relação com o seu trabalho e seus estudos precisa ser saudável pra dar certo, afinal, você escolheu tudo isso por gostar. Mas sua vida não se resume a um emprego, um título, um trabalho. Escolher esse caminho pode te isolar. Pode doer.

Pare, pense, reflita.
Sempre.
Para só então saber como continuar.

Análise de Dados para Iniciantes em Python: Parte 1

Júlio Guedes — Thu, 07 May 2020 19:16:18 +0000

Este post foi feito em parceria com o Colabora Dados, e você pode conferir o post original aqui.

A análise de dados é um conjunto de técnicas que permite extrair informação sobre um conjunto de dados. Achou muito técnico? Podemos entender isso como uma forma de conhecer melhor os dados que temos. Caso queira se aprofundar mais nos termos, esse post introduz bem o que é ciência de dados e suas áreas.

Os tópicos que serão abordados neste post são:

Python
- O que é
- Como instalar
- Como executar um programa
- Como usar Python online
- Bibliotecas
Sintaxe
Conjunto de dados = Tabelas!
Abrindo tabelas em Python
Primeira Visualização

Python

O que é

Como você já deve ter imaginado, Python é uma Linguagem de Programação de propósito geral. Isso quer dizer que diferentemente de outras linguagens, Python pode ser utilizado para diversos propósitos, dependendo do seu objetivo. Alguns possíveis são: criar e manter um site, fazer análises de dados ou até mesmo criar um programa que identifica se uma foto é de um cachorro ou um gato.

Como instalar

Esta seção do tutorial só é importante se você está usando o sistema operacional Windows. Se você usa alguma distribuição Linux ou MacOS, o Python já está instalado.

Nota rápida: caso você não queira instalar o Python neste momento, siga para a próxima seção.

No site oficial do Python, você pode encontrar uma aba para downloads. Nessa aba, queremos baixar a versão 3.6.10. Durante a instalação, marque a opção Add Python 3.6.10 to PATH.

Como executar um programa

Caso você use Windows deverá abrir o o cmd. Se usa Linux ou MacOS abra o terminal. Nesse tutorial, a única diferença é o comando para listar os arquivos e pastas: no Windows, use o comando "dir" para listar, enquanto nos outros, use o comando "ls".

Para acessar uma subpasta, use o comando "cd nome_da_pasta". Por exemplo: se você está na pasta Documentos e quer entrar na pasta códigos, use o comando "cd codigos".

Para garantir que o Python está instalado, execute "python" na linha de comando, ou "python3" se você está usando Linux. Você verá algo semelhante a imagem abaixo:

O lugar mágico que você acabou de acessar chama-se shell do Python. É uma linha de comando para executar comandos em Python. Ele serve pra calcular alguma coisa e também testar comandos. Para sair dele, execute o comando "exit()".

Quando você tiver escrito um programa em Python, precisará entrar na pasta onde o arquivo está e depois usar o comando "python nome_do_arquivo.py" para executá-lo. O arquivo de um programa é exatamente igual a um arquivo de texto (um .txt), mas o salvamos com a extensão .py para representar que é um arquivo de texto Python.

Como usar Python online

Se você escolheu executar online, há alternativas para utilizar Python, como o Google Colab. Para acessar, basta entrar na sua conta Google (Gmail), e abrir o seu Google Drive. Nas opções para a criação de documentos, clique em exibir mais opções e você encontrará a opção Google Colaboratory.

O Google Colab funciona em modo notebook (ou jupyter notebook). Se você já programou em R, é equivalente a R markdown. Num notebook, é possível adicionar textos ou códigos.

Como é possível ver acima, existem trechos de texto em fundo branco, e trechos de código em fundo cinza. Caso queira usar notebooks no seu computador, é possível usando Jupyter. Você pode encontrar mais informações sobre isso neste link.

Bibliotecas

No contexto de programação, bibliotecas contém o código que já foi escrito por alguém e nos permite executar funcionalidades específicas já prontas.

Bibliotecas usualmente utilizadas na análise de dados são:

NumPy, que permite fazer operações matemáticas mais avançadas;
Pandas, que permite ler arquivos de dados mais facilmente; e
MatPlotLib, que permite gerar visualizações dos dados em gráficos de barras, boxplots, e outros tipos de gráficos.

Após a instalação local do Python, utilizaremos o pip (Package Installer for Python). O pip é o gerenciador de pacotes (bibliotecas) do Python. Utilize o comando abaixo para instalar o NumPy, Pandas e MatPlotLib:

pip install numpy pandas matplotlib

Sintaxe

Inicialmente, é necessário entender o conceito de variável. Uma variável é utilizada para armazenar um valor durante a execução do programa. A sintaxe segue o seguinte formato:

nome_da_variavel = valor

O "=" é chamado de atribuição.

idade = 21

As variáveis podem ser utilizadas também em expressões, veja a expressão aritmética abaixo:

dobro = idade * 2

No código acima não foi necessário utilizar o 21 novamente, pois seu valor estava armazenado na variável. Outro exemplo onde armazena-se um nome:

nome = "Júlio"

Entre os exemplos anteriores, há uma diferença sutil: o uso das aspas. Isso faz a distinção de fierentes tipos de dados. Os tipos mais simples (denominados tipos literais) são:

String: é um dado que se refere uma sequência de caracteres. Por exemplo: nome = "Júlio";
Int: é um dado numérico que não tem valor decimal. Por exemplo: idade = 21;
Float: é um dado numérico que possui valor decimal. Por exemplo: altura = 1.83. Para valores decimais utiliza-se o ponto, e não a vírgula.

A medida que você se aprofundar, será possível encontrar tipos mais avançados de dados, inclusive criar seus próprios tipos de dados.

Conjunto de dados = Tabelas?

Após a breve explicação sobre variáveis e os tipos mais básicos de dados, o próximo passo é usar dados existentes nos programas.

Na análise de dados não tratamos o tipo do dado apenas como o tipo de uma variável. Entende-se que os conjuntos de dados assumem alguns tipos diferentes: dados tabulares (Excel, CSV, etc), imagens, vídeos, pdfs ou docs, páginas da internet, entre outros. Dependendo da análise, o dado pode tomar diferentes formas: um tweet, uma foto, um e-mail, entre outros.

No decorrer deste tutorial, usaremos tabelas para representar os dados que temos interesse.

Abrindo tabelas em Python

Usaremos como conjunto de dados os valores da Cota para o Exercício da Atividade Parlamentar (CEAP). Você pode ler mais sobre o que é a CEAP aqui, mas pode-se resumir como um auxílio financeiro para os deputados para gastos com hotelaria, transporte, passagens, etc. Você pode baixar a tabela dadosCEAP1.csv aqui.

Para abrir uma tabela, podemos usar a biblioteca Pandas. O código que precisamos escrever para incluir a biblioteca é:

import pandas as pd

A linha acima torna as funcionalidades existentes na biblioteca Pandas para o nosso código através da variável pd. Em seguida, podemos abrir a tabela:

tabela = pd.read_csv('dadosCEAP1.csv')

Para visualizar nossa tabela, podemos usar o comando .head():

tabela.head()

Isso nos permite ver as cinco primeiras linhas da nossa tabela para entendermos melhor os dados que estamos lidando. Se você tiver executando na linha de comando, será algo como:

Caso esteja executando em um notebook, será assim:

Agora que abrimos a nossa tabela com Python, podemos fazer diversas coisas, incluindo visualizar os dados.

Primeira Visualização

Um dos gráficos mais simples que podemos gerar é um histograma. Uma variável interessante para analisar é o valor gasto, que está presente na tabela na coluna valorLíquido. Quando pensamos nas perguntas: "Quantos reembolsos foram pedidos até o valor de cinco mil reais? E entre cinco e dez mil reais?", podemos respondê-las usando um histograma.

Para gerar o histograma, usaremos a biblioteca matplotlib, mais especificamente a função pyplot que existe nessa biblioteca. Novamente, importamos a biblioteca com o seguinte comando:

from matplotlib import pyplot as plt

Acima, estamos importando apenas a função pyplot da biblioteca inteira e colocando essa função na variável plt. Anteriormente importamos a biblioteca Pandas por completo, mas apenas utilizamos a função read_csv. poderíamos também ter feito isso através do comando:

from pandas import read_csv as abre_csv

Abrindo dessa forma, ao invés de abrir o csv utilizando pd.read_csv, usamos abre_csv.

Continuando com o código para gerar nosso histograma, podemos declarar o início de uma nova figura:

plt.figure()

Em seguida, geramos o histograma da coluna valorLíquido:

plt.hist(tabela['valorLíquido'])

Acima, a coluna da tabela foi acessada usando colchetes e colocando o nome da coluna dentro, tabela['valorLíquido']. Por fim, podemos salvar nosso gráfico como uma imagem png usando o comando:

plt.savefig('histograma.png')

Ao abrir, teremos o gráfico:

Pelo gráfico, entendemos que mais de 500 mil reembolsos foram pedidos com o valor até 25 mil reais. Ainda assim, observando a extensão do eixo X, observa-se que há pelo menos um reembolso com valor próximo a 175 mil.

Na próxima parte do tutorial, abordaremos tópicos mais avançadas que podemos fazer usando apenas essas bibliotecas, e assim entender ainda mais o nosso conjunto de dados.

Agradeço a leitura, e fique a vontade para ler mais textos na minha página do Medium e na minha página do Dev.to. Se quiser entrar em contato, @juliobguedes.

Entendendo JavaScript: Promises

Júlio Guedes — Tue, 17 Sep 2019 17:13:46 +0000

No início da programação em JavaScript as coisas geralmente vão bem: é fácil entender a sintaxe da linguagem e assimilar a outras linguagens popularmente conhecidas, como Python e Java. Ao entrar mais a fundo nas possibilidades de implementação com JavaScript, surge o "bicho papão" para todo iniciante: as Promises.

Entretanto, embora pareçam assustadoras, as Promises são essenciais enquanto programando JavaScript e, com um pouco de prática, passam a ser rotina. Neste post, discutiremos o que são Promises, como utilizá-las, além de um plus pro async/await.

Antes de tudo, assíncrono

Diferente de algumas outras linguagens, como Python e Java, JavaScript permite a programação de forma assíncrona, isto é, as linhas de código de uma função podem não ser executadas uma após a outra: as linhas 1, 2 e 3 serem executadas uma após a outra não é garantia de que a linha 4 será a próxima a ser executada.

Fetch

Durante o restante desse tutorial utilizaremos o fetch como base para os exemplos. Agora nativo no JavaScript, a API do fetch nos permite fazer requisições HTTP sem utilizar libs externas. Sumarizando bastante, as requisições são pedidos de informação de fontes externas à nossa aplicação, seja de um servidor, uma API, ou outras fontes, e o fetch será a função que nos permite solicitar essa informação no nosso código.

Além do fetch, existem libs que permitem fazer requisições HTTP: um exemplo forte na comunidade é a axios. Alguns frameworks, como o Angular.js, possuem funções internas ($http, no caso do Angular.js) que permitem fazer essas requisições.

O que são Promises?

Agora sim, Promises. Como explicado na sessão anterior, as requisições buscam informação em fontes externas. Entretanto, o nome fetch não foi escolhido ao acaso: pedir informação de uma fonte externa é como jogar uma bola para o cachorro ir buscar — em inglês, a expressão go fetch é usada no lugar do pega, que é geralmente usado aqui no Brasil — mas, assim como o cachorro demora para trazer a bola de volta, a informação também demora a chegar do servidor.

Mas, JavaScript é assíncrono: se a linha 3 demorar demais, como impedir que a linha 4 execute? As Promises surgem então nesse contexto: no nosso código, uma Promise (promessa, em português) serve para impedir que a linha 4 execute antes da linha 3, pois era necessária a informação adquirida na linha 3 antes de executar a linha 4. A semântica básica das promises é do this ... then do that — faça isso ... depois faça aquilo.

Infelizmente, assim como na vida real, nem toda promessa é cumprida, e precisamos nos precaver para esse tipo de situação. A semântica, nesse caso, lembra um pouco o try catch de Java: se não é possível recuperar a informação ou houve erro no código do then, caímos num catch.

Obama cruzando os dedos: Promises também podem ser quebradas! Disclaimer: essa foto é uma montagem

Mesmo que o código dentro do nosso then não cause erros, erros lançados pelo servidor e erros na comunicação precisam ser tratados, por exemplo: quando o serviço externo no qual se está buscando a informação não está online, nossa requisição gera um erro de timeout; se não estamos conectados à internet no momento em que a requisição é feita, nossa requisição gera um erro de network. Detalhes como esse precisam ser tratados, e muitas vezes é isso que transforma as promises em algo delicado.

Exemplos de Promise

Para fins de exemplo, nosso serviço externo será o Laguinho da OpenDevUFCG.

Quando fizermos uma requisição GET para o Laguinho, ele deve nos retornar {"status":"running"}. Assim, utilizando o fetch, vejamos o código necessário para fazer essa requisição:

const url = 'https://laguinho.opendevufcg.org/';
const resposta = fetch(url);
console.log('Resposta:', resposta);

Quando executamos o código acima, o console.log nos retorna um objeto do tipo Promise, e não o objeto com o status, que deveria ser o retorno. Vamos aplicar a semântica de promises ao código:

const url = 'https://laguinho.opendevufcg.org/';
fetch(url).then((resposta) => {
  console.log('Resposta:', resposta);
});

Temos então um objeto do tipo Response, e a partir dele é possível obter os dados da resposta dada pelo serviço externo. Já que o Laguinho nos retorna um objeto em JSON, aplicaremos a função json na resposta para obter os dados. Note que a função json também é uma promise.

const url = 'https://laguinho.opendevufcg.org/';
fetch(url).then((resposta) => {
  console.log('Resposta:', resposta);
  resposta.json().then((respostaDoServidor) => {
    console.log('Resposta do Servidor:', respostaDoServidor);
  });
});

Até agora, todos os nossos casos funcionam. Mas, e se houvéssemos escrito a url incorreta? Como provavelmente não haveria um servidor que se comunica utilizando JSON na url que (por exemplo) trocamos uma letra, a requisição iria falhar. Nesse caso, precisamos de um catch, para impedir que seja lançada uma exceção, e podermos tratar de acordo. Vejamos:

const url = 'https://laguinoh.opendevufcg.org/';
fetch(url).then((resposta) => {
  console.log('Resposta:', resposta);
  resposta.json().then((respostaDoServidor) => {
    console.log('Resposta do Servidor:', respostaDoServidor);
  });
}).catch((erro) => {
  console.log('Aconteceu um erro durante a requisição:', erro);
});

Agora você já deve ter entendido o que são promises, como elas aparecem no seu código, e como lidar com elas. Mas, em termos de legibilidade de código, ainda há um problema: se existem diversas promises que estão uma dentro da outra, torna-se muito difícil entender o fluxo de execução. Vejamos então uma forma diferente de escrever Promises.

Plus: Async/Await

Agora, os mimos. Async/await é uma forma sensacional e bastante legível de escrever Promises, pois além de não ser verborrágica, não torna o código ilegível, seja pelo fluxo ou pelas indentações, mas é necessário encapsular o código em uma função. Vejamos os códigos anteriores quando escrito usando async/await:

const url = 'https://laguinho.opendevufcg.org/';
const fluxo = async () => {
  try {
    const resposta = await fetch(url);
    const respostaServidor = await resposta.json();
    console.log('resposta do servidor', respostaServidor);
  } catch(erro) {
    console.log('Aconteceu um erro durante a requisição:', erro);
  }
};

Note que, não importa em que linha de código o erro aconteceu, ele sempre cairá no bloco do catch. Se você não gostou da ideia de ter um bloco try/catch no seu código, saiba que você não é o único: eu costumo escrever as promises utilizando uma mistura dos dois estilos, por exemplo:

const url = 'https://laguinho.opendevufcg.org/';
const fluxo = async () => {
  const resposta = await fetch(url).catch((erro) => {
    console.log('Erro no fetch', erro);
  });
  const respostaServidor = await resposta.json().catch((erro) => {
    console.log('Erro no .json', erro);
  });
  console.log('resposta do servidor', respostaServidor);
};

Async/Await está se tornando cada vez mais popular, mas o estilo não agrada a todos: fica a seu critério decidir entre usar ou não :)

Chegamos ao fim desse post... :(

Agradeço bastante pela leitura e sinta-se à vontade para tirar quaisquer dúvidas que ainda existam. Se esse tutorial foi útil, dá uma olhada no meu outro post, introduzindo conceitos de teste em JavaScript.

Caso queira entrar em contato, só mandar um Tweet! Te convido a continuar lendo textos meus, confere meu Medium.

Se estiver buscando posts sobre programação em Português, te recomendo dar uma olhada no conteúdo do OpenDevUFCG. Se curtir desenvolvimento OpenSource, aproveita e dá uma olhada no GitHub também!

Testes em JavaScript: Conceitos iniciais

Júlio Guedes — Sat, 07 Sep 2019 21:51:15 +0000

Diferentemente do que muitos pensam, o desenvolvimento de uma aplicação Web ou Mobile necessita de testes, seja para assegurar a qualidade do produto, o funcionamento, e até mesmo a aparência, durante a evolução do código.
Quando nosso software está bem consolidado em termos de testes, podemos estabelecer estratégias de integração e deploy contínuos (CI/CD). Esses métodos atuam para garantir que nossa aplicação não tenha sofrido efeitos colaterais com as adições, modificações e correções que estarão sendo enviadas à branch principal para deploy. Nesse post, serão introduzidos os conceitos de Spies e Stubs, e como eles são úteis durante o desenvolvimento de um conjunto de testes de unidade.

Teste de Unidade

Vamos supor o seguinte cenário: temos uma aplicação que requer o cadastro dos seus usuários com um username, que deve ter tamanho de pelo menos 3 caracteres. Para tal, podemos adicionar no código de cadastro uma verificação para o tamanho do username:

function cadastrar(username, senha) {
  if (username.length < 3) {
    throw new Error('O username necessita de pelo menos 3 caracteres');
  }
  // Continua o cadastro
};

Quando escrevemos testes para a função de cadastro, nossa intenção seria testar diferentes casos, escolhendo valores limite, para podermos testar a qualidade da nossa verificação e se estamos deixando passar algum cenário indesejado. Por enquanto, não vamos nos importar tanto com a sintaxe, mas na semântica:

describe('testes da função de cadastro', () => {
  it('testa um username válido', () => {
    expect(cadastrar('teste', 'teste')).to.not.throw();
    /* Nesse caso, espera-se que não seja lançado um erro,
     * visto que o username tem três ou mais caracteres
     */
  });
  it('testa um username invalido', () => {
    expect(cadastrar('te', 'teste')).to
      .throw('O username necessita de pelo menos 3 caracteres');
    /* Nesse outro caso, como o username tem menos de 3 caracteres,
     * espera-se que seja lançado um erro com a mensagem descrita
     */
  });
  // testes de senha, e outros fluxos do cadastro
});

Nesse caso, estamos testando apenas a função de cadastro, ou seja, um teste unitário que testa apenas uma "unidade básica" do sistema (entenda unidade básica como aquela unidade que não chama outras funções internamente). De agora em diante, a ideia é termos funções mais complicadas que isso, ou seja, funções que precisam chamar outras funções na sua execução, por envolverem lógicas mais complexas.

Spies

Imagine agora que, uma vez cadastrado, também seja possível alterar esse username. Temos, então, duas situações possíveis em que desejamos verificar se o que o usuário inseriu é válido. Para isso, podemos refatorar nosso código atual de maneira a reutilizar as linhas que verificam se o username está no padrão correto:

function verificaUsername(username) {
  if (username.length < 3) {
    throw new Error('O username necessita de pelo menos 3 caracteres');
  }
};

function cadastrar(username, senha) {
  verificaUsername(username);
  // Continua o cadastro
};

Com o código refatorado, é também preciso refatorar os testes, para que se adequem ao contexto real do código:

describe('testes da função de cadastro', () => {
  it('testa um username válido', () => {
    const spy = sinon.spy(verificaUsername);
    expect(cadastrar('teste', 'teste')).to.not.throw();
    expect(spy).to.have.been.called;
  });
  it('testa um username invalido', () => {
    const spy = sinon.spy(verificaUsername);
    expect(cadastrar('te', 'teste')).to
      .throw('O username necessita de pelo menos 3 caracteres');
    expect(spy).to.have.been.called;
  });
  // testes de senha, e outros fluxos do cadastro
});

Agora que já vimos como os spies são declarados e verificados, é mais fácil entender seu significado: um spy serve para verificar se uma função foi chamada ou não durante a execução de outra função. No nosso exemplo, pedimos para que o sinon (a biblioteca de testes que estamos usando) "espie" o método verificaUsername e, após a chamada para a execução de cadastrar, verificamos se verificaUsername foi chamada.

Entretanto, existe uma particularidade importante a se notar no nosso código: quando testamos um username inválido, a exceção ainda é lançada. Isso nos faz notar que nosso spy não modifica nada no código em execução, apenas verifica se as chamadas internas a uma função são realmente chamadas.

Stubs

Mudando um pouco a perspectiva dentro do sistema que estamos construindo, podemos pensar num sistema mais complexo e que funciona numa certa sequência de operações e, para executar a operação seguinte, a anterior precisa ter sido executada corretamente. Por exemplo:

function operacaoComplexa() {
  return operacaoMenor().then((resposta) => {
    if (resposta.param) {
      // ...
    } else {
      // ...
    }
    return x;
  }).catch((erro) => {
    throw new Error(erro);
  });
}

A função acima não parece ter uma lógica nem um motivo bem definidos, como é o caso da função de cadastro. Entretanto, não é esse o ponto em que precisamos focar: podemos ver que o retorno da operacaoMenor é importante para entendermos o que será retornado nessa função, seja em caso de sucesso ou em caso de erro. Consideremos então que, por exemplo, essa função menor faz uma requisição a um serviço externo, uma API por exemplo.

Na execução do nosso código, o código dessa função executará normalmente, fazendo a requisição necessária. Durante os testes, entretanto, não se deve fazer uma chamada à API, já que a API pode alterar dados reais da aplicação, deixar o banco de dados inconsistente e causar muitos outros problemas. Precisamos então de uma forma para testar a operação complexa sem realmente executar o código de operacaoMenor, e para isso servem os stubs.

Então, o que exatamente um Stub faz? Durante a execução dos nossos testes, um stub substitui uma função existente no código por uma função representativa, na qual é possível controlar o seu retorno. Através desse controle, o restante do código pode executar normalmente e é possível percorrer todos os cenários da execução do programa durante os testes, manipulando o retorno do stub conforme adequado. Vejamos como seria a aplicação de um stub no código dessa função:

describe('testa operacaoComplexa', () => {
  it('testa cenario 1 do then', async () => {
    const stub = sinon.stub(operacaoMenor)
      .resolves({ param: true });
    const retornoComplexo = await operacaoComplexa();
    expect(retornoComplexo).to.eql(/* retorno no caso 1 */);
    expect(stub).to.have.been.called;
  });
  it('testa cenario 2 do then', async () => {
    const stub = sinon.stub(operacaoMenor)
      .resolves({ param: false });
    const retornoComplexo = await operacaoComplexa();
    expect(retornoComplexo).to.eql(/* retorno no caso 2 */);
    expect(stub).to.have.been.called;
  });
  it('testa cenario catch', () => {
    const stub = sinon.stub(operacaoMenor)
      .rejects('mensagem de erro');
    operacaoComplexa()
      .then(() => {
        throw new Error('Operação não deveria ter dado certo');
      }).catch((erro) => {
        expect(erro).to.eql('mensagem de erro');
      });
    expect(stub).to.have.been.called;
  });
});

O teste acima verifica os três cenários que colocamos no código da nossa função. O teste parece ser grande, mas cobre apenas os três fluxos básicos na execução da operacaoComplexa. Explicando em alto nível a sintaxe:

no caso 1, estamos dizendo que a operacaoMenor deve ser um stub que resolve, no retorno da Promise, um objeto { param: true };
no caso 2, estamos dizendo que a operacaoMenor deve ser um stub que resolve, no retorno da Promise, um objeto { param: false };
no caso 3, de erro, estamos dizendo que a operacaoMenor deve ser um stub que rejeita, no retorno da Promise, sendo 'mensagem de erro' a string retornada no erro.

Nesse caso específico, nossa função complexa tinha uma chamada assíncrona (uma Promise) e, por isso, utilizamos resolves e rejects no nosso stub; caso fosse uma função síncrona, poderíamos ter utilizado returns normalmente.

Plus!

Existem diversas bibliotecas que podem ser utilizadas para testes em JavaScript. Algumas das mais famosas são Mocha, Sinon e Chai, que geralmente são utilizados em conjunto. Atualmente, uma das bibliotecas que está sendo bastante visada é o Jest. Se você está pensando em como começar a aplicar o que aprendeu aqui, te sugiro fazer alguns testes simples num dos sites que você hospeda no GitHub Pages — um portfolio, um pequeno projeto de disciplina, quem sabe? Qualquer um desses vai te dar um bom contato inicial :).

Chegamos ao fim desse post... :(

Mas não se preocupe, há muito mais conteúdo do OpenDevUFCG para ler aqui no dev.to, e em breve ainda mais posts saindo do forno.

Agradeço bastante pela leitura, e se quiser entrar em contato comigo, só mandar um Tweet! Se quiser ler mais textos meus, confere meu Medium que em breve mais posts vão sair.

Fique atento: em breve, teremos novos artigos de contribuidores do OpenDevUFCG aqui no dev.to. Acompanhe o OpenDevUFCG no Twitter, no Instagram e, claro, no GitHub.