Kris Lagerström - freeCodeCamp.org

Uma introdução aos testes unitários com o Jasmine

Kris Lagerström — Sun, 22 Sep 2024 21:00:00 +0000

Artigo original: An Introduction to Jasmine Unit Testing

Escrito por: Ahmed Bouchefra

O Jasmine é a biblioteca do JS mais popular para testes unitários de aplicações para a web. Neste tutorial, projetado para iniciantes, apresentaremos um guia rápido e completo para testes com o Jasmine.

Você será apresentado ao Jasmine, um framework de testes popular orientado a comportamentos para o JavaScript. Também veremos um exemplo prático simples de como escrever testes unitários com o Jasmine, que pode ajudá-lo a verificar facilmente se há bugs em seu código.

Em resumo, veremos como escrever suítes de teste, especificações e expectativas, além de como aplicar matchers (comparadores) integrados do Jasmine ou criar seus próprios matchers personalizados.

Também veremos como você pode agrupar suítes para organizar seus testes para bases de código mais complexas.

Apresentando o Jasmine

O Jasmine é um framework de desenvolvimento orientado a comportamentos (em inglês, BDD ou behavior-driven development). Com ele, você escreve testes antes de escrever o código real. Ele é muito popular para testes unitários de aplicações em JavaScript. Ele fornece utilitários que podem ser usados para executar testes automatizados para código síncrono e assíncrono.

O Jasmine tem muitos recursos:

Ele é rápido, tem baixa sobrecarga e nenhuma dependência externa.
É uma biblioteca completa e oferece tudo o que você precisa para testar seu código.
Está disponível para Node e para o navegador.
Pode ser usado com outras linguagens, como Python e Ruby.
Não requer o DOM.
Fornece uma sintaxe limpa e fácil de entender e também uma API rica e direta.
Podemos usar linguagem natural para descrever os testes e os resultados esperados.

O Jasmine é uma ferramenta de código aberto disponível sob a licença permissiva do MIT. No momento da redação deste artigo, a versão principal mais recente é a Jasmine 3.0, que fornece novos recursos e algumas mudanças significativas. A versão 2.99 do Jasmine fornecerá diferentes avisos de descontinuação para suítes que têm comportamento diferente na versão 3.0, o que facilitará a migração dos desenvolvedores para a nova versão.

Você pode ler sobre os novos recursos e mudanças significativas neste documento.

Usando o Jasmine

Você pode usar o Jasmine de várias maneiras diferentes:

da maneira antiga, incluindo o núcleo do Jasmine e seus arquivos de teste usando uma tag
Lembre-se de que você precisa alterar os arquivos incluídos das pastas /src e /spec para conter seus arquivos de código-fonte e de teste reais.
Usando o Jasmine como uma biblioteca
Você também pode usar o Jasmine como uma biblioteca em seu projeto. Por exemplo, o código a seguir importa e executa o Jasmine:
```
var Jasmine = require('jasmine');
var jasmine = new Jasmine();

jasmine.loadConfigFile('spec/support/jasmine.json');

jasmine.execute();
```
Primeiro, solicitamos/importamos o Jasmine e usamos o método loadConfigFile() para carregar o arquivo de configuração disponível no caminho spec/support/jasmine.json e, finalmente, executamos o Jasmine.
Usando o Jasmine via CLI
Você também pode usar o Jasmine a partir da CLI (interface de linha de comando), o que permite executar facilmente os testes do Jasmine e, por padrão, gerar os resultados no terminal.
Seguiremos essa abordagem para executar nossos testes de exemplo neste guia, então, primeiro, execute o seguinte comando para instalar o Jasmine globalmente:
```
npm install -g jasmine
```
Você pode precisar executar sudo para instalar pacotes npm globalmente, dependendo da sua configuração do npm.
Agora, crie uma pasta para seu projeto e navegue para dentro dela:
```
$ mkdir jasmine-project $ cd jasmine-project
```
Em seguida, execute o seguinte comando para inicializar seu projeto para o Jasmine:
O comando simplesmente cria uma pasta spec e um arquivo de configuração JSON. Esta é a saída do comando dir:
```
.
└── spec
    └── support
        └── jasmine.json

2 directories, 1 file
```
Este é o conteúdo de um arquivo jasmine.json padrão:
```
{
  "spec_dir": "spec",
  "spec_files": [
    "**/*[sS]pec.js"
  ],
  "helpers": [
    "helpers/**/*.js"
  ],
  "stopSpecOnExpectationFailure": false,
  "random": true
}
```
- spec_dir: especifica onde o Jasmine procura arquivos de teste.
- spec_files: especifica os padrões de arquivos de teste. Por padrão, todos os arquivos JS que terminam com as strings Spec ou spec.
- helpers: especifica onde o Jasmine procura arquivos auxiliares. Os arquivos auxiliares são executados antes das especificações e podem ser usados para definir matchers personalizados.
- stopSpecOnExpectationFailure: quando definido como true, interromperá imediatamente uma especificação na primeira falha de uma expectativa (pode ser usado como uma opção CLI via --stop-on-failure).
- random: quando definido como true, o Jasmine executará os casos de teste de modo pseudoaleatório (pode ser usado como uma opção da CLI via --random).
Os arrays spec_files e helpers também podem conter padrões Glob (graças ao pacote node-glob) para especificar caminhos de arquivo que são padrões que você normalmente usa para especificar um conjunto de arquivos ao trabalhar no Bash (por exemplo, ls *.js).
Se você não usar o local padrão para o arquivo de configuração jasmine.json, basta especificar o local personalizado por meio da opção jasmine --config.
Você pode encontrar mais opções da CLI na documentação oficial.
Entendendo o Jasmine
Nesta seção, aprenderemos sobre os elementos básicos dos testes do Jasmine, como suítes, especificações, expectativas, matchers e spies etc.
Na pasta do projeto, ao executar o comando para inicializar um novo módulo do Node, npm init -y, você criará um arquivo package.json com informações padrão:
```
{
  "name": "jasmine-project",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "",
  "license": "ISC"
}
```
Em seguida, crie um arquivo index.js e adicione o seguinte código:
```
function fibonacci(n){

    if (n === 1) {
        return [0, 1];
    }
    else {
        var s = fibonacci(n - 1);
        s.push(s[s.length - 1] + s[s.length - 2]);
        return s;
    }
}
function isPrime(num){
    for (let i = 2; i < num; i++)
        if (num % i === 0) return false;
    return num !== 1 && num !== 0;
}
function isEven(n) {
    return n % 2 == 0;
}
function isOdd(n) {
    return Math.abs(n % 2) == 1;
}

function toLowerCase(str){
    return str.toLowerCase();
}
function toUpperCase(str){
    return str.toUpperCase();
}
function contains(str, substring, fromIndex){
    return str.indexOf(substring, fromIndex) !== -1;
}
function repeat(str, n){
    return (new Array(n + 1)).join(str);
}

module.exports = {
    fibonacci: fibonacci,
    isPrime: isPrime,
    isEven: isEven,
    isOdd: isOdd,
    toLowerCase: toLowerCase,
    toUpperCase: toUpperCase,   
    contains: contains,
    repeat: repeat
};
```
Suítes
Uma suíte agrupa um conjunto de especificações ou casos de teste. É usada para testar um comportamento específico do código em JavaScript que geralmente é encapsulado por um objeto/classe ou uma função. Ela é criada usando a função global do Jasmine describe(), que recebe dois parâmetros, o título da suíte de teste e uma função que implementa o código real da suíte de teste.
Vamos começar criando nossa primeira suíte de teste. Dentro da pasta spec, crie um arquivo MyJSUtilitiesSpec.js e adicione:
```
describe("MyJSUtilities", function() { /* ... */ });
```
MyJSUtilities é o nome da suíte de teste de nível superior.
Como agrupar e aninhar suítes
Para melhor organização e descrição precisa do nosso conjunto de testes, podemos aninhar suítes dentro da suíte de nível superior. Por exemplo, vamos adicionar duas suítes à suíte MyJSUtilities:
```
describe("String Utils", function() { /*...*/});describe("Math Utils", function() { /*...*/});
```
Dentro da suíte Math Utils, vamos também adicionar duas suítes aninhadas:
```
describe("Basic Math Utils", function() {   /* ... */ }); describe("Advanced Math Utils", function() {   /* ... */ });
```
Estamos agrupando testes relacionados em testes para String Utils, Basic Math Utils e Advanced Math Utils e aninhando-os dentro da suíte de nível superior MyJSUtilities. Isso comporá suas especificações como árvores semelhantes a uma estrutura de pastas.
A estrutura de aninhamento será mostrada no relatório, o que facilita a localização de testes com falha.
Como excluir suítes
Você pode desabilitar temporariamente uma suíte usando a função xdescribe(). Ela tem a mesma assinatura (parâmetros) de uma função describe(), o que significa que você pode desabilitar rapidamente suas suítes existentes simplesmente adicionando um x à função.
As especificações dentro de uma função xdescribe() serão marcadas como pendentes e não serão executadas no relatório.
Especificações
Uma especificação declara um caso de teste que pertence a uma suíte de teste. Isso é feito chamando a função global do Jasmine it(), que recebe dois parâmetros: o título da especificação (que descreve a lógica que queremos testar) e uma função que implementa o caso de teste real.
Uma especificação pode conter uma ou mais expectativas. Cada expectativa é simplesmente uma asserção que pode retornar true ou false. Para que a especificação seja aprovada, todas as expectativas pertencentes à especificação devem ser true. Caso contrário, a especificação falha.
Dentro da nossa suíte String Utils, adicione estas especificações:
```
describe("String Utils", function() {  it("should be able to lower case a string",function() {    /*...*/  });  it("should be able to upper case a string",function() {    /*...*/  });  it("should be able to confirm if a string contains a substring",function() {    /*...*/  });  it("should be able repeat a string multiple times",function() {    /*...*/  });});
```
Dentro da nossa suíte Basic Math Utils, vamos adicionar algumas especificações:
```
describe("Basic Math Utils", function() {  it("should be able to tell if a number is even",function() {    /*...*/  });     it("should be able to tell if a number is odd",function() {    /*...*/  });     });
```
Para Advanced Math Utils, vamos adicionar as especificações:
```
describe("Advanced Math Utils", function() {  it("should be able to tell if a number is prime",function() {    /*...*/  });   it("should be able to calculate the fibonacci of a number",function() {    /*...*/  }); });
```
Como excluir especificações
Assim como as suítes, você também pode excluir especificações individuais usando a função xit(), que desabilita temporariamente a especificação it() e a marca como pendente.
Expectativas
As expectativas são criadas usando a função expect() que recebe um valor chamado real (que pode ser valores, expressões, variáveis, funções, objetos etc.). As expectativas compõem a especificação e são usadas junto com funções matcher (via encadeamento) para definir o que o desenvolvedor espera que uma unidade específica de código execute.
Uma função matcher compara um valor real (passado para a função expect() com a qual está encadeada) e um valor esperado (passado diretamente como um parâmetro para o matcher) e retorna true ou false, o que passa ou falha a especificação.
Você pode encadear a função expect() com vários matchers. Para negar/inverter o resultado booleano de qualquer matcher, você pode usar a palavra-chave not antes de chamar o matcher.
Vamos implementar as especificações do nosso exemplo. Por enquanto, usaremos expect() com o matcher nothing(), que faz parte dos matchers integrados que veremos um pouco mais tarde. Isso passará em todas as especificações, pois não esperamos nada neste momento.
```
describe("MyJSUtilities", function() {describe(">String Utils", function() {  it("should be able to lower case a string",function() {    expect().nothing();  });  it("should be able to upper case a string",function() {    expect().nothing();  });  it("should be able to confirm if a string contains a substring",function() {    expect().nothing();  });  it("should be able repeat a string multiple times",function() {    expect().nothing();  });     });describe("Math Utils", function() { describe("Basic Math Utils", function() {  it("should be able to tell if a number is even",function() {    expect().nothing();  });     it("should be able to tell if a number is odd",function() {    expect().nothing();  });    }); describe("Advanced Math Utils", function() {  it("should be able to tell if a number is prime",function() {    expect().nothing();  });   it("should be able to calculate the fibonacci of a number",function() {    expect().nothing();  });     }); });});
```
Esta é uma captura de tela dos resultados neste ponto:
Temos oito especificações aprovadas e zero falhas.
Você pode usar matchers integrados ou também criar seus próprios matchers personalizados para suas necessidades específicas.
Matchers integrados
O Jasmine fornece um rico conjunto de matchers integrados. Vamos ver alguns dos mais importantes:
- toBe() para testar identidade,
- toBeNull() para testar null,
- toBeUndefined()/toBeDefined() para testar undefined/não undefined,
- toBeNaN() para testar NaN (Not A Number)
- toEqual() para testar igualdade,
- toBeFalsy()/toBeTruthy() para testar falsidade/veracidade etc.
Você pode encontrar a lista completa de matchers na documentação.
Vamos agora implementar nossas especificações com alguns desses matchers quando apropriado. Primeiro, importe as funções que estamos testando em nosso arquivo MyJSUtilitiesSpec.js:
```
const utils = require("../index.js");
```
Em seguida, comece com a suíte String Utils e altere expect().nothing() com as expectativas apropriadas.
Por exemplo, para a primeira especificação, esperamos que o método toLowerCase() seja primeiro definido e, em segundo lugar, retorne uma string em minúsculas, ou seja:
```
it("should be able to lower case a string",function() {        expect(utils.toLowerCase).toBeDefined();        expect(utils.toLowerCase("HELLO WORLD")).toEqual("hello world");  });
```
Este é o código completo para a suíte:
```
describe(">String Utils", function() {  it("should be able to lower case a string",function() {    expect(utils.toLowerCase).toBeDefined();    expect(utils.toLowerCase("HELLO WORLD")).toEqual("hello world");  });  it("should be able to upper case a string",function() {    expect(utils.toUpperCase).toBeDefined();    expect(utils.toUpperCase("hello world")).toEqual("HELLO WORLD");  });  it("should be able to confirm if a string contains a substring",function() {    expect(utils.contains).toBeDefined();    expect(utils.contains("hello world","hello",0)).toBeTruthy();  });  it("should be able repeat a string multiple times",function() {    expect(utils.repeat).toBeDefined();    expect(utils.repeat("hello", 3)).toEqual("hellohellohello");  });     });
```
Matchers personalizados
O Jasmine fornece a capacidade de escrever matchers personalizados para implementar asserções não cobertas pelos matchers integrados ou apenas para tornar os testes mais descritivos e legíveis.
Por exemplo, vamos pegar a seguinte especificação:
```
it("should be able to tell if a number is even",function() {    expect(utils.isEven).toBeDefined();    expect(utils.isEven(2)).toBeTruthy();    expect(utils.isEven(1)).toBeFalsy();  });
```
Vamos supor que o método isEven() não esteja implementado. Se executarmos os testes, receberemos mensagens como a seguinte captura de tela:
A mensagem de falha que recebemos diz Expected undefined to be defined, o que não nos dá nenhuma pista do que está acontecendo. Então, vamos tornar essa mensagem mais significativa no contexto do nosso domínio de código (isso será mais útil para bases de código complexas). Para isso, vamos criar um matcher personalizado.
Criamos matchers personalizados usando o método addMatchers(), que recebe um objeto composto por uma ou várias propriedades que serão adicionadas como matchers. Cada propriedade deve fornecer uma função factory que recebe dois parâmetros: util, que possui um conjunto de funções utilitárias para os matchers usarem (consulte: MatchersUtil.js) e customEqualityTesters, que precisa ser passado se util.equals for chamado, devendo retornar um objeto com uma função compare, que será chamada para verificar a expectativa.
Precisamos registrar o matcher personalizado antes de executar cada especificação usando o método beforeEach():
```
describe("/Basic Math Utils", function () {beforeEach(function () {jasmine.addMatchers({hasEvenMethod:  function (util, customEqualityTesters) {return {compare:  function (actual, expected) {var  result  = { pass:  utils.isEven  !==  undefined };if (result.pass) {result.message  =  "Expected isEven() to be not defined."}else {result.message  =  "Expected isEven() to be defined."}return  result;}}}});});/*...*/});
```
Podemos então usar o matcher personalizado em vez de expect(utils.isEven).toBeDefined():
```
expect().hasEvenMethod();
```
Isso nos dará uma mensagem de falha melhor:
Usando beforeEach() e afterEach()
Para inicializar e limpar suas especificações, o Jasmine fornece duas funções globais, beforeEach() e afterEach():
- A função beforeEach é chamada uma vez antes de cada especificação na suíte onde é chamada.
- A função afterEach é chamada uma vez após cada especificação na suíte onde é chamada.
Por exemplo, se você precisar usar quaisquer variáveis em sua suíte de teste, pode simplesmente declará-las no início da função describe() e colocar qualquer código de inicialização ou instanciação dentro de uma função beforeEach(). Finalmente, você pode usar a função afterEach() para redefinir as variáveis após cada especificação, para que você possa ter testes unitários puros sem a necessidade de repetir o código de inicialização e limpeza para cada especificação.
A função beforeEach() também é perfeitamente combinada com muitas APIs do Jasmine, como o método addMatchers() para criar matchers personalizados ou também com a função done() para aguardar operações assíncronas antes de continuar o teste.
Falhando um teste
Você pode forçar um teste a falhar usando o método global fail() disponível no Jasmine. Por exemplo:
```
it("should explicitly fail", function () { fail('Forced to fail'); });
```
Você deve receber o seguinte erro:
Testando exceções
Quando você está testando seu código unitariamente, erros e exceções podem ser lançados, então você pode precisar testar esses cenários. O Jasmine fornece os matchers toThrow() e toThrowError() para testar quando uma exceção é lançada ou para testar uma exceção específica, respectivamente.
Por exemplo, se tivermos uma função que lança uma exceção TypeError:
```
function throwsError() { throw new TypeError("A type error"); }
```
Você pode escrever uma especificação para testar se uma exceção é lançada:
```
it('it should throw an exception', function () { expect(throwsError).toThrow(); });
```
Ou você também pode usar o teste para a exceção TypeError específica:
```
it('it should throw a TypeError', function () { expect(throwsError).toThrowError(TypeError); });
```
Entendendo spies
Muitas vezes, os métodos dependem de outros métodos. Isso significa que, ao testar um método, você pode acabar testando suas dependências também. Isso não é recomendado em testes, ou seja, você precisa garantir que está testando a função pura, isolando o método e vendo como ele se comporta, dado um conjunto de entradas.
O Jasmine fornece spies que podem ser usados para "espionar"/ouvir chamadas de método em objetos e relatar se um método é chamado e em qual contexto e argumentos.
O Jasmine fornece duas maneiras de espionar chamadas de método: usando os métodos spyOn() ou createSpy().
Você pode usar spyOn() quando o método já existe no objeto. Caso contrário, você precisa usar jasmine.createSpy(), que retorna uma nova função.
Por padrão, um spy apenas relatará se uma chamada foi feita sem chamar a função espionada (ou seja, a função parará de ser executada), mas você pode alterar o comportamento padrão usando estes métodos:
- and.callThrough(): chama a função original,
- and.returnValue(value): retorna o valor especificado,
- and.callFake(fn): chama a função falsa em vez da original,
- and.throwError(err): lança um erro,
- and.stub(): redefine o comportamento de stub padrão.
Você pode usar um spy para coletar estatísticas de tempo de execução na função espionada, por exemplo, se você quiser saber quantas vezes sua função foi chamada.
Digamos que queremos garantir que nosso método toUpperCase() esteja usando o método String.toUpperCase() integrado. Precisamos, simplesmente, espionar String.toUpperCase() usando:
```
it("should be able to upper case a string", function () { 
```
```
var spytoUpperCase = spyOn(String.prototype, 'toUpperCase') 
```
```
expect(utils.toUpperCase).toBeDefined(); expect(utils.toUpperCase("hello world")).toEqual("HELLO WORLD"); expect(String.prototype.toUpperCase).toHaveBeenCalled(); expect(spytoUpperCase.calls.count()).toEqual(1); });
```
O teste falhou devido à segunda expectativa, pois utils.toUpperCase("hello world") retornou undefined em vez do HELLO WORLD esperado. Isso ocorre porque, como mencionamos, anteriormente, após criar o spy em toUpperCase(), o método não é executado. Precisamos mudar esse comportamento padrão chamando callThrough():
Observe que uma função spy substitui a função espionada por um stub por padrão. Se você precisar chamar a função original, pode adicionar .and.callThrough() ao seu objeto spy.
```
var spytoUpperCase = spyOn(String.prototype, 'toUpperCase').and.callThrough();
```
Agora, todas as expectativas passam.
Você também pode usar and.callFake() ou and.returnValue() para falsificar a função espionada ou apenas o valor de retorno se você não quiser chamar a função real:
```
var spytoUpperCase = spyOn(String.prototype, 'toUpperCase').and.returnValue("HELLO WORLD"); 
```
```
var spytoUpperCase = spyOn(String.prototype, 'toUpperCase').and.callFake(function(){ return "HELLO WORLD"; });
```
Agora, se acabarmos não usando o String.toUpperCase() integrado em nossa própria implementação de utils.toUpperCase(), obteremos estas falhas:
As duas expectativas expect(String.prototype.toUpperCase).toHaveBeenCalled() expect(spytoUpperCase.calls.count()).toEqual(1) falharam.
Como lidar com assincronia no Jasmine
Se o código que você está testando contém operações assíncronas, você precisa de uma maneira de informar ao Jasmine quando as operações assíncronas forem concluídas.
Por padrão, o Jasmine espera que qualquer operação assíncrona, definida por uma callback, uma promise ou a palavra-chave async, seja concluída. Se o Jasmine encontrar uma callback, promise ou palavra-chave async em uma dessas funções: beforeEach, afterEach, beforeAll, afterAll e it, ele aguardará a conclusão da operação assíncrona antes de prosseguir para a próxima operação.
Usando done() com beforeEach()/it() ..
Vamos pegar nosso exemplo simulateAsyncOp(), que simula uma operação assíncrona usando setTimeout(). Em um cenário do mundo real, pode ser uma solicitação Ajax ou qualquer coisa semelhante que aconteça de maneira assíncrona:
```
function simulateAsyncOp(callback){ 
```
```
setTimeout(function () { callback(); }, 2000); }
```
Para testar esta função, podemos usar a função beforeEach() com a callback especial done(). Nosso código precisa invocar done() para informar ao Jasmine que a operação assíncrona foi concluída:
```
describe("/Async Op", function () {var  asyncOpCompleted  =  false;beforeEach(function (done) {utils.simulateAsyncOp(function(){  asyncOpCompleted  =  true;  done();});});it("should be able to tell if the async call has completed", function () {  expect(asyncOpCompleted).toEqual(true);});});
```
Podemos notar rapidamente uma desvantagem desse método, então precisamos escrever nosso código para aceitar a callback done(). No nosso caso, não codificamos o método done() em nosso simulateAsyncOp(fn), mas fornecemos um parâmetro de callback apenas para poder chamar done().
Usando as promises
Se você não quiser criar código que dependa de como você escreve seu teste, pode usar uma promise e chamar a callback done() quando a promise for resolvida. Ou melhor ainda, a partir do Jasmine 2.7+, se seu código retornar uma Promise, o Jasmine aguardará até que ela seja resolvida ou rejeitada antes de executar o próximo código.
Usando async/await
O Jasmine 2.7+ suporta chamadas a async e await em especificações. Isso o libera de colocar asserções em um bloco .then() ou .catch().
```
it("should work with async/await", async () => { let completed = false; completed = await utils.simulateAsyncOp(); expect(completed).toEqual(true); });
```
Esta é a implementação de simulateAsyncOp:
```
function simulateAsyncOp() { 
```
```
return new Promise(resolve => { setTimeout(() => { resolve(true); }, 1000); }); }
```
Usando o Jasmine Clock
O Jasmine Clock é usado para testar código assíncrono que depende de funções de tempo, como setTimeout(), da mesma maneira que testamos código síncrono, simulando APIs baseadas em tempo com métodos personalizados. Desse modo, você pode executar as funções testadas sincronicamente controlando ou avançando manualmente o relógio.
Você pode instalar o Jasmine Clock chamando a função jasmine.clock().install em sua especificação ou suíte.
Depois de usar o relógio, você precisa desinstalá-lo para restaurar as funções originais.
Com o Jasmine Clock, você pode controlar as funções setTimeout ou setInterval do JavaScript avançando o relógio para avançar no tempo usando a função jasmine.clock().tick, que recebe o número de milissegundos que você pode mover.
Você também pode usar o Jasmine Clock para simular a data atual.
```
beforeEach(function () {jasmine.clock().install();});afterEach(function() {jasmine.clock().uninstall();});it("should call the asynchronous operation synchronously", function() {var  completed  =  false;utils.simulateAsyncOp(function(){completed  =  true;});expect(completed).toEqual(false);jasmine.clock().tick(1001);expect(completed).toEqual(true);});
```
Esta é a função simulateAsyncOp:
```
function simulateAsyncOp(callback){ 
```
```
setTimeout(function () { callback(); }, 1000); }
```
Caso você não tenha especificado um horário para a função mockDate, ela usará a data atual.
Lidando com erros
Se o seu código assíncrono falhar devido a algum erro, você vai querer que suas especificações falhem da maneira certa. A partir do Jasmine 2.6+, quaisquer erros não tratados são enviados para a especificação atualmente executada.
O Jasmine também fornece uma maneira que você pode usar se precisar falhar explicitamente em suas especificações:
- usando a callback done() com beforeEach() chamando o método done.fail(err),
- simplesmente passando um erro para a callback done(err) (Jasmine 3+),
- chamando o método reject() de uma Promise.
Conclusão
Neste guia, apresentamos o Jasmine e vimos como começar a usá-lo para fazer testes unitários de seu código em JavaScript. Agradecemos pela leitura!
Este artigo foi publicado originalmente em techiediaries.

Como realizar testes de integração usando JUnit 5 e TestContainers com SpringBoot

Kris Lagerström — Thu, 05 Sep 2024 21:00:00 +0000

Artigo original: How to Perform Integration Testing using JUnit 5 and TestContainers with SpringBoot

Escrito por: Sameer Shukla

TestContainers é uma biblioteca que ajuda você a executar contêineres Docker específicos do módulo para simplificar o teste de integração.

Esses contêineres do Docker são leves e, uma vez que os testes são concluídos, os contêineres são destruídos.

Neste artigo, vamos entender o que é o TestContainers e como ele ajuda você a escrever testes mais confiáveis.

Também vamos entender os componentes importantes (anotações e métodos) da biblioteca que ajudam você a escrever os testes.

Finalmente, aprenderemos a escrever um teste de integração adequado no SpringBoot usando a biblioteca TestContainers e seus componentes.

Limitações do teste com um banco de dados H2 na memória

A abordagem mais comum para o teste de integração hoje é usar um banco de dados H2 na memória. Existem, no entanto, certas limitações para esse método.

Em primeiro lugar, digamos que estamos usando a versão 8.0 do MySQL em produção, mas que nossos testes de integração estão usando H2. Nunca poderemos executar nossos testes para a versão do banco de dados em execução em produção.

Aplicação do SpringBoot com banco de dados MySQL e H2

‌Em segundo lugar, os casos de teste são menos confiáveis porque, em produção, estamos usando um banco de dados totalmente diferente – e os testes estão apontando para o H2. A aplicação pode ter problemas em produção, mas os testes de integração podem ser bem-sucedidos.

Eu estava tentando acessar meu serviço RESTful localmente e me deparei com este erro:

"Caused by: org.postgresql.util.PSQLException: FATAL: database "example_db" does not exist".

Ele aconteceu por causa de um problema de permissão, mas os testes locais funcionaram bem.

Por fim, conforme documentado aqui, na seção Compatibility (documentação em inglês), o H2 é compatível com outros bancos de dados apenas até certo ponto. Existem algumas áreas onde o H2 é incompatível. Se você precisar usar "nativeQueries" em uma aplicação do SpringBoot, por exemplo, usar o H2 pode causar problemas.

Apresentando a biblioteca TestContainers

Ao usar TestContainers, podemos superar as limitações do H2.

Os testes de integração apontarão para a mesma versão do banco de dados que está em produção. Assim, podemos vincular nossa imagem de banco de dados do TestContainer à mesma versão em execução na produção.
Os testes de integração são muito mais confiáveis porque a aplicação e os testes estarão usando o mesmo tipo e versão de banco de dados, não havendo problemas de compatibilidade, portanto, nos casos de teste.

O que são os TestContainers?

A biblioteca TestContainers é uma API wrapper sobre o Docker. Quando escrevemos código para criar um contêiner nos bastidores, ele pode ser traduzido para algum comando do Docker como, por exemplo‌:

Criação do MySQLContainer

Este código pode ser traduzido para algo como o seguinte:

docker run -d --env MYSQL_DATABASE=example_db --env MYSQL_USER=test --env MYSQL_PASSWORD=test ‘mysql:latest’

O TestContainers tem um nome de método "withCommand". Você o usa para definir o comando que deve ser executado dentro do contêiner do Docker, o que confirma que o TestContainers é uma API wrapper sobre o Docker.

O TestContainers baixa as imagens MySQL, Postgres, Kafka, Redis e as executa em um contêiner. O MySQLContainer executará um banco de dados do MySQL em um contêiner e os casos de teste podem se conectar a ele na máquina local. Uma vez que a execução termina, o banco de dados desaparecerá – ele simplesmente é excluído da máquina. Nos casos de teste, podemos iniciar quantas imagens de contêiner quisermos.

O TestContainers suporta JUnit 4, JUnit 5 e Spock. Se você for ao site TestContainers.org, basta visitar a seção QuickStart que explica como usá-lo:

TestContainers.org: como começar com o Test Framework

O TestContainers tem suporte a quase todos os bancos de dados, do MySQL e Postgres ao CockroachDB. Você pode encontrar mais informações sobre isso no site TestContainers.org, na seção Modules:‌

Suporte do TestContainers para módulos de bancos de dados

‌O TestContainers também suporta módulos de nuvem como o módulo da GCloud e o módulo do Azure. Se sua aplicação estiver sendo executada no Google Cloud, o TestContainers terá suporte para Cloud Spanner, Firestore, Datastore e assim por diante.‌

Suporte do TestContainers para o módulo da GCloud

Até agora, no artigo, falamos apenas sobre bancos de dados, mas o TestContainers suporta vários outros componentes, como Kafka, SOLR, Redis e muito mais.

Como usar a biblioteca TestContainers

Neste artigo, vamos explorar o TestContainers com o JUnit 5. Para implementar o TestContainers, precisamos entender algumas anotações, métodos e bibliotecas importantes do TestContainers que precisamos implementar em nosso projeto.

Bibliotecas TestContainers

Anotações em TestContainers

Duas anotações importantes são necessárias em nossos testes para que o TestContainers funcione: @TestContainers e @Container.

@TestContainer é uma extensão do JUnit-Jupiter que inicia e interrompe automaticamente os contêineres usados nos testes. Essa anotação encontra os campos que são marcados com @Container e chama os métodos específicos do ciclo de vida do contêiner. Aqui, os métodos do ciclo de vida do MySQLContainer serão invocados.‌

MySQLContainer

O MySQLContainer é declarado como estático, pois, se declararmos o contêiner como estático, um único contêiner será iniciado e será compartilhado entre todos os métodos de teste.

Se for uma variável de instância, um contêiner será criado para cada método de teste.

Métodos da biblioteca TestContainers

Existem alguns métodos importantes na biblioteca TestContainers que você usará nos testes. É bom conhecê-los antes de usar a biblioteca.

withInitScript: usando 'withInitScript', podemos executar o .SQL para definir o esquema, tabelas e também adicionar os dados ao banco de dados. Resumindo, esse método é usado para executar o .SQL para popular o banco de dados.
withReuse (true): usando o método 'withReuse', podemos habilitar a reutilização de contêineres. Esse método funciona bem em conjunto com a habilitação da propriedade "testcontainers.reuse.enable:true" no arquivo ".testcontainers.properties".
start: usamos isso para iniciar o contêiner.
withClasspathResourceMapping: usamos para mapear um recurso (arquivo ou diretório) no classpath para um caminho dentro do contêiner. Isso só funcionará se você estiver executando seus testes fora de um contêiner do Docker.
withCommand: define o comando que deve ser executado dentro do contêiner do Docker.
withExposedPorts: usado para definir a porta na qual o contêiner escuta.
withFileSystemBind: usado para mapear um arquivo/diretório do sistema de arquivos local para o contêiner.

Caso de uso do TestContainers

No exemplo que veremos agora, a aplicação se comunicará apenas com o banco de dados e escreverá os testes de integração para ele usando o TestContainers. Em seguida, estenderemos o caso de uso implementando o Redis no meio.

Se os dados existirem no cache do Redis, eles serão retornados; caso contrário, ele mergulhará no banco de dados para salvar e recuperar com base na chave.

Caso de uso - a solicitação acessa o cache do Redis e retorna, caso a informação esteja lá. Do contrário, é feito o acesso ao BD do MySQL

O serviço é simples. Ele tem 2 endpoints – o primeiro é para criar um usuário e o segundo é para encontrar um usuário por e-mail. Se o usuário for encontrado, ele será retornado; caso contrário, obteremos um 404. O código da classe de serviço tem esta aparência:‌

Componente de serviço

Vamos escrever os testes para essa classe. Você pode encontrar toda a base de código aqui:‌

Classe de teste

A classe de teste é marcada com a anotação @TestContainers, que inicia/para o contêiner. Usamos a anotação @Container para chamar os métodos específicos do ciclo de vida do contêiner.

Além disso, o "MySQLContainer" é declarado como estático porque, então, um único contêiner é iniciado. Em seguida, ele é compartilhado entre todos os métodos de teste (já discutimos a importância dessas anotações).

BeforeAll

Em seguida, precisamos escrever um método de configuração marcado com @BeforeAll, onde habilitamos o método "withReuse". Isso nos ajuda a reutilizar os contêineres existentes. Estamos usando o método "withInitScript" para executar o arquivo ".sql" e, em seguida, iniciar o contêiner.‌

Sobrescrevendo as Properties

‌@DynamicPropertySource nos ajuda a sobrescrever as propriedades declaradas no arquivo properties. Escrevemos esse método para permitir que o TestContainers crie o URL, o nome de usuário e a senha por conta própria – caso contrário, podemos enfrentar erros.

Por exemplo, ao remover o nome de usuário e a senha, podemos enfrentar um erro 'Access denied' (acesso negado, em português), que pode nos confundir. Portanto, é melhor permitir que o TestContainer atribua essas propriedades dinamicamente por conta própria.

É isso – estamos prontos para executar os casos de teste:

Casos de teste

Execute @AfterAll para parar o contêiner. Caso contrário, ele poderá continuar sendo executado em sua máquina local se você não o parar explicitamente.‌

Como usar o GenericContainer

‌‌GenericContainer é o contêiner mais flexível. Ele facilita a execução de quaisquer imagens de contêiner dentro do GenericContainer.

Agora que temos o Redis em seu devido lugar, tudo o que precisamos fazer em nosso caso de teste é ativar um GenericContainer com a imagem do Redis.

GenericContainer para o Redis

Em seguida, iniciamos o contêiner genérico do Redis em @BeforeAll e o paramos com o método de desmontagem @AfterAll.

Iniciando os contêineres

Parando os contêineres

Conclusão

É extremamente fácil usar o TestContainers em nossa aplicação para escrever testes melhores. A curva de aprendizado não é muito íngreme e tem suporte para vários módulos diferentes de uma variedade de bancos de dados, como Kafka, Redis e outros.

Escrever testes usando o TestContainers torna nossos testes muito mais confiáveis. O único lado negativo é que os testes são lentos em comparação aos do H2. Isso ocorre porque o H2 está na memória e o TestContainers leva tempo para baixar a imagem, executar o contêiner e executar toda a configuração que discutimos neste artigo.

Teste do JUnit com o Maven no VSCode

Kris Lagerström — Wed, 04 Sep 2024 21:00:00 +0000

Artigo original: JUnit Test with Maven in VSCode

Escrito por: Clark Jason Ngo

Instalar o VSCode

Configuração aqui: Configurando o Visual Studio Code

Instalar e criar um projeto do Maven

Guia de instalação completo aqui: Maven – Maven em 5 minutos (em inglês)

Se você tem o Maven instalado, siga estas etapas:

Gerar o projeto

mvn archetype:generate -DgroupId=com.mycompany.app -DartifactId=my-app -DarchetypeArtifactId=maven-archetype-quickstart -DarchetypeVersion=1.4 -DinteractiveMode=false

Mudar para o diretório do projeto

cd my-app

Construir o projeto

mvn package

Testar e compilar o projeto

java -cp target/my-app-1.0-SNAPSHOT.jar com.mycompany.app.App

Você deve obter uma saída com: Hello World!

Modificar nosso projeto

Vamos começar criando funções matemáticas simples

Procure o arquivo App.java e substitua o conteúdo por este código:

package com.mycompany.app;

public class App 
{
  public static int add(int firstNumber, int secondNumber) {
    return firstNumber + secondNumber;
  }

  public static int multiply(int multiplicand, int multiplier) {
    return multiplicand * multiplier;
  }

  public static int divide(int dividend, int divisor) {
    if (divisor == 0)
      throw new IllegalArgumentException("Cannot divide by zero (0)."); // Não pode dividir por zero (0).

    return dividend / divisor;
  }
  public static void main( String[] args )
  {
    System.out.println(App.add(3, 3)); 
  }
}

Procure por AppTest.java e substitua o conteúdo por este código:

package com.mycompany.app;

import static org.junit.Assert.assertTrue;

import org.junit.Assert;
import org.junit.Test;

/**
* Teste unitário para App simples. 
*/ 
public class AppTest 
{
    /**
    *Teste Rigoroso :-)
    */
    @Test
    public void shouldAnswerWithTrue() // deveResponderComVerdadeiro
    {
        assertTrue( true );
    }
    @Test
    public void add_TwoPlusTwo_ReturnsFour() { // adicionar_DoisMaisDois_RetornaQuatro
      // Organizar
      final int expected = 4;

      // Agir
      final int actual = App.add(2, 2);

      // Afirmar
      Assert.assertEquals(expected, actual);
    }    
    @Test
    public void multiply_FourTimesTwo_ReturnsEight() { // multiplicar_QuatroVezesDois_RetornaOito
      // Organizar
      final int expected = 8;

      // Agir
      final int actual = App.multiply(4, 2);

      // Afirmar
      Assert.assertEquals(expected, actual);
    }        

    @Test
    public void divide_TenDividedTwo_ReturnsFive() { // dividir_DezDivididoPorDois_RetornaCinco
      // Organizar
      final int expected = 5;

      // Agir
      final int actual = App.divide(10, 2);

      // Afirmar
      Assert.assertEquals(expected, actual);
    }           
}

Você pode continuar criando testes como, por exemplo:

@Test    
public void multiply_FiftyTimesTwo_ReturnsOneHundred()  // multiplicar_CinquentaVezesDois_RetornaCem
{      
  // // Organizar
  final int expected = 100;        
  // // Agir
  final int actual = App.multiply(50, 2);        
  // // Afirmar
  Assert.assertEquals(actual, expected);    
}

Construir o projeto

mvn package

Saída:

[INFO] -------------------------------------------------------
[INFO]  T E S T S
[INFO] -------------------------------------------------------
[INFO] Running com.mycompany.app.AppTest
[INFO] Tests run: 3, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.026 s - in com.mycompany.app.AppTest
[INFO] 
[INFO] Results:
[INFO] 
[INFO] Tests run: 3, Failures: 0, Errors: 0, Skipped: 0

Testar e compilar o projeto

java -cp target/my-app-1.0-SNAPSHOT.jar com.mycompany.app.App

Saída:

6
Hello World!

Uma maneira alternativa de executar os testes é clicar em Run Test dentro de AppTest.java

No exemplo abaixo, Run Test está localizado logo abaixo da linha de código 44.

Nos comentários, "Arrange" (organizar), "Act" (agir) e Assert (afirmar)

Visualizar testes e relatório de teste

Migrando do JUnit 4 para o JUnit 5

Altere as dependências do seu pom.xml para:

  
      
          org.junit.jupiter
          junit-jupiter-api
          5.4.2
          test
      
      
          org.junit.jupiter
          junit-jupiter-engine
          5.4.2
          test

Altere seu AppTest.java para:

package com.mycompany.app;

import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.assertEquals;

import org.junit.jupiter.api.Test;

/** 
* Teste unitário para App simples. 
*/
public class AppTest 
{
    /**
    * Teste Rigoroso :-)
    */ 
    @Test
    public void shouldAnswerWithTrue() // deveResponderComVerdadeiro
    {
        assertTrue( true );
    }
    @Test
    public void add_TwoPlusTwo_ReturnsFour() { // adicionar_DoisMaisDois_RetornaQuatro
      // Organizar
      final int expected = 4;

      // Agir
      final int actual = App.add(2, 2);

      // Afirmar
      assertEquals(expected, actual);
    }    
    @Test
    public void multiply_FourTimesTwo_ReturnsEight() { // multiplicar_QuatroVezesDois_RetornaOito
      // Organizar
      final int expected = 8;

      // Agir
      final int actual = App.multiply(4, 2);

      // Afirmar
      assertEquals(expected, actual);
    }        

    @Test
    public void divide_TenDividedTwo_ReturnsFive() { // dividir_DezDivididoPorDois_RetornaCinco
      // Organizar
      final int expected = 5;

      // Agir
      final int actual = App.divide(10, 2);

      // Afirmar
      assertEquals(expected, actual);
    }           
}

Adicionando cobertura de teste

Verifique o relatório de cobertura de teste

No VSCode, abra o Extension MarketPlace e pesquise Coverage Gutters

Clique no botão Instalar (ou Install)

Abra o arquivo pom.xml na sua pasta raiz e substitua o conteúdo pelo pom.xml no GitHub para adicionar suporte a um plug-in.




  4.0.0

  com.mycompany.app
  my-app
  1.0-SNAPSHOT

  my-app
  
  http://www.exemplo.com

  
    UTF-8
    1.7
    1.7
  

  
    
        org.junit.jupiter
        junit-jupiter-api
        5.4.2
        test
    
    
        org.junit.jupiter
        junit-jupiter-engine
        5.4.2
        test
    
  


  
    
      
        
          org.jacoco
          jacoco-maven-plugin
          0.8.2
          
              
                  
                      prepare-agent
                  
              
              
                  report
                  prepare-package
                  
                      report
                  
              
          
        
        
        
          maven-clean-plugin
          3.1.0
        
        
        
          maven-resources-plugin
          3.0.2
        
        
          maven-compiler-plugin
          3.8.0
        
        
          maven-surefire-plugin
          2.22.1
        
        
          maven-jar-plugin
          3.0.2
        
        
          maven-install-plugin
          2.5.2
        
        
          maven-deploy-plugin
          2.8.2
        
        
        
          maven-site-plugin
          3.7.1
        
        
          maven-project-info-reports-plugin
          3.0.0

Abra o terminal no VSCode e execute

mvn install
mvn clean jacoco:prepare-agent install jacoco:report

Abra seu arquivo App.java na pasta main/java/com/mycompany/app e clique no botão Watch para verificar o relatório

Barra vermelha: código de teste não coberto

Barra amarela: condição não coberta

Barra verde: código coberto

Abra o arquivo index.html na sua pasta root/target/site/jacoco.

Para abrir:

Eme seguida, cole (Ctrl + V para Windows e Command + V para MacOS) o caminho no seu navegador.

Você pode ver um relatório de cobertura de teste muito detalhado:

Obrigado pela leitura! 😉

Construindo uma aplicação de CRUD simples com Express e MongoDB

Kris Lagerström — Sun, 04 Aug 2024 23:29:53 +0000

Artigo original: Building a Simple CRUD Application with Express and MongoDB

Escrito por: Zell Liew

Por muito tempo, não ousei me aventurar no desenvolvimento de back-end. Me sentia intimidado por causa da minha falta de formação acadêmica em programação.

Lembro-me de quando finalmente criei coragem para tentar o desenvolvimento de back-end. Tive tanta dificuldade em entender a documentação do Express, MongoDB e Node.js que desisti.

No fim, voltei e trabalhei para esclarecer minha confusão. Agora, um ano depois, entendi como trabalhar com essas ferramentas. Então, decidi escrever este tutorial abrangente para que você não precise passar pela mesma dor de cabeça que eu passei.

CRUD, Express e MongoDB

CRUD, Express e MongoDB são palavras grandes para uma pessoa que nunca tocou em programação do lado do servidor em sua vida. Vamos apresentar rapidamente o que elas são antes de mergulharmos no tutorial.

Express é um framework para construir aplicações para a web com base no Node.js. Ele simplifica o processo de criação do servidor que já está disponível no Node. Caso você esteja se perguntando: o Node permite que você use JavaScript como sua linguagem do lado do servidor.

MongoDB é um banco de dados. É no banco de dados que você armazena informações para seus sites (ou aplicações) para a web.

CRUD é uma abreviação em inglês para Criar, Ler, Atualizar e Excluir. É um conjunto de operações que fazemos para que os servidores as executem (POST, GET, PUT e DELETE, respectivamente). Isso é o que cada operação faz:

Criar (POST) — Criar algo
Ler (GET) — Obter algo
Atualizar (PUT) — Alterar algo
Excluir (DELETE)– Remover algo

Se colocarmos CRUD, Express e MongoDB juntos em um único diagrama, seria assim:

À direita, o navegador. Entre ele e o servidor, as operações de CRUD.

CRUD, Express e MongoDB fazem mais sentido para você agora?

Ótimo. Vamos em frente.

O que vamos construir

Vamos construir uma aplicação de lista simples que permite que você acompanhe as coisas dentro de uma lista (como uma Lista de Tarefas, por exemplo).

Bem, uma lista de tarefas é meio chata. Que tal fazermos uma lista de citações de personagens de Star Wars? Incrível, não é? Além disso, aqui é onde você pode encontrar o código finalizado para a aplicação.

A propósito, o que estamos construindo não é uma aplicação de página única atraente. Estamos focando principalmente em como usar o CRUD, o Express e Mongo DB neste tutorial. Serão, portanto, mais orientações de como criar o lado do servidor. Não vou enfatizar o estilo.

Você precisará de duas coisas para começar com este tutorial:

Você não deve ter medo de digitar comandos em um shell. Confira este artigo (em inglês) se estiver com medo.
Você precisa ter o Node instalado.

Para verificar se você tem o Node instalado, abra sua linha de comando e execute o seguinte código:

$ node -v

Você deve obter um número de versão se tiver o Node instalado. Se não tiver, você pode instalar o Node baixando o instalador do site do Node ou baixando-o por meio de gerenciadores de pacotes como Homebrew (Mac) e Chocolatey (Windows).

Começando

Comece criando uma pasta para este projeto. Sinta-se à vontade para chamá-la do que quiser. Depois de navegar até ela, execute o comando npm init.

Esse comando cria um arquivo package.json, que ajuda você a gerenciar as dependências que instalaremos mais tarde no tutorial.

$ npm init

Basta pressionar Enter em tudo o que aparecer. Falarei sobre o que você precisa saber à medida que avançamos.

Executando o Node pela primeira vez em sua vida

A maneira mais simples de usar o node é executar o comando node e especificar um caminho para um arquivo. Vamos criar um arquivo chamado server.js para executar o node.

$ touch server.js

Quando executarmos o arquivo server.js, queremos ter certeza de que ele está sendo executado corretamente. Para fazer isso, basta escrever uma instrução console.log no server.js:

console.log('Que o Node esteja com você')

Agora, execute node server.js em sua linha de comando e você deverá ver a instrução que você registrou:

Se você enxergar May Node be with you (Que o Node esteja com você), é sinal de que deu certo.

Ótimo. Vamos em frente e aprender como usar o Express agora.

Usando o Express

Primeiro, temos que instalar o Express antes de podermos usá-lo em nossa aplicação. Instalar o Express é muito fácil. Tudo o que temos que fazer é executar um comando de instalação com o gerenciador de pacotes do Node (npm), que vem junto com o Node.

Execute o comando npm install express --save em sua linha de comando:

$ npm install express --save

Depois de terminar, você deverá ver que o npm salvou o Express como uma dependência no package.json.

A versão da dependência será diferente, dependendo de quando você estiver lendo este artigo.

Em seguida, usamos o express em server.js exigindo-o.

const express = require('express');
const app = express();

A primeira coisa que queremos fazer é criar um servidor ao qual os navegadores possam se conectar. Podemos fazer isso com a ajuda de um método listen fornecido pelo Express:

app.listen(3000, function() {
	console.log('Escutando na porta 3000')
})

Agora, execute node server.js e navegue até localhost:3000 em seu navegador. Você deverá ver uma mensagem que diz Cannot get /.

Isso é um bom sinal. Significa que agora podemos nos comunicar com nosso servidor do Express através do navegador. É aqui que começamos as operações CRUD.

CRUD — LER

A operação LER é realizada pelos navegadores sempre que você visita uma página da web. Nos bastidores, os navegadores enviam uma solicitação GET ao servidor para realizar uma operação de LEITURA. O motivo pelo qual vemos o erro "Cannot get /" é porque ainda não enviamos nada de volta ao navegador do nosso servidor.

No Express, lidamos com uma solicitação GET com o método get:

app.get(caminho, callback)

O primeiro argumento, caminho, é o caminho da solicitação GET. É qualquer coisa que vem depois do nome de domínio.

Quando estamos visitando localhost:3000, nossos navegadores estão, na verdade, procurando por localhost:3000/. O argumento caminho, neste caso, é /.

O segundo argumento é uma função de callback que informa ao servidor o que fazer quando o caminho é correspondido. Ele recebe dois argumentos, um objeto de solicitação e um objeto de resposta:

app.get('/', function (request, response) {
  // faça algo aqui
})

Por enquanto, vamos escrever "Olá Mundo" de volta para o navegador. Fazemos isso usando um método send que vem com o objeto de resposta:

app.get('/', function(req, res) {
  res.send('Olá Mundo')
}) // Observação: solicitação e resposta são geralmente escritas como req e res, respectivamente.

Vou começar a escrever em código ES6 e mostrar como converter para ES6 ao longo do caminho também. Primeiro, estou substituindo o function() pela arrow function, da ES6. O código abaixo é o mesmo que o código acima:

app.get('/', (req, res) => {
  res.send('Olá mundo')
})

Agora, reinicie seu servidor fazendo o seguinte:

Pare o servidor atual pressionando CTRL + C na linha de comando.
Execute node server.js novamente.

Em seguida, navegue até localhost:3000 em seu navegador. Você deverá ver uma string que diz "Hello World" (Olá Mundo).

Ótimo. Vamos mudar nossa aplicação para que sirva uma página index.html de volta para o navegador. Para fazer isso, usamos o método sendFile que é fornecido pelo objeto res.

app.get('/', (req, res) => {
  res.sendFile(__dirname + '/index.html')
}) // Observação: __dirname é o caminho para o seu diretório de trabalho atual. Tente registrá-lo e veja o que você obtém! O meu era '/Users/zellwk/Projects/demo-repos/crud-express-mongo' para esta aplicação.

No método sendFile() acima, dissemos ao Express para servir um arquivo index.html que pode ser encontrado na raiz da pasta do seu projeto. Ainda não temos esse arquivo. Vamos criá-lo agora.

touch index.html

Vamos colocar algum texto em nosso arquivo index.html também:



	
	  
	  MEU APP
	
	
		Que o Node e o Express estejam com você.

Reinicie seu servidor e atualize seu navegador. Você deverá ver os resultados do seu arquivo HTML agora.

Você deve ver May Node and Express be with you/Que o Node e o Express estejam com você!

É assim que o Express lida com uma solicitação GET (operação LER) em poucas palavras.

Neste ponto, você provavelmente percebeu que precisa reiniciar seu servidor sempre que fizer uma alteração em server.js. Esse processo é incrivelmente tedioso. Por isso, vamos fazer um pequeno desvio e otimizá-lo usando um pacote chamado nodemon.

Apresentando o Nodemon

O Nodemon reinicia o servidor automaticamente sempre que você salva um arquivo que o servidor usa. Podemos instalar o Nodemon usando o seguinte comando:

$ npm install nodemon --save-dev

Observação: o motivo pelo qual estamos usando uma flag --save-dev aqui é porque estamos usando o Nodemon apenas quando estamos desenvolvendo. Essa flag salvaria o Nodemon como uma devDependency em seu arquivo package.json.

Continuando, o Nodemon se comporta exatamente da mesma maneira que o node, o que significa que podemos executar nosso servidor chamando nodemon server.js. No entanto, não podemos fazer isso na linha de comando agora porque o Nodemon não está instalado com uma flag -g.

Há outra maneira de executar o Nodemon — podemos executá-lo a partir da pasta node_modules. O código se parece com isto:

$ ./node_modules/.bin/nodemon server.js

Isso é muito para digitar. Uma maneira de simplificar é criar uma chave de script em package.json.

{  
	// ...
   "scripts": {
		"dev": "nodemon server.js"
	}
    // ...
}

Agora, você pode executar npm run dev para acionar nodemon server.js.

De volta ao tópico principal. Vamos cobrir a operação CRIAR em seguida.

CRUD — CRIAR

A operação CRIAR é realizada apenas pelo navegador se uma solicitação POST for enviada ao servidor. Essa solicitação POST pode ser acionada com JavaScript ou por meio de um elemento

Vamos descobrir como usar um elemento para criar entradas para nossa aplicação de citações de Star Wars para esta parte do tutorial.

Para fazer isso, você primeiro precisa criar um elemento e adicioná-lo ao seu arquivo index.html. Você precisa ter três coisas nesse elemento de formulário:

Um atributo action
Um atributo method
Atributos name em todos os elementos dentro do formulário

O atributo action informa ao navegador para onde navegar em nossa aplicação Express. Neste caso, estamos navegando para /quotes. O atributo method informa ao navegador qual solicitação enviar. Neste caso, é uma solicitação POST.

Em nosso servidor, podemos lidar com essa solicitação POST com um método post que o Express fornece. Ele recebe os mesmos argumentos que o método GET:

app.post('/quotes', (req, res) => {  console.log('Oláááááááááááááá!')})

Reinicie seu servidor (espero que você tenha configurado o Nodemon para que ele reinicie automaticamente) e atualize seu navegador. Em seguida, insira algo em seu elemento de formulário. Você deverá ver Oláááááááááááááá! em sua linha de comando.

Você deverá ver Helloooooooooooooooo! ou Oláááááááááá

Ótimo, sabemos que o Express está lidando com o formulário para nós agora. A próxima pergunta é: como obtemos os valores de entrada com o Express?

Acontece que o Express não lida com a leitura de dados do elemento

por conta própria. Temos que adicionar outro pacote chamado body-parser para obter essa funcionalidade.

$ npm install body-parser --save

O Express nos permite adicionar middlewares como body-parser à nossa aplicação com o método use. Você ouvirá muito o termo middleware ao lidar com o Express. Essas coisas são basicamente plug-ins que alteram o objeto de solicitação ou resposta antes que eles sejam tratados por nossa aplicação. Certifique-se de colocar o body-parser antes de seus manipuladores CRUD!

const express = require('express')
const bodyParser= require('body-parser')
const app = express()
app.use(bodyParser.urlencoded({extended: true}))
// Todos os outros manipuladores aqui...

O método urlencoded dentro do body-parser informa ao body-parser para extrair dados do elemento e adicioná-los à propriedade body no objeto de solicitação.

Nota da tradução: nas versões mais recentes, é possível usar express.json no lugar de body-parser para fazer o parsing do documento, tornando desnecessária a requisição deste último.

Agora, você deverá ver tudo no campo do formulário dentro do objeto req.body. Tente fazer um console.log e veja o que é!

app.post('/quotes', (req, res) => {
  console.log(req.body)
})

Você deverá obter um objeto semelhante ao seguinte em sua linha de comando:

Hmmm. Mestre Yoda falou! Vamos garantir que nos lembremos das palavras de Yoda. É importante. Queremos poder recuperá-las na próxima vez que carregarmos nossa página inicial.

É aqui que entra o banco de dados, o MongoDB.

MongoDB

Primeiro, temos que instalar o MongoDB através do npm se quisermos usá-lo como nosso banco de dados.

npm install mongodb --save

Depois de instalado, podemos nos conectar ao MongoDB através do método connect do Mongo.Client, conforme mostrado no código abaixo:

const MongoClient = require('mongodb').MongoClient

MongoClient.connect('link-para-o-mongodb', (err, database) => {
  // ... inicie o servidor
})

A próxima parte é obter o link correto para nosso banco de dados. A maioria das pessoas armazenam seus bancos de dados em serviços em nuvem como o MongoLab. Faremos o mesmo também.

Então, vá em frente e crie uma conta no MongoLab. (É grátis). Depois de terminar, crie uma nova implantação do MongoDB e defina o plano como sandbox.

Depois de terminar de criar a implantação, vá até ela e crie um usuário de banco de dados e uma senha de banco de dados. Lembre-se do usuário e da senha do banco de dados porque você os usará para conectar o banco de dados que acabou de criar.

Finalmente, pegue o URL do MongoDB e adicione-a ao seu método MongoClient.connect. Certifique-se de usar seu usuário e senha do banco de dados!

MongoClient.connect('seu-url-do-mongodb', (err, database) => {
  // ... faça algo aqui
})

Em seguida, queremos iniciar nossos servidores apenas quando o banco de dados estiver conectado. Portanto, vamos mover app.listen para dentro do método connect(). Também vamos criar uma variável db para nos permitir usar o banco de dados quando lidarmos com solicitações do navegador.

var db

MongoClient.connect('sua-url-do-mongodb', (err, database) => {
  if (err) return console.log(err)
  db = database  
  app.listen(3000, () => {
    console.log('escutando na porta 3000')
  })
})

Terminamos de configurar o MongoDB. Agora, vamos criar uma coleção de citações para armazenar citações para nossa aplicação.

A propósito, uma coleção é um local nomeado para armazenar coisas. Você pode criar quantas coleções quiser. Podem ser coisas como "produtos", "citações", "mantimentos" ou quaisquer outros rótulos que você escolher.

Podemos criar a coleção de citações usando a string quotes ao chamar o método db.collection() do MongoDB. Ao criar a coleção de citações, também podemos salvar nossa primeira entrada no MongoDB com o método save simultaneamente.

Depois de terminarmos de salvar, temos que redirecionar o usuário para algum lugar (ou ele ficará preso esperando para sempre que nosso servidor se mova). Nesse caso, vamos redirecioná-los de volta para /, o que faz com que seus navegadores recarreguem.

app.post('/quotes', (req, res) => {
  db.collection('quotes').save(req.body, (err, result) => {
    if (err) return console.log(err)
    console.log('salvo no banco de dados')
    res.redirect('/')
    })
})

Agora, se você inserir algo no elemento, poderá ver uma entrada em sua coleção do MongoDB.

Uhuuu! Já que já temos algumas citações na coleção, por que não tentar mostrá-las ao nosso usuário quando ele acessar nossa página?

Mostrando citações aos usuários

Temos que fazer duas coisas para mostrar as citações armazenadas no MongoLab aos nossos usuários.

Obter citações do MongoLab
Usar um mecanismo de template para exibir as citações

Vamos passo a passo.

Podemos obter as citações do MongoLab usando o método find que está disponível no método collection.

app.get('/', (req, res) => {
	var cursor = db.collection('quotes').find()
})

O método find retorna um cursor (um objeto do Mongo) que provavelmente não faz sentido se você fizer console.log dele.

A boa notícia é que esse objeto cursor contém todas as citações do nosso banco de dados. Ele também contém várias outras propriedades e métodos que nos permitem trabalhar com dados facilmente. Um desses métodos é o método toArray().

O método toArray recebe uma função de callback que nos permite fazer coisas com as citações que recuperamos do MongoLab. Vamos tentar fazer um console.log() para os resultados e ver o que obtemos!

db.collection('quotes').find().toArray(function(err, results) {
	console.log(results)  // enviar arquivo HTML preenchido com citações aqui
})

Ótimo! Agora, você vê um array de citações (eu só tenho uma agora). Concluímos a primeira parte — obter dados do MongoLab. A próxima parte é gerar um HTML que contenha todas as nossas citações.

Não podemos servir nosso arquivo index.html e esperar que as citações apareçam magicamente porque não há como adicionar conteúdo dinâmico a um arquivo HTML. O que podemos fazer em vez disso é usar mecanismos de template para nos ajudar. Alguns mecanismos de template populares incluem Jade, Embedded JavaScript e Nunjucks.

Escrevi extensivamente sobre o como e o porquê dos mecanismos de template em uma artigo separado (em inglês). Você pode querer dar uma olhada se não tiver ideia do que são mecanismos de template. Eu pessoalmente uso (e recomendo) Nunjucks como meu mecanismo de template de escolha. Sinta-se à vontade para conferir o artigo para descobrir o porquê.

Para este tutorial, vamos usar Embedded JavaScript - ejs como nosso mecanismo de template porque é o mais fácil para começar. Você o achará familiar desde o início, pois já conhece HTML e JavaScript.

Podemos usar o EJS primeiro instalando-o e, em seguida, definindo o mecanismo de visualização no Express como ejs.

$ npm install ejs --save

app.set('view engine', 'ejs')

Depois que o mecanismo de visualização for definido, podemos começar a gerar o HTML com nossas citações. Esse processo também é chamado de renderização. Podemos usar o objeto render integrado ao objeto de resposta render para fazer isso. Ele tem a seguinte sintaxe:

res.render(view, locals)

O primeiro parâmetro, views, é o nome do arquivo que estamos renderizando. Esse arquivo deve ser colocado dentro de uma pasta views.

O segundo parâmetro, locals, é um objeto que passa dados para a visualização.

Vamos primeiro criar um arquivo index.ejs dentro da pasta views para que possamos começar a preencher os dados.

$ mkdir views$ touch views/index.ejs

Agora, coloque o seguinte código dentro de index.ejs.


	<% for(var i=0; i
		
      		<%= quotes[i].name %>
      		<%= quotes[i].quote %>
    	
	<% } %>

Viu o que eu quis dizer quando disse que você o acharia familiar? No EJS, você pode escrever JavaScript dentro de tags <% e %>. Você também pode gerar JavaScript como strings se usar as tags <%= e %>.

Aqui, você pode ver que estamos basicamente percorrendo o array quotes e criando strings com quotes[i].name e quotes[i].quote.

Mais uma coisa a fazer antes de prosseguirmos com o arquivo index.ejs. Lembre-se de copiar o elemento do arquivo index.html para esse arquivo também. O arquivo index.ejs completo até agora deve ser:



	
    	
        MEU APP
    
    
    	Que o Node e o Express estejam com você.
        
        	<% for(var i=0; i
            	
                	<%= quotes[i].name %>
                    <%= quotes[i].quote %>
                
            <% } %>

Finalmente, temos que renderizar esse arquivo index.ejs ao lidar com a solicitação GET. Aqui, estamos definindo os resultados (um array) como o array quotes que usamos em index.ejs acima.

app.get('/', (req, res) => {
	db.collection('quotes').find().toArray((err, result) => {
    	if (err) return console.log(err)    // renderiza index.ejs
        res.render('index.ejs', {quotes: result})
    })
})

Agora, atualize seu navegador e você deverá ver as citações do Mestre Yoda.

Ah, você pode ter apenas uma citação se seguiu o tutorial passo a passo até esse ponto. O motivo pelo qual tenho várias citações é porque adicionei mais silenciosamente enquanto trabalhava na aplicação.

Conclusão

Cobrimos muito terreno em apenas 3 mil palavras! Aqui estão alguns marcadores para resumir tudo. Você...

Criou um servidor Express
Aprendeu a executar operações CRIAR (CREATE) e LER (READ)
Aprendeu a salvar e ler no MongoDB
Aprendeu a usar um mecanismo de template como o Embedded JS.

Este artigo apareceu pela primeira vez no blog do autor (em inglês). Confira o blog se quiser ver mais artigos como este.

O que é uma API e como ela funciona? APIs para iniciantes

Kris Lagerström — Mon, 29 Jul 2024 12:49:00 +0000

Artigo original: What is an API and How Does it Work? APIs for Beginners

Quando comecei a aprender a programar, o termo API sempre me assombrava. Eu não conseguia entender o que realmente significava porque ouvia as pessoas falando sobre APIs em diferentes contextos.

O maior desafio era que eu não conseguia encontrar recursos para aprender sobre APIs em termos simples.

Agora que sei como as APIs funcionam, decidi escrever este guia para qualquer iniciante que tenha dificuldade para entender esse tópico que não é tão complicado, mas que ainda é confuso, em desenvolvimento para a web e em engenharia de software.

O que é uma API?

API significa Interface de Programação de Aplicações. A aplicação pode ser qualquer software que execute uma tarefa específica e a interface é um ponto onde duas aplicações se comunicam.

Uma aplicação atua como client e o outro atua como servidor. Um client solicita algum recurso (por exemplo, uma foto) e o servidor envia essa foto para o client.

O client, aqui, pode ser seu celular, computador desktop ou laptop ou qualquer dispositivo que você usa para navegar na internet. O servidor é um computador maior, que armazena os dados que você deseja (uma foto, no nosso caso).

Suponha que eu queira uma fotografia da natureza para enviar para meu blog de viagens. Eu posso ir ao site do Unsplash, digitar "natureza" na barra de pesquisa e ele retornará um grande número de fotografias da natureza.

Essa é uma API trabalhando nos bastidores para fazer a conversa entre o Unsplash e eu acontecer.

Como as APIs funcionam?

Os computadores seguem um protocolo para se comunicar uns com os outros. Um protocolo nada mais é do que um conjunto de regras que os computadores seguem para se comunicar. Qualquer computador que não siga o protocolo quebra o fio da comunicação.

Você pode ter usado Bluetooth para compartilhar dados no passado. Bluetooth nada mais é do que um protocolo para dispositivos móveis se comunicarem entre eles a uma distância menor.

Quando você pede ao seu amigo para enviar fotos de sua última viagem, seu dispositivo atua como client e o dispositivo do seu amigo (aquele que envia as fotos) é o servidor.

Esse é apenas um exemplo de protocolo. Temos um grande número de protocolos no mundo da ciência da computação – um para quase tudo.

Na web, usamos o protocolo HTTP (em inglês, Hyper Text Transfer Protocol). As APIs disponíveis na web usam o protocolo HTTP por vários motivos – é fácil de usar e é popular, por exemplo.

As comunicações que ocorrem pelo protocolo HTTP também são conhecidas como ciclo de solicitação-resposta porque é exatamente assim que o protocolo funciona. O client envia uma solicitação ao servidor e o servidor responde ao client em relação a essa solicitação.

Ao contrário dos humanos, os computadores precisam ser rígidos para se comunicarem uns com os outros ou eles quebram a comunicação. Por esse motivo, um client (computador/dispositivo solicitante) precisa de um conjunto de informações para enviar com a solicitação para que o servidor responda de acordo. Essas informações incluem:

URL – um endereço da web onde você deseja fazer uma solicitação
Método – se você deseja dados já armazenados em algum lugar ou deseja salvar novos dados em um banco de dados
Cabeçalho – todas as informações relevantes sobre sua solicitação, incluindo em qual formato o dispositivo client espera receber os dados
Corpo – os dados reais da solicitação

No nosso exemplo do Unsplash, o URL é https://unsplash.com/s/photos/nature. O método é GET, porque queremos que o servidor recupere imagens da natureza. O cabeçalho inclui informações como o formato que nosso computador espera obter e aceitar – como o idioma, o idioma do dispositivo, nosso sistema operacional e assim por diante. O corpo inclui os dados que precisamos enviar ao servidor (a palavra-chave natureza, por exemplo).

Existem quatro tipos de métodos para solicitações HTTP que abordaremos em breve. Por enquanto, saiba apenas que um método indica o que você deseja fazer com os dados disponíveis no servidor. Por exemplo, se você deseja esses dados como documentos ou se deseja salvar uma nova entrada em dados salvos em algum lugar.

Quando um client faz uma solicitação, o servidor responde a essa solicitação. A resposta pode ser os dados que o client solicitou ou um erro.

Assim como uma resposta, uma solicitação tem uma estrutura que inclui URL, código de status, cabeçalho e corpo. Em uma solicitação, temos um método, que possui quatro tipos. Na resposta, temos um código de status, que indica se uma solicitação foi aceita ou recusada.

Métodos HTTP

Existem quatro métodos HTTP disponíveis e cada um tem sua funcionalidade exclusiva.

GET: como já discutido, indica que o client está solicitando que os dados sejam enviados do servidor.
POST: esse método informa ao servidor que o client deseja criar uma entrada em um banco de dados. Por exemplo, salvar uma nova postagem em um blog em um banco de dados de todos os blogs anteriores.
DELETE: como o nome em inglês sugere, o client deseja excluir um registro de dados de um banco de dados.
PUT: esse método é usado quando um client deseja atualizar ou editar um registro de dados. Por exemplo, alterar sua senha do Facebook.

Códigos de status HTTP

Existe uma lista enorme de códigos de status HTTP, mas vamos dar uma olhada em alguns dos mais comuns:

200 OK: indica que a solicitação foi atendida com sucesso pelo servidor
201 CREATED: a entrada de dados cuja criação você solicitou foi criada
404 NOT FOUND: indica que o recurso que você solicitou não foi encontrado pelo servidor
500 INTERNAL SERVER ERROR: significa que ocorreu um erro no lado do servidor e que ele não pôde atender à sua solicitação

Não há necessidade de memorizar esses códigos de status, pois a lista é enorme e você os aprenderá inconscientemente à medida que os encontrar em sua jornada de desenvolvimento.

Ainda assim, existem vários códigos de status que indicam uma resposta genérica, como você pode ver aqui:

100s: respostas informativas, indicando o progresso da solicitação
200s: sucesso, indicando o sucesso da solicitação
300s: redirecionamento, indicando que a solicitação teve que ser redirecionada para outro lugar
400s: erros do client, indicando erros que ocorreram no lado do client
500s: erros do servidor, quando o servidor falha ao responder a uma solicitação válida do client

Tipos de APIs

Você se lembra quando eu disse que ficava confusa quando as pessoas falavam sobre APIs em diferentes contextos? Isso ocorre porque também temos diferentes tipos de APIs disponíveis.

As que falamos neste artigo são APIs da web que usam o protocolo HTTP. Os desenvolvedores podem usá-las para criar uma melhor experiência do usuário para seus usuários.

Outros tipos incluem as APIs internas, que estão ocultas de usuários externos e que são usadas apenas dentro de uma empresa.

Existem também APIs abertas, que estão disponíveis para serem usadas por qualquer pessoa gratuitamente (como a OpenWeatherMap API, a API de mapa meteorológico aberto). Você pode ter APIs de parceiros, que são compartilhadas apenas entre parceiros de negócios para realizar suas tarefas de negócios e APIs compostas, que combinam sequencialmente várias solicitações de API em uma única chamada de API para reduzir a carga do servidor e criar uma experiência mais rápida.

Recursos para aprender mais sobre APIs:

Se você quiser aprender mais sobre a criação de APIs, aqui há um texto para começar (em inglês).

Aqui está um tutorial sobre tipos de APIs, ferramentas de testes e documentação (em inglês).

Aqui está uma ficha informativa sobre a Fetch API (em inglês), para você começar a aprender mais sobre ela.

Conclusão

Uma API é uma interface para dois computadores se comunicarem para realizar tarefas na internet.

As APIs da web seguem o protocolo HTTP para se comunicarem. Esse protocolo possui uma estrutura específica de solicitação e resposta.

Existem diferentes métodos para realizar diferentes tarefas e vários códigos de status estão disponíveis. Eles indicam se a solicitação foi bem-sucedida, recusada ou está em estado pendente.

Interessado em se conectar pelo LinkedIn? Fale com a autora por lá.

A grande competição entre os termos usados em programação

Kris Lagerström — Sun, 28 Jul 2024 21:00:00 +0000

Artigo original: The Great Programming Jargon Bake-off

Escrito por: Preethi Kasireddy

Imperativo x Declarativo, Puro x Impuro, Estático x Dinâmico.

Terminologias como essas são salpicadas por várias publicações em blogs de programação, palestras em conferências, artigos e livros didáticos.

Porém, você não deve se deixar intimidar por esse vocabulário. Vamos examinar e desvendar alguns desses conceitos para que você possa entender sobre o que todos esses desenvolvedores ao seu redor estão falando.

Tipagem estática x dinâmica

Isso se trata de quando a informação de tipo é adquirida — seja no momento da compilação ou em tempo de execução.

Você pode usar essa informação de tipo para detectar erros de tipo. Um erro de tipo ocorre quando um valor não é do tipo esperado.

Verificação de tipo estática

É o processo de verificar a segurança de tipo de um programa com base na análise do código-fonte do programa. Em outras palavras, a verificação de tipo ocorre no momento da compilação, permitindo que erros de tipo sejam detectados mais cedo.

À direita: os tipos de x e y são verificados no momento da compilação para garantir que as duas variáveis são do tipo int/Abaixo: quando você instancia a classe Point, os tipos de x e de y são verificados no momento da compilação para garantir que são do tipo int

Verificação de tipo dinâmica

O processo de verificar a segurança de tipo de um programa em tempo de execução. Com a verificação de tipo dinâmica, os erros de tipo ocorrem em tempo de execução.

À direita: os tipos de x e y são determinados no momento da execução/Abaixo: quando você instancia a classe Point, os tipos de x e de y não são verificados. Se você passar um valor de string para y, o programa o aceitará (e pode lançar um erro de tempo de execução se y for usado indevidamente)

Tipagem forte x fraca

É importante observar que forte x fraca não tem um significado técnico sobre o qual todos universalmente concordam. Por exemplo, mesmo que Java seja tipado estaticamente, toda vez que você usa reflexão ou cast, você está adiando a verificação de tipo para a execução.

Da mesma maneira, a maioria das linguagens fortemente tipadas ainda converterá automaticamente entre inteiros e ponto flutuante. Portanto, você deve evitar usar esses termos porque chamar um sistema de tipagem "forte" ou "fraca", por si só, não diz muito.

Tipagem forte

Em uma linguagem fortemente tipada, o tipo de uma construção não muda — um int é sempre um int e tentar usá-lo como uma string resultará em um erro.

Tipagem fraca

Tipagem fraco significa que o tipo de uma construção pode mudar dependendo do contexto. Por exemplo, em uma linguagem de tipagem fraca, a string "123" pode ser tratada como o número 123 se você adicionar outro número a ela.

Isso geralmente significa que o sistema de tipos pode ser subvertido (invalidando quaisquer garantias) porque você pode converter um valor de um tipo para outro.

Adicionar a string "4" à soma de 4 + 4 = 8 resulta na string "8" + "4" = "84". Assim, adicionar a string a um número causou o casting (a conversão) do número 8 para uma string.

Dados mutáveis x imutáveis

Dados imutáveis

Quando um objeto não pode ser modificado após sua criação, você pode dizer que ele é "imutável", que é outro modo de dizer "inalterável". Isso significa que você alocará um novo valor para cada alteração.

Dados mutáveis

Quando você pode modificar um objeto após sua criação, ele é "mutável". Quando você tem uma referência a um objeto mutável, por exemplo, o conteúdo do objeto pode mudar.

A variável person é mutável. Assim, podemos atualizar a propriedade age (idade)

Funções puras x impuras

Funções puras

Uma função pura tem duas qualidades:

Ela depende apenas da entrada fornecida — e não de nenhum estado externo que possa mudar durante sua avaliação ou entre chamadas.
Ela não causa nenhum efeito colateral semanticamente observável, como modificar um objeto global ou um parâmetro passado por referência.

A função depende somente das variáveis passadas explicitamente a ela, não alterando estados externos nem os argumentos passados a ela

Funções impuras

Qualquer função que não atenda a esses dois requisitos para uma função pura é "impura".

A função depende da variável global PI e altera o argumento de entrada radii

Avaliação lenta x avaliação rápida

Avaliação lenta

A avaliação lenta não avalia os argumentos da função a menos que seus valores sejam necessários para avaliar a própria chamada da função.

Em outras palavras, as expressões são avaliadas apenas quando ocorre a avaliação de outra expressão que depende da expressão atual.

A versão lenta das avaliações permite que os programas calculem estruturas de dados que são potencialmente infinitas sem travar.

Acima: vamos supor que temos uma função que filtra todos os números ímpares de 1 até o infinito e recebe os dez primeiros elementos/Abaixo: com a avaliação lenta, isso não é executado até que a operação que depende disso, take, é chamada.

Avaliação rápida

A avaliação ávida — também conhecida como avaliação estrita — sempre avalia completamente os argumentos da função antes de invocar a função. Em outras palavras, uma expressão é avaliada assim que é vinculada a uma variável.

Com a avaliação rápida, a função range tentará executar por inteiro antes de enviar seu resultado a take, o que leva a um loop infinito.

Declarativo x imperativo

Programação declarativa

Programas declarativos expressam um conjunto de operações sem revelar como são implementadas ou como os dados fluem através delas. Eles se concentram em "o que" o programa deve realizar (usando expressões para descrever a lógica) em vez de "como" o programa deve alcançar o resultado.

Um exemplo de programação declarativa é o SQL. As consultas SQL são compostas por instruções que descrevem como deve ser o resultado de uma consulta, enquanto abstraem o processo interno de como os dados são recuperados:

SELECT EMP_ID, FIRST_NAME, LAST_NAMEFROM EMPLOYEES WHERE CITY = ‘SAN FRANCISCO’ ORDER BY EMP_ID;

Aqui está um exemplo de código declarativo:

Usa funções de ordem superior para expressar o que o programa faz, não como o faz.

Programação imperativa

A programação imperativa concentra-se em descrever como um programa deve alcançar um resultado usando instruções que especificam o fluxo de controle ou alterações de estado. Ela usa uma sequência de instruções para calcular um resultado.

Aqui está um exemplo de código imperativo:

Informa ao programa como executar a tareda usando loops e instruções if-else

Com estado x sem estado

Um estado (em inglês, state) é uma sequência de valores calculados progressivamente, que contém os resultados intermediários de um cálculo.

Com estado

Programas com estado (do inglês., stateful) têm algum mecanismo para acompanhar e atualizar o estado. Eles têm alguma memória do passado e lembram transações anteriores que podem afetar a transação atual.

Essa função tem conhecimento do passado. Ela sabe o valor da variável count.

Sem estado

Programas sem estado (do inglês, stateless), por outro lado, não acompanham o estado. Não há memória do passado. Cada transação é realizada como se estivesse sendo feita pela primeira vez. Programas stateless darão a mesma resposta para o mesmo pedido, função ou chamada de método — todas as vezes.

Essa função não tem conhecimento do passado. A variável count é passada como um parâmetro e a função simplesmente retorna um resultado a partir daquilo que é passado para ela.

Funcional x orientada a objetos

Funcional

A programação funcional é um paradigma que enfatiza o uso de funções. O objetivo da programação funcional é usar funções para abstrair fluxos de controle e operações em dados, evitando efeitos colaterais.

Então, a programação funcional usa funções puras e evita dados mutáveis, o que, por sua vez, fornece transparência referencial.

Uma função tem transparência referencial quando você pode substituir livremente uma expressão por seu valor e não mudar o comportamento do programa. Dito de um modo um pouco diferente: para uma determinada entrada, ele sempre retorna os mesmos resultados.

Alguns exemplos de linguagens que enfatizam a programação funcional incluem Haskell, Lisp, Clojure e Elm. Você pode, contudo, usar conceitos de programação funcional na maioria das linguagens, incluindo em JavaScript.

Orientada a objetos

O paradigma de programação orientada a objetos enfatiza o uso de objetos. Isso resulta em programas que são feitos de objetos que interagem entre si. Esses objetos podem conter dados (na forma de campos ou atributos) e comportamento (na forma de métodos).

É um estilo de particionamento (ou encapsulamento) do estado de um programa através de objetos para tornar a análise do efeito das mudanças tratável [1].

Além disso, programas orientados a objetos usam herança e/ou composição como seus principais mecanismos para reutilização de código. Herança significa que uma nova classe pode ser definida em termos de classes existentes especificando apenas como a nova classe é diferente. Representa um relacionamento "é um" (por exemplo, uma classe Pássaro que estende uma classe Animal). A composição, por outro lado, é quando as classes contêm instâncias de outras classes que implementam a funcionalidade desejada. Representa um relacionamento "tem um" (por exemplo, uma classe Pássaro tem uma instância de uma classe Asa como membro).

O polimorfismo também é um mecanismo importante para a reutilização de código na programação orientada a objetos. É quando uma linguagem pode processar objetos de maneira diferente dependendo de seu tipo de dados ou classe.

Alguns exemplos de linguagens que enfatizam a programação orientada a objetos incluem Java, C++, Ruby. Novamente, você pode aplicar esses conceitos na maioria das linguagens, incluindo em JavaScript.

Comentários em ordem (de cima para baixo): Métodos de instâncias usam "this" para acessar os dados do objeto/Herança/Dados mutáveis

Determinístico x não determinístico

Determinístico

Programas determinísticos sempre retornam o mesmo resultado sempre que são chamados com um conjunto específico de valores de entrada e o mesmo estado fornecido.

Não importa o número de vezes que invocarmos a função add, os resultados sempre serão os mesmos.

Não determinístico

Programas não determinísticos podem retornar resultados diferentes cada vez que são chamados, mesmo com o mesmo conjunto específico de valores de entrada e estado inicial.

O não determinismo é uma propriedade de qualquer sistema concorrente — ou seja, qualquer sistema em que várias tarefas podem acontecer ao mesmo tempo, executando em diferentes threads. Um algoritmo concorrente que está alterando o estado pode se comportar de maneira diferente a cada vez, dependendo de qual thread o agendador decidir executar.

Por exemplo:

declare Xthread X=1 endthread X=2 end

A ordem de execução das duas threads não é fixa. Não sabemos se X será vinculado a 1 ou 2. O sistema escolherá durante a execução do programa, sendo livre para escolher qual thread executar primeiro.

Outro exemplo de não determinismo:

Temos dois resultados possíveis para os valores resultantes de a e de b, dependendo de qual chamada de API é retornada primeiro./Se a primeira chamada de API retorna antes da segunda, foo será invocada antes de bar, a será 15 e b será 3. Caso contrário, a será 13 e b será 2.

Conclusão

Como sempre, seu feedback e sua contribuição são realmente importantes para mim. Você também pode conferir a apresentação do Prezi que criei para este artigo.

[1] Um agradecimento especial a Kent Beck por sua contribuição para este artigo.

Já programamos há milhares de anos

Kris Lagerström — Fri, 26 Jul 2024 00:59:59 +0000

Artigo original: We have been programming for thousands of years

Escrito por: Tautvilas Mečinskas

Programas de computador estão por toda parte. Interagimos com eles todos os dias. Parece que os softwares estão se tornando cada vez mais importantes para a nossa sociedade. Por que, no entanto, achamos os programas tão necessários? Por que e quando começamos a programar? Qual é a essência da programação? Essas perguntas podem parecer triviais, mas sinto que hoje ainda não temos uma boa definição do que é programação. Talvez este artigo possa ajudar a mudar isso.

É bastante difícil definir programação porque ela é muito diversa. Pode-se programar jogos, aplicações para dispositivos móveis, sites, compiladores, simulações e muito mais. Nesse caso, pode ser útil começar eliminando algumas ideias preconcebidas e esclarecer o que a programação não é.

Programação não é ciência. A ciência é a arte de examinar o mundo e descobrir padrões repetitivos nele. O método científico consiste em fazer uma hipótese e, em seguida, realizar experimentos para provar ou rejeitá-la. Não usamos esse método na programação – portanto, não é ciência. A programação não se trata de descoberta, mas de criatividade.

Programação não é matemática. Sim, há um aspecto matemático na programação. Algumas partes dos programas podem ser expressas como funções matemáticas. Escrever um gerador de números de Fibonacci é divertido, mas completamente inútil sem uma aplicação no mundo real. A matemática na programação é um meio para um fim, não uma parte central do processo.

Programação não se trata de computadores eletrônicos. Computadores são muito úteis, mas não são necessários. Os programas podem ser entendidos e interpretados por seres humanos também. Portanto, os computadores são apenas ferramentas que usamos na programação.

Então, do que se trata a programação? O que se encontra dentro de todo programa, seja ele ou pequeno?

Abstrações.

O que é abstração? É uma imagem reduzida do mundo. Ao abstrair, estamos convertendo a realidade em símbolos que podem ser transmitidos como informação. A palavra abstração origina-se de duas palavras latinas, que são abs, que significa longe de e trahere, que significa desenhar. A tradução latina sugere que abstrair implica separar algo do todo.

O processo de abstração é único da programação? De fato, não. É algo que os humanos fazem há bastante tempo. Nossas ferramentas de abstração mais básicas são o mapa e o relógio.

Arqueólogos descobriram mapas de pedra que os humanos fizeram há mais de 14 mil anos. Isso mostra que a cartografia é fundamental para os humanos. É um processo de transformar território em símbolos abstratos. Um mapa é um modo de abstrair o espaço. É uma ferramenta que nos ajuda a fazer sentido do território ao nosso redor para que a navegação seja mais fácil.

Um relógio, por outro lado, é um modo de abstrair o tempo. Achamos a natureza contínua do tempo confusa. Por isso, a abstraímos. Os humanos dividem o tempo em intervalos discretos: anos, meses, dias, horas, minutos, segundos. Enquanto um mapa nos ajuda a navegar no espaço, um relógio nos ajuda a navegar no tempo. O predecessor do relógio - o calendário - surgiu há mais de 10 mil anos.

O gigante calendário solar de Chankillo foi construído há 2.300 anos.

Já aos computadores são ferramentas que também lidam com abstrações. Há 3 partes fundamentais em todo computador:

Relógio interno – a maneira de o computador abstrair o tempo
Memória – a maneira de o computador abstrair o espaço
Unidade de processamento – a maneira de o computador executar operações lógicas

Esses recursos dão aos computadores uma maneira de entender abstrações espaciais e suas interações no tempo abstrato. Isso significa que os programas são abstrações do espaço e do tempo. A programação é a arte de criar abstrações do espaço e do tempo. Essas abstrações nos ajudam a navegar na realidade, sendo, por isso, tão importantes para nós.

Existe um método de abstração que é muito semelhante à programação, mas que é ainda mais antigo que mapas, relógios e calendários: a linguagem.

Se você olhar de perto para nossa linguagem natural, verá que ela possui todas as características necessárias para abstrair o espaço e o tempo.

Vamos analisar um exemplo de frase:

Vá para o jardim e colha algumas flores esta noite.

O jardim e as flores referem-se a espaço abstrato. Esta noite é um modo de abstrair o tempo. E adiciona lógica à frase. Vá para e colha são sub-rotinas.

Podemos facilmente transformar a frase acima em JavaScript:

quandoNoite.then(()=>voce.irPara(jardim)).then(()=>voce.pegar(flor))

Essa frase pode ser entendida por um computador que tenha definições de noite, você, flores e as sub-rotinas necessárias definidas.

O problema da linguagem natural é que ela tem aplicações muito amplas. A linguagem pode ser usada não apenas para comunicar informações, mas também para expressar sentimentos e emoções. Os melhores exemplos de programas de linguagem natural pura são leis, regras de jogos de tabuleiro e manuais de instruções.

O Código de Hamurabi é um dos mais antigos programas de linguagem natural (foto de Richard / CC BY-NC-SA)

As linguagens de programação, por outro lado, são rigorosas e só podem criar abstrações. Os computadores são projetados para interpretar essas abstrações de uma maneira muito específica e determinística.

Para escrever programas de computador, você precisa aprender a programar a linguagem natural em símbolos que o computador possa entender. Isso geralmente requer conhecimento intrincado da arquitetura do computador e da sintaxe da linguagem de computador escolhida. Portanto, se você quiser que um computador entenda suas abstrações de realidade, você precisa aprender a programar.

Os computadores são ferramentas que podem executar regras definidas em programas com velocidade e precisão sobre-humanas. Eles nos capacitam a construir abstrações complexas e multicamadas e a transformar nossos programas em mapas da realidade verdadeiramente dinâmicos e interativos.

De muitas maneiras, programar é algo que todos nós já sabemos fazer. O processo de abstração da realidade é fundamental para os seres humanos. A programação de computadores é apenas a maneira mais eficaz de se fazer isso.

Clean Code explicado: um guia prático para iniciantes

Kris Lagerström — Wed, 24 Jul 2024 21:00:00 +0000

Artigo original: Clean Code Explained – A Practical Introduction to Clean Coding for Beginners

"Qualquer um consegue escrever código que um computador entende. Bons programadores escrevem código que humanos entendem." – Martin Fowler

Escrever código limpo, fácil de entender e que não dê dor de cabeça para mexer depois é essencial para qualquer programador.

Neste guia prático, vamos desvendar os segredos do código elegante e mostrar como deixar seu código tinindo!

Dando nome aos bois (ou melhor, às variáveis)

"Só existem duas coisas difíceis em Ciência da Computação: invalidar o cache e dar nomes às coisas." – Phil Karlton

Já imaginou ter que decorar um monte de números sem sentido para usar um programa? É por isso que damos nomes às variáveis: para facilitar a nossa vida!

Um bom nome já diz tudo sobre a variável, sem precisar de gambiarras.

Nomes que contam uma história

Evite usar comentários para explicar o óbvio. Se o nome precisa de legenda, é hora de repensar a vida (e o código!).

"Um bom nome já diz para que ele serve, o que faz e como usar. Se precisa de comentário, é porque está faltando informação." – Clean Code

Jeito tosco:

var d; // tempo decorrido em dias

Não caia na armadilha de esconder o problema com comentários! Letras soltas, como x, y, a ou b só servem para confundir.

Jeito elegante:

var tempoDecorridoEmDias;
var diasDesdeACriacao;
var diasDesdeAModificacao;

Veja a diferença! Agora, sabemos exatamente o que cada variável guarda.

Informação clara e direta

Cuidado com nomes que induzem ao erro! Não chame um grupo de contas de listaDeContas se não for uma lista de verdade.

Seja específico e use nomes simples e diretos.

Jeito tosco:

var listaDeContas = [];

Jeito elegante:

var contas = []

Sem enrolação

Nomes longos e repetitivos só servem para ocupar espaço. Corte o excesso!

O ou A (como prefixo)
Informacoes
Dados
Variavel
Objeto
Gerenciador

Jeito tosco:

class InformacoesDoUsuario {
  // ...
}

Jeito elegante:

class Usuario {
  // ...
}

Falando a língua dos humanos

Escolha nomes fáceis de ler e pronunciar, para não ter que soletrar código em voz alta.

Jeito tosco:

const yyyymmdstr = moment().format("YYYY/MM/DD");

Jeito elegante:

const dataAtual = moment().format("YYYY/MM/DD");

Fácil de encontrar

Evite usar números mágicos no código. Dê nomes descritivos às constantes para facilitar a busca.

Jeito tosco:

if (aluno.aulas.length < 7) {
   // Fazer alguma coisa
}

Jeito elegante:

if (aluno.aulas.length < MAXIMO_AULAS_POR_ALUNO) {
    // Fazer alguma coisa
}

Agora, se precisarmos mudar o limite de aulas, é só ajustar a constante.

Consistência é a alma do negócio

Use o mesmo nome para o mesmo conceito em todo o código. Nada de usar buscar, recuperar e obter para a mesma operação!

Funções espertas e enxutas

Tamanho é documento

Funções curtas e diretas são mais fáceis de entender e manter. Evite escrever códigos gigantes!

Uma função, uma responsabilidade

Funções devem fazer apenas uma coisa, devem fazê-la bem e ponto final. – Clean Code

Se sua função está fazendo malabarismos, é hora de dividi-la em partes menores.

Escondendo a complexidade

Use funções para encapsular condições complexas e deixar o código principal mais limpo.

Exemplo:

public void inserirPeca(int coluna) throws Exception {
        if (jogadaValida(coluna)) {
            // Lógica para inserir a peça
        } else {
            // Lógica para lidar com jogadas inválidas
        }
    }

    private boolean jogadaValida(int coluna) {
        // Verificar se a coluna é válida e se a jogada é possível
    }

Argumentos contidos

Funções com muitos argumentos são confusas e difíceis de testar. Limite-se a dois, no máximo.

Evite as flags

Argumentos booleanos que controlam o fluxo da função são sinais de problemas. Divida a função em funções menores!

Efeitos colaterais: evite-os!

Efeitos colaterais são como surpresas desagradáveis no código. Evite modificar variáveis globais ou parâmetros passados por referência sem necessidade.

Repetição? Nem pensar!

Código duplicado é sinônimo de dor de cabeça. Use as ferramentas da sua IDE para extrair métodos e evitar repetições.

Dicas extras

Comentários não são lixeiras

Evite comentar código desnecessário. Se não for mais útil, exclua-o! Use o controle de versão para recuperar o código antigo, se precisar.

Conheça as regras do jogo

Cada linguagem tem suas próprias convenções de estilo. Use e abuse das boas práticas! Confira os guias de estilo abaixo (em inglês):

Conclusão

Código limpo é um hábito que se constrói com o tempo. Aplique esses princípios no seu dia a dia e veja a mágica acontecer!

Gostou do guia? Compartilhe-o com seus amigos programadores! 😉

Como (e por que) incorporar conceitos de domínio no código

Kris Lagerström — Tue, 23 Jul 2024 21:00:00 +0000

Artigo original: How (and why) to embed domain concepts in code

Imagine que o código é como uma receita de bolo: ele precisa ser fácil de entender para que qualquer um possa seguir os passos e ter o resultado esperado. Para isso, é fundamental que ele reflita claramente o problema que está resolvendo, como se estivesse falando a língua do problema.

Incorporar os conceitos do problema no código exige atenção e habilidade. Isso não acontece automaticamente só porque você está usando TDD (Desenvolvimento Orientado a Testes). Acredite, porém, que esse esforço extra vale a pena, pois resulta em um código muito mais fácil de entender e manter.

Para ilustrar, vou usar um exemplo que vivenciei em um encontro de programadores. O desafio era criar um Relógio de Berlim simplificado, que mostra as horas através de luzes que piscam em um padrão específico (veja a imagem abaixo). No nosso caso, a saída era em formato de texto, mas a ideia é a mesma.

Solução Inicial com TDD

Muitas duplas usaram a técnica de TDD "de dentro para fora" e chegaram a soluções parecidas com esta (o código completo está no GitHub).

def berlin_clock_time(julian_time):
    hours, minutes, seconds = list(map(int, julian_time.split(":")))

    return [
        seconds_row_lights(seconds % 2)
        , five_hours_row_lights(hours)
        , single_hours_row_lights(hours % 5)
        , five_minutes_row_lights(minutes)
        , single_minutes_row_lights(minutes % 5)
    ]

def five_hours_row_lights(hours):
    lights_on = hours // 5
    lights_in_row = 4
    return lights_for_row("R", lights_on, lights_in_row)

# ...

Essa solução surge naturalmente ao aplicar o TDD, mas observe que alguns detalhes importantes sobre como o relógio funciona ficam escondidos nas funções auxiliares, como a get_five_hours.

Elevando os conceitos

Para melhorar a clareza, podemos trazer alguns desses detalhes para o topo do código, mesmo que isso quebre alguns testes (o código completo está no GitHub).

def berlin_clock_time(julian_time):
    hours, minutes, seconds = list(map(int, julian_time.split(":")))

    single_seconds = seconds_row_lights(seconds % 2)
    five_hours = row_lights(
        light_colour="R",
        lights_on=hours // 5,
        lights_in_row=4)
    single_hours = row_lights(
        light_colour="R",
        lights_on=hours % 5,
        lights_in_row=4)
    five_minutes = row_lights(
        light_colour="Y",
        lights_on=minutes // 5,
        lights_in_row=11)
    single_minutes = row_lights(
        light_colour="Y",
        lights_on=minutes % 5,
        lights_in_row=4)

    return [
        single_seconds,
        five_hours,
        single_hours,
        five_minutes,
        single_minutes
    ]

# ...

Agora, fica mais evidente que:

Existem 5 linhas no relógio.
A linha dos segundos é um caso especial.
Há 2 linhas para as horas e 2 para os minutos.
As linhas usam cores diferentes (vermelho e amarelo).
Cada linha tem um número diferente de luzes.

Nomeando conceitos implícitos

Apesar da melhoria, ainda não está claro como as linhas se relacionam entre si e o que cada luz representa em termos de tempo. Para resolver isso, precisamos tornar esses conceitos implícitos explícitos, dando nomes a eles.

Por exemplo, podemos passar um valor time_per_light para a função row_lights. Isso nos leva a perceber que existem dois tipos de linhas:

Linhas que representam a divisão inteira do tempo (//).
Linhas que representam o resto da divisão (%).

Ao analisarmos o primeiro caso, notamos que o segundo parâmetro é sempre 5 (5 horas ou 5 minutos). Já no segundo caso, o time_per_light (tempo por luz) é sempre 1 (1 hora ou 1 minuto), complementando o primeiro caso.

Com essa percepção, podemos reescrever as linhas da seguinte maneira:

five_hour_row = row_lights(
    time_per_light=5,
    value=hours, 
    light_colour="R",
    lights_in_row=4)

Essa mudança deixa claro que existe uma relação de pai e filho entre as linhas, onde a linha do resto depende da linha da divisão inteira.

Com base nisso, podemos criar uma função específica para as linhas "filhas" e o código fica assim (o código completo está no GitHub):

def berlin_clock_time(julian_time):
    hours, minutes, seconds = list(map(int, julian_time.split(":")))

    return [
        seconds_row_lights(
            seconds % 2),
        parent_row_lights(
            time_per_light=5,
            value=hours, 
            light_colour="R",
            lights_in_row=4),
        child_remainder_row_lights(
            parent_time_per_light=5,
            value=hours,
            light_colour="R"),
        parent_row_lights(
            time_per_light=5,
            value=minutes, 
            light_colour="Y",
            lights_in_row=11),
        child_remainder_row_lights(
            parent_time_per_light=5,
            light_colour="Y",
            value=minutes)
    ]

# ...

Agora, com uma rápida olhada no código, podemos entender quase todos os conceitos do domínio do problema:

A primeira linha representa os segundos e é um caso especial.
Na segunda linha, cada luz "R" representa 5 horas.
A terceira linha mostra o resto da divisão das horas por 5.
Na quarta linha, cada luz "Y" representa 5 minutos.
A quinta linha mostra o resto da divisão dos minutos por 5.

Conclusões

Incorporar os conceitos de domínio no código exige tempo e esforço – e o TDD não faz isso para você, necessariamente. No entanto, esses conceitos tornam o código muito mais fácil de entender e manter, o que economiza tempo e dinheiro a longo prazo. Lembre-se de que, como em uma receita de bolo, um código claro e organizado é essencial para que todos possam "colaborar na cozinha" sem dificuldades.

Notação pé de galinha (ERD) – símbolos de relacionamento e como ler diagramas

Kris Lagerström — Mon, 22 Jul 2024 21:00:00 +0000

Artigo original: Crow's Foot Notation – Relationship Symbols And How to Read Diagrams

Diagramas de entidade-relacionamento (ERD - do inglês, Entity-Relationship Diagram) são como mapas que mostram a relação entre diferentes "coisas" dentro de um sistema.

Pense em um banco de dados, por exemplo. Ele é como um armário gigante com várias gavetas (tabelas) para guardar informações sobre clientes, produtos, pedidos etc. O ERD serve para visualizarmos como essas gavetas se conectam.

Para entender a relação entre as entidades em um ERD, usamos símbolos e notações. Uma das mais populares é a notação pé de galinha (em inglês, crow's foot), que vamos desvendar neste tutorial.

Ao final, você será capaz de:

Entender o que são entidades e atributos em um ERD.
Decifrar os símbolos da notação pé de galinha.
Ler e interpretar diagramas como um profissional.
Criar seus próprios ERDs!

Vamos usar os termos "notação", "indicadores" e "símbolos" como sinônimos, ok?

O que é uma entidade em um ERD?

Entidade é cada "coisa" importante no nosso banco de dados, como clientes, produtos ou pedidos.

Dica: use nomes no singular (cliente, produto) e não no plural (clientes, produtos).

Olha um exemplo:

Aí, temos a entidade "Cliente". É nela que guardaremos as informações sobre cada cliente cadastrado.

O que são os atributos?

Atributos são as características de uma entidade, como nome, endereço e telefone do cliente.

Nesse exemplo, a entidade "Cliente" tem 3 atributos: nome de usuário, idade e e-mail.

Relacionamento entre Entidades: conectando as peças do quebra-cabeças

Na maioria dos casos, um banco de dados tem várias entidades interligadas. Para mostrar essas relações, usamos linhas com símbolos que indicam o tipo de relação entre elas.

Símbolos da notação pé de galinha e seus significados

Antes de mostrar os símbolos, precisamos entender o conceito de cardinalidade.

A cardinalidade define quantos "elementos" de uma entidade se relacionam com quantos "elementos" de outra entidade. Parece complicado, mas você vai entender rapidinho!

Zero

A bolinha na ponta da linha indica "zero" ou "nenhum".

Um

A perninha reta indica "um" e somente um.

Muitos

O "pé de galinha" indica "muitos".

Combinando esses símbolos básicos, podemos representar diferentes tipos de relações:

Zero ou Muitos

Um ou Muitos

Um e Somente Um

Hora da prática: exemplos de ERD com notação pé de galinha

Vamos usar a notação para modelar um banco de dados simples.

Exemplo nº 1: professores e cursos

Passo 1: entidades

Imagine um sistema de cursos on-line com duas entidades: "Professor" e "Curso".

Passo 2: relação professor-curso

Regra: cada professor só pode ministrar um curso por vez.

Usamos o indicador "um e somente um" do lado do "Curso".

A cardinalidade do lado do "Professor" é 1:1 (mínimo 1, máximo 1).

Passo 3: relação curso-professor

Regra: cada curso pode ter um ou vários professores.

Usamos o indicador "um ou muitos" do lado do "Professor".

A cardinalidade do lado do "Curso" é 1:N (mínimo 1, máximo N, ou seja, vários).

Exemplo nº 2: clientes e pizzas

Aqui, uma pizza pode ser pedida por zero ou muitos clientes (quem nunca dividiu uma pizza com a galera?).

Da mesma maneira, um cliente pode pedir zero ou muitas pizzas (a fome bate, certo?).

A cardinalidade em ambos os lados é 0:N (mínimo 0, máximo N).

Conclusão

A notação pé de galinha facilita a vida na hora de modelar bancos de dados. Com ela, você consegue visualizar as entidades e seus relacionamentos de maneira clara e organizada.

Os exemplos que vimos são simples, mas a lógica se aplica a sistemas complexos. Agora, é só praticar e se aventurar no mundo da modelagem de dados!

Como usar o Git e o GitHub – controle de versão para iniciantes

Kris Lagerström — Sun, 21 Jul 2024 21:00:00 +0000

Artigo original: How to Use Git and GitHub – Version Control Basics for Beginners

Já pensou em como programadores guardam as diferentes versões do código que escrevem? É aí que entra o "controle de versão", uma ferramenta que salva o histórico do seu código, como se fosse um "control + z" turbinado.

Com ele, você e sua equipe podem voltar atrás em qualquer mudança, como se fosse uma máquina do tempo para o seu código!

Existem três tipos principais de sistemas de controle de versão:

Sistemas locais: salvam as versões do código na sua própria máquina. É simples, mas se o computador der problema, já era!
Sistemas centralizados: guardam tudo em um servidor central. É bom para colaboração, mas, se o servidor cair, ninguém trabalha!
Sistemas distribuídos: cada desenvolvedor tem uma cópia completa do código. É o mais seguro e moderno.

Certo, e o que isso tem a ver com o Git?

O Git é um sistema de controle de versão distribuído, gratuito e muito popular. Com ele, você salva "instantâneos" do seu código (chamados de commits) e pode voltar para qualquer um deles quando quiser.

Pense no Git como um álbum de figurinhas do seu código, onde cada figurinha representa uma mudança.

O que é o GitHub?

O GitHub é como se fosse uma rede social para o seu código do Git. É lá que você guarda seus projetos (chamados de repositórios) e mostra para o mundo (ou não, você escolhe!).

No GitHub, você pode:

Trabalhar em equipe em um projeto, cada um com sua cópia, sem confusões.
"Clonar" o código de outros projetos e aprender com eles.
Mostrar seus projetos para futuros empregadores.

Por que usar o GitHub?

Organização: chega de pastas com nomes "projeto_final_versao_5_final_mesmo.zip"!
Trabalho em equipe: programe junto com seus amigos sem dor de cabeça.
Portfólio: mostre seus projetos para o mundo e impressione os recrutadores.

Mãos à obra: configurando o Git

Baixe o Git: vá no site oficial https://git-scm.com/ e baixe a versão para o seu sistema operacional (Windows, Mac ou Linux).
Instale o Git: é só seguir as instruções do instalador.
Configure o Git: abra o terminal (ou o Git Bash) e digite:

git config --global user.name "Seu Nome"
git config --global user.email "seu_e-mail@exemplo.com"

Substitua "Seu Nome" e "seu_e-mail@exemplo.com" por suas informações.

Criando sua conta no GitHub

Acesse o site https://github.com/.
Clique em "Sign up" (inscrever-se) no canto superior direito.
Preencha o formulário com seu e-mail, senha e nome de usuário.
Pronto! Você já faz parte da comunidade GitHub!

Comandos básicos do Git

git init: cria um novo repositório Git na pasta atual.
git add: adiciona suas mudanças na "área de preparação" (em inglês, staging area).
git commit -m "mensagem": salva suas mudanças com uma mensagem descrevendo o que você fez.
git clone [link do repositório]: copia um repositório do GitHub para sua máquina.
git push: envia suas mudanças para o GitHub.

Conclusão

Este guia é uma introdução ao mundo do Git e GitHub. Agora, é hora de você colocar a mão na massa e começar a fazer o versionamento de seus projetos!

Lembre-se: errar faz parte do aprendizado. Não tenha medo de experimentar e explorar as funcionalidades do Git e do GitHub.

Boa programação para você!

Clear Code – como escrever código fácil de ler

Kris Lagerström — Thu, 18 Jul 2024 21:00:00 +0000

Artigo original: https://www.freecodecamp.org/news/clear-code-how-to-write-code-that-is-easy-to-read/

Este artigo é uma continuação de um tweet que fiz sobre como lido com minha péssima capacidade de lembrar código. Pode parecer engraçado para você, mas eu realmente tendo a esquecer o que escrevo logo depois de escrever.

If you have a bad memory for code like I do, then I suggest you make your code read like a book.

That way you don't need to remember what you wrote yesterday, or a month ago; the code will tell you as you read it.
— Ryan Kay (@wiseAss301) November 11, 2022

Primeiro, discutiremos por que você pode querer escrever um código mais legível em vez de um código curto e conciso. Depois, veremos as seguintes estratégias sobre como fazer isso com:

Nomenclatura de variáveis, valores, referências, classes, objetos e funções
Funções auxiliares
Comentários de código
Enums/dicionários/classes seladas etc.
Organização e nomenclatura de pacotes

Conhecimento básico de código é recomendado para aproveitar ao máximo este artigo. No entanto, tentei torná-lo acessível para iniciantes, sempre que possível.

Foto por: Jamie Street / Unsplash

A eficiência vem de escrever menos código?

Lembro-me de quando era um desenvolvedor júnior, pensando que nomes curtos ou abreviados para identificadores – basicamente, qualquer código que nós, desenvolvedores, podemos nomear – eram mais eficientes.

Minha lógica era simples: se eu levo menos tempo para escrever, posso terminar o trabalho mais rápido.

Essa lógica faria sentido se as seguintes coisas fossem verdadeiras:

Eu, ou outra pessoa, nunca teria que ler ou corrigir o que escrevi no passado
Eu não esqueceria com frequência o que era uma variável, ou várias variáveis, enquanto lia uma função
Eu não teria que escrever ocasionalmente algum código que fosse realmente complexo e obscuro
Eu poderia renomear funções, classes ou propriedades de bibliotecas externas ridículas ou obscuras para algo mais sensato

O ponto é que, para mim, encontro poucas situações em que ser conciso realmente economiza tempo. Além disso, os IDEs modernos têm esse recurso útil chamado preenchimento automático de código que economiza a maior parte da digitação de qualquer maneira.

Você pode não se sentir da mesma maneira – e tudo bem! Pegue o que funcionar para você neste artigo e descarte o resto.

Como nomear classes, variáveis e funções

Agora, compartilharei o que faço para tornar meu código mais fácil de ler para mim e para os outros. Os exemplos de código que usarei serão em Kotlin, mas os pontos que levantarei devem ser aplicáveis à maioria das plataformas e linguagens.

Existem duas coisas importantes para saber ao aprender, como nomear entidades de software. Antes de chegar a isso, o termo entidades de software se refere a qualquer um dos seguintes:

Classes, structs, objetos
Variáveis, valores, referências, ponteiros
Funções, métodos, algoritmos, comandos
Interfaces, protocolos, abstrações

Essencialmente, qualquer coisa que um programador precisa nomear ao escrever um programa.

Que nível de descrição devemos usar para os nomes

Meu objetivo para nomear entidades de software é este: o nome deve reduzir qualquer confusão sobre o que uma entidade de software faz ou é.

Os detalhes de como ela faz algo geralmente não são necessários.

O contexto, ou tudo ao redor, de uma entidade de software é importante ao decidir sobre um nome. Algo pode exigir mais ou menos detalhes dependendo do seu contexto.

Vamos considerar três exemplos:

obterDataFormatada(data: String) : String
obterDataFormatadaAAAAMMDD(data: String) : String
obterDataFormatadaAAAAMMDDdeFormatoISO8601(data: String) : String

A aplicação em produção na qual estou trabalhando atualmente exige frequentemente a transformação de datas de e para diferentes formatos.

Nesse contexto, eu simplesmente uso nomes como o do exemplo 3, que é muito mais claro do que o do exemplo 1.

Outra opção pode ser alterar o nome do parâmetro no exemplo 2 para algo como dataISO8601.

Embora eu sugira que você seja consistente em sua abordagem em uma determinada base de código, sinta-se à vontade para experimentar o que funciona para você. O ponto é adicionar o máximo de informações necessárias para esclarecer qualquer ambiguidade.

Se eu estivesse escrevendo um programa único que apenas converte um formato para outro, o exemplo 1 seria bom. Adicionar mais informações do que o necessário não é o que estou defendendo aqui.

Quanto mais algo faz, mais difícil é nomeá-lo

Se você está tendo problemas para nomear algo, geralmente (embora nem sempre) é porque ele faz muitas coisas que não estão conceitualmente relacionadas.

O grau em que as entidades de software estão conceitualmente relacionadas é conhecido como coesão (texto em inglês).

Ao observar quais partes de um programa são coesas ou não, você pode começar a entender o que deve ser separado ou agrupado.

Esse processo pode ser feito de várias perspectivas, que tentarei explicar por meio de exemplos.

Suponha que você tenha quatro entidades de software:

ArmazenarUsuárioNaNuvem
ArmazenarUsuárioEmDisco
ArmazenarMensagem
EditarIUDoUsuário

A primeira perspectiva que podemos considerar é a informação do mundo real com a qual essas entidades estão preocupadas. Dessa perspectiva, podemos ver que ArmazenarUsuárioNaNuvem, ArmazenarUsuárioEmDisco e EditarIUDoUsuário usam o mesmo modelo de informação: um usuário.

No entanto, há outra perspectiva que devemos ter em mente, particularmente ao projetar programas de interface gráfica do usuário (GUI).

Todo programa de GUI pode ser dividido em três camadas principais:

Interface do usuário (comumente chamada de "View" – em português, visão ou visualização)
Lógica (comumente se refere a coisas como controladores e apresentadores)
Modelo (armazenamento e acesso a dados, ou o próprio estado, dependendo da sua definição)

Isso não significa que você deva sempre olhar para um programa como tendo apenas essas três camadas! A abordagem de três camadas é uma generalização que frequentemente é insuficiente.

De qualquer modo, a partir dessa perspectiva, ArmazenarMensagem tem mais em comum com as outras entidades de armazenamento do que EditarIUDoUsuário.

Ser capaz de olhar para seus programas de várias perspectivas é algo que virá à medida que você construir programas mais complexos.

A principal lição é que separar sua base de código em partes coesas e relacionadas geralmente tornará as entidades de software mais fáceis de nomear.

Como usar funções auxiliares

Funções auxiliares, particularmente, quando combinadas com boas práticas de nomenclatura de funções, podem melhorar muito a legibilidade do seu código.

As funções auxiliares também são uma oportunidade para aplicar um princípio fundamental da arquitetura de software: a separação de responsabilidades.

Como criar quebra-cabeças de Sudoku com funções auxiliares

Agora, veremos um exemplo prático para demonstrar o uso extensivo de funções auxiliares. Tente imaginar a dificuldade que seria seguir este código se tudo estivesse em uma única função gigante!

No passado, trabalhei em uma parte grande, mas coesa, de um programa: um construtor de Sudoku que usa estruturas de dados e algoritmos de grafos. Mesmo que você não esteja familiarizado com Sudoku ou grafos, acredito que ainda seja capaz de acompanhar o ponto principal.

Você pode encontrar o código-fonte completo aqui.

Podemos dividir o processo de geração de um quebra-cabeça de Sudoku jogável em cinco etapas:

Criar os nós do quebra-cabeça (representando as peças)
Criar as arestas do quebra-cabeça (arestas, neste caso, é outra palavra para relacionamentos/referências entre as peças: linha, coluna ou subgrade)
Semear (adicionar) alguns valores à estrutura de dados para tornar a resolução mais rápida
Resolver o quebra-cabeça
Desfazer um certo número de peças para que o jogo seja realmente jogável por um usuário

Usei algo semelhante ao padrão construtor para representar essas etapas na função que chamo para criar o quebra-cabeça:

internal fun construirNovoSudoku(
    limite: Int,
    dificuldade: Dificuldade
): QuebraCabecaSudoku = construirNos(limite, dificuldade)
        .construirArestas()
        .semearCores()
        .resolver()
        .desfazer()

Embora a ideia de "nós" e "arestas" seja a de definições técnicas dentro da teoria dos grafos, esse código reflete claramente as cinco etapas que decidi.

Não veremos toda a base de código, mas quero destacar como as funções auxiliares continuam a decompor a lógica e promover a legibilidade:

internal fun QuebraCabecaSudoku.construirArestas(): QuebraCabecaSudoku {
    this.grafo.forEach {
        val x = it.value.first.x
        val y = it.value.first.y

        it.value.mesclarSemRepeticoes(
                obterNosPorColuna(this.grafo, x)
        )

        it.value.mesclarSemRepeticoes(
                obterNosPorLinha(this.grafo, y)
        )

        it.value.mesclarSemRepeticoes(
                obterNosPorSubgrade(this.grafo, x, y, limite)
        )

    }
    return this
}

internal fun LinkedList.mesclarSemRepeticoes(novo: List) {
    val hashes: MutableList = this.map { it.hashCode() }.toMutableList()
    novo.forEach {
        if (!hashes.contains(it.hashCode())) {
            this.add(it)
            hashes.add(it.hashCode())
        }
    }
}

internal fun obterNosPorColuna(grafo: LinkedHashMap>, x: Int): List {
    val listaDeArestas = mutableListOf()
    grafo.values.filter {
        it.first.x == x
    }.forEach {
        listaDeArestas.add(it.first)
    }
    return listaDeArestas
}
//...

Para resumir esse processo, as funções auxiliares fornecem dois benefícios:

Elas são um substituto para um bloco de código que faz algo
Esse bloco de código pode receber um nome descritivo

Ambos os benefícios podem levar a uma maior legibilidade, pois o código se torna menos confuso e mais descritivo.

Se você está se perguntando o que deve e o que não deve ser uma função auxiliar, sugiro que pratique diferentes abordagens para ver o que funciona para você.

Como usar comentários de código

Minha preferência pessoal em comentários de código é que eles tenham dois usos principais: primeiro, os comentários ajudam a descrever funções complexas em detalhes.

Segundo, para esclarecer qualquer confusão sobre uma linha ou bloco de código.

Como usar comentários para projetar novas funções

Quando encontro funções que espero que sejam difíceis de escrever, descrevo o que a função faz usando linguagem simples ou pseudocódigo.

A forma como faço isso mudou ao longo dos anos, então encorajo você a tentar diferentes abordagens.

Nos exemplos da seção anterior, omiti os comentários de código:

/** * 1. Gere um Mapa que contém n*n nós. * 2. para cada nó adjacente (conforme as regras do Sudoku), adicione uma Aresta ao conjunto hash *  - Por coluna *  - Por linha *  - Por subgrade de tamanho n * *  LinkedHashMap: Escolhi usar um LinkedHashMap porque ele preserva a ordem dos *  elementos colocados dentro do Mapa, mas também permite pesquisas por código hash, que são *  gerados por valores x e y. * *  Quanto ao LinkedList em cada bucket (elemento) do mapa, assuma que o primeiro elemento *  é o nó em hashCode(x, y), e os elementos subsequentes são arestas desse elemento. *  Além da ordenação do primeiro elemento como Cabeça do LinkedList, o resto dos *  elementos não precisa ser ordenado de nenhuma maneira específica. * * *  */
internal fun construirNos(n: Int, dificuldade: Dificuldade): QuebraCabecaSudoku {
    val novoMapa = LinkedHashMap>()

    (1..n).forEach { indiceX ->
        (1..n).forEach { indiceY ->
            val novoNo = NoSudoku(
                    indiceX,
                    indiceY,
                    0
            )

            val novaLista = LinkedList()
            novaLista.add(novoNo)
            novoMapa.put(
                    novoNo.hashCode(),
                    novaLista
            )
        }
    }
    return QuebraCabecaSudoku(n, dificuldade, novoMapa)
}

A quantidade de detalhes que adiciono a esses comentários depende do contexto. Se estou trabalhando em equipe, geralmente tento mantê-los muito mais curtos do que o que você vê acima e incluo apenas informações que considero necessárias.

O exemplo acima foi um projeto de aprendizado pessoal que eu esperava compartilhar com outras pessoas. É por isso que até incluí meu processo de tomada de decisão sobre os tipos usados para representar um quebra-cabeça de Sudoku.

Para os fãs de desenvolvimento orientado a testes, você pode tentar escrever as etapas de pseudocódigo de um algoritmo antes de escrever o teste:

/**     * No processo de vinculação, chamado pela visualização em onCreate. Verifique o estado atual do usuário, grave esse resultado em     * vModel, mostre o gráfico de carregamento, execute alguma inicialização     *     * a. Usuário é Anônimo     * b. Usuário é Registrado     *     * a:     * 1. Exibir Visualização de Carregamento     * 2. Verificar se há um usuário conectado da autenticação: nulo     * 3. gravar nulo no estado do usuário vModel     * 4. chamar o processo On start     */
    @Test
    fun `On bind Usuário anônimo`() = runBlocking {

        //...
    }

Isso permite que você projete a unidade em um nível mais alto de abstração antes de escrever a implementação. O tempo que você gasta projetando em níveis mais altos de abstração pode economizar tempo a longo prazo.

Como usar comentários de código em linha de modo eficaz

Existem duas situações principais em que escreverei um comentário de código em linha:

Quando sinto que o propósito de uma linha ou bloco de código não ficará claro para mim ou para qualquer outra pessoa que o leia mais tarde
Quando tenho que chamar alguma função de biblioteca mal nomeada que tem um nome confuso ou enganoso

De longe, o algoritmo de Sudoku mais complexo no meu programa é o algoritmo de resolução. Na verdade, é tão longo que postarei apenas um trecho dele aqui:

internal fun QuebraCabecaSudoku.resolver()
        : QuebraCabecaSudoku {
    //nós que foram atribuídos (não incluindo nós semeados de semearCores())
    val atribuicoes = LinkedList()

    //acompanhe as tentativas de atribuição com falha para observar loops infinitos
    var tentativasDeAtribuicao = 0
    //Duas etapas de retrocesso, parcial é metade do conjunto de dados, completo é uma reinicialização completa
    var retrocessoParcial = false

    var contadorDeRetrocessoCompleto = 0

    //de 0 - limite, representa o quão "exigente" o algoritmo é sobre atribuir novos valores
    var valorLegal: Int = (limite / 2)

    //para evitar ser muito legal muito cedo
    var contadorLegal = 0

    //trabalhe com uma cópia
    var novoGrafo = LinkedHashMap(this.grafo)
    //todos os nós que são de valor 0 (não coloridos)
    val nosNaoColoridos = LinkedList()
    novoGrafo.values.filter { it.first.cor == 0 }.forEach { nosNaoColoridos.add(it.first) }

    while (nosNaoColoridos.size > 0) {
    //...
    }
//...
}

Neste caso, os comentários em linha eram necessários, pois eu frequentemente esquecia o que algumas dessas variáveis eram enquanto lia este algoritmo gigante.

Outro caso em que adicionarei um comentário em linha é quando tenho que explicar ou me lembrar sobre o código sobre o qual não tenho controle.

Por exemplo, a infame API Java Calendar usa indexação baseada em zero para meses. Isso é indiscutivelmente muito estúpido, pois não estou ciente de nenhum padrão que represente janeiro com 0, nem me importo se existe um!

Não posso compartilhar o código com você, pois é proprietário, mas basta dizer que tenho comentários na base de código da minha equipe atual que explicam instruções aleatórias - 1 para se conformar com a API Calendar.

Como usar enums e dicionários

Existem outros nomes para esses tipos de construções de código, mas esses são os dois com os quais estou familiarizado. Suponha que você tenha um conjunto restrito ou limitado de valores que você usa para representar algo.

Por exemplo, eu precisava de uma maneira de limitar o número de peças que são incluídas em um novo quebra-cabeça de Sudoku, com base:

No tamanho do quebra-cabeça (4, 9 ou 16 peças por coluna/linha/subgrade)
Na dificuldade do quebra-cabeça (fácil, médio ou difícil)

Por meio de testes extensivos, cheguei aos seguintes valores como modificadores:

enum class Dificuldade(val modificador:Double) {
    FACIL(0.50),
    MEDIO(0.44),
    DIFICIL(0.38)
}

data class QuebraCabecaSudoku(
        val limite: Int,
        val dificuldade: Dificuldade,
        val grafo: LinkedHashMap>
        = construirNovoSudoku(limite, dificuldade).grafo,
        var tempoDecorrido: Long = 0L
)//...

Esses valores são usados em vários lugares onde a lógica deve mudar com base na dificuldade.

Às vezes, você nem precisa ter valores associados a nomes legíveis por humanos. Usei um enum diferente para representar diferentes estratégias de resolução para garantir que um quebra-cabeça seja jogável em relação à dificuldade selecionada:

enum class EstrategiaDeResolucao {
    BASICA,
    AVANCADA,
    INSOLUVEL
}

internal fun determinarDificuldade(
    quebraCabeca: QuebraCabecaSudoku
): EstrategiaDeResolucao {
    val resolucaoBasica = ehBasica(
        quebraCabeca
    )
    val resolucaoAvancada = ehAvancada(
        quebraCabeca
    )

    //se o quebra-cabeça não for mais solucionável, retornamos a estratégia atual
    if (resolucaoBasica) return EstrategiaDeResolucao.BASICA
    else if (resolucaoAvancada) return EstrategiaDeResolucao.AVANCADA
    else {
        quebraCabeca.imprimir()
        return EstrategiaDeResolucao.INSOLUVEL
    }
}

Um bom princípio no projeto de qualquer sistema é este: menos partes móveis geralmente têm menos coisas que podem dar errado.

Colocar restrições em valores e tipos e dar a eles bons nomes não apenas torna seu código mais fácil de ler, mas também pode protegê-lo de erros.

Como organizar e nomear pacotes, pastas e diretórios

Nenhum guia sobre legibilidade de código estaria completo sem alguma discussão sobre pacotes. Se a plataforma e a linguagem de sua preferência não usam esse termo, assuma que quero dizer pasta ou diretório.

Já mudei de opinião sobre isso várias vezes. Isso se reflete em meus projetos mais antigos.

Duas abordagens comuns para a organização de pacotes são:

Pacote por camada arquitetônica
Pacote por recurso

Como fazer pacote por camada

Pacote por camada é o primeiro e pior sistema que já usei. A ideia geralmente é construir sua estrutura de pacotes em torno de algum padrão arquitetônico como MVC, MVP, MVVM e assim por diante.

Para tomar o MVC como exemplo, sua estrutura de pacotes de nível superior seria assim:

modelo
visão
controlador

O primeiro problema com essa abordagem é que ela assume que toda classe ou função se encaixa confortavelmente em uma dessas camadas. Isso raramente é o caso na prática.

Também acho essa abordagem a menos legível, pois o nível superior informa apenas os detalhes mais gerais sobre o que esperar dentro de cada pacote.

Essa abordagem geralmente pode ser aprimorada adicionando mais "camadas" para ser mais específica:

ui
modelo
api
logicaDeConstrucao/di
repositorio
dominio
comum

Isso pode funcionar razoavelmente bem em bases de código menores, onde todos os desenvolvedores estão familiarizados com o padrão geral e o estilo usado.

Como fazer pacote por recurso

Pacote por recurso tem suas próprias falhas, mas geralmente é mais fácil de ler e navegar. Isso supondo que você dê bons nomes aos pacotes.

O termo recurso é difícil de descrever, mas eu geralmente o definiria assim: uma tela/página ou conjunto de telas/páginas que definem uma parte principal da funcionalidade para usuários ou clientes.

Para uma aplicação de mídia social, podemos ver uma estrutura como:

linhaDoTempo
amigos
perfilDoUsuario
mensagens
detalheDaMensagem

O problema principal com o pacote por recurso é o oposto do pacote por camada: quase sempre haverá entidades de software que são usadas em vários recursos.

Existem duas soluções para esse problema. A primeira seria ter código duplicado em cada recurso.

Acredite ou não, duplicar entidades de software pode ser incrivelmente útil em ambientes corporativos em situações específicas.

No entanto, não é algo que eu recomendaria como regra geral.

Como fazer uma estrutura de pacote híbrida

A solução que geralmente recomendo aos desenvolvedores é o que gosto de chamar de abordagem híbrida. É muito simples, flexível e deve cobrir a maioria dos seus requisitos:

linhaDoTempo
amigos
mensagens
todasAsMensagens
conversa
detalheDaMensagem
api
linhaDoTempo
usuario
mensagem
componentesDeIU

Não leve esse exemplo muito a sério; estou tentando transmitir a ideia geral: qualquer coisa que seja específica do recurso vai para o pacote desse recurso. Qualquer coisa que seja compartilhada entre os recursos vai para um pacote separado aninhado no mesmo nível ou em um nível superior.

Novamente, o que define uma camada é um conceito vago para começar. Então, não siga uma convenção cegamente. Pense criticamente sobre o que é claro, particularmente para alguém que não está familiarizado com o projeto.

Considerações finais

A maioria das minhas preferências em legibilidade e estilo de código veio de muitas tentativas de diferentes abordagens. Às vezes, essas eram abordagens que eu vi outras pessoas usarem e algumas delas surgiram naturalmente.

Se você for capaz de se colocar na posição de alguém menos familiarizado com o código ou programa que está olhando, terá mais facilidade em fazer seu código ser lido como se fosse um livro.

Comandos da linha de comando – tutorial de CLI

Kris Lagerström — Wed, 17 Jul 2024 21:00:00 +0000

Artigo original: Command Line Commands – CLI Tutorial

A linha de comando do Windows é uma das ferramentas mais poderosas em um PC com Windows. Com ela, você pode interagir diretamente com o sistema operacional e fazer muitas coisas que não estão disponíveis na interface gráfica do usuário (GUI – do inglês, Graphical User Interface).

Neste artigo, mostrarei 40 comandos que você pode usar na linha de comando do Windows e que podem aumentar sua confiança como usuário do Windows.

Observação: você precisa ter cuidado ao usar os comandos que mostrarei. Isso ocorre porque alguns comandos podem ter um efeito negativo ou positivo duradouro em seu PC com Windows até que você o reinicie.

Além disso, alguns desses comandos exigem que você abra o prompt de comando como administrador.

Comandos da linha de comando do Windows

`powershell start cmd -v runAs` – executar o prompt de comando como administrador

Inserir esse comando abre outra janela do prompt de comando como administrador:

`driverquery` – lista todos os drivers instalados

É importante ter acesso a todos os drivers porque eles costumam causar problemas.

É isso que este comando faz – ele mostra até mesmo os drivers que você não encontrará no gerenciador de dispositivos.

`chdir` ou `cd` – muda o diretório de trabalho atual para o diretório especificado

`systeminfo` – mostra os detalhes do seu PC

Se você quiser ver informações mais detalhadas sobre o seu sistema que você não vê na GUI, esse é o comando para você.

`set` – mostra as variáveis de ambiente do seu PC

`prompt` – altera o texto padrão exibido antes de inserir comandos

Por padrão, o prompt de comando mostra o caminho da unidade C para sua conta de usuário.

Você pode usar o comando prompt para alterar esse texto padrão com a sintaxe prompt nome_do_prompt $G:

Observação: se você não anexar $G ao comando, não obterá o símbolo de maior que (>) na frente do texto.

`clip` – copia um item para a área de transferência

Por exemplo, dir | clip copia todo o conteúdo do diretório de trabalho atual para a área de transferência.

Você pode digitar clip /? e pressionar ENTER para ver como usá-lo.

`assoc` – lista os programas e as extensões com as quais eles estão associados

`title` – altera o título da janela do prompt de comando usando o formato `title nome-do-título-da-janela`

`fc` – compara dois arquivos semelhantes

Se você é um programador ou escritor e deseja ver rapidamente a diferença entre dois arquivos, pode inserir esse comando e, em seguida, o caminho completo para os dois arquivos. Por exemplo, fc "caminho-do-arquivo-1" "caminho-do-arquivo-2".

`cipher` – limpa o espaço livre e criptografa dados

Em um PC, os arquivos excluídos permanecem acessíveis para você e outros usuários. Então, tecnicamente, eles não são excluídos nos bastidores.

Você pode usar o comando cipher para limpar a unidade e criptografar esses arquivos.

`netstat -an` – mostra as portas abertas, seus endereços IP e estados

`ping` – mostra o endereço IP de um site, permite saber quanto tempo leva para transmitir dados e obter uma resposta

`color` – altera a cor do texto do prompt de comando

Digite color attr para ver as cores para as quais você pode mudar:

Digitar color 2 muda a cor do terminal para verde:

`for /f "skip=9 tokens=1,2 delims=:" %i in ('netsh wlan show profiles') do @echo %j | findstr -i -v echo | netsh wlan show profiles %j key=clear` – mostra todas as senhas de Wi-Fi

`ipconfig` – mostra informações sobre endereços IP e conexões do PC

Esse comando também possui extensões como ipconfig /release, ipconfig /renew e ipconfig /flushdns, que você pode usar para solucionar problemas com conexões de internet.

`sfc` – verificador de arquivos do sistema

Esse comando verifica seu computador em busca de arquivos corrompidos e os repara. A extensão do comando que você pode usar para executar uma verificação é /scannow.

`powercfg` – controla as configurações de energia configuráveis

Você pode usar esse comando com suas várias extensões para mostrar informações sobre o estado de energia do seu PC.

Você pode digitar powercfg help para mostrar essas extensões.

Por exemplo, você pode usar powercfg /energy para gerar um relatório de integridade da bateria.

O comando powercfg /energy gerará um arquivo HTML contendo o relatório. Você pode encontrar o arquivo HTML em C:\Windows\system32\energy-report.html.

`dir` – lista itens em um diretório

`del` – exclui um arquivo

`attrib +h +s +r nome_da_pasta` – oculta uma pasta

Você pode ocultar uma pasta diretamente da linha de comando digitando attrib +h +s +r nome_da_pasta e pressionando ENTER.

Para mostrar a pasta novamente, execute o comando attrib -h -s -r nome_da_pasta.

`start endereço-do-site` – abre um site a partir da linha de comando

`tree` – mostra a árvore do diretório atual ou da unidade especificada

`ver` – mostra a versão do sistema operacional

`tasklist` – mostra os programas abertos

Você pode fazer a mesma coisa que faz com o gerenciador de tarefas com esse comando:

O próximo comando mostra como fechar uma tarefa aberta.

`taskkill` – encerra uma tarefa em execução

Para encerrar uma tarefa, execute taskkill /IM "tarefa.exe" /F. Por exemplo, taskkill /IM "chrome.exe" /F:

`date` – mostra e altera a data atual

`time` – mostra e altera a hora atual

`vol` – mostra o número de série e as informações de rótulo da unidade atual

`dism` – executa a ferramenta de gerenciamento e manutenção de imagens de implantação

`CTRL + C` – interrompe a execução de um comando

`-help` – fornece um guia para outros comandos

Por exemplo, powercfg -help mostra como usar o comando powercfg

`echo` – mostra mensagens personalizadas ou mensagens de um script ou arquivo

Você também pode usar o comando echo para criar um arquivo com esta sintaxe: echo conteúdo-do-arquivo > nome-do-arquivo.extensão.

`mkdir` – cria uma pasta

`rmdir` – exclui uma pasta

Observação: a pasta deve estar vazia para que esse comando funcione.

`more` – mostra mais informações ou o conteúdo de um arquivo

`move` – move um arquivo ou pasta para uma pasta especificada

`ren` – renomeia um arquivo com a sintaxe `ren nome-do-arquivo.extensão novo-nome.extensão`

`cls` – limpa a linha de comando

Caso você insira vários comandos e a linha de comando fique congestionada, você pode usar cls para limpar todas as entradas e suas saídas.

`exit` – fecha a linha de comando

`shutdown` – desliga, reinicia, hiberna, suspende o computador

Você pode desligar, reiniciar, hibernar e suspender seu PC a partir da linha de comando.

Digite shutdown na linha de comando para ver as extensões que você pode usar para executar as ações. Por exemplo, shutdown /r0 reiniciará seu computador.

Conclusão

Este artigo mostrou vários comandos "desconhecidos para muitos" que você pode usar para obter acesso a funcionalidades ocultas em seu PC com Windows.

Novamente, você deve ter cuidado ao trabalhar com esses comandos porque eles podem ter um efeito duradouro em seu sistema operacional.

Se você achar os comandos úteis, compartilhe o artigo com seus amigos e familiares.

O que é CI/CD? Aprenda integração contínua/entrega contínua criando um projeto

Kris Lagerström — Tue, 16 Jul 2024 21:00:00 +0000

Artigo original: What is CI/CD? Learn Continuous Integration/Continuous Deployment by Building a Project

Olá! Neste artigo, você aprenderá sobre CI/CD (integração contínua e implantação contínua).

Vamos revisar o que essa prática significa, como ela se compara à abordagem anterior na indústria de desenvolvimento de software e, finalmente, ver um exemplo prático de como podemos implementá-la em nossos projetos.

Vamos lá!

Índice

Introdução

Integração Contínua e Entrega Contínua (CI/CD, do inglês Continuous Integration/Continuous Delivery) é uma abordagem de desenvolvimento de software que visa melhorar a velocidade, eficiência e confiabilidade da entrega de software. Ela envolve integração frequente de código, testes automatizados e entrega contínua de alterações de software em produção.

Antes da adoção do CI/CD na indústria de desenvolvimento de software, a abordagem comum era um modelo tradicional em cascata de desenvolvimento de software.

Nessa abordagem, os desenvolvedores trabalhavam em silos, com cada etapa do ciclo de vida do desenvolvimento de software sendo concluída após a anterior. O processo normalmente envolvia a coleta de requisitos, o design do software, a programação, os testes e a implantação.

As desvantagens dessa abordagem tradicional incluem:

Ciclos de lançamento lentos: como cada etapa do ciclo de vida do desenvolvimento de software era concluída em sequência, o ciclo de lançamento era lento, o que dificultava a resposta rápida às mudanças nas necessidades do cliente.
Altas taxas de falha: os projetos de software eram propensos a falhas devido à falta de testes automatizados, o que significava que os desenvolvedores tinham que confiar em testes manuais, levando a erros e bugs no código.
Colaboração limitada: a abordagem tradicional não incentivava a colaboração entre desenvolvedores, testadores e outras partes interessadas, o que dificultava a identificação e correção de problemas.
Alto custo: a natureza manual do desenvolvimento de software significava que era caro, com altos custos associados a testes, depuração e correção de erros.
Agilidade limitada: como a abordagem tradicional era linear, não era possível fazer alterações no software rapidamente ou responder às necessidades do cliente em tempo real.

O CI/CD surgiu como uma solução para essas desvantagens, introduzindo uma abordagem mais ágil e colaborativa para o desenvolvimento de software. O CI/CD permite que as equipes trabalhem juntas, integrando suas alterações de código com frequência e automatizando o processo de teste e implantação.

Como o CI/CD funciona

O CI/CD é um processo automatizado que envolve integração frequente de código, testes automatizados e implantação contínua de alterações de software em produção.

Vamos explicar cada etapa com um pouco mais de detalhes:

Integração de código

A primeira etapa no pipeline de CI/CD é a integração de código. Nessa etapa, os desenvolvedores confirmam suas alterações de código em um repositório remoto (como GitHub, GitLab ou BitBucket), onde o código é integrado à base de código principal.

Essa etapa visa garantir que as alterações de código sejam compatíveis com o restante da base de código e não interrompam a compilação.

Testes automatizados

Uma vez que o código é integrado, a próxima etapa é o teste automatizado. O teste automatizado envolve a execução de um conjunto de testes para garantir que as alterações de código sejam funcionais, atendam aos padrões de qualidade esperados e estejam livres de defeitos.

Essa etapa ajuda a identificar problemas no início do processo de desenvolvimento, permitindo que os desenvolvedores os corrijam de maneira rápida e eficiente.

Se você não está familiarizado com o tópico de testes, consulte este artigo.

Entrega contínua

Depois que as alterações de código passam na etapa de teste automatizado, a próxima etapa é a entrega contínua. Nessa etapa, as alterações de código são implantadas automaticamente em um ambiente de teste para testes adicionais.

Essa etapa visa garantir que o software seja atualizado continuamente com as alterações de código mais recentes, entregando novos recursos e funcionalidades aos usuários de maneira rápida e eficiente.

Implantação em produção

A etapa final no pipeline de CI/CD é a implantação em produção. Nessa etapa, as alterações de software são lançadas para os usuários finais. Essa etapa envolve o monitoramento do ambiente de produção, garantindo que o software esteja funcionando sem problemas e identificando e corrigindo quaisquer problemas que surjam.

As quatro etapas de um pipeline de CI/CD trabalhem juntas para garantir que as alterações de software sejam testadas, integradas e implantadas em produção automaticamente. Essa automação ajuda a reduzir erros, aumentar a eficiência e melhorar a qualidade geral do software.

Ao adotar um pipeline de CI/CD, as equipes de desenvolvimento podem alcançar ciclos de lançamento mais rápidos, reduzir o risco de defeitos de software e melhorar a experiência do usuário.

Lembre-se de que as etapas do pipeline podem parecer diferentes, dado o projeto ou empresa específica sobre a qual estamos falando. Ou seja, algumas equipes podem ou não usar testes automatizados, algumas equipes podem ou não ter um ambiente de "teste" e assim por diante.

As partes principais que compõem a prática de CI/CD são a integração e a implantação (entrega). Isso significa que o código deve ser continuamente integrado em um repositório remoto e que esse código deve ser continuamente implantado em um determinado ambiente após cada integração.

Os principais benefícios do CI/CD

Os principais benefícios do CI/CD incluem:

Ciclos de lançamento mais rápidos: ao automatizar o processo de teste e implantação, o CI/CD permite que as equipes lancem software com mais frequência, respondendo rapidamente às necessidades do cliente.
Qualidade aprimorada: o teste automatizado garante que as alterações de software não introduzam novos bugs ou problemas, melhorando a qualidade geral do software.
Maior colaboração: a integração e o teste frequentes de código exigem que os desenvolvedores trabalhem em estreita colaboração, levando a uma melhor colaboração e comunicação.
Risco reduzido: a implantação contínua permite que os desenvolvedores identifiquem e corrijam problemas rapidamente, reduzindo o risco de falhas graves e tempo de inatividade.
Custo-benefício: o CI/CD reduz a quantidade de trabalho manual necessária para implantar alterações de software, economizando tempo e reduzindo custos.

Em resumo, o CI/CD surgiu como uma solução para as limitações da abordagem tradicional e linear para o desenvolvimento de software. Ao introduzir uma abordagem mais ágil e colaborativa para o desenvolvimento de software, o CI/CD permite que as equipes trabalhem juntas, lancem software com mais frequência e respondam rapidamente às necessidades do cliente.

Ferramentas para CI/CD

Existem várias ferramentas disponíveis para implementar pipelines de CI/CD no desenvolvimento de software. Cada ferramenta tem seus recursos, prós e contras exclusivos. Aqui estão algumas das ferramentas mais usadas em pipelines de CI/CD hoje:

Jenkins

O Jenkins é um servidor de automação de código aberto amplamente utilizado em pipelines de CI/CD. É altamente personalizável e suporta uma grande variedade de plug-ins, tornando-o adequado para vários ambientes de desenvolvimento. Alguns de seus principais recursos incluem:

Prós:

Altamente personalizável com uma grande quantidade de plug-ins
Suporta integração com várias ferramentas e tecnologias
Fornece relatórios e análises detalhados

Contras:

Requer alguma experiência técnica para configurar e manter
Pode consumir muitos recursos, especialmente para grandes projetos
Falta de um painel centralizado para gerenciar vários projetos

Se você quiser saber mais sobre o Jenkins, clique aqui (em inglês).

Travis CI

O Travis CI é uma plataforma de CI/CD baseada em nuvem que fornece testes e implantação automatizados para projetos de software. Ele suporta várias linguagens de programação e frameworks, tornando-o adequado para vários ambientes de desenvolvimento. Alguns de seus principais recursos incluem:

Prós:

Fácil de configurar e usar
Baseado em nuvem, não havendo a necessidade de configurar e manter a infraestrutura
Suporta uma grande variedade de linguagens de programação e frameworks
Fornece relatórios e análises detalhados

Contras:

Opções de personalização limitadas
Não é adequado para grandes projetos com requisitos complexos
Suporte limitado para instalações locais

Para saber mais sobre o Travis CI, clique aqui (em inglês).

GitHub Actions

GitHub Actions é uma ferramenta poderosa de CI/CD, que permite que os desenvolvedores automatizem fluxos de trabalho, executem testes e implantem código diretamente de seus repositórios no GitHub.

Prós:

Integrado ao GitHub
Fácil de usar
Fornece um grande ecossistema e boa documentação

Contras:

Minutos de compilação limitados
Sintaxe YAML complexa

Nota: menciono GitHub Actions aqui porque é uma ferramenta popular – mas lembre-se de que outros provedores de repositórios online, como GitLab e BitBucket, também oferecem opções muito semelhantes às GitHub Actions.

Recursos de CI/CD integrados por hosts

Hosts populares, como Vercel ou Netlify, têm recursos de CI/CD integrados que permitem vincular um repositório on-line a um determinado site e implantar nesse site após um determinado evento ocorrer nesse repositório.

Prós:

Muito simples de configurar e usar

Contras:

Opções de personalização limitadas

Cada uma dessas ferramentas tem seus recursos, prós e contras exclusivos. A escolha da ferramenta dependerá dos requisitos específicos do seu projeto, da experiência técnica da sua equipe e do seu orçamento.

Como configurar um pipeline de CI/CD com GitHub Actions

Agora que temos uma ideia clara do que é CI/CD, vamos ver como podemos implementar um exemplo simples com um projeto real usando GitHub Actions.

Inicializando o projeto

Começaremos com uma aplicação do React muito básica construída com Vite. Você pode fazer isso executando yarn create vite no seu console.

Vamos nos concentrar no pipeline de CI/CD aqui. Então, não haverá complexidade no código real da aplicação. Para se ter uma ideia, porém, o componente app.jsx terá este código:

import './App.css';

function App() {

    return (
        
            Vite + Reactooooo
        
    );
}

export default App;

Então, teremos um arquivo de teste que verificará se esse texto é renderizado:

import { describe, expect, it } from 'vitest';
import { render, screen } from './utils/test-utils/test-utils.jsx';

import App from 'src/App.jsx';

describe('App', async () => {
    it('deve renderizar durante a autenticação', () => {
        render();

        expect(screen.getByText('Vite + Reactooooo')).toBeInTheDocument();
    });
});

Esse teste será executado cada vez que executarmos o comando yarn test.

O próximo passo deve ser enviar nosso código para um repositório no GitHub. Vamos falar um pouco mais sobre o que são GitHub Actions e sobre como funcionam.

O que são GitHub Actions e como funcionam?

GitHub Actions é um serviço de CI/CD (Integração Contínua/Entrega Contínua) fornecido pelo GitHub. Ele permite que os desenvolvedores automatizem fluxos de trabalho definindo scripts personalizados, conhecidos como "ações", que podem ser acionados por eventos como pushes para um repositório, pull requests ou issues.

As ações são definidas em um arquivo YAML, também conhecido como "fluxo de trabalho", que especifica as etapas necessárias para concluir uma tarefa. Os fluxos de trabalho das GitHub Actions podem ser executados em ambientes Linux, Windows e macOS e suportam uma grande variedade de linguagens de programação e frameworks.

Quando um evento aciona um fluxo de trabalho das GitHub Actions, o serviço cria um novo ambiente, instala dependências e executa as etapas definidas na ordem especificada. Isso pode incluir tarefas como compilar, testar, empacotar e implantar código.

As GitHub Actions também fornecem várias ações integradas, que podem ser usadas para simplificar tarefas comuns, como verificar código, compilar e testar aplicações, publicar lançamentos e implantar em provedores de nuvem populares como AWS, Azure e Google Cloud.

Os fluxos de trabalho das GitHub Actions podem ser executados em um cronograma, manualmente ou automaticamente, quando um evento específico ocorre, como um pull request sendo aberto ou um novo commit sendo enviado para uma branch.

Configurando nosso fluxo de trabalho

Como vimos, basicamente, as GitHub Actions são um recurso que nos permite definir fluxos de trabalho para nossos projetos. Esses fluxos de trabalho nada mais são do que uma série de tarefas ou etapas que serão executadas na nuvem do GitHub após um determinado evento que declaramos.

A maneira como o GitHub lê e executa esses fluxos de trabalho é lendo automaticamente os arquivos dentro do diretório .github/workflows na raiz do nosso projeto. Esses arquivos de fluxo de trabalho devem ter a extensão .yaml e usar a sintaxe YAML.

Para criar um fluxo de trabalho, basta criar um arquivo YAML dentro desse diretório. Chamaremos o nosso de prod.yaml, pois o usaremos para implantar a branch de produção do nosso projeto.

Lembre-se de que um único projeto pode ter muitos fluxos de trabalho diferentes que executam tarefas diferentes em ocasiões diferentes. Por exemplo, poderíamos ter um fluxo de trabalho para branches de desenvolvimento e teste também, pois esses ambientes podem exigir tarefas diferentes para executar e provavelmente serão implantados em sites diferentes.

Depois de criar esse arquivo, vamos colocar o seguinte código nele:

# Nome do nosso fluxo de trabalho
name: Implantação de Produção

# Aciona o fluxo de trabalho no push para o branch principal
on:
  push:
    branches:
      - main

# Lista de trabalhos
# Um "trabalho" é um conjunto de etapas que são executadas no mesmo executor
jobs:
  # Nome do trabalho
  testar-e-implantar-no-netlify:
    # Sistema operacional para executar
    runs-on: ubuntu-latest

    # Lista de etapas que compõem o trabalho
    steps:
    # Faz checkout do seu repositório em $GITHUB_WORKSPACE, para que seu trabalho possa acessá-lo
    - name: Checkout do código
      uses: actions/checkout@v2

    # Configurar ambiente Node.js
    - name: Usar Node.js 16.x
      uses: actions/setup-node@v2
      with:
        node-version: '16.x'

    # Instalar dependências
    - name: Instalar dependências
      run: yarn install

    # Executar testes
    - name: Executar testes
      run: yarn test

    # Implantar no Netlify
    - name: Implantação Netlify
      uses: jsmrcaga/action-netlify-deploy@v2.0.0
      with:
        # Token de autenticação para usar com o Netlify
        NETLIFY_AUTH_TOKEN: ${{ secrets.NETLIFY_AUTH_TOKEN }}
        # ID do seu site Netlify
        NETLIFY_SITE_ID:  ${{ secrets.NETLIFY_SITE_ID }}
        # Diretório onde os arquivos compilados são armazenados
        build_directory: './dist'
        # Comando para instalar dependências
        install_command: yarn install
        # Comando para compilar o site estático
        build_command: yarn build

Então, nosso fluxo de trabalho tem as seguintes tarefas declaradas:

Etapa "Checkout do código", que faz checkout do último commit na branch atual.
Etapa "Usar Node.js 16.x", que configura o ambiente Node.js para a versão 16.x.
Etapa "Instalar dependências", que instala as dependências do projeto usando o gerenciador de pacotes Yarn.
Etapa "Executar testes", que executa os testes do projeto usando o gerenciador de pacotes Yarn.
Etapa "Implantação no Netlify", que implanta o projeto no Netlify usando a ação jsmrcaga/action-netlify-deploy. Essa etapa usa o token de autenticação do Netlify e os segredos de ID do site armazenados nos segredos do repositório GitHub. O diretório de compilação, o comando de instalação e o comando de compilação também são especificados.

Você provavelmente notou que a primeira e a última etapas têm a palavra-chave uses. Essa palavra-chave permite que você use ações ou fluxos de trabalho desenvolvidos por outros usuários do GitHub e é um dos melhores recursos das GitHub Actions.

Algo fantástico é o fato de que, ao usar essas ações de terceiros, podemos executar tarefas complexas, como implantar em um host externo ou construir infraestrutura de nuvem complexa, sem a necessidade de escrever cada linha de código necessária.

Como essas tarefas tendem a ser repetitivas e frequentemente executadas em muitos projetos, podemos simplesmente usar um fluxo de trabalho desenvolvido por uma conta oficial da empresa (como Azure ou AWS, por exemplo) ou um desenvolvedor independente de código aberto. Pense nisso como usar uma biblioteca de terceiros. É a mesma ideia, mas aplicada aos fluxos de trabalho de CI/CD. É muito conveniente.

Outra coisa importante a mencionar aqui é que, nos fluxos de trabalho das GitHub Actions, as tarefas são executadas sequencialmente, uma após a outra. Se uma determinada tarefa falhar ou lançar um erro, a próxima não será executada. Isso é importante porque, se tivermos um problema ao instalar nossas dependências ou se um teste falhar, não queremos que esse código seja implantado.

Antes de enviarmos esse código e vermos como a mágica funciona, primeiro, precisamos criar um site no Netlify e obter o NETLIFY_AUTH_TOKEN e o NETLIFY_SITE_ID. Isso é bastante direto. Mesmo quee você não tenha experiência anterior com o Netlify, experimente e pesquise um pouco no Google se não conseguir descobrir. 😉

Depois de ter esses dois tokens, você precisa declará-los como segredos do repositório no seu repositório do GitHub. Você pode fazer isso na guia de configurações (Settings):

Configure os dois tokens secretos do Netlify no seu repositório

Com isso em vigor, agora nosso arquivo prod.yaml poderá ler esses dois tokens e executar a ação de implantação do Netlify.

A mágica

Agora, que temos tudo no lugar, vamos enviar nosso código e ver como vai.

Após o push, se formos para a guia "Actions" do nosso repositório, à esquerda veremos uma lista de todos os fluxos de trabalho que temos em nosso repositório. À direita, veremos uma lista de cada execução do fluxo de trabalho selecionado. Como nosso fluxo de trabalho é executado após cada push, devemos ver uma nova execução cada vez que enviarmos.

Uma execução de fluxo de trabalho

Quando a execução tem uma luz amarela à esquerda, significa que ainda está em execução (executando tarefas). Se tiver uma luz verde, significa que terminou de executar com sucesso. Se a luz estiver vermelha, você sabe que algo deu errado.

Depois de clicar na execução, podemos ver uma lista dos trabalhos do fluxo de trabalho (tínhamos apenas um).

Os trabalhos do fluxo de trabalho

Depois de clicar no trabalho, podemos ver uma lista das tarefas do trabalho.

As tarefas do trabalho

Cada tarefa é expansível e, dentro dela, podemos ver os logs correspondentes à execução dessa tarefa. Isso é muito útil para fins de depuração. 😉

Agora, se formos para o nosso site do Netlify configurado anteriormente, devemos ver nossa aplicação funcionando!

Como temos nosso pipeline de CI/CD em funcionamento, podemos implantar nossa aplicação após cada push para a branch principal, tudo sem precisar de mais esforços. 😀

Conclusão

CI/CD é uma abordagem de desenvolvimento de software que oferece vários benefícios às equipes de desenvolvimento de software, incluindo tempo mais rápido de lançamento no mercado, qualidade aprimorada, maior colaboração, risco reduzido e custo-benefício.

Ao automatizar o pipeline de entrega de software, as equipes podem implantar rapidamente novos recursos e correções de bugs, ao mesmo tempo em que reduzem o risco de falhas graves e tempo de inatividade.

Com a disponibilidade de várias ferramentas de CI/CD, tornou-se mais fácil para as equipes implementarem essa abordagem e melhorarem seu processo de entrega de software.

Como sempre, espero que tenham gostado do artigo e aprendido algo novo.

Bancos de dados ACID – atomicidade, consistência, isolamento e durabilidade explicados

Kris Lagerström — Mon, 15 Jul 2024 21:00:00 +0000

Artigo original: ACID Databases – Atomicity, Consistency, Isolation & Durability Explained

ACID é a sigla para Atomicidade, Consistência, Isolamento e Durabilidade. Essas são quatro propriedades essenciais que a maioria dos sistemas de gerenciamento de bancos de dados (DBMS, do inglês DataBase Management Systems) oferece como garantia ao lidar com transações.

A maioria dos DBMS populares, como MySQL, PostgresSQL e Oracle, possui garantias ACID prontas para uso. Outros têm garantias ACID parciais, como Redis, DynamoDB e Cassandra. A tendência, no entanto, parece ser que mais e mais DBMS ofereçam conformidade com ACID.

É importante observar que, embora muitos DBMS possam afirmar ser compatíveis com ACID, a implementação dessa conformidade pode variar.

Assim, por exemplo, se o isolamento é uma propriedade fundamental de que você precisa para uma aplicação que está criando, é necessário entender como exatamente o DBMS escolhido implementa o isolamento.

Este artigo explicará o que são transações e analisará em detalhes o que significam atomicidade, consistência, isolamento e durabilidade, usando analogias e exemplos do mundo real.

Índice:

O que são transações?

Muitas coisas podem dar errado ao usar um banco de dados:

o hardware ou software do banco de dados pode falhar
a aplicação que chama o banco de dados pode falhar no meio da operação
a rede pode ficar congestionada com mais tráfego do que ela pode lidar (tornando-a inoperante)
vários clients podem fazer gravações ao mesmo tempo que sobrescrevem as alterações uns dos outros
os clients podem ler dados fantasmas, que não deveriam estar no banco de dados

Várias outras coisas podem dar errado - esta não é, de modo algum, uma lista completa.

Como algo pode dar errado de mais maneiras do que podemos prever, tentar evitar todas as falhas possíveis pode se tornar desnecessariamente caro e complicado. Em vez disso, é melhor projetar um sistema que possa continuar a operar apesar de uma falha. As transações nos permitem fazer isso.

As transações têm um único propósito: garantir que um sistema seja tolerante a falhas. Se ocorrer uma falha em um sistema, o sistema pode continuar a operar sem uma catástrofe completa? Dito de outro modo, o sistema consegue tolerar falhas? Uma resposta "sim" a essa pergunta significa que tal sistema é tolerante a falhas.

Então, o que é exatamente uma transação?

Não, não estamos falando DESTE tipo de transação

Uma transação é uma abstração. É um conjunto de operações (leituras e gravações) que são tratadas como uma única operação lógica.

Imagine que você deseja comprar um único livro em uma loja on-line, como a amazon.com.br, por exemplo. As etapas abaixo mostram uma visão simplificada do que precisa acontecer:

Primeiro, você seleciona o livro, adicionando o item à sua cesta.
A quantidade em estoque do livro é verificada para garantir que seja válida (ou seja, o valor do estoque para o título que você está comprando precisa ser maior que zero).
Você clica em "comprar", o que atualiza o estoque da Amazon para o livro e o diminui em 1 (já que você está comprando um único livro).
Além disso, o saldo da sua conta bancária é atualizado para contabilizar o custo do livro.

Uma transação garante que todas as operações relacionadas à compra sejam tratadas como uma única operação. Se qualquer parte da transação falhar, toda a transação é revertida, deixando o banco de dados em um estado como se o cliente nunca tivesse tentado a compra, mantendo assim a integridade dos dados.

A transação é confirmada quando todas as operações dentro da transação são concluídas com sucesso e seus resultados são registrados permanentemente. Essa permanência é normalmente alcançada gravando as alterações no armazenamento do banco de dados, que pode ser em disco para bancos de dados tradicionais ou na memória para bancos de dados na memória, como o Redis.

Ao tratar todas essas diferentes operações como uma única operação lógica, o banco de dados pode oferecer algumas garantias sobre como ele pode ser tolerante a falhas. Essas garantias são atomicidade, consistência, isolamento e durabilidade.

O que significa atomicidade?

Atomicidade significa simplesmente que todas as consultas em uma transação devem ser bem-sucedidas para que a transação seja bem-sucedida. Se uma consulta falhar, toda a transação falhará.

Um restaurante atômico

Imagine usar uma máquina de autoatendimento em um restaurante de fast-food. A transação, neste caso, é pedir comida e consiste em duas operações separadas:

Selecionar comida
Fazer o pagamento

Ambas devem ser bem-sucedidas para que a transação seja bem-sucedida. Se alguma falhar, a transação falhará.

Cliente fazendo um pedido em um restaurante "atômico"

Você seleciona seu hambúrguer, batata frita e uma bebida no menu da tela sensível ao toque. A máquina solicita que você pague e, somente depois de seu pagamento ser processado com sucesso, ela enviará seu pedido para a cozinha. Momentos depois, seu pedido completo está pronto e você o retira no balcão.

Essa é uma operação atômica: a transação (pedir comida) é totalmente concluída (se você selecionar seu item de comida e fizer um pagamento) ou não é concluída.

Se qualquer parte da transação falhar, toda a transação falhará. Se o seu pagamento falhar, a máquina não processará nenhuma parte do pedido, então a transação falhará. Se você fizer um pagamento sem selecionar um item de comida, a transação também falhará, pois não há nada para a cozinha preparar.

Um restaurante não atômico

Agora, considere a alternativa – um restaurante tradicional com serviço de mesa onde você pede vários pratos. À medida que cada prato é preparado, ele é trazido à sua mesa.

Cliente fazendo um pedido em um restaurante "não atômico"

Novamente, a transação é pedir comida e consiste em duas operações separadas:

Selecionar comida
Fazer o pagamento

Nesse restaurante não atômico, a falha em fazer um pagamento não impede que a transação seja concluída, pois você paga depois de terminar sua refeição. Falhas parciais não fazem com que uma transação falhe.

Isso cria um risco para o restaurante. Os clientes que optam por comer e sair correndo podem pedir comida à vontade e simplesmente ir embora sem pagar, causando prejuízo financeiro para o restaurante.

Restaurantes não atômicos correm o risco de clientes darem o golpe da "saidinha"

Transações atômicas

Se várias consultas SQL são agrupadas em uma transação, a atomicidade é uma garantia de que, se alguma das consultas falhar por qualquer motivo (problemas de hardware, da aplicação ou da rede), a transação será interrompida e o banco de dados retornará ao seu estado anterior, como se nada tivesse acontecido.

Sem atomicidade, se ocorrer uma falha enquanto algumas consultas estão sendo executadas, é difícil saber quais consultas foram confirmadas (ou seja, concluídas) e quais não foram. Executar as consultas novamente após uma falha pode agravar o problema, pois você corre o risco de introduzir dados incorretos no banco de dados ao executar novamente consultas que foram bem-sucedidas anteriormente.

As transações atômicas evitam essa incerteza, pois você sabe que, se a transação anterior falhou, ela falhou em sua totalidade e você pode simplesmente tentar novamente sem se preocupar em introduzir dados inconsistentes.

O que significa consistência?

Consistência pode significar coisas diferentes em engenharia de nuvem/software, dependendo do contexto. No caso de ACID, o "C" provavelmente foi adicionado para fazer a abreviação funcionar.

Consistência no contexto de ACID significa consistência nos dados, que é definida pelo criador do banco de dados. O termo técnico para consistência de dados é integridade referencial. A integridade referencial é um método para garantir que os relacionamentos entre as tabelas permaneçam consistentes. Geralmente, é aplicada por meio do uso de chaves estrangeiras.

Para entender a integridade referencial, considere o seguinte.

Imagine um sistema de biblioteca com dois tipos de cartões: um cartão de livro e um cartão de usuário.

O cartão de livro lista todos os livros disponíveis na biblioteca.
O cartão de usuário rastreia quais livros estão emprestados para quais membros.

Um cartão de livro e um cartão de usuário para uma biblioteca

A regra da biblioteca é que um livro só pode ser listado no cartão de um usuário se ele existir no cartão de livro. Isso é integridade referencial. Se alguém tentar listar um livro no cartão de um usuário que não está no cartão de livro (ou seja, um livro que não existe na biblioteca), o sistema não permitirá.

Embora a atomicidade, o isolamento e a durabilidade sejam propriedades intrínsecas ao próprio banco de dados, a consistência dos dados, ou integridade referencial, não é uma propriedade intrínseca ao banco de dados.

A consistência é definida pelo criador do banco de dados. A aplicação que chama o banco de dados depende das propriedades de atomicidade e isolamento do banco de dados para manter essa consistência.

O que significa isolamento?

Isolamento é uma garantia de que transações executadas simultaneamente não devam interferir umas nas outras. Concorrência aqui se refere a duas ou mais transações tentando modificar ou ler os mesmos registros do banco de dados ao mesmo tempo.

Existem três níveis de isolamento de transação. Vou apenas explicar os dois principais abaixo, organizados do menos rígido para o mais rígido.

Leitura confirmada (read committed)

Isso oferece duas garantias. Impede leituras sujas e gravações sujas.

Sem leituras sujas (no dirty reads): ler dados de outra transação que ainda não foi confirmada é chamado de "leitura suja". Com o nível de isolamento de leitura confirmada, você verá apenas os dados que foram confirmados por outra transação.

Sem gravações sujas (no dirty writes): sobrescrever dados que já foram gravados por outra transação, mas que ainda não foram confirmados, é chamado de "gravação suja".

Para entender como funciona o isolamento de leitura confirmada, considere o seguinte exemplo.

Imagine um restaurante de fast-food com apenas um último hambúrguer especial disponível e dois clientes famintos, Marie e Marko, tentando comprá-lo simultaneamente.

Dois clientes pedindo um hambúrguer ao mesmo tempo

Marie verifica a disponibilidade de hambúrgueres e vê o último disponível. Sem que ela saiba, o pedido de Marko está sendo processado, mas ainda não foi finalizado no sistema, pois ele não pagou. Como seu pedido ainda não foi finalizado, Marie não sabe que seu pedido está em conflito com o dela. Isso é semelhante a uma transação lendo os dados confirmados mais recentemente, onde ela não vê as alterações não confirmadas (como o pedido pendente de Marko).
Marie faz um pedido com base nessas informações incompletas, pensando que um hambúrguer está disponível.
Assim que Marko paga, o sistema é atualizado para mostrar que não há mais hambúrgueres restantes. Isso é semelhante a uma transação sendo confirmada.
O pedido de Marie terá que ser negado, pois não há mais hambúrgueres restantes.

O ponto principal aqui é a etapa nº 3. Se o pagamento de Marko falhar nesta fase, a transação não será confirmada e ainda haverá um hambúrguer disponível para Marie.

Nesse exemplo, o isolamento de leitura confirmada garante que Marie não tenha a compra do hambúrguer prematuramente negada apenas porque outra pessoa disse que o queria. Somente transações confirmadas podem ser lidas. Portanto, o hambúrguer está disponível para ser pedido, desde que ninguém o tenha pago.

Leitura repetitiva (repeatable read)

A leitura repetitiva é um nível de isolamento mais rígido, pois oferece as mesmas garantias que o isolamento de leitura confirmada – além de garantir que as leituras sejam repetitivas.

Uma leitura repetitiva garante que, se uma transação ler uma linha de dados, quaisquer leituras subsequentes dessa mesma linha de dados dentro da mesma transação produzirão o mesmo resultado, independentemente das alterações feitas por outras transações. Essa consistência é mantida durante toda a duração da transação.

Quando uma transação lê os mesmos dados duas vezes, mas vê um valor diferente em cada leitura porque uma transação confirmada atualizou o valor entre as duas leituras, isso é chamado de leitura difusa. O nível de isolamento de leitura repetitiva impede leituras difusas.

Leituras difusas não são inerentemente boas nem ruins. Tudo depende do que você está tentando alcançar.

Leituras difusas são ruins para transações de longa duração somente leitura, pois novas gravações podem ocorrer durante a transação e isso pode causar inconsistências nos dados. Exemplos de transações de longa duração somente leitura são um back-up de banco de dados e consultas analíticas normalmente usadas em um data warehouse.

Leituras repetitivas são geralmente implementadas pelo DBMS lendo de um instantâneo do banco de dados que permanece inalterado durante a transação, ignorando assim quaisquer novas gravações confirmadas nesse período.

O que significa durabilidade?

Durabilidade é uma garantia de que as alterações feitas por uma transação confirmada não devem ser perdidas. Todas as transações confirmadas devem ser persistidas em armazenamento durável e não volátil, ou seja, em disco. Isso garante que quaisquer transações confirmadas sejam protegidas, mesmo se o banco de dados travar.

Naturalmente, a durabilidade não pode proteger contra a destruição do disco que armazena os dados. Redundância adicional pode ser adicionada, tendo back-ups do seu banco de dados armazenados separadamente do original.

Juntando tudo

O ACID (Atomicidade, Consistência, Isolamento e Durabilidade) fornece um conjunto de garantias ao trabalhar com um DBMS. Embora a maioria dos DBMS relacionais sejam compatíveis com ACID, a implementação dessa conformidade pode variar.

A atomicidade garante que todas ou nenhuma das partes de uma transação sejam concluídas. Falhas parciais não são permitidas.

A consistência, ou integridade referencial, garante que os dados permaneçam precisos e confiáveis, aderindo a regras predefinidas. Ao contrário das outras prioridades, a consistência não é intrínseca ao próprio DBMS. Em vez disso, a aplicação que chama o banco de dados depende das propriedades de atomicidade e isolamento do banco de dados para manter a consistência.

O isolamento é uma garantia de que transações executadas simultaneamente não devem interferir umas nas outras. Essa é, indiscutivelmente, a propriedade mais importante, porque um DBMS pode frequentemente ter diferentes níveis de isolamento padrão, que podem precisar ser alterados com base no que é necessário para a sua aplicação.

Por fim, a durabilidade é uma garantia de que as alterações feitas por uma transação confirmada não devem ser perdidas.

Kris Lagerström - freeCodeCamp.org

Uma introdução aos testes unitários com o Jasmine

Apresentando o Jasmine

Usando o Jasmine

Usando o Jasmine como uma biblioteca

Usando o Jasmine via CLI

Entendendo o Jasmine

Suítes

Como agrupar e aninhar suítes

Como excluir suítes

Especificações

Como excluir especificações

Expectativas

Matchers integrados

Matchers personalizados

Usando beforeEach() e afterEach()

Falhando um teste

Testando exceções

Entendendo spies

Como lidar com assincronia no Jasmine

Usando done() com beforeEach()/it() ..

Usando as promises

Usando async/await

Usando o Jasmine Clock

Lidando com erros

Conclusão

Como realizar testes de integração usando JUnit 5 e TestContainers com SpringBoot

Limitações do teste com um banco de dados H2 na memória

Apresentando a biblioteca TestContainers

O que são os TestContainers?

Como usar a biblioteca TestContainers

Anotações em TestContainers

Métodos da biblioteca TestContainers

Caso de uso do TestContainers

Como usar o GenericContainer

Conclusão

Teste do JUnit com o Maven no VSCode

Instalar o VSCode

Instalar e criar um projeto do Maven

Modificar nosso projeto

Migrando do JUnit 4 para o JUnit 5

Construindo uma aplicação de CRUD simples com Express e MongoDB

CRUD, Express e MongoDB

O que vamos construir

Começando

Executando o Node pela primeira vez em sua vida

Usando o Express

CRUD — LER

Apresentando o Nodemon

CRUD — CRIAR

MongoDB

Mostrando citações aos usuários

Conclusão

O que é uma API e como ela funciona? APIs para iniciantes

O que é uma API?

Como as APIs funcionam?

Métodos HTTP

Códigos de status HTTP

Tipos de APIs

Recursos para aprender mais sobre APIs:

Conclusão

A grande competição entre os termos usados em programação

Tipagem estática x dinâmica

Verificação de tipo estática

Verificação de tipo dinâmica

Tipagem forte x fraca

Tipagem forte

Tipagem fraca

Dados mutáveis x imutáveis

Dados imutáveis

Dados mutáveis

Funções puras x impuras

Funções puras

Funções impuras

Avaliação lenta x avaliação rápida

Avaliação lenta

Avaliação rápida

Declarativo x imperativo

Programação declarativa

Programação imperativa

Usando `done()` com `beforeEach()`/`it()` ..