<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<!--Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
-->
<html>
<head>
<meta http-equiv="content-type" content="text/html; charset=UTF-8">
<meta name="description" content="How to integrate PHPUnit and Selenium with NetBeans IDE for writing automated tests. Includes demonstration of Code Coverage and the IDE's test result UI.">
<meta name="keywords" content="NetBeans, IDE, integrated development environment, tutorial, guide, user, documentation, open source, PHP, testing, automated testing, PHPUnit, Selenium, Code Coverage">
<link rel="stylesheet" type="text/css" href="../../../netbeans.css">
<title>Testando com o PHPUnit e Selenium -- Tutorial do NetBeans IDE</title></head>
<body>
<h1>Testando com o PHPUnit e Selenium</h1>
<p>O NetBeans IDE para PHP oferece suporte aos testes automatizados <a target="_blank" href="http://www.phpunit.de">PHPUnit</a>. Gra&ccedil;as ao PHPUnit, o NetBeans IDE fornece a cobertura de c&oacute;digo para PHP, similar a cobertura de c&oacute;digo que o IDE fornece ao Python. A sa&iacute;da do teste aparece na mesma janela de sa&iacute;da rica em recursos que os executores de teste JUnit, e Python do IDE utilizam. </p>
<p>O NetBeans IDE tamb&eacute;m suporta a estrutura de teste port&aacute;til Selenium em combina&ccedil;&atilde;o com o PHPUnit. Um plug-in Selenium est&aacute; dispon&iacute;vel no Centro de atualiza&ccedil;&otilde;es. A instala&ccedil;&atilde;o deste plug-in adiciona um servidor Selenium nos servidores registrados do IDE e adiciona op&ccedil;&otilde;es de teste Selenium aos menus PHP.</p>
<p><b>Conte&uacute;do</b></p>
 <img  src="../../../images_www/articles/71/netbeans-stamp.png" class="stamp" width="114" height="114" alt="O conte&uacute;do desta p&aacute;gina se aplica ao NetBeans IDE 7.1" title="O conte&uacute;do desta p&aacute;gina se aplica ao NetBeans IDE 7.1"> 
<ul class="toc">

  <li><a href="#installing-phpunit">Instalando o PHPUnit</a></li>
  <li><a href="#create-test">Criando e executando testes PHPUnit</a></li>
  <li><a href="#test-groups">Uso de grupos de teste</a></li>
  <li><a href="#result-windows">Resultados do teste e sa&iacute;da IDE</a></li>
  <li><a href="#code-coverage">Cobertura de c&oacute;digo</a></li>
  <li><a href="#project-specific-configurations">Utilizando configura&ccedil;&otilde;es espec&iacute;ficas do projeto</a></li>
  <li><a href="#selenium">Executando testes no framewor Selenium</a></li>
</ul>
<p><b>Para  seguir este tutorial, voc&ecirc; precisa dos seguintes recursos e softwares.</b></p>
<table>
  <tbody>
    <tr>
      <th class="tblheader" scope="col">Software ou recurso</th>
      <th class="tblheader" scope="col">Vers&atilde;o necess&aacute;ria</th>
    </tr>
    <tr>
      <td class="tbltd1"><a target="_blank" href="http://download.netbeans.org/netbeans/6.7/rc/">NetBeans IDE</a></td>
      <td class="tbltd1">
        Pacote de download do PHP</td>
    </tr>
    <tr>
      <td class="tbltd1">Um mecanismo PHP incluindo PEAR</td>
      <td class="tbltd1">Vers&atilde;o 5. </tr>
    <tr>
      <td class="tbltd1">Um servidor Web</td>
      <td>&Eacute; recomendado o Apache HTTP Server 2.2.<br></td>
    </tr>

    
<tr>
        <td class="tbltd1"><a target="_blank" href="http://www.phpunit.de">PHPUnit</a></td>
        <td>Vers&atilde;o 3.3.0 ou posterior.</td>
    </tr>
  </tbody>
</table>

<h2 id="installing-phpunit">Instala&ccedil;&atilde;o do PHPUnit</h2>
<p>Utilize o PEAR para instalar o PHPUnit como descrito na <a target="_blank" href="http://www.phpunit.de/manual/current/en/installation.html">Documenta&ccedil;&atilde;o PHPUnit</a>. Instale o PHPUnit vers&atilde;o 3.3.0 ou posterior. Nenhuma configura&ccedil;&atilde;o especial &eacute; necess&aacute;ria. Ap&oacute;s o PHPUnit ser instalado, o NetBeans pode reconhec&ecirc;-lo. Note que &eacute; necess&aacute;rio possuir o PEAR instalado com seu mecanismo PHP. Note tamb&eacute;m que a documenta&ccedil;&atilde;o PHPUnit informa que o PHPUnit &eacute; usualmente instalado no diret&oacute;rio PEAR local. Eles fornecem um caminho de <tt>/usr/lib/php/PHPUnit</tt>, mas no XAMPP para Windows, &eacute; <tt>XAMPP_HOME\php\PEAR\PHPUnit</tt>. </p>
<p>Para verificar se o NetBeans IDE reconhece sua instala&ccedil;&atilde;o PHPUnit, abra Ferramentas &gt; Op&ccedil;&otilde;es (no Mac, abra Prefer&ecirc;ncias do NetBeans) e examine a janela PHP. Abra a guia Teste de unidade. O caminho para seu script PHPUnit deveria aparecer no campo Script PHPUnit. Se o script n&atilde;o est&aacute; ali, procure pelo mesmo.</p>
<img src="../../../images_www/articles/71/php/phpunit/php-options.png" height="431" width="519" alt="P&aacute;gina Op&ccedil;&otilde;es mostrando o caminho para o script PHPUnit" class="margin-around">
<h2 id="create-test">Cria&ccedil;&atilde;o e execu&ccedil;&atilde;o de testes PHPUnit</h2>
<p>O NetBeans IDE pode criar e executar testes PHPUnit em todas as classes PHP em um arquivo. Para ter certeza de que o gerador de teste ir&aacute; funcionar, forne&ccedil;a o mesmo nome do arquivo PHP que a primeira classe no arquivo. </p>
<p><strong>Para criar e executar testes PHPUnit para um classe</strong></p>
<ol>
  <li>Crie um projeto PHP denominado Calculador. Neste projeto, crie um arquivo denominado <tt>calculator.php</tt>. Neste arquivo, digite ou cole a classe Calculator a partir do <a target="_blank" href="http://www.phpunit.de/manual/current/en/skeleton-generator.html">cap&iacute;tulo Skeleton Generator da documenta&ccedil;&atilde;o do PHPUnit</a>.
  <pre class="examplecode">&lt;?php
class Calculator
{
    public function add($a, $b)
    {
        return $a + $b;
    }
}
?&gt;</pre></li>
<li>Adicione um bloco de coment&aacute;rio com o <a target="_blank" href="http://sebastian-bergmann.de/archives/628-Improved-Skeleton-Generator-in-PHPUnit-3.html">@assert annotation</a> e alguma amostra de entrada e sa&iacute;da. Observe que uma afirma&ccedil;&atilde;o incorreta est&aacute; inclu&iacute;da neste exemplo.
<pre class="examplecode">&lt;?php
class Calculator
{
    /**
     * @assert (0, 0) == 0
     * @assert (0, 1) == 1
     * @assert (1, 0) == 1
     * @assert (1, 1) == 2
     * @assert (1, 2) == 4
     */
    public function add($a, $b)
    {
        return $a + $b;
    }
}
?&gt;</pre></li>
<li>Na janela Projetos, clique com o bot&atilde;o direito do mouse no n&oacute; Calulator.php e selecione Ferramentas &gt; Criar testes PHPUnit. Observe que voc&ecirc; pode criar testes para todos os arquivos em um projeto a partir do menu de contexto para o n&oacute; Arquivos de c&oacute;digo-fonte.<br>
<img src="../../../images_www/articles/71/php/phpunit/create-tests.png" height="647" width="453" alt="Menu de contexto para o n&oacute; Arquivos de c&oacute;digo-fonte do projeto PHP, mostrando a op&ccedil;&atilde;o Criar testes PHP" class="margin-around"></li>
<li>Na primeira vez que voc&ecirc; cria testes, uma caixa de di&aacute;logo &eacute; aberta perguntando pelo diret&oacute;rio onde deseja armazenar os arquivos de teste. Nesse exemplo, a fun&ccedil;&atilde;o Procurar foi utilizada para criar um diret&oacute;rio <tt>testes</tt>.
<br><img src="../../../images_www/articles/71/php/phpunit/test-directory.png" height="177" width="364" alt="Caixa de di&aacute;logo Diret&oacute;rio de arquivo de teste" class="margin-around"></li>
<li>O IDE gera uma classe de teste de esqueleto em um arquivo denominado CalculatorTest.php, que aparece em sua janela Projetos e &eacute; aberta no editor.
<br><img src="../../../images_www/articles/71/php/phpunit/test-class-in-project.png" alt="Janela Projetos mostrando a nova classe de teste" height="245" width="204" class="margin-around">
<p>Observe que um teste &eacute; criado para cada anota&ccedil;&atilde;o <tt>@assert</tt>.</p>
<pre class="examplecode">    /**
     * Generated from @assert (1, 1) == 2.
     */
    public function testAdd4()
    {
        $this-&gt;assertEquals(
          2,
          $this-&gt;object-&gt;add(1, 1)
        );
    }</pre></li>
    <li>&Eacute; poss&iacute;vel testar um arquivo individual ou todo o projeto. Para testar o projeto, clique com o bot&atilde;o direito do mouse no n&oacute; pai do projeto e selecione Testar ou pressione Alt-F6. Para testar o arquivo Calculator.php, clique com o bot&atilde;o direito do mouse no n&oacute; do arquivo e selecione Testar ou pressione Ctrl-F6/⌘-F6. Esse exemplo tem somente uma classe em um arquivo, portanto, os resultados s&atilde;o os mesmos. O IDE executa os testes e exibe os resultados na janela Resultados do teste.
    <br><img src="../../../images_www/articles/71/php/phpunit/test-results-narrow.png" alt="Janela Resultados do teste" height="254" width="600" class="margin-around"> <p>Uma vers&atilde;o textual mais verbosa dos resultados &eacute; exibida na janela Sa&iacute;da.</p>
    <img src="../../../images_www/articles/71/php/phpunit/test-result-output.png" alt="Janela Sa&iacute;da mostrando os resultados do teste" height="269" width="535" class="margin-around"></li>
</ol>
<h2><a name="test-groups"></a>Uso de grupos de teste</h2>
<p>A partir do NetBeans IDE vers&atilde;o 7.1, voc&ecirc; pode usar grupos de teste PHPUnit. Selecione que grupos de teste quer executar quando for executar o conjunto de teste. Por exemplo: &eacute; poss&iacute;vel ter somente alguns testes a serem executados num ambiente de produ&ccedil;&atilde;o e outros testes a serem executados tanto nos ambientes de produ&ccedil;&atilde;o quanto de desenvolvimento. Os testes antigos seriam colocados num grupo de <tt>production</tt> e os testes posteriores tanto nos grupos <tt>produ&ccedil;&atilde;o</tt> quanto <tt>desenvolvimento</tt>. Quando o conjunto de testes &eacute; executado no ambiente de desenvolvimento, seleciona-se somente o grupo de teste de <tt>desenvolvimento</tt> a ser executado.</p>
<p>&Eacute; preciso ativar os grupos de teste para um projeto PHP antes de usar os grupos de teste em qualquer arquivo do projeto. </p>
<p>Para marcar um teste como parte de um grupo de teste, anote o m&eacute;todo de teste com <tt>@group [nome do grupo]</tt>.</p>
<p><strong>Para criar e executar grupos de teste:</strong></p>
<ol>
  <li>Na janela Projetos, clique com o bot&atilde;o direito no n&oacute; Calculadora e selecione Propriedades. Ser&atilde;o exibidas as Propriedades do projeto.</li>
  <li>Nas Propriedades do projeto, selecione a categoria PhpUnit. Selecione Solicitar grupos de teste antes de executar os testes. Clique em OK.<br><img src="../../../images_www/articles/71/php/phpunit/test-group-properties.png" alt="Propriedades do projeto, Categoria PhpUnit, mostrando os grupos de testes ativados" width="600" height="424" class="margin-around"></li>
  <li>Abra <tt>CalculatorTest.php</tt> no editor.</li>
  <li>Para os m&eacute;todos <tt>testAdd</tt>, <tt>testAdd3</tt> e <tt>testAdd5</tt>, acrescente a anota&ccedil;&atilde;o <tt>@group production</tt>.<br><img src="../../../images_www/articles/71/php/phpunit/production-group-annotation.png" alt="C&oacute;digo mostrando a anota&ccedil;&atilde;o de grupo de teste" width="391" height="155" class="margin-around b-all"></li>
  <li>Para os m&eacute;todos <tt>testAdd2</tt> e <tt>testAdd4</tt>, acrescente as anota&ccedil;&otilde;es <tt>@group production</tt> e <tt>@group development</tt>. <img src="../../../images_www/articles/71/php/phpunit/production-development-group-code.png" alt="C&oacute;digo mostrando as anota&ccedil;&otilde;es do grupo de teste" width="388" height="172" class="margin-around b-all"></li>
  <li>Clique com o bot&atilde;o direito no n&oacute; <tt>Calculator.php</tt> e selecione Teste. Abre-se uma caixa de di&aacute;logo, perguntando quais grupos de teste ser&atilde;o executados. Selecione “development” e clique em OK. O IDE s&oacute; executa os testes anotados com <tt>@group development</tt>.<br><img src="../../../images_www/articles/71/php/phpunit/select-test-group.png" alt="Caixa de di&aacute;logo Selecionar grupo de teste" width="374" height="260" class="margin-around"></li>
</ol>
<p>Para obter mais informa&ccedil;&otilde;es sobre os grupos de teste PhpUnit no IDE NetBeans, consulte a publica&ccedil;&atilde;o no blog do IDE NetBeans para PHP<a target="_blank" href="http://blogs.oracle.com/netbeansphp/entry/using_phpunit_test_groups">Uso de grupos de teste da unidade PHP</a>.</p>
<h2 id="result-windows">Resultados de teste e sa&iacute;da IDE</h2>
<p>Os resultados dos testes PHPUnit s&atilde;o exibidos em duas das janelas do IDE, Resultados do teste e Sa&iacute;da. A janela Resultados do teste possui um painel gr&aacute;fico e um painel de texto curto. A janela Sa&iacute;da fornece um vers&atilde;o textual mais verbosa da sa&iacute;da. Nesta se&ccedil;&atilde;o voc&ecirc; explora as janelas Resultados do teste e Sa&iacute;da em mais detalhes.</p>
<p>Na janela Resultados do teste, voc&ecirc; obt&eacute;m informa&ccedil;&otilde;es sobre os testes que falharam a partir destas localiza&ccedil;&otilde;es:</p>
<ul>
  <li>As mensagens no painel IU anexado &agrave; entrada da &aacute;rvore para os testes que falharam</li>
  <li>Texto no painel direito, incluindo links para as linhas do c&oacute;digo de teste que falhou</li>
  <li>Texto da dica de ferramenta que aparece quando voc&ecirc; passa o cursor sobre o teste que falhou no painel IU</li>
</ul>
<img src="../../../images_www/articles/71/php/phpunit/test-results-tooltip.png" class="margin-around" height="267" width="596" alt="Janela Resultados do teste mostrando a dica da ferramenta">
<p>A janela Resultados do teste inclui os seguintes bot&otilde;es no lado esquerdo:</p>
<ul>
    <li> Executar novamente o teste <img src="../../../images_www/articles/71/php/phpunit/rerun-button.png" alt="bot&atilde;o de nova execu&ccedil;&atilde;o"></li>
  <li>Mostrar os testes com falha <img src="../../../images_www/articles/71/php/phpunit/show-failed.png" alt="bot&atilde;o Mostrar testes com falha"></li>
  <li>Mostrar testes aprovados<img src="../../../images_www/articles/71/php/phpunit/show-passed.png" alt="bot&atilde;o Mostrar testes aprovados"></li>
  <li>Mostrar testes aprovados com erros<img src="../../../images_www/articles/71/php/phpunit/show-error.png" alt="bot&atilde;o Mostrar testes aprovados com erros"></li>
  <li>Navegar entre as exibi&ccedil;&otilde;es de pr&oacute;ximo resultado de teste<img src="../../../images_www/articles/71/php/phpunit/next-test-button.png" alt="bot&atilde;o pr&oacute;ximo teste"> ou resultado de teste anterior <img src="../../../images_www/articles/71/php/phpunit/previous-test-button.png" alt="bot&atilde;o teste anterior"></li>
</ul>
<p>A janela Sa&iacute;da mostra a sa&iacute;da completa do script PHPUnit. Ela pode ser &uacute;til quando n&atilde;o &eacute; poss&iacute;vel identificar a causa de um erro com as informa&ccedil;&otilde;es na janela Resultados do teste. Como na janela Resultados do teste, a janela Sa&iacute;da inclui links para a linha da classe de teste que falhou. Ela tamb&eacute;m inclui bot&otilde;es no lado esquerdo para re-executar os testes e para abrir a janela Op&ccedil;&otilde;es PHP. <img src="../../../images_www/articles/71/php/phpunit/options-link-button.png" alt="Bot&atilde;o na janela Sa&iacute;da vinculando com Op&ccedil;&otilde;es"></p>
<img src="../../../images_www/articles/71/php/phpunit/test-result-output.png" alt="Janela Sa&iacute;da mostrando os resultados completos do teste PHPUnit" height="269" width="535" class="margin-around">
<h2 id="code-coverage">Cobertura de c&oacute;digo</h2>
<p>O NetBeans IDE para o PHP oferece a cobertura de c&oacute;digo junto com o suporte PHPUnit. (O IDE tamb&eacute;m oferece cobertura de c&oacute;digo para Python). A cobertura do c&oacute;digo verifica se todos os seus m&eacute;todos s&atilde;o cobertos pelos testes PHPUnit. Nesta se&ccedil;&atilde;o, voc&ecirc; v&ecirc; como funciona a cobertura de c&oacute;digo com sua classe Calculator existente.</p>
<p><strong>Para utilizar a cobertura de c&oacute;digo:</strong></p>
<ol>
  <li>Abra Calculator.php e adicione uma fun&ccedil;&atilde;o <tt>add</tt> duplicada, denominada <tt>add2</tt>. A classe <tt>Calculator</tt> agora se parece com o seguinte:
  <pre class="examplecode">&lt;?php
class Calculator {
    /**
     * @assert (0, 0) == 0
     * @assert (0, 1) == 1
     * @assert (1, 0) == 1
     * @assert (1, 1) == 2
     * @assert (1, 2) == 4
     */
    public function add($a, $b) {
        return $a + $b;
    }

    public function add2($a, $b) {
        return $a + $b;
    }

}    
?&gt;
</pre></li>
<li>Clique com o bot&atilde;o direito do mouse no n&oacute; do projeto. No menu de contexto, selecione Cobertura de c&oacute;digo &gt; Coletar e exibir a cobertura de c&oacute;digo. Por padr&atilde;o, Exibir a barra do editor tamb&eacute;m &eacute; selecionada.
<br><img src="../../../images_www/articles/71/php/phpunit/turn-on-code-coverage.png" alt="Habilitando a cobertura de c&oacute;digo a partir do menu de contexto do n&oacute; do projeto" height="251" width="503" class="margin-around" border="1"></li>
<li>O editor agora tem uma barra de editor de cobertura de c&oacute;digo atrav&eacute;s da parte inferior. Como a cobertura do c&oacute;digo ainda n&atilde;o foi testada, a barra do editor reporta 0% de cobertura. (Ela tamb&eacute;m exibe isso ap&oacute;s voc&ecirc; clicar em Limpar para limpar os resultados do teste). 
<br><img src="../../../images_www/articles/71/php/phpunit/editor-bar-before.png" alt="Barra do editor para a cobertura do c&oacute;digo antes da execu&ccedil;&atilde;o dos testes" height="428" width="592" class="margin-around"></li>
<li>Clique em Testar para testar o arquivo aberto ou em Todos os testes para executar todos os testes do projeto. Os resultados do teste s&atilde;o exibidos. Al&eacute;m disso, a barra Cobertura de c&oacute;digo lhe informa qual a porcentagem das instru&ccedil;&otilde;es de c&oacute;digo execut&aacute;veis &eacute; coberta pelos testes. Na janela Editor, o c&oacute;digo coberto &eacute; real&ccedil;ado em verde e o c&oacute;digo n&atilde;o coberto &eacute; real&ccedil;ado em vermelho.
    <p class="alert"><b>Aviso: </b>se os arquivos de testes forem gerados novamente DEPOIS da adi&ccedil;&atilde;o da fun&ccedil;&atilde;o add2, os testes PHPUnit n&atilde;o ser&atilde;o executados. O PHPUnit cria duas fun&ccedil;&otilde;es testAdd2 com conflito. N&atilde;o diferencie fun&ccedil;&otilde;es acrescentando n&uacute;meros no final se voc&ecirc; planeja usar o PHPUnit em mais de uma fun&ccedil;&atilde;o como essa. Consulte a <a href="http://www.phpunit.de/ticket/701" target="_blank">documenta&ccedil;&atilde;o do PHPUnit</a>. </p>   
<img src="../../../images_www/articles/71/php/phpunit/editor-bar-after.png" alt="Barra do editor para a cobertura do c&oacute;digo ap&oacute;s a execu&ccedil;&atilde;o dos testes"  class="margin-around"></li>
<li>Na barra Editor, clique em relat&oacute;rio... O relat&oacute;rio de Cobertura de c&oacute;digo &eacute; aberto mostrando os resultados de todos os testes executados em seu projeto. Os bot&otilde;es no relat&oacute;rio permitem limpar os resultados, reexecutar todos os testes ou desativar a cobertura de c&oacute;digo (clique em Conclu&iacute;do).
<br><img src="../../../images_www/articles/71/php/phpunit/code-coverage-report.png" alt="relat&oacute;rio de cobertura de c&oacute;digo" height="185" width="405" class="margin-around"></li>
<li>&Eacute; poss&iacute;vel adicionar outra classe em seu projeto, excluir e recriar os arquivos de teste e examinar novamente o relat&oacute;rio de cobertura de c&oacute;digo. Sua nova classe &eacute; listada. No relat&oacute;rio a seguir, a classe <tt>Calculator</tt> tem novamente uma fun&ccedil;&atilde;o que n&atilde;o est&aacute; inclu&iacute;da nos testes.
<br><img src="../../../images_www/articles/71/php/phpunit/code-coverage-report2.png" alt="relat&oacute;rio de cobertura de c&oacute;digo mostrando a segunda classe" height="226" width="451" class="margin-around"></li>
</ol>
<h2 id="project-specific-configurations">Uso de configura&ccedil;&otilde;es espec&iacute;ficas do projeto</h2>
<p>No IDE, voc&ecirc; pode selecionar as configura&ccedil;&otilde;es personalizadas seguintes no seu projeto:</p>
<ul>
  <li>Um arquivo bootstrap</li>
  <li>Um arquivo de configura&ccedil;&atilde;o XML</li>
  <li>Um su&iacute;te de teste</li>
</ul>
<p>Para definir uma configura&ccedil;&atilde;o espec&iacute;fica do projeto, clique com o bot&atilde;o direito do mouse no n&oacute; Testar arquivos do projeto e selecione Propriedades. Isso abre a caixa de di&aacute;logo Propriedades. Em seguida, selecione a categoria PHPUnit. &Eacute; exibida uma caixa de di&aacute;logo na qual &eacute; poss&iacute;vel selecionar um arquivo bootstrap personalizado, um arquivo de configura&ccedil;&atilde;o XML ou um arquivo de su&iacute;te de teste. Se n&atilde;o estiver familiarizado com a estrutura desses arquivos, voc&ecirc; pode utilizar o NetBeans IDE para gerar um esquema.</p>
<img src="../../../images_www/articles/71/php/phpunit/phpunit-project-properties.png" class="margin-around" alt="Selecionando as op&ccedil;&otilde;es personalizados do PHPUnit em uma caixa de di&aacute;logo das propriedades do projeto" border="1">
<p>A <em>op&ccedil;&atilde;o bootstrap</em> &eacute; necess&aacute;ria em projetos que utilizam um carregador de classe personalizado, por exemplo, para implementar a fun&ccedil;&atilde;o m&aacute;gica <tt>__autoload()</tt>. Tamb&eacute;m &eacute; poss&iacute;vel utilizar a op&ccedil;&atilde;o bootstrap se for necess&aacute;rio incluir um arquivo com anteced&ecirc;ncia, como um arquivo que defina as constantes globais utilizadas por v&aacute;rias classes no projeto.</p>
<p>O <em>arquivo de configura&ccedil;&atilde;o XML</em> permite definir as op&ccedil;&otilde;es utilizadas em uma chamada da linha de comando. H&aacute; uma introdu&ccedil;&atilde;o completa no <a target="_blank" href="http://www.phpunit.de/manual/3.3/en/appendixes.configuration.html" title="Manual do PHPUnit">manual do PHPUnit</a>. Tamb&eacute;m &eacute; poss&iacute;vel utilizar o arquivo de configura&ccedil;&atilde;o XML para definir as configura&ccedil;&otilde;es do <tt>php.ini</tt> e as vari&aacute;veis globais dos casos de teste. &Eacute; poss&iacute;vel definir a op&ccedil;&atilde;o bootstrap tamb&eacute;m no arquivo de configura&ccedil;&atilde;o XML.</p>
<p>Se voc&ecirc; definir uma <em>su&iacute;te de teste personalizada</em>, tal su&iacute;te ser&aacute; executada sempre que voc&ecirc; selecionar Executar &gt; Testar projeto. Isso &eacute; particularmente &uacute;til quando voc&ecirc; desejar executar somente um subconjunto dos testes ou caso queira utilizar os recursos adicionados recentemente de PHPUnit que devem ser adicionados manualmente, como Provedores de dados. </p>
<p>Observe que voc&ecirc; pode definir quantos su&iacute;tes de teste quiser e execut&aacute;-los de forma separada clicando com o bot&atilde;o direito do mouse no explorador de projetos e escolhendo &quot;executar&quot;.</p>
<p>Para evitar confus&otilde;es, o NetBeans lhe avisa se estiver utilizando uma su&iacute;te de teste personalizado. A notifica&ccedil;&atilde;o pode ser encontrada nos Resultados do teste e na janela Sa&iacute;da.</p>
<h2 id="selenium">Executando testes no framework Selenium</h2>
<p>O Selenium &eacute; uma estrutura de software de teste port&aacute;til para aplicativos da Web. Os testes podem ser escritos como tabelas HTML ou codificados em diversas linguagens de programa&ccedil;&atilde;o populares e podem ser executados diretamente na maioria dos navegadores modernos da Web. O Selenium pode ser implantado no Windows, Linux e Macintosh. Para obter mais detalhes, consulte o <a target="_blank" href="http://www.openqa.org/selenium/">site do Selenium</a>. </p>
<p>O NetBeans IDE tem um plug-in que inclui um servidor Selenium. Com esse plug-in, &eacute; poss&iacute;vel executar testes Selenium nos projetos PHP, aplicativos da Web ou Maven. Para executar testes Selenium no PHP, &eacute; preciso instalar o pacote Testing Selenium em seu mecanismo PHP.</p>
<p><strong>Para executar testes Selenium no PHP:</strong></p>
<ol>
  <li>Abra um prompt de comando e execute o comando <tt>pear install Testing_Selenium-beta</tt>. &Eacute; preciso possuir<tt> PHP_HOME/php/PEAR</tt> em seu Path. Se o comando obtiver &ecirc;xito, o prompt exibir&aacute; <tt>install ok: channel://pear.php.net/Testing_Selenium-0.4.3</tt>.</li>
  <li>No IDE, abra Ferramentas &gt; Plug-ins e instale o m&oacute;dulo Selenium para o PHP.</li>
  <li>Na janela Projetos, clique com o bot&atilde;o direito do mouse no n&oacute; do projeto Calculador. Selecione Novo &gt; Outro. O assistente Novo arquivo &eacute; aberto. Selecione Selenium e clique em Pr&oacute;ximo.
  <br><img src="../../../images_www/articles/71/php/phpunit/new-selenium.png" height="413" width="543" alt="Assistente Novo arquivo com o arquivo Selenium escolhido" class="margin-around"></li>
  <li>Na primeira vez que voc&ecirc; cria um teste Selenium, &eacute; exibida uma caixa de di&aacute;logo solicitando que voc&ecirc; defina o diret&oacute;rio dos arquivos de teste Selenium. Ele deveria ser separado do diret&oacute;rio dos arquivos de teste PHPUnit. Caso contr&aacute;rio, os testes Selenium ser&atilde;o executados cada vez que voc&ecirc; executar testes de unidade. A execu&ccedil;&atilde;o de testes funcionais como o Selenium, normalmente levam mais tempo do que a execu&ccedil;&atilde;o de testes de unidade, portanto, voc&ecirc; provavelmente n&atilde;o desejar&aacute; executar estes testes cada vez que executar testes de unidade.</li>
  <li>Aceite os padr&otilde;es na p&aacute;gina Nome e localiza&ccedil;&atilde;o e clique em Terminar. O novo arquivo de teste Selenium &eacute; aberto no editor e aparece na janela Projetos.
  <br><img src="../../../images_www/articles/71/php/phpunit/selenium-test-in-project.png" alt="Janela Projetos mostrando o novo teste Selenium" height="187" width="279" class="margin-around"></li>
  <li>O item Executar testes Selenium est&aacute; agora adicionado no menu de contexto do projeto. Clique neste item e os resultados do teste Selenium ser&atilde;o exibidos na janela Resultados do teste, da mesma forma que os resultados de testes PHPUnit.</li>
</ol>
<h2 id="more-exercises">Mais exerc&iacute;cios</h2>
    <p>Aqui est&atilde;o mais algumas id&eacute;ias para voc&ecirc; explorar:</p>
    <ul>
      <li>Adicione uma segunda classe ao Calculator.php, como um classe <tt>Calculator2</tt> que multiplica $a e $b. Exclua e gere novamente os testes.</li>
      <li>Se voc&ecirc; experimentar o <a href="../../docs/php/wish-list-tutorial-main-page.html">Tutorial de cria&ccedil;&atilde;o de um aplicativo CRUD</a> de m&uacute;ltiplas partes, crie um teste Selenium para o projeto final. </li>
    </ul>
<div class="feedback-box">
  <a href="/about/contact_form.html?to=3&amp;subject=Feedback:PHPUnit and Selenium on NB 6.7">Envie-nos seus coment&aacute;rios</a>
</div>
<br style="clear:both;" >
<p>Para enviar coment&aacute;rios e sugest&otilde;es, obter suporte e manter-se informado sobre os desenvolvimentos mais recentes dos recursos de desenvolvimento em PHP no NetBeans IDE, <a href="../../../community/lists/top.html">junte-se &agrave; lista de usu&aacute;rios users@php.netbeans.org</a>. Esta lista &eacute; espelhada nos <a target="_blank" href="http://forums.netbeans.org/">f&oacute;runs NetBeans IDE</a>.</p>
<a name="seeAlso"></a>
        <h2>Consulte tamb&eacute;m</h2>

        <p>Para obter mais informa&ccedil;&otilde;es sobre como testar o PHP no NetBeans IDE <a target="_blank" href="https://netbeans.org/"></a>, consulte os seguintes recursos:</p>
        <ul>
            <li><a target="_blank" href="http://blogs.sun.com/netbeansphp/entry/phpunit_support_added">Blog do NetBeans para o PHP: suporte PHPUnit adicionado</a></li>
            <li><a target="_blank" href="http://blogs.sun.com/netbeansphp/entry/ui_for_phpunit_support">Blog do NetBeans para o PHP: IU para suporte PHPUnit</a></li>
            <li><a target="_blank" href="http://blogs.sun.com/netbeansphp/entry/code_coverage_for_php_why">Blog do NetBeans para o PHP: cobertura de c&oacute;digo para o PHP - Porque n&atilde;o?</a></li>
            <li><a target="_blank" href="http://blogs.sun.com/netbeansphp/entry/recent_improvements_in_phpunit_support">Blog do NetBeans para PHP: melhorias recentes no suporte do PHPUnit</a></li>
            <li><a target="_blank" href="http://wiki.netbeans.org/SeleniumPluginPHP">Wiki do NetBeans IDE: plug-in Selenium para o PHP</a></li>
            <li><a href="../../docs/php/debugging.html">Depurando o c&oacute;digo-fonte do PHP no NetBeans IDE</a></li>
            
        </ul>
<p><a href="../../trails/php.html">Voltar &agrave; trilha do aprendizado PHP</a> </p>
  
</body>