Créer un composant Apache Camel de connexion à l’APNS – 3 sur 3

Nous avons vu dans un premier article comment initier le développement d’un composant Apache Camel, puis dans un second comment implémenter ses différentes classes.

A ce stade de notre développement nous sommes déjà en mesure d’utiliser pleinement notre composant, mais nous ne pouvons pas encore en assurer sa qualité. Pour cela, il est nécessaire d’ajouter à notre composant différentes classes de test. Bien que la testabilité de frameworks d’intégration puisse parfois paraître difficile, le projet Apache Camel fournit tous les outils nécessaires permettant de répondre à ce besoin. Nous verrons donc dans cet article comment tester le composant que nous avons développé.

Pour finir, nous verrons comment intégrer notre développement à un projet Camel, ainsi que les limites de notre composant et les solutions pour résoudre ces limitations.

Tester la classe ApnsConsumer

Bien que le projet Apache Camel permette de travailler naturellement avec Spring, nous nous attarderons dans un premier temps sur les méthodes permettant de tester notre composant sur un mode standalone. Pour cela, nous étendrons la classe CamelTestSupport. Cette dernière fournit les méthodes nécessaires pour effectuer différentes assertions sur les valeurs attendues en fin de traitement, en particulier sur des endpoints de type MockEndpoint.

Nous devons tout d’abord implémenter les 2 méthodes suivantes:

Méthode	Description
createCamelContext()	Permet de créer le contexte Camel qui sera utilisé par le test
createRouteBuilder()	Permet de construire la route qui sera appelée par le test. Idéalement, la route doit se terminer par l'appel d'un MockEpoint

Avant l’exécution de nos tests, un serveur APNS bouchonné doit être lancé. Il enverra sur le flux feedback des données factices.

L’objectif de ce test est de valider que le endpoint apns:consumer est capable de consommer les informations de test renvoyées par le flux feedback du serveur bouchonné. Le endpoint Camel mock:result nous permet de valider les assertions nécessaires sur les messages reçus par ce endpoint.

Le endpoint apns:consumer est configuré pour poller le flux feedback de l’APNS toutes les 500ms. Le test ne doit donc pas durer raisonnablement plus de 5 secondes en tenant compte du temps d’attente d’une seconde avant les assertions et du temps de démarrage du serveur bouchon APNS. Un timeout de 5 secondes est donc placé sur le test pour s’assurer que ce dernier tombe en erreur si un événement bloquant inattendu empêche le test de se terminer.

public class ApnsConsumerTest extends CamelTestSupport {

    ApnsServerStub server;

    public ApnsConsumerTest() {
        super();
    }

    /**
     * Démarrage du serveur bouchonné simulant l’APNS
     */
    @Before
    public void startup() throws InterruptedException {
        server = ApnsServerStub.prepareAndStartServer(FixedCertificates.TEST_GATEWAY_PORT, FixedCertificates.TEST_FEEDBACK_PORT);
    }

    /**
     * Arrêt du serveur bouchonné simulant l’APNS
     */
    @After
    public void stop() {
        server.stop();
    }

    /**
     * Test de l’ApnsConsumer. L’objectif est de vérifier que le flux feedback est
     * bien consommé par la route Camel. Pour cela on vérifie après consommation
     * que le endpoint MockEndpoint a bien reçu les messages.
     */
    @Test(timeout = 5000)
    public void testConsumer() throws Exception {

        byte[] deviceTokenBytes = ApnsUtils.createRandomDeviceTokenBytes();
        String deviceToken = ApnsUtils.encodeHexToken(deviceTokenBytes);

        MockEndpoint mock = getMockEndpoint(“mock: result”);
        mock.expectedMessageCount(1);
        mock.message(0).body().isInstanceOf(InactiveDevice.class);

        byte[] feedBackBytes = ApnsUtils.generateFeedbackBytes(deviceTokenBytes);
        server.toSend.write(feedBackBytes);

        Thread.sleep(1000);

        assertMockEndpointsSatisfied();

        InactiveDevice inactiveDevice = (InactiveDevice) mock.getExchanges().get(0).getIn().getBody();
        assertNotNull(inactiveDevice);
        assertNotNull(inactiveDevice.getDate());
        assertNotNull(inactiveDevice.getDeviceToken());
        assertEquals(deviceToken, inactiveDevice.getDeviceToken());
    }

    /**
     * Création et configuration du contexte Camel avec une configuration de test.
     * Enregistrement du composant APNS, et configuration de l’ApnsService
     */
    protected CamelContext createCamelContext() throws Exception {
        CamelContext camelContext = super.createCamelContext();

        ApnsServiceFactory apnsServiceFactory = ApnsUtils.createDefaultTestConfiguration();
        ApnsService apnsService = apnsServiceFactory.getApnsService();

        ApnsComponent apnsComponent = new ApnsComponent(apnsService);

        camelContext.addComponent(“apns”, apnsComponent);

        return camelContext;
    }

    /**
     * Création de la route Camel permettant de simuler la consommation du flux
     * feedback de l’APNS
     */
    protected RouteBuilder createRouteBuilder() throws Exception {
        return new RouteBuilder() {
            public void configure() throws Exception {
                from(“apns: consumer ? initialDelay = 500 & amp; amp; amp; delay = 500 & amp; amp; amp; timeUnit = MILLISECONDS”)
                    .to(“log: com.apache.camel.component.apns ? showAll = true & amp; amp; amp; multiline = true”)
                    .to(“mock: result”);
            }
        };
    }

}   

Tester la classe ApnsProducer

De la même façon que nous nous y sommes pris pour la classe de test ApnsConsumerTest, nous allons étendre la classe CamelTestSupport pour tester notre classe ApnsProducer. L’objectif est de vérifier que le serveur bouchonné reçoit bien les messages produits.

public class ApnsProducerTest extends CamelTestSupport {

        private ApnsServerStub server;
        private String FAKE_TOKEN = “19308314834701 ACD8313AEBD92AEFDE192120371FE13982392831701318B943”;

        public ApnsProducerTest() {
            super();
        }

        /**
         * Démarrage du serveur bouchonné simulant l’APNS
         */
        @Before
        public void startup() {
            server = ApnsServerStub.prepareAndStartServer(FixedCertificates.TEST_GATEWAY_PORT, FixedCertificates.TEST_FEEDBACK_PORT);
        }

        /**
         * Arrêt du serveur bouchonné simulant l’APNS
         */
        @After
        public void stop() {
            server.stop();
        }

        /**
         * Test de l’ApnsProducer. L’objectif est de vérifier que le serveur APNS a
         * bien reçu les notifications envoyées.
         * Pour cela on vérifie après production des notifications que le serveur bouchonné
         * a bien reçu les messages: On s’assure que les tableaux de bytes de la notification
         * produite et du contenu reçu par le serveur sont bien égaux.
         */
        @Test(timeout = 2000)
        public void testProducer() throws Exception {
            String message = “Hello World”;
            String messagePayload = APNS.newPayload().alertBody(message).build();

            ApnsNotification apnsNotification = new ApnsNotification(FAKE_TOKEN, messagePayload);
            server.stopAt(apnsNotification.length());

            template.sendBody(“direct: test”, message);

            server.messages.acquire();
            assertArrayEquals(apnsNotification.marshall(), server.received.toByteArray());
        }

        /**
         * Création et configuration du contexte Camel avec une configuration de test.
         * Enregistrement du composant APNS, et configuration de l’ApnsService
         */
        protected CamelContext createCamelContext() throws Exception {
            CamelContext camelContext = super.createCamelContext();

            ApnsServiceFactory apnsServiceFactory = ApnsUtils.createDefaultTestConfiguration();
            ApnsService apnsService = apnsServiceFactory.getApnsService();

            ApnsComponent apnsComponent = new ApnsComponent(apnsService);
            camelContext.addComponent(“apns”, apnsComponent);

            return camelContext;
        }

        /**
         * Création de la route Camel permettant de simuler la production de messages
         * à destination des serveurs APNS.
         */
        protected RouteBuilder createRouteBuilder() throws Exception {
            return new RouteBuilder() {
                public void configure() throws Exception {
                    from(“direct: test”).
                    setHeader(ApnsConstants.HEADER_TOKENS, constant(FAKE_TOKEN)).
                    to(“apns: notify”);
                }
            };
        }
    }

Tester l’intégration d’un composant Camel avec Spring

Les configurations Camel sont souvent déclarées par des fichiers de configuration Spring. C’est pourquoi il est nécessaire de tester l’intégration du composant dans une configuration Spring. Un bon moyen d’automatiser ce type de test est d’utiliser les classes de support JUnit fournies par Spring ( _AbstractJUnit4SpringContextTests_ ).

L’ensemble de la configuration est déclarée dans le fichier SpringApnsConsumerTest-context.xml associé au test unitaire. Les différents beans utilisés par la classe de test sont injectés via les annotations @Autowired et @EndpointInject(uri = “mock:result”).

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:camel="http://camel.apache.org/schema/spring"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
        http://camel.apache.org/schema/spring http://camel.apache.org/schema/spring/camel-spring.xsd">

	<bean id="apnsServiceFactory" class="org.apache.camel.component.apns.factory.ApnsServiceFactory">
		<property name="feedbackHost" value="localhost" />
		<property name="feedbackPort" value="7843" />
		<property name="gatewayHost" value="localhost" />
		<property name="gatewayPort" value="7654" />
		<property name="sslContext" ref="sslContext" />
	</bean>

	<!-- Déclaration de l'ApnsService, utilisé par l'ApnsComponent -->
	<bean id="apnsService" factory-bean="apnsServiceFactory" factory-method="getApnsService" />


	<bean id="sslContext" class="org.apache.camel.component.apns.util.FixedCertificates" factory-method="clientContext"/>

	<!-- Déclaration de l'ApnsComponent. Le scheme utilisé pour la création des endpoints -->
	<!-- sera l'Id utilisé pour la création du bean -->
	<bean id="apns" class="org.apache.camel.component.apns.ApnsComponent">
		<property name="apnsService" ref="apnsService" />
	</bean>

	<!-- Déclaration du context Camel, et de la route de test: 'apns-test' -->
	<!-- Les message reçus par le flux feedback seront envoyés vers le endpoint mock:result -->
	<camelcontext id="camel-apns-test" xmlns="http://camel.apache.org/schema/spring">

		<route id="apns-test">
			<from uri="apns:consumer?initialDelay=500&amp;delay=500&amp;timeUnit=MILLISECONDS" />
			<to uri="log:org.apache.camel.component.apns?showAll=true&amp;multiline=true" />
			<to uri="mock:result" />
		</route>

	</camelcontext>

</beans>

Une fois la déclaration du composant Camel effectuée via le fichier de configuration Spring, il ne reste plus qu’à injecter les différents beans configurés dans les propriétés de la classe de test. Le contenu du test en lui-même reste identique, cependant la partie configuration a disparu ce qui rend le test plus lisible. Afin de faire disparaître du test ce qui peut encore en parasiter sa lisibilité, une classe de test parent peut être créée pour contenir les méthodes d’initialisation et d’arrêt du serveur APNS de test.

@ContextConfiguration
public class SpringApnsConsumerTest extends AbstractJUnit4SpringContextTests {

    ApnsServerStub server;

    /**
     * Injection du context Camel déclaré via Spring
     */
    @Autowired
    protected CamelContext camelContext;

    /**
     * Injection du endpoint Camel “mock:result” déclaré via Spring
     */
    @EndpointInject(uri = “mock: result”)
    protected MockEndpoint mock;

    public SpringApnsConsumerTest() {
        super();
    }

    /**
     * Démarrage du serveur bouchonné simulant l’APNS
     */
    @Before
    public void startup() throws InterruptedException {
        server = ApnsServerStub.prepareAndStartServer(FixedCertificates.TEST_GATEWAY_PORT, FixedCertificates.TEST_FEEDBACK_PORT);
    }

    /**
     * Arrêt du serveur bouchonné simulant l’APNS
     */
    @After
    public void stop() {
        server.stop();
    }

    /**
     * Test du consommateur
     */
    @Test(timeout = 5000)
    public void testConsumer() throws Exception {

        byte[] deviceTokenBytes = ApnsUtils.createRandomDeviceTokenBytes();
        String deviceToken = ApnsUtils.encodeHexToken(deviceTokenBytes);

        mock.expectedMessageCount(1);
        mock.message(0).body().isInstanceOf(InactiveDevice.class);

        byte[] feedBackBytes = ApnsUtils.generateFeedbackBytes(deviceTokenBytes);
        server.toSend.write(feedBackBytes);

        Thread.sleep(1000);

        mock.assertIsSatisfied();

        InactiveDevice inactiveDevice = (InactiveDevice) mock.getExchanges().get(0).getIn().getBody();
        Assert.assertNotNull(inactiveDevice);
        Assert.assertNotNull(inactiveDevice.getDate());
        Assert.assertNotNull(inactiveDevice.getDeviceToken());
        Assert.assertEquals(deviceToken, inactiveDevice.getDeviceToken());
    }

}

Limitations du composant actuel

Dans un soucis de simplicité, le composant présenté est limité fonctionnellement et ne propose qu’un ensemble réduit de fonctionnalités. L’implémentation proposée dans ce billet nous oblige à déclarer les tokens à notifier directement au niveau de la route. Cependant une implémentation plus complète pourrait permettre d’exploiter des en-têtes par exemple pour rendre la sélection de token à notifier plus dynamique.

Heureusement, la richesse du framework Apache Camel nous permet de passer outre cette restriction et d’obtenir l’aspect dynamique souhaité en utilisant le pattern Recipient List, qui permet par exemple l’extraction des URIs de destination depuis un en-tête de message produit au préalable.

RouteBuilder builder = new RouteBuilder() {
    public void configure() {
        from(“direct: a”).recipientList(
            header(“recipientListHeader”).tokenize(“, ”));
    }
};

Dans cet exemple, l’en-tête recipientListHeader contiendrait les différentes URIs séparées par des virgules.

Utilisation du composant dans un projet

Pour utiliser le composant développé dans cette série d’articles, il suffit de l’importer en tant que dépendance Maven dans votre projet Camel et de déclarer le repository qui permettra de le charger à défaut de l’avoir déjà dans son répository local.

Ce qui donne les lignes suivantes à ajouter dans le pom de votre projet:

• La dépendance Maven:

<dependency>
    <groupid>org.apache.camel</groupid>
    <artifactid>camel-apns</artifactid>
    <version>2.4.0</version>
</dependency>

• Le repository Maven qui met à disposition le composant:

<repositories>
    <repository>
        <id>camel-apns.repo-release</id>
        <url>http://camel-apns.googlecode.com/svn/maven/public/repository/release/</url>
    </repository>
</repositories>

Exemples d’utilisation

Afin de donner une vision synthétique de l’usage de notre composant, voici un condensé de quelques exemples d’utilisation:

• Consommation du flux feedback avec une configuration Java

from(“apns: consumer”)
    .to(“log: com.apache.camel.component.apns ? showAll = true & amp; amp; amp; multiline = true”)
    .to(“mock: result”);

• Envoi de notifications avec une configuration Java

from(“direct: test”)
    .setHeader(ApnsConstants.HEADER_TOKENS, constant(FAKE_TOKEN))
to(“apns: notify”);

• Envoi d’une notification avec une configuration Spring

<camelcontext id="camel-apns-test" xmlns="http://camel.apache.org/schema/spring">

	<route id="apns-test">
		<from uri="apns:consumer" />
		<to uri="log:org.apache.camel.component.apns?showAll=true&amp;multiline=true" />
		<to uri="mock:result" />
	</route>

</camelcontext>

Conclusion

Nous avons vu dans cet article comment créer et tester un composant Camel qui communique avec les serveurs de notifications d’Apple. Les API du framework ont été pensées pour faciliter le développement de nouveaux composants, et vous permettront d’implémenter et de tester facilement les composants dont vous avez besoin. Vous pouvez consulter le code source du composant camel-apns présenté dans cette série d’article sur sa page Google Code.

Liens utiles

Le site google code du composant ‘camel-apns’ présenté dans le billet:

• http://code.google.com/p/camel-apns

D’autres liens utiles sur le développement de composants Camel:

• Créer des tests unitaires Apache Camel
• Tester un composant Apache Camel

Précédentes parties de l’article:

• Créer un composant Apache Camel de connexion à l’APNS – 1 sur 3
• Créer un composant Apache Camel de connexion à l’APNS – 2 sur 3