DEV Community: PHP Brasil

Protegendo seu servidor contra acessos indevidos

Daniel — Wed, 03 Feb 2021 16:08:30 +0000

Se você precisa de segurança extra em um servidor Linux/Debian, e você sempre precisa, lá vai uma dica de ouro, desative acesso SSH por meio de senhas, assim você evitará qualquer ataque do tipo força bruta, vamos a prática.

No servidor

Crie um par de chaves SSH;

ssh-keygen -b 4096

Generating public/private rsa key pair.
Enter file in which to save the key (/home/pi/.ssh/id_rsa):

Tecle enter para confirmar;

Created directory '/home/pi/.ssh'.

Crie uma senha para sua chave SSH e confirme;

Enter passphrase (empty for no passphrase):
Enter same passphrase again:

A chave foi gerada com sucesso, veja o resultado abaixo;

The key fingerprint is:
SHA256:oVHrP/nGj3umYFkKRvnC/SKk8nSgHmeZ/OTUAQS+gvs pi@raspberrypi
The key's randomart image is:
+---[RSA 4096]----+
|      ..o        |
|     . o o       |
|      o *        |
|   .   B =       |
|  . . + S + .    |
|   . + B = B     |
|  . + O = @..    |
|   o B * o =o.o  |
|    E . o  .=*.  |
+----[SHA256]-----+

Chaves SSH ficam salvas na pasta oculta .ssh na raiz do seu usuário Linux, no meu caso estão em:

/home/pi/.ssh

Digitando o comando ls dá pra ver o seu par de chaves(pública, privada), do lado do servidor o trabalho está terminado.

id_rsa  id_rsa.pub

No cliente

Autorize a sua máquina cliente a se conectar ao servidor sem precisar digitar uma senha, para isso vamos copiar a chave pública do cliente para dentro do servidor, e autorizar o acesso, basta um simples comando pra isso:

cat ~/.ssh/id_rsa.pub | ssh pi@192.168.15.2 'mkdir -p ~/.ssh && cat >> ~/.ssh/authorized_keys'

Na próxima etapa digite yes, assim você está informando que reconhece o servidor;

The authenticity of host '192.168.15.2 (192.168.15.2)' can't be established.
ECDSA key fingerprint is SHA256:g1gtgJgDd24rXR0KJTTBjdLUI+SX829GTwQ1CYgVCiQ.
Are you sure you want to continue connecting (yes/no/[fingerprint])?
Warning: Permanently added '192.168.15.2' (ECDSA) to the list of known hosts.

Neste momento um arquivo chamado .ssh/authorized_keys será criado no servidor, esse arquivo tem a chave pública do cliente, indicando assim que o mesmo possui autorização de acesso ao servidor.

Digite a senha do servidor;

pi@192.168.15.2's password:

Conecte-se ao servidor;

ssh <USERNAME>@<IP-ADDRESS>

No meu caso o comando será;

ssh pi@192.168.15.2

Pra mim a mensagem de boas-vindas foi a seguinte:

Linux raspberrypi 5.4.83-v7+ #1379 SMP Mon Dec 13 20:08:57 GMT 2020 armv7l

Passo final, o "pulo do gato"

O último passo é desativar a autenticação por senha no servidor, para isso basta editar o arquivo com as configurações de ssh no servidor, use o comando:

sudo nano /etc/ssh/sshd_config

O arquivo será aberto e estará pronto para edição, apenas procure o seguinte trecho:

#PasswordAuthentication yes

Edite o trecho removendo o comentário # deixando assim:

PasswordAuthentication no

Reinicie o servidor

sudo reboot

Tudo certo, a partir de agora você não precisa mais digitar senhas para ter acesso ao servidor, e ainda garante que apenas acessos via SSH e autorizados serão aceitos, desta forma a segurança está garantida no seu servidor

Assinando commits com uma chave GPG

Daniel — Thu, 17 Dec 2020 16:16:02 +0000

O Git tem a opção de assinar e verificar seus commits utilizando-se de chave GPG, para isso basta seguir os passos a seguir

Passo 1 - Gere uma nova chave GPG

1 - Digite o comando para gerar a chave GPG;

gpg --full-generate-key

2 - Selecione a opção: (1) RSA e RSA (padrão);

gpg (GnuPG) 2.2.4; Copyright (C) 2017 Free Software Foundation, Inc.
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.

Por favor selecione o tipo de chave desejado:
   (1) RSA e RSA (padrão)
   (2) DSA e Elgamal
   (3) DSA (apenas assinatura)
   (4) RSA (apenas assinar)
Sua opção?

3 - Digite o maior comprimento(4096), para sua nova chave GPG;

RSA chaves podem ter o seu comprimento entre 1024 e 4096 bits.
Que tamanho de chave você quer? (3072) 4096

4 - Decida qual o prazo de expiração para sua chave;

Por favor especifique por quanto tempo a chave deve ser válida.
         0 = chave não expira
      <n>  = chave expira em n dias
      <n>w = chave expira em n semanas
      <n>m = chave expira em n meses
      <n>y = chave expira em n anos
A chave é valida por? (0)

5 - Confirme o tempo de expiração da chave;

A chave não expira nunca
Está correto (s/N)?

6 - Digite seu nome completo;

GnuPG precisa construir uma ID de usuário para identificar sua chave.

Nome completo:

7 - Digite seu email;

Endereço de correio eletrônico:

8 - Crie um comentário para sua chave caso seja necessário;

Comentário:

9 - Confirme as informações que você acabou de preencher, basta digitar o para OK;

Você selecionou este identificador de usuário:
    "Joao Ninguem <joao@ninguem.nada>"

Muda (N)ome, (C)omentário, (E)ndereço ou (O)k/(S)air?

10 - Digite uma senha segura para sua chave GPG e confirme a senha;

11 - Aguarde o processo de criação de sua chave finalizar;

Precisamos gerar muitos bytes aleatórios. É uma boa idéia realizar outra
atividade (digitar no teclado, mover o mouse, usar os discos) durante a
geração dos números primos; isso dá ao gerador de números aleatórios
uma chance melhor de conseguir entropia suficiente.
gpg: chave FD2B172CC4C9F3E4 marcada como plenamente confiável
gpg: revocation certificate stored as '/home/geekcom/.gnupg/openpgp-revocs.d/92518C10D23E004325112DB9FD2B172CC4C9F3E4.rev'
chaves pública e privada criadas e assinadas.

pub   rsa4096 2020-04-28 [SC]
      92518C10D23E004325112DB9FD2B172CC4C9F3E4
uid                      Joao Ninguem <joao@ninguem.nada>
sub   rsa4096 2020-04-28 [E]

Neste momento sua chave GPG foi gerado com sucesso, agora é necessário adiciona-la ao GitHub.

Passo 2 - Adicionando uma chave GPG ao GitHub

1 - Use o seguinte comando para listar a chave GPG privada que você acabou de criar:

gpg --list-secret-keys --keyid-format LONG joao@ninguem.nada

Substitua joao@ninguem.nada pelo e-mail que você usou para criar a chave.

2 - Copie o ID da chave GPG que começa com sec. No exemplo a seguir, é FD2B172CC4C9F3E4:

sec   rsa4096/FD2B172CC4C9F3E4 2020-04-28 [SC]
      92518C10D23E004325112DB9FD2B172CC4C9F3E4
uid                 [final] Joao Ninguem <joao@ninguem.nada>
ssb   rsa4096/AB9EC40EA9DE16E3 2020-04-28 [E]

3 - Exporte a chave pública desse ID (substitua pelo seu ID da chave da etapa anterior):

gpg --armor --export FD2B172CC4C9F3E4

4 - Por fim, copie a chave pública e adicione-a nas configurações do seu perfil do GitHub em https://github.com/settings/keys

Passo 3 - Associando sua chave GPG ao Git

1 - Depois de criar sua chave GPG e adicioná-la à sua conta GitLab, é hora de informar ao Git qual chave usar.

gpg --list-secret-keys --keyid-format LONG joao@ninguem.nada

Substitua joao@ninguem.nada pelo seu email.

2 - Copie o ID da chave GPG que começa com sec. No exemplo a seguir, é FD2B172CC4C9F3E4:

sec   rsa4096/FD2B172CC4C9F3E4 2020-04-28 [SC]
      92518C10D23E004325112DB9FD2B172CC4C9F3E4
uid                 [final] Joao Ninguem <joao@ninguem.nada>
ssb   rsa4096/AB9EC40EA9DE16E3 2020-04-28 [E]

3 - Diga ao Git que deseja usar essa chave para assinar os seus commits:

git config --global user.signingkey FD2B172CC4C9F3E4

Substitua FD2B172CC4C9F3E4 pelo ID da sua chave GPG.

Passo 4 - Assinando commits com sua chave GPG

Depois de criar sua chave GPG e adicioná-la à sua conta, você pode começar a assinar seus commits:

1 - Continua como você costumava fazer, a única diferença é a adição da flag -S:

git commit -S -m "mensagem do meu commit"

2 - Digite a senha da sua chave GPG quando solicitada.

A partir de agora seus commits podem assinados com sua chave GPG sempre que desejar, no GitHub você poderá ver que seus commits estão assinados.

Como o PHP lida com a questão da segurança

Daniel — Tue, 29 Sep 2020 19:04:28 +0000

O que é um problema de segurança?

O time do PHP classifica como problemas de segurança, bugs que:

Permitem que os usuários executem ações não autorizadas;
Cruzam os limites de segurança;
Acessam dados que não deveriam ser acessíveis;
Impactam severamente a acessibilidade ou desempenho do sistema.

O objetivo desta classificação é alertar os usuários e desenvolvedores sobre problemas que precisam ser tratados como prioridade.

O PHP é seguro

Esta afirmação é possível com base no conhecimento do ciclo de vida de uma vulnerabilidade no PHP, em resumo o processo funciona assim:

Uma possível vulnerabilidade é reportada;
Então ela é avaliada por alguém do time ou um contribuidor externo/você que está lendo;
Acontecerá uma discussão sobre o suposto bug;
O problema é resolvido;
Uma versão menor (por exemplo: 7.4.9), é criada contendo a solução, depois é possível ver no log de mudanças tudo que foi resolvido;
Novas versões, são criadas em média a cada 4 semanas.

Cuidando da segurança

Mantenha-se informado, fique atento aos materiais que a comunidade disponibiliza;
Sempre que possível atualize a versão;
Observe todos os outros aspectos de segurança (códigos, sistemas operacionais, configurações, infra estrutura e o fator humano/engenharia social).

Conclusão

Nenhum sistema é invulnerável, pois o fator humano sempre existirá. Entretanto é possível mitigar a maioria dos problemas que acontecem em softwares, mas isso requer um pouco de atenção e cuidados por parte de todos os envolvidos.

Deixe nos comentários o que você acha disso.

Referências e links úteis

https://bugs.php.net/
https://wiki.php.net/security
https://www.php.net/supported-versions.php
https://www.php.net/eol.php

PHP assíncrono de forma nativa

Vinicius Dias — Wed, 16 Sep 2020 12:42:21 +0000

Realizar acesso a streams é uma tarefa relativamente comum para devs PHP. Seja lendo e escrevendo em arquivos, fazendo requisições HTTP, etc.

Operações de I/O são custosas e levam algum tempo para executar. Quando temos diversas operações desse tipo, uma técnica que pode ajudar (e muito) na performance da aplicação é realizá-las de forma assíncrona.

Acesso a streams

Antes de falar sobre técnicas e funções que permitem a programação assíncrona, é importante saber como normalmente nós trabalhamos com I/O.

Acesso a arquivos, requisições HTTP, sockets e muito mais pode ser feito através de streams. Um stream é basicamente um fluxo de dados, sendo que a origem desse fluxo pode variar (vide o início desse parágrafo). Quando utilizamos funções como file_get_contents, fopen, fgets, e as demais, estamos trabalhando com streams do PHP.

Programação assíncrona

Se você não está familiarizado com o termo "programação assíncrona", recomendo assistir este vídeo antes de continuar o artigo:

Entendido o que é programação assíncrona, como podemos fazer acesso a streams de forma assíncrona utilizando PHP sem nenhuma extensão ou biblioteca externa? Será possível?

Eventos

Programação orientada a eventos não é novidade e nós utilizamos muito na web. Para agir quando um botão for clicado, ou quando um texto for digitado em um input nós utilizamos eventos no JavaScript. Eventos podem acontecer a qualquer momento então sua natureza é assíncrona. Mas será possível fazer algo parecido do lado do PHP?

Antes de falar do PHP em si, acho válido citar que o sistema operacional já trabalha com chamadas assíncronas. Diversos eventos acontecem durante a execução do seu sistema, e há código reagindo a estes eventos o tempo todo. Utilizando PHP nós podemos acessar algumas dessas funcionalidades do sistema operacional

Função stream_select

Uma função não muito comum para nós que trabalhamos com PHP é a stream_select. Essa função nos permite "observar" modificações que possam acontecer em streams. O probelma é que ela não é nada fácil de se entender, então vou tentar tornar este processo menos doloroso para você.

Cenário

Imagine que para executar uma tarefa nós precisemos ler 5 arquivos distintos e depois realizar algum processamento. Normalmente utilizando PHP nós poderíamos fazer algo como:

<?php

$conteudoDoArquivo1 = file_get_contents('arquivo1.txt');
$conteudoDoArquivo2 = file_get_contents('arquivo2.txt');
$conteudoDoArquivo3 = file_get_contents('arquivo3.txt');
$conteudoDoArquivo4 = file_get_contents('arquivo4.txt');
$conteudoDoArquivo5 = file_get_contents('arquivo5.txt');

// Processar os 5 arquivos

O problema nessa abordagem é óbvio: Antes de ler o arquivo2.txt precisamos terminar de ler todo o conteúdo de arquivo1.txt. Enquanto o computador espera, nós já poderíamos estar sendo os demais arquivos e os processando de forma individual.

Quando temos uma operação de I/O (acesso a arquivos, rede, etc) sendo realizada de forma síncrona, o processador fica ocioso enquanto a operação não é executada. Ou seja, enquanto o arquivo estiver sendo carregado, o processador fica esperando, sem fazer nada. É exatamente isso que queremos evitar. Queremos garantir que ele continue trabalhando enquanto o arquivo não estiver pronto para leitura.

Solução com assincronicidade

Para resolver essa situação, podemos utilizar a função stream_select que observa alterações no status de uma lista de streams, ou seja, quando algum dos arquivos estiver pronto para leitura, essa função nos avisará. E é interessante citar que a leitura não necessariamente vai acontecer em ordem. O sistema operacional pode abrir o arquivo3.txt mais rápido do que o arquivo1.txt, por exemplo. Neste cenário, vamos processá-lo logo, sem ficar esperando os arquivos anteriores.

<?php

$listaDeStreamsDeArquivos = [
    fopen('arquivo1.txt', 'r'),
    fopen('arquivo2.txt', 'r'),
    fopen('arquivo3.txt', 'r'),
    fopen('arquivo4.txt', 'r'),
    fopen('arquivo5.txt', 'r'),
];

foreach ($listaDeStreamsDeArquivos as $streamDeArquivo) {
    stream_set_blocking($streamDeArquivo, false);
}

do {
    $streamsParaLer = $listaDeStreamsDeArquivos;
    $streamsComNovidades = stream_select($streamsParaLer, $write, $except, 1, 0);

    if ($streamsComNovidades === false) {
        echo 'Erro inesperado';
        exit(1);
    }

    if ($streamsComNovidades === 0) {
        continue;
    }

    foreach ($streamsParaLer as $indice => $streamDeArquivo) {
        $conteudo = stream_get_contents($streamDeArquivo);
        // processa o conteúdo do arquivo
        if (feof($streamDeArquivo)) {
            fclose($streamDeArquivo);
            unset($listaDeStreamsDeArquivos[$indice]);
        }
    }
} while ($listaDeStreamsDeArquivos !== []);

Explicação

Preparação

Como eu disse, não é muito fácil, então vamos por partes. Primeiro abrimos todos os arquivos que queremos ler com o fopen. Até aí sem segredo. Depois, informamos com a função stream_set_blocking que o recurso deve ser aberto em modo não-bloqueante - assim, o processo que acessa o arquivo não bloqueará a CPU por causar um estado de espera ao tentar acessar os arquivos.

Nesse ponto, temos um array com 5 recursos abertos para podermos trabalhar com estes streams. Então analisando o este pedaço de código:

$listaDeStreamsDeArquivos = [
    fopen('arquivo1.txt', 'r'),
    fopen('arquivo2.txt', 'r'),
    fopen('arquivo3.txt', 'r'),
    fopen('arquivo4.txt', 'r'),
    fopen('arquivo5.txt', 'r'),
];

var_dump($listaDeStreamsDeArquivos);

Teríamos a seguinte saída:

array(5) {
  [0]=>
  resource(5) of type (stream)
  [1]=>
  resource(6) of type (stream)
  [2]=>
  resource(7) of type (stream)
  [3]=>
  resource(8) of type (stream)
  [4]=>
  resource(9) of type (stream)
}

Depois disso que começa a parte difícil. A chamada para a função stream_select deve estar em um loop, porque pode acontecer de nem todos os streams estarem prontos para leitura logo de cara.

Parâmetros

Segundo detalhe importante: os parâmetros. O 3 primeiros parâmetros dessa função são passados por referência. Por isso o segundo e terceiro são variáveis que nós nem tínhamos definido ainda. O primeiro parâmetro é a lista de streams que queremos observar para ler. O segundo é para escrita. Já o terceiro, menos comum, é para dados excepcionais que possuem maior prioridade. Os 2 últimos parâmetros são sobre timeout.

O parâmetro passado como 1 indica o número de segundos que essa função deve esperar receber uma notificação de novidade nos streams até "desistir", ou seja, o timeout. Esse é o motivo pelo qual ela deve estar em um loop. Se esse tempo passar e nós não tivermos novidade, devemos tentar de novo depois. Caso algum (não necessariamente todos) stream esteja pronto antes desse 1 segundo, a função retornará. O último parâmetro, que informamos como 0, indica o tempo em microsegundos para timeout.

Retorno e leitura

Agora vamos falar do retorno. Essa função retorna o número de streams que contém modificações. No nosso caso, vai informar quantos arquivos estão prontos para leitura. Porém em caso de erro essa função nos retorna o valor false.

Além disso, os parâmetros que nós passamos podem ter sido modificados. Por isso eu realizo uma cópia da lista original de streams em $arquivosParaLer = $listaDeArquivos;. Após o retorno da função, o parâmetro passado vai conter apenas os streams que possuem novidades, ou seja, no nosso caso, os arquivos que estão prontos para leitura.

Para exemplificar, vamos supor que na primeira execução do loop todos os arquivos já estejam disponíveis. Nesse caso, analisando os valores das variáveis, podemos entender o que está acontecendo. Analisando então o valor de $streamsComNovidades, teríamos int(5) como resultado deste cenário.

Já analisando ambos arrays de streams ($listaDeStreamsDeArquivos e $streamsParaLer), teríamos exatamente o mesmo resultado:

array(5) {
  [0]=>
  resource(5) of type (stream)
  [1]=>
  resource(6) of type (stream)
  [2]=>
  resource(7) of type (stream)
  [3]=>
  resource(8) of type (stream)
  [4]=>
  resource(9) of type (stream)
}
array(5) {
  [0]=>
  resource(5) of type (stream)
  [1]=>
  resource(6) of type (stream)
  [2]=>
  resource(7) of type (stream)
  [3]=>
  resource(8) of type (stream)
  [4]=>
  resource(9) of type (stream)
}

Agora caso na primeira execução tivéssemos apenas 3 dos 5 arquivos prontos, e analisássemos os 3 valores anteriores, teríamos ter algo como:

var_dump($streamsComNovidades, $listaDeStreamsDeArquivos, $streamsParaLer);

int(3)
array(5) {
  [0]=>
  resource(5) of type (stream)
  [1]=>
  resource(6) of type (stream)
  [2]=>
  resource(7) of type (stream)
  [3]=>
  resource(8) of type (stream)
  [4]=>
  resource(9) of type (stream)
}
array(3) {
  [0]=>
  resource(5) of type (stream)
  [2]=>
  resource(7) of type (stream)
  [4]=>
  resource(9) of type (stream)
}

Onde, nesse caso, o segundo array exibido é o de $streamsParaLer, e possui apenas os 3 arquivos prontos para leitura.

Sendo assim, posso percorrer este array tendo a certeza de que há dados para ler e processar. Mas não há garantia de que todo o conteúdo do arquivo estará lá, por isso verifico se cheguei ao fim do arquivo com feof. Para arquivos pequenos, via de regra, todo o conteúdo virá de uma vez só, mas não conte com isso e prepare seu código para ler até mesmo um único byte por vez.

Após ler todo o arquivo, devemos fechá-lo. Mas um outro detalhe importante é que eu também o removo da lista original de streams que queremos ler. Faço isso para que caso seja necessária uma nova iteração no loop, ou seja, caso nem todos os arquivos tenham sido lidos, eu não tente ler novamente os arquivos que já foram lidos e fechados.

Com isso temos nossa condição de saída do loop. Quando todos os arquivos tiverem sido removidos e minha lista estiver vazia, sei que processei todos os arquivos.

PS.: A função stream_set_blocking só surte efeito com arquivos e sockets. Os outros wrappers, com esta técnica, não podem ser lidos de forma assíncrona e não bloqueante.

Conceitos

Esse código obviamente pode ser refatorado para torná-lo um pouco mais legível, mas acredito que a lógica por trás dele tenha ficado clara. Caso contrário, você pode usar a sessão de comentários dessa página para fazer perguntas.

O que nós escrevemos de forma rudimentar aqui pode ser visto como uma implementação do que é conhecido como Event Loop, ou loop de eventos. Você provavelmente já ouviu esse termo se estuda sobre a runtime Node.js.

Claro que essa implementação não é completa ou otimizada, mas atende nosso propósito: ler arquivos conforme eles fiquem prontos para leitura. Dessa forma nós vamos pedir para que o sistema operacional prepare todos os arquivos para leitura de uma só vez.

As vantagens nessa abordagem assíncrona são mais perceptíveis quando temos operações mais lentas como chamadas HTTP, por exemplo. Mas isso aumentaria a complexidade do código para este artigo.

Conclusão

Claro que o PHP já possui ferramentas que realizam este trabalho de forma muito mais simples. ReactPHP com seu pacote de Streams é um ótimo exemplo.

Mas seguindo o que citei no post sobre aprendizado, eu penso como Richard Feynman (Nobel de física): "O que eu não consigo criar, eu não entendo". Então antes de utilizar uma ferramenta que realiza o trabalho para mim, eu gosto de saber como realizar este trabalho sem ela. Com isso, se algum problema acontecer com a biblioteca, por exemplo, eu vou estar mais preparado para resolvê-lo já que eu entendo um pouco melhor como as coisas funcionam.

Além disso, se chamadas HTTP assíncronas com essa técnica é um assunto que te interessa, interaja com essa publicação para que eu produza um conteúdo sobre isso.

TDD: Iniciando com TDD no PHP

Eduardo Figueiredo Gonçalves — Sat, 23 May 2020 02:53:27 +0000

TDD

Estava estudando um pouco sobre TDD e vi o artigo que me fez pensar em algumas coisas interessantes e resolvi escrever esse post.

Vou fazer algumas colocações sobre o material e mostrar alguns exemplos dele, recomendo darem uma lida no texto antes que eu curti demais. Durante sprints de desenvolvimento em SCRUM há situações que podem ser resumidas à imagem:

Há momentos do dia em que estamos com muito gás e outros que a nossa produtividade se esgota. Desde sistemas de pequena complexidade até em sistemas mais complexos há alguns CRUDs que se repetem como por exemplo CRUD de Autenticação e CRUD de ACL (Controle de Acesso), será que quando formos unir todas os módulos tudo funcionará conforme esperado? Acredito que a grande maioria saiba que as chances de erros inesperados é enorme e para contornarmos esse problema falaremos sobre a técnica de TDD que é uma grande aliada do programador. As regras de TDD são: escreva testes, escreva código, refatore.

TDD do inglês Test Driven Development ou em nossa língua nativa Desenvolvimento Guiado por Testes basicamente consiste em seguir um simples algoritmo de 3 passos para o desenvolvimento de software.

Você não tem permissão de escrever um código de produção se não tiver escrito um teste antes.
Escreva um teste em que o seu código de produção falhe.
Escreva o código de produção que faça seu teste que falhou no passo anterior passar.

Os passos devem ser repetidos até termos um código que cubra o máximo de possibilidade de falhas possível.

Basicamente TDD é uma técnica de desenvolvimento e design de software em que devemos escrever testes antes de código de produção. Geralmente times ágeis adotam essa prática e é uma das principais ferramentas no desenvolvimento de software ágil.

Segundo a Wikipedia:

Test Driven Development (TDD) ou em português Desenvolvimento guiado por testes é uma técnica de desenvolvimento de software que se relaciona com o conceito de verificação e validação e se baseia em um ciclo curto de repetições: Primeiramente o desenvolvedor escreve um caso de teste automatizado que define uma melhoria desejada ou uma nova funcionalidade.

Desenvolvimento dirigido por testes requer dos desenvolvedores criar testes de unidade automatizados que definam requisitos em código antes de escrever o código da aplicação. Os testes contém asserções que podem ser verdadeiras ou falsas. Após as mesmas serem consideradas verdadeiras após sua execução, os testes confirmam o comportamento correto, permitindo os desenvolvedores evoluir e refatorar o código.

Fonte: https://pt.wikipedia.org/wiki/Test_Driven_Development

PHP Unit

PHP Unit é uma ferramenta que permite desenvolvedores PHP a escreverem testes unitários e praticarem o TDD. PHP Unit é um framework completo criado por Sebastian Bergmann com suporte à tecnica de mocking onde criamos objetos falsos que simulam comportamentos de objetos reais.

Não entrarei nos detalhes da instalação desta ferramenta pois a própria documentação é bem rica e inclusive traduzida em português, o composer novamente é uma mão na roda para adicionar o PHP Unit ao nosso projeto.

Fonte: https://phpunit.de/

O que TDD não é:

Apenas criar testes unitários;
É ter testes unitários;
Perda de tempo;
TDD = software sem bug.

O que ganho implementando TDD?

Menor custo para manutenção do software;
Melhorar nas estimativas;
Legibilidade do código;
Design guiado por Testes.

Deixo um repositório para quem está iniciando com TDD no PHP.

A estrutura do projeto foi criada utilizando o comando composer init que facilita para seguirmos o PSR-4, já os nomes de variáveis e o estilo de codificação procurei seguei PSR-1 e PSR-2, abaixo temos a estrutura do projeto:

- app
  - Wrapper.php
- tests/
  - FirstTest.php
- .gitignore
- LICENSE
- README.MD
- composer.json

No arquivo FirstTest.php temos a implementação dos testes, eles foram escritos seguindo os passos de 1 a 3 e assim que foi escrito cada método de teste logo em seguida foi escrito cada método de produção:

Classe de Testes: FirstTest.php

Código de produção: Wrapper.php

Os testes foram criados na classe WrapperTest e possui 8 métodos que são:

testItShouldWrapAnEmptyString
testDoesNotWrapAShorterThanMaxCharsWord
testItWrapsAWordSeveralTimesIfItsTooLong
testItWrapsTwoWordsWhenSpaceAtTheEndOfLine
testItWrapsTwoWordsWhenLineEndIsAfterFirstWord
testItWraps3WordsOn2Lines
testItWraps2WordsOn3Lines
testItWraps2WordsAtBoundry

O projeto se resume em uma classe de produção chamada Wrapper (Embalagem) e seu único método wrap que significa embrulhar/envolver recebe 2 argumentos $text e $lineLength, sendo o primeiro o texto que será envolvido e o segundo o tamanho da linha. O código de produção foi refatorado e a última versão do método wrap é capaz de passar todos os testes. Deixei comentado as versões anteriores do método wrap que passam os testes.

Chegamos ao fim, espero ter contribuído com o aprendizado sobre TDD!

p.s.: Agradecimentos especiais ao Wil Correa pela revisão.