Java tutorial
/** * Copyright 2010-2011 Nokia * * Licensed 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 com.github.restdriver.clientdriver.integration; import static com.github.restdriver.clientdriver.ClientDriverRequest.Method.*; import static com.github.restdriver.clientdriver.RestClientDriver.*; import static org.hamcrest.MatcherAssert.*; import static org.hamcrest.Matchers.*; import java.io.ByteArrayInputStream; import java.io.IOException; import java.io.InputStream; import java.net.URI; import java.util.regex.Pattern; import org.apache.commons.io.IOUtils; import org.apache.http.HttpResponse; import org.apache.http.client.ClientProtocolException; import org.apache.http.client.HttpClient; import org.apache.http.client.methods.HttpDelete; import org.apache.http.client.methods.HttpEntityEnclosingRequestBase; import org.apache.http.client.methods.HttpGet; import org.apache.http.client.methods.HttpHead; import org.apache.http.client.methods.HttpOptions; import org.apache.http.client.methods.HttpPatch; import org.apache.http.client.methods.HttpPost; import org.apache.http.client.methods.HttpPut; import org.apache.http.client.methods.HttpTrace; import org.apache.http.entity.ContentType; import org.apache.http.entity.StringEntity; import org.apache.http.impl.client.DefaultHttpClient; import org.apache.http.message.BasicHeader; import org.apache.http.util.EntityUtils; import org.junit.Rule; import org.junit.Test; import org.junit.rules.ExpectedException; import com.github.restdriver.clientdriver.ClientDriverRequest.Method; import com.github.restdriver.clientdriver.ClientDriverRule; import com.github.restdriver.clientdriver.exception.ClientDriverFailedExpectationException; public class ClientDriverSuccessTest { @Rule public ClientDriverRule driver = new ClientDriverRule(); @Rule public ExpectedException thrown = ExpectedException.none(); @Test public void testJettyWorking200() throws Exception { driver.addExpectation(onRequestTo("/blah"), giveResponse("OUCH!!", "text/plain").withStatus(200).withHeader("Server", "TestServer")); HttpClient client = new DefaultHttpClient(); String baseUrl = driver.getBaseUrl(); HttpGet getter = new HttpGet(baseUrl + "/blah"); HttpResponse response = client.execute(getter); assertThat(response.getStatusLine().getStatusCode(), is(200)); assertThat(IOUtils.toString(response.getEntity().getContent()), is("OUCH!!")); assertThat(response.getHeaders("Server")[0].getValue(), is("TestServer")); } @Test public void testJettyWorking404() throws Exception { String baseUrl = driver.getBaseUrl(); driver.addExpectation(onRequestTo("/blah2"), giveResponse("o.O", "text/plain").withStatus(404)); HttpClient client = new DefaultHttpClient(); HttpGet getter = new HttpGet(baseUrl + "/blah2"); HttpResponse response = client.execute(getter); assertThat(response.getStatusLine().getStatusCode(), is(404)); assertThat(IOUtils.toString(response.getEntity().getContent()), equalTo("o.O")); } @Test public void testJettyWorking500() throws Exception { String baseUrl = driver.getBaseUrl(); driver.addExpectation(onRequestTo("/blah2"), giveResponse("___", "text/plain").withStatus(500)); HttpClient client = new DefaultHttpClient(); HttpGet getter = new HttpGet(baseUrl + "/blah2"); HttpResponse response = client.execute(getter); assertThat(response.getStatusLine().getStatusCode(), is(500)); assertThat(IOUtils.toString(response.getEntity().getContent()), equalTo("___")); } @Test public void matchingPathWithMatcherSucceeds() throws Exception { String baseUrl = driver.getBaseUrl(); driver.addExpectation(onRequestTo(containsString("hello")).withMethod(Method.GET), giveEmptyResponse().withStatus(418).withHeader("Cache-Control", "no-cache")); HttpClient client = new DefaultHttpClient(); HttpGet get = new HttpGet(baseUrl + "/this_url_can_be_anything_as_long_as_it_says_hello_somewhere"); HttpResponse response = client.execute(get); assertThat(response.getStatusLine().getStatusCode(), is(418)); } @Test public void testJettyWorkingBinaryResponse() throws Exception { ClassLoader loader = ClientDriverSuccessTest.class.getClassLoader(); byte[] binaryContent = IOUtils.toByteArray(loader.getResourceAsStream("example-binary.zip")); InputStream stream = new ByteArrayInputStream(binaryContent); String baseUrl = driver.getBaseUrl(); driver.addExpectation(onRequestTo("/blah2"), giveResponseAsBytes(stream, "application/octet-stream")); HttpClient client = new DefaultHttpClient(); HttpGet getter = new HttpGet(baseUrl + "/blah2"); HttpResponse response = client.execute(getter); assertThat(response.getStatusLine().getStatusCode(), is(200)); assertThat(IOUtils.toByteArray(response.getEntity().getContent()), is(binaryContent)); } @Test public void testJettyWorkingTwoRequests() throws Exception { String baseUrl = driver.getBaseUrl(); driver.addExpectation(onRequestTo("/blah123"), giveResponse("__2_", "text/plain").withStatus(200)); driver.addExpectation(onRequestTo("/blah456"), giveResponse("__7_", "text/plain").withStatus(300)); HttpClient client = new DefaultHttpClient(); HttpGet getter1 = new HttpGet(baseUrl + "/blah123"); HttpResponse response1 = client.execute(getter1); assertThat(response1.getStatusLine().getStatusCode(), is(200)); assertThat(IOUtils.toString(response1.getEntity().getContent()), equalTo("__2_")); HttpGet getter2 = new HttpGet(baseUrl + "/blah456"); HttpResponse response2 = client.execute(getter2); assertThat(response2.getStatusLine().getStatusCode(), is(300)); assertThat(IOUtils.toString(response2.getEntity().getContent()), equalTo("__7_")); } @Test public void testJettyWorkingWithMethodAndParams() throws Exception { driver.addExpectation(onRequestTo("/blah").withMethod(Method.DELETE).withParam("gang", "green"), giveResponse("OUCH!!", "text/plain").withStatus(200).withHeader("Server", "TestServer")); HttpClient client = new DefaultHttpClient(); String baseUrl = driver.getBaseUrl(); HttpDelete deleter = new HttpDelete(baseUrl + "/blah?gang=green"); HttpResponse response = client.execute(deleter); assertThat(response.getStatusLine().getStatusCode(), is(200)); assertThat(IOUtils.toString(response.getEntity().getContent()), equalTo("OUCH!!")); assertThat(response.getHeaders("Server")[0].getValue(), equalTo("TestServer")); } @Test public void testJettyWorkingWithMethodAndParamsPattern() throws Exception { driver.addExpectation( onRequestTo(Pattern.compile("/[a-z]l[a-z]{2}")).withMethod(Method.DELETE).withParam("gang", Pattern.compile("gre[a-z]+")), giveResponse("OUCH!!", "text/plain").withStatus(200).withHeader("Server", "TestServer")); HttpClient client = new DefaultHttpClient(); String baseUrl = driver.getBaseUrl(); HttpDelete deleter = new HttpDelete(baseUrl + "/blah?gang=green"); HttpResponse response = client.execute(deleter); assertThat(response.getStatusLine().getStatusCode(), is(200)); } @Test public void testJettyWorkingTwoSameRequests() throws Exception { driver.addExpectation(onRequestTo("/blah"), giveResponse("OUCH!!", "text/plain").withStatus(200).withHeader("Server", "TestServer")); driver.addExpectation(onRequestTo("/blah"), giveResponse("OUCH!!404", "text/plain404").withStatus(404).withHeader("Server", "TestServer404")); HttpClient client = new DefaultHttpClient(); String baseUrl = driver.getBaseUrl(); HttpGet getter = new HttpGet(baseUrl + "/blah"); HttpResponse response = client.execute(getter); assertThat(response.getStatusLine().getStatusCode(), is(200)); assertThat(IOUtils.toString(response.getEntity().getContent()), equalTo("OUCH!!")); assertThat(response.getHeaders("Server")[0].getValue(), equalTo("TestServer")); HttpGet getter2 = new HttpGet(baseUrl + "/blah"); HttpResponse response2 = client.execute(getter2); assertThat(response2.getStatusLine().getStatusCode(), is(404)); assertThat(IOUtils.toString(response2.getEntity().getContent()), equalTo("OUCH!!404")); assertThat(response2.getHeaders("Server")[0].getValue(), equalTo("TestServer404")); } @Test public void testJettyWorkingWithPostBody() throws Exception { String baseUrl = driver.getBaseUrl(); driver.addExpectation( onRequestTo("/blah2").withMethod(Method.PUT).withBody("Jack your body!", "text/plain"), giveResponse("___", "text/plain").withStatus(501)); HttpClient client = new DefaultHttpClient(); HttpPut putter = new HttpPut(baseUrl + "/blah2"); putter.setEntity(new StringEntity("Jack your body!", ContentType.TEXT_PLAIN)); HttpResponse response = client.execute(putter); assertThat(response.getStatusLine().getStatusCode(), is(501)); assertThat(IOUtils.toString(response.getEntity().getContent()), equalTo("___")); } @Test public void testJettyWorkingWithPostBodyPattern() throws Exception { String baseUrl = driver.getBaseUrl(); driver.addExpectation(onRequestTo("/blah2").withMethod(Method.PUT) .withBody(Pattern.compile("Jack [\\w\\s]+!"), "text/plain"), giveResponse("___", "text/plain").withStatus(501)); HttpClient client = new DefaultHttpClient(); HttpPut putter = new HttpPut(baseUrl + "/blah2"); putter.setEntity(new StringEntity("Jack your body!", ContentType.TEXT_PLAIN)); HttpResponse response = client.execute(putter); assertThat(response.getStatusLine().getStatusCode(), is(501)); assertThat(IOUtils.toString(response.getEntity().getContent()), equalTo("___")); } @Test public void testJettyWorkingWithPatchBody() throws Exception { String baseUrl = driver.getBaseUrl(); driver.addExpectation( onRequestTo("/blah2").withMethod(Method.custom("PATCH")).withBody("Jack your body!", "text/plain"), giveResponse("___", "text/plain").withStatus(501)); HttpClient client = new DefaultHttpClient(); HttpPatch patcher = new HttpPatch(baseUrl + "/blah2"); patcher.setEntity(new StringEntity("Jack your body!", ContentType.TEXT_PLAIN)); HttpResponse response = client.execute(patcher); assertThat(response.getStatusLine().getStatusCode(), is(501)); assertThat(IOUtils.toString(response.getEntity().getContent()), equalTo("___")); } @Test public void testJettyWorkingWithPatchBodyPattern() throws Exception { String baseUrl = driver.getBaseUrl(); driver.addExpectation( onRequestTo("/blah2").withMethod(Method.custom("PATCH")) .withBody(Pattern.compile("Jack [\\w\\s]+!"), "text/plain"), giveResponse("___", "text/plain").withStatus(501)); HttpClient client = new DefaultHttpClient(); HttpPatch patcher = new HttpPatch(baseUrl + "/blah2"); patcher.setEntity(new StringEntity("Jack your body!", ContentType.TEXT_PLAIN)); HttpResponse response = client.execute(patcher); assertThat(response.getStatusLine().getStatusCode(), is(501)); assertThat(IOUtils.toString(response.getEntity().getContent()), equalTo("___")); } @Test public void testHttpOPTIONS() throws Exception { String baseUrl = driver.getBaseUrl(); driver.addExpectation(onRequestTo("/blah2").withMethod(Method.OPTIONS), giveResponse(null, null).withStatus(200).withHeader("Allow", "POST, OPTIONS")); HttpClient client = new DefaultHttpClient(); HttpOptions options = new HttpOptions(baseUrl + "/blah2"); HttpResponse response = client.execute(options); assertThat(response.getStatusLine().getStatusCode(), is(200)); assertThat(response.getHeaders("Allow")[0].getValue(), equalTo("POST, OPTIONS")); } @Test public void testJettyWorkingWithHeaderString() throws Exception { String baseUrl = driver.getBaseUrl(); driver.addExpectation(onRequestTo("/header").withMethod(Method.GET), giveEmptyResponse().withStatus(204).withHeader("Cache-Control", "no-cache")); HttpClient client = new DefaultHttpClient(); HttpGet get = new HttpGet(baseUrl + "/header"); HttpResponse response = client.execute(get); assertThat(response.getStatusLine().getStatusCode(), is(204)); assertThat(response.getHeaders("Cache-Control")[0].getValue(), equalTo("no-cache")); } @Test public void matchingOnRequestHeader() throws Exception { String baseUrl = driver.getBaseUrl(); driver.addExpectation(onRequestTo("/header").withMethod(Method.GET).withHeader("X-FOO", "bar"), giveEmptyResponse().withStatus(204).withHeader("Cache-Control", "no-cache")); HttpClient client = new DefaultHttpClient(); HttpGet get = new HttpGet(baseUrl + "/header"); get.addHeader(new BasicHeader("X-FOO", "bar")); HttpResponse response = client.execute(get); assertThat(response.getStatusLine().getStatusCode(), is(204)); assertThat(response.getHeaders("Cache-Control")[0].getValue(), equalTo("no-cache")); } @Test public void matchingOnRequestHeaderNotBeingPresent() throws Exception { String baseUrl = driver.getBaseUrl(); driver.addExpectation( onRequestTo("/without-header-test").withMethod(Method.GET).withoutHeader("Some Header"), giveEmptyResponse().withStatus(204).withHeader("Cache-Control", "no-cache")); driver.addExpectation( onRequestTo("/without-header-test").withMethod(Method.GET).withHeader("Some Header", "hello"), giveEmptyResponse().withStatus(418).withHeader("Cache-Control", "no-cache")); HttpClient client = new DefaultHttpClient(); HttpGet get = new HttpGet(baseUrl + "/without-header-test"); HttpResponse response = client.execute(get); assertThat(response.getStatusLine().getStatusCode(), is(204)); get = new HttpGet(baseUrl + "/without-header-test"); get.addHeader(new BasicHeader("Some Header", "hello")); response = client.execute(get); assertThat(response.getStatusLine().getStatusCode(), is(418)); } @Test public void failedMatchingOnRequestHeader() throws Exception { thrown.expect(ClientDriverFailedExpectationException.class); String baseUrl = driver.getBaseUrl(); driver.addExpectation(onRequestTo("/header").withMethod(Method.GET).withHeader("X-FOO", "bar"), giveEmptyResponse().withStatus(204).withHeader("Cache-Control", "no-cache")); HttpClient client = new DefaultHttpClient(); HttpGet get = new HttpGet(baseUrl + "/header"); get.addHeader(new BasicHeader("X-FOO", "baz")); client.execute(get); } @Test public void matchingHeaderWithMatcherSucceeds() throws Exception { String baseUrl = driver.getBaseUrl(); driver.addExpectation( onRequestTo("/header").withMethod(Method.GET).withHeader("Something", containsString("foo")), giveEmptyResponse().withStatus(204).withHeader("Cache-Control", "no-cache")); HttpClient client = new DefaultHttpClient(); HttpGet get = new HttpGet(baseUrl + "/header"); get.addHeader(new BasicHeader("Something", "bar grep foo woof")); client.execute(get); } @Test public void failedMatchingOnRequestHeaderWithPattern() throws Exception { thrown.expect(ClientDriverFailedExpectationException.class); String baseUrl = driver.getBaseUrl(); driver.addExpectation(onRequestTo("/header").withMethod(Method.GET).withHeader("X-FOO", is("bar")), giveEmptyResponse().withStatus(204).withHeader("Cache-Control", "no-cache")); HttpClient client = new DefaultHttpClient(); HttpGet get = new HttpGet(baseUrl + "/header"); get.addHeader(new BasicHeader("X-FOO", "baz")); client.execute(get); } @Test public void testHttpHEADMatchesHttpGETExceptForEntity() throws Exception { String baseUrl = driver.getBaseUrl(); String URL = baseUrl + "/blah2"; driver.addExpectation(onRequestTo("/blah2").withMethod(Method.GET), giveResponse("something", "text/plain").withStatus(200).withHeader("Allow", "GET, HEAD")); driver.addExpectation(onRequestTo("/blah2").withMethod(Method.HEAD), giveResponse("something", "text/plain").withStatus(200).withHeader("Allow", "GET, HEAD")); HttpClient client = new DefaultHttpClient(); HttpHead headRequest = new HttpHead(URL); HttpResponse headResponse = client.execute(headRequest); HttpGet getRequest = new HttpGet(URL); HttpResponse getResponse = client.execute(getRequest); assertThat(headResponse.getStatusLine().getStatusCode(), is(200)); assertThat(headResponse.getHeaders("Allow")[0].getValue(), equalTo("GET, HEAD")); assertThat(headResponse.getAllHeaders().length, is(getResponse.getAllHeaders().length)); String getEntityBody = EntityUtils.toString(getResponse.getEntity()); assertThat(getEntityBody, is("something")); assertThat(headResponse.getEntity(), nullValue()); } @Test public void testMatchingParamUsingMatcherDirectly() throws Exception { String url = driver.getBaseUrl() + "/testing?key=value1"; driver.addExpectation(onRequestTo("/testing").withMethod(Method.GET).withParam("key", startsWith("value")), giveResponse("something", "text/plain").withStatus(200)); HttpClient client = new DefaultHttpClient(); HttpGet getRequest = new HttpGet(url); HttpResponse getResponse = client.execute(getRequest); String getEntityBody = EntityUtils.toString(getResponse.getEntity()); assertThat(getEntityBody, is("something")); } @Test public void testMatchingOnMultipleParameters() throws Exception { String url = driver.getBaseUrl() + "/testing?key=value1&key=value2"; driver.addExpectation(onRequestTo("/testing").withMethod(Method.GET).withParam("key", "value1") .withParam("key", "value2"), giveResponse("something", "text/plain").withStatus(200)); HttpClient client = new DefaultHttpClient(); HttpGet getRequest = new HttpGet(url); HttpResponse getResponse = client.execute(getRequest); String getEntityBody = EntityUtils.toString(getResponse.getEntity()); assertThat(getEntityBody, is("something")); } @Test public void testHttpTRACE() throws ClientProtocolException, IOException { String baseUrl = driver.getBaseUrl(); driver.addExpectation(onRequestTo("/blah2").withMethod(Method.TRACE), giveResponse(null, null).withStatus(200)); HttpClient client = new DefaultHttpClient(); HttpTrace trace = new HttpTrace(baseUrl + "/blah2"); HttpResponse response = client.execute(trace); assertThat(response.getStatusLine().getStatusCode(), is(200)); } @Test public void testPostWithBodyOverTwoExpectations() throws Exception { // bug fix String baseUrl = driver.getBaseUrl(); driver.addExpectation(onRequestTo("/foo"), giveResponse("___", "text/plain").withStatus(417)); driver.addExpectation(onRequestTo("/blah2").withBody("<eh/>", "application/xml").withMethod(POST), giveResponse("___", "text/plain").withStatus(418)); HttpClient postClient = new DefaultHttpClient(); HttpPost poster = new HttpPost(baseUrl + "/blah2"); poster.setEntity(new StringEntity("<eh/>", ContentType.APPLICATION_XML)); HttpResponse response = postClient.execute(poster); HttpClient getClient = new DefaultHttpClient(); HttpGet getter = new HttpGet(baseUrl + "/foo"); HttpResponse getResponse = getClient.execute(getter); assertThat(getResponse.getStatusLine().getStatusCode(), equalTo(417)); assertThat(response.getStatusLine().getStatusCode(), is(418)); assertThat(IOUtils.toString(response.getEntity().getContent()), equalTo("___")); } @Test public void bodyIsAllowedForGet() throws Exception { driver.addExpectation(onRequestTo("/foo").withBody("A BODY", "text/plain"), giveEmptyResponse().withStatus(418)); HttpClient client = new DefaultHttpClient(); HttpMethodWithBody get = new HttpMethodWithBody("GET", driver.getBaseUrl() + "/foo"); get.setEntity(new StringEntity("A BODY")); HttpResponse response = client.execute(get); assertThat(response.getStatusLine().getStatusCode(), is(418)); } @Test public void emptyResponseHasNoContentType() throws Exception { driver.addExpectation(onRequestTo("/foo"), giveEmptyResponse().withStatus(200)); HttpClient client = new DefaultHttpClient(); HttpMethodWithBody get = new HttpMethodWithBody("GET", driver.getBaseUrl() + "/foo"); HttpResponse response = client.execute(get); assertThat(response.getHeaders("Content-Type").length, is(0)); } @Test public void bodyIsAllowedForDelete() throws Exception { driver.addExpectation(onRequestTo("/foo").withMethod(Method.DELETE).withBody("A BODY", "text/plain"), giveEmptyResponse().withStatus(418)); HttpClient client = new DefaultHttpClient(); HttpMethodWithBody delete = new HttpMethodWithBody("DELETE", driver.getBaseUrl() + "/foo"); delete.setEntity(new StringEntity("A BODY")); HttpResponse response = client.execute(delete); assertThat(response.getStatusLine().getStatusCode(), is(418)); } private class HttpMethodWithBody extends HttpEntityEnclosingRequestBase { private final String method; public HttpMethodWithBody(String method, String uri) { super(); this.method = method; setURI(URI.create(uri)); } @Override public String getMethod() { return method; } } }