javax.ws.rs.core.Response

Here are the examples of the java api class javax.ws.rs.core.Response taken from open source projects.

@Test
public void testJackson() throws Exception {
    WebTarget target = client.target(generateURL("/products/333"));
    Response response = target.request().get();
    Product p = response.readEntity(Product.class);
    Assert.assertEquals(333, p.getId());
    Assert.assertEquals("Iphone", p.getName());
    response.close();
    target = client.target(generateURL("/products"));
    Response response2 = target.request().get();
    System.out.println(response2.readEntity(String.class));
    Assert.assertEquals(200, response2.getStatus());
    response2.close();
    target = client.target(generateURL("/products/333"));
    response = target.request().post(Entity.entity(p, "application/foo+json"));
    p = response.readEntity(Product.class);
    Assert.assertEquals(333, p.getId());
    Assert.assertEquals("Iphone", p.getName());
    response.close();
}

@Test
public void testJackson() throws Exception {
    WebTarget target = client.target(generateURL("/products/333"));
    Response response = target.request().get();
    Product p = response.readEntity(Product.class);
    Assert.assertEquals(333, p.getId());
    Assert.assertEquals("Iphone", p.getName());
    response.close();
    target = client.target(generateURL("/products"));
    Response response2 = target.request().get();
    String entity2 = response2.readEntity(String.class);
    System.out.println(entity2);
    Assert.assertEquals(200, response2.getStatus());
    response2.close();
    target = client.target(generateURL("/products/333"));
    response = target.request().post(Entity.entity(p, "application/foo+json"));
    p = response.readEntity(Product.class);
    Assert.assertEquals(333, p.getId());
    Assert.assertEquals("Iphone", p.getName());
    response.close();
}

@Test
public void testDifferentVerbs() throws Exception {
    Client client = ClientBuilder.newClient();
    Response response = client.target(generateURL("/verbs")).request().accept(MediaType.TEXT_PLAIN).get();
    response.close();
    Assert.assertEquals("Incorrectly logged " + MESSAGE_CODE, 0, logHandler.messagesLogged);
    response = client.target(generateURL("/verbs")).request().accept(MediaType.TEXT_PLAIN, MediaType.WILDCARD).get();
    response.close();
    Assert.assertEquals("Incorrectly logged " + MESSAGE_CODE, 0, logHandler.messagesLogged);
    response = client.target(generateURL("/verbs")).request().get();
    response.close();
    Assert.assertEquals("Incorrectly logged " + MESSAGE_CODE, 0, logHandler.messagesLogged);
}

@Test
public void testUnique() throws Exception {
    Client client = ClientBuilder.newClient();
    Response response = client.target(generateURL("/unique")).request().accept(MediaType.TEXT_PLAIN, MediaType.WILDCARD).get();
    response.close();
    Assert.assertEquals("Incorrectly logged " + MESSAGE_CODE, 0, logHandler.messagesLogged);
    response = client.target(generateURL("/unique")).request().get();
    response.close();
    Assert.assertEquals("Incorrectly logged " + MESSAGE_CODE, 0, logHandler.messagesLogged);
    response = client.target(generateURL("/unique")).request().accept(MediaType.TEXT_PLAIN).get();
    response.close();
    Assert.assertEquals("Incorrectly logged " + MESSAGE_CODE, 0, logHandler.messagesLogged);
}

@Test
public void testXmlString() throws Exception {
    WebTarget target = client.target(generateURL("/xml/products/333"));
    Response response = target.request().get();
    String entity = response.readEntity(String.class);
    System.out.println(entity);
    Assert.assertEquals(200, response.getStatus());
    Assert.assertTrue(entity.startsWith("{\"product"));
    response.close();
    target = client.target(generateURL("/xml/products"));
    Response response2 = target.request().get();
    String entity2 = response2.readEntity(String.class);
    System.out.println(entity2);
    Assert.assertEquals(200, response2.getStatus());
    Assert.assertTrue(entity2.startsWith("[{\"product"));
    response2.close();
}

@Test
public void testJacksonString() throws Exception {
    WebTarget target = client.target(generateURL("/products/333"));
    Response response = target.request().get();
    String entity = response.readEntity(String.class);
    System.out.println(entity);
    Assert.assertEquals(200, response.getStatus());
    Assert.assertEquals("{\"name\":\"Iphone\",\"id\":333}", entity);
    response.close();
    target = client.target(generateURL("/products"));
    Response response2 = target.request().get();
    String entity2 = response2.readEntity(String.class);
    System.out.println(entity2);
    Assert.assertEquals(200, response2.getStatus());
    Assert.assertEquals("[{\"name\":\"Iphone\",\"id\":333},{\"name\":\"macbook\",\"id\":44}]", entity2);
    response2.close();
}

@Test
public void testXmlString() throws Exception {
    WebTarget target = client.target(generateURL("/xml/products/333"));
    Response response = target.request().get();
    String entity = response.readEntity(String.class);
    System.out.println(entity);
    Assert.assertEquals(200, response.getStatus());
    Assert.assertTrue(entity.startsWith("{\"product"));
    response.close();
    target = client.target(generateURL("/xml/products"));
    Response response2 = target.request().get();
    String entity2 = response2.readEntity(String.class);
    System.out.println(entity2);
    Assert.assertEquals(200, response2.getStatus());
    Assert.assertTrue(entity2.startsWith("[{\"product"));
    response2.close();
}

@Test
public void testJacksonString() throws Exception {
    WebTarget target = client.target(generateURL("/products/333"));
    Response response = target.request().get();
    String entity = response.readEntity(String.class);
    System.out.println(entity);
    Assert.assertEquals(200, response.getStatus());
    Assert.assertEquals("{\"name\":\"Iphone\",\"id\":333}", entity);
    response.close();
    target = client.target(generateURL("/products"));
    Response response2 = target.request().get();
    String entity2 = response2.readEntity(String.class);
    System.out.println(entity2);
    Assert.assertEquals(200, response2.getStatus());
    Assert.assertEquals("[{\"name\":\"Iphone\",\"id\":333},{\"name\":\"macbook\",\"id\":44}]", entity2);
    response2.close();
}

@Test
public void testCustomerResource() throws Exception {
    WebTarget customerTarget = client.target("http://localhost:8080/services/customers/1");
    Response response = customerTarget.request().get();
    Assert.assertEquals(200, response.getStatus());
    Customer cust = response.readEntity(Customer.class);
    EntityTag etag = response.getEntityTag();
    response.close();
    System.out.println("Doing a conditional GET with ETag: " + etag.toString());
    response = customerTarget.request().header("If-None-Match", etag).get();
    Assert.assertEquals(304, response.getStatus());
    response.close();
    // Update and send a bad etag with conditional PUT
    cust.setCity("Bedford");
    response = customerTarget.request().header("If-Match", "JUNK").put(Entity.xml(cust));
    Assert.assertEquals(412, response.getStatus());
    response.close();
}

@Test
public void testToInputStream() throws Exception {
    CamelContext context = new DefaultCamelContext();
    Exchange exchange = new DefaultExchange(context);
    Response response = EasyMock.createMock(Response.class);
    InputStream is = EasyMock.createMock(InputStream.class);
    response.getEntity();
    EasyMock.expectLastCall().andReturn(is);
    EasyMock.replay(response);
    InputStream result = CxfConverter.toInputStream(response, exchange);
    assertEquals("We should get the inputStream here ", is, result);
    EasyMock.verify(response);
    EasyMock.reset(response);
    response.getEntity();
    EasyMock.expectLastCall().andReturn("Hello World");
    EasyMock.replay(response);
    result = CxfConverter.toInputStream(response, exchange);
    assertTrue("We should get the inputStream here ", result instanceof ByteArrayInputStream);
    EasyMock.verify(response);
}

@Test
public void testHead() {
    // mucks up stream so create our own client.
    //Client client = ClientBuilder.newClient();
    Response response = client.target(generateURL("/head")).request().head();
    Assert.assertEquals(200, response.getStatus());
    if (response.hasEntity()) {
        String str = response.readEntity(String.class);
    }
    response.close();
//client.close();
}

@Test
public void testClientResponse() throws Exception {
    Client proxy = client.target(generateBaseUrl()).proxy(Client.class);
    Assert.assertEquals("basic", proxy.getBasic());
    Assert.assertEquals("basic", proxy.getForwardBasic());
    Assert.assertEquals("object1", proxy.getObject(1).readEntity(String.class));
    Assert.assertEquals("object1", proxy.getForwardedObject(1).readEntity(String.class));
    Response cr = proxy.getObject(0);
    Assert.assertEquals(Response.Status.NO_CONTENT.getStatusCode(), cr.getStatus());
    cr.close();
    cr = proxy.getForwardedObject(0);
    Assert.assertEquals(Response.Status.NO_CONTENT.getStatusCode(), cr.getStatus());
    cr.close();
    proxy.putForwardBasic("testBasic");
    Assert.assertEquals("testBasic", proxy.getBasic());
    proxy.postForwardBasic("testBasic1");
    Assert.assertEquals("testBasic1", proxy.getBasic());
    proxy.deleteForwardBasic();
    Assert.assertEquals("basic", proxy.getBasic());
}

@Test
public void testJBEAP2138() throws Exception {
    Client client = ClientBuilder.newClient();
    WebTarget target = client.target(TestPortProvider.generateURL("/test"));
    Response response = target.request().get();
    response.bufferEntity();
    try {
        response.readEntity(Place.class);
    } catch (Exception e) {
    }
    response.readEntity(Person.class);
}

@Test
public void test() throws Exception {
    ResteasyClient client = new ResteasyClientBuilder().build();
    WebTarget target = client.target("http://localhost:8081/test/one/");
    System.out.println("Sending request");
    Response response = target.request().get();
    String entity = response.readEntity(String.class);
    System.out.println("Received response: " + entity);
    Assert.assertEquals(200, response.getStatus());
    Assert.assertTrue("Type property is missing.", entity.contains("type"));
    response.close();
    target = client.target("http://localhost:8081/test/list/");
    System.out.println("Sending request");
    response = target.request().get();
    entity = response.readEntity(String.class);
    System.out.println("Received response: " + entity);
    Assert.assertEquals(200, response.getStatus());
    Assert.assertTrue("Type property is missing.", entity.contains("type"));
    response.close();
    client.close();
}

@Test
public void test() throws Exception {
    ResteasyClient client = new ResteasyClientBuilder().build();
    WebTarget target = client.target("http://localhost:8081/test/one/");
    System.out.println("Sending request");
    Response response = target.request().get();
    String entity = response.readEntity(String.class);
    System.out.println("Received response: " + entity);
    Assert.assertEquals(200, response.getStatus());
    Assert.assertTrue("Type property is missing.", entity.contains("type"));
    response.close();
    target = client.target("http://localhost:8081/test/list/");
    System.out.println("Sending request");
    response = target.request().get();
    entity = response.readEntity(String.class);
    System.out.println("Received response: " + entity);
    Assert.assertEquals(200, response.getStatus());
    Assert.assertTrue("Type property is missing.", entity.contains("type"));
    response.close();
    client.close();
}

@Test
public void argumentContainsExceptionWhenSendingIoExceptionTest() throws Exception {
    invokeClear();
    invokeReset();
    Future<Response> suspend = client.target("http://localhost:8080/resource/suspend").request().async().get();
    Future<Response> register = client.target("http://localhost:8080/resource/register?stage=0").request().async().get();
    assertString(register, Resource.FALSE);
    Future<Response> exception = client.target("http://localhost:8080/resource/resumechecked?stage=1").request().async().get();
    Response response = exception.get();
    Response suspendResponse = suspend.get();
    Assert.assertEquals(suspendResponse.getStatusInfo(), Response.Status.INTERNAL_SERVER_ERROR);
    suspendResponse.close();
    Future<Response> error = client.target("http://localhost:8080/resource/error").request().async().get();
    assertString(error, IOException.class.getName());
}

@Test
public void argumentContainsExceptionInTwoCallbackInstancesTest() throws Exception {
    invokeClear();
    invokeReset();
    Future<Response> suspend = client.target("http://localhost:8080/resource/suspend").request().async().get();
    Future<Response> register = client.target("http://localhost:8080/resource/registerobjects?stage=0").request().async().get();
    assertString(register, Resource.FALSE);
    Future<Response> exception = client.target("http://localhost:8080/resource/exception?stage=1").request().async().get();
    Response response = exception.get();
    Response suspendResponse = suspend.get();
    Assert.assertEquals(suspendResponse.getStatusInfo(), Response.Status.INTERNAL_SERVER_ERROR);
    suspendResponse.close();
    Future<Response> error = client.target("http://localhost:8080/resource/error").request().async().get();
    assertString(error, RuntimeException.class.getName());
    error = client.target("http://localhost:8080/resource/seconderror").request().async().get();
    assertString(error, RuntimeException.class.getName());
}

@Test
public void argumentContainsExceptionInTwoCallbackClassesTest() throws Exception {
    invokeClear();
    invokeReset();
    Future<Response> suspend = client.target("http://localhost:8080/resource/suspend").request().async().get();
    Future<Response> register = client.target("http://localhost:8080/resource/registerclasses?stage=0").request().async().get();
    assertString(register, Resource.FALSE);
    Future<Response> exception = client.target("http://localhost:8080/resource/exception?stage=1").request().async().get();
    Response response = exception.get();
    Response suspendResponse = suspend.get();
    Assert.assertEquals(suspendResponse.getStatusInfo(), Response.Status.INTERNAL_SERVER_ERROR);
    suspendResponse.close();
    Future<Response> error = client.target("http://localhost:8080/resource/error").request().async().get();
    assertString(error, RuntimeException.class.getName());
    error = client.target("http://localhost:8080/resource/seconderror").request().async().get();
    assertString(error, RuntimeException.class.getName());
}

@Test
public void testCancel() throws Exception {
    Client client = ClientBuilder.newClient();
    Response response = client.target("http://localhost:8080/jaxrs/cancel").request().get();
    Assert.assertEquals(503, response.getStatus());
    response.close();
    response = client.target("http://localhost:8080/jaxrs/cancelled").request().get();
    Assert.assertEquals(204, response.getStatus());
    response.close();
    client.close();
}

@Before
public void initFederationProviders() {
    UserFederationProviderRepresentation ldapRep = UserFederationProviderBuilder.create().displayName("ldap-1").providerName("ldap").priority(1).build();
    Response resp = realm.userFederation().create(ldapRep);
    this.ldapProviderId = ApiUtil.getCreatedId(resp);
    resp.close();
    assertAdminEvents.assertEvent(realmId, OperationType.CREATE, AdminEventPaths.userFederationResourcePath(this.ldapProviderId), ldapRep);
    UserFederationProviderRepresentation dummyRep = UserFederationProviderBuilder.create().displayName("dummy-1").providerName("dummy").priority(2).build();
    resp = realm.userFederation().create(dummyRep);
    this.dummyProviderId = ApiUtil.getCreatedId(resp);
    resp.close();
    assertAdminEvents.assertEvent(realmId, OperationType.CREATE, AdminEventPaths.userFederationResourcePath(this.dummyProviderId), dummyRep);
}

@Test
public void testNullBearerToken() {
    Client client = ClientBuilder.newClient();
    WebTarget target = client.target(customerDb.toString());
    Response response = target.request().get();
    assertEquals(401, response.getStatus());
    response.close();
    response = target.request().header(HttpHeaders.AUTHORIZATION, "Bearer null").get();
    assertEquals(401, response.getStatus());
    response.close();
    client.close();
}

/**
     * KEYCLOAK-518
     * @throws Exception
     */
public void testNullBearerToken() throws Exception {
    Client client = ClientBuilder.newClient();
    WebTarget target = client.target(APP_SERVER_BASE_URL + "/customer-db/");
    Response response = target.request().get();
    Assert.assertEquals(401, response.getStatus());
    response.close();
    response = target.request().header(HttpHeaders.AUTHORIZATION, "Bearer null").get();
    Assert.assertEquals(401, response.getStatus());
    response.close();
    client.close();
}

@Test(timeout = REQUEST_TIMEOUT)
public void testCancelled() throws Exception {
    Response response = null;
    response = client.target(BASE_URI).path("jaxrs/cancelled").request().put(null);
    Assert.assertEquals(204, response.getStatus());
    response.close();
    Thread.sleep(100);
    response = client.target(BASE_URI).path("jaxrs/cancelled").request().get();
    Assert.assertEquals(500, response.getStatus());
    response.close();
    Thread.sleep(100);
}

@Test
public void readEntityGenericTypeTest() throws Exception {
    Response response = client.target(generateURL("/entity")).request().get();
    Assert.assertEquals(200, response.getStatus());
    response.bufferEntity();
    String line;
    Reader reader = response.readEntity(new GenericType<Reader>(Reader.class));
    line = readLine(reader);
    Assert.assertTrue(Resource.ENTITY.equals(line));
    byte[] buffer = new byte[0];
    buffer = response.readEntity(generic(buffer.getClass()));
    Assert.assertNotNull(buffer);
    line = new String(buffer);
    Assert.assertTrue(Resource.ENTITY.equals(line));
    response.close();
}

public static void setupIDM(String realmJson) throws Exception {
    idm = new InfinispanIDM(getDefaultCache());
    RealmFactory factory = new RealmFactory(idm);
    deployment.getProviderFactory().register(new SkeletonKeyContextResolver(true));
    deployment.getRegistry().addSingletonResource(factory);
    TokenManagement tokenManagement = new TokenManagement(idm);
    deployment.getRegistry().addSingletonResource(tokenManagement);
    RealmRepresentation r = loadJson(realmJson);
    client = new ResteasyClientBuilder().build();
    WebTarget target = client.target(generateURL("/realms"));
    Response response = target.request().post(Entity.json(r));
    Assert.assertEquals(201, response.getStatus());
    Assert.assertNotNull(response.getLocation());
    realm = client.target(response.getLocation());
    realmInfo = response.readEntity(PublishedRealmRepresentation.class);
    response.close();
}

@Test
public void testGoodRealmCreation() throws Exception {
    RealmRepresentation realm = SkeletonTestBase.loadJson("testrealm.json");
    Client client = new ResteasyClientBuilder().build();
    WebTarget target = client.target(generateURL("/realms"));
    Response response = target.request().post(Entity.json(realm));
    Assert.assertEquals(201, response.getStatus());
    response.close();
    client.close();
}

@Test
public void testBasicVerificationBadSignatureNoBody() throws Exception {
    WebTarget target = client.target(TestPortProvider.generateURL("/signed/nobody"));
    DKIMSignature contentSignature = new DKIMSignature();
    contentSignature.setSelector("test");
    contentSignature.setDomain("samplezone.org");
    contentSignature.setPrivateKey(badKey);
    Response response = target.request().header(DKIMSignature.DKIM_SIGNATURE, contentSignature).get();
    Assert.assertEquals(401, response.getStatus());
    response.close();
}

@Test
public void testManualWithHeader() throws Exception {
    Verifier verifier = new Verifier();
    Verification verification = verifier.addNew();
    verification.setRepository(repository);
    //ResteasyClient client = new ResteasyClient();
    WebTarget target = client.target(TestPortProvider.generateURL("/signed/header"));
    Invocation.Builder request = target.request();
    request.property(Verifier.class.getName(), verifier);
    Response response = request.get();
    System.out.println(response.getHeaderString(DKIMSignature.DKIM_SIGNATURE));
    Assert.assertNotNull(response.getHeaderString(DKIMSignature.DKIM_SIGNATURE));
    Assert.assertEquals(200, response.getStatus());
    String output = response.readEntity(String.class);
    Assert.assertEquals("hello world", output);
    response.close();
}

@Test
public void testManual() throws Exception {
    Verifier verifier = new Verifier();
    Verification verification = verifier.addNew();
    verification.setRepository(repository);
    //ResteasyClient client = new ResteasyClient();
    WebTarget target = client.target(TestPortProvider.generateURL("/signed/manual"));
    Invocation.Builder request = target.request();
    request.property(Verifier.class.getName(), verifier);
    Response response = request.get();
    System.out.println(response.getHeaderString(DKIMSignature.DKIM_SIGNATURE));
    Assert.assertNotNull(response.getHeaderString(DKIMSignature.DKIM_SIGNATURE));
    Assert.assertEquals(200, response.getStatus());
    String output = response.readEntity(String.class);
    Assert.assertEquals("hello", output);
    response.close();
}

@Test
public void testExpiresYears() throws Exception {
    Verifier verifier = new Verifier();
    Verification verification = verifier.addNew();
    verification.setRepository(repository);
    //ResteasyClient client = new ResteasyClient();
    WebTarget target = client.target(TestPortProvider.generateURL("/signed/expires-year"));
    Invocation.Builder request = target.request();
    request.property(Verifier.class.getName(), verifier);
    Response response = request.get();
    System.out.println(response.getHeaderString(DKIMSignature.DKIM_SIGNATURE));
    Assert.assertEquals(200, response.getStatus());
    String output = response.readEntity(String.class);
    response.close();
}

@Test
public void testExpiresMonths() throws Exception {
    Verifier verifier = new Verifier();
    Verification verification = verifier.addNew();
    verification.setRepository(repository);
    //ResteasyClient client = new ResteasyClient();
    WebTarget target = client.target(TestPortProvider.generateURL("/signed/expires-month"));
    Invocation.Builder request = target.request();
    request.property(Verifier.class.getName(), verifier);
    Response response = request.get();
    System.out.println(response.getHeaderString(DKIMSignature.DKIM_SIGNATURE));
    Assert.assertEquals(200, response.getStatus());
    String output = response.readEntity(String.class);
    response.close();
}

@Test
public void testExpiresDays() throws Exception {
    Verifier verifier = new Verifier();
    Verification verification = verifier.addNew();
    verification.setRepository(repository);
    //ResteasyClient client = new ResteasyClient();
    WebTarget target = client.target(TestPortProvider.generateURL("/signed/expires-day"));
    Invocation.Builder request = target.request();
    request.property(Verifier.class.getName(), verifier);
    Response response = request.get();
    System.out.println(response.getHeaderString(DKIMSignature.DKIM_SIGNATURE));
    Assert.assertEquals(200, response.getStatus());
    String output = response.readEntity(String.class);
    response.close();
}

@Test
public void testExpiresMinutes() throws Exception {
    Verifier verifier = new Verifier();
    Verification verification = verifier.addNew();
    verification.setRepository(repository);
    //ResteasyClient client = new ResteasyClient();
    WebTarget target = client.target(TestPortProvider.generateURL("/signed/expires-minute"));
    Invocation.Builder request = target.request();
    request.property(Verifier.class.getName(), verifier);
    Response response = request.get();
    System.out.println(response.getHeaderString(DKIMSignature.DKIM_SIGNATURE));
    Assert.assertEquals(200, response.getStatus());
    String output = response.readEntity(String.class);
    response.close();
}

@Test
public void testExpiresHour() throws Exception {
    Verifier verifier = new Verifier();
    Verification verification = verifier.addNew();
    verification.setRepository(repository);
    //ResteasyClient client = new ResteasyClient();
    WebTarget target = client.target(TestPortProvider.generateURL("/signed/expires-hour"));
    Invocation.Builder request = target.request();
    request.property(Verifier.class.getName(), verifier);
    Response response = request.get();
    System.out.println(response.getHeaderString(DKIMSignature.DKIM_SIGNATURE));
    Assert.assertEquals(200, response.getStatus());
    String output = response.readEntity(String.class);
    response.close();
}

@Test
public void testBasicVerificationBadSignature() throws Exception {
    //ResteasyClient client = new ResteasyClient();
    WebTarget target = client.target(TestPortProvider.generateURL("/signed"));
    DKIMSignature contentSignature = new DKIMSignature();
    contentSignature.setSelector("test");
    contentSignature.setDomain("samplezone.org");
    contentSignature.setPrivateKey(badKey);
    Response response = target.request().header(DKIMSignature.DKIM_SIGNATURE, contentSignature).post(Entity.text("hello world"));
    Assert.assertEquals(401, response.getStatus());
    response.close();
}

@Test
public void testBasicVerificationRepository() throws Exception {
    //ResteasyClient client = new ResteasyClient();
    WebTarget target = client.target(TestPortProvider.generateURL("/signed"));
    target.property(KeyRepository.class.getName(), repository);
    DKIMSignature contentSignature = new DKIMSignature();
    contentSignature.setSelector("test");
    contentSignature.setDomain("samplezone.org");
    Response response = target.request().header(DKIMSignature.DKIM_SIGNATURE, contentSignature).post(Entity.text("hello world"));
    Assert.assertEquals(204, response.getStatus());
    response.close();
}

@Test
public void testManualVerification() throws Exception {
    //ResteasyClient client = new ResteasyClient();
    WebTarget target = client.target(TestPortProvider.generateURL("/signed/verify-manual"));
    DKIMSignature contentSignature = new DKIMSignature();
    contentSignature.setDomain("samplezone.org");
    contentSignature.setSelector("test");
    contentSignature.setAttribute("code", "hello");
    contentSignature.setPrivateKey(keys.getPrivate());
    Response response = target.request().header(DKIMSignature.DKIM_SIGNATURE, contentSignature).post(Entity.text("hello world"));
    Assert.assertEquals(204, response.getStatus());
    response.close();
}

@Test
public void testBasicVerification() throws Exception {
    //ResteasyClient client = new ResteasyClient();
    WebTarget target = client.target(TestPortProvider.generateURL("/signed"));
    DKIMSignature contentSignature = new DKIMSignature();
    contentSignature.setDomain("samplezone.org");
    contentSignature.setSelector("test");
    contentSignature.setPrivateKey(keys.getPrivate());
    Response response = target.request().header(DKIMSignature.DKIM_SIGNATURE, contentSignature).post(Entity.text("hello world"));
    Assert.assertEquals(204, response.getStatus());
    response.close();
}

@Test
public void testSigningManual() throws Exception {
    //ResteasyClient client = new ResteasyClient();
    WebTarget target = client.target(TestPortProvider.generateURL("/signed"));
    Response response = target.request().get();
    Assert.assertEquals(200, response.getStatus());
    MarshalledEntity<String> marshalledEntity = response.readEntity(new GenericType<MarshalledEntity<String>>() {
    });
    Assert.assertEquals("hello world", marshalledEntity.getEntity());
    String signatureHeader = response.getHeaderString(DKIMSignature.DKIM_SIGNATURE);
    System.out.println(DKIMSignature.DKIM_SIGNATURE + ":  " + signatureHeader);
    Assert.assertNotNull(signatureHeader);
    DKIMSignature contentSignature = new DKIMSignature(signatureHeader);
    contentSignature.verify(response.getStringHeaders(), marshalledEntity.getMarshalledBytes(), keys.getPublic());
    response.close();
}

@Test
public void testRoleText() {
    ResteasyClient client = new ResteasyClientBuilder().providerFactory(deployment.getProviderFactory()).build();
    Response response = client.target(generateURL("/roles")).request().post(Entity.text("admin"));
    Assert.assertEquals(response.getStatus(), 201);
    response.close();
    ResteasyWebTarget target = client.target(response.getLocation());
    String role = target.request().get(String.class);
    System.out.println(role);
    Role u = target.request().get(Role.class);
    System.out.println(u);
    Assert.assertEquals("admin", u.getName());
    Assert.assertEquals(target.request().delete().getStatus(), 204);
    response = target.request().get();
    Assert.assertEquals(404, response.getStatus());
    client.close();
}

@Test
public void testRole() {
    String newRole = "{ \"role\" : { \"name\" : \"admin\"} }";
    ResteasyClient client = new ResteasyClientBuilder().providerFactory(deployment.getProviderFactory()).build();
    Response response = client.target(generateURL("/roles")).request().post(Entity.json(newRole));
    Assert.assertEquals(response.getStatus(), 201);
    response.close();
    ResteasyWebTarget target = client.target(response.getLocation());
    String role = target.request().get(String.class);
    System.out.println(role);
    Role u = target.request().get(Role.class);
    System.out.println(u);
    Assert.assertEquals("admin", u.getName());
    Assert.assertEquals(target.request().delete().getStatus(), 204);
    response = target.request().get();
    Assert.assertEquals(404, response.getStatus());
    client.close();
}

@Test
public void testGetComplex4() throws Exception {
    Response response = client.target(generateURL("/complex")).request().accept("application/xml", "text/xml", "application/xhtml+xml", "image/png", "text/html;q=0.9", "text/plain;q=0.8", "*/*;q=0.5").acceptLanguage("en", "en-us;q=0.5").get();
    Assert.assertEquals(HttpResponseCodes.SC_OK, response.getStatus());
    Assert.assertEquals("GET", response.readEntity(String.class));
    Assert.assertEquals("en", response.getLanguage().toString());
    Assert.assertEquals(MediaType.TEXT_XML_TYPE, response.getMediaType());
    response.close();
}

@Test
public void testGetComplex3() throws Exception {
    Response response = client.target(generateURL("/complex")).request().accept("application/xml", "text/xml", "application/xhtml+xml", "image/png", "text/html;q=0.9", "text/plain;q=0.8", "*/*;q=0.5").acceptLanguage("en-us", "en;q=0.5").get();
    Assert.assertEquals(HttpResponseCodes.SC_OK, response.getStatus());
    Assert.assertEquals("GET", response.readEntity(String.class));
    Assert.assertEquals(MediaType.APPLICATION_XML_TYPE, response.getMediaType());
    Assert.assertEquals("en-us", new LocaleDelegate().toString(response.getLanguage()));
    response.close();
}

@Test
public void testGetComplex2() throws Exception {
    Response response = client.target(generateURL("/complex")).request().accept("text/xml", "application/xml", "application/xhtml+xml", "image/png", "text/html;q=0.9", "text/plain;q=0.8", "*/*;q=0.5").acceptLanguage("en", "en-us").get();
    Assert.assertEquals(HttpResponseCodes.SC_OK, response.getStatus());
    Assert.assertEquals("GET", response.readEntity(String.class));
    Assert.assertEquals(MediaType.APPLICATION_XML_TYPE, response.getMediaType());
    Assert.assertEquals("en-us", new LocaleDelegate().toString(response.getLanguage()));
    response.close();
}

@Test
public void testGetComplex1() throws Exception {
    Response response = client.target(generateURL("/complex")).request().accept("text/xml", "application/xml", "application/xhtml+xml", "image/png", "text/html;q=0.9", "text/plain;q=0.8", "*/*;q=0.5").acceptLanguage("en-us", "en;q=0.5").get();
    Assert.assertEquals(HttpResponseCodes.SC_OK, response.getStatus());
    Assert.assertEquals("GET", response.readEntity(String.class));
    Assert.assertEquals(MediaType.APPLICATION_XML_TYPE, response.getMediaType());
    Assert.assertEquals("en-us", new LocaleDelegate().toString(response.getLanguage()));
    response.close();
}

@Test
public void selectVariantResponseVaryTest() {
    Response response = client.target(generateURL("/SelectVariantTestResponse")).request().accept("application/json").acceptEncoding("*").get();
    Assert.assertEquals(200, response.getStatus());
    List<String> headers = response.getStringHeaders().get("Vary");
    Assert.assertEquals(1, headers.size());
    String vary = headers.get(0);
    System.out.println(vary);
    Assert.assertTrue(vary.contains("Accept-Language"));
    Assert.assertTrue(vary.contains("Accept-Encoding"));
    Assert.assertTrue(vary.matches(".*Accept.*Accept.*Accept.*"));
    response.close();
}

@Test
public void logoutAll() {
    setupTestAppAndUser();
    Response response = realm.users().create(UserBuilder.create().username("user").build());
    String userId = ApiUtil.getCreatedId(response);
    response.close();
    assertAdminEvents.assertEvent(realmId, OperationType.CREATE, AdminEventPaths.userResourcePath(userId));
    realm.users().get(userId).resetPassword(CredentialBuilder.create().password("password").build());
    assertAdminEvents.assertEvent(realmId, OperationType.ACTION, AdminEventPaths.userResetPasswordPath(userId));
    oauth.doLogin("user", "password");
    GlobalRequestResult globalRequestResult = realm.logoutAll();
    assertAdminEvents.assertEvent(realmId, OperationType.ACTION, "logout-all", globalRequestResult);
    assertEquals(1, globalRequestResult.getSuccessRequests().size());
    assertEquals("http://localhost:8180/auth/realms/master/app/admin", globalRequestResult.getSuccessRequests().get(0));
    assertNull(globalRequestResult.getFailedRequests());
    assertNotNull(testingClient.testApp().getAdminLogoutAction());
}

@Test
public void clearUserCache() {
    UserRepresentation user = new UserRepresentation();
    user.setUsername("clearcacheuser");
    Response response = realm.users().create(user);
    String userId = ApiUtil.getCreatedId(response);
    response.close();
    assertAdminEvents.assertEvent(realmId, OperationType.CREATE, AdminEventPaths.userResourcePath(userId), user);
    realm.users().get(userId).toRepresentation();
    assertTrue(testingClient.testing().isCached("users", userId));
    realm.clearUserCache();
    assertAdminEvents.assertEvent(realmId, OperationType.ACTION, "clear-user-cache");
    assertFalse(testingClient.testing().isCached("users", userId));
}

@Before
public void createClientForClientRoles() {
    ClientRepresentation client = new ClientRepresentation();
    client.setClientId(CLIENT_ROLES_CLIENT);
    client.setName(CLIENT_ROLES_CLIENT);
    client.setRootUrl("foo");
    client.setProtocol("openid-connect");
    Response resp = testRealmResource().clients().create(client);
    // for some reason, findAll() will later fail unless readEntity is called here
    resp.readEntity(String.class);
//testRealmResource().clients().findAll();
}

@Test
public void testImpersonateByMasterImpersonator() {
    Response response = adminClient.realm("master").users().create(UserBuilder.create().username("master-impersonator").build());
    String userId = ApiUtil.getCreatedId(response);
    response.close();
    UserResource user = adminClient.realm("master").users().get(userId);
    user.resetPassword(CredentialBuilder.create().password("password").build());
    ClientResource testRealmClient = ApiUtil.findClientResourceByClientId(adminClient.realm("master"), "test-realm");
    List<RoleRepresentation> roles = new LinkedList<>();
    roles.add(ApiUtil.findClientRoleByName(testRealmClient, AdminRoles.VIEW_USERS).toRepresentation());
    roles.add(ApiUtil.findClientRoleByName(testRealmClient, ImpersonationConstants.IMPERSONATION_ROLE).toRepresentation());
    user.roles().clientLevel(testRealmClient.toRepresentation().getId()).add(roles);
    testSuccessfulImpersonation("master-impersonator", Config.getAdminRealm());
    adminClient.realm("master").users().get(userId).remove();
}

private ClientRepresentation createAppClient() {
    String redirectUri = oauth.getRedirectUri().replace("/master/", "/" + REALM_NAME + "/");
    ClientRepresentation client = new ClientRepresentation();
    client.setClientId("test-app");
    client.setAdminUrl(suiteContext.getAuthServerInfo().getContextRoot() + "/auth/realms/master/app/admin");
    client.setRedirectUris(Collections.singletonList(redirectUri));
    client.setSecret("secret");
    int notBefore = Time.currentTime() - 60;
    client.setNotBefore(notBefore);
    Response response = realm.clients().create(client);
    String id = ApiUtil.getCreatedId(response);
    response.close();
    assertAdminEvents.assertEvent(realmId, OperationType.CREATE, AdminEventPaths.clientResourcePath(id), client);
    client.setId(id);
    return client;
}

private ClientRepresentation createClient() {
    ClientRepresentation rep = new ClientRepresentation();
    rep.setClientId("my-app");
    rep.setDescription("my-app description");
    rep.setEnabled(true);
    Response response = realm.clients().create(rep);
    response.close();
    String id = ApiUtil.getCreatedId(response);
    assertAdminEvents.assertEvent(realmId, OperationType.CREATE, AdminEventPaths.clientResourcePath(id), rep);
    rep.setId(id);
    return rep;
}

private String createTemplate(String templateName, String protocol) {
    ClientTemplateRepresentation rep = new ClientTemplateRepresentation();
    rep.setName(templateName);
    rep.setFullScopeAllowed(false);
    rep.setProtocol(protocol);
    Response resp = clientTemplates().create(rep);
    Assert.assertEquals(201, resp.getStatus());
    resp.close();
    String templateId = ApiUtil.getCreatedId(resp);
    assertAdminEvents.assertEvent(getRealmId(), OperationType.CREATE, AdminEventPaths.clientTemplateResourcePath(templateId), rep);
    return templateId;
}

@Test
public void testDeleteOidcMapper() {
    ProtocolMapperRepresentation rep = makeOidcMapper("oidc-hardcoded-role-mapper3");
    Response resp = oidcMappersRsc.createMapper(rep);
    resp.close();
    String createdId = ApiUtil.getCreatedId(resp);
    assertAdminEvents.assertEvent(getRealmId(), OperationType.CREATE, AdminEventPaths.clientTemplateProtocolMapperPath(oidcClientTemplateId, createdId), rep);
    oidcMappersRsc.delete(createdId);
    assertAdminEvents.assertEvent(getRealmId(), OperationType.DELETE, AdminEventPaths.clientTemplateProtocolMapperPath(oidcClientTemplateId, createdId));
    try {
        oidcMappersRsc.getMapperById(createdId);
        Assert.fail("Not expected to find mapper");
    } catch (NotFoundException nfe) {
    }
}

@Test
public void testDeleteSamlMapper() {
    ProtocolMapperRepresentation rep = makeSamlMapper("saml-role-name-mapper3");
    Response resp = samlMappersRsc.createMapper(rep);
    resp.close();
    String createdId = ApiUtil.getCreatedId(resp);
    assertAdminEvents.assertEvent(getRealmId(), OperationType.CREATE, AdminEventPaths.clientTemplateProtocolMapperPath(samlClientTemplateId, createdId), rep);
    samlMappersRsc.delete(createdId);
    assertAdminEvents.assertEvent(getRealmId(), OperationType.DELETE, AdminEventPaths.clientTemplateProtocolMapperPath(samlClientTemplateId, createdId));
    try {
        samlMappersRsc.getMapperById(createdId);
        Assert.fail("Not expected to find mapper");
    } catch (NotFoundException nfe) {
    }
}

@Test
public void test07UpdateOidcMapper() {
    ProtocolMapperRepresentation rep = makeOidcMapper("oidc-hardcoded-role-mapper2");
    Response resp = oidcMappersRsc.createMapper(rep);
    resp.close();
    String createdId = ApiUtil.getCreatedId(resp);
    assertAdminEvents.assertEvent(getRealmId(), OperationType.CREATE, AdminEventPaths.clientTemplateProtocolMapperPath(oidcClientTemplateId, createdId), rep);
    rep.getConfig().put("role", "myotherrole");
    rep.setId(createdId);
    rep.setConsentRequired(false);
    oidcMappersRsc.update(createdId, rep);
    assertAdminEvents.assertEvent(getRealmId(), OperationType.UPDATE, AdminEventPaths.clientTemplateProtocolMapperPath(oidcClientTemplateId, createdId), rep);
    ProtocolMapperRepresentation updated = oidcMappersRsc.getMapperById(createdId);
    assertEqualMappers(rep, updated);
}

@Test
public void test06UpdateSamlMapper() {
    ProtocolMapperRepresentation rep = makeSamlMapper("saml-role-name-mapper2");
    Response resp = samlMappersRsc.createMapper(rep);
    resp.close();
    String createdId = ApiUtil.getCreatedId(resp);
    assertAdminEvents.assertEvent(getRealmId(), OperationType.CREATE, AdminEventPaths.clientTemplateProtocolMapperPath(samlClientTemplateId, createdId), rep);
    rep.getConfig().put("role", "account.manage-account");
    rep.setId(createdId);
    rep.setConsentRequired(false);
    samlMappersRsc.update(createdId, rep);
    assertAdminEvents.assertEvent(getRealmId(), OperationType.UPDATE, AdminEventPaths.clientTemplateProtocolMapperPath(samlClientTemplateId, createdId), rep);
    ProtocolMapperRepresentation updated = samlMappersRsc.getMapperById(createdId);
    assertEqualMappers(rep, updated);
}

@Test
public void test05CreateOidcProtocolMapper() {
    //{"protocol":"openid-connect",
    // "config":{"role":"myrole"},
    // "consentRequired":true,
    // "consentText":"My consent text",
    // "name":"oidc-hardcoded-role-mapper",
    // "protocolMapper":"oidc-hardcoded-role-mapper"}
    ProtocolMapperRepresentation rep = makeOidcMapper("oidc-hardcoded-role-mapper");
    int totalMappers = oidcMappersRsc.getMappers().size();
    int totalOidcMappers = oidcMappersRsc.getMappersPerProtocol("openid-connect").size();
    Response resp = oidcMappersRsc.createMapper(rep);
    resp.close();
    String createdId = ApiUtil.getCreatedId(resp);
    assertAdminEvents.assertEvent(getRealmId(), OperationType.CREATE, AdminEventPaths.clientTemplateProtocolMapperPath(oidcClientTemplateId, createdId), rep);
    assertEquals(totalMappers + 1, oidcMappersRsc.getMappers().size());
    assertEquals(totalOidcMappers + 1, oidcMappersRsc.getMappersPerProtocol("openid-connect").size());
    //findByName(samlMappersRsc, "saml-role-name-mapper");
    ProtocolMapperRepresentation created = oidcMappersRsc.getMapperById(createdId);
    assertEqualMappers(rep, created);
}

@Test
public void test04CreateSamlProtocolMapper() {
    //{"protocol":"saml",
    // "config":{"role":"account.view-profile","new.role.name":"new-role-name"},
    // "consentRequired":true,
    // "consentText":"My consent text",
    // "name":"saml-role-name-maper",
    // "protocolMapper":"saml-role-name-mapper"}
    ProtocolMapperRepresentation rep = makeSamlMapper("saml-role-name-mapper");
    int totalMappers = samlMappersRsc.getMappers().size();
    int totalSamlMappers = samlMappersRsc.getMappersPerProtocol("saml").size();
    Response resp = samlMappersRsc.createMapper(rep);
    resp.close();
    String createdId = ApiUtil.getCreatedId(resp);
    assertAdminEvents.assertEvent(getRealmId(), OperationType.CREATE, AdminEventPaths.clientTemplateProtocolMapperPath(samlClientTemplateId, createdId), rep);
    assertEquals(totalMappers + 1, samlMappersRsc.getMappers().size());
    assertEquals(totalSamlMappers + 1, samlMappersRsc.getMappersPerProtocol("saml").size());
    ProtocolMapperRepresentation created = samlMappersRsc.getMapperById(createdId);
    assertEqualMappers(rep, created);
}

@Test
public void testDeleteOidcMapper() {
    ProtocolMapperRepresentation rep = makeOidcMapper("oidc-hardcoded-role-mapper3");
    Response resp = oidcMappersRsc.createMapper(rep);
    resp.close();
    String createdId = ApiUtil.getCreatedId(resp);
    assertAdminEvents.assertEvent(getRealmId(), OperationType.CREATE, AdminEventPaths.clientProtocolMapperPath(oidcClientId, createdId), rep);
    oidcMappersRsc.delete(createdId);
    assertAdminEvents.assertEvent(getRealmId(), OperationType.DELETE, AdminEventPaths.clientProtocolMapperPath(oidcClientId, createdId));
    try {
        oidcMappersRsc.getMapperById(createdId);
        Assert.fail("Not expected to find mapper");
    } catch (NotFoundException nfe) {
    }
}

@Test
public void testDeleteSamlMapper() {
    ProtocolMapperRepresentation rep = makeSamlMapper("saml-role-name-mapper3");
    Response resp = samlMappersRsc.createMapper(rep);
    resp.close();
    String createdId = ApiUtil.getCreatedId(resp);
    assertAdminEvents.assertEvent(getRealmId(), OperationType.CREATE, AdminEventPaths.clientProtocolMapperPath(samlClientId, createdId), rep);
    samlMappersRsc.delete(createdId);
    assertAdminEvents.assertEvent(getRealmId(), OperationType.DELETE, AdminEventPaths.clientProtocolMapperPath(samlClientId, createdId));
    try {
        samlMappersRsc.getMapperById(createdId);
        Assert.fail("Not expected to find mapper");
    } catch (NotFoundException nfe) {
    }
}

@Test
public void testUpdateOidcMapper() {
    ProtocolMapperRepresentation rep = makeOidcMapper("oidc-hardcoded-role-mapper2");
    Response resp = oidcMappersRsc.createMapper(rep);
    resp.close();
    String createdId = ApiUtil.getCreatedId(resp);
    assertAdminEvents.assertEvent(getRealmId(), OperationType.CREATE, AdminEventPaths.clientProtocolMapperPath(oidcClientId, createdId), rep);
    rep.getConfig().put("role", "myotherrole");
    rep.setId(createdId);
    rep.setConsentRequired(false);
    oidcMappersRsc.update(createdId, rep);
    assertAdminEvents.assertEvent(getRealmId(), OperationType.UPDATE, AdminEventPaths.clientProtocolMapperPath(oidcClientId, createdId), rep);
    ProtocolMapperRepresentation updated = oidcMappersRsc.getMapperById(createdId);
    assertEqualMappers(rep, updated);
}

@Test
public void testUpdateSamlMapper() {
    ProtocolMapperRepresentation rep = makeSamlMapper("saml-role-name-mapper2");
    Response resp = samlMappersRsc.createMapper(rep);
    resp.close();
    String createdId = ApiUtil.getCreatedId(resp);
    assertAdminEvents.assertEvent(getRealmId(), OperationType.CREATE, AdminEventPaths.clientProtocolMapperPath(samlClientId, createdId), rep);
    rep.getConfig().put("role", "account.manage-account");
    rep.setId(createdId);
    rep.setConsentRequired(false);
    samlMappersRsc.update(createdId, rep);
    assertAdminEvents.assertEvent(getRealmId(), OperationType.UPDATE, AdminEventPaths.clientProtocolMapperPath(samlClientId, createdId), rep);
    ProtocolMapperRepresentation updated = samlMappersRsc.getMapperById(createdId);
    assertEqualMappers(rep, updated);
}

@Test
public void testCreateOidcProtocolMapper() {
    //{"protocol":"openid-connect",
    // "config":{"role":"myrole"},
    // "consentRequired":true,
    // "consentText":"My consent text",
    // "name":"oidc-hardcoded-role-mapper",
    // "protocolMapper":"oidc-hardcoded-role-mapper"}
    ProtocolMapperRepresentation rep = makeOidcMapper("oidc-hardcoded-role-mapper");
    int totalMappers = oidcMappersRsc.getMappers().size();
    int totalOidcMappers = oidcMappersRsc.getMappersPerProtocol("openid-connect").size();
    Response resp = oidcMappersRsc.createMapper(rep);
    resp.close();
    String createdId = ApiUtil.getCreatedId(resp);
    assertAdminEvents.assertEvent(getRealmId(), OperationType.CREATE, AdminEventPaths.clientProtocolMapperPath(oidcClientId, createdId), rep);
    assertEquals(totalMappers + 1, oidcMappersRsc.getMappers().size());
    assertEquals(totalOidcMappers + 1, oidcMappersRsc.getMappersPerProtocol("openid-connect").size());
    //findByName(samlMappersRsc, "saml-role-name-mapper");
    ProtocolMapperRepresentation created = oidcMappersRsc.getMapperById(createdId);
    assertEqualMappers(rep, created);
}

@Test
public void testCreateSamlProtocolMapper() {
    //{"protocol":"saml",
    // "config":{"role":"account.view-profile","new.role.name":"new-role-name"},
    // "consentRequired":true,
    // "consentText":"My consent text",
    // "name":"saml-role-name-maper",
    // "protocolMapper":"saml-role-name-mapper"}
    ProtocolMapperRepresentation rep = makeSamlMapper("saml-role-name-mapper");
    int totalMappers = samlMappersRsc.getMappers().size();
    int totalSamlMappers = samlMappersRsc.getMappersPerProtocol("saml").size();
    Response resp = samlMappersRsc.createMapper(rep);
    resp.close();
    String createdId = ApiUtil.getCreatedId(resp);
    assertAdminEvents.assertEvent(getRealmId(), OperationType.CREATE, AdminEventPaths.clientProtocolMapperPath(samlClientId, createdId), rep);
    assertEquals(totalMappers + 1, samlMappersRsc.getMappers().size());
    assertEquals(totalSamlMappers + 1, samlMappersRsc.getMappersPerProtocol("saml").size());
    ProtocolMapperRepresentation created = samlMappersRsc.getMapperById(createdId);
    assertEqualMappers(rep, created);
}

@Test
public // KEYCLOAK-2580
void addExecutionFlow() {
    HashMap<String, String> params = new HashMap<>();
    params.put("newName", "parent");
    Response response = authMgmtResource.copy("browser", params);
    Assert.assertEquals(201, response.getStatus());
    response.close();
    assertAdminEvents.assertEvent(REALM_NAME, OperationType.CREATE, AdminEventPaths.authCopyFlowPath("browser"), params);
    params = new HashMap<>();
    params.put("alias", "child");
    params.put("description", "Description");
    params.put("provider", "registration-page-form");
    params.put("type", "basic-flow");
    authMgmtResource.addExecutionFlow("parent", params);
    assertAdminEvents.assertEvent(REALM_NAME, OperationType.CREATE, AdminEventPaths.authAddExecutionFlowPath("parent"), params);
}

@Test
public void testCreateConfig() {
    AuthenticatorConfigRepresentation cfg = newConfig("foo", IdpCreateUserIfUniqueAuthenticatorFactory.REQUIRE_PASSWORD_UPDATE_AFTER_REGISTRATION, "true");
    // Attempt to create config for non-existent execution
    Response response = authMgmtResource.newExecutionConfig("exec-id-doesnt-exists", cfg);
    Assert.assertEquals(404, response.getStatus());
    response.close();
    // Create config success
    String cfgId = createConfig(executionId, cfg);
    // Assert found
    AuthenticatorConfigRepresentation cfgRep = authMgmtResource.getAuthenticatorConfig(cfgId);
    assertConfig(cfgRep, cfgId, "foo", IdpCreateUserIfUniqueAuthenticatorFactory.REQUIRE_PASSWORD_UPDATE_AFTER_REGISTRATION, "true");
    // Cleanup
    authMgmtResource.removeAuthenticatorConfig(cfgId);
    assertAdminEvents.assertEvent(REALM_NAME, OperationType.DELETE, AdminEventPaths.authExecutionConfigPath(cfgId));
}

@Test
public void salesMetadataTest() throws Exception {
    Document doc = loadXML(AbstractSAMLServletsAdapterTest.class.getResourceAsStream("/adapter-test/keycloak-saml/sp-metadata.xml"));
    modifyDocElementAttribute(doc, "SingleLogoutService", "Location", "8080", System.getProperty("app.server.http.port", null));
    modifyDocElementAttribute(doc, "AssertionConsumerService", "Location", "8080", System.getProperty("app.server.http.port", null));
    ClientRepresentation clientRep = testRealmResource().convertClientDescription(IOUtil.documentToString(doc));
    String appServerUrl;
    if (Boolean.parseBoolean(System.getProperty("app.server.ssl.required"))) {
        appServerUrl = "https://localhost:" + System.getProperty("app.server.https.port", "8543") + "/";
    } else {
        appServerUrl = "http://localhost:" + System.getProperty("app.server.http.port", "8280") + "/";
    }
    clientRep.setAdminUrl(appServerUrl + "sales-metadata/saml");
    Response response = testRealmResource().clients().create(clientRep);
    assertEquals(201, response.getStatus());
    response.close();
    testSuccessfulAndUnauthorizedLogin(salesMetadataServletPage, testRealmSAMLPostLoginPage);
}

@Test
@Ignore
public void testBadUser() {
    Client client = ClientBuilder.newClient();
    URI uri = OIDCLoginProtocolService.tokenUrl(authServerPage.createUriBuilder()).build("demo");
    WebTarget target = client.target(uri);
    String header = BasicAuthHelper.createHeader("customer-portal", "password");
    Form form = new Form();
    form.param(OAuth2Constants.GRANT_TYPE, OAuth2Constants.PASSWORD).param("username", "[email protected]").param("password", "password");
    Response response = target.request().header(HttpHeaders.AUTHORIZATION, header).post(Entity.form(form));
    assertEquals(401, response.getStatus());
    response.close();
    client.close();
}

@Test
public void updateProfileEnabledTest() throws Exception {
    // Switch updateProfileOnFirstLogin to on
    RealmRepresentation realm = testRealmResource().toRepresentation();
    UserFederationProviderRepresentation kerberosProviderRepresentation = realm.getUserFederationProviders().get(0);
    kerberosProviderRepresentation.getConfig().put(KerberosConstants.UPDATE_PROFILE_FIRST_LOGIN, "true");
    testRealmResource().update(realm);
    // Assert update profile page is displayed
    Response spnegoResponse = spnegoLogin("hnelson", "secret");
    Assert.assertEquals(200, spnegoResponse.getStatus());
    String responseText = spnegoResponse.readEntity(String.class);
    Assert.assertTrue(responseText.contains("You need to update your user profile to activate your account."));
    Assert.assertTrue(responseText.contains("hnelson@" + getConfig().get(KerberosConstants.KERBEROS_REALM).toLowerCase()));
    spnegoResponse.close();
    // Assert user was imported and has required action on him
    assertUser("hnelson", "hnelson@" + getConfig().get(KerberosConstants.KERBEROS_REALM).toLowerCase(), null, null, true);
    // Switch updateProfileOnFirstLogin to off
    kerberosProviderRepresentation = realm.getUserFederationProviders().get(0);
    kerberosProviderRepresentation.getConfig().put(KerberosConstants.UPDATE_PROFILE_FIRST_LOGIN, "false");
    testRealmResource().update(realm);
}

protected Response spnegoLogin(String username, String password) {
    kerberosPortal.navigateTo();
    Response res = client.target(kerberosPortal.getInjectedUrl().toString()).request().get();
    String kcLoginPageLocation = res.getLocation().toString();
    if (driver.manage().getCookieNamed("OAuth_Token_Request_State") != null) {
        kcLoginPageLocation = res.getLocation().toString().replaceFirst("state=.*&", "state=" + driver.manage().getCookieNamed("OAuth_Token_Request_State").getValue() + "&");
    }
    // Request for SPNEGO login sent with Resteasy client
    spnegoSchemeFactory.setCredentials(username, password);
    Response response = client.target(kcLoginPageLocation).request().get();
    if (response.getStatus() == 302) {
        if (response.getLocation() == null)
            return response;
        String uri = response.getLocation().toString();
        if (uri.contains("login-actions/required-action")) {
            response = client.target(uri).request().get();
        }
    }
    return response;
}

// KEYCLOAK-2102
@Test
public void spnegoCaseInsensitiveTest() throws Exception {
    Response spnegoResponse = spnegoLogin(ldapTestConfiguration.isCaseSensitiveLogin() ? "MyDuke" : "myduke", "theduke");
    Assert.assertEquals(302, spnegoResponse.getStatus());
    List<UserRepresentation> users = testRealmResource().users().search("myduke", 0, 1);
    String userId = users.get(0).getId();
    events.expectLogin().client("kerberos-app").user(userId).detail(Details.REDIRECT_URI, kerberosPortal.toString()).detail(//.detail(Details.AUTH_METHOD, "spnego")
    Details.USERNAME, "myduke").assertEvent();
    String location = spnegoResponse.getLocation().toString();
    driver.navigate().to(location);
    String pageSource = driver.getPageSource();
    Assert.assertTrue(pageSource.contains("Kerberos Test") && pageSource.contains("Kerberos servlet secured content"));
    spnegoResponse.close();
    events.clear();
}

protected void spnegoLoginTestImpl() throws Exception {
    Response spnegoResponse = spnegoLogin("hnelson", "secret");
    Assert.assertEquals(302, spnegoResponse.getStatus());
    List<UserRepresentation> users = testRealmResource().users().search("hnelson", 0, 1);
    String userId = users.get(0).getId();
    events.expectLogin().client("kerberos-app").user(userId).detail(Details.REDIRECT_URI, kerberosPortal.toString()).detail(//.detail(Details.AUTH_METHOD, "spnego")
    Details.USERNAME, "hnelson").assertEvent();
    String location = spnegoResponse.getLocation().toString();
    driver.navigate().to(location);
    String pageSource = driver.getPageSource();
    Assert.assertTrue(pageSource.contains("Kerberos Test") && pageSource.contains("Kerberos servlet secured content"));
    spnegoResponse.close();
    events.clear();
}

@Test
public void spnegoNotAvailableTest() throws Exception {
    initHttpClient(false);
    String kcLoginPageLocation = client.target(kerberosPortal.getInjectedUrl().toString()).request().get().getLocation().toString();
    Response response = client.target(kcLoginPageLocation).request().get();
    Assert.assertEquals(401, response.getStatus());
    Assert.assertEquals(KerberosConstants.NEGOTIATE, response.getHeaderString(HttpHeaders.WWW_AUTHENTICATE));
    String responseText = response.readEntity(String.class);
    responseText.contains("Log in to test");
    response.close();
}

// @Test
public void testCxfExample() {
    //String uri = "http://localhost:9000/customerservice/customers/123";
    String uri = "http://localhost:8080/jax_rs_basic_servlet/services/service1/customerservice/customers/123";
    Response resp = client.target(uri).request().get();
    Assert.assertEquals(resp.getStatus(), 401);
    resp.close();
    // Retrieve token
    OAuthClient.AccessTokenResponse accessTokenResp = retrieveAccessToken();
    String authHeader = "Bearer " + accessTokenResp.getAccessToken();
    String resp2 = client.target(uri).request().header(HttpHeaders.AUTHORIZATION, authHeader).get(String.class);
    System.out.println(resp2);
}

@Test
public void testSslRequired() {
    keycloakRule.update(new KeycloakRule.KeycloakSetup() {

        @Override
        public void config(RealmManager manager, RealmModel adminstrationRealm, RealmModel appRealm) {
            Map<String, String> initParams = new TreeMap<String, String>();
            initParams.put(CONFIG_FILE_INIT_PARAM, "classpath:jaxrs-test/jaxrs-keycloak-ssl.json");
            keycloakRule.deployJaxrsApplication("JaxrsSimpleApp", "/jaxrs-simple", JaxrsTestApplication.class, initParams);
        }
    });
    // Retrieve token
    OAuthClient.AccessTokenResponse accessTokenResp = retrieveAccessToken();
    String authHeader = "Bearer " + accessTokenResp.getAccessToken();
    // Fail due to non-https
    Response getResp = client.target(JAXRS_APP_URL).request().header(HttpHeaders.AUTHORIZATION, authHeader).get();
    Assert.assertEquals(getResp.getStatus(), 403);
    getResp.close();
}

// KEYCLOAK-2102
@Test
public void spnegoCaseInsensitiveTest() throws Exception {
    KeycloakRule keycloakRule = getKeycloakRule();
    AssertEvents events = getAssertEvents();
    Response spnegoResponse = spnegoLogin("MyDuke", "theduke");
    Assert.assertEquals(302, spnegoResponse.getStatus());
    events.expectLogin().client("kerberos-app").user(keycloakRule.getUser("test", "myduke").getId()).detail(Details.REDIRECT_URI, KERBEROS_APP_URL).detail(//.detail(Details.AUTH_METHOD, "spnego")
    Details.USERNAME, "myduke").assertEvent();
    String location = spnegoResponse.getLocation().toString();
    driver.navigate().to(location);
    String pageSource = driver.getPageSource();
    Assert.assertTrue(pageSource.contains("Kerberos Test") && pageSource.contains("Kerberos servlet secured content"));
    spnegoResponse.close();
    events.clear();
}

protected void spnegoLoginTestImpl() throws Exception {
    KeycloakRule keycloakRule = getKeycloakRule();
    AssertEvents events = getAssertEvents();
    Response spnegoResponse = spnegoLogin("hnelson", "secret");
    Assert.assertEquals(302, spnegoResponse.getStatus());
    events.expectLogin().client("kerberos-app").user(keycloakRule.getUser("test", "hnelson").getId()).detail(Details.REDIRECT_URI, KERBEROS_APP_URL).detail(//.detail(Details.AUTH_METHOD, "spnego")
    Details.USERNAME, "hnelson").assertEvent();
    String location = spnegoResponse.getLocation().toString();
    driver.navigate().to(location);
    String pageSource = driver.getPageSource();
    Assert.assertTrue(pageSource.contains("Kerberos Test") && pageSource.contains("Kerberos servlet secured content"));
    spnegoResponse.close();
    events.clear();
}

@Test
public void spnegoNotAvailableTest() throws Exception {
    initHttpClient(false);
    SpnegoAuthenticator.bypassChallengeJavascript = true;
    driver.navigate().to(KERBEROS_APP_URL);
    String kcLoginPageLocation = driver.getCurrentUrl();
    Response response = client.target(kcLoginPageLocation).request().get();
    Assert.assertEquals(401, response.getStatus());
    Assert.assertEquals(KerberosConstants.NEGOTIATE, response.getHeaderString(HttpHeaders.WWW_AUTHENTICATE));
    String responseText = response.readEntity(String.class);
    responseText.contains("Log in to test");
    response.close();
    SpnegoAuthenticator.bypassChallengeJavascript = false;
}

/**
     * KEYCLOAK-518
     * @throws Exception
     */
public void testBadUser() throws Exception {
    Client client = ClientBuilder.newClient();
    UriBuilder builder = UriBuilder.fromUri(AUTH_SERVER_URL);
    URI uri = OIDCLoginProtocolService.tokenUrl(builder).build("demo");
    WebTarget target = client.target(uri);
    String header = BasicAuthHelper.createHeader("customer-portal", "password");
    Form form = new Form();
    form.param(OAuth2Constants.GRANT_TYPE, OAuth2Constants.PASSWORD).param("username", "[email protected]").param("password", "password");
    Response response = target.request().header(HttpHeaders.AUTHORIZATION, header).post(Entity.form(form));
    Assert.assertEquals(401, response.getStatus());
    response.close();
    client.close();
}

/**
     * KEYCLOAK-3016
     * @throws Exception
     */
public void testBasicAuthErrorHandling() throws Exception {
    Client client = ClientBuilder.newClient();
    WebTarget target = client.target(APP_SERVER_BASE_URL + "/customer-db/");
    Response response = target.request().get();
    Assert.assertEquals(401, response.getStatus());
    response.close();
    // The number of iterations should be HttpClient's connection pool size + 1.
    final int LIMIT = ConnManagerParams.DEFAULT_MAX_TOTAL_CONNECTIONS + 1;
    for (int i = 0; i < LIMIT; i++) {
        System.out.println("Testing Basic Auth with bad credentials " + i);
        response = target.request().header(HttpHeaders.AUTHORIZATION, "Basic dXNlcm5hbWU6cGFzc3dvcmQ=").get();
        Assert.assertEquals(401, response.getStatus());
        response.close();
    }
    client.close();
}

private ModelResponse deployForm(String id) throws IOException {
    Response response;
    try (InputStream is = openPMML(id)) {
        FormDataMultiPart formData = new FormDataMultiPart();
        formData.field("id", id);
        formData.bodyPart(new FormDataBodyPart("pmml", is, MediaType.APPLICATION_XML_TYPE));
        Entity<FormDataMultiPart> entity = Entity.entity(formData, MediaType.MULTIPART_FORM_DATA);
        response = target("model").request(MediaType.APPLICATION_JSON).post(entity);
        formData.close();
    }
    assertEquals(201, response.getStatus());
    URI location = response.getLocation();
    assertEquals("/model/" + id, location.getPath());
    return response.readEntity(ModelResponse.class);
}

private ModelResponse deploy(String id) throws IOException {
    Response response;
    try (InputStream is = openPMML(id)) {
        Entity<InputStream> entity = Entity.entity(is, MediaType.APPLICATION_XML);
        response = target("model/" + id).request(MediaType.APPLICATION_JSON).put(entity);
    }
    assertEquals(201, response.getStatus());
    return response.readEntity(ModelResponse.class);
}

@Test
public void testVerification() {
    // Keys repository
    DosetaKeyRepository repository = new DosetaKeyRepository();
    repository.setKeyStorePath("demo.jks");
    repository.setKeyStorePassword("changeit");
    repository.start();
    // Building the client
    ResteasyClient client = new ResteasyClientBuilder().build();
    Verifier verifier = new Verifier();
    Verification verification = verifier.addNew();
    verification.setRepository(repository);
    WebTarget target = client.target("http://localhost:8080/signatures-1.0/signed");
    Invocation.Builder request = target.request();
    request.property(Verifier.class.getName(), verifier);
    // Invocation to Restful web service
    Response response = request.post(Entity.text("Rene"));
    // Status 200 OK
    Assert.assertEquals(200, response.getStatus());
    System.out.println(response.readEntity(String.class));
    response.close();
    client.close();
}

@Test(enabled = true)
public void testServerConfExposureInSession() throws Exception {
    // conf : lens-site.xml
    MapBuilder query1 = new MapBuilder("sessionid", sessionHandleString, "key", LensConfConstants.SERVER_DB_JDBC_PASS);
    Response response1 = lens.sendQuery("get", SessionURL.SESSION_PARAMS_URL, query1);
    Assert.assertEquals(response1.getStatus(), Response.Status.NOT_FOUND.getStatusCode());
    //Driver conf : jdbc-driver.xml
    MapBuilder query2 = new MapBuilder("sessionid", sessionHandleString, "key", "lens.driver.jdbc.db.user");
    Response response2 = lens.sendQuery("get", SessionURL.SESSION_PARAMS_URL, query2);
    Assert.assertEquals(response2.getStatus(), Response.Status.NOT_FOUND.getStatusCode());
}

//LENS-928
@Test
public void testDeleteOnInMemoryResult() throws Exception {
    sHelper.setAndValidateParam(LensConfConstants.QUERY_PERSISTENT_RESULT_SET, "false");
    sHelper.setAndValidateParam(LensConfConstants.QUERY_PERSISTENT_RESULT_INDRIVER, "false");
    sHelper.setAndValidateParam("lens.query.enable.mail.notify", "false");
    MapBuilder query = new MapBuilder("sessionid", sessionHandleString, "fromindex", "0", "fetchsize", "100");
    QueryHandle queryHandle = (QueryHandle) qHelper.executeQuery(QueryInventory.JDBC_DIM_QUERY).getData();
    LensQuery lensQuery = qHelper.waitForCompletion(queryHandle);
    Assert.assertEquals(lensQuery.getStatus().getStatus(), QueryStatus.Status.SUCCESSFUL, "Query did not succeed");
    Response response = qHelper.exec("get", QueryURL.QUERY_URL + "/" + queryHandle.toString() + "/resultset", servLens, null, query);
    AssertUtil.assertSucceededResponse(response);
    Thread.sleep(20000);
    Response response1 = qHelper.exec("delete", QueryURL.QUERY_URL + "/" + queryHandle.toString() + "/resultset", servLens, null, query);
    AssertUtil.assertSucceededResponse(response1);
}

private AccessTokenResponse executeGrantAccessTokenRequest(WebTarget grantTarget) {
    String header = BasicAuthHelper.createHeader("test-app", "password");
    Form form = new Form();
    form.param(OAuth2Constants.GRANT_TYPE, OAuth2Constants.PASSWORD).param("username", "[email protected]").param("password", "password");
    Response response = grantTarget.request().header(HttpHeaders.AUTHORIZATION, header).post(Entity.form(form));
    assertEquals(200, response.getStatus());
    AccessTokenResponse accessTokenResponse = response.readEntity(AccessTokenResponse.class);
    response.close();
    return accessTokenResponse;
}

@Test
public void testSessionExpired() throws Exception {
    Client client = ClientBuilder.newClient();
    UriBuilder builder = UriBuilder.fromUri(AUTH_SERVER_ROOT);
    URI grantUri = OIDCLoginProtocolService.tokenUrl(builder).build("test");
    WebTarget grantTarget = client.target(grantUri);
    AccessTokenResponse accessTokenResponse = executeGrantAccessTokenRequest(grantTarget);
    testingClient.testing().removeUserSessions("test");
    Response response = executeUserInfoRequest(accessTokenResponse.getToken());
    assertEquals(Status.FORBIDDEN.getStatusCode(), response.getStatus());
    response.close();
    client.close();
}

@Test
public void testSuccessfulUserInfoRequest() throws Exception {
    Client client = ClientBuilder.newClient();
    UriBuilder builder = UriBuilder.fromUri(AUTH_SERVER_ROOT);
    URI grantUri = OIDCLoginProtocolService.tokenUrl(builder).build("test");
    WebTarget grantTarget = client.target(grantUri);
    AccessTokenResponse accessTokenResponse = executeGrantAccessTokenRequest(grantTarget);
    Response response = executeUserInfoRequest(accessTokenResponse.getToken());
    assertEquals(Status.OK.getStatusCode(), response.getStatus());
    UserInfo userInfo = response.readEntity(UserInfo.class);
    response.close();
    assertNotNull(userInfo);
    assertNotNull(userInfo.getSubject());
    assertEquals("[email protected]", userInfo.getEmail());
    assertEquals("[email protected]", userInfo.getPreferredUsername());
    client.close();
}

@Test
public void testBrowserSecurityHeaders() {
    Client client = ClientBuilder.newClient();
    Response response = client.target(oauth.getLoginFormUrl()).request().get();
    Assert.assertEquals(200, response.getStatus());
    for (Map.Entry<String, String> entry : BrowserSecurityHeaders.defaultHeaders.entrySet()) {
        String headerName = BrowserSecurityHeaders.headerAttributeMap.get(entry.getKey());
        String headerValue = response.getHeaderString(headerName);
        Assert.assertNotNull(headerValue);
        Assert.assertEquals(headerValue, entry.getValue());
    }
    response.close();
}

@Test
public void createDuplicatedUser7() {
    createUser("user1", "[email protected]");
    UserRepresentation user = new UserRepresentation();
    user.setUsername("user2");
    user.setEmail("[email protected]");
    Response response = realm.users().create(user);
    assertEquals(409, response.getStatus());
    response.close();
    assertAdminEvents.assertEmpty();
}

@Test
public void createDuplicatedUser1() {
    createUser();
    UserRepresentation user = new UserRepresentation();
    user.setUsername("user1");
    Response response = realm.users().create(user);
    assertEquals(409, response.getStatus());
    assertAdminEvents.assertEmpty();
    // Just to show how to retrieve underlying error message
    ErrorRepresentation error = response.readEntity(ErrorRepresentation.class);
    Assert.assertEquals("User exists with same username", error.getErrorMessage());
    response.close();
}

@Test
@RunAsClient
public void createResourceWithContentUsingPut() {
    Resource sr = createSourceResource("my.txt");
    TextFlow stf = new TextFlow("tf1", LocaleId.EN, "tf1");
    sr.getTextFlows().add(stf);
    Response response = getSourceDocResource().putResource("my.txt", sr, null, false);
    assertThat(response.getStatus(), is(Status.CREATED.getStatusCode()));
    Response resourceGetResponse = getSourceDocResource().getResource("my.txt", null);
    assertThat(resourceGetResponse.getStatus(), is(Status.OK.getStatusCode()));
    Resource gotSr = getResourceFromResponse(resourceGetResponse);
    assertThat(gotSr.getTextFlows().size(), is(1));
    assertThat(gotSr.getTextFlows().get(0).getContents(), is(asList("tf1")));
}

@Test
@RunAsClient
public void createResourceWithContentUsingPost() {
    Resource sr = createSourceResource("my.txt");
    TextFlow stf = new TextFlow("tf1", LocaleId.EN, "tf1");
    sr.getTextFlows().add(stf);
    Response postResponse = getSourceDocResource().post(sr, null, true);
    assertThat(postResponse.getStatus(), is(Status.CREATED.getStatusCode()));
    postResponse = getSourceDocResource().post(sr, null, true);
    Response resourceGetResponse = getSourceDocResource().getResource("my.txt", null);
    assertThat(resourceGetResponse.getStatus(), is(Status.OK.getStatusCode()));
    Resource gotSr = getResourceFromResponse(resourceGetResponse);
    assertThat(gotSr.getTextFlows().size(), is(1));
    assertThat(gotSr.getTextFlows().get(0).getContents(), is(asList("tf1")));
}

@Test
@RunAsClient
public void testDeleteResource() {
    Resource rs1 = resourceTestFactory.getTextFlowTest2();
    getSourceDocResource().post(rs1, null, true);
    Response resourceGetResponse = getSourceDocResource().deleteResource(rs1.getName());
    assertThat(resourceGetResponse.getStatus(), is(Status.OK.getStatusCode()));
    Resource rs2 = resourceTestFactory.getTextFlowTest();
    Response resourceGetResponse2 = getSourceDocResource().deleteResource(rs2.getName());
    assertThat(resourceGetResponse2.getStatus(), is(Status.NOT_FOUND.getStatusCode()));
}

@Test
@RunAsClient
public void deleteTranslations() throws Exception {
    TranslatedDocResource translationsClient = getTransResource("/projects/p/sample-project/iterations/i/1.0/r/", AuthenticatedAsUser.Admin);
    Response response = translationsClient.deleteTranslations("my,path,document-3.txt", LocaleId.EN_US);
    // 200
    assertThat(response.getStatus(), is(Status.OK.getStatusCode()));
    releaseConnection(response);
    // try to fetch them again
    Response getResponse = translationsClient.getTranslations("my,path,document-3.txt", LocaleId.EN_US, new StringSet(PoHeader.ID + ";" + SimpleComment.ID), false, null);
    List<TextFlowTarget> targets = getTransResourceFromResponse(getResponse).getTextFlowTargets();
    for (TextFlowTarget target : targets) {
        assertThat(target.getState(), is(ContentState.New));
    }
}

@Test
public void testDefaultHead() {
    // mucks up stream so create our own client.
    //Client client = ClientBuilder.newClient();
    Response response = client.target(generateURL("/default_head")).request().head();
    Assert.assertEquals(200, response.getStatus());
    System.out.println(response.getMediaType());
    response.close();
//client.close();
}

@Test
public void testDefaultHead() {
    // mucks up stream so create our own client.
    //Client client = ClientBuilder.newClient();
    Response response = client.target(generateURL("/default_head")).request().head();
    Assert.assertEquals(201, response.getStatus());
    Assert.assertNotNull(response.getMediaType());
    System.out.println(response.getMediaType());
    Assert.assertTrue(response.getMediaType().equals(MediaType.TEXT_PLAIN_TYPE));
    response.close();
//client.close();
}

/**
    * See RESTEASY-1094
    */
@Test
public void testFullRange() {
    Response response = client.target(generateURL("/small-file")).request().header("Range", "bytes=0-8").get();
    Assert.assertEquals(response.getStatus(), 206);
    Assert.assertEquals(9, response.getLength());
    System.out.println("Content-Range: " + response.getHeaderString("Content-Range"));
    Assert.assertEquals(response.readEntity(String.class), "123456789");
    response.close();
}

@Test
public void testRange0to3000() {
    Response response = client.target(generateURL("/file")).request().header("Range", "bytes=0-3000").get();
    Assert.assertEquals(response.getStatus(), 206);
    Assert.assertEquals(3001, response.getLength());
    System.out.println("Content-Range: " + response.getHeaderString("Content-Range"));
    byte[] bytes = response.readEntity(new GenericType<byte[]>() {
    });
    Assert.assertEquals(3001, bytes.length);
    response.close();
}