org.apache.http.client.methods.HttpTrace Java Examples

/**
 * Create a Commons HttpMethodBase object for the given HTTP method and URI specification.
 * @param httpMethod the HTTP method
 * @param uri the URI
 * @return the Commons HttpMethodBase object
 */
protected HttpUriRequest createHttpUriRequest(HttpMethod httpMethod, URI uri) {
	switch (httpMethod) {
		case GET:
			return new HttpGet(uri);
		case HEAD:
			return new HttpHead(uri);
		case POST:
			return new HttpPost(uri);
		case PUT:
			return new HttpPut(uri);
		case PATCH:
			return new HttpPatch(uri);
		case DELETE:
			return new HttpDelete(uri);
		case OPTIONS:
			return new HttpOptions(uri);
		case TRACE:
			return new HttpTrace(uri);
		default:
			throw new IllegalArgumentException("Invalid HTTP method: " + httpMethod);
	}
}
 

/**
 * <p>Retrieves the proper extension of {@link HttpRequestBase} for the given {@link InvocationContext}. 
 * This implementation is solely dependent upon the {@link RequestMethod} property in the annotated 
 * metdata of the endpoint method definition.</p>
 *
 * @param context
 * 			the {@link InvocationContext} for which a {@link HttpRequestBase} is to be generated 
 * <br><br>
 * @return the {@link HttpRequestBase} translated from the {@link InvocationContext}'s {@link RequestMethod}
 * <br><br>
 * @throws NullPointerException
 * 			if the supplied {@link InvocationContext} was {@code null} 
 * <br><br>
 * @since 1.3.0
 */
static HttpRequestBase translateRequestMethod(InvocationContext context) {
	
	RequestMethod requestMethod = Metadata.findMethod(assertNotNull(context).getRequest());
	
	switch (requestMethod) {
	
		case POST: return new HttpPost();
		case PUT: return new HttpPut();
		case PATCH: return new HttpPatch();
		case DELETE: return new HttpDelete();
		case HEAD: return new HttpHead();
		case TRACE: return new HttpTrace();
		case OPTIONS: return new HttpOptions();
		
		case GET: default: return new HttpGet();
	}
}
 

private HttpUriRequest resolveMethod( String _method, boolean _multipart ) throws cfmRunTimeException {
	String method = _method.toUpperCase();
	if ( method.equals( "GET" ) ) {
		return new HttpGet();
	} else if ( method.equals( "POST" ) ) {
		return new HttpPost();
	} else if ( method.equals( "HEAD" ) ) {
		return new HttpHead();
	} else if ( method.equals( "TRACE" ) ) {
		return new HttpTrace();
	} else if ( method.equals( "DELETE" ) ) {
		return new HttpDelete();
	} else if ( method.equals( "OPTIONS" ) ) {
		return new HttpOptions();
	} else if ( method.equals( "PUT" ) ) {
		return new HttpPut();
	} else if ( method.equals( "PATCH" ) ) {
		return new HttpPatch();
	}
	throw newRunTimeException( "Unsupported METHOD value [" + method + "]. Valid METHOD values are GET, POST, HEAD, TRACE, DELETE, OPTIONS, PATCH and PUT." );
}
 

protected HttpUriRequest buildHttpRequest(Method method, URI uri) {
    switch (method) {
        case OPTIONS:
            return new HttpOptions(uri);
        case GET:
            return new HttpGet(uri);
        case HEAD:
            return new HttpHead(uri);
        case POST:
            return new HttpPost(uri);
        case PUT:
            return new HttpPut(uri);
        case DELETE:
            return new HttpDelete(uri);
        case TRACE:
            return new HttpTrace(uri);
        case PATCH:
            return new HttpPatch(uri);
        default:
            throw new IllegalArgumentException("Method " + method + " is not implemented!");
    }
}
 

/**
 * Create a Commons HttpMethodBase object for the given HTTP method and URI specification.
 * @param method the HTTP method
 * @param uri the URI
 * @return the Commons HttpMethodBase object
 */
private static HttpUriRequest createHttpUriRequest(String method, URI uri) {
    switch (method) {
        case "GET":
            return new HttpGet(uri);
        case "HEAD":
            return new HttpHead(uri);
        case "POST":
            return new HttpPost(uri);
        case "PUT":
            return new HttpPut(uri);
        case "PATCH":
            return new HttpPatch(uri);
        case "DELETE":
            return new HttpDelete(uri);
        case "OPTIONS":
            return new HttpOptions(uri);
        case "TRACE":
            return new HttpTrace(uri);
        default:
            throw new IllegalArgumentException("Invalid HTTP method: " + method);
    }
}
 

@Test
public void requireThatServerRespondsToAllMethods() throws Exception {
    final TestDriver driver = TestDrivers.newInstance(newEchoHandler());
    final URI uri = driver.client().newUri("/status.html");
    driver.client().execute(new HttpGet(uri))
          .expectStatusCode(is(OK));
    driver.client().execute(new HttpPost(uri))
          .expectStatusCode(is(OK));
    driver.client().execute(new HttpHead(uri))
          .expectStatusCode(is(OK));
    driver.client().execute(new HttpPut(uri))
          .expectStatusCode(is(OK));
    driver.client().execute(new HttpDelete(uri))
          .expectStatusCode(is(OK));
    driver.client().execute(new HttpOptions(uri))
          .expectStatusCode(is(OK));
    driver.client().execute(new HttpTrace(uri))
          .expectStatusCode(is(OK));
    driver.client().execute(new HttpPatch(uri))
            .expectStatusCode(is(OK));
    assertThat(driver.close(), is(true));
}
 

/**
 * Create a Commons HttpMethodBase object for the given HTTP method and URI specification.
 * @param httpMethod the HTTP method
 * @param uri the URI
 * @return the Commons HttpMethodBase object
 */
protected HttpUriRequest createHttpUriRequest(HttpMethod httpMethod, URI uri) {
	switch (httpMethod) {
		case GET:
			return new HttpGet(uri);
		case HEAD:
			return new HttpHead(uri);
		case POST:
			return new HttpPost(uri);
		case PUT:
			return new HttpPut(uri);
		case PATCH:
			return new HttpPatch(uri);
		case DELETE:
			return new HttpDelete(uri);
		case OPTIONS:
			return new HttpOptions(uri);
		case TRACE:
			return new HttpTrace(uri);
		default:
			throw new IllegalArgumentException("Invalid HTTP method: " + httpMethod);
	}
}
 

/**
 * Create a Commons HttpMethodBase object for the given HTTP method and URI specification.
 * @param httpMethod the HTTP method
 * @param uri the URI
 * @return the Commons HttpMethodBase object
 */
protected HttpUriRequest createHttpUriRequest(HttpMethod httpMethod, URI uri) {
	switch (httpMethod) {
		case GET:
			return new HttpGet(uri);
		case HEAD:
			return new HttpHead(uri);
		case POST:
			return new HttpPost(uri);
		case PUT:
			return new HttpPut(uri);
		case PATCH:
			return new HttpPatch(uri);
		case DELETE:
			return new HttpDelete(uri);
		case OPTIONS:
			return new HttpOptions(uri);
		case TRACE:
			return new HttpTrace(uri);
		default:
			throw new IllegalArgumentException("Invalid HTTP method: " + httpMethod);
	}
}
 

/**
 * Create a Commons HttpMethodBase object for the given HTTP method and URI specification.
 * @param httpMethod the HTTP method
 * @param uri the URI
 * @return the Commons HttpMethodBase object
 */
protected HttpUriRequest createHttpUriRequest(HttpMethod httpMethod, URI uri) {
	switch (httpMethod) {
		case GET:
			return new HttpGet(uri);
		case HEAD:
			return new HttpHead(uri);
		case POST:
			return new HttpPost(uri);
		case PUT:
			return new HttpPut(uri);
		case PATCH:
			return new HttpPatch(uri);
		case DELETE:
			return new HttpDelete(uri);
		case OPTIONS:
			return new HttpOptions(uri);
		case TRACE:
			return new HttpTrace(uri);
		default:
			throw new IllegalArgumentException("Invalid HTTP method: " + httpMethod);
	}
}
 

static Stream<Arguments> successfulEmptyRequestCreation()
{
    return Stream.of(
            Arguments.of(HttpMethod.GET, HttpGet.class),
            Arguments.of(HttpMethod.HEAD, HttpHead.class),
            Arguments.of(HttpMethod.DELETE, HttpDelete.class),
            Arguments.of(HttpMethod.OPTIONS, HttpOptions.class),
            Arguments.of(HttpMethod.TRACE, HttpTrace.class),
            Arguments.of(HttpMethod.POST, HttpPost.class),
            Arguments.of(HttpMethod.PUT, HttpPutWithoutBody.class),
            Arguments.of(HttpMethod.DEBUG, HttpDebug.class)
    );
}
 

@Test public void createTraceRequest() throws Exception {
    TestRequest.Trace request = new TestRequest.Trace();
    assertEquals(request.getMethod(), Method.TRACE);

    HttpUriRequest httpRequest = HttpClientStack.createHttpRequest(request, null);
    assertTrue(httpRequest instanceof HttpTrace);
}
 

@Test public void createTraceRequest() throws Exception {
    TestRequest.Trace request = new TestRequest.Trace();
    assertEquals(request.getMethod(), Method.TRACE);

    HttpUriRequest httpRequest = HttpClientStack.createHttpRequest(request, null);
    assertTrue(httpRequest instanceof HttpTrace);
}
 

@Test
public void testTrace() throws Exception {
    final HttpURLConnection connection = getConnection();
    connection.setRequestMethod(HttpTrace.METHOD_NAME);
    connection.connect();
    assertEquals(HttpURLConnection.HTTP_UNAUTHORIZED, connection.getResponseCode());
}
 

/**
 * Creates the appropriate subclass of HttpUriRequest for passed in request.
 */
static HttpRequestBase createHttpRequest(
        Request<?> request, Map<String, String> additionalHeaders) {
    switch (request.getMethod()) {
        case Request.Method.GET:
            return new HttpGet(request.getUrlString());
        case Request.Method.DELETE:
            return new HttpDelete(request.getUrlString());
        case Request.Method.POST: {
            HttpPost postRequest = new HttpPost(request.getUrlString());
            postRequest.addHeader(HEADER_CONTENT_TYPE, request.getBodyContentType());
            setEntityIfNonEmptyBody(postRequest, request);
            return postRequest;
        }
        case Request.Method.PUT: {
            HttpPut putRequest = new HttpPut(request.getUrlString());
            putRequest.addHeader(HEADER_CONTENT_TYPE, request.getBodyContentType());
            setEntityIfNonEmptyBody(putRequest, request);
            return putRequest;
        }
        case Request.Method.HEAD:
            return new HttpHead(request.getUrlString());
        case Request.Method.OPTIONS:
            return new HttpOptions(request.getUrlString());
        case Request.Method.TRACE:
            return new HttpTrace(request.getUrlString());
        case Request.Method.PATCH: {
            HttpPatch patchRequest = new HttpPatch(request.getUrlString());
            patchRequest.addHeader(HEADER_CONTENT_TYPE, request.getBodyContentType());
            setEntityIfNonEmptyBody(patchRequest, request);
            return patchRequest;
        }
        default:
            throw new IllegalStateException("Unknown request method.");
    }
}
 

@Override
public HttpResponse Trace(final String uri) throws IOException {
    DefaultHttpClient client = new DefaultHttpClient();
    client.setRedirectStrategy(new LaxRedirectStrategy());
    final HttpTrace trace = new HttpTrace(uri);
    final HttpResponse response = client.execute(trace);
    return response;
}
 

@Override
public HttpUriRequest getRedirect(
        final HttpRequest request,
        final HttpResponse response,
        final HttpContext context) throws ProtocolException {
    URI uri = null;
    try {
        uri = getLocationURI(request, response, context);
    } catch (URISyntaxException ex) {
        Logger.getLogger(CustomRedirectStrategy.class.getName()).log(Level.SEVERE, null, ex);
    }
    String method = request.getRequestLine().getMethod();
    if (method.equalsIgnoreCase(HttpHead.METHOD_NAME)) {
        return new HttpHead(uri);
    } else if (method.equalsIgnoreCase(HttpGet.METHOD_NAME)) {
        return new HttpGet(uri);
    } else {
        int status = response.getStatusLine().getStatusCode();
        if (status == HttpStatus.SC_TEMPORARY_REDIRECT) {
            if (method.equalsIgnoreCase(HttpPost.METHOD_NAME)) {
                return copyEntity(new HttpPost(uri), request);
            } else if (method.equalsIgnoreCase(HttpPut.METHOD_NAME)) {
                return copyEntity(new HttpPut(uri), request);
            } else if (method.equalsIgnoreCase(HttpDelete.METHOD_NAME)) {
                return new HttpDelete(uri);
            } else if (method.equalsIgnoreCase(HttpTrace.METHOD_NAME)) {
                return new HttpTrace(uri);
            } else if (method.equalsIgnoreCase(HttpOptions.METHOD_NAME)) {
                return new HttpOptions(uri);
            } else if (method.equalsIgnoreCase(HttpPatch.METHOD_NAME)) {
                return copyEntity(new HttpPatch(uri), request);
            }
        }
        return new HttpGet(uri);
    }
}
 

@Test public void createTraceRequest() throws Exception {
    TestRequest.Trace request = new TestRequest.Trace();
    assertEquals(request.getMethod(), Method.TRACE);

    HttpUriRequest httpRequest = HttpClientStack.createHttpRequest(request, null);
    assertTrue(httpRequest instanceof HttpTrace);
}
 

@Test public void createTraceRequest() throws Exception {
    TestRequest.Trace request = new TestRequest.Trace();
    assertEquals(request.getMethod(), Method.TRACE);

    HttpUriRequest httpRequest = HttpClientStack.createHttpRequest(request, null);
    assertTrue(httpRequest instanceof HttpTrace);
}
 

@Test
public void createTraceRequest() throws Exception {
    TestRequest.Trace request = new TestRequest.Trace();
    assertEquals(request.getMethod(), Method.TRACE);

    HttpUriRequest httpRequest = HttpClientStack.createHttpRequest(request, null);
    assertTrue(httpRequest instanceof HttpTrace);
}
 

public void testCreateTraceRequest() throws Exception {
    TestRequest.Trace request = new TestRequest.Trace();
    assertEquals(request.getMethod(), Method.TRACE);

    HttpUriRequest httpRequest = HttpClientStack.createHttpRequest(request, null);
    assertTrue(httpRequest instanceof HttpTrace);
}
 

@Test public void createTraceRequest() throws Exception {
    TestRequest.Trace request = new TestRequest.Trace();
    assertEquals(request.getMethod(), Method.TRACE);

    HttpUriRequest httpRequest = HttpClientStack.createHttpRequest(request, null);
    assertTrue(httpRequest instanceof HttpTrace);
}
 

@Override
public HttpResponse trace(final String url) throws HttpClientException {
    return process(new HttpTrace(url));
}
 

@Override
public HttpResponse trace(final String url, final Map<String, String> params) throws HttpClientException {
    return process(createBase(HttpTrace.class, url, params));
}
 

@Override
public HttpResponse trace(final String url, final Map<String, String> headers, final Map<String, String> params) throws HttpClientException {
    return process(createBase(HttpTrace.class, url, headers, params));
}
 

@Test(expectedExceptions = PropagatedRuntimeException.class)
public void testHttpRequestBuilderThrowsExIfBodySetForTrace() throws Exception {
    new HttpTool.HttpRequestBuilder<>(HttpTrace.class).body("test").build();
}