Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. */ package org.apache.brooklyn.util; import java.net.URI; import java.util.concurrent.ExecutionException; import java.util.concurrent.Executors; import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.TimeUnit; import org.apache.brooklyn.test.http.TestHttpRequestHandler; import org.apache.brooklyn.test.http.TestHttpServer; import org.apache.brooklyn.util.exceptions.Exceptions; import org.apache.brooklyn.util.http.HttpAsserts; import org.apache.brooklyn.util.http.HttpTool; import org.apache.brooklyn.util.http.HttpToolResponse; import org.apache.brooklyn.util.javalang.JavaClassNames; import org.apache.brooklyn.util.net.Networking; import org.apache.brooklyn.util.time.Duration; import org.apache.brooklyn.util.time.Time; import org.apache.http.HttpStatus; import org.apache.http.client.HttpClient; import org.apache.http.localserver.RequestBasicAuth; import org.apache.http.localserver.ResponseBasicUnauthorized; import org.apache.http.protocol.ResponseServer; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.testng.annotations.AfterMethod; import org.testng.annotations.BeforeMethod; import org.testng.annotations.Test; import com.google.common.collect.ImmutableMap; import com.google.common.util.concurrent.ListenableFuture; import com.google.common.util.concurrent.ListeningExecutorService; import com.google.common.util.concurrent.MoreExecutors; /** * Tests on {@link HttpAsserts}. * * @todo Restructure this to avoid sleeps, according to conversation at * <a href="https://github.com/apache/incubator-brooklyn/pull/994#issuecomment-154074295">#994</a> on github. */ @Test(groups = "Integration") public class HttpAssertsTest { private static final Logger LOG = LoggerFactory.getLogger(HttpAssertsTest.class); private static Duration DELAY_FOR_SERVER_TO_SETTLE = Duration.seconds(2); HttpClient httpClient; URI baseUri; private TestHttpServer server; private String baseUrl; private String simpleEndpoint; private ScheduledExecutorService executor; @BeforeMethod(alwaysRun = true) public void setUp() throws Exception { server = initializeServer(); initVars(); Time.sleep(DELAY_FOR_SERVER_TO_SETTLE); } private void initVars() { baseUrl = server.getUrl(); httpClient = HttpTool.httpClientBuilder().uri(baseUrl).build(); baseUri = URI.create(baseUrl); simpleEndpoint = testUri("/simple"); executor = Executors.newScheduledThreadPool(3); } private TestHttpServer initializeServerUnstarted() { return new TestHttpServer().interceptor(new ResponseServer()).interceptor(new ResponseBasicUnauthorized()) .interceptor(new RequestBasicAuth()).handler("/simple", new TestHttpRequestHandler().response("OK")) .handler("/empty", new TestHttpRequestHandler().code(HttpStatus.SC_NO_CONTENT)) .handler("/missing", new TestHttpRequestHandler().code(HttpStatus.SC_NOT_FOUND).response("Missing")) .handler("/redirect", new TestHttpRequestHandler().code(HttpStatus.SC_MOVED_TEMPORARILY).response("Redirect") .header("Location", "/simple")) .handler("/cycle", new TestHttpRequestHandler().code(HttpStatus.SC_MOVED_TEMPORARILY).response("Redirect") .header("Location", "/cycle")) .handler("/secure", new TestHttpRequestHandler().code(HttpStatus.SC_MOVED_TEMPORARILY) .response("Redirect").header("Location", "https://0.0.0.0/")); } private TestHttpServer initializeServer() { return initializeServerUnstarted().start(); } @AfterMethod(alwaysRun = true) public void tearDown() throws Exception { if (executor != null) executor.shutdownNow(); server.stop(); Time.sleep(DELAY_FOR_SERVER_TO_SETTLE); } // schedule a stop of server after n seconds private void stopAfter(final Duration time) { final TestHttpServer serverCached = server; executor.schedule(new Runnable() { @Override public void run() { LOG.info("stopping server (" + time + " elapsed)"); serverCached.stop(); } }, time.toMilliseconds(), TimeUnit.MILLISECONDS); } // stop server and pause to wait for it to finish private void stopServer() { server.stop(); Time.sleep(DELAY_FOR_SERVER_TO_SETTLE); } // schedule a start of server after n seconds private void startAfter(final Duration time) { // find the port before delay so that callers can get the right url // (sometimes if stopped and started it can't bind to the same port; // at least that is one suspicion for failures on hosted jenkins) server = initializeServerUnstarted(); server.basePort(Networking.nextAvailablePort(50606)); initVars(); executor.schedule(new Runnable() { @Override public void run() { LOG.info("starting server (" + time + " elapsed)"); server.start(); } }, time.toMilliseconds(), TimeUnit.MILLISECONDS); } private HttpToolResponse doGet(String str) { final URI address = baseUri.resolve(str); return HttpTool.httpGet(httpClient, address, ImmutableMap.<String, String>of()); } @Test public void shouldAssertHealthyStatusCode() { final HttpToolResponse response = doGet("/simple"); HttpAsserts.assertHealthyStatusCode(response.getResponseCode()); } @Test public void shouldAssertUrlReachable() { HttpAsserts.assertUrlReachable(baseUrl); } @Test public void shouldAssertUrlUnreachable() { stopServer(); HttpAsserts.assertUrlUnreachable(simpleEndpoint); } @Test public void shouldAssertUrlUnreachableEventually() { HttpAsserts.assertUrlReachable(baseUrl); stopAfter(Duration.seconds(1)); HttpAsserts.assertUrlUnreachableEventually(baseUrl); } @Test public void shouldAssertUrlUnreachableEventuallyWithFlags() throws Exception { String baseUrlOrig = baseUrl; LOG.info("testing " + JavaClassNames.niceClassAndMethod() + ", server " + server.getUrl()); stopAfter(DELAY_FOR_SERVER_TO_SETTLE); startAfter(DELAY_FOR_SERVER_TO_SETTLE.add(DELAY_FOR_SERVER_TO_SETTLE).add(DELAY_FOR_SERVER_TO_SETTLE)); LOG.info(JavaClassNames.niceClassAndMethod() + " queued server changes"); HttpAsserts.assertUrlReachable(baseUrlOrig); HttpAsserts.assertUrlUnreachableEventually(ImmutableMap.of("timeout", "10s"), baseUrlOrig); } @Test(expectedExceptions = AssertionError.class) public void shouldFailAssertUrlUnreachableEventuallyWithTimeout() throws Exception { HttpAsserts.assertUrlReachable(baseUrl); HttpAsserts.assertUrlUnreachableEventually(ImmutableMap.of("timeout", "3s"), baseUrl); } @Test public void shouldAssertHttpStatusCodeEquals() { HttpAsserts.assertHttpStatusCodeEquals(baseUrl, 500, 501); HttpAsserts.assertHttpStatusCodeEquals(simpleEndpoint, 201, 200); HttpAsserts.assertHttpStatusCodeEquals(testUri("/missing"), 400, 404); } @Test public void shouldAssertHttpStatusCodeEventuallyEquals() throws Exception { stopServer(); HttpAsserts.assertUrlUnreachable(simpleEndpoint); startAfter(DELAY_FOR_SERVER_TO_SETTLE); try { HttpAsserts.assertHttpStatusCodeEventuallyEquals(simpleEndpoint, 200); } catch (Throwable t) { LOG.warn("Failed waiting for simple with start after: " + t, t); LOG.warn("Detail: server at " + server.getUrl() + " (" + server + "), looking at " + simpleEndpoint); throw Exceptions.propagate(t); } } private String testUri(String str) { return baseUri.resolve(str).toString(); } @Test public void shouldAssertContentContainsText() { HttpAsserts.assertContentContainsText(simpleEndpoint, "OK"); } @Test public void shouldAssertContentNotContainsText() { HttpAsserts.assertContentNotContainsText(simpleEndpoint, "Bad"); } @Test public void shouldAssertErrorContentsContainsText() { HttpAsserts.assertErrorContentContainsText(testUri("/missing"), "Missing"); } @Test public void shouldAssertErrorContentNotContainsText() { HttpAsserts.assertErrorContentNotContainsText(testUri("/missing"), "Bogus"); } @Test public void shouldAssertContentEventuallyContainsText() { stopServer(); HttpAsserts.assertUrlUnreachable(simpleEndpoint); startAfter(DELAY_FOR_SERVER_TO_SETTLE); HttpAsserts.assertContentEventuallyContainsText(simpleEndpoint, "OK"); } @Test public void shouldAssertContentEventuallyContainsTextWithFlags() { stopServer(); HttpAsserts.assertUrlUnreachable(simpleEndpoint); startAfter(DELAY_FOR_SERVER_TO_SETTLE); HttpAsserts.assertContentEventuallyContainsText( ImmutableMap.of("timeout", DELAY_FOR_SERVER_TO_SETTLE.add(Duration.ONE_SECOND).toStringRounded()), simpleEndpoint, "OK"); } @Test(expectedExceptions = AssertionError.class) public void shouldAssertContentEventuallyContainsTextWithTimeout() { stopServer(); HttpAsserts.assertUrlUnreachable(simpleEndpoint); startAfter(DELAY_FOR_SERVER_TO_SETTLE.add(Duration.seconds(2))); HttpAsserts.assertContentEventuallyContainsText( ImmutableMap.of("timeout", DELAY_FOR_SERVER_TO_SETTLE.add(Duration.ONE_SECOND).toStringRounded()), simpleEndpoint, "OK"); } @Test public void shouldAssertContentMatches() { HttpAsserts.assertContentMatches(simpleEndpoint, "[Oo][Kk]"); } @Test public void shouldAssertContentEventuallyMatches() throws Exception { stopServer(); Time.sleep(DELAY_FOR_SERVER_TO_SETTLE); HttpAsserts.assertUrlUnreachable(simpleEndpoint); Time.sleep(DELAY_FOR_SERVER_TO_SETTLE); startAfter(DELAY_FOR_SERVER_TO_SETTLE); HttpAsserts.assertContentEventuallyMatches(simpleEndpoint, "[Oo][Kk]"); } @Test public void shouldAssertContentEventuallyMatchesWithFlags() { stopServer(); HttpAsserts.assertUrlUnreachable(simpleEndpoint); startAfter(DELAY_FOR_SERVER_TO_SETTLE); HttpAsserts.assertContentEventuallyMatches(ImmutableMap.of("timeout", "3s"), simpleEndpoint, "[Oo][Kk]"); } @Test(expectedExceptions = AssertionError.class) public void shouldAssertContentEventuallyMatchesWithTimeout() { stopServer(); HttpAsserts.assertUrlUnreachable(simpleEndpoint); startAfter(DELAY_FOR_SERVER_TO_SETTLE.add(Duration.seconds(2))); HttpAsserts.assertContentEventuallyMatches( ImmutableMap.of("timeout", DELAY_FOR_SERVER_TO_SETTLE.add(Duration.ONE_SECOND).toStringRounded()), simpleEndpoint, "[Oo][Kk]"); } @Test public void shouldAssertAsyncHttpStatusCodeContinuallyEquals() throws Exception { stopServer(); ListeningExecutorService listeningExecutor = MoreExecutors.listeningDecorator(executor); final ListenableFuture<?> future = HttpAsserts.assertAsyncHttpStatusCodeContinuallyEquals(listeningExecutor, simpleEndpoint, 200); startAfter(DELAY_FOR_SERVER_TO_SETTLE.add(Duration.seconds(1))); if (future.isDone()) { future.get(); // should not throw exception } future.cancel(true); } @Test(expectedExceptions = ExecutionException.class) public void shouldAssertAsyncHttpStatusCodeContinuallyEqualsFails() throws Exception { stopServer(); ListeningExecutorService listeningExecutor = MoreExecutors.listeningDecorator(executor); final ListenableFuture<?> future = HttpAsserts.assertAsyncHttpStatusCodeContinuallyEquals(listeningExecutor, testUri("/missing"), 200); startAfter(DELAY_FOR_SERVER_TO_SETTLE.add(Duration.seconds(1))); Time.sleep(DELAY_FOR_SERVER_TO_SETTLE); if (future.isDone()) { Object result = future.get(); // should throw exception LOG.warn("Should have failed, instead gave " + result + " (accessing " + server + ")"); } else { LOG.warn("Future should have been done"); } future.cancel(true); } }