public void getHello() throws Exception {
    HttpTester request = makeRequest("GET", "/a/hello");
    HttpTester response = getResponse(request);

    assertEquals(response.getStatus(), 200);
    assertEquals(response.getContent(), "Hello, world");
  }
  public void getSimpleParam() throws Exception {
    HttpTester request = makeRequest("GET", "/a/simple?var=Salomon");
    HttpTester response = getResponse(request);

    assertEquals(response.getStatus(), 200);
    assertEquals(response.getContent(), "v:Salomon");
  }
  public void getMatch() throws Exception {
    HttpTester request = makeRequest("GET", "/b/match-one-two-three");
    HttpTester response = getResponse(request);

    assertEquals(response.getStatus(), 200);
    assertEquals(response.getContent(), "get:one:two:three");
  }
  public void getSimpleConsumes() throws Exception {
    HttpTester request = makeRequest("GET", "/a/simple");
    request.addHeader("content-type", "x-sj-test");
    HttpTester response = getResponse(request);

    assertEquals(response.getStatus(), 200);
    assertEquals(response.getContent(), "Consumes");
  }
  public void getPrint() throws Exception {
    HttpTester request = makeRequest("POST", "/a/print");
    addPost(request, "txt", "hello the world");
    HttpTester response = getResponse(request);

    assertEquals(response.getStatus(), 200);
    assertEquals(response.getContent(), "hello the world");
  }
  public void getSimpleHeader() throws Exception {
    HttpTester request = makeRequest("GET", "/a/simple");
    request.addHeader("x-sj-test", "Salomon");
    HttpTester response = getResponse(request);

    assertEquals(response.getStatus(), 200);
    assertEquals(response.getContent(), "h:Salomon");
  }
  public void getSimpleProduces() throws Exception {
    HttpTester request = makeRequest("GET", "/a/simple");
    request.addHeader("accept", "x-sj-test,xml;");
    HttpTester response = getResponse(request);

    assertEquals(response.getStatus(), 200);
    assertEquals(response.getContent(), "Produces");
  }
  @Test(invocationCount = 3, dataProvider = "requestMethods")
  public void allSimple(String method) throws Exception {
    if (method.equals("HEAD")) return;
    HttpTester request = makeRequest(method, "/a/simple");
    HttpTester response = getResponse(request);

    assertEquals(response.getStatus(), 200);
  }
Example #9
0
 private void dumpHeaders(String prefix, HttpTester http) {
   System.out.println(prefix);
   @SuppressWarnings("unchecked")
   Enumeration<String> names = http.getHeaderNames();
   while (names.hasMoreElements()) {
     String name = names.nextElement();
     String value = http.getHeader(name);
     System.out.printf("  [%s] = %s%n", name, value);
   }
 }
  @Test
  public void testServiceRegistryFunctionsOnJsonRequestBody() throws Exception {
    Map<String, String> initParams = new HashMap<String, String>();
    initParams.put("request.body", "oozie-conf");
    setUp("test-user", initParams);

    String input =
        TestUtils.getResourceString(
            ServiceRegistryFunctionsTest.class, "test-input-body.json", "UTF-8");
    String expect =
        TestUtils.getResourceString(
            ServiceRegistryFunctionsTest.class, "test-expect-body.json", "UTF-8");

    // Setup the server side request/response interaction.
    interaction
        .expect()
        .method("PUT")
        .requestUrl("http://test-host:42/test-path")
        .contentType("application/json")
        .characterEncoding("UTF-8")
        .content(expect, Charset.forName("UTF-8"));
    interaction.respond().status(200);
    interactions.add(interaction);
    request.setMethod("PUT");
    request.setURI("/test-path");
    request.setVersion("HTTP/1.1");
    request.setHeader("Host", "test-host:42");
    request.setContentType("application/json; charset=UTF-8");
    request.setContent(input);

    response.parse(server.getResponses(request.generate()));

    // Test the results.
    assertThat(response.getStatus(), Is.is(200));
  }
Example #11
0
  @Test
  public void testCreateToken401() throws Exception {
    HttpTester req = new HttpTester();
    req.setMethod("POST");
    req.setHeader("Content-Type", "application/x-www-form-urlencoded");
    req.setContent(DIRECT_AUTH);
    req.setURI(CONTEXT + TokenEndpoint.TOKEN_GRANT_ENDPOINT);
    req.setVersion("HTTP/1.0");

    HttpTester resp = new HttpTester();
    resp.parse(server.getResponses(req.generate()));
    assertEquals(401, resp.getStatus());
  }
Example #12
0
 private void assertResponseHeaders(int expectedFilesize, int status, HttpTester response) {
   Assert.assertThat("Response.method", response.getMethod(), nullValue());
   Assert.assertThat("Response.status", response.getStatus(), is(status));
   if (expectedFilesize != (-1)) {
     Assert.assertThat(
         "Response.header[Content-Length]", response.getHeader("Content-Length"), notNullValue());
     int serverLength = Integer.parseInt(response.getHeader("Content-Length"));
     Assert.assertThat("Response.header[Content-Length]", serverLength, is(expectedFilesize));
   }
   Assert.assertThat(
       "Response.header[Content-Encoding]",
       response.getHeader("Content-Encoding"),
       not(containsString(compressionType)));
 }
Example #13
0
  @Test
  public void testDeleteToken() throws Exception {
    when(ServiceLocator.getInstance().getTokenStore().delete("token_to_be_deleted"))
        .thenReturn(true);

    HttpTester req = new HttpTester();
    req.setMethod("POST");
    req.setHeader("Content-Type", "application/x-www-form-urlencoded");
    req.setContent("token_to_be_deleted");
    req.setURI(CONTEXT + TokenEndpoint.TOKEN_REVOKE_ENDPOINT);
    req.setVersion("HTTP/1.0");

    HttpTester resp = new HttpTester();
    resp.parse(server.getResponses(req.generate()));
    assertEquals(204, resp.getStatus());
  }
Example #14
0
  private HttpTester executeRequest(String uri) throws IOException, Exception {
    System.err.printf("[GzipTester] requesting %s%n", uri);
    HttpTester request = new HttpTester();
    HttpTester response = new HttpTester();

    request.setMethod("GET");
    request.setVersion("HTTP/1.0");
    request.setHeader("Host", "tester");
    request.setHeader("Accept-Encoding", compressionType);
    if (this.userAgent != null) request.setHeader("User-Agent", this.userAgent);

    request.setURI(uri);

    // Issue the request
    ByteArrayBuffer reqsBuff = new ByteArrayBuffer(request.generate().getBytes());
    // Collect the response(s)
    ByteArrayBuffer respBuff = servletTester.getResponses(reqsBuff);
    response.parse(respBuff.asArray());
    return response;
  }
Example #15
0
  private String readResponse(HttpTester response)
      throws IOException, UnsupportedEncodingException {
    String actual = null;
    InputStream in = null;
    ByteArrayOutputStream out = null;
    try {
      in = new ByteArrayInputStream(response.getContentBytes());
      out = new ByteArrayOutputStream();
      IO.copy(in, out);

      actual = out.toString(encoding);
    } finally {
      IO.close(out);
      IO.close(in);
    }
    return actual;
  }
Example #16
0
  @Test
  public void testCreateTokenWithPassword() throws Exception {
    when(ServiceLocator.getInstance()
            .getCredentialAuth()
            .authenticate(any(PasswordCredentials.class)))
        .thenReturn(claim);

    HttpTester req = new HttpTester();
    req.setMethod("POST");
    req.setHeader("Content-Type", "application/x-www-form-urlencoded");
    req.setContent(DIRECT_AUTH);
    req.setURI(CONTEXT + TokenEndpoint.TOKEN_GRANT_ENDPOINT);
    req.setVersion("HTTP/1.0");

    HttpTester resp = new HttpTester();
    resp.parse(server.getResponses(req.generate()));
    assertEquals(201, resp.getStatus());
    assertTrue(resp.getContent().contains("expires_in\":10"));
    assertTrue(resp.getContent().contains("Bearer"));
  }
Example #17
0
  @Test
  public void testCreateTokenWithRefreshToken() throws Exception {
    when(ServiceLocator.getInstance().getTokenStore().get(anyString()))
        .thenReturn(new AuthenticationBuilder(claim).build());
    when(ServiceLocator.getInstance().getIdmService().listRoles(anyString(), anyString()))
        .thenReturn(Arrays.asList("admin", "user"));

    HttpTester req = new HttpTester();
    req.setMethod("POST");
    req.setHeader("Content-Type", "application/x-www-form-urlencoded");
    req.setContent(REFRESH_TOKEN);
    req.setURI(CONTEXT + TokenEndpoint.TOKEN_GRANT_ENDPOINT);
    req.setVersion("HTTP/1.0");

    HttpTester resp = new HttpTester();
    resp.parse(server.getResponses(req.generate()));
    assertEquals(201, resp.getStatus());
    assertTrue(resp.getContent().contains("expires_in\":10"));
    assertTrue(resp.getContent().contains("Bearer"));
  }
Example #18
0
  public void assertIsResponseGzipCompressed(String requestedFilename, String serverFilename)
      throws Exception {
    System.err.printf("[GzipTester] requesting /context/%s%n", requestedFilename);
    HttpTester request = new HttpTester();
    HttpTester response = new HttpTester();

    request.setMethod("GET");
    request.setVersion("HTTP/1.0");
    request.setHeader("Host", "tester");
    request.setHeader("Accept-Encoding", compressionType);
    if (this.userAgent != null) request.setHeader("User-Agent", this.userAgent);
    request.setURI("/context/" + requestedFilename);

    // Issue the request
    ByteArrayBuffer reqsBuff = new ByteArrayBuffer(request.generate().getBytes());
    // Collect the response(s)
    ByteArrayBuffer respBuff = servletTester.getResponses(reqsBuff);
    response.parse(respBuff.asArray());

    // Assert the response headers
    Assert.assertThat("Response.method", response.getMethod(), nullValue());
    //
    // Assert.assertThat("Response.status",response.getStatus(),is(HttpServletResponse.SC_OK));
    Assert.assertThat(
        "Response.header[Content-Length]", response.getHeader("Content-Length"), notNullValue());
    Assert.assertThat(
        "Response.header[Content-Encoding]",
        response.getHeader("Content-Encoding"),
        containsString(compressionType));

    // Assert that the decompressed contents are what we expect.
    File serverFile = testdir.getFile(serverFilename);
    String expected = IO.readToString(serverFile);
    String actual = null;

    ByteArrayInputStream bais = null;
    InputStream in = null;
    ByteArrayOutputStream out = null;
    try {
      bais = new ByteArrayInputStream(response.getContentBytes());
      if (compressionType.equals(GzipFilter.GZIP)) {
        in = new GZIPInputStream(bais);
      } else if (compressionType.equals(GzipFilter.DEFLATE)) {
        in = new InflaterInputStream(bais, new Inflater(true));
      }
      out = new ByteArrayOutputStream();
      IO.copy(in, out);

      actual = out.toString(encoding);
      assertThat("Uncompressed contents", actual, equalTo(expected));
    } finally {
      IO.close(out);
      IO.close(in);
      IO.close(bais);
    }
  }
  public void getExpect404() throws Exception {
    HttpTester request = makeRequest("GET", "/a/not-existing");
    HttpTester response = getResponse(request);

    assertEquals(response.getStatus(), 404);
  }
  public void getInvalidMethod() throws Exception {
    HttpTester request = makeRequest("GET", "/a/print");
    HttpTester response = getResponse(request);

    assertEquals(response.getStatus(), 404);
  }
  public void postMissingArgument() throws Exception {
    HttpTester request = makeRequest("POST", "/a/print");
    HttpTester response = getResponse(request);

    assertEquals(response.getStatus(), 400);
  }
Example #22
0
 protected void processRequest() throws Exception {
   response.parse(tester.getResponses(request.generate()));
 }
Example #23
0
  /**
   * Makes sure that the response contains an unfiltered file contents.
   *
   * <p>This is used to test exclusions and passthroughs in the GzipFilter.
   *
   * <p>An example is to test that it is possible to configure GzipFilter to not recompress content
   * that shouldn't be compressed by the GzipFilter.
   *
   * @param requestedFilename the filename used to on the GET request,.
   * @param testResourceSha1Sum the sha1sum file that contains the SHA1SUM checksum that will be
   *     used to verify that the response contents are what is intended.
   * @param expectedContentType
   */
  public void assertIsResponseNotGzipFiltered(
      String requestedFilename, String testResourceSha1Sum, String expectedContentType)
      throws Exception {
    System.err.printf("[GzipTester] requesting /context/%s%n", requestedFilename);
    HttpTester request = new HttpTester();
    HttpTester response = new HttpTester();

    request.setMethod("GET");
    request.setVersion("HTTP/1.0");
    request.setHeader("Host", "tester");
    request.setHeader("Accept-Encoding", compressionType);
    if (this.userAgent != null) request.setHeader("User-Agent", this.userAgent);
    request.setURI("/context/" + requestedFilename);

    // Issue the request
    ByteArrayBuffer reqsBuff = new ByteArrayBuffer(request.generate().getBytes());
    // Collect the response(s)
    ByteArrayBuffer respBuff = servletTester.getResponses(reqsBuff);
    response.parse(respBuff.asArray());

    dumpHeaders(requestedFilename + " / Response Headers", response);

    // Assert the response headers
    String prefix = requestedFilename + " / Response";
    Assert.assertThat(prefix + ".method", response.getMethod(), nullValue());
    Assert.assertThat(prefix + ".status", response.getStatus(), is(HttpServletResponse.SC_OK));
    Assert.assertThat(
        prefix + ".header[Content-Length]", response.getHeader("Content-Length"), notNullValue());
    Assert.assertThat(
        prefix + ".header[Content-Encoding] (should not be recompressed by GzipFilter)",
        response.getHeader("Content-Encoding"),
        nullValue());
    Assert.assertThat(
        prefix + ".header[Content-Type] (should have a Content-Type associated with it)",
        response.getHeader("Content-Type"),
        notNullValue());
    Assert.assertThat(
        prefix + ".header[Content-Type]",
        response.getHeader("Content-Type"),
        is(expectedContentType));

    ByteArrayInputStream bais = null;
    DigestOutputStream digester = null;
    try {
      MessageDigest digest = MessageDigest.getInstance("SHA1");
      bais = new ByteArrayInputStream(response.getContentBytes());
      digester = new DigestOutputStream(new NoOpOutputStream(), digest);
      IO.copy(bais, digester);

      String actualSha1Sum = Hex.asHex(digest.digest());
      String expectedSha1Sum = loadExpectedSha1Sum(testResourceSha1Sum);
      Assert.assertEquals(
          requestedFilename + " / SHA1Sum of content", expectedSha1Sum, actualSha1Sum);
    } finally {
      IO.close(digester);
      IO.close(bais);
    }
  }