Tests unitaires Vertx - java.util.concurrent.TimeoutException

Question

J'essaie de tester un appel http à partir de vertx WebClient en utilisant VertxUnitRunner et la version RXified de vertx.

Le problème est que mon test d'unité échoue toujours avec une exception de dépassement de délai. Existe-t-il un moyen différent pour tester les appels http WebClient? Ci-dessous mon code:

import io.vertx.core.AsyncResult; 
import io.vertx.core.http.HttpClientOptions; 
import io.vertx.core.http.HttpServerOptions; 
import io.vertx.ext.unit.TestContext; 
import io.vertx.ext.unit.junit.VertxUnitRunner; 
import io.vertx.rxjava.core.Vertx; 
import io.vertx.rxjava.core.buffer.Buffer; 
import io.vertx.rxjava.core.http.HttpServer; 
import io.vertx.rxjava.ext.web.client.HttpResponse; 
import io.vertx.rxjava.ext.web.client.WebClient; 
import org.junit.Before; 
import org.junit.Test; 
import org.junit.runner.RunWith; 
import rx.Single; 


@RunWith(VertxUnitRunner.class) 
public class MyVertxTest { 

    private Vertx vertx; 
    private WebClient client; 

    @Before 
    public void setUp() throws Exception { 
     vertx = Vertx.vertx(); 
    } 

    @Test 
    public void testGetContactDetails(TestContext context) { 

     System.out.println("start"); 
     long start = System.currentTimeMillis(); 
     HttpServer server = vertx.createHttpServer(new HttpServerOptions().setPort(TEST_SERVER_PORT)); 

     server.requestStream().handler(req -> { 
      req.response().setChunked(true).write("foo bar").end(); 
     }); 

     System.out.println("created server"); 

     try { 
      server.listen(9000, "localhost", (AsyncResult<HttpServer> ar) -> { 

       client = WebClient.wrap(vertx.createHttpClient(new HttpClientOptions())); 

       System.out.println("created client"); 

       Single<HttpResponse<Buffer>> single = client 
         .get(9000, "localhost", "/foo") 
         .rxSend(); 

       single.subscribe(s -> { 
        System.out.println("inside subscribe"); 
        context.assertEquals("foo bar", s.bodyAsString()); 
       }, e -> { 
        context.fail(e); 
       }); 
      }); 

      context.async().await(); 
      System.out.println("total time : " + (System.currentTimeMillis() - start/1000)+" seconds); 

     } catch (Exception e) { 
      context.fail(e); 
     } finally { 
      server.close(); 
     } 
    } 
} 

Le test échoue toujours en raison de délai d'attente après 120 secondes

SORTIE

start 
created server 
created client 
inside subscribe 
total time : 120 

java.util.concurrent.TimeoutException 
    at io.vertx.ext.unit.impl.TestContextImpl$Step.lambda$run$0(TestContextImpl.java:112) 
    at java.lang.Thread.run(Thread.java:745) 

Answer 1

Parce que l'utilisation de la vôtre de async tort. C'est similaire à Java CountDownLatch. Il est décrit dans docs

donc une bonne utilisation serait:

 Async async = context.async(); //here 

     server.listen(9000, "localhost", (AsyncResult<HttpServer> ar) -> { 

      client = WebClient.wrap(vertx.createHttpClient(new HttpClientOptions())); 

      System.out.println("created client"); 

      Single<HttpResponse<Buffer>> single = client 
       .get(9000, "localhost", "/foo") 
       .rxSend().subscribeOn(Schedulers.io()); 

      single.subscribe(s -> { 
       System.out.println("inside subscribe"); 
       context.assertEquals("foo bar", s.bodyAsString()); 
       async.complete(); //here 
      }, e -> { 
       context.fail(e); 
      }); 
     }); 

     async.awaitSuccess(); 

vous pouvez également faire votre code de blocage pour éviter les essais async:

 Single<HttpServer> obs = server.rxListen(9000, "localhost"); 
     obs.toBlocking().value(); //here 

     client = WebClient.wrap(vertx.createHttpClient(new HttpClientOptions())); 

     System.out.println("created client"); 

     Single<HttpResponse<Buffer>> single = client 
      .get(9000, "localhost", "/foo") 
      .rxSend().subscribeOn(Schedulers.io()); 

     Assert.assertEquals(single.toBlocking().value().bodyAsString(), "foo bar"); //here 

Answer 2

Vous pouvez essayer d'ajouter un délai d'attente Règle

@Rule

public Timeout timeoutRule = Timeout.seconds (3600);