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.

Observação. Se você estiver usando GlassFish 3.1.x, consulte Testando uma Aplicação Corporativa Maven com o GlassFish Server 3.1 Incorporado

Exercícios do Tutorial

O conteúdo desta página se aplica ao NetBeans IDE 6.8, 6.9, 7.4 e 8.0

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

Software ou Recurso Versão Necessária
NetBeans IDE Pacote Java EE 7.4 e 8.0
JDK (Java Development Kit) versão 7 ou 8
GlassFish Server Open Source Edition 4.0

Observação. 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.

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

  4. 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 Configurando o Maven no tutorial Criando uma Aplicação Maven Swing Utilizando Hibernação e também 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.

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.

Observação. 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.

  2. Digite MyEntity para o Nome da Classe.
  3. Selecione com.mycompany.mavenwebtestapp como o Pacote e defina o Tipo de Chave Primária como int.
  4. Confirme se Criar Unidade de Persistência está selecionado. Clique em Próximo.
  5. Selecione jdbc/sample na lista drop-down Fonte de Dados.
  6. 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.
    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.

  7. No editor de código-fonte, adicione o campo privado nome à classe.
    private String name;
  8. 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.
  9. Adicione o construtor a seguir.
    public MyEntity(int id) {
        this.id = id;
        name = "Entity number " + id + " created at " + new Date();
    }
  10. 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.
    @Entity
    @NamedQueries({
        @NamedQuery(name = "MyEntity.findAll", query = "select e from MyEntity e")})
    public class MyEntity implements Serializable {

  11. Clique na dica na margem esquerda próximo da declaração de classe e selecione a dica Criar construtor default.
    Janela Projetos que mostra projetos gerados
  12. 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.

  2. Selecione Beans de Sessão para Classes de Entidade na categoria Enterprise JavaBeans. Clique em Próximo.
  3. Na lista de Classes de Entidade Disponíveis, selecione MyEntity e clique em Adicionar. Clique em Próximo.
  4. 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.

    @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);
        }
        
    }
  5. Adicione os seguintes métodos a MyEntityFacade.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);
            }
        }
  6. Corrija suas importações para adicionar as instruções de importação necessárias. Salve as alterações.
    Janela Projetos que mostra projetos gerados

    Observação. 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.

    Observação. 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.

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

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

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

        @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.");
        }
  6. Faça as seguintes alterações (em negrito) no esqueleto do método de teste testVerify.
    @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();
    }
  7. 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.

  8. Abra pom.xml no editor e localize o elemento <properties>.
        <properties>
            <endorsed.dir>${project.build.directory}/endorsed</endorsed.dir>
            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        </properties>
                    
  9. 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.
        <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>
                    

    Observação. <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.

  10. Clique com o botão direito do mouse no nó Dependências na janela Projetos e selecione Adicionar Dependência.
  11. Na caixa de diálogo Adicionar Dependência, digite embedded-static-shell no campo de texto Consultar.
  12. Localize o JAR 4.0 nos resultados da pesquisa e clique em Adicionar.
    tela da janela Resultados de 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.

  13. 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.
            <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>
                    
  14. 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.

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

tela da janela Resultados de Teste

Na janela Resultados do Teste, você pode clicar no ícone Aprovado (Í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.

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


Consulte Também

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

Para obter mais informações sobre o uso de Enterprise Beans, consulte o 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, inscreva-se na lista de correspondência de nbj2ee.

get support for the NetBeans

Support


By use of this website, you agree to the NetBeans Policies and Terms of Use. © 2013, Oracle Corporation and/or its affiliates. Sponsored by Oracle logo