netbeans.apache.org/src/content/kb/docs/javaee/javaee-entapp-junit_pt_BR.asciidoc

// 
//     Licensed to the Apache Software Foundation (ASF) under one
//     or more contributor license agreements.  See the NOTICE file
//     distributed with this work for additional information
//     regarding copyright ownership.  The ASF licenses this file
//     to you under the Apache License, Version 2.0 (the
//     "License"); you may not use this file except in compliance
//     with the License.  You may obtain a copy of the License at
// 
//       http://www.apache.org/licenses/LICENSE-2.0
// 
//     Unless required by applicable law or agreed to in writing,
//     software distributed under the License is distributed on an
//     "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
//     KIND, either express or implied.  See the License for the
//     specific language governing permissions and limitations
//     under the License.
//

= Usando o Container EJB Incorporado para Testar Aplicações Corporativas
:jbake-type: tutorial
:jbake-tags: tutorials 
:jbake-status: published
:icons: font
:syntax: true
:source-highlighter: pygments
:toc: left
:toc-title:
:description: Usando o Container EJB Incorporado para Testar Aplicações Corporativas - Apache NetBeans
:keywords: Apache NetBeans, Tutorials, Usando o Container EJB Incorporado para Testar Aplicações Corporativas

Esse tutorial demonstra como criar e executar testes JUnit para uma aplicação enterprise Java EE. Neste tutorial, você criará uma aplicação web com uma classe de entidade e um bean de sessão. Primeiro, você criará uma classe de teste JUnit para o bean de sessão e executará o teste no contêiner EJB incorporado. Em seguida, você adicionará uma classe de entidade ao projeto e modificará a classe de teste para adicionar um método de teste para a classe de entidade.

*Exercícios do Tutorial*

* <<Exercise_1,Testando um Bean de Sessão>>
* <<Exercise_1a,Criando o Projeto>>
* <<Exercise_1b,Criando o Bean de Sessão>>
* <<Exercise_1c,Testando o Bean de Sessão>>
* <<Exercise_1d,Modificando o Teste para Especificar Propriedades do Container>>
* <<Exercise_1e,Usando Anotações @BeforeClass e @AfterClass>>
* <<Exercise_2,Testando uma Classe de Entidade>>
* <<Exercise_2a,Criando a Classe de Entidade>>
* <<Exercise_2b,Modificando o Bean de Sessão>>
* <<Exercise_2c,Testando a Classe de Entidade>>
* <<Exercise_3,Fazendo Download do Projeto da Solução>>

*Para seguir este tutorial, são necessários os recursos e o software a seguir.*

|===
|Software ou Recurso |Versão Necessária 

|link:/downloads/[+NetBeans IDE+] |Pacote Java EE 7.2, 7.3, 7.4, 8.0 

|link:http://www.oracle.com/technetwork/java/javase/downloads/index.html[+JDK (Java Development Kit)+] |versão 7 ou 8 

|GlassFish Server Open Source Edition |3.1.x ou 4.x 
|===

NOTE: Este tutorial requer o plug-in JUnit. Se você não tiver instalado o plug-in JUnit quando instalou o IDE, abra o Gerenciador de Plug-ins, selecione a guia plug-ins Disponíveis e instale o plug-in JUnit.

*Pré-requisitos*

Este tutorial pressupõe que você tenha algum conhecimento básico das tecnologias a seguir, ou alguma experiência de programação com elas:

* Programação em Java
* NetBeans IDE

Antes de começar este tutorial, você pode se familiarizar com os seguintes documentos.

* link:javaee-gettingstarted.html[+Conceitos Básicos sobre Aplicações do Java EE+]
* link:../java/junit-intro.html[+Escrevendo Testes JUnit no NetBeans IDE+]
* link:http://download.oracle.com/docs/cd/E19798-01/821-1754/gjlde/index.html[+Usando a API integrada do EJB 3.1 com o GlassFish Server Incorporado+]

Você pode fazer download link:https://netbeans.org/projects/samples/downloads/download/Samples%252FJavaEE%252FWebAppJUnit.zip[+de um arquivo compactado zip do projeto finalizado+].


== Testando um Bean de Sessão

Nesta sessão, você criará uma aplicação web Java EE simples que conterá uma classe de entidade e um bean de sessão.


=== Criando o Projeto

1. Selecione Arquivo > Novo Projeto (Ctrl-Shift-N; ⌘-Shift-N no Mac) no menu principal.
2. Na categoria Java Web, selecione Aplicação Web. Clique em Próximo.
3. Chame o projeto de *WebAppJUnit* e defina a localização do projeto.
4. Desmarque a opção Usar Pasta Dedicada, se ela estiver selecionada.
Clique em Próximo.

[start=5]
. Defina o servidor como *GlassFish Server* e defina a versão do Java EE para *Java EE 6 Web* ou *Java EE 7 Web*. 
Clique em Finalizar.


=== Criando o Bean de Sessão

Neste exercício, você criará um bean de sessão muito simples que contém um método que adiciona dois números.

1. Clique com o botão direito do mouse no projeto WebAppJUnit na janela Projetos e selecione Novo > Outro.
2. Selecione o Bean de Sessão na categoria Enterprise JavaBeans. Clique em Próximo.
3. Digite *MyBean* como o Nome EJB.
4. Insira *bean* como o Nome do Pacote.
5. Selecione Sem Estado para o Tipo de Sessão. Clique em Finalizar.

Quando você clica em Finalizar, a nova classe é aberta no editor.


[start=6]
. No editor, adicione o seguinte método  ``addNumbers``  à classe.

[source,java]
----

@Stateless
public class MyBean {
    *public int addNumbers(int numberA, int numberB) {
        return numberA + numberB;
    }*
}
----

NOTE:  Ele não é necessário para adicionar uma anotação  ``@LocalBean``  ou implementar uma interface neste tutorial. Por default, o bean expõe uma view sem interface quando nenhuma view é especificada explicitamente.


[start=7]
. Salve as alterações.


=== Testando o Bean de Sessão

Neste exercício, você criará uma classe de teste para o bean de sessão que testará o método  ``addNumbers`` . O IDE pode gerar os novos métodos de classe de teste e de teste esqueleto com base nos métodos da classe de destino.

1. Clique com o botão direito do mouse na classe  ``MyBean``  na janela Projetos e selecione Ferramentas > Criar Testes.
2. Selecione JUnit na lista drop-down Frameworks.
3. Use os valores default na caixa de diálogo Criar Testes. Clique em OK.

image::images/create-tests-dialog.png[title="Caixa de diálogo Criar Testes"]

NOTE:  Na primeira vez que você criar um teste da unidade JUnit, deverá especificar a versão de JUnit. Selecione a JUnit 4.x na caixa de diálogo Selecionar Versão do JUnit e clique em Selecionar.

Quando você clica em OK, o IDE gera o arquivo  ``MyBeanTest.java``  e abre a classe no editor.

Na janela Projetos, você pode ver que o IDE gerou a classe de teste no nó Testar Pacotes. Por default, o IDE gera um método de teste esqueleto na classe de teste que chama  ``javax.ejb.embeddable.EJBContainer.createEJBContainer()``  para criar uma instância do contêiner EJB. O método  ``createEJBContainer()``  é um dos métodos na classe link:http://download.oracle.com/javaee/6/api/javax/ejb/embeddable/EJBContainer.html[+  ``EJBContainer`` +] que faz parte da API integrada do EJB 3.1.

Se você expandir o nó Bibliotecas de Teste na janela Projetos, poderá ver que o IDE adicionou automaticamente o GlassFish Server (contêiner incorporado) e o JUnit 4.x como bibliotecas de teste. Se você expandir a biblioteca do GlassFish Server, verá que a biblioteca contém o  ``glassfish-embedded-static-shell.jar`` .

image::images/embedded-static-shell-jar.png[title="Estrutura do projeto na janela Projetos"]

NOTE:  O JAR  ``glassfish-embedded-static-shell.jar``  não contém os códigos-fonte do contêiner EJB incorporado. O JAR  ``glassfish-embedded-static-shell.jar``  requer uma instalação local do GlassFish. O classpath para a instalação local do GlassFish é determinado pelo servidor de destino do projeto. Você pode alterar o servidor de destino na caixa de diálogo Propriedades do projeto.


[start=4]
. Modifique o método de teste esqueleto gerado para especificar valores para  ``numberA`` ,  ``numberB``  e  ``expResult``  e remova a chamada default para falha.

[source,java]
----

@Test
public void testAddNumbers() throws Exception {
    System.out.println("addNumbers");
    *int numberA = 1;
    int numberB = 2;*
    EJBContainer container = javax.ejb.embeddable.EJBContainer.createEJBContainer();
    MyBean instance = (MyBean)container.getContext().lookup("java:global/classes/MyBean");
    *int expResult = 3;*
    int result = instance.addNumbers(numberA, numberB);
    assertEquals(expResult, result);
    container.close();
}
----

[start=5]
. Clique com o botão direito do mouse no projeto na janela Projetos e selecione Testar.

Quando você executa o teste, a janela Resultados do Teste é aberta no IDE e exibe o andamento e os resultados do teste.

image::images/test-results1.png[title="Janela Resultados do Teste"]

Você verá uma saída semelhante à seguinte na janela de Saída:


[source,java]
----

Testsuite: bean.MyBeanTest
addNumbers
...
Tests run: 1, Failures: 0, Errors: 0, Time elapsed: 31.272 sec

------------- Standard Output ---------------
addNumbers
...
------------- ---------------- ---------------
test-report:
test:
BUILD SUCCESSFUL (total time: 35 seconds)
----


=== Modificando o Teste para Especificar Propriedades do Container

Quando você usou o assistente Criar Testes, o IDE gerou uma classe de teste esqueleto default que continha código para iniciar o contêiner EJB. Neste exercício, você modificará o código gerado que inicia o contêiner para permitir a especificação de propriedades adicionais para a instância do contêiner incorporado.

1. Adicione o seguinte código (em negrito) à classe de teste.

[source,java]
----

@Test
public void testAddNumbers() throws Exception {
    System.out.println("addNumbers");
    int numberA = 1;
    int numberB = 2;

    // Create a properties map to pass to the embeddable container:
    *Map<String, Object> properties = new HashMap<String, Object>();*
    // Use the MODULES property to specify the set of modules to be initialized,
    // in this case a java.io.File 
    *properties.put(EJBContainer.MODULES, new File("build/jar"));*

    // Create the container instance, passing it the properties map:
    EJBContainer container = javax.ejb.embeddable.EJBContainer.createEJBContainer(*properties*);

    // Create the instance using the container context to look up the bean 
    // in the directory that contains the built classes
    MyBean instance = (MyBean) container.getContext().lookup("java:global/classes/MyBean");

    int expResult = 3;

    // Invoke the addNumbers method on the bean instance:
    int result = instance.addNumbers(numberA, numberB);

    assertEquals(expResult, result);

    // Close the embeddable container:
    container.close();
}
----

[start=2]
. Clique com o botão direito do mouse no editor e selecione Corrigir Importações (Alt-Shift-I; ⌘-Shift-I no Mac) para adicionar instruções de importação para  ``java.util.HashMap``  e  ``java.util.Map`` .

[start=3]
. Execute novamente o teste para confirmar se o teste modificado funciona e se o contêiner foi criado corretamente.

Você pode clicar no botão Reexecutar na janela Resultados do Teste.

 


=== Usando Anotações  ``@BeforeClass``  e  ``@AfterClass`` 

Neste exercício, você modificará a classe de teste para criar métodos individuais para criar e encerrar a instância do contêiner. Isso pode ser útil quando você desejar executar vários testes que podem usar a mesma instância do contêiner. Dessa forma, não é necessário abrir e fechar uma instância do contêiner para cada teste e criar, em vez disso, uma instância que é criada de os testes serem executados e fechada depois de todos os testes terem sido concluídos.

Neste exercício, você moverá o código que cria o contêiner EJB para o método  ``setUpClass`` . O método  ``setUpClass``  é anotado com  ``@BeforeClass``  que é usado para indicar um método que será executado primeiro, antes dos outros métodos na classe de teste. Neste exemplo, a instância do contêiner será criada antes do método de teste  ``testAddNumbers``  e o contêiner existirá até que seja encerrado.

De forma semelhante, você moverá o código que encerra o contêiner para o método  ``tearDownClass``  que é anotado com  ``@AfterClass`` .

1. Adicione o campo a seguir à classe de teste.

[source,java]
----

private static EJBContainer container;
----

[start=2]
. Copie o código que cria o contêiner do método de teste  ``testAddNumbers``  para o método  ``setUpClass``  e

[source,java]
----

@BeforeClass
public static void setUpClass() *throws Exception* {
    *Map<String, Object> properties = new HashMap<String, Object>();
    properties.put(EJBContainer.MODULES, new File("build/jar"));
    container = EJBContainer.createEJBContainer(properties);
    System.out.println("Opening the container");*
}
----

[start=3]
. Copie o código que fecha o contêiner do método de teste  ``testAddNumbers``  para o método  ``tearDownClass`` .

[source,java]
----

@AfterClass
public static void tearDownClass() *throws Exception* {
    *container.close();
    System.out.println("Closing the container");*
}
----

[start=4]
. Remova o código redundante do método  ``testAddNumbers`` . Salve as alterações.

A classe de teste deve se parecer com o seguinte.


[source,java]
----

public class MyBeanTest {
    private static EJBContainer container;

    public MyBeanTest() {
    }

    @BeforeClass
    public static void setUpClass() throws Exception {
        Map<String, Object> properties = new HashMap<String, Object>();
        properties.put(EJBContainer.MODULES, new File("build/jar"));
        container = EJBContainer.createEJBContainer(properties);
        System.out.println("Opening the container");
    }

    @AfterClass
    public static void tearDownClass() throws Exception {
        container.close();
        System.out.println("Closing the container");
    }

    @Before
    public void setUp() {
    }

    @After
    public void tearDown() {
    }

    /**
     * Test of addNumbers method, of class MyBean.
     */ 
    @Test
    public void testAddNumbers() throws Exception {
        System.out.println("addNumbers");
        int numberA = 1;
        int numberB = 2;

        // Create the instance using the container context to look up the bean 
        // in the directory that contains the built classes
        MyBean instance = (MyBean) container.getContext().lookup("java:global/classes/MyBean");

        int expResult = 3;

        // Invoke the addNumbers method on the bean instance:
        int result = instance.addNumbers(numberA, numberB);

        assertEquals(expResult, result);
    }
}
----

Caso você execute novamente o teste para confirmar se o contêiner é criado e fechado corretamente, verá uma saída semelhante à seguinte na janela Resultados do Teste.

image::images/test-results2a.png[title="Janela Resultados do Teste"]

Você pode ver que o método  ``setUpClass``  foi executado antes do teste  ``addNumbers``  e imprimiu "Abrindo o contêiner".


== Testando uma Classe de Entidade

Nesta sessão, você criará uma classe de entidade e unidade de persistência, e modificará o bean de sessão para injetar o gerenciador de entidades e acessar as entidades. Você adicionará um método simples à nova classe de entidade que imprime o número de id da entrada na saída. Em seguida, você adicionará alguns métodos simples ao bean de sessão para criar e verificar entradas no banco de dados.


=== Criando a Classe de Entidade

Nesta seção, você usará o assistente Nova Classe de Entidade para criar uma classe de entidade e uma unidade de persistência com os detalhes de conexão do banco de dados.

1. Clique com o botão direito do mouse no projeto WebAppJUnit na janela Projetos e selecione Novo > Outro.
2. Selecione a Classe de Entidade na categoria Persistência. Clique em Próximo.
3. Digite *SimpleEntity* como o Nome da Classe.
4. Selecione bean na lista drop-down Pacote.
5. Digite *int* como o Tipo de Chave Primária. Clique em Próximo.
6. Use o Nome e o Provedor da Unidade de Persistência Default.
7. Selecione  ``jdbc/sample``  como a fonte de dados e Soltar e Criar como a estratégia. Clique em Finalizar.

image::images/create-entity-wizard.png[title="Caixa de diálogo Criar Classe de Entidade"]

Quando você clica em Finalizar, a nova classe de entidade é aberta no editor. Se você expandir o nó Arquivos de Configuração na janela Projetos, verá que o IDE gerou automaticamente o arquivo  ``persistence.xml``  que define as propriedades da unidade de persistência  ``WebAppJUnitPU`` .


[start=8]
. No editor, adicione o campo privado a seguir à classe de entidade.

[source,java]
----

private String name;
----

[start=9]
. Clique com o botão direito do mouse no Editor de Código-Fonte e selecione Inserir Código (Alt-Insert; Ctrl-I no Mac) e selecione Getter e Setter para abrir a caixa de diálogo Gerar Getters e Setters.

[start=10]
. Selecione o campo  ``name``  na caixa de diálogo. Clique em Gerar.

[start=11]
. Adicione o seguinte método à classe.

[source,java]
----

public SimpleEntity(int id) {
    this.id = id;
    name = "Entity number " + id + " created at " + new Date();
}
----

[start=12]
. Use as anotações  ``@NamedQueries``  e  ``@NamedQuery``  para criar uma consulta SQL nomeada.

[source,java]
----

@Entity
*@NamedQueries({@NamedQuery(name = "SimpleEntity.findAll", query = "select e from SimpleEntity e")})*
public class SimpleEntity implements Serializable {
----

[start=13]
. Crie um construtor default.

Você pode clicar no ícone de sugestão exibido na medianiz, próximo à declaração de classe, se quiser que o IDE gere o construtor para você.


[start=14]
. Corrija suas importações para adicionar instruções de importação para  ``javax.persistence.NamedQueries`` ,  ``javax.persistence.NamedQuery``  e  ``java.util.Date`` . Salve as alterações.

Além do código default gerado, a classe de entidade agora deve ser semelhante a:


[source,java]
----

package bean;

import java.io.Serializable;
import java.util.Date;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;


@Entity
@NamedQueries({@NamedQuery(name = "SimpleEntity.findAll", query = "select e from SimpleEntity e")})
public class SimpleEntity implements Serializable {
    private static final long serialVersionUID = 1L;
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private int id;

    private String name;

    public SimpleEntity() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public SimpleEntity(int id) {
        this.id = id;
        name = "Entity number " + id + " created at " + new Date();
    }

    

    ...

}
----


=== Modificando o Bean de Sessão

Neste exercício, você editará o bean de sessão  ``MyBean``  para adicionar métodos para inserir e recuperar dados para a tabela do banco de dados.

1. Abra  ``MyBean.java``  no editor.
2. Clique com o botão direito do mouse no editor, selecione Inserir Código (Alt-Insert; Ctrl-I no Mac) e selecione Usar Gerenciador de Entidades no menu pop-up.

Quando você tiver selecionado Usar Gerenciador de Entidades, o IDE terá adicionado o código a seguir à classe para injetar o gerenciador de entidades. Você pode ver que o nome da unidade de persistência foi gerado automaticamente.


[source,java]
----

@PersistenceContext(unitName="WebAppJUnitPU")
private EntityManager em;
----

[start=3]
. Adicione os seguintes métodos  ``verify``  e  ``insert`` .

[source,java]
----

@PermitAll
public int verify() {
    String result = null;
    Query q = em.createNamedQuery("SimpleEntity.findAll");
    Collection entities = q.getResultList();
    int s = entities.size();
    for (Object o : entities) {
        SimpleEntity se = (SimpleEntity)o;
        System.out.println("Found: " + se.getName());
    }

    return s;
}

@PermitAll
public void insert(int num) {
    for (int i = 1; i <= num; i++) {
        System.out.println("Inserting # " + i);
        SimpleEntity e = new SimpleEntity(i);
        em.persist(e);
    }
}
----

[start=4]
. Corrija suas importações para importar o  ``javax.persistence.Query``  e salve as alterações.


=== Testando a Classe de Entidade

Neste exercício, você editará a classe de teste para adicionar um método para testar se a aplicação pode procurar o EJB e se os métodos  ``insert``  e  ``verify``  estão se comportando corretamente.

1. Inicie o banco de dados JavaDB.
2. Abra a classe de teste  ``MyBeanTest.java``  no editor.
3. Edite a classe de teste para adicionar o seguinte método de teste  ``testInsert`` .

[source,java]
----

@Test
public void testInsert() throws Exception {

    // Lookup the EJB
    System.out.println("Looking up EJB...");
    MyBean instance = (MyBean) container.getContext().lookup("java:global/classes/MyBean");

    System.out.println("Inserting entities...");
    instance.insert(5);
    int res = instance.verify();
    System.out.println("JPA call returned: " + res);
    System.out.println("Done calling EJB");

    Assert.assertTrue("Unexpected number of entities", (res == 5));
    System.out.println("..........SUCCESSFULLY finished embedded test");
}
----

[start=4]
. Na janela Projetos, clique com o botão direito do mouse no nó do projeto e escolha Testar no menu pop-up.

A janela Resultados do teste será aberta e exibirá uma saída semelhante à seguinte.

image::images/test-results2b.png[title="A janela Resultados do Teste depois da adição do teste testInsert"]

Você pode ver o andamento dos testes e a ordem na qual eles foram executados nas mensagens impressas que foram adicionadas à classe de teste.

Agora que você tem um teste para seu bean de sessão e sabe que a conexão de sua classe de entidade funciona, pode começar a codificar uma interface web para a aplicação. 


== Fazendo Download do Projeto da Solução

Você pode fazer o download da solução para este projeto como um projeto das seguintes formas.

* Faça download link:https://netbeans.org/projects/samples/downloads/download/Samples%252FJavaEE%252FWebAppJUnit.zip[+de um arquivo compactado zip do projeto finalizado+].
* Faça o check-out do código-fonte do projeto das Amostras do NetBeans ao executar as etapas a seguir:
1. Escolha Equipe > Subversion > Efetuar check-out no menu principal.
2. Na caixa de diálogo Check-out, insira o URL de Repositório a seguir:
 ``https://svn.netbeans.org/svn/samples~samples-source-code`` 
Clique em Próximo.

[start=3]
. Clique em Procurar para abrir a caixa de diálogo Procurar Pastas do Repositório.

[start=4]
. Expanda o nó raiz e selecione *samples/javaee/WebAppJUnit*. Clique em OK.

[start=5]
. Especifique a Pasta Local para o códigos-fonte (a pasta local precisa estar vazia).

[start=6]
. Clique em Finalizar.

Quando você clica em Finalizar, o IDE inicializa a pasta local como um repositório Subversion e verifica os códigos-fonte do projeto.


[start=7]
. Clique em Abrir Projeto na caixa de diálogo exibida quando o check-out for concluído.

NOTE: É necessário um cliente Subversion para verificar os códigos-fonte. Para saber mais sobre a instalação do Subversion, consulte a seção link:../ide/subversion.html#settingUp[+Configurando o Subversion+] no link:../ide/subversion.html[+Guia do Subversion no NetBeans IDE+].


link:/about/contact_form.html?to=3&subject=Feedback:%20Using%20the%20Embedded%20EJB%20Container[+Enviar Feedback neste Tutorial+]



== Consulte Também

Para obter mais informações sobre o uso do NetBeans IDE para desenvolver aplicações Java EE, consulte os seguintes recursos:

* link:javaee-intro.html[+Introdução à Tecnologia Java EE+]
* link:javaee-gettingstarted.html[+Conceitos Básicos sobre Aplicações do Java EE+]
* link:../web/quickstart-webapps.html[+Introdução ao Desenvolvimento de Aplicações Web+]
* link:../../trails/java-ee.html[+Trilha de Aprendizado do Java EE e Java Web+]

Você pode encontrar mais informações sobre o uso do Enterprise Beans EJB 3.1 no link:http://download.oracle.com/javaee/6/tutorial/doc/[+Tutorial do Java EE 6+].

Para enviar comentários e sugestões, obter suporte e se manter informado sobre os mais recentes desenvolvimentos das funcionalidades de desenvolvimento do Java EE do NetBeans IDE, link:../../../community/lists/top.html[+inscreva-se na lista de correspondência de nbj2ee+].