Capitolo 44. Simulazione dell'integrazione di Red Hat 2023.q2 | Portale clienti Red Hat (2023)

mock:qualcheNome[?opzioni]

DovesomeNamepuò essere qualsiasi stringa che identifica in modo univoco l'endpoint.

I componenti Camel sono configurati su due livelli separati:

Il componente Mock supporta 4 opzioni, elencate di seguito.

L'endpoint Mock è configurato utilizzando la sintassi URI:

finto: nome

con i seguenti parametri di percorso e query:

Ecco un semplice esempio di endpoint Mock in uso. Innanzitutto, l'endpoint viene risolto nel contesto. Quindi stabiliamo un'aspettativa e poi, dopo che il test è stato eseguito, affermiamo che le nostre aspettative sono state soddisfatte:

MockEndpoint resultEndpoint = context.getEndpoint("mock:foo", MockEndpoint.class);// imposta le aspettativeresultEndpoint.expectedMessageCount(2);// invia alcuni messaggi// ora asseriamo che l'endpoint mock:foo ha ricevuto 2 messaggiresultEndpoint.assertIsSatisfied( );

In genere si chiama sempre il metodo per verificare che le aspettative siano state soddisfatte dopo l'esecuzione di un test.

Camel aspetterà per impostazione predefinita 10 secondi quando il fileassertIsSatisfied()viene invocato. Questo può essere configurato impostando ilsetResultWaitTime(millis)metodo.

Quando l'asserzione è soddisfatta, Camel smetterà di aspettare e continuerà dalassertIsSatisfiedmetodo. Ciò significa che se un nuovo messaggio arriva sull'endpoint fittizio, solo un po' più tardi, quell'arrivo non influirà sull'esito dell'asserzione. Supponiamo che tu voglia verificare che non arrivino nuovi messaggi dopo un periodo successivo, quindi puoi farlo impostando ilsetAssertPeriodmetodo, ad esempio:

MockEndpoint resultEndpoint = context.getEndpoint("mock:foo", MockEndpoint.class);resultEndpoint.setAssertPeriod(5000);resultEndpoint.expectedMessageCount(2);// invia alcuni messaggi// ora asseriamo che l'endpoint mock:foo ha ricevuto 2 messageresultEndpoint.assertIsSatisfied();

Puoi vedere dal Javadoc diMockEndpointi vari metodi di supporto che puoi utilizzare per impostare le aspettative. I metodi principali sono i seguenti:

Ecco un altro esempio:

resultEndpoint.expectedBodiesReceived("firstMessageBody", "secondMessageBody", "thirdMessageBody");

Inoltre, puoi utilizzare ilmessaggio(int messaggioIndice)metodo per aggiungere asserzioni su un messaggio specifico ricevuto.

Ad esempio, per aggiungere aspettative delle intestazioni o del corpo del primo messaggio (utilizzando l'indicizzazione in base zero comejava.util.List), è possibile utilizzare il seguente codice:

resultEndpoint.message(0).header("foo").isEqualTo("bar");

Ci sono alcuni esempi dell'endpoint Mock in uso innucleo di cammellotest del processore.

Camel ora ti consente di simulare automaticamente gli endpoint esistenti nelle tue rotte Camel.

Supponiamo di avere il percorso indicato di seguito:

Itinerario

@Override protected RouteBuilder createRouteBuilder() genera un'eccezione { return new RouteBuilder() { @Override public void configure() genera un'eccezione { from("direct:start").routeId("start") .to("direct:foo") .to("log:foo").to("mock:risultato"); from("direct:foo").routeId("foo") .transform(constant("Bye World")); } }; }

È quindi possibile utilizzare ilconsiglioConfunzione in Camel per prendere in giro tutti gli endpoint in un determinato percorso dal test unitario, come mostrato di seguito:

consiglioConderidendo tutti gli endpoint

@Test public void testAdvisedMockEndpoints() getta Exception { // indica il percorso iniziale utilizzando il generatore di percorsi in stile lambda AdviceWith incorporato // che ha capacità estese rispetto al normale generatore di percorsi AdviceWith.adviceWith(context, "start", a -> // mock tutti gli endpoint a.mockEndpoints()); getMockEndpoint("mock:direct:start").expectedBodiesReceived("Hello World"); getMockEndpoint("mock:direct:foo").expectedBodiesReceived("Hello World"); getMockEndpoint("mock:log:foo").expectedBodiesReceived("Ciao mondo"); getMockEndpoint("mock:result").expectedBodiesReceived("Bye World"); template.sendBody("direct:start", "Hello World"); assertMockEndpointsSatisfied(); // test aggiuntivo per garantire la correttezza degli endpoint nel registro assertNotNull(context.hasEndpoint("direct:start")); assertNotNull(context.hasEndpoint("direct:foo")); assertNotNull(context.hasEndpoint("log:foo")); assertNotNull(context.hasEndpoint("mock:result")); // tutti gli endpoint sono stati derisi assertNotNull(context.hasEndpoint("mock:direct:start")); assertNotNull(context.hasEndpoint("mock:direct:foo")); assertNotNull(context.hasEndpoint("mock:log:foo")); }

Si noti che agli endpoint fittizi viene assegnato l'URImock:, Per esempiomock:direct:foo. Tronchi di cammello aINFORMAZIONIlivellare gli endpoint presi in giro:

INFO Endpoint consigliato [direct://foo] con endpoint fittizio [mock:direct:foo]

È anche possibile deridere solo determinati endpoint utilizzando un pattern. Ad esempio per deridere tuttitronco d'alberoendpoint che fai come mostrato:

consiglioConderidendo solo gli endpoint del log utilizzando un modello

@Test public void testAdvisedMockEndpointsWithPattern() getta Exception { // indica il percorso iniziale utilizzando il generatore di percorsi in stile lambda AdviceWith incorporato // che ha capacità estese rispetto al normale generatore di percorsi AdviceWith.adviceWith(context, "start", a -> // endpoint di log solo mock a.mockEndpoints("log*")); // ora possiamo fare riferimento a log:foo come a un mock e impostare le nostre aspettative getMockEndpoint("mock:log:foo").expectedBodiesReceived("Bye World"); getMockEndpoint("mock:result").expectedBodiesReceived("Bye World"); template.sendBody("direct:start", "Hello World"); assertMockEndpointsSatisfied(); // test aggiuntivo per garantire la correttezza degli endpoint nel registro assertNotNull(context.hasEndpoint("direct:start")); assertNotNull(context.hasEndpoint("direct:foo")); assertNotNull(context.hasEndpoint("log:foo")); assertNotNull(context.hasEndpoint("mock:result")); // solo l'endpoint log:foo è stato deriso assertNotNull(context.hasEndpoint("mock:log:foo")); assertNull(context.hasEndpoint("mock:direct:start")); assertNull(context.hasEndpoint("mock:direct:foo")); }

Il modello supportato può essere un carattere jolly o un'espressione regolare. Vedi maggiori dettagli su questo su Intercept poiché è la stessa funzione di corrispondenza utilizzata da Camel.

Invece di usare ilconsiglioConper istruire Camel a simulare gli endpoint, puoi facilmente abilitare questo comportamento quando usi ilprova del cammelloKit di prova.

Lo stesso percorso può essere testato come segue. Nota che torniamo"*"dalisMockEndpointsmetodo, che dice a Camel di prendere in giro tutti gli endpoint.

Se vuoi solo deridere tuttitronco d'alberoendpoint che puoi restituire"tronco d'albero*"Invece.

isMockEndpointsutilizzando il kit di test del cammello

public class IsMockEndpointsJUnit4Test extends CamelTestSupport { @Override public String isMockEndpoints() { // esegue l'override di questo metodo e restituisce il modello per i quali endpoint simulare. // usa * per indicare tutti i return "*"; } @Test public void testMockAllEndpoints() throws Exception { // nota che abbiamo simulato automaticamente tutti gli endpoint e il nome degli endpoint è "mock:uri" getMockEndpoint("mock:direct:start").expectedBodiesReceived("Hello World") ; getMockEndpoint("mock:direct:foo").expectedBodiesReceived("Hello World"); getMockEndpoint("mock:log:foo").expectedBodiesReceived("Ciao mondo"); getMockEndpoint("mock:result").expectedBodiesReceived("Bye World"); template.sendBody("direct:start", "Hello World"); assertMockEndpointsSatisfied(); // test aggiuntivo per garantire la correttezza degli endpoint nel registro assertNotNull(context.hasEndpoint("direct:start")); assertNotNull(context.hasEndpoint("direct:foo")); assertNotNull(context.hasEndpoint("log:foo")); assertNotNull(context.hasEndpoint("mock:result")); // tutti gli endpoint sono stati derisi assertNotNull(context.hasEndpoint("mock:direct:start")); assertNotNull(context.hasEndpoint("mock:direct:foo")); assertNotNull(context.hasEndpoint("mock:log:foo")); } @Override protected RouteBuilder createRouteBuilder() genera un'eccezione { return new RouteBuilder() { @Override public void configure() genera un'eccezione { from("direct:start").to("direct:foo").to("log: foo").to("mock:risultato"); from("direct:foo").transform(constant("Ciao mondo")); } }; }}

Se non usi ilprova del cammellocomponente per unit test (come mostrato sopra) è possibile utilizzare un approccio diverso quando si utilizzano i file XML per i percorsi.
La soluzione è creare un nuovo file XML utilizzato dal test unitario e quindi includere il file XML previsto che contiene il percorso che si desidera testare.

Supponiamo di avere il percorso inpercorso-cammello.xmlfile:

           Ciao mondo   

Quindi creiamo un nuovo file XML come segue, dove includiamo il filepercorso-cammello.xmlfile e definire un bean spring con la classeorg.apache.camel.impl.InterceptSendToMockEndpointStrategyche dice a Camel di deridere tutti gli endpoint:

Quindi nel tuo unit test carichi il nuovo file XML (test-percorso-cammello.xml) invece dipercorso-cammello.xml.

Solo per deridere tuttiTronco d'alberoendpoints è possibile definire il modello nel costruttore per il bean:

A volte vuoi simulare facilmente e saltare l'invio a determinati endpoint. Quindi il messaggio viene deviato e inviato solo all'endpoint fittizio. Ora puoi usare ilmockEndpointsAndSkipmetodo utilizzando AdviceWith. L'esempio seguente salterà l'invio ai due endpoint"diretto: foo", E"diretto: bar".

consiglioCon finta e salta l'invio agli endpoint

@Test public void testAdvisedMockEndpointsWithSkip() lancia Exception { // consiglia il primo percorso utilizzando il generatore di percorsi AdviceWith incorporato // che ha capacità estese rispetto al normale generatore di percorsi AdviceWith.adviceWith(context.getRouteDefinitions().get(0), context, new AdviceWithRouteBuilder() { @Override public void configure() lancia un'eccezione { // simula l'invio a direct:foo e direct:bar e salta l'invio a esso mockEndpointsAndSkip("direct:foo", "direct:bar"); } }) ; getMockEndpoint("mock:result").expectedBodiesReceived("Hello World"); getMockEndpoint("mock:direct:foo").expectedMessageCount(1); getMockEndpoint("mock:direct:bar").expectedMessageCount(1); template.sendBody("direct:start", "Hello World"); assertMockEndpointsSatisfied(); // il messaggio non è stato inviato alla route direct:foo e quindi non è stato inviato // all'endpoint seda SedaEndpoint seda = context.getEndpoint("seda:foo", SedaEndpoint.class); assertEquals(0, seda.getCurrentQueueSize()); }

Lo stesso esempio utilizzando il kit di test

isMockEndpointsAndSkip utilizzando il kit di test del cammello

public class IsMockEndpointsAndSkipJUnit4Test extends CamelTestSupport { @Override public String isMockEndpointsAndSkip() { // esegue l'override di questo metodo e restituisce il modello per cui simulare gli endpoint, // e salta l'invio all'endpoint originale. return "direct:foo"; } @Test public void testMockEndpointAndSkip() throws Exception { // nota che abbiamo simulato automaticamente gli endpoint direct:foo e il nome degli endpoint è "mock:uri" getMockEndpoint("mock:result").expectedBodiesReceived("Hello World" ); getMockEndpoint("mock:direct:foo").expectedMessageCount(1); template.sendBody("direct:start", "Hello World"); assertMockEndpointsSatisfied(); // il messaggio non è stato inviato alla route direct:foo e quindi non è stato inviato all'endpoint seda SedaEndpoint seda = context.getEndpoint("seda:foo", SedaEndpoint.class); assertEquals(0, seda.getCurrentQueueSize()); } @Override protected RouteBuilder createRouteBuilder() genera un'eccezione { return new RouteBuilder() { @Override public void configure() genera un'eccezione { from("direct:start").to("direct:foo").to("mock: risultato"); from("direct:foo").transform(constant("Bye World")).to("seda:foo"); } }; }}

ILDerideregli endpoint manterranno per impostazione predefinita una copia di ogni Exchange ricevuto. Quindi, se esegui il test con molti messaggi, consumerà memoria.
Abbiamo introdotto due opzioniretainPrimoEretainLastche può essere utilizzato per specificare di mantenere solo l'N° del primo e/o dell'ultimo Scambio.

Ad esempio, nel codice seguente, vogliamo conservare solo una copia dei primi 5 e degli ultimi 5 scambi ricevuti dal mock.

MockEndpoint mock = getMockEndpoint("mock:data"); mock.setRetainFirst(5); mock.setRetainLast(5); mock.expectedMessageCount(2000); mock.assertIsSatisfied();

L'utilizzo di questo ha alcune limitazioni. ILgetExchanges()EgetReceivedExchanges()metodi sulMockEndpointrestituirà solo le copie trattenute degli Scambi. Quindi nell'esempio sopra, l'elenco conterrà 10 scambi; i primi cinque e gli ultimi cinque.
ILretainPrimoEretainLastopzioni hanno anche limitazioni sui metodi di aspettativa che è possibile utilizzare. Ad esempio ilprevistoXXXi metodi che funzionano su corpi di messaggi, intestazioni, ecc. funzioneranno solo sui messaggi conservati. Nell'esempio precedente possono testare solo le aspettative sui 10 messaggi conservati.

ILDeriderel'endpoint archivia l'ora di arrivo del messaggio come proprietà nell'Exchange

Data ora = exchange.getProperty(Exchange.RECEIVED_TIMESTAMP, Date.class);

Puoi utilizzare queste informazioni per sapere quando il messaggio è arrivato sul mock. Ma fornisce anche le basi per conoscere l'intervallo di tempo tra il messaggio precedente e quello successivo arrivato sul mock. Puoi usarlo per impostare le aspettative usando ilarrivaDSL sull'endpoint fittizio.

Ad esempio per dire che il primo messaggio dovrebbe arrivare tra 0-2 secondi prima del successivo puoi fare:

mock.message(0).arrives().noLaterThan(2).seconds().beforeNext();

Puoi anche definire questo come quel secondo messaggio (0 indice basato) dovrebbe arrivare non più tardi di 0-2 secondi dopo il precedente:

mock.message(1).arrives().noLaterThan(2).seconds().afterPrevious();

Puoi anche usare between per impostare un limite inferiore. Ad esempio, supponiamo che dovrebbe essere compreso tra 1 e 4 secondi:

mock.message(1).arrives().between(1, 4).seconds().afterPrevious();

Puoi anche impostare l'aspettativa su tutti i messaggi, ad esempio per dire che il divario tra loro dovrebbe essere al massimo 1 secondo:

mock.allMessages().arrives().noLaterThan(1).seconds().beforeNext();

Quando si utilizza mock con Spring Boot, assicurarsi di utilizzare la seguente dipendenza Maven per avere il supporto per la configurazione automatica:

 org.apache.camel.springboot camel-mock-starter

Il componente supporta 5 opzioni, elencate di seguito.