@Test public void testCacheInterceptor() throws Exception { server.requestHandler(req -> fail()); startServer(); client.addInterceptor(this::cacheInterceptorHandler); HttpRequest<Buffer> builder = client.get("/somepath").host("localhost").port(8080); builder.send(onSuccess(resp -> { assertEquals(200, resp.statusCode()); complete(); })); await(); }
private Handler<HttpContext<?>> retryInterceptorHandler(AtomicInteger reqCount, AtomicInteger respCount, int num) { return ctx -> handle(ctx, reqCount, respCount, num); }
@Test public void testPhasesThreadFromNonVertxThread() throws Exception { server.requestHandler(req -> req.response().end()); startServer(); testPhasesThread((t1, t2) -> Arrays.asList(t1, t1, t2, t2)); await(); }
private void testPhasesThread(BiFunction<Thread, Thread, List<Thread>> abc) { Thread testThread = Thread.currentThread(); List<Thread> phaseThreads = Collections.synchronizedList(new ArrayList<>()); client.addInterceptor(context -> { phaseThreads.add(Thread.currentThread()); context.next(); }); HttpRequest<Buffer> builder = client.get("/somepath"); builder.send(onSuccess(resp -> { Thread contextThread = Thread.currentThread(); assertEquals(abc.apply(testThread, contextThread), phaseThreads); complete(); })); }
@Test public void testMutateCodecInterceptor() throws Exception { server.requestHandler(req -> req.response().end("foo!")); startServer(); File f = Files.createTempFile("vertx", ".dat").toFile(); assertTrue(f.delete()); AsyncFile foo = vertx.fileSystem().openBlocking(f.getAbsolutePath(), new OpenOptions().setSync(true).setTruncateExisting(true)); client.addInterceptor(this::handleMutateCodec); HttpRequest<Void> builder = client.get("/somepath").as(BodyCodec.pipe(foo)); builder.send(onSuccess(resp -> { foo.write(Buffer.buffer("bar!")); foo.close(onSuccess(v -> { assertEquals("bar!", vertx.fileSystem().readFileBlocking(f.getAbsolutePath()).toString()); testComplete(); })); })); await(); if (f.exists()) { f.delete(); } }
private void mutateResponseHandler(HttpContext context) { if (context.phase() == ClientPhase.DISPATCH_RESPONSE) { HttpResponse<?> resp = context.response(); assertEquals(500, resp.statusCode()); context.response(new HttpResponseImpl<Object>() { @Override public int statusCode() { return 200; } }); } context.next(); }
@Test public void testPhasesThreadFromVertxThread() throws Exception { server.requestHandler(req -> req.response().end()); startServer(); vertx.getOrCreateContext().runOnContext(v -> { testPhasesThread((t1, t2) -> Arrays.asList(t2, t2, t2, t2)); }); await(); }
@Test public void testRetry() throws Exception { int num = 3; server.requestHandler(req -> req.response().setStatusCode(503).end(req.path())); startServer(); AtomicInteger reqCount = new AtomicInteger(); AtomicInteger respCount = new AtomicInteger(); client.addInterceptor(retryInterceptorHandler(reqCount, respCount, num)); HttpRequest<Buffer> builder = client.get("/"); builder.send(onSuccess(resp -> { assertEquals(num + 1, reqCount.get()); assertEquals(num + 1, respCount.get()); assertEquals(503, resp.statusCode()); complete(); })); await(); }
@Test public void testMutateResponseInterceptor() throws Exception { server.requestHandler(req -> req.response().setStatusCode(500).end()); startServer(); client.addInterceptor(this::mutateResponseHandler); HttpRequest<Buffer> builder = client.get("/somepath"); builder.send(onSuccess(resp -> { assertEquals(200, resp.statusCode()); complete(); })); await(); }
@Test public void testMutateRequestInterceptor() throws Exception { server.requestHandler(req -> req.response().end()); startServer(); client.addInterceptor(this::handleMutateRequest); HttpRequest<Buffer> builder = client.get("/somepath").host("another-host").port(8081); builder.send(onSuccess(resp -> complete())); await(); }
@Test public void testInterceptorsOrder() throws Exception { server.requestHandler(req -> req.response().setStatusCode(204).end()); startServer(); List<String> events = Collections.synchronizedList(new ArrayList<>()); client.addInterceptor(context -> { events.add(context.phase().name() + "_1"); context.next(); }); client.addInterceptor(context -> { events.add(context.phase().name() + "_2"); context.next(); }); HttpRequest<Buffer> builder = client.get("/somepath"); builder.send(onSuccess(resp -> { assertEquals(Arrays.asList( "PREPARE_REQUEST_1", "PREPARE_REQUEST_2", "SEND_REQUEST_1", "SEND_REQUEST_2", "RECEIVE_RESPONSE_1", "RECEIVE_RESPONSE_2", "DISPATCH_RESPONSE_1", "DISPATCH_RESPONSE_2"), events); complete(); })); await(); }
startServer(); List<ClientPhase> phases = new ArrayList<>(); List<String> requestUris = new ArrayList<>(); switch (ctx.phase()) { case PREPARE_REQUEST: assertEquals(0, ctx.redirects()); break; case SEND_REQUEST: assertEquals(redirects.getAndIncrement(), ctx.redirects()); requestUris.add(ctx.clientRequest().path()); break; }); HttpRequest<Buffer> builder = client.get("/1").host("localhost").port(8080); builder.send(onSuccess(resp -> { assertEquals(200, resp.statusCode()); assertEquals(Arrays.asList( ClientPhase.PREPARE_REQUEST, ClientPhase.SEND_REQUEST, ClientPhase.RECEIVE_RESPONSE, ClientPhase.DISPATCH_RESPONSE), phases); assertEquals(Arrays.asList("/1", "/2"), requestUris); complete(); })); await();
req.response().setStatusCode(302).putHeader("location", "http://localhost:8080" + req.path() + "0").end(); }); startServer(); List<ClientPhase> phases = new ArrayList<>(); client.addInterceptor(ctx -> { }); HttpRequest<Buffer> builder = client.get("/").host("localhost").port(8080); builder.send(onSuccess(resp -> { assertEquals(302, resp.statusCode()); assertEquals(Arrays.asList( ClientPhase.PREPARE_REQUEST, ClientPhase.SEND_REQUEST, ClientPhase.DISPATCH_RESPONSE ), phases); assertEquals(Arrays.asList( "/", "/0", "/0000000000000000" ), requests); complete(); })); await();