Accéder au contenu principal Passer au contenu complémentaire

Test unitaire de Routes

Les tests unitaires sont une partie essentielle de tout processus de développement de logiciel professionnel. Cette section explique comment des Routes peuvent être testées unitairement via le framework de test Apache Camel.

Création d'une Route

Pour reproduire un exemple de test unitaire, créez d'abord une Route. La Route lit un fichier d'un répertoire spécifique et filtre les messages du fichier.

Procedure

  1. Placez les composants suivants de la Palette dans l'espace de modélisation graphique :
    • un cFile,
    • un cConvertBodyTo,
    • un cMessageFilter,
    • et un cMessagingEndpoint.
    Capture d'écran du Job dans l'espace de modélisation graphique.
  2. Renommez les composants afin de mieux identifier leur rôle au sein de la Route. Reliez le cMessageFilter au cMessagingEndpoint à l'aide d'un lien Row > filter. Reliez les autres composants à l'aide de liens Row > Route.
  3. Double-cliquez sur le composant cFile pour ouvrir sa vue Basic settings dans l'onglet Component et configurez-le comme ci-dessous afin qu'il lise des fichiers d'un système de fichiers local.
    Vue Basic settings (Paramètres simples).
  4. Double-cliquez sur le cConvertBodyTo pour ouvrir sa vue Basic settings dans l'onglet Component et configurez-le pour qu'il convertisse le corps du message de chaque fichier en type String.
    Vue Basic settings (Paramètres simples).
  5. Double-cliquez sur le cMessageFilter pour ouvrir sa vue Basic settings dans l'onglet Component et configurer le composant pour qu'il filtre le corps du message, selon l'expression :
    ${body} contains 'bar'
    Vue Basic settings (Paramètres simples).
  6. Double-cliquez sur le cMessagingEndpoint pour ouvrir sa vue Basic settings dans l'onglet Component et configurez-le comme ci-dessous afin qu'il enregistre la sortie de la Route.
    Vue Basic settings (Paramètres simples).
  7. Dans la vue Run, cliquez sur le bouton Run pour lancer l'exécution de votre Route. Les données correspondant aux critères de filtre sont affichées dans la console.
    Capture d'écran des résultats dans la console après l'exécution réussie du Job.

Results

Pour plus d'informations concernant la création d'une Route, consultez Créer une Route.

Publier la Route dans le référentiel d'artefacts

Procedure

  1. Cliquez-droit sur la Route dans la vue Repository et sélectionnez Publish dans le menu contextuel
    L'assistant Publish into Artifact Repository s'ouvre.
  2. Laissez les paramètres par défaut et cliquez sur Finish pour publier la Route dans le référentiel d'artefacts.
    AssistantPublish into Artifact Repository (Publier dans le référentiel d'artefacts).

Results

Votre élément est disponible en tant qu'artefact dans le référentiel.

Pour plus d'informations concernant la publication de Routes, consultez Publier dans un référentiel d'artefacts.

Créer un projet Maven pour les tests unitaires

Les tests unitaires sont situés dans un projet séparé.

Vous devez passer en perspective Java et créer un projet simple basé Maven.

Procedure

  1. Cliquez-droit sur la zone blanche de la vue Package Explorer et sélectionnez New (Nouveau) > Project (Projet)... dans le menu contextuel.
  2. L'assistant [New Project] s'ouvre. Sélectionnez Maven Project sous le nœud Maven puis cliquez sur Next.
    Assistant New Project (Nouveau projet).
  3. Dans la vue Select project name and location, la case Use default Workspace location est cochée. Cliquez sur Next.
    Assistant New Maven Project (Nouveau projet Maven).
  4. Dans la vue Select an Archetype, org.apache.maven.archetypes (colonne Group Id) et maven-archetype-quickstart (colonne Artifact Id) sont sélectionnées. Laissez les autres paramètres par défaut et cliquez sur Next.
    Assistant New Maven Project (Nouveau projet Maven).
  5. Dans la vue Specify Archetype parameters, saisissez org.talend dans le champ Group Id et route-unit-test dans le champ Artifact Id. Cliquez sur Finish. Le projet apparaît dans la vue Package Explorer.
    Assistant New Maven Project (Nouveau projet Maven).
  6. Double-cliquez sur le fichier pom.xml sous le nouveau nœud de projet afin de l'ouvrir dans l'espace de modélisation graphique. Modifiez-le comme ci-dessous.
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
        <groupId>org.talend</groupId>
        <artifactId>route-unit-test</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <dependencies>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.8.1</version>
                <scope>test</scope>
            </dependency>
            <dependency>
                <groupId>org.apache.camel</groupId>
                <artifactId>camel-test</artifactId>
                <version>2.9.1</version>
            </dependency>
            <dependency>
                <groupId>org.slf4j</groupId>
                <artifactId>slf4j-jdk14</artifactId>
                <version>1.6.1</version>
            </dependency>
            <dependency>
                <groupId>org.talend.camel</groupId>
                <artifactId>systemRoutines</artifactId>
                <version>1.0.0</version>
            </dependency>
            <dependency>
                <groupId>org.talend.camel</groupId>
                <artifactId>userRoutines</artifactId>
                <version>1.0.0</version>
            </dependency>
            <dependency>
                <groupId>org.example</groupId>
                <artifactId>SimpleRoute</artifactId>
                <version>0.2.0-SNAPSHOT</version>
                <type>jar</type>
            </dependency>
        </dependencies>
        <repositories>
            <repository>
                <id>repo-snapshot</id>
                <name>Snapshots bundles</name>
                <url>http://tadmin:tadmin@localhost:8082/archiva/repository/repo-snapshot/</url>
                <snapshots>
                    <enabled>true</enabled>
                </snapshots>
            </repository>
        </repositories>
    </project>

    Comme montré ci-dessus, les dépendances de Maven sont JUnit et le framework de tests unitaires Camel, Les fichiers JAR utilitaires requis pour les Routes Talend ESB et les fichiers JAR des Routes publiées depuis le Studio Talend.

    Dans cet exemple, vous allez utiliser directement la Route dans Référentiel d'artefacts Talend (Talend Artifact Repository), afin de l'ajouter dans le fichier pom.xml en tant que référentiel. Le nom d'utilisateur ou d'utilisatrice et le mot de passe sont compris dans l'URL pour plus de simplicité. Vous pouvez également le spécifier dans le fichier ${Maven_HOME}/conf/settings.xml.

  7. Sauvegardez votre fichier pom.xml.

Publier des fichiers JAR utilitaires dans votre référentiel Maven local

Démarrez une invite de commande pour déployer les fichiers JAR dans votre référentiel Maven local.

Procedure

  1. Exécutez la commande suivante afin de déployer les routines système : mvn install:install-file -DgroupId=org.talend.camel -DartifactId=systemRoutines -Dversion=1.0.0 -Dfile=./src/ext/systemRoutines.jar -Dpackaging=jar -DgeneratePom=true
  2. Exécutez les commandes suivantes pour déployer les routines utilisateur·trice : mvn install:install-file -DgroupId=org.talend.camel -DartifactId=userRoutines -Dversion=1.0.0 -Dfile=./src/ext/userRoutines.jar -Dpackaging=jar -DgeneratePom=true

Results

Vous avez toutes les dépendances nécessaires aux tests unitaires.

Écrire et exécuter un test JUnit

Procedure

  1. Cliquez-droit sur le projet Maven route-unit-test dans le Package Explorer et sélectionnez New (Nouveau) > JUnit Test Case (Scénario de test JUnit) dans le menu contextuel.
    Assistant New JUnit Test Case (Nouveau scénario de test JUnit).
    Le nouvel assistant [New JUnit Test Case] s'ouvre.
  2. Sélectionnez l'option New JUnit 3 test et saisissez RouteTestSample comme nom de classe de test. Cliquez sur Finish.
  3. La classe de test s'ouvre dans l'espace de modélisation graphique. Saisissez le test comme suit.
    package org.talend.test;
    
    import java.util.Map;
    
    import org.apache.camel.CamelContext;
    import org.apache.camel.EndpointInject;
    import org.apache.camel.Produce;
    import org.apache.camel.ProducerTemplate;
    import org.apache.camel.builder.RouteBuilder;
    import org.apache.camel.component.mock.MockEndpoint;
    import org.apache.camel.test.junit4.CamelTestSupport;
    import org.junit.Test;
    
    import esbdemos.simpleroute_0_1.SimpleRoute;
    
    public class RouteTestSample extends CamelTestSupport {
    	@EndpointInject(uri = "mock:result")
    	protected MockEndpoint resultEndpoint;
    	@Produce(uri = "direct:start")
    	protected ProducerTemplate template;
    	private RouteBuilder builder;
    
    	@Test
    	public void testSendMatchingMessage() throws Exception {
    		String expectedBody = "bar";
    		resultEndpoint.expectedBodiesReceived(expectedBody);
    		template.sendBody(expectedBody);
    		resultEndpoint.assertIsSatisfied();
    	}
    
    	@Test
    	public void testSendNotMatchingMessage() throws Exception {
    		resultEndpoint.expectedMessageCount(0);
    		template.sendBody("foo");
    		resultEndpoint.assertIsSatisfied();
    	}
    
    	@Override
    	protected CamelContext createCamelContext() throws Exception {
    		SimpleRoute route = new SimpleRoute();
    		// Setup the test aliases
    		Map<String, String> uriProperties = route.getUriMap();
    		uriProperties.put("start", "direct:start");
    		uriProperties.put("end", "mock:result");
    		route.loadCustomUriMap(uriProperties);
    		// Build the route
    		builder = route.Route(false);
    		return builder.getContext();
    	}
    
    	@Override
    	protected RouteBuilder createRouteBuilder() {
    		return builder;
    	}
    }

    Comme affiché ci-dessus, vous utilisez le framework Camel Test pour tester la Route, ce qui nécessite l'utilisation d'endpoints mock spéciaux pour extraire les résultats durant le test unitaire. La Route créée n'utilise pas des endpoints mock. Elle utilise les composants habituels file et log. La solution est de remplacer les composants file et log par les composants direct:start et mock:result. De la ligne 49 à la ligne 52, vous pouvez voir Map<String,String>, qui permet de mapper le nom du composant et son URI et change les valeurs en start et end. Cela permet de simuler les composants et de tester la Route isolée.

  4. Cliquez sur le bouton Run Job (Exécuter le Job) dans la barre d'outils afin d'exécuter le test.
    Onglet JUnit.

    Le test est réussi.

Cette page vous a-t-elle aidé ?

Si vous rencontrez des problèmes sur cette page ou dans son contenu – une faute de frappe, une étape manquante ou une erreur technique – faites-le-nous savoir.