// 
//     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.
//

= Testando uma Aplicação Corporativa Maven
:jbake-type: tutorial
:jbake-tags: tutorials 
:jbake-status: published
:icons: font
:syntax: true
:source-highlighter: pygments
:toc: left
:toc-title:
:description: Testando uma Aplicação Corporativa Maven - Apache NetBeans
:keywords: Apache NetBeans, Tutorials, Testando uma Aplicação Corporativa Maven

Este tutorial demonstra como testar uma aplicação corporativa simples utilizando arquétipos Maven e NetBeans IDE. Neste tutorial, você cria uma aplicação corporativa que contém uma classe de entidade e um bean de sessão. Você usará um assistente para criar uma classe de teste simples para a classe bean e, em seguida, executará o teste no IDE. A classe de teste criará uma instância do contêiner EJB incorporado no GlassFish para testar a conexão com o banco de dados.

NOTE:  Se você estiver usando GlassFish 3.1.x, consulte link:../../73/javaee/maven-entapp-testing.html[+Testando uma Aplicação Corporativa Maven com o GlassFish Server 3.1 Incorporado+]

*Exercícios do Tutorial*

* <<intro,Utilizando o Maven no IDE>>
* <<Exercise_1,Criando a Aplicação Corporativa>>
* <<Exercise_1a,Criando o Projeto Web>>
* <<Exercise_1b,Criando a Classe de Entidade>>
* <<Exercise_1c,Criando o Bean de Sessão>>
* <<Exercise_2,Criando o Teste de Bean de Sessão>>

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

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

|link:https://netbeans.org/downloads/index.html[+NetBeans IDE+] |Pacote Java EE 7.4 e 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 |4.0 
|===

NOTE:  O instalador do GlassFish Server é incluído quando você faz download do pacote Java EE. Você pode instalar e registrar o GlassFish como parte do processo de instalação do NetBeans IDE.

*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, talvez você queira se familiarizar com a documentação a seguir.

* link:http://wiki.netbeans.org/MavenBestPractices[+Melhores Práticas para o Apache Maven no NetBeans IDE+]
* link:http://books.sonatype.com/mvnref-book/reference/introduction.html[+Capítulo 1. Introdução ao Apache Maven+] (do link:http://books.sonatype.com/mvnref-book/reference/index.html[+Maven: A Referência Completa +])


== Utilizando o Maven no IDE

O suporte ao Maven está totalmente integrado no NetBeans IDE. Desenvolver um projeto que utiliza o framework do Maven é quase igual a desenvolver um projeto no Ant. No entanto, há algumas diferenças relacionadas ao modo como o Maven constrói os projetos e trabalha com as dependências. As dicas a seguir podem ajudá-lo a evitar alguns problemas caso esteja criando uma aplicação Maven pela primeira vez.

*Verifique as definições do Maven*

Se este for seu primeiro Projeto Maven, pode ser necessário verificar as definições da configuração do Maven na janela Opções. Para completar este tutorial é preciso ter o Maven instalado em seu sistema local. O Maven está incorporado ao IDE e é instalado quando você instala o IDE.

1. Abra a janela Opções no IDE (Ferramentas > Opções; NetBeans > Preferências no Mac).
2. Selecione a categoria Java na janela Opções e clique na guia Maven.
3. Confirme se um Início do Maven está especificado.

Você pode usar a versão do Maven incorporada no IDE ou especificar a localização de uma instalação local do Maven (requer versão 2.0.9 ou posterior).



. Clique em OK para fechar a janela Opções.

*Observações.* O suporte a Maven será automaticamente ativado quando o Java estiver ativado no IDE. Você precisará ativar o plug-in Java EE, se não estiver ativado.

*Atualizar seus repositórios Maven*

Os repositórios remotos e locais do Maven são utilizados para a funcionalidade autocompletar código e para construir projetos. É necessário atualizar os índices dos repositórios remotos do Maven para garantir que os artefatos necessários estejam prontamente disponíveis no momento de desenvolver o projeto. Você pode configurar com que frequência o IDE verifica as atualizações na guia Maven da janela Opções. Você também pode executar uma verificação imediata das atualizações e explorar os repositórios remotos e locais do Maven na janela Serviço.

1. Escolha Janela > Serviços para abrir a janela Serviços.
2. Expanda o nó Repositórios do Maven na janela Serviços.
3. Clique com o botão direito do mouse no repositório e escolha Atualizar Índice no menu pop-up.

Quando você clica em Atualizar Índices, o IDE verifica e faz o download do índice mais recente de cada um dos repositórios remotos do Maven. Um índice representa o estado atual dos artefatos localizados no repositório e é utilizado para proporcionar referências aos artefatos que estão disponíveis na aplicação. Por default, o IDE não faz download de um artefato de um repositório até que o artefato seja explicitamente necessário.

*Observações.*

* Os índices são muito grandes e pode levar algum tempo para atualizar todos eles.

Para obter mais detalhes sobre o uso do Maven no NetBeans IDE, consulte a seção link:https://netbeans.org/kb/docs/java/maven-hib-java-se.html#02[+Configurando o Maven+] no tutorial link:https://netbeans.org/kb/docs/java/maven-hib-java-se.html[+Criando uma Aplicação Maven Swing Utilizando Hibernação+] e também link:http://wiki.netbeans.org/MavenBestPractices[+Melhores Práticas para o Apache Maven no NetBeans IDE+].


== Criando a Aplicação Corporativa

Nesta seção, você criará uma aplicação web simples que contém uma classe de entidade e um bean de sessão que acessa a classe de entidade.


=== Criando o Projeto Web

Neste exercício, você utilizará o assistente Novo Projeto para criar uma aplicação web Java EE com base em um arquétipo Maven. Ao criar o projeto com o assistente, você especificará o GlassFish Server como o servidor de destino.

1. Selecione Arquivo > Novo Projeto (Ctrl-Shift-N; ⌘-Shift-N no Mac) no menu principal para abrir o assistente Novo Projeto.
2. Selecione Aplicação Web na categoria Maven. Clique em Próximo.
3. Chame o projeto de *mavenwebtestapp* e defina a localização dele. Clique em Próximo.
4. Selecione o GlassFish Server na lista drop-down Servidor.
5. Selecione Java EE 6 Web ou Java EE 7 Web na lista drop-down Java EE Version. Clique em Finalizar.

Quando você clica em Finalizar, o IDE cria a aplicação web e abre o projeto na janela Projetos.

image::images/maven-testing-projects.png[title="Janela Projetos que mostra projetos gerados"]

Se você expandir o nó do projeto na janela Projetos, poderá notar que o JAR  ``javaee-web-api``  está listado como uma dependência do projeto e que o JDK está listado como uma dependência do Java. O IDE gerou o POM do projeto ( ``pom.xml`` ) e o arquivo foi listado no nó Arquivos do Projeto.


=== Criando a Classe de Entidade

Neste exercício, você usa o assistente Novo Arquivo para criar uma classe de entidade. Ao criar a classe de entidade, você selecionará a fonte de dados  ``jdbc/sample``  no assistente. Não é preciso criar ou registrar uma nova fonte de dados, pois a fonte de dados  ``jdbc/sample``  foi registrada quando você instalou o servidor.

NOTE:  Se quiser criar uma nova fonte de dados ou usar uma fonte de dados diferente, a fonte de dados deverá ser registrada no servidor, antes de você testar a aplicação que usa o contêiner incorporado. Quando você testar a aplicação usando o contêiner incorporado, o IDE não registrará a fonte de dados para você como faz ao implantar em uma instância do GlassFish Server.

1. Clique com o botão direito do mouse no nó do projeto e selecione Novo > Classe de Entidade.

Como alternativa, selecione Arquivo > Novo Arquivo (Ctrl-N; ⌘-N no Mac) no menu principal e selecione Classe de Entidade na categoria Persistência.



. Digite *MyEntity* para o Nome da Classe.


. Selecione  ``com.mycompany.mavenwebtestapp``  como o Pacote e defina o Tipo de Chave Primária como * ``int`` *.


. Confirme se Criar Unidade de Persistência está selecionado. Clique em Próximo.


. Selecione *jdbc/sample* na lista drop-down Fonte de Dados.


. Confirme se a opção Usar APIs de Transação Java está selecionada e selecione Soltar e Criar como a Estratégia de Geração de Tabela. Clique em Finalizar.

image::images/maven-testing-pu.png[title="Janela Projetos que mostra projetos gerados"]

Quando você clica em Finalizar, o IDE gera a classe MyEntity e abre a classe no editor de código-fonte. O IDE adiciona os artefatos  ``eclipselink`` ,  ``javax.persistence``  e  ``org.eclipse.persistence.jpa.modelgen.processor``  como dependências de projeto.



. No editor de código-fonte, adicione o campo privado  ``nome``  à classe.

[source,java]
----

private String name;
----


. Clique com o botão direito do mouse no editor e selecione Getter e Setter no menu pop-up Inserir Código (Alt-Insert; Ctrl+I no Mac) para gerar um getter e um setter para o campo  ``nome`` .


. Adicione o construtor a seguir.

[source,java]
----

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


. Adicione as anotações  ``@NamedQueries``  e  ``@NamedQuery``  a seguir (em negrito) para criar uma consulta SQL nomeada que localizará todos os registros na tabela MyEntity.

[source,java]
----

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



. Clique na dica na margem esquerda próximo da declaração de classe e selecione a dica *Criar construtor default*.

image::images/maven-testing-createconstructor.png[title="Janela Projetos que mostra projetos gerados"]



. Corrija as instruções de importação (Ctrl-Shift-I; ⌘-Shift-I no Mac) para adicionar instruções de importação para  ``javax.persistence.NamedQuery`` ,  ``javax.persistence.NamedQueries``  e  ``java.util.Date`` . Salve as alterações. 


=== Criando o Bean de Sessão

Neste exercício, você utilizará o assistente para criar uma fachada de sessão para a classe de entidade  ``MyEntity`` . Quando você usa o assistente para gerar a fachada, o IDE também gerará uma fachada abstrata que contém alguns métodos, como  ``create``  e  ``find`` , que são usados comumente ao acessar classes de entidade. Você adicionará, em seguida, dois métodos à fachada.

1. Clique com o botão direito do mouse no nó do projeto e selecione Novo > Outro.

Como alternativa, selecione Arquivo > Novo Arquivo (Ctrl-N; ⌘-N no Mac) no menu principal para abrir o assistente Novo Arquivo.



. Selecione Beans de Sessão para Classes de Entidade na categoria Enterprise JavaBeans. Clique em Próximo.


. Na lista de Classes de Entidade Disponíveis, selecione  ``MyEntity``  e clique em Adicionar. Clique em Próximo.


. Use as propriedades default no painel Beans de Sessão Gerados do assistente. Clique em Finalizar.

Quando você clicar em Finalizar, o IDE gerará  ``AbstractFacade.java``  e  ``MyEntityFacade.java``  no pacote  ``com.mycompany.mavenwebtestapp``  e abrirá as classes no editor de código-fonte.

No editor de código-fonte, você poderá ver que o IDE gerou o código para  ``EntityManager``  e adicionou a anotação  ``@PersistenceContext``  para especificar a unidade de persistência.


[source,java]
----

@Stateless
public class MyEntityFacade extends AbstractFacade<MyEntity> {
    @PersistenceContext(unitName = "com.mycompany_mavenwebtestapp_war_1.0-SNAPSHOTPU")
    private EntityManager em;

    @Override
    protected EntityManager getEntityManager() {
        return em;
    }

    public MyEntityFacade() {
        super(MyEntity.class);
    }
    
}
----


. Adicione os seguintes métodos a  ``MyEntityFacade.java`` .

[source,java]
----

    @PermitAll
    public int verify() {
        String result = null;
        Query q = em.createNamedQuery("MyEntity.findAll");
        Collection entities = q.getResultList();
        int s = entities.size();
        for (Object o : entities) {
            MyEntity se = (MyEntity) 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);
            MyEntity e = new MyEntity(i);
            em.persist(e);
        }
    }
----


. Corrija suas importações para adicionar as instruções de importação necessárias. Salve as alterações. 

image::images/maven-testing-fiximports.png[title="Janela Projetos que mostra projetos gerados"]

NOTE:  Confirme se * ``javax.persistence.Query`` * está selecionado na caixa de diálogo Corrigir Todas as Importações.


== Criando o Teste do Bean de Sessão

Nesta seção, você criará uma classe de teste JUnit para a fachada de sessão  ``MyEntityFacade`` . O IDE gerará métodos de teste esqueletos para cada um dos métodos na classe de fachada, bem como para cada um dos métodos na fachada abstrata. Você anotará os métodos de teste que são gerados para os métodos na fachada abstrata para instruir o IDE e o executor do teste de JUnit a ignorá-los. Em seguida, você modificará o método de teste do método  ``verify``  que foi adicionado a  ``MyEntityFacade`` .

Nos testes gerados, você verá que o IDE adiciona automaticamente um código que chama o  ``EJBContainer``  para criar uma instância do contêiner EJB.

1. Clique com o botão direito do mouse em  ``MyEntityFacade.java``  na janela Projetos e escolha Ferramentas > Criar Testes.
2. Selecione um framework de teste na lista drop-down Framework
3. Use as opções default na caixa de diálogo Criar Testes. Clique em OK.

NOTE:  Na primeira vez que você criar um teste de JUnit, deverá especificar a versão do framework de JUnit. Selecione a JUnit 4.x como a versão de JUnit e clique em Selecionar.

Por default, o IDE gera uma classe de teste esqueleto que contém testes para cada um dos métodos em  ``MyEntityFacade``  e  ``AbstractFacade`` . O IDE adiciona, automaticamente, uma dependência no JUnit 4.10 para o POM.



. Anote cada um dos métodos de teste, exceto  ``testVerify`` , com a anotação  ``@Ignore`` . O IDE ignorará cada um dos testes anotados com  ``@Ignore``  ao executar os testes.

Como alternativa, você pode deletar todos os métodos de teste, exceto  ``testVerify`` .



. Localize o método de teste  ``testVerify``  na classe de teste.

Você pode ver que o teste contém uma linha que chama  ``EJBContainer`` .


[source,java]
----

    @Test
    public void testVerify() throws Exception {
        System.out.println("verify");
        EJBContainer container = javax.ejb.embeddable.EJBContainer.createEJBContainer();
        MyEntityFacade instance = (MyEntityFacade)container.getContext().lookup("java:global/classes/MyEntityFacade");
        int expResult = 0;
        int result = instance.verify();
        assertEquals(expResult, result);
        container.close();
        // TODO review the generated test code and remove the default call to fail.
        fail("The test case is a prototype.");
    }
----


. Faça as seguintes alterações (em negrito) no esqueleto do método de teste  ``testVerify`` .

[source,java]
----

@Test
public void testVerify() throws Exception {
    System.out.println("verify");
    EJBContainer container = javax.ejb.embeddable.EJBContainer.createEJBContainer();
    MyEntityFacade instance = (MyEntityFacade)container.getContext().lookup("java:global/classes/MyEntityFacade");
    *System.out.println("Inserting entities...");
    instance.insert(5);*
    int result = instance.verify();
    *System.out.println("JPA call returned: " + result);
    System.out.println("Done calling EJB");
    Assert.assertTrue("Unexpected number of entities", (result == 5));*
    container.close();
}
----


. Corrija as instruções de importação para adicionar  ``junit.framework.Assert`` . Salve as alterações.

Você agora precisa modificar o POM para adicionar uma dependência ao  ``<glassfish.embedded-static-shell.jar>``  que está localizado em sua instalação local do GlassFish Server.



. Abra  ``pom.xml``  no editor e localize o elemento  ``<properties>`` .

[source,xml]
----

    <properties>
        <endorsed.dir>${project.build.directory}/endorsed</endorsed.dir>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
                
----


. Edite o elemento  ``<properties>``  para adicionar o elemento  ``<glassfish.embedded-static-shell.jar>``  (em *negrito*) que especifica a localização do JAR em sua instalação GlassFish local. Em seguida, você fará referência a esta propriedade na dependência do artefato.

[source,xml]
----

    <properties>
        <endorsed.dir>${project.build.directory}/endorsed</endorsed.dir>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        *<glassfish.embedded-static-shell.jar>_<INSTALLATION_PATH>_/glassfish-4.0/glassfish/lib/embedded/glassfish-embedded-static-shell.jar</glassfish.embedded-static-shell.jar>*

    </properties>
                
----

NOTE:   ``_<INSTALLATION_PATH>_``  é o caminho absoluto para sua instalação do GlassFish local. Será preciso modificar esse elemento no POM se o caminho para a instalação local for alterado.



. Clique com o botão direito do mouse no nó Dependências na janela Projetos e selecione Adicionar Dependência.


. Na caixa de diálogo Adicionar Dependência, digite *embedded-static-shell* no campo de texto Consultar.


. Localize o JAR 4.0 nos resultados da pesquisa e clique em Adicionar.

image::images/add-shell-dependency.png[title="Janela Resultados do Teste"]

Quando você clica em Adicionar, o IDE adiciona a dependência ao POM.

Agora você quer modificar o POM para especificar a instalação local do GlassFish como a origem para o JAR.



. Localize a dependência no POM e faça as seguintes alterações (em *negrito*) para modificar o elemento para fazer referência à propriedade  ``<glassfish.embedded-static-shell.jar>``  que você adicionou e para especificar o  ``<escopo>`` . Salve as alterações.

[source,xml]
----

        <dependency>
            <groupId>org.glassfish.main.extras</groupId>
            <artifactId>glassfish-embedded-static-shell</artifactId>
            <version>4.0</version>
            *<scope>system</scope>
            <systemPath>${glassfish.embedded-static-shell.jar}</systemPath>*
        </dependency>
                
----


. Na janela Serviços, clique com o botão direito do mouse no nó GlassFish Server e selecione Iniciar.

O servidor do banco de dados JavaDB também será iniciado quando você iniciar o GlassFish Server.



. Na janela Projetos, clique com o botão direito do mouse no nó do projeto e selecione Testar,

Quando você selecionar Testar, o IDE construirá a aplicação e executará a fase de teste do ciclo de vida da construção. Os testes de unidade serão executados com o plug-in surefire, que suporta a execução de testes JUnit 4.x. Para saber mais sobre o plug-in surefire, consulte link:http://maven.apache.org/plugins/maven-surefire-plugin/[+http://maven.apache.org/plugins/maven-surefire-plugin/+].

Você pode ver os resultados do teste na janela Resultados do Teste. É possível abrir a janela Resultados do Teste selecionando Janela > Saída > Resultados do Teste no menu principal.

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

Na janela Resultados do Teste, você pode clicar no ícone Aprovado (image:images/test-ok_16.png[title="Ícone Mostrar Aprovados"]) para exibir uma lista de todos os testes aprovados. Neste exemplo, você pode ver que nove testes passaram. Se observar a janela de Saída, você verá que só um teste foi executado e oito testes foram ignorados. Testes ignorados são incluídos na lista de testes aprovados, na janela Resultados do Teste.


[source,java]
----

Running com.mycompany.mavenwebtestapp.MyEntityFacadeTest
verify
...
Inserting entities...
Inserting # 1
Inserting # 2
Inserting # 3
Inserting # 4
Inserting # 5
Found: Entity number 2 created at Wed Oct 09 19:06:59 CEST 2013
Found: Entity number 4 created at Wed Oct 09 19:06:59 CEST 2013
Found: Entity number 3 created at Wed Oct 09 19:06:59 CEST 2013
Found: Entity number 1 created at Wed Oct 09 19:06:59 CEST 2013
Found: Entity number 5 created at Wed Oct 09 19:06:59 CEST 2013
JPA call returned: 5
Done calling EJB
...

Results :

Tests run: 9, Failures: 0, Errors: 0, Skipped: 8

----


link:/about/contact_form.html?to=3&subject=Feedback:%20Creating%20an%20Enterprise%20Application%20Using%20Maven[+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:maven-entapp.html[+Criando uma Aplicação Corporativa com o Maven+]
* link:../../trails/java-ee.html[+Trilha de Aprendizado do Java EE e Java Web+]

Para obter mais informações sobre o uso de Enterprise Beans, consulte o 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+].

