Começando com PHPUnit

Introdução

Neste artigo vamos aprender como criar um novo projeto PHP com o phpunit configurado. A ideia é a criação de um projeto com phpunit, baseado no composer, para que você possa usá-lo como base em um novo projeto seu. Ou você pode simplesmente extrair o necessário para configura-lo em algum projeto existente.

PHPUnit é um framework que auxilia a criação e execução automática de testes unitários em classes PHP.

A importância de Testes Unitários

Antes de qualquer abordagem técnica gostaria de destacar a importância de escrever softwares baseados em testes. O conceito, que você já deve ter ouvido por ai, é chamado de TDD (Test Driven Development ou Desenvolvimento Orientado a Testes).

  • TDD é uma forma de testar o seu software durante o processo de desenvolvimento, antes mesmo de tê-lo pronto. Os testes são criados junto com o desenvolvimento de suas classes/métodos.
  • Este modelo de desenvolvimento, força uma maior divisão de responsabilidades entre classes/métodos, tornando o código mais legível, incentivando o Baixo acoplamento e Alta Coesão.
  • Com TDD, o software ganha mais em qualidade. Erros podem ser facilmente identificados.
  • O desenvolvimento se torna mais ágil e as entregas mais rápidas.
  • Ajuda a identificar e eliminar códigos duplicados.
  • Os testes se tornam uma documentação natural do código. Ficam de exemplos de como funciona o software.
  • A refatoração de código se torna mais simples. Os testes garantem se depois de todas mudanças feitas, o código continua funcionando conforme deve funcionar.

Instalação

Vamos realizar a instalação do phpunit através do composer. Primeiro, instale o composer no diretório raiz do seu projeto:

curl -sS https://getcomposer.org/installer | php

Crie um arquivo composer.json, inserindo o conteúdo abaixo:

{
    "require-dev": {
        "phpunit/phpunit": "4.5.*"
    }
}

Para que o composer baixe a dependência do phpunit no seu projeto e crie o autoload necessário para usá-lo, execute o comando install do composer:

php composer.phar install

Criando Testes Unitários

Para exemplificar o uso do phpunit, vamos criar, e posteriormente testar, uma classe em nosso projeto chamado Calculo, responsável por realizar cálculos aritméticos básicos. Em nosso exemplo teremos apenas o método soma().

Teremos o diretório src/ para armazenar as classes do nosso projeto, e o diretório tests/ para armazenar os testes. A estrutura do projeto final será semelhante a figura abaixo:

Estrutura phpunit

Portanto, crie o arquivo src/Calculo.php contendo:

<?php
namespace Application;

/**
 * Simples classe para calculo do soma
 */
class Calculo
{

        /**
         * Retorna a soma dos valores passados como argumento para funcao
         */
        function soma()
        {
                $soma = 0;
                $args = func_get_args();
                foreach($args as $value) {
                        $soma += $value;
                }

                return $soma;
        }
}

Antes de continuar, vamos configurar o autoloader para as classes do nosso projeto. Para isso vamos usar o composer e seguir as orientações do pessoal do PHP-FIG, tendo como referência a PSR-4. Para isso, edite o arquivo composer.json e adicione o seguinte conteúdo:

    "autoload": {
        "psr-4": {
            "Application\\": "src"
        }
    }

Veja que o namespace usado em nossas classes chama-se Application. Isso poderá ser diferente no seu projeto.

Execute o comando abaixo para atualizar a estrutura do composer com as novas mudanças:

php composer.phar update

Em seguida criamos o teste para nossa classe Calculo em tests/CalculoTest.php. Ele irá garantir que o método soma() esta se comportando conforme desejado:

<?php
namespace Application;

class CalculoTest extends \PHPUnit_Framework_TestCase
{
        public function setUp()
        {
                // executado antes de cada um dos testes dessa classe
        }

        public function tearDown()
        {
                // executado apos cada um dos testes dessa classe
        }

        function testSoma()
        {
                $calculo = new \Application\Calculo();

                $this->assertEquals(19, $calculo->soma(10, 5, 4));
                $this->assertEquals(12, $calculo->soma(2, 2, 2, 6));
        }
}

Executando o teste unitário:

$ ./vendor/bin/phpunit tests/SomaTest.php
PHPUnit 4.5.0 by Sebastian Bergmann and contributors.

.

Time: 21 ms, Memory: 3.00Mb

OK (1 test, 2 assertions)

Caso tenha recebido a mensagem acima, o teste foi executado com sucesso. Total de 1 teste (Linha 16) e 2 assetions (Linhas 10 e 11).

Algumas considerações sobre testes com phpunit:

  • Você pode criar quantos testes quiser em uma mesma classe de testes. Basta criar métodos que comecem com test. Ex: testSoma, testSubtracao, testXXX. Qualquer outro método que não comece com test, não será considerado um teste, e pode ser usado como um método de apoio caso necessário.
  • Qualquer tipo de inicialização pode ser inseridas no método setUp() que é executado antes de qualquer teste presente na classe. Já códigos de finalização, podem ser inseridos no método tearDown() que é executado após a finalização de cada um dos testes.
  • A biblioteca de assertions do phpunit é rica. Em nosso exemplo usamos o assertEquals() para garantir que o método soma() esta retornando os valores esperados corretamente. Existem vários outros assertions que podem se enquadrar melhor de acordo com a necessidade. Ex:
    • assertNull()
    • assertNotNull()
    • assertInstanceOf()
    • assertEmpty()
    • assertTrue()
    • assertFalse()
    • assertContains()

    Para um referência completa de assertions, verificar na documentação oficial.

    Please follow and like us:

Comments

  1. By Luis

    • mm By Douglas V. Pasqua

      • By Luis

Follow

Get every new post on this blog delivered to your Inbox.

Join other followers: