Começando rápido com o Forge

Authors: Paul Bakker, Lincoln Baxter, III Translator: Rafael Sakurai Language:
Last Update:Sep 14, 2013

Este guia irá te familiar com o plugin do Arquillian para o JBoss Forge. Depois de ler este guia, você será capaz de:

  • Instalar o plugin do Arquillian na sua instalação do Forge;
  • Usar o plugin para adicionar a infraestrutura do Arquillian nos projetos Java baseado em Maven;
  • Gerar um componente e seu correspondente teste Arquillian;
  • Executar o teste Arquillian em múltiplos containers sem configuração manual.

Você irá executar muitos passos iguais aos descritos no guia Começando, só que você deixará para o Forge fazer o trabalho pesado para você. Desenhamos esse guia para uma leitura rápida, assim o seu começo será mais rápido!

Considerações

Esse guia assume que você já tem configurado o JBoss Forge. A instalação do Forge é um processo relativamente simples. Veja no guia Começando ou na documentação oficial do Forge as instruções para baixar e instalar o Forge. Você também precisará do JDK 1.6 ou superior instalado na sua maquina.

Esse guia simula a saída para um usuário que tem o diretório home em /home/ike, e que criou os projetos na pasta projects e colocou as aplicações na pasta applications. Ajuste esses caminhos para ficarem iguais no seu sistema.

Criando um projeto

Antes de começarmos com o Arquillian, precisamos de um projeto. Se você não tem um criado, use os seguintes comandos do Forge para gerar um projeto básico com Java EE 6 que inclui o CDI.

$ new-project --named arquillian-demo --topLevelPackage org.arquillian.example
? Use [/home/ike/projects/arquillian-demo] as project directory? [Y/n]
***SUCCESS*** Created project [arquillian-demo] in new working directory [/home/ike/projects/arquillian-demo]
Wrote /home/ike/projects/arquillian-demo
Wrote /home/ike/projects/arquillian-demo/pom.xml
Wrote /home/ike/projects/arquillian-demo/src/main/java
Wrote /home/ike/projects/arquillian-demo/src/test/java
Wrote /home/ike/projects/arquillian-demo/src/main/resources
Wrote /home/ike/projects/arquillian-demo/src/test/resources
Wrote /home/ike/projects/arquillian-demo/src/main/java/org/arquillian/example
Wrote /home/ike/projects/arquillian-demo/src/main/resources/META-INF/forge.xml

O Forge adicionar o repositório da comunidade JBoss no arquivo pom.xml. Esse repositório não é obrigatório para usar o Arquillian. Você pode remover facilmente o repositório do arquivo pom.xml usando o comando do Forge:

$ project remove-repository http://repository.jboss.org/nexus/content/groups/public 
Removed repository [JBOSS_NEXUS->http://repository.jboss.org/nexus/content/groups/public]
Wrote /home/ike/projects/arquillian-demo/pom.xml

Seu novo projeto está criado! Agora precisamos criar algum código para testar. Vamos usar o Forge para criar um novo bean CDI.

Primeiro, vamos instalar o CDI em nosso projeto usando o plugin beans.

$ beans setup
***SUCCESS*** Installed [forge.spec.cdi] successfully.
***SUCCESS*** Beans (CDI) is installed.
Wrote /home/ike/projects/arquillian-demo/src/main/resources/META-INF/beans.xml
Wrote /home/ike/projects/arquillian-demo/pom.xml

A seguir, vamos usar o plugin para criar um novo bean com escopo dependent (dependente).

$ beans new-bean --type org.arquillian.example.MySimpleBean --scoped DEPENDENT
Picked up type <JavaResource>: org.arquillian.example.MySimpleBean
Wrote /home/ike/projects/arquillian-demo/src/main/java/org/arquillian/example/MySimpleBean.java

O projeto agora tem um componente. Vamos voltar para o diretório raiz do projeto e vamos testá-lo!

$ cd ~~

Configurando o Arquillian

A configuração do Arquillian é fácil, como você pode ver no guia Começando. No entanto, há muito trabalho de copiar e colar que necessários para configurar um novo adaptador de container do Arquillian no arquivo pom.xml. O Forge pode fazer isso para você com um único comando!

Primeiro você precisa instalar o plugin Arquillian no Forge.

$ forge install-plugin arquillian
Connecting to remote repository [https://raw.github.com/forge/plugin-repository/master/repository.yaml]... connected!
***INFO*** Preparing to install plugin: arquillian
***INFO*** Checking out plugin source files to [/tmp/forgetemp7898368163271511889/repo] via 'git'
...
***INFO*** Installing plugin artifact.
...
***SUCCESS*** Installed from [https://github.com/forge/plugin-arquillian.git] successfully.
...

O plugin já está pronto para ser usado. Agora precisamos configurar o Arquillian e o adaptador do container. Iremos configurar o Arquillian para usar com o JBoss AS7.

$ arquillian setup --container JBOSS_AS_MANAGED_7.X

O Forge irá sugerir a versão do JUnit, Arquillian e JBoss AS 7 que serão usados. Use a ultima versão de cada um.

O Forge pode até mesmo baixar o JBoss AS 7 para você automaticamente, te perguntando durante a configuração:

 ? Do you want Arquillian to install the container? [y/N]
Se você responder y:
O Forge te perguntará o local que você quer instalar o JBoss AS 7 (por exemplo: /home/ike/applications). O Forge então configura as dependências do plugin do Maven para baixar e descompactar o AS 7 nesse local antes dos testes iniciarem.
Se você responder n:
Você precisa ter uma instalação do JBoss AS 7 na sua maquina.

Nesse caso, você precisará informar para o Arquillian o local que o JBoss AS 7 está instalado. Uma maneira é configurar a variável de ambiente JBOSS_HOME com a localização da instalação do JBoss AS 7. A forma mais comum é configurar o caminho da instalação explicitamente usando a propriedade de configuração do container jbossHome no arquivo arquillian.xml. O Forge nós ajuda a fazer isso:

$ arquillian configure-container --profile JBOSS_AS_MANAGED_7.X
Which property do you want to set?

  1 - [Configuration{type='java.lang.String', name='jbossHome', description='The JBoss configuration to start.', defaultValue='$JBOSS_HOME'}]
  ...
 ? Choose an option by typing the number of the selection: 1
 ? What value do you want to set? /home/ike/applications/jboss-as-7.1.1.Final
Wrote /home/ike/projects/arquillian-demo/src/test/resources/arquillian.xml

A seguir temos o resultado do arquivo arquillian.xml (formatado para melhor leitura):

src/test/resources/arquillian.xml
<arquillian xmlns="http://jboss.org/schema/arquillian"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="
        http://jboss.org/schema/arquillian
        http://jboss.org/schema/arquillian/arquillian_1_0.xsd">
    <container qualifier="JBOSS_AS_MANAGED_7.X">
        <configuration>
            <property name="jbossHome">/home/ike/applications/jboss-as-7.1.1.Final</property>
        </configuration>
    </container>
</arquillian>

Para usar as configurações do container, você tem que:

  • Adicionar o atributo default="true" no elemento <container> do arquillian.xml;
  • Escrever o qualificador JBOSS_AS_MANAGED_7.X com apenas os conteúdos do arquivo src/test/resources/arquillian.launch.

É isso! O Arquillian está configurado e pronto para executar os testes dentro do JBoss AS 7.

Escreva um teste

Agora vamos escrever um teste. Mais uma vez, o Forge pode te ajudar nisso rapidamente:

$ arquillian create-test --class org.arquillian.example.MySimpleBean.java
Picked up type <JavaResource>: org.arquillian.example.MySimpleBeanTest
Wrote /home/ike/projects/arquillian-demo/src/test/java/org/arquillian/example/MySimpleBeanTest.java

Uma nova classe de teste com a publicação (deployment) e o método de teste é adicionado no projeto.

src/test/java/org/arquillian/example/MySimpleBeanTest.java
package org.arquillian.example;

import org.arquillian.example.MySimpleBean;
import javax.inject.Inject;
import org.jboss.arquillian.container.test.api.Deployment;
import org.jboss.arquillian.junit.Arquillian;
import org.jboss.shrinkwrap.api.ShrinkWrap;
import org.jboss.shrinkwrap.api.spec.JavaArchive;
import org.jboss.shrinkwrap.api.asset.EmptyAsset;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import static org.junit.Assert.*;
import static org.hamcrest.core.Is.*;

@RunWith(Arquillian.class)
public class MySimpleBeanTest {
    @Inject private MySimpleBean mysimplebean;

    @Deployment public static JavaArchive createDeployment() {
        return ShrinkWrap.create(JavaArchive.class, "test.jar")
            .addClass(MySimpleBean.class)
            .addAsManifestResource(EmptyAsset.INSTANCE, "beans.xml");
    }

    @Test
    public void testIsDeployed() {
        Assert.assertNotNull(mysimplebean);
    }
}

Como você pode ver, o teste injeta a classe dentro do teste (tal como: MySimpleBean) usando o CDI, então isso irá provar imediatamente se você está executando o teste em um container.

Você agora pode executar o teste da sua IDE, através do Maven (fora do Forge) ou pelo próprio Forge. Vamos ficar com o Forge.

$ build test --profile JBOSS_AS_MANAGED_7.X
...
-------------------------------------------------------
T E S T S
-------------------------------------------------------
Running org.arquillian.example.MySimpleBeanTest
...
Results :

Tests run: 1, Failures: 0, Errors: 0, Skipped: 0

Parabéns! Você conseguiu sua primeira barra verde com o Arquillian e o JBoss Forge!

Agora vamos tentar testar algum código JPA.

Teste de persistência

Antes de escrevermos o teste que usa o Java Persistence API (JPA), precisamos configurar o JPA. Então vamos criar uma Entity e seu correspondente Data Access Object (DAO). Essas são as classes que iremos testar.

$ persistence setup --provider HIBERNATE --container JBOSS_AS7
***SUCCESS*** Installed [forge.spec.jpa] successfully.
***INFO*** Setting transaction-type="JTA"
***INFO*** Using example data source [java:jboss/datasources/ExampleDS]
 ? The JPA provider [HIBERNATE], also supplies extended APIs. Install these as well? [y/N] n
Wrote /home/ike/projects/arquillian-demo/src/main/resources/META-INF/persistence.xml
Wrote /home/ike/projects/arquillian-demo/pom.xml

Agora vamos criar a entity.

$ entity --named Language --package org.arquillian.example.domain
Created @Entity [org.arquillian.example.domain.Language]
Picked up type <JavaResource>: org.arquillian.example.domain.Language
Wrote /home/ike/projects/arquillian-demo/src/main/java/org/arquillian/example/domain/Language.java

Então, vamos adicionar alguns campos na nossa entity.

$ field string --named name
Added field to org.arquillian.example.domain.Language: @Column private String name;
Wrote /home/ike/projects/arquillian-demo/src/main/java/org/arquillian/example/domain/Language.java

Se você abrir a classe Language, você verá uma estrutura de entidade JPA típica.

Agora precisamos de um Data Access Object (DAO) para gerenciar essa entity. Copie essa classe DAO para o seu projeto:

src/main/java/org/arquillian/example/dao/LanguageDao.java
package org.arquillian.example.dao;

import org.arquillian.example.domain.Language;
import javax.annotation.PostConstruct;
import javax.ejb.Singleton;
import javax.ejb.Startup;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import java.util.List;

@Singleton
@Startup
public class LanguageDao {
    @PersistenceContext
    EntityManager em;

    public List<Language> listLanguages() {
        return em.createQuery("select l from Language l").getResultList();
    }

    @PostConstruct
    public void insertTestData() {
        Language java = new Language();
        java.setName("Java");
        em.persist(java);

        Language ruby = new Language();
        ruby.setName("Ruby");
        em.persist(ruby);

        Language groovy = new Language();
        groovy.setName("Groovy");
        em.persist(groovy);
    }
}

Para compilar essa classe, você precisará adicionar as APIs do EJB no projeto.

$ ejb setup
***SUCCESS*** Installed [forge.spec.ejb] successfully.
***SUCCESS*** Enterprise Java Beans (EJB) is installed.
Wrote /home/ike/projects/arquillian-demo/pom.xml

Agora está na hora de criar nossa classe de teste. Essa parte é muito parecida com a primeira metade desse tutorial, exceto que dessa vez instruiremos o comando create-test para preparar um teste para JPA.

$ arquillian create-test --class org.arquillian.example.dao.LanguageDao.java --enableJPA
Picked up type <JavaResource>: org.arquillian.example.dao.LanguageDaoTest
Wrote /home/ike/projects/arquillian-demo/src/test/java/org/arquillian/example/dao/LanguageDaoTest.java

Isso cria novamente um novo teste, mas também adiciona o seu persistence.xml na publicação. A seguir temos o teste gerado:

src/test/java/org/arquillian/example/dao/LanguageDaoTest.java
package org.arquillian.example.dao;

import org.arquillian.example.dao.LanguageDao;
import javax.inject.Inject;
import org.jboss.arquillian.container.test.api.Deployment;
import org.jboss.arquillian.junit.Arquillian;
import org.jboss.shrinkwrap.api.ShrinkWrap;
import org.jboss.shrinkwrap.api.spec.JavaArchive;
import org.jboss.shrinkwrap.api.asset.EmptyAsset;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import static org.junit.Assert.*;
import static org.hamcrest.core.Is.*;

@RunWith(Arquillian.class)
public class LanguageDaoTest {
    @Inject private LanguageDao languagedao;

    @Deployment public static JavaArchive createDeployment() {
        return ShrinkWrap.create(JavaArchive.class, "test.jar")
            .addClass(LanguageDao.class)
            .addAsManifestResource("META-INF/persistence.xml", "persistence.xml")
            .addAsManifestResource(EmptyAsset.INSTANCE, "beans.xml");
    }

    @Test
    public void testIsDeployed() {
        Assert.assertNotNull(languagedao);
    }
}

Abra o teste na sua IDE e adicione a entidade Language na publicação. Adicione o import adequado, então modifique essa linha:

.addClass(LanguageDao.class)

… para essa:

.addClasses(Language.class, LanguageDao.class)

Agora escreva um novo método de teste para validar o comportamento da listLanguages().

src/test/java/org/arquillian/example/dao/LanguageDaoTest.java
@Test
public void testListLanguages() {
    Assert.assertEquals(3, languagedao.listLanguages().size());
}

Agora execute os testes.

$ build test --profile JBOSS_AS_MANAGED_7.X

Parabéns! Outra (greenbar) barra verde com o Arquillian!

Adicionando mais adaptadores de containers

Adicionar mais adaptadores de containers é tão simples como executar o comando de configuração anterior. Por exemplo, vamos adicionar o adaptador remoto do GlassFish.

$ arquillian setup --container GLASSFISH_REMOTE_3_1_(REST)

Simplesmente troque os containers através da troca do profile do Maven. Por exemplo no Forge:

$ build test --profile GLASSFISH_REMOTE_3_1_(REST)

Algumas configurações adicionais são necessárias para fazer os testes funcionarem em uma instância standalone do GlassFish. Chame isso de lição de casa ~:)

Exportando a publicação

Por motivos de depuração, pode ser útil exportar a sua publicação para um arquivo. Você pode fazer isso usando o Forge.

Primeiro navegue até o teste Arquillian:

$ cd src/test/java/org/arquillian/example/MySimpleBeanTest.java

Então exporte a publicação:

$ arquillian export

Você poderá encontrar o arquivo exportado no diretório target do projeto.

$ cd ~~
$ ls target/*.jar
arquillian-demo.jar

Se você inspecionar o arquivo .jar usando um programa de arquivo, você encontrará que ele coincide com o ShrinkWrap que você definiu no método @Deployment do teste.

Share the Knowledge

Find this guide useful?

There’s a lot more about Arquillian to cover. If you’re ready to learn more, check out the other available guides.

Feedback

Find a bug in the guide? Something missing? You can fix it by forking this website, making the correction and sending a pull request. If you’re just plain stuck, feel free to ask a question in the user discussion forum.

Recent Changelog

  • Sep 14, 2013: Translating guide "get started faster with forge" to portuguese brazil by Rafael Sakurai
  • Sep 13, 2013: Translating "get started faster with forge" to portuguese brazil by Rafael Sakurai

See full history »