private static void updateBook() {
   ResteasyClient client = new ResteasyClientBuilder().build();
   Publisher publisher = new Publisher(1, "陕西师范大学出版社");
   Book book = new Book(1, "金庸", "987634556", "书剑恩仇录", publisher);
   Response response =
       client
           .target("http://localhost:8080/v1/api")
           .path("bookstore/book")
           .request()
           .header("Authorization", "Basic " + getBasicAuthenticationEncoding())
           .accept(MediaType.APPLICATION_JSON)
           .put(Entity.entity(book, MediaType.APPLICATION_JSON));
   System.out.println(response.getStatus());
   System.out.println(response.readEntity(String.class));
   System.out.println("---------------------------------------");
   response =
       client
           .target("http://localhost:8080/v1/api")
           .path("bookstore/book")
           .request()
           .header("Authorization", "Basic " + getBasicAuthenticationEncoding())
           .accept(MediaType.APPLICATION_XML)
           .put(Entity.entity(book, MediaType.APPLICATION_XML));
   System.out.println(response.getStatus());
   System.out.println(response.readEntity(String.class));
 }
  @Test
  public void testPostEmployee() {
    if (null == cookie) {
      fail("cannot login!!!");
    }
    Employee ep1 = generateEmployee();

    try {
      ResteasyClient client = new ResteasyClientBuilder().build();

      WebTarget target = client.target(baseUrl + "/rest/ag/employee");
      client.register(new CookieRequestFilter(cookie));

      Response response = target.request().post(Entity.entity(ep1, "application/json"));

      if (response.getStatus() != 200) {
        throw new RuntimeException("Failed : HTTP error code : " + response.getStatus());
      }

      Employee value = response.readEntity(Employee.class);
      System.out.println("Server response : \n");
      System.out.println(value.toString());

      assertEquals("same first name", "Special", value.getFirstName());

      client.close();

    } catch (Exception e) {

      e.printStackTrace();
    }
  }
 private static void getBooksSet() {
   ResteasyClient client = new ResteasyClientBuilder().build();
   System.out.println("----------------JSON-----------------------");
   Response response =
       client
           .target("http://localhost:8080/v1/api")
           .path("bookstore/set")
           .request()
           .accept(MediaType.APPLICATION_JSON)
           .get();
   System.out.println(response.getStatus());
   System.out.println(response.readEntity(String.class));
   System.out.println("----------------JSNOP-----------------------");
   response =
       client
           .target("http://localhost:8080/v1/api")
           .path("bookstore/set")
           .queryParam("callback", "books")
           .request()
           .accept(MediaType.APPLICATION_JSON)
           .get();
   System.out.println(response.getStatus());
   System.out.println(response.readEntity(String.class));
   System.out.println("----------------XML-----------------------");
   response =
       client
           .target("http://localhost:8080/v1/api")
           .path("bookstore/set")
           .request()
           .accept(MediaType.APPLICATION_XML)
           .get();
   System.out.println(response.getStatus());
   System.out.println(response.readEntity(String.class));
 }
 private static void removeBook() {
   ResteasyClient client = new ResteasyClientBuilder().build();
   Response response =
       client
           .target("http://localhost:8080/v1/api")
           .path("bookstore/book")
           .path("1")
           .request()
           .header("Authorization", "Basic " + getBasicAuthenticationEncoding())
           .accept(MediaType.APPLICATION_JSON)
           .delete();
   System.out.println(response.getStatus());
   System.out.println(response.readEntity(String.class));
   System.out.println("---------------------------------------");
   response =
       client
           .target("http://localhost:8080/v1/api")
           .path("bookstore/book")
           .path("1")
           .request()
           .header("Authorization", "Basic " + getBasicAuthenticationEncoding())
           .accept(MediaType.APPLICATION_XML)
           .delete();
   System.out.println(response.getStatus());
   System.out.println(response.readEntity(String.class));
 }
Exemple #5
0
  @Test
  public void testCMD() throws Exception {
    Authentication auth =
        new SkeletonKeyClientBuilder()
            .username("wburke")
            .password("geheim")
            .authentication("Skeleton Key");
    ResteasyClient client = new ResteasyClient();
    WebTarget target = client.target(generateBaseUrl());
    String tiny = target.path("tokens").path("url").request().post(Entity.json(auth), String.class);
    System.out.println(tiny);
    System.out.println("tiny.size: " + tiny.length());
    Security.addProvider(new BouncyCastleProvider());

    KeyPair keyPair = KeyPairGenerator.getInstance("RSA", "BC").generateKeyPair();
    PrivateKey privateKey = keyPair.getPrivate();
    X509Certificate cert = KeyTools.generateTestCertificate(keyPair);

    byte[] signed = p7s(privateKey, cert, null, tiny.getBytes());

    CMSSignedData data = new CMSSignedData(signed);
    byte[] bytes = (byte[]) data.getSignedContent().getContent();
    System.out.println("BYTES: " + new String(bytes));
    System.out.println("size:" + signed.length);
    System.out.println("Base64.size: " + Base64.encodeBytes(signed).length());

    SignerInformation signer =
        (SignerInformation) data.getSignerInfos().getSigners().iterator().next();
    System.out.println("valid: " + signer.verify(cert, "BC"));
  }
 private static void addBooksMap() {
   ResteasyClient client = new ResteasyClientBuilder().build();
   Publisher publisher = new Publisher(1, "陕西师范大学出版社");
   Map<String, Book> books = new HashMap<String, Book>();
   Book book;
   for (int i = 1; i <= 20; i++) {
     book = new Book(i, "金庸", "987634556", "书剑恩仇录", publisher);
     books.put(String.valueOf(i), book);
   }
   Response response =
       client
           .target("http://localhost:8080/v1/api")
           .path("bookstore/map")
           .request()
           .header("Authorization", "Basic " + getBasicAuthenticationEncoding())
           .accept(MediaType.APPLICATION_JSON)
           .post(Entity.entity(books, MediaType.APPLICATION_JSON));
   System.out.println(response.getStatus());
   System.out.println(response.readEntity(String.class));
   System.out.println("---------------------------------------");
   response =
       client
           .target("http://localhost:8080/v1/api")
           .path("bookstore/map")
           .request()
           .header("Authorization", "Basic " + getBasicAuthenticationEncoding())
           .accept(MediaType.APPLICATION_XML)
           .post(Entity.entity(books, MediaType.APPLICATION_JSON));
   System.out.println(response.getStatus());
   System.out.println(response.readEntity(String.class));
 }
  @Test
  public void testAppLoad() throws Exception {
    clearCache();
    startDeployment();
    init();
    stopDeployment();
    startDeployment();
    ResteasyClient client = new ResteasyClientBuilder().build();
    WebTarget target = client.target(generateBaseUrl());
    SkeletonKeyAdminClient admin =
        new SkeletonKeyClientBuilder().username("wburke").password("geheim").idp(target).admin();

    StoredUser newUser = new StoredUser();
    newUser.setName("John Smith");
    newUser.setUsername("jsmith");
    newUser.setEnabled(true);
    Map creds = new HashMap();
    creds.put("password", "foobar");
    newUser.setCredentials(creds);
    Response response = admin.users().create(newUser);
    User user = response.readEntity(User.class);
    response = admin.roles().create("user");
    Role role = response.readEntity(Role.class);
    Projects projects = admin.projects().query("Skeleton Key");
    Project project = projects.getList().get(0);
    admin.projects().addUserRole(project.getId(), user.getId(), role.getId());

    admin =
        new SkeletonKeyClientBuilder().username("jsmith").password("foobar").idp(target).admin();
    response = admin.roles().create("error");
    Assert.assertEquals(403, response.getStatus());
    stopDeployment();
  }
Exemple #8
0
 @Test
 public void testDispatchDynamic43() throws Exception {
   ResteasyClient client = new ResteasyClientBuilder().build43();
   Invocation.Builder request = client.target(generateURL("/test/dispatch/dynamic")).request();
   Response response = request.get();
   assertEquals(HttpResponseCodes.SC_OK, response.getStatus());
   assertEquals("Wrong content of response", "forward", response.readEntity(String.class));
 }
 public static <T> void save(String path, T data) {
   ResteasyClient client = new ResteasyClientBuilder().build();
   Response response =
       client
           .target(SALES_ORDER_APP + path)
           .request()
           .post(Entity.entity(data, MediaType.APPLICATION_JSON));
   System.out.println(response.getStatus());
 }
 public static <T> List<Object> getSaleOrdersList(String path) {
   ResteasyClient client = new ResteasyClientBuilder().build();
   ArrayList<SaleOrders> response =
       client
           .target(SALES_ORDER_APP + path)
           .request()
           .get(new GenericType<ArrayList<SaleOrders>>() {});
   Object[] array = response.toArray();
   return Arrays.asList(array);
 }
 @Test
 public void testMe() throws Exception {
   ResteasyClient client = new ResteasyClient();
   MyTest proxy = client.target(TestPortProvider.generateURL("")).proxy(MyTest.class);
   try {
     proxy.postIt("hello");
     Assert.fail();
   } catch (NotAuthorizedException e) {
     Assert.assertEquals(401, e.getResponse().getStatus());
   }
   client.close();
 }
  /**
   * Save CSV or XML file with the storage component
   *
   * @expects "GEMO portal wide params" in portal-ext.properties:
   *     gemo.storage.upload.url=http://?????????/service/storage/upload
   *     gemo.storage.search.query.url=http://?????????/service/storage/ search?query=
   * @param csvXmlFile the file
   * @return the url
   * @throws SystemException the system exception
   * @throws URISyntaxException the uRI syntax exception
   * @throws IOException
   * @throws PortalException
   */
  public static String uploadToStorage(UploadedFile csvXmlFile)
      throws SystemException, URISyntaxException, IOException, PortalException,
          NullPointerException {
    // grab props from constants
    final String storage_uri =
        PrefsPropsUtil.getString(PortalProperties.GEMO_STORAGE_URL, "http://localhost/storage");
    final String upload_uri =
        PrefsPropsUtil.getString(
            PortalProperties.GEMO_STORAGE_UPLOAD_URL, "http://localhost/storage/upload");
    final String upload_base64_uri =
        PrefsPropsUtil.getString(
            PortalProperties.GEMO_STORAGE_UPLOADBASE64_URL,
            "http://localhost:8080/storage/uploadbase64");
    final String query_uri =
        PrefsPropsUtil.getString(
            PortalProperties.GEMO_STORAGE_SEARCH_QUERY_URL,
            "http://localhost/storage/search?query=");

    final String tableName = NameUtils.UsersUsableUniqueNamefromFile(csvXmlFile);

    try {
      byte[] bytes = csvXmlFile.getBytes();
      String theBase64Bytes = Base64.encodeBytes(bytes);

      ResteasyClient client = new ResteasyClientBuilder().build();
      ResteasyWebTarget target = client.target(upload_base64_uri);

      MultipartFormDataOutput mdo = new MultipartFormDataOutput();
      mdo.addFormData("tableName", tableName, MediaType.TEXT_PLAIN_TYPE);
      mdo.addFormData("fileName", csvXmlFile.getName(), MediaType.TEXT_PLAIN_TYPE);
      mdo.addFormData("fileBase64", theBase64Bytes, MediaType.TEXT_PLAIN_TYPE.withCharset("utf-8"));

      GenericEntity<MultipartFormDataOutput> entity =
          new GenericEntity<MultipartFormDataOutput>(mdo) {};
      Response r = target.request().post(Entity.entity(entity, MediaType.MULTIPART_FORM_DATA_TYPE));
      String obj = r.readEntity(String.class);
      LOG.debug("Storage returned: " + obj);
    } catch (ClientProtocolException e) {
      e.printStackTrace();
    } catch (IOException e) {
      e.printStackTrace();
    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      // httpclient.getConnectionManager().shutdown();
    }
    return query_uri + "select * from " + tableName + " LIMIT 10";
  }
  /** allow to reset proxy as per security needs */
  @Override
  public void setProxy() {
    ResteasyClient client = null;
    String urlString = url.toString();
    Class<P> proxyClass = this.getProxyClass();

    if (useAuth()) {
      String user = properties.getProperty(USER_PROPERTY);
      String password = properties.getProperty(PASSWORD_PROPERTY);
      client =
          (ResteasyClient) ClientBuilder.newClient().register(new Authenticator(user, password));
    } else {
      client = (ResteasyClient) ClientBuilder.newClient();
    }

    proxy = client.target(urlString).proxy(proxyClass);
  }
  public static void main(String args[]) throws Exception {
    Configuration config = OtrBootstrap.init();

    File fLibrary = new File(config.getString(TestPropertyKeys.dirTaggerDst));
    File fBackup = new File(config.getString(TestPropertyKeys.dirMcBackup));

    String restUrl = config.getString("url.otrseries");
    logger.info("Connectiong to " + restUrl);

    ResteasyClient client = new ResteasyClientBuilder().build();
    ResteasyWebTarget target = client.target(restUrl);
    OtrSeriesRest rest = target.proxy(OtrSeriesRest.class);
    ;

    McLibraryTagger tagger = new McLibraryTagger(rest, fBackup, null);
    tagger.scan(fLibrary);
  }
Exemple #15
0
 /**
  * @tpTestDetails This tests decorators in general with the @Stylesheet annotation
  * @tpPassCrit The response contains expected xml-stylesheet header
  * @tpSince RESTEasy 3.0.16
  */
 @Test
 public void testStylesheet() throws Exception {
   ResteasyWebTarget target = client.target(generateURL("/test/stylesheet"));
   String response = target.request().get(String.class);
   logger.info(response);
   Assert.assertTrue(
       "The response doesn't contain the expected xml-stylesheet header",
       response.contains("<?xml-stylesheet"));
 }
 protected Response spnegoLogin(String username, String password) {
   SpnegoAuthenticator.bypassChallengeJavascript = true;
   driver.navigate().to(KERBEROS_APP_URL);
   String kcLoginPageLocation = driver.getCurrentUrl();
   String location =
       "http://localhost:8081/auth/realms/test/protocol/openid-connect/auth?response_type=code&client_id=kerberos-app&redirect_uri=http%3A%2F%2Flocalhost%3A8081%2Fkerberos-portal&state=0%2F88a96ddd-84fe-4e77-8a46-02394d7b3a7d&login=true";
   // Request for SPNEGO login sent with Resteasy client
   spnegoSchemeFactory.setCredentials(username, password);
   Response response = client.target(kcLoginPageLocation).request().get();
   SpnegoAuthenticator.bypassChallengeJavascript = false;
   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;
 }
Exemple #17
0
 @Test
 public void testNotAuthenticated() {
   {
     // assuming @RolesAllowed is on class level. Too lazy to test it all!
     String newUser =
         "******"user\" : { \"username\" : \"wburke\", \"name\" : \"Bill Burke\", \"email\" : \"[email protected]\", \"enabled\" : true, \"credentials\" : { \"password\" : \"geheim\" }} }";
     ResteasyClient client = new ResteasyClient(deployment.getProviderFactory());
     Response response = client.target(generateURL("/users")).request().post(Entity.json(newUser));
     Assert.assertEquals(response.getStatus(), 403);
     response.close();
   }
   {
     String newRole = "{ \"role\" : { \"name\" : \"admin\"} }";
     ResteasyClient client = new ResteasyClient(deployment.getProviderFactory());
     Response response = client.target(generateURL("/roles")).request().post(Entity.json(newRole));
     Assert.assertEquals(response.getStatus(), 403);
     response.close();
   }
   {
     String newProject =
         "{ \"project\" : { \"id\" : \"5\", \"name\" : \"Resteasy\", \"description\" : \"The Best of REST\", \"enabled\" : true } }";
     ResteasyClient client = new ResteasyClient(deployment.getProviderFactory());
     Response response =
         client.target(generateURL("/projects")).request().post(Entity.json(newProject));
     Assert.assertEquals(response.getStatus(), 403);
     response.close();
   }
 }
  private String callNeo(String query) {
    ResteasyClient client = new ResteasyClientBuilder().build();
    ResteasyWebTarget target = client.target("http://" + getStrNeoHost() + ":7474/db/data/cypher");
    String token = "neo4j" + ":" + "neo4j";
    String base64Token = "";
    try {
      base64Token = DatatypeConverter.printBase64Binary(token.getBytes("UTF-8"));
    } catch (UnsupportedEncodingException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
    Response response =
        target
            .request()
            .header("Authorization", "Basic " + base64Token)
            .header("Accept", "application/json; charset=UTF-8")
            .header("Content-Type", "application/json")
            .post(Entity.entity(query, "application/json"));

    String value = response.readEntity(String.class);
    response.close();

    return value;
  }
Exemple #19
0
  @Test
  public void testSignedAuth() throws Exception {
    // Use our own providerFactory to test json context provider
    ResteasyProviderFactory providerFactory = new ResteasyProviderFactory();
    RegisterBuiltin.register(providerFactory);
    ResteasyClient client = new ResteasyClient(providerFactory);
    WebTarget target = client.target(generateBaseUrl());
    SkeletonKeyAdminClient admin =
        new SkeletonKeyClientBuilder().username("wburke").password("geheim").idp(target).admin();

    StoredUser newUser = new StoredUser();
    newUser.setName("John Smith");
    newUser.setUsername("jsmith");
    newUser.setEnabled(true);
    Map creds = new HashMap();
    creds.put("password", "foobar");
    newUser.setCredentials(creds);
    Response response = admin.users().create(newUser);
    User user = response.readEntity(User.class);
    response = admin.roles().create("user");
    Role role = response.readEntity(Role.class);
    Projects projects = admin.projects().query("Skeleton Key");
    Project project = projects.getList().get(0);
    admin.projects().addUserRole(project.getId(), user.getId(), role.getId());

    String signed =
        new SkeletonKeyClientBuilder()
            .username("jsmith")
            .password("foobar")
            .idp(target)
            .obtainSignedToken("Skeleton Key");
    System.out.println(signed);
    PKCS7SignatureInput input = new PKCS7SignatureInput(signed);
    input.setCertificate(certificate);
    Assert.assertTrue(input.verify());
  }
Exemple #20
0
  @Test
  public void testReadProductRelease() throws Exception {
    String relativeUrl = "/product-releases/" + productReleaseId;
    stubFor(
        get(urlEqualTo(CONTEXT_URL + relativeUrl))
            .willReturn(
                aResponse()
                    .withHeader("Content-Type", "application/json")
                    .withBody(readResponseBodyFromTemplate("product-releases-1.json"))));

    Response response = client.target(pncUrl + relativeUrl).request().get();
    Singleton<ProductReleaseRest> responseEntity =
        response.readEntity(new GenericType<Singleton<ProductReleaseRest>>() {});

    assertEquals(productReleaseId, responseEntity.getContent().getId());
  }
  @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;
  }
Exemple #22
0
  @Test
  public void testReadProductReleaseBuildConfigurations() throws Exception {
    String relativeUrl = "/product-releases/" + productReleaseId + "/distributed-build-records-ids";
    stubFor(
        get(urlEqualTo(CONTEXT_URL + relativeUrl))
            .willReturn(
                aResponse()
                    .withHeader("Content-Type", "application/json")
                    .withBody(
                        readResponseBodyFromTemplate(
                            "product-release-distributed-build-records-ids-1.json"))));

    ProductReleaseEndpoint endpoint = client.target(pncUrl).proxy(ProductReleaseEndpoint.class);
    Response response =
        endpoint.getAllBuildsInDistributedRecordsetOfProductRelease(productReleaseId);
    Page<BuildRecordRest> ids =
        ((Page<BuildRecordRest>) response.readEntity(new GenericType<Page<BuildRecordRest>>() {}));

    assertArrayEquals(asList(1, 2).toArray(), extractIds(ids.getContent()).toArray());
  }
  @Before
  public void init() throws Exception {
    httpClient = HttpClientBuilder.create().build();

    engine = new CustomApacheHttpClient4Engine(httpClient);

    clientBuilder = new CustomResteasyClientBuilder();
    client = clientBuilder.build();
    client.register(JacksonConfigurationProvider.class);

    ResteasyProviderFactory resteasyProviderFactory = new ResteasyProviderFactory();
    clientConfiguration = new ClientConfiguration(resteasyProviderFactory);
    headers = new ClientRequestHeaders(clientConfiguration);

    uri = new URI("http://127.0.0.1");

    // request = new ClientInvocation(client, uri, headers, clientConfiguration);
    request = mock(ClientInvocation.class);
    when(request.getHeaders()).thenReturn(headers);
    when(request.getClientConfiguration()).thenReturn(clientConfiguration);
  }
Exemple #24
0
 @After
 public void tearDown() throws Exception {
   if (client != null) {
     client.close();
   }
 }
Exemple #25
0
 @After
 public void after() throws Exception {
   client.close();
   client = null;
 }
  @Test
  public void testResteasy734() throws Exception {
    ResteasyWebTarget target = null;
    Response response = null;

    target = client.target("http://localhost:8081/encoded/pathparam/bee bop");
    response = target.request().get();
    String entity = response.readEntity(String.class);
    System.out.println("Received encoded path param: " + entity);
    Assert.assertEquals(200, response.getStatus());
    Assert.assertEquals("bee%20bop", entity);
    response.close();

    target = client.target("http://localhost:8081/decoded/pathparam/bee bop");
    response = target.request().get();
    entity = response.readEntity(String.class);
    System.out.println("Received decoded path param: " + entity);
    Assert.assertEquals(200, response.getStatus());
    Assert.assertEquals("bee bop", entity);
    response.close();

    target = client.target("http://localhost:8081/encoded/matrix;m=bee bop");
    response = target.request().get();
    entity = response.readEntity(String.class);
    System.out.println("Received encoded matrix param: " + entity);
    Assert.assertEquals(200, response.getStatus());
    Assert.assertEquals("bee%20bop", entity);
    response.close();

    target = client.target("http://localhost:8081/decoded/matrix;m=bee bop");
    response = target.request().get();
    entity = response.readEntity(String.class);
    System.out.println("Received decoded matrix param: " + entity);
    Assert.assertEquals(200, response.getStatus());
    Assert.assertEquals("bee bop", entity);
    response.close();

    target = client.target("http://localhost:8081/encoded/query?m=bee bop");
    response = target.request().get();
    entity = response.readEntity(String.class);
    System.out.println("Received encoded query param: " + entity);
    Assert.assertEquals(200, response.getStatus());
    Assert.assertEquals("bee%20bop", entity);
    response.close();

    target = client.target("http://localhost:8081/decoded/query?m=bee bop");
    response = target.request().get();
    entity = response.readEntity(String.class);
    System.out.println("Received decoded query param: " + entity);
    Assert.assertEquals(200, response.getStatus());
    Assert.assertEquals("bee bop", entity);
    response.close();

    target = client.target("http://localhost:8081/encoded/form");
    Form form = new Form();
    form.param("f", "bee bop");
    response = target.request().post(Entity.form(form));
    entity = response.readEntity(String.class);
    System.out.println("Received encoded form param: " + entity);
    Assert.assertEquals(200, response.getStatus());
    Assert.assertEquals("bee+bop", entity);
    response.close();

    target = client.target("http://localhost:8081/decoded/form");
    form = new Form();
    form.param("f", "bee bop");
    response = target.request().post(Entity.form(form));
    entity = response.readEntity(String.class);
    System.out.println("Received decoded form param: " + entity);
    Assert.assertEquals(200, response.getStatus());
    Assert.assertEquals("bee bop", entity);
    response.close();

    target = client.target("http://localhost:8081/encoded/segment/bee bop");
    response = target.request().get();
    entity = response.readEntity(String.class);
    System.out.println("Received encoded path param from segment: " + entity);
    Assert.assertEquals(200, response.getStatus());
    Assert.assertEquals("bee%20bop", entity);
    response.close();

    target = client.target("http://localhost:8081/decoded/segment/bee bop");
    response = target.request().get();
    entity = response.readEntity(String.class);
    System.out.println("Received decoded path param from segment: " + entity);
    Assert.assertEquals(200, response.getStatus());
    Assert.assertEquals("bee bop", entity);
    response.close();

    target = client.target("http://localhost:8081/encoded/segment/matrix/params;m=bee bop");
    response = target.request().get();
    entity = response.readEntity(String.class);
    System.out.println("Received encoded matrix param from segment: " + entity);
    Assert.assertEquals(200, response.getStatus());
    Assert.assertEquals("bee%20bop", entity);
    response.close();

    target = client.target("http://localhost:8081/decoded/segment/matrix/params;m=bee bop");
    response = target.request().get();
    entity = response.readEntity(String.class);
    System.out.println("Received decoded matrix param from segment: " + entity);
    Assert.assertEquals(200, response.getStatus());
    Assert.assertEquals("bee bop", entity);
    response.close();
  }
 public static <T> Object get(String path, Class<T> clas) {
   ResteasyClient client = new ResteasyClientBuilder().build();
   T response = client.target(SALES_ORDER_APP + path).request().get(clas);
   return response;
 }
 @After
 public void after() {
   client.close();
   client = null;
 }
 public static <T> Response delete(String path) {
   ResteasyClient client = new ResteasyClientBuilder().build();
   Response response = client.target(SALES_ORDER_APP + path).request().delete();
   System.out.println(response.getStatus());
   return response;
 }
 @AfterClass
 public static void shutdown() throws Exception {
   client.close();
   EmbeddedContainer.stop();
   deployment = null;
 }