Objetivos:
Criar e acessar um datapool a partir de um aplicativo de teste de exemplo utilizando o TPTP (Eclipse
Test and Performance Tools Platform).
Tempo Necessário
1 hora
Antes de iniciar este tutorial,
é necessário
-
Instalar o Eclipse e o Eclipse TPTP (Test and Performance Tools
Platform).
- Possuir um entendimento básico do teste JUnit. Para obter informações adicionais sobre o teste JUnit, consulte www.junit.org.
- Configure e execute o Agent Controller que corresponde à versão do TPTP. Para obter informações adicionais, consulte
Introdução ao Agent Controller.
Descrição
Neste tutorial,
você cria e testa um aplicativo chamado MyShoppingCart. O TPTP (Eclipse Test and Performance Tools Platform) permite desenvolver testes JUnit e criar um datapool para fornecer dados ao ambiente de teste.
Este tutorial fornece orientação sobre os seguintes procedimentos:
- Criando um Aplicativo de Usuário de Amostra
- Configurando um Conjunto de Teste do
TPTP
- Criando um Datapool e Inicializando os Dados de
Teste
- Modificando Casos de Teste para Referenciar um
Datapool
Neste procedimento, você desenvolve a classe MyShoppingCart. Em procedimentos subseqüentes, você utilizará o Eclipse Test and Performance Tools Platform para desenvolver um ambiente de teste correspondente.
- Crie um novo Projeto Java do Eclipse.
- No menu Arquivo, escolha Arquivo > Novo > Projeto... O
diálogo Novo Projeto aparece.
- Na lista de Assistentes, selecione Projeto Java e clique em Avançar.
A página Criar um Projeto Java aparece.
- Digite datapoolExample para o nome do Projeto e clique em Concluir.
O projeto datapoolExample aparece na Visualização Navegador.
- Crie a classe MyShoppingCart.
- Na visualização Navegador, clique com o botão direito do mouse no projeto datapoolExample
e escolha Nova > Classe. O diálogo Nova Classe Java
aparece.
- Digite MyShoppingCart no campo Nome.
- Limpe a opção para criar o método principal public static void
main(String[] args).
- Clique em Concluir. O arquivo MyShoppingCart.java aparece no editor
Java.
- Digite o seguinte para a origem MyShoppingCart:
import java.util.*;
public class MyShoppingCart {
public Hashtable myFlowers;
public MyShoppingCart() {
myFlowers = new Hashtable();
myFlowers.put("Orchid", new Double(5.99));
myFlowers.put("Tulip", new Double(1.99));
myFlowers.put("White Poinsee", new Double(6.99));
myFlowers.put("White Rose", new Double(9.99));
myFlowers.put("Geraniums", new Double(4.99));
}
public double itemCost(String itemName, int itemQuantity)
{
Double price = (Double)myFlowers.get(itemName);
if (price != null) {
return price.doubleValue()*itemQuantity;
}
return -1;
}
}
- Salve MyShoppingCart.java. No menu Arquivo, escolha Arquivo >
Salvar.
Neste procedimento, você desenvolve um conjunto de teste para a classe MyShoppingCart. O Eclipse Test and Performance Tools Platform permite desenvolver um teste
JUnit para o método itemCost.
- Abra a Perspectiva de Teste.
- No menu Arquivo, escolha Janela > Abrir Perspectiva >
Outro.
- Selecione Teste e clique em OK. O Navegador de Teste aparece.
- Crie um novo Teste JUnit TPTP.
- No Navegador de Teste, clique com o botão direito do mouse no projeto datapoolExample e escolha Novo
> Elemento de Teste...
- No diálogo Elemento de Teste, selecione Teste JUnit TPTP e clique em Avançar. O diálogo Novo Caso de Teste aparece, solicitando a inclusão das bibliotecas JUnit. Clique em Sim para incluir as bibliotecas JUnit.
- Na página Novo Código Fonte do Teste JUnit, digite shoppingCartTest_src no campo Nome. Na seção Selecionar o Modo de Edição do Comportamento de Teste, escolha a opção de edição No
Editor de Teste (o padrão).
- Clique em Concluir. O editor do Teste JUnit TPTP aparece, mostrando o
conjunto de teste shoppingCartTest_src. A guia Visão Geral inclui uma descrição do teste, Informações de Origem e uma listagem dos Métodos de Teste. Atualmente, nenhum método de teste é definido. Para este tutorial, o editor do Teste JUnit TPTP gera stubs de método para que a opção Implementar
Comportamento de Teste como Código na seção Informações de Origem seja limpa. Para obter informações adicionais, consulte
Editor do Conjunto de Teste JUnit.
- Inclua os métodos testItemCost e testShoppingCartConstructor.
- Na guia Métodos de Teste, clique em Incluir. Aparece um nome padrão para o teste.
- Inclua o método testItemCost. No campo Nome, digite testItemCost para o novo nome do teste. No campo Descrição, digite Teste
para o Método MyShoppingCart.itemCost(String, int).
- Inclua o método testShoppingCartConstructor. Na guia Métodos de Teste, clique em Incluir. No campo Nome, digite testShoppingCartConstructor para o novo nome do teste. No campo Descrição, digite Teste
para o Construtor MyShoppingCart.
- Configure o comportamento de execução do teste.
- Inclua um loop de execução de teste. Na guia Comportamento, clique em Incluir...
> Loop. No campo Nome, digite Loop_MyShoppingCart. No
campo Número de Iterações, digite 1 (o valor padrão).
- Inclua uma chamada testShoppingCartConstructor. Selecione
Loop_MyShoppingCart e clique em Incluir... > chamada. O diálogo
Chamada de Teste aparece. Selecione testShoppingCartConstructor e
clique em OK.
- Inclua uma chamada testItemCost. Selecione
Loop_MyShoppingCart e clique em Incluir... > chamada. O diálogo
Chamada de Teste aparece. Selecione testItemCost e clique em OK.
- Salve o conjunto de teste. No menu Arquivo, escolha Arquivo > Salvar.
Nota: o comando Save faz com que o editor do Teste JUnit TPTP crie
stubs de método de teste em shoppingCartTest_src.java.
-
Digite código para os métodos de teste JUnit gerados, testShoppingCartConstructor e testItemCost.
- Abra a Perspectiva Java. No menu Arquivo, escolha Janela
> Abrir Perspectiva > Outro... > Java.
- Abra shoppingCartTest_src.java. No Navegador, abra a pasta de projetos datapoolExample e dê um clique duplo em shoppingCartTest_src.java. O conteúdo de shoppingCartTest_src.java aparece no editor Java, incluindo código para configuração e execução do conjunto de teste, além de métodos de stub para testShoppingCartConstructor e testItemCost.
- Digite o seguinte código para o método testShoppingCartConstructor.
public void testShoppingCartConstructor()
throws Exception
{
MyShoppingCart cart = new MyShoppingCart();
Double priceOrchid = (Double)cart.myFlowers.get("Orchid");
Double priceTulip = (Double)cart.myFlowers.get("Tulip");
assertTrue(priceOrchid.doubleValue() == 5.99);
assertTrue(priceTulip.doubleValue() == 1.99);
}
- Digite o seguinte código para o método testItemCost.
public void testItemCost()
throws Exception
{
MyShoppingCart cart = new MyShoppingCart();
double priceForTwo = cart.itemCost("Orchid", 2);
assertTrue(priceForTwo == 11.98);
}
- Salve shoppingCartTest_src.java. No menu Arquivo, escolha Arquivo
> Salvar.
- Abra a Perspectiva de Teste e crie uma implementação de teste. Para obter um exemplo, consulte Criando uma
Implementação de Teste.
-
Execute o teste utilizando a implementação personalizada.
- No Navegador de Teste, clique com o botão direito do mouse no conjunto de teste shoppingCartTest_src e escolha Executar
como > Executar.... O diálogo Executar Configuração aparece.
- Na área de janela Configurações, selecione Teste e, em seguida, clique em Novo.
- Na área de janela à esquerda da Configuração de Execução (Selecionar Teste a Ser Executado), expanda datapoolExample e escolha o conjunto de teste shoppingCartTest_src.
- Na área de janela à direita da Configuração de Execução, selecione a implementação criada na seção.
- Na guia Logs de Teste, limpe a opção Utilizar Padrões e
selecione a pasta de projetos datapoolExample do local.
- Clique em Executar para ativar o teste.
- Dê um clique duplo no registro de teste de shoppingCartTest_src, que aparece no Navegador de Teste. O registro de teste shoppingCartTest_src aparece. Selecione a guia Eventos para visualizar os detalhes do teste. Você deverá ver os seguintes eventos: início do conjunto de teste, início de Loop_MyShoppingCart, início do teste, veredito do teste, parada do teste, segundo início do teste, segundo veredito do teste, segunda parada do teste, parada do loop, veredito do conjunto de teste e parada do conjunto de teste.

Neste procedimento, você cria um datapool simples para armazenar dados de teste. Utilizando o editor de datapool, você define os elementos estruturais de um
datapool, incluindo variáveis (colunas), registros (linhas) e
classes de equivalência (grupos de registros relacionados).
- Crie um arquivo CSV (delimitado por vírgula) que inclua os dados de teste. Normalmente, é possível exportar dados em um aplicativo de planilha ou banco de dados para o formato CSV. Neste tutorial, no entanto, os dados são digitados em um editor de texto.
- Digite o seguinte em um editor de texto:
,ModelNumber::String,Description::String,Price::Double
flowers,F0001,Orchid,5.99
flowers,F0002,Tulip,1.99
flowers,F0003,White Poinsee,6.99
flowers,F0004,White Rose,9.99
flowers,F0005,Geraniums,4.99
- Salve o arquivo como flowerData.csv em um local externo temporário.
- No Eclipse, abra a perspectiva de Teste.
- No menu Arquivo, escolha Janela > Abrir Perspectiva >
Outro.
- Selecione Teste e clique em OK. O Navegador de Teste aparece.
- No Navegador de Teste, clique com o botão direito do mouse em um
projeto e selecione Novo > Elemento de Teste...
O diálogo Novo Elemento de Teste aparece.
- Na lista de opções Assistentes, expanda a pasta Recursos de Teste e selecione Datapool.
- Clique em Avançar. O diálogo Novo Datapool aparece.
- Escolha a pasta de projetos do datapool e
o nome do datapool. Na lista de projetos existentes, selecione o
projeto datapoolExample. No campo Nome,
digite shoppingCartDatapool. Clique em Avançar para
continuar e, em seguida, em Avançar novamente para abrir a página de importação do arquivo CSV (delimitado por vírgula).
- Importe o
arquivo CSV flowerData.csv.
- No campo Arquivo CSV, clique em Procurar
e navegue para flowerData.csv.
- Marque a opção A primeira linha
contém nomes e tipos sugeridos de variáveis. A primeira linha de flowerData.csv contém os títulos e os tipos de colunas.
- Marque a opção A primeira coluna contém
nomes da classe de equivalência. As classes de equivalência agrupam dados relacionados. A primeira coluna de flowerData.csv especifica uma única classe de equivalência chamada flowers.
- Clique em Concluir. Se você tiver especificado dimensões iniciais do datapool, que podem entrar em conflito com as dimensões do arquivo CSV, aparecerá um diálogo. Clique em Sim para utilizar as dimensões do arquivo CSV. Clique em Não para utilizar as dimensões iniciais especificadas (e, possivelmente, truncar os dados do arquivo CSV).
O editor de Datapool aparece, mostrando os dados contidos na classe de equivalência flowers.
Para obter informações detalhadas sobre a criação de um datapool, consulte Criando um Datapool.
Neste procedimento, você utiliza a API do datapool para substituir os valores de teste com hardcode atribuído por
referências a colunas do datapool.
Incluindo Bibliotecas Exigidas pela API do Datapool
A API do datapool requer várias bibliotecas TPTP e EMF (Eclipse Modeling Framework). Neste procedimento, você inclui as bibliotecas no caminho de construção Java.
- Abra a Perspectiva Java. No menu Arquivo, escolha Janela >
Abrir Perspectiva > Java.
- Abra as propriedades do projeto datapoolExample. Na janela Navegador ou Explorador de Pacotes, clique com o botão direito do mouse na pasta de projetos datapoolExample e escolha Propriedades. O diálogo Propriedades para datapoolExample aparece.
- Inclua tptp-models.jar no caminho de construção Java.
-
Na área de janela à esquerda, selecione Caminho de Construção Java.
- Na área de janela à direita, selecione a guia Bibliotecas e clique em Incluir
Variável.... O diálogo Nova Entrada de Caminho de Classe da Variável aparece.
- Selecione a variável ECLIPSE_HOME e clique em Estender.... O diálogo Extensão da Variável aparece. Abra a pasta plugins
> org.eclipse.tptp.platform.models_Version e selecione
tptp-models.jar, em que Version é o número da versão do TPTP.
- Clique em OK para incluir a biblioteca.
- Inclua org.eclipse.emf.common_Version.jar no caminho de construção Java, em que Version é a versão do EMF.
-
No diálogo Nova Entrada de Caminho de Classe da Variável, selecione a variável ECLIPSE_HOME e clique em Estender...
- Abra a pasta de plugins e selecione
org.eclipse.emf.common_Version.jar, em que Version é a versão do EMF.
- Clique em OK para incluir a biblioteca.
- Inclua org.eclipse.emf.ecore_Version.jar no caminho de construção Java, em que Version é a versão do EMF.
- No diálogo Nova Entrada de Caminho de Classe da Variável, selecione a
variável ECLIPSE_HOME e clique em Estender...
- Abra a pasta de plugins e selecione org.eclipse.emf.ecore_Version.jar, em que Version é a versão do EMF.
- Clique em OK para incluir a biblioteca.
- Inclua org.eclipse.core.runtime_Version.jar no caminho de construção Java, em que Version é a versão da plataforma Eclipse.
- No diálogo Nova Entrada de Caminho de Classe da Variável, selecione a
variável ECLIPSE_HOME e clique em Estender...
- Abra a pasta de plugins e selecione org.eclipse.core.runtime_Version.jar,
em que Version é a versão da plataforma Eclipse.
- Clique em OK para incluir a biblioteca.
- Clique em OK para fechar o diálogo Propriedades.
Utilizando a API do Datapool
Neste procedimento, você modifica a classe shoppingCartTest_src e o método testShoppingCartConstructor para utilizar o
shoppingCartDatapool.
- Se necessário, abra a Perspectiva Java. No menu Arquivo, escolha Janela >
Abrir Perspectiva > Java.
- Abra shoppingCartTest_src.java. No Navegador, abra a
pasta de projetos datapoolExample e dê um clique duplo em
shoppingCartTest_src.java. O conteúdo de shoppingCartTest_src.java
aparece no editor Java.
- Inclua as seguintes instruções de importação na classe shoppingCartTest_src.
import org.eclipse.hyades.models.common.datapool.impl.*;
import org.eclipse.hyades.execution.runtime.datapool.*;
- Declare uma instância de classe IDatapoolIterator. Essa instância de classe será inicializada em seu código de configuração e utilizada em métodos de teste.
public class shoppingCartTest_src extends HyadesTestCase {
IDatapoolIterator dpIterator;
//...
- Modifique o método setUp para inicializar seu datapool. Em um ambiente de teste JUnit TPTP, o método setUp fornece uma fixação comum. Você pode utilizar setUp para inicializar variáveis de teste comuns. Nota: especifique o caminho completo do espaço de trabalho no lugar de <workspace> no construtor java.io.File.
protected void setUp() throws Exception {
// Inicializar o depósito de informações do provedor do datapool
IDatapoolFactory dpFactory = new Common_DatapoolFactoryImpl();
// Carregar o datapool shoppingCartDatapool
IDatapool datapool = dpFactory.load(
new java.io.File("<workspace>\\datapoolExample\\shoppingCartDatapool.datapool"),
false);
// Criar um iterador para percorrer o datapool
dpIterator = dpFactory.open(datapool,"org.eclipse.hyades.datapool.iterator.DatapoolIteratorSequentialPrivate");
// Inicializar o datapool para percorrer a primeira classe de equivalência.
dpIterator.dpInitialize(datapool,0);
}
Notas:
- O segundo parâmetro no método de carregamento IDatapoolFactory indica se a instância de datapool é compartilhada. Se for, será verificado se há uma cópia existente do datapool na cache de datapool. Se não, o datapool será uma instância privada. A modificação de uma instância compartilhada do datapool pode afetar outros usuários e só é recomendada em ambientes restritos.
- Se quiser editar um datapool através de programação, importe org.eclipse.hyades.edit.datapool.
- O segundo parâmetro no método de abertura IDatapoolFactory representa o tipo de iterador. Para datapools compartilhados, utilize DatapoolIteratorSequentialPrivate.
- Modifique o método testShoppingCartConstructor para utilizar o
shoppingCartDatapool.
public void testShoppingCartConstructor()
throws Exception
{
MyShoppingCart cart = new MyShoppingCart();
// Percorrer por meio do datapool...
// Testar se o construtor inicializa cada registro de flor apropriadamente
while(!dpIterator.dpDone())
{
String Description = dpIterator.dpCurrent().getCell("Description").getStringValue();
double datapoolPrice = dpIterator.dpCurrent().getCell("Price").getDoubleValue();
// Testar se a flor é contabilizada no aplicativo
Double applicationPrice;
assertNotNull(applicationPrice = (Double)cart.myFlowers.get(Description));
// Testar se o preço do aplicativo equivale ao preço no datapool
assertTrue(applicationPrice.doubleValue() == datapoolPrice);
dpIterator.dpNext();
}
}
- Salve shoppingCartTest_src.java. No menu Arquivo, escolha Arquivo
> Salvar.
- Inclua o datapool no testArtifact.
- Abra a Perspectiva de Teste. No Navegador de Teste, dê um clique duplo em testDeployment para abri-lo no editor.
- Na guia Pares, selecione testAsset e clique em Abrir...
- Na guia Recursos de Teste, clique em Incluir.... Selecione o datapool e clique em OK. Salve o recurso.
- Execute o teste utilizando a implementação personalizada.
- Abra a Perspectiva de Teste. No Navegador de Teste, clique com o botão direito do mouse no conjunto de teste shoppingCartTest_src e escolha Executar
como > Executar.... O diálogo Executar Configuração aparece.
- Na área de janela à esquerda da Configuração de Execução, escolha o conjunto de teste shoppingCartTest_src.
- Na área de janela à direita da Configuração de Execução, selecione a implementação criada na seção Antes de Começar.
- Na guia Logs de Teste, limpe a opção Utilizar Padrões e
selecione a pasta de projetos datapoolExample do local.
- Clique em Executar para ativar o teste.
- Dê um clique duplo no registro de teste de shoppingCartTest_src, que aparece no Navegador de Teste. O registro de teste shoppingCartTest_src aparece. Selecione a guia Eventos para visualizar os detalhes do resultado do teste.