O documento descreve como integrar o framework de teste Cucumber com o Mule ESB para realizar testes de integração e comportamentais. Ele explica como ler arquivos de uma pasta de origem usando o Mule ESB e como implementar passos de teste Cucumber para validar o fluxo Mule.

1. Mule ESB com Framework Cucumber – Part 1
O que é Mule ESB?
Mule ESB é um peso leve baseado em Java Enterprise Service Bus (ESB) e
plataforma de integração que permite aos desenvolvedores para conectar
aplicações de forma rápida e facilmente, permitindo-lhes trocar dados.
Mule ESB permite fácil integração de sistemas existentes,
independentemente das diferentes tecnologias que os aplicativos usam,
incluindo JMS, Web Services, JDBC, HTTP, e muito mais.
Este exemplo mostra como podemos integrar estrutura de testes de
Cucumber com Mule ESB para a integração ou a aceitação ou
comportamentais Driven Development (BDD). Nós simplesmente colocar
um arquivo em uma pasta de origem e Mule irá ler o arquivo no diretório
de origem. Usando Mule ESB é muito fácil de ler o arquivo de um local. Se
tivéssemos que ler o arquivo usando codificação manual, em seguida,
tivemos que escrever muitas linhas de código. Mas usando ESB Mule nós
simplesmente colocar um arquivo em um diretório e deixar a mula sabe o
caminho do arquivo e da mula faz o resto da coisa. Você pode colocar
qualquer tipo de arquivo para a fonte para a leitura. O arquivo que
colocamos em um diretório de origem será um anexo para o endereço de
correio do destinatário. Então, finalmente, quando vamos ver o arquivo
como um anexo na caixa de correio.
O que é Cucumber Framework?
Por favor, dê uma olhada no https://cukes.info/
Pré-requisitos
AnyPoint Studio (Mule Studio) 3.5.1
JDK 1.6

2. Maven 3
Runtime Mule 3.5.1 EE
Conhecimento de XML, Java, Cucumber
Passo 1. Abra Mule Studio e criar um projeto de mula. Vá para Arquivo->
Novo-> Mule Project. Agora digite o nome do projeto, selecione Runtime -
Mule Server, marque a caixa de seleção para uso Maven. Agora insira as
seguintes informações
Grupo Id: sua empresa (. Ex roytuts.com) nome - com.roytuts
Artefato Id: nome do projeto - mulecucumber (preenchido
automaticamente quando o nome do projeto está sendo digitado)
Versão: estúdio Mule gera padrão
Passo 2. Clique em Avançar e verifique projeto Localização e JRE / JDK
estão configuradas corretamente. Clique em Concluir.
Passo 3. Agora arrastar e soltar os elementos do lado direito do estúdio
Mule como mostrado abaixo na imagem.

3. Cucumber Framework com Mule ESB
propriedades do conector de arquivo
propriedades do conector de arquivo Procurar e selecione o caminho de
onde um arquivo será lido por um anexo. Logger componente propriedades
do componente Logger irá exibir conteúdo no console a partir de cada
fluxo. Arquivo para cordas propriedades transformador arquivar-se forte
transformador apenas transforma o objeto de arquivo para o formato de
cadeia legível. Nós não vai definir qualquer propriedade para este
elemento. Propriedades transformador anexo usando transformador anexo
podemos definir payload de fluxo anterior como um anexo. Temos para
selecionar tipo de conteúdo, operação que Set Anexo, nome, valor.
propriedades do conector SMTP para o conector SMTP temos de host de
entrada de e-mail, nome de usuário, senha, porta em Configurações básicas
e abordar, a partir de endereços, Sujeito em e-mail Informação. O arquivo
XML inteiro de todo o fluxo de
Procurar e selecione o caminho de onde um arquivo será lido por um
anexo.
Arquivo para propriedades de transformadores de corda
Arquivo-se forte transformador apenas transforma o objeto de arquivo para
o formato de cadeia legível. Nós não vai definir qualquer propriedade para
este elemento.
propriedades do componente Logger
componente Logger irá exibir conteúdo no console a partir de cada fluxo.
O arquivo XML inteiro de todo o fluxo

4. <?xml version="1.0" encoding="UTF-8"?>
<mule xmlns:file="http://www.mulesoft.org/schema/mule/file"
xmlns:tracking="http://www.mulesoft.org/schema/mule/ee/tracking"
xmlns="http://www.mulesoft.org/schema/mule/core"
xmlns:doc="http://www.mulesoft.org/schema/mule/documentation"
xmlns:spring="http://www.springframework.org/schema/beans"
version="EE-3.5.1"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/bean
s http://www.springframework.org/schema/beans/spring-beans-current.xsd
http://www.mulesoft.org/schema/mule/core
http://www.mulesoft.org/schema/mule/core/current/mule.xsd
http://www.mulesoft.org/schema/mule/file
http://www.mulesoft.org/schema/mule/file/current/mule-file.xsd
http://www.mulesoft.org/schema/mule/ee/tracking
http://www.mulesoft.org/schema/mule/ee/tracking/current/mule-tracking-
ee.xsd">
<flow name="mulecucumberFlow"
doc:name="mulecucumberFlow">
<file:inbound-endpoint
path="D:AnypointStudioWorkspacesourcefile"
responseTimeout="10000" doc:name="File" />
<file:file-to-string-transformer
doc:name="File to String" />
<logger level="INFO" doc:name="Logger"
message="#[payload]" />
</flow>
</mule>

5. Passo 4. Uma vez que colocar qualquer arquivo com o caminho
selecionado a partir de onde mula irá ler o arquivo, podemos executar o
arquivo mulecucumber.xml e vamos ver a saída do arquivo no console, mas
não é nosso alvo principal. Queremos testar o fluxo usando a estrutura
Cucumber. Então agora vamos criar todas as coisas necessárias para o
Framework de Cucumber.
Vamos colocar o arquivo mulecucumber.xml em src teste / recursos /
diretório / mula. Se src / test / recursos não existe, então, criar-lo de Novo->
pasta de origem.
Passo 5. Vamos criar arquivo de mula-config.xml com baixo conteúdo e
colocá-lo em src / test / diretório app.
<?xml version="1.0" encoding="UTF-8"?>
<mule xmlns="http://www.mulesoft.org/schema/mule/core"
xmlns:doc="http://www.mulesoft.org/schema/mule/documentation"
xmlns:spring="http://www.springframework.org/schema/beans"
version="EE-3.5.1"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/bean
s http://www.springframework.org/schema/beans/spring-beans-current.xsd
http://www.mulesoft.org/schema/mule/core
http://www.mulesoft.org/schema/mule/core/current/mule.xsd">
<spring:beans>
<spring:import resource="classpath:mule/mulecucumber.xml"
/>
</spring:beans>
</mule>

6. Passo 6. Agora vamos criar um arquivo de recurso chamado
CucumberFeature.feature com o conteúdo abaixo dentro dele e colocá-lo
em / / recursos / recurso de teste src.
Feature: File connector reads a file from a particular location and log the
file content in the console
Scenario Outline: Send file content to logger component
Given The scenario with "<SCENARIO_ID>" and scenario
description "<SCENARIO_DESC>"
When The Source system "<SOURCE_SYS>" sends
"<INBOUND_FILE>" to Destination system "<DESTINATION_SYS>"
Then one acknowledge message will come from
"<DESTINATION_SYS>" to "<SOURCE_SYS>"
Examples:
| SCENARIO_ID | SCENARIO_DESC
| SOURCE_SYS | INBOUND_FILE |
DESTINATION_SYS |
| File_Data_to_Logger1 | Send file data to logger component |
File_source | files/data.csv | Logger |
#| File_Data_to_Logger2 | Send file data to logger component |
File source directory | files/data.csv | Logger |
Passo 7. Vamos criar classe de utilitário MuleEmbeddedServer.java e
colocá-lo sob src diretório / test / java no com.roytuts.cucumber.common
pacote com baixo conteúdo.
package com.roytuts.cucumber.common;

7. import java.io.File;
import java.io.IOException;
import org.mule.api.MuleContext;
import org.mule.api.MuleException;
import org.mule.config.spring.SpringXmlConfigurationBuilder;
import org.mule.context.DefaultMuleContextFactory;
public class MuleEmbeddedServer {
private static MuleContext muleContext;
public static void initialize() throws IOException, MuleException {
final String curPath = new File(".").getCanonicalPath();
muleContext = new DefaultMuleContextFactory()
.createMuleContext(new
SpringXmlConfigurationBuilder(curPath
+ "/src/test/app/mule-config.xml"));
muleContext.start();
}
public static void close() throws MuleException {
muleContext.stop();
}
public static MuleContext getMuleContext() {
return muleContext;
}

8. }
Passo 8. Agora vamos criar classe de teste que irá testar o fluxo de mula
usando a estrutura Cucumber.
package com.roytuts.cucumber.cuke;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.runner.RunWith;
import org.mule.api.MuleException;
import com.roytuts.cucumber.common.MuleEmbeddedServer;
import cucumber.api.junit.Cucumber;
@RunWith(Cucumber.class)
@Cucumber.Options(features = {
"classpath:features/CucumberFeature.feature" }, glue =
"com.roytuts.cucumber.cuke.steps", strict = true, format = {
"pretty", "html:target/cucumber", "json:target/Cucumber.json"
})
public class CucumberTest {
@BeforeClass()
public static void initTestEnvironment() {
System.out.println("Initialize Test Environment");
try {

9. MuleEmbeddedServer.initialize();
} catch (Exception e) {
System.out.println("Mule Embedded Server cannot be
iniatilaized.");
e.printStackTrace();
}
System.out.println("Test Environment initialized.");
}
@AfterClass()
public static void destroyTestEnvironment() throws MuleException {
System.out.println("Destroy Test Environment.");
MuleEmbeddedServer.close();
System.out.println("Test Environment destroyed.");
}
}
Nos recursos de classe acima = { "classpath: características /
CucumberFeature.feature"} significa que temos de colocar o arquivo de
recurso em / / recursos / recurso de teste src.
cola = "com.roytuts.cucumber.cuke.steps" significa que teremos um
arquivo de classe passo em src diretório / test / java nos
com.roytuts.cucumber.cuke.steps pacote.
Passo 9. Agora vamos criar em branco arquivo CucumberSteps.java em src
diretório / test / java nos com.roytuts.cucumber.cuke.steps pacote.
Passo 10. Agora vamos executar o CucumberTest.java arquivo de classe e
vamos obter as assinaturas passos no console. Então, vamos copiar esses

10. passos não implementadas no CucumberSteps.java classe e implementá-los
um por um, como mostrado abaixo.
package com.roytuts.cucumber.cuke.steps;
import java.util.logging.Logger;
import org.mule.MessageExchangePattern;
import org.mule.api.MuleEvent;
import org.mule.api.processor.MessageProcessor;
import org.mule.tck.MuleTestUtils;
import org.mule.util.IOUtils;
import com.roytuts.cucumber.common.MuleEmbeddedServer;
import cucumber.api.java.en.Given;
import cucumber.api.java.en.Then;
import cucumber.api.java.en.When;
public class CucumberSteps {
private static final Logger LOGGER =
Logger.getLogger("CucumberSteps");
@Given("^The scenario with "([^"]*)" and scenario description
"([^"]*)"$")
public void The_scenario_with_and_scenario_description(String
arg1,
String arg2) throws Throwable {

11. LOGGER.info("Scenario ID : " + arg1);
LOGGER.info("Scenario Description : " + arg2);
}
@When("^The Source system "([^"]*)" sends "([^"]*)" to
Destination system "([^"]*)"$")
public void
The_Source_system_sends_to_Destination_system(String arg1,
String arg2, String arg3) throws Throwable {
LOGGER.info("Source System : " + arg1);
LOGGER.info("File Name : " + arg2);
LOGGER.info("Destination System : " + arg3);
String flowName = "mulecucumberFlow";
Object payload = IOUtils.getResourceAsString(arg2,
this.getClass());
MuleEvent event = MuleTestUtils.getTestEvent(payload,
MessageExchangePattern.REQUEST_RESPONSE,
MuleEmbeddedServer.getMuleContext());
MessageProcessor messageProcessor =
MuleEmbeddedServer.getMuleContext()
.getRegistry().lookupObject(flowName);
event = messageProcessor.process(event);
LOGGER.info("Mule Event Response : " +
event.getMessageAsString());
}
@Then("^one acknowledge message will come from "([^"]*)" to
"([^"]*)"$")

12. public void one_acknowledge_message_will_come_from_to(String
arg1,
String arg2) throws Throwable {
LOGGER.info("Destination System : " + arg1);
LOGGER.info("Source System : " + arg2);
}
}