Пример #1
0
  @Test
  public void testHttpPostIdentity() throws Exception {
    this.server.registerHandler(
        "*",
        new HttpRequestHandler() {

          public void handle(
              final HttpRequest request, final HttpResponse response, final HttpContext context)
              throws HttpException, IOException {

            if (request instanceof HttpEntityEnclosingRequest) {
              final HttpEntity incoming = ((HttpEntityEnclosingRequest) request).getEntity();
              final byte[] data = EntityUtils.toByteArray(incoming);
              final ByteArrayEntity outgoing = new ByteArrayEntity(data);
              response.setEntity(outgoing);
            } else {
              final StringEntity outgoing = new StringEntity("No content");
              response.setEntity(outgoing);
            }
          }
        });

    this.server.start();

    final DefaultBHttpClientConnection conn = client.createConnection();
    final HttpHost host = new HttpHost("localhost", this.server.getPort());

    try {
      if (!conn.isOpen()) {
        client.connect(host, conn);
      }

      final BasicHttpEntityEnclosingRequest post = new BasicHttpEntityEnclosingRequest("POST", "/");
      post.setEntity(null);

      this.client =
          new HttpClient(
              new ImmutableHttpProcessor(
                  new HttpRequestInterceptor[] {
                    new HttpRequestInterceptor() {

                      public void process(final HttpRequest request, final HttpContext context)
                          throws HttpException, IOException {
                        request.addHeader(HTTP.TRANSFER_ENCODING, "identity");
                      }
                    },
                    new RequestTargetHost(),
                    new RequestConnControl(),
                    new RequestUserAgent(),
                    new RequestExpectContinue(true)
                  }));

      final HttpResponse response = this.client.execute(post, host, conn);
      Assert.assertEquals(HttpStatus.SC_BAD_REQUEST, response.getStatusLine().getStatusCode());
    } finally {
      conn.close();
      this.server.shutdown();
    }
  }
Пример #2
0
  @Test
  public void testNoContentResponse() throws Exception {

    final int reqNo = 20;

    // Initialize the server-side request handler
    this.server.registerHandler(
        "*",
        new HttpRequestHandler() {

          public void handle(
              final HttpRequest request, final HttpResponse response, final HttpContext context)
              throws HttpException, IOException {
            response.setStatusCode(HttpStatus.SC_NO_CONTENT);
          }
        });

    this.server.start();

    final DefaultBHttpClientConnection conn = client.createConnection();
    final HttpHost host = new HttpHost("localhost", this.server.getPort());

    try {
      for (int r = 0; r < reqNo; r++) {
        if (!conn.isOpen()) {
          client.connect(host, conn);
        }

        final BasicHttpRequest get = new BasicHttpRequest("GET", "/?" + r);
        final HttpResponse response = this.client.execute(get, host, conn);
        Assert.assertNull(response.getEntity());
        if (!this.client.keepAlive(response)) {
          conn.close();
          Assert.fail("Connection expected to be re-usable");
        }
      }

      // Verify the connection metrics
      final HttpConnectionMetrics cm = conn.getMetrics();
      Assert.assertEquals(reqNo, cm.getRequestCount());
      Assert.assertEquals(reqNo, cm.getResponseCount());

    } finally {
      conn.close();
      this.server.shutdown();
    }
  }
Пример #3
0
  @Test
  public void testHttpPostNoEntity() throws Exception {
    this.server.registerHandler(
        "*",
        new HttpRequestHandler() {

          public void handle(
              final HttpRequest request, final HttpResponse response, final HttpContext context)
              throws HttpException, IOException {

            if (request instanceof HttpEntityEnclosingRequest) {
              final HttpEntity incoming = ((HttpEntityEnclosingRequest) request).getEntity();
              final byte[] data = EntityUtils.toByteArray(incoming);
              final ByteArrayEntity outgoing = new ByteArrayEntity(data);
              response.setEntity(outgoing);
            } else {
              final StringEntity outgoing = new StringEntity("No content");
              response.setEntity(outgoing);
            }
          }
        });

    this.server.start();

    final DefaultBHttpClientConnection conn = client.createConnection();
    final HttpHost host = new HttpHost("localhost", this.server.getPort());

    try {
      if (!conn.isOpen()) {
        client.connect(host, conn);
      }

      final BasicHttpEntityEnclosingRequest post = new BasicHttpEntityEnclosingRequest("POST", "/");
      post.setEntity(null);

      final HttpResponse response = this.client.execute(post, host, conn);
      Assert.assertEquals(HttpStatus.SC_OK, response.getStatusLine().getStatusCode());
      final byte[] received = EntityUtils.toByteArray(response.getEntity());
      Assert.assertEquals(0, received.length);
    } finally {
      conn.close();
      this.server.shutdown();
    }
  }
Пример #4
0
  @Test
  public void testHttpContent() throws Exception {

    final String[] patterns = {
      "0123456789ABCDEF",
      "yadayada-blahblah-this-and-that-yadayada-blahblah-this-and-that-"
          + "yadayada-blahblah-this-and-that-yadayada-blahblah-this-and-that-"
          + "yadayada-blahblah-this-and-that-yadayada-blahblah-this-and-that-"
          + "yadayada-blahblah-this-and-that-yadayada-blahblah-this-and-that-"
          + "yadayada-blahblah-this-and-that-yadayada-blahblah-this-and-that-"
          + "yadayada-blahblah-this-and-that-yadayada-blahblah-this-and-that-"
          + "yadayada-blahblah-this-and-that-yadayada-blahblah-this-and-that-"
          + "yadayada-blahblah-this-and-that-yadayada-blahblah-this-and-that-"
          + "yadayada-blahblah-this-and-that-yadayada-blahblah-this-and-that-"
          + "yadayada-blahblah-this-and-that-yadayada-blahblah-this-and-that-"
          + "yadayada-blahblah-this-and-that-yadayada-blahblah-this-and-that-"
          + "yadayada-blahblah-this-and-that-yadayada-blahblah-this-and-that-"
          + "yadayada-blahblah-this-and-that-yadayada-blahblah-this-and-that-"
          + "yadayada-blahblah-this-and-that-yadayada-blahblah-this-and-that-"
          + "yadayada-blahblah-this-and-that-yadayada-blahblah-this-and-that"
    };

    // Initialize the server-side request handler
    this.server.registerHandler(
        "*",
        new HttpRequestHandler() {

          public void handle(
              final HttpRequest request, final HttpResponse response, final HttpContext context)
              throws HttpException, IOException {

            if (request instanceof HttpEntityEnclosingRequest) {
              int n = 1;
              String s = request.getRequestLine().getUri();
              if (s.startsWith("/?n=")) {
                s = s.substring(4);
                try {
                  n = Integer.parseInt(s);
                  if (n <= 0) {
                    throw new HttpException(
                        "Invalid request: " + "number of repetitions cannot be negative or zero");
                  }
                } catch (final NumberFormatException ex) {
                  throw new HttpException("Invalid request: " + "number of repetitions is invalid");
                }
              }

              final HttpEntity incoming = ((HttpEntityEnclosingRequest) request).getEntity();
              final String line = EntityUtils.toString(incoming);
              final ContentType contentType = ContentType.getOrDefault(incoming);
              Charset charset = contentType.getCharset();
              if (charset == null) {
                charset = HTTP.DEF_CONTENT_CHARSET;
              }
              final RepeatingEntity outgoing = new RepeatingEntity(line, charset, n);
              outgoing.setChunked(n % 2 == 0);
              response.setEntity(outgoing);
            } else {
              throw new HttpException("Invalid request: POST request expected");
            }
          }
        });

    this.server.start();
    final DefaultBHttpClientConnection conn = client.createConnection();
    final HttpHost host = new HttpHost("localhost", this.server.getPort());

    try {
      for (final String pattern : patterns) {
        for (int n = 1000; n < 1020; n++) {
          if (!conn.isOpen()) {
            client.connect(host, conn);
          }

          final BasicHttpEntityEnclosingRequest post =
              new BasicHttpEntityEnclosingRequest("POST", "/?n=" + n);
          final StringEntity outgoing = new StringEntity(pattern);
          outgoing.setChunked(n % 2 == 0);
          post.setEntity(outgoing);

          final HttpResponse response = this.client.execute(post, host, conn);
          final HttpEntity incoming = response.getEntity();
          Assert.assertNotNull(incoming);
          final InputStream instream = incoming.getContent();
          final ContentType contentType = ContentType.getOrDefault(incoming);
          Charset charset = contentType.getCharset();
          if (charset == null) {
            charset = HTTP.DEF_CONTENT_CHARSET;
          }
          Assert.assertNotNull(instream);
          final BufferedReader reader =
              new BufferedReader(new InputStreamReader(instream, charset));

          String line;
          int count = 0;
          while ((line = reader.readLine()) != null) {
            Assert.assertEquals(pattern, line);
            count++;
          }
          Assert.assertEquals(n, count);
          if (!this.client.keepAlive(response)) {
            conn.close();
          }
        }
      }
    } finally {
      conn.close();
      this.server.shutdown();
    }
  }
Пример #5
0
  /**
   * This test case executes a series of simple POST requests that do not meet the target server
   * expectations.
   */
  @Test
  public void testHttpPostsWithExpectationVerification() throws Exception {

    final int reqNo = 3;

    // Initialize the server-side request handler
    this.server.registerHandler(
        "*",
        new HttpRequestHandler() {

          public void handle(
              final HttpRequest request, final HttpResponse response, final HttpContext context)
              throws HttpException, IOException {

            final StringEntity outgoing = new StringEntity("No content");
            response.setEntity(outgoing);
          }
        });

    this.server.setExpectationVerifier(
        new HttpExpectationVerifier() {

          public void verify(
              final HttpRequest request, final HttpResponse response, final HttpContext context)
              throws HttpException {
            final Header someheader = request.getFirstHeader("Secret");
            if (someheader != null) {
              int secretNumber;
              try {
                secretNumber = Integer.parseInt(someheader.getValue());
              } catch (final NumberFormatException ex) {
                response.setStatusCode(HttpStatus.SC_BAD_REQUEST);
                return;
              }
              if (secretNumber < 2) {
                response.setStatusCode(HttpStatus.SC_EXPECTATION_FAILED);
                final ByteArrayEntity outgoing =
                    new ByteArrayEntity(EncodingUtils.getAsciiBytes("Wrong secret number"));
                response.setEntity(outgoing);
              }
            }
          }
        });

    this.server.start();

    final DefaultBHttpClientConnection conn = client.createConnection();
    final HttpHost host = new HttpHost("localhost", this.server.getPort());

    try {
      for (int r = 0; r < reqNo; r++) {
        if (!conn.isOpen()) {
          client.connect(host, conn);
        }

        final BasicHttpEntityEnclosingRequest post =
            new BasicHttpEntityEnclosingRequest("POST", "/");
        post.addHeader("Secret", Integer.toString(r));
        final ByteArrayEntity outgoing =
            new ByteArrayEntity(EncodingUtils.getAsciiBytes("No content " + r));
        post.setEntity(outgoing);

        final HttpResponse response = this.client.execute(post, host, conn);

        final HttpEntity entity = response.getEntity();
        Assert.assertNotNull(entity);
        EntityUtils.consume(entity);

        if (r < 2) {
          Assert.assertEquals(
              HttpStatus.SC_EXPECTATION_FAILED, response.getStatusLine().getStatusCode());
        } else {
          Assert.assertEquals(HttpStatus.SC_OK, response.getStatusLine().getStatusCode());
        }

        if (!this.client.keepAlive(response)) {
          conn.close();
        }
      }
      // Verify the connection metrics
      final HttpConnectionMetrics cm = conn.getMetrics();
      Assert.assertEquals(reqNo, cm.getRequestCount());
      Assert.assertEquals(reqNo, cm.getResponseCount());
    } finally {
      conn.close();
      this.server.shutdown();
    }
  }
Пример #6
0
  /**
   * This test case executes a series of simple POST requests using the 'expect: continue'
   * handshake.
   */
  @Test
  public void testHttpPostsWithExpectContinue() throws Exception {

    final int reqNo = 20;

    final Random rnd = new Random();

    // Prepare some random data
    final List<byte[]> testData = new ArrayList<byte[]>(reqNo);
    for (int i = 0; i < reqNo; i++) {
      final int size = rnd.nextInt(5000);
      final byte[] data = new byte[size];
      rnd.nextBytes(data);
      testData.add(data);
    }

    // Initialize the server-side request handler
    this.server.registerHandler(
        "*",
        new HttpRequestHandler() {

          public void handle(
              final HttpRequest request, final HttpResponse response, final HttpContext context)
              throws HttpException, IOException {

            if (request instanceof HttpEntityEnclosingRequest) {
              final HttpEntity incoming = ((HttpEntityEnclosingRequest) request).getEntity();
              final byte[] data = EntityUtils.toByteArray(incoming);

              final ByteArrayEntity outgoing = new ByteArrayEntity(data);
              outgoing.setChunked(true);
              response.setEntity(outgoing);
            } else {
              final StringEntity outgoing = new StringEntity("No content");
              response.setEntity(outgoing);
            }
          }
        });

    this.server.start();

    // Activate 'expect: continue' handshake
    final DefaultBHttpClientConnection conn = client.createConnection();
    final HttpHost host = new HttpHost("localhost", this.server.getPort());

    try {
      for (int r = 0; r < reqNo; r++) {
        if (!conn.isOpen()) {
          client.connect(host, conn);
        }

        final BasicHttpEntityEnclosingRequest post =
            new BasicHttpEntityEnclosingRequest("POST", "/");
        final byte[] data = testData.get(r);
        final ByteArrayEntity outgoing = new ByteArrayEntity(data);
        outgoing.setChunked(true);
        post.setEntity(outgoing);

        final HttpResponse response = this.client.execute(post, host, conn);
        final byte[] received = EntityUtils.toByteArray(response.getEntity());
        final byte[] expected = testData.get(r);

        Assert.assertEquals(expected.length, received.length);
        for (int i = 0; i < expected.length; i++) {
          Assert.assertEquals(expected[i], received[i]);
        }
        if (!this.client.keepAlive(response)) {
          conn.close();
        }
      }

      // Verify the connection metrics
      final HttpConnectionMetrics cm = conn.getMetrics();
      Assert.assertEquals(reqNo, cm.getRequestCount());
      Assert.assertEquals(reqNo, cm.getResponseCount());
    } finally {
      conn.close();
      this.server.shutdown();
    }
  }
Пример #7
0
  /** This test case executes a series of simple GET requests */
  @Test
  public void testSimpleBasicHttpRequests() throws Exception {

    final int reqNo = 20;

    final Random rnd = new Random();

    // Prepare some random data
    final List<byte[]> testData = new ArrayList<byte[]>(reqNo);
    for (int i = 0; i < reqNo; i++) {
      final int size = rnd.nextInt(5000);
      final byte[] data = new byte[size];
      rnd.nextBytes(data);
      testData.add(data);
    }

    // Initialize the server-side request handler
    this.server.registerHandler(
        "*",
        new HttpRequestHandler() {

          public void handle(
              final HttpRequest request, final HttpResponse response, final HttpContext context)
              throws HttpException, IOException {

            String s = request.getRequestLine().getUri();
            if (s.startsWith("/?")) {
              s = s.substring(2);
            }
            final int index = Integer.parseInt(s);
            final byte[] data = testData.get(index);
            final ByteArrayEntity entity = new ByteArrayEntity(data);
            response.setEntity(entity);
          }
        });

    this.server.start();

    final DefaultBHttpClientConnection conn = client.createConnection();
    final HttpHost host = new HttpHost("localhost", this.server.getPort());

    try {
      for (int r = 0; r < reqNo; r++) {
        if (!conn.isOpen()) {
          client.connect(host, conn);
        }

        final BasicHttpRequest get = new BasicHttpRequest("GET", "/?" + r);
        final HttpResponse response = this.client.execute(get, host, conn);
        final byte[] received = EntityUtils.toByteArray(response.getEntity());
        final byte[] expected = testData.get(r);

        Assert.assertEquals(expected.length, received.length);
        for (int i = 0; i < expected.length; i++) {
          Assert.assertEquals(expected[i], received[i]);
        }
        if (!this.client.keepAlive(response)) {
          conn.close();
        }
      }

      // Verify the connection metrics
      final HttpConnectionMetrics cm = conn.getMetrics();
      Assert.assertEquals(reqNo, cm.getRequestCount());
      Assert.assertEquals(reqNo, cm.getResponseCount());

    } finally {
      conn.close();
      this.server.shutdown();
    }
  }