sábado, 19 de outubro de 2013

Zend Certified PHP 5.5


    Chega de suposições sobre a próxima certificação que a Zend vai lançar, no dia 03 de Outubro de 2013 a Zend deixou disponível através da Pearson VUE a sua mais nova certificação.  PHP 5.5 a versão atual do PHP agora está disponível para quem quiser fazer a prova. Verifiquei nos tópicos que pouca coisa mudou, apenas foram adicionados os aspectos importantes do 5.4 E 5.5.

    A prova ainda é dividida em 10 tópicos sendo eles: 


      PHP BasicsFunctionsData Format & Types
      • Syntax
      • Operators
      • Variables
      • Control Structures
      • Language Constructs and Functions
      • Namespaces (5.3) *
      • Extensions
      • Config
      • Performance/bytecode caching (5.3) *
      • Arguments
      • Variables
      • References
      • Returns
      • Variable Scope
      • Anonymous Functions, closures (5.3) *
      • XML Basics
      • SimpleXML
      • XML Extension
      • Webservices Basics
      • SOAP
      • JSON (5.3) *
      • DateTime (5.3) *
      • DOMDocument
      Web FeaturesObject Oriented ProgrammingSecurity
      • Sessions
      • Forms
      • GET and POST data
      • Cookies
      • HTTP Headers
      • HTTP Authentication
      • HTTP Status Codes *

      I/O

      • Files
      • Reading
      • Writing
      • File System Functions
      • Streams
      • Contexts
      • Instantiation
      • Modifiers/Inheritance
      • Interfaces
      • Exceptions
      • Autoload
      • Reflection
      • Type Hinting
      • Class Constants
      • Late Static Binding
      • Magic (_*) Methods
      • Instance Methods & Properties
      • SPL
      • Traits (5.4) *
      • Configuration
      • Session Security
      • Cross-Site Scripting
      • Cross-Site Request Forgeries
      • SQL Injection
      • Remote Code Injection
      • Email Injection
      • Filter Input
      • Escape Output
      • Encryption, Hashing algorithms
      • File uploads
      • PHP Configuration
      • Data Storage
      • SSL
      • Password hashing API (5.5)*
      Strings & PatternsDatabases & SQLArrays
      • Quoting
      • Matching
      • Extracting
      • Searching
      • Replacing
      • Formatting
      • PCRE
      • NOWDOC and HEREDOC
      • Encodings
      • SQL
      • Joins
      • Analyzing Query
      • Prepared Statements
      • Transactions
      • PDO
      • Enumerated Arrays
      • Associative Arrays
      • Array Iteration
      • Array Functions
      • SPL, Objects as arrays (5.3/5.4/ 5.5) *
      • Casting







    Bem por esse quadro nós percebemos claramente que foi adicionado o que é de fato importante, e a Zend tiou algumas coisas que não faz mais sentido estar no PHP 5.5 ou seja, se vc já estava estudando para a certificação continue o seu plano de estudos, continue fazendo os testes que encontrou e estude apenas as coisas novas em paralelo. Para essas novas funcionalidades vou indicar um blog de um cara que é fera e conceituadissimo na comunidade PHP que é o Thiago Belem e aqui esta o blog http://blog.thiagobelem.net/

quarta-feira, 18 de setembro de 2013

PHP 5.4, 5.5 Traits, Generators e outras coisas boas - Hands On

Olá amigos e amigas, esse artigo é apenas para eu divulgar o Hands On que vou fazer sobre PHP 5.4 e PHP 5.5 , dessa vez ńão é apenas apresentação mas sim mão na massa de como e quando utilizar esses funcionalidades das novas versões.


Para se inscrever é só entrar aqui http://www.season.com.br/cms/treinamentos/calendario/detalhe/evento/447/ o custo de investimento é de R$ 140,00 para presencial, provavelmente vamos transmitir também mas eu ainda não sei ainda se os preços serão os mesmos, assim que eu conseguir informações eu informo.


Bem, nos vemos la!

sábado, 7 de setembro de 2013

Traits do PHP 5.4

Bem amigos(as) hoje vou falar finalmente das TRAITS adicionadas no PHP 5.4, é verdade que já faz um ano que lançaram o PHP 5.4 e eu sempre quis falar rápido sobre as poderosas traits mas sempre fiquei enrolando então, agora é a hora.


Afinal, o que são Traits? Traits são mecanismos que ajudam o problema de multipla extensão  auxiliando de forma elegante o reuso de código. Essa é basicamente a explicação da documentação mas a minha visão sobre Traits é que além de facilitar o reuso do código elas ajudam e muito uma arquitetura melhor da sua aplicação PHP e vocês vão ver pq eu acho isso.

Vamos imaginar uma situação real, vc está desenvolvendo um portal de notícias e toda interação dos usuários no site (Autenticação, comentário em notícia, adicionar agenda, comprar ingressos para show, etc...)  precisamos registrar em uma funcionalidade que grava o comportamento do usuário nesse site, não sendo necessáriamente um log mas sim uma funcionalidade para traçar perfil. 

Vamos imaginar o básico da classe de usuario e da classe de traçar perfil(vamos chamar ela de perfil apenas para estudo certo?)
Classe PERFIL RESPONSÁVEL PARA REGISTRAR E TRAÇAR PERFIL DE AÇÕES
  1. <?php
  2. class Perfil{    
  3.     public function registra($acao){
  4.         //registra uma ação
  5.     }
  6. }
E ai a nossa de usuario com uma pequena ação de alterar foto
Classe PESSOA
  
  1. <?php
  2. class Pessoa extends AppEntityPessoa{
  3.    
  4.     private $nome;    
  5.     /**
  6.      * Getters and setters
  7.      */        
  8.    
  9.    
  10.     public function alteraFoto($acao){
  11.         //faz algo...
  12.         // preciso registrar a acao na perfil como tornar isso um comportamento desse contexto?
  13.     }
  14.    
  15. }

Legal agora temos um problema que deve ser tratado seriamente como um padrão de arquitetura, se por obrigação todas minhas classes que representem dados precisam estender de uma entity da aplicação(vamos imaginar que essa é a estrutura imaginada), como eu soluciono esse problema? Existem diversas formas, mas as mais utilizadas seriam duas, a primeira seria criar uma estrutura de heranças em que em uma parte dela teriamos a classe perfil e essa por questões obvias é muito feia e sem sentido, mas ainda assim é uma solução utilizada. A segunda solução e mais recomendade seria no construtor da classe pessoa eu instânciar a classe Perfil e ai eu teria a instância injetada nessa classe utilizando esse contexto facilmente.

Pois bem apesar de uma solução melhor ainda assim não e boa e as traits resolvem isso mesmo, utilizando essa solução em traits criariamos a classe perfil como uma trait e apenas usariamos nas classes que julgamos necessário basicamente assim:
TRAIT PERFIL RESOLVENDO NOSSO PROBLEMA
  1. <?php
  2. trait Perfil{    
  3.     public function registra($acao){
  4.         //registra uma ação
  5.     }


E ai a classe pessoa utilizaria a trait com o use dentro da classe, herdando assim as características dela sem precisar instancia-la:
UTILIZANDO A TRAIT PERFIL
  1. <?php
  2. class Pessoa extends Perfil{
  3.     use Perfil;
  4.    
  5.     private $nome;    
  6.     /**
  7.      * Getters and setters
  8.      */        
  9.    
  10.    
  11.     public function alteraFoto($acao){
  12.         //faz algo
  13.         $this->registra($acao);
  14.     }
  15.    
  16. }

Conclusão

Traits resolvem de fato um problema de arquitetura sendo mais fácil pensar em como consumir classes fóra de contexto sem instancia-las ou herdar elas criando uma estrutura maluca. Frameworks vão utilizar isso com muita felicidade pois essa funcionalidade acaba com uma porrada de hierarquias gigantes criadas anteriormente.

Bem... é isso.


Referência: Documentação Oficial http://br1.php.net/manual/en/language.oop5.traits.php

domingo, 4 de agosto de 2013

Encontro PHP dia 06/08 19:30 em SP

Buenas! Esse artigo é somente para compartilhar o encontro PHP realizado pela Season onde vamos ter muito networking e compartilhamento de conhecimento. O encontro acontece dia 06/08/2013 (terça-feira) ás 19:30 na  Avenida Bernadino de Campos, nº 327 CJ 92, Bairro Paraíso - São Paulo - SP

Esse evento conta com duas palestras, sendo uma minha que vou falar sobre Domain-Driven Design aplicado no PHP e outra do Anderson Casimiro (Duodraco) que vai falar sobre Excelência em Software.

Se inscreva e participe, a inscrição é gratuita! Agora se você não puder ir se inscreve e assista via WEBCAST nesse link:

https://docs.google.com/spreadsheet/viewform?formkey=dEttMGpLNlVXQlQzSXRFUWxsb043ZUE6MA


sábado, 27 de julho de 2013

Instalando o OpenJDK 7 no Ubuntu 13.04


Olá amigos, essa é para vc que precisa do OpenJDK 7 para acessar seu internet banking ou instalar netbeans subir o solr ou coisas derivadas que precisam do java. Vamos instalar o Open JDK 7 no ubuntu 13.04


Primeiro vamos instalar o IcedTea plugin para o navegador
$ sudo apt-get install icedtea-7-plugin openjdk-7-jre


Agora O openjdk
$ sudo apt-get install openjdk-7-jdk


Bem, é isso ae.

quarta-feira, 12 de junho de 2013

Nginx php-fpm e mysql e phpmyadmin no Ubuntu 13.04

Olá amigos e amigas tudo bem? Hoje vou mostrar aqui de maneira bem objetiva como montar um ambiente padrão com o todo poderoso Nginx utilizando php-fpm e de quebra mysql no Ubuntu 13.04 ok?

No final deste pequeno artigo teremos um phpmyadmin rodando legalzinho com o nginx.


Abra o seu console e siga os passos(preciso dizer que precisa rodar como root?).


1º Vamos começar com nosso querido mysql

apt-get install mysql-client-5.5 mysql-server-5.5 php5-mysql

1º Agora o PHP
apt-get install php5 php5-cli php5-dev php5-mcrypt php5-curl php5-gd libapache2-mod-php5


2º Agora o Nginx

apt-get install nginx



3º Restart no nginx


 
/etc/init.d/nginx restart


4º Instalando o php-fpm
apt-get install php5-fpm


5º Vamos criar o diretorio www no /var para deixar la nossos fontes (vc não precisa fazer isso pode utilizar outro lugar, mas eu gosto deste)
mkdir /var/www




Agora vamos baixar os fontes do phpmyadmin em http://www.phpmyadmin.net/ estou utilizando a versão 4.0.3

Terminando o download vamos descompactar nosso amiguinho
unzip phpMyAdmin-4.0.3-all-languages.zip

E mover ele para o diretorio /var/www com o nome somente de phpMyAdmin
mv phpMyAdmin-4.0.3-all-languages /var/www/phpMyAdmin

Pronto. Agora vamos configurar os hosts do nosso phpMyAdmin

Criando a linha no hosts
vim /etc/hosts

Adicione
127.0.0.1     phpmyadmin.dev

E agora vamos criar o arquivo de configuração do nginx
vim /etc/nginx/sites-available/phpmyadmin.dev

E ai vc insere esse conteudo:

### phpmyadmin simple configuration
server {
server_name phpmyadmin.dev;
access_log /var/log/nginx/phpmyadmin.access.log;
error_log /var/log/nginx/phpmyadmin.error.log; 
client_max_body_size 5m;
client_header_timeout 1200;
client_body_timeout 1200;
send_timeout 1200;
keepalive_timeout 1200;
set $thttps off;
root /var/www/phpMyAdmin/;
try_files $uri $uri/ /index.php?$args;
index index.php;
location ~ \.php$ {
fastcgi_pass 127.0.0.1:9000;
fastcgi_index index.php;
include fastcgi_params;
fastcgi_connect_timeout 1200;
fastcgi_send_timeout 1200;
fastcgi_read_timeout 1200;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
fastcgi_param APPLICATION_ENV dev;
}
error_page 403 /403.html;
error_page 404 /404.html;
error_page 500 502 503 504 /50x.html;
}

Cria um link maroto para o sites-enable
ln -s /etc/nginx/sites-available/phpmyadmin.dev /etc/nginx/sites-enabled/phpmyadmin.dev

por fim vamos arrumar a porta de escuta no fpm
sudo vim /etc/php5/fpm/pool.d/www.conf 

procura a linha que esta assim:
listen = /var/run/php5-fpm.sock

e mude para
listen = 127.0.0.1:9000
(lembre-se que no arquivo de conf colocamos o fast na 9000)

E da um restart na parada toda
service php5-fpm restart
/etc/init.d/nginx restart


e ai é só acessar
http://phpmyadmin.dev


Done!

Dúvidas não exite em perguntar.

sábado, 1 de junho de 2013

segunda-feira, 27 de maio de 2013

ZF1 para ZF2

Olá amigos(as), hoje vou apenas compartilhar aqui o video que foi o primeiro Webinar oficial da Zend feito em português pelo já conhecido e famoso Flávio Gomes Lisboa (Escritor dos livros de ZF1). Eu tive a oportunidade de assistir a transmissão ao vivo e achei muito produtiva em todos os aspectos.
Acho que o video tenta de uma forma simples comparar as diferenças entre os dois frameworks e mostrar os desafios que a Zend passou para criar esse framework tão robusto que é o Zend Framework 2.

Sendo assim segue abaixo o link do video:

http://www.zend.com/en/webinar/ZF/70170000000c4Mm-migrando-do-zf1-para-o-zf2-20130416.flv


terça-feira, 30 de abril de 2013

Netflix no Linux Ubuntu

Esse pequeno artigo vai te ajudar rapidamente a rodar o Netflix no Linux Ubuntu.

Mas espera ai! O NETFLIX NÃO RODA NO LINUX? E A RESPOSTA É SIMPLES, O NETFLIX utiliza o Microsoft Silverlight....

Na boa, há um ano atrás eu vi algumas estratégias do NETFLIX sobre uso do HTML5 muito interessantes, e até imaginei que fosse uma empresa "estilo Google de pensar", mas depois que eu vi que além de utilizarem Silverlight não existe uma alternativa criada POR ELES DIRETO NO BROWSER achei uma baita palhaçada e descaso dessa empresa.
Sério, que ano eles pensam que estão? Será que é tudo da
Microsoft? Será que a Microsoft ainda não aprendeu que quando vc tenta impor algo vc só tem a perder? Sei lá viu, algumas pessoas e alguns cargos na área de TI não deveriam simplesmente existir.

Enfim, deixando o desabafo de lado vamos falar da solução técnica para isso, um programador do EUA chamado Erich E. Hoover também ficou puto mas não apenas reclamou como arregaçou as mangas e foi desenvolver uma solução(PARA NOOOOOSSSAAA ALEGRIAA), e é bemmm simples pois é basicamente o programa que trabalha com o Wine em conjunto com o Firefox. E para vc e eu que queremos fazer o Netflix rodar sem muito esforço ficou perfeito(rs).



Abra o terminal e resolva isso com 3 comandinhos
$ sudo apt-add-repository ppa:ehoover/compholio
$ sudo apt-get update
$ sudo apt-get install netflix-desktop



Depois de instalado é só chamar nosso amiguinho e pronto
$ netflix-desktop




Fonte http://www.compholio.com/netflix-desktop/

sábado, 20 de abril de 2013

Arquitetura SOLID

Olá amigos, ultimamente ando com artigos mais conceituais pois meu intuito ultimamente é flexionar nosso cérebro para pensar  de uma forma mais ampla do desenvolvimento de software. Por isso hoje vou falar da consagrada Arquitetura de Software SOLID


Em meados de 2005, Robert Martin(Uncle Bob), publicou um artigo sobre 11 princípios de Design para desenvolvimento Orientado a Objetos. No artigo ele diz que não basta programar orientado a objetos, é necessário ter princípios de design para manter a qualidade. Os 5 primeiros princípios ficaram “mais famosos”, sendo estes os que formam o S.O.L.I.D.

O SOLID tenta mostrar de maneira simples como planejar algo limpo e de uso altamente flexível(afinal,  pq usar?). Vou dar uma acordada em vc ai, sabia que o famoso Zend Framework 2 usa SOLID? Pois é meu amigo e amiga o Matthew Weier cabeça do desenvolvimento do ZF2 buscou usar o melhor da atualidade para o framework e eles encontraram no SOLID uma forma de expressar o que eles queriam de fato que é o conceito de framework "USE O QUE VC QUISER E A VONTADE". Ta mais vamos ao ponto desse nome, veja a figura acima e acompanhe a explicação das siglas abaixo.

S – Single Responsibility principle: uma classe deve ter apenas uma responsabilidade.
O – Open/Closed principle: entidades de software devem ser abertos para extensão, mas fechadas para modificação.
L – Liskov substitution principle: objetos em um programa devem ser substitíveis por suas classes derivadas em qualquer ponto do código sem alterar a funcionalidade do programa.

I – Interface segregation principle: interfaces muito específicas são melhores do que interfaces de uso geral.
D – Dependency inversion principle: módulos devem depender de abstrações.
Mais detalhes, clique aqui.



Bem é basicamente isso recomendo uma leitura na documentação do Zend Framework 2(aqui) e também na matéria do Bob(aqui)

terça-feira, 19 de março de 2013

Entenda o Domain Driven Design


Olá amigos e amigas tudo bem? Hoje vou resumir de uma forma mais "Mamão com açucar" O que é o DDD e imaginar exemplos utilizando o DDD para como resolver um determinado problema ok?

Provavelmente vc se lembra daqueles 3 gordinhos da Embratel não é? "pegue o seu d d dedo e disque o nu número da embratel, antes do ddd é 021..." Pois bem, eles não tem nada haver com o que eu vou explicar, mas fica ai como imagem de apresentação.


Existem duas maneiras de vc ter caído aqui no meu blog, a é vc conhecer meu blog e veio aqui para ver novos artigos(a grande menoria). A é pq vc está pesquisando sobre DDD e encontra muito artigo cheio de filosofia e acaba não absorvendo muito bem, e provavelmente vc não tem muito tempo para lêr o livro do Evans então chegas mais que vou resumir essa parada pra vc!

Antes de mais nada vamos ao entendimento básico, Domain Driven Design significa entre outras palavras Projeto Orientado a Domínio. Que veio do título do livro do Eric Evans. O livro do Evans é basicamente um catálogo de padrões baseados em experiências do próprio Evans ao longo de mais de 20 anos de desenvolvimento de software utilizando técnicas de Orientação a Objetos.

O DDD é basicamente o uso ideal da Orientação a Objetos(PRONTO ACABEI DE EXPLICAR TUDO PODE IR EMBORA).

Não fique bravo(a) comigo pois essencialmente é isso mesmo, DDD é o uso inteligente da orientação a objetos para resolver diversos problemas.

Vamos lá open your mind.


Os decoradores(entende-se pessoas que decoram) de Orientação a Objetos tem um problema grave com isso pois quando se fala em OO as primeiras coisas que vem na mente são "classes, herança, polimorfismo, encapsulamento, lalala...". Mas essa são as regras básicas e técnicas da OO, a grande sacada dela está em independência de tecnologia, mínimo de acoplamento, reutilização de código, alinhamento do código com o negócio, coerência em problemas reais... Olha só, agora sim estamos falando de OO resolvendo problemas reais e essa é a essencia campeonato(entende-se campeão).
 


Vamos ter um papo sério sem muita filosofia esse não é um artigo é mais uma conversa ok? Então vamos pensar, o Projeto Orientado a Domínio é essencialmente entendermos o negócio e tornar o código lógico a esse negócio, coeso a esse negócio, aquele papo de entity não pode ter lógica é justamente o OPOSTO do DDD pois sim vamos ter uma camada de domínio cujo qual minhas entidades são inteligentes! Separar a lógica em serviços que manipulam as entidades muitas vezes torna o reuso impossivel e é basicamente dizer eu sou um macaco que batuco o teclado com a intenção de gerar código....

O DDD não vai exatamente te impor como vc faz a arquitetura do seu software mas sim te abrir a mente sobre como dar funções para quem realmente merece afinal, vc não mandaria um engenheiro fazer uma cirurgia plástica não é?

Veja um exemplo do DDD por "cima":




Interface de Usuário – parte responsável pela exibição de informações do sistema ao usuário e também por interpretar comandos do usuário;

Aplicação – essa camada não possui lógica de negócio. Ela é apenas uma camada fina, responsável por conectar a Interface de Usuário às camadas inferiores;

Domínio – representa os conceitos, regras e lógicas de negócio. Todo o foco de DDD está nessa camada. Nosso trabalho, daqui para frente, será aperfeiçoar e compreender profundamente essa parte;

Infra-estrutura – fornece recursos técnicos que darão suporte às camadas superiores. São normalmente as partes de um sistema responsáveis por persistência de dados, conexões com bancos de dados, envio de mensagens por redes, gravação e leitura de discos, etc.


O DDD basicamente começa por essa premissa básica de conhecer de fato o domínio, mas ele é muito mais amplo e mais complexo por isso eu tentei aqui dar a introdução desse mundo partindo do principio de entender essa ideia.

Existem alguns pontos importantes abordados no DDD que são o uso da mesma linguagem, evitar traduções indevidas, quebrar o problema em camadas, entender entidades, agregados, objetos de valor, fábricas, serviços, repositórios, módulos entre outros.


Segue aqui a primeira versão de um slide da minha palestra sobre Domain Driven Design



Caso vc queira se aprofundar nos estudos então é melhor ler o livro do Evans 
http://www.informit.com/store/domain-driven-design-tackling-complexity-in-the-heart-9780321125217



Até a próxima.


quinta-feira, 28 de fevereiro de 2013

Testando suas classes com PHPUnit

Hoje vou replicar um post do meu irmão(http://developer-v.blogspot.com.br), sim meu irmão também tem um blog e ele é da minha area. 

Hy, folks!!!
E ai galera, finalmente vamos fazer um post, mão-na-massa, o que seria isso ???


????????????????????????
Simples um teste em classes, vamos usar agora o PHPunit para fazer um teste que ira funcionar realmente.

O que é Unit Testing?

- Testes para pequenos trechos de código (unidades)
- Verifica se o comportamento de classes e funções é o esperado
- Caso erros são encontrados exceções são lançadas
- Não interfere com o seu código-fonte

Qual a vantagem?

- Os testes são automatizados
- Eles são executados continuamente durante o ciclo de desenvolvimento
- Detectam falhas tanto de digitação e lógica e também comportamentos inesperados

Exemplo


  1. class Classe1
  2. {
  3.     public function somar($a, $b)
  4.     {
  5.         return $a+$b;
  6.     }
  7.        
  8.     public function subtrair($a, $b)
  9.     {
  10.         return $a-$b;
  11.     }
  12. }
  13. // Teste da classe
  14. $foo = new Classe1();
  15. $soma = $foo->somar(2, 2);
  16. $subracao = $foo->subtrair(2, 2);
  17. echo '2 mais 2 = ' . $soma;
  18. echo '2 menos 2 = ' . $subtracao;
  19. // Funciona conforme esperado!


Apesar do exemplo simples, ilutra uma prática bem comum: a de inserir vários echo() e print() para confirmar o funcionamento de uma classe ou função.

O PHPUnit é uma framework que tem como objetivo automatizar e padronizar a forma como nosso código é testado.

"Whenever you are tempted to type something into a print statement or a debugger expression, write it as a test instead." -- Martin Fowler

Ou seja: "Toda vez que sentir vontade de escrever um print ou outra expressão de debug, pare e crie um teste!"


  1. // Especifique o caminho do PHPUnit
  2. require_once '/usr/share/php/PHPUnit/Framework.php';
  3. // Especifique o caminho da classe a ser testada
  4. require_once 'Classe1.php';
  5. // Como a classe a ser testada se chama "Classe1", a classe de teste deverá se chamar "ClasseTest" e (neste caso) irá herdar de PHPUnit_Framework_TestCase
  6. class Classe1Test extends PHPUnit_Framework_TestCase
  7. {
  8.         // Funções de teste devem ter o prefixo "test"
  9.         public function testSoma()
  10.         {
  11.                 // A classe a ser testada é instanciada
  12.                 $foo = new Classe1();
  13.                 // Testamos a afirmação que "4" é o resultado de passar "2" e "2" (ou seja, 2 + 2 = 4)
  14.                 $this->assertEquals('4', $foo->somar(2, 2));
  15.         }
  16.        
  17.         public function testSubtracao()
  18.         {
  19.                 // idem (veja função acima)
  20.                 $foo = new Classe1();
  21.                 $this->assertEquals('0', $foo->subtrair(2, 2));
  22.         }
  23. }


O resultado:

  1. PHPUnit 3.3.16 by Sebastian Bergmann.
  2. .
  3. Time: 0 seconds
  4. OK (2 tests, 2 assertions)
  5. // Funciona conforme esperado!


O que aconteceu?
Criamos uma classe (Classe1Test) de teste para testar a nossa classe (Classe1) e usamos o PHPUnit para testar o funcionamento esperado

Não é mais complicado?
- Sim e não! Inicialmente pode parecer bem mais simples inserir alguns print() ou echo() e verificar manaulmente, mas ao longo prazo usar o PHPUnit traz diversas vantagens:
- Os testes ficam separados do código, assim não corremos o risco de esqueçer testes no meio do código. Devido à separação também não é necessário ficar voltando e comentando e descomentando as linhas de teste inseridas manualmente.
- Para aplicações um pouco mais complexas (por exemplo com várias classes interagindo juntas ou com AJAX) as vezes não é possível colocar echo() ou print() em qualquer lugar. Até mesmo o FirePHP gera erros de 'header'!
- Usando o PHPUnit criamos vários testes e sempre que desejarmos podemos rodá-los novamente para testar modificações.
- E o melhor de tudo, não precisamos fazer nada na hora de colocar a aplicação no ar. Simplesmente não fazemos o upload da pasta de testes! O código-fonte original segue intacto.

Como funciona?
- Crie uma classe de teste para testar uma classe já existente
- Excute os testes no terminal (ou prompt de comando) e veja os resultados
- A melhor maneira da aprender isto é através de exemplos então vamos instalar o PHPUnit e criar alguns testes!


Instalação do PHPUnit

Quem usa o linux pode fazer facilmente:


  1. # se não tiver o PEAR instalado
  2. apt-get install pear
  3. # descubra o canal do PHPUnit
  4. pear channel-discover pear.phpunit.de
  5. # instale o phpunit
  6. pear install phpunit/PHPUnit
  7. # Ele fica instalado por padrão no /usr/share/php/PHPUnit
  8. # Agora é só incluir o framework nos arquivos de teste e começar!


Quem usa windows procure no google! Não deve ser muito complicado... (se não me engano ele já vem incluso no pacote XAMPP)

Guia para criar Unit Tests

- Os testes para a classe "Classe1" (Classe1.php) deverão ser localizados dentro da classe "Classe1Test" (Classe1Test.php), sempre use o sufixo "Test" (NomeDaClasseTest)
- Na maioria dos casos a classe de teste irá herdar (extends) da classe PHPUnit_Framework_TestCase
- Os testes deverão ser funções públicas com o prefixo "test" (testSomar, testSubtrair, etc)
- Os testes são baseados em afirmações, ou seja: afirmamos que o resultado esperado da função X é Y, e testamos a afirmação pra ver se ela procede.
- Usamos funções como assertEquals() para testar afirmações (exemplos a seguir)

Algumas Afirmações disponíveis (Funções de Teste)

- Existem dezenas (veja a documentação http://www.phpunit.de/manual/), seguem algumas das mais comuns:
- assertEquals($valor, funcao()) (afirma que o valor retornado da funcao é igual a $valor)
- assertNotEquals($valor, funcao()) (afirma que o valor retornado da funcao não é igual a $valor)
- assertSame($valor, funcao()) (testa se o objeto retornado é igual a $valor)
- assertTrue(funcao()) (afirma que o valor retornado é === true)
- assertFalse(funcao()) (=== false)
- setExpectedException (avisa sobre uma exceção que deverá ser lançada)

Como rodar os testes

Através do terminal (ou prompt de comando), no diretório do arquivo de teste digite:


  1. phpunit NomeDaClasseTest
  2. # para rodar os testes contidos no arquivo NomeDaClasseTest.php


Vamos ver alguns exemplos na próxima página.
O test seguinte usa a função assertEquals() para checar o retorno de um método:

  1. // Especifique o caminho do PHPUnit
  2. require_once '/usr/share/php/PHPUnit/Framework.php';
  3. // Especifique o caminho da classe a ser testada
  4. require_once 'Classe2.php';
  5. class Classe2Test extends PHPUnit_Framework_TestCase
  6. {
  7.     public function testCumprimentarSemParametro()
  8.     {
  9.         // O comportamento esperado é que retorne "Olá fulano", testa esta afirmação
  10.         $this->assertEquals('Olá fulano', $foo->cumprimentar());
  11.     }
  12.     public function testCumprimentarComParametro()
  13.     {
  14.         // Instancia a classe e passa "Alex" ao construtor
  15.         $foo = new Classe2('Alex');
  16.         // O comportamento esperado é que retorne "Olá Alex", testa esta afirmação
  17.         $this->assertEquals('Olá Alex', $foo->cumprimentar());
  18.     }
  19.    
  20.         // Funções de teste também podem ser identificados pela anotação @test no DocBlock
  21.         /**
  22.          * @test
  23.          */
  24.          public function vaiDarErrado()
  25.          {
  26.                  // Instancia a classe e passa "ciclano" ao construtor
  27.                 $foo = new Classe2('ciclano');
  28.                 // O comportamento esperado é que retorne "Olá ciclano", mas vamos afirmar que retornará outro valor para forçar um erro
  29.                 $this->assertEquals('Olá Alex', $foo->cumprimentar());
  30.          }
  31. }


Outro teste simples que retorna o seguinte:

  1. PHPUnit 3.3.16 by Sebastian Bergmann.
  2. ..F
  3. Time: 0 seconds
  4. There was 1 failure:
  5. 1) vaiDarErrado(Classe2Test)
  6. Failed asserting that two strings are equal.
  7. expected string <Olá Alex>
  8. difference      <     xxxx???>
  9. got string      <Olá ciclano>
  10. /caminho/para/o/arquivo/Classe2Test.php:35
  11. FAILURES!
  12. Tests: 3Assertions: 3Failures: 1.


Ou seja, quando um teste falha ele informa o arquivo e linha onde ocorreu o erro.
Explica também qual foi o erro:
- O valor esperado era "Ola Alex"
- O valor retornado foi "Ola ciclano"
E ele ainda mostra a diferença ( xxxx???)

Fornecendo valores para os testes

- As vezes não basta só um teste com um valor estático
- Podemos criar uma função para alimentar o teste usando vários valores (e nada impede que sejam de fontes externas)
- A função é identificada através da anotação @dataProvider no DocBlock

Exemplo:

Uma versão um pouco mais complicada para explicar o uso do data provider em testes:

  1. // Demonstração de "Data Providers"
  2. class Classe3Test extends PHPUnit_Framework_TestCase
  3. {
  4.     // Informa o nome do forneçedor de dados (@dataProvider) para a clase de teste
  5.     /**
  6.      * @dataProvider provider
  7.      */
  8.     // Recebe 3 parâmetros
  9.     public function testCombine($a, $b, $c)
  10.     {
  11.         // Afirma que o valor do terceiro parâmetro é igual a concatenação dos primeiros dois separados por um espaço
  12.         $this->assertEquals($c, $a . ' ' . $b);
  13.     }
  14.     // A função fornecedora de valores
  15.     public function provider()
  16.     {
  17.         // retorna um array contendo 3 grupos de valores a serem testados
  18.         return array(
  19.             array('Hello', 'World', 'Hello World'),
  20.             array('É', 'Nois', 'É Nois'),
  21.             array('Deu', 'Errado', 'Deu Certo')
  22.         );
  23.     }
  24. }


Valor retornado:

  1. PHPUnit 3.3.16 by Sebastian Bergmann.
  2. ..F
  3. Time: 0 seconds
  4. There was 1 failure:
  5. 1) testCombine(Classe3Test) with data set #2 ('Deu''Errado''Deu Certo')
  6. Failed asserting that two strings are equal.
  7. expected string <Deu Certo>
  8. difference      <    xxxxx?>
  9. got string      <Deu Errado>
  10. /home/alex/Documents/aw/Articles/PHPUnit/Classe3Test.php:16
  11. FAILURES!
  12. Tests: 3Assertions: 3Failures: 1.


Resumindo...

- O assunto é bastante extenso e realmente fica difícil cobrir todas as possibilidades (que são quase infinitas)
- É possível criar testes para testar se Exceções são lançadas conforme esperado, para testar classes de acesso ao banco de dados e muito mais
- O ideal seria implementar isto em uma aplicação que esteja desenvolvendo, ou seja, crie uma pasta para os testes e vá criando testes para as suas classes nela

Todo o código-fonte para os exemplos e outros exemplos mais complexos (todos bem documentados) estão disponíveis:

Espero que tenham gostado e que eu tenha introduzido bem este assunto que é frequentemente subestimado e importantíssimo quande se trata de desenvolvimento.

Este post, foi melhorado para uma linguagem mais visual e facíl de entender =D...

Fonte PHPbr