public void testPost() throws IOException, ResourceException {
    Representation result = clientResource.post("[\"root\"]", MediaType.APPLICATION_JSON);
    assertNotNull(result);
    assertEquals("[\"root\"]2", result.getText());
    assertEquals(MediaType.APPLICATION_JSON, result.getMediaType());

    result = clientResource.post("<root/>", MediaType.APPLICATION_XML);
    assertNotNull(result);
    assertEquals("<root/>1", result.getText());
    assertEquals(MediaType.APPLICATION_XML, result.getMediaType());
  }
  @Test
  public void shouldPostWithSSL() throws ResourceException {

    // Given
    setSslConfiguration();
    final String uri = "URI";
    final Map<String, String> queryParameters = new HashMap<String, String>();
    final Map<String, String> headers = new HashMap<String, String>();
    final Context context = mock(Context.class);
    final ConcurrentHashMap<String, Object> requestAttributes =
        new ConcurrentHashMap<String, Object>();
    final JSONObject restResponse = mock(JSONObject.class);

    given(resource.getContext()).willReturn(context);
    given(context.getAttributes()).willReturn(requestAttributes);
    given(resource.post(anyObject(), eq(JSONObject.class))).willReturn(restResponse);
    given(restResponse.toString()).willReturn("{}");

    // When
    final JsonValue response = restClient.post(uri, queryParameters, headers);

    // Then
    verify(resource, never()).addQueryParameter(anyString(), anyString());
    verify(requestHeaders, never()).set(anyString(), anyString());
    verify(resource).getContext();
    assertTrue(requestAttributes.containsKey("sslContextFactory"));
    assertEquals(response.size(), 0);
  }
  public GetStreamKeyStreamServer getGetStreamKeyStreamServer(
      String songID, GetCountry country, String sesionID) {
    GetStreamKeyStreamServer res = null;
    String post =
        "{\"method\":\"getStreamKeyStreamServer\",\"header\":{\"wsKey\":\""
            + KEY
            + "\",\"sessionID\":\""
            + sesionID
            + "\"},\"parameters\":{\"songID\":\""
            + songID
            + "\",\"country\":"
            + country.getResult()
            + ",\"lowBitrate\":\"\"}}";
    ClientResource cr = new ClientResource(uri + getSignatures(post));
    try {
      res = gson.fromJson(cr.post(post).getText(), GetStreamKeyStreamServer.class);
    } catch (JsonSyntaxException e) {
      e.printStackTrace();
    } catch (ResourceException e) {
      e.printStackTrace();
    } catch (IOException e) {
      e.printStackTrace();
    }

    return res;
  }
  /**
   * Invoke POST
   *
   * @param uri String
   * @param params String
   * @param object Representation
   * @param parameters Map<String, String>
   * @param uriTemplate String
   */
  public void postDocAPI(
      String uri,
      String params,
      Representation object,
      Map<String, String> parameters,
      String uriTemplate) {

    ClientResource cr = new ClientResource(uri);
    System.out.println("URI: " + uriTemplate);
    docAPI.appendSection("Format");
    // url type
    // request
    ClientResource crLocal = new ClientResource(uriTemplate);
    docAPI.appendRequest(Method.POST, crLocal);
    // parameters
    docAPI.appendParameters(parameters);
    docAPI.appendSection("Example");
    docAPI.appendRequest(Method.POST, cr, object);

    Representation result = cr.post(object, docAPI.getMediaTest());

    // response
    docAPI.appendResponse(result);

    RIAPUtils.exhaust(result);
  }
示例#5
0
  public void postContent(String content) {
    ClientResource cr = null;

    try {
      cr = new ClientResource(uriShare + "?access_token=" + access_token + "&message=" + content);
      cr.post(content);
    } catch (ResourceException re) {
      System.err.println("Error when retrieving friends: " + cr.getResponse().getStatus());
      System.err.println(uri + "?access_token" + access_token);
    }
  }
示例#6
0
    @Override
    public String call() throws Exception {
      String url = buildUrl();

      System.out.println("Sending ==>" + url);

      ClientResource client = new ClientResource(url);
      StringWriter writer = new StringWriter();

      client.post(javascript, MediaType.APPLICATION_JSON).write(writer);

      return writer.toString();
    }
  /**
   * Tries to send a query to the PushEndpoint running on http://localhost:8183/pushendpoint.
   *
   * @throws Exception
   */
  @Test
  public void sendQueryToPushEndpoint() throws Exception {

    // construct workflow
    ClientResource rdfResource = new ClientResource(Resources.MGMT_WORKFLOWS_URL);

    Form form = new Form();
    form.add("workflow", SampleRdfWorkflows.getWorkflowWithPushEndpoint());
    Representation rep = form.getWebRepresentation();
    rep.setMediaType(MediaType.APPLICATION_RDF_XML);
    Representation rdfResponse = rdfResource.post(rep);
    Reference url = rdfResponse.getLocationRef();

    // retrieve endpoint
    ClientResource endpointResource =
        new ClientResource(url + "/endpoint?urn=urn:eu.larkc.endpoint.push.ep1");
    Representation endpointResponse = endpointResource.get();

    Reference pushEndpointUrl = endpointResponse.getLocationRef();
    logger.debug("PushEndpoint URL: {}", pushEndpointUrl);

    // execute query
    ClientResource pushEndpointResource = new ClientResource(pushEndpointUrl);

    Form queryForm = new Form();
    queryForm.add("query", SampleQueries.WHO_KNOWS_FRANK);
    Representation queryRep = queryForm.getWebRepresentation();

    pushEndpointResource.post(queryRep);

    Assert.assertEquals(200, pushEndpointResource.getResponse().getStatus().getCode());

    // delete workflow
    ClientResource workflowResource = new ClientResource(url);
    workflowResource.delete();
  }
示例#8
0
  // TODO Die Parameter beim Request werden nicht korrekt übergeben. Keine
  // Ahnung woran es liegt.
  @Test(enabled = false)
  public void testPostCompute() {
    // connect to api
    clientResource.setReference(
        OcciConfig.getInstance().config.getString("occi.server.location") + "compute");
    // Tests if client resource is connected to api
    Assert.assertNotNull(clientResource);
    // try to create a compute resource
    String architecture = "x86";
    String cores = "20";
    String hostname = "Ubuntu";
    String speed = "2000000";
    String memory = "1024";
    String category = "compute";
    // create new request and add all attributes
    Form form = new Form();
    form.add("occi.compute.architecture", architecture);
    form.add("occi.compute.cores", cores);
    form.add("occi.compute.hostname", hostname);
    form.add("occi.compute.speed", speed);
    form.add("occi.compute.memory", memory);
    form.add("category", category);
    System.out.println("\n FORM " + form.toString());
    // create new representation
    Representation representation = null;
    try {
      // send post request
      representation = clientResource.post(form.toString(), MediaType.TEXT_PLAIN);
    } catch (Exception ex) {
      System.out.println("Failed to execute POST request " + ex.getMessage());
    }
    Assert.assertNotNull(representation);
    // get request and print it in debugger
    Request request = Request.getCurrent();
    System.out.println(request.toString() + "\n\n" + form.getMatrixString());
    System.out.println("--------------------------------");
    // get current response
    Response response = Response.getCurrent();
    Assert.assertNotNull(response);
    System.out.println("Response: " + response.toString());

    try {
      representation.write(System.out);
    } catch (IOException e) {
      System.out.println(e.getMessage());
    }
    System.out.println("\n--------------------------------");
  }
 public GetCountry getCountry() {
   GetCountry res = null;
   String post =
       "{\"method\":\"getCountry\",\"header\":{\"wsKey\":\"" + KEY + "\"},\"parameters\":[]}";
   ClientResource cr = new ClientResource(uri + getSignatures(post));
   try {
     res = gson.fromJson(cr.post(post).getText(), GetCountry.class);
   } catch (JsonSyntaxException e) {
     e.printStackTrace();
   } catch (ResourceException e) {
     e.printStackTrace();
   } catch (IOException e) {
     e.printStackTrace();
   }
   return res;
 }
示例#10
0
 public void doPost(String path, String fileToPost) {
   ClientResource cr = new ClientResource(testContext, BASE_URI + path);
   Form form = new Form();
   InputStream in = getClass().getClassLoader().getResourceAsStream(fileToPost);
   try {
     Properties prop = new Properties();
     prop.load(in);
     for (Entry<Object, Object> entry : prop.entrySet()) {
       form.add((String) entry.getKey(), (String) entry.getValue());
     }
     cr.post(form.getWebRepresentation());
   } catch (Exception e) {
     e.printStackTrace();
     Assert.fail();
   }
 }
示例#11
0
    @Override
    protected JSONObject doInBackground(Object... params) {
      Address requestAddress = (Address) params[1];

      ClientResource res = new ClientResource(params[0].toString());
      res.setMethod(Method.POST);

      double latitude = 0;
      double longitude = 0;

      // Location returns null if no position is currently available. In this case, cancel the
      // request.
      if (requestAddress == null) {

        JSONObject o = new JSONObject();
        try {
          o.put("ID", -1);
        } catch (JSONException e) {
          e.printStackTrace();
        }
        return o;
      } else {
        latitude = requestAddress.getLatitude();
        longitude = requestAddress.getLongitude();
      }

      int bottomId = 10000; // Indicates that we want the latest.

      int sort = ((Integer) params[2]).intValue();

      JSONObject obj =
          JSONMessage.getPosts(
              bottomId, "", Double.valueOf(latitude), Double.valueOf(longitude), sort);
      StringRepresentation stringRep = new StringRepresentation(obj.toString());

      stringRep.setMediaType(MediaType.APPLICATION_JSON);
      JSONObject o = null;
      try {
        Representation r = res.post(stringRep);
        o = new JSONObject(r.getText());
      } catch (Exception e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
      }
      return o;
    }
  protected void assertResultsPresentInDataResponse(
      String url,
      ObjectNode body,
      int numberOfResultsExpected,
      String variableName,
      Object variableValue)
      throws JsonProcessingException, IOException {

    // Do the actual call
    ClientResource client = getAuthenticatedClient(url);
    Representation response = client.post(body);

    // Check status and size
    assertEquals(Status.SUCCESS_OK, client.getResponse().getStatus());
    JsonNode dataNode = objectMapper.readTree(response.getStream()).get("data");
    assertEquals(numberOfResultsExpected, dataNode.size());

    // Check presence of ID's
    if (variableName != null) {
      boolean variableFound = false;
      Iterator<JsonNode> it = dataNode.iterator();
      while (it.hasNext()) {
        JsonNode variableNode = it.next();
        String name = variableNode.get("variableName").getTextValue();
        if (variableName.equals(name)) {
          variableFound = true;
          if (variableValue instanceof Boolean) {
            assertTrue(
                "Variable value is not equal",
                variableNode.get("value").asBoolean() == (Boolean) variableValue);
          } else if (variableValue instanceof Integer) {
            assertTrue(
                "Variable value is not equal",
                variableNode.get("value").asInt() == (Integer) variableValue);
          } else {
            assertTrue(
                "Variable value is not equal",
                variableNode.get("value").asText().equals((String) variableValue));
          }
        }
      }
      assertTrue("Variable " + variableName + " is missing", variableFound);
    }

    client.release();
  }
示例#13
0
  /**
   * Performs a test by sending HTTP Gets to the URL, and records the number of bytes returned. Each
   * test results are documented and displayed in standard out with the following information:
   *
   * <p>URL - The source URL of the test REQ CNT - How many times this test has run START - The
   * start time of the last test run STOP - The stop time of the last test run THREAD - The thread
   * id handling this test case RESULT - The result of the test. Either the number of bytes returned
   * or an error message.
   */
  private void doTest() {
    String result = "";
    this.reqCount++;

    // Connect and run test steps
    Date startTime = new Date();
    try {
      ClientResource client = new ClientResource(this.myURL);

      // place order
      JSONObject json = new JSONObject();
      json.put("payment", "quarter");
      json.put("action", "place-order");
      client.post(new JsonRepresentation(json), MediaType.APPLICATION_JSON);

      // Get Gumball Count
      Representation result_string = client.get();
      JSONObject json_count = new JSONObject(result_string.getText());
      result = Integer.toString((int) json_count.get("count"));
    } catch (Exception e) {
      result = e.toString();
    } finally {
      Date stopTime = new Date();
      // Print Report of Result:
      System.out.println(
          "======================================\n"
              + "URL     => "
              + this.myURL
              + "\n"
              + "REQ CNT => "
              + this.reqCount
              + "\n"
              + "START   => "
              + startTime
              + "\n"
              + "STOP    => "
              + stopTime
              + "\n"
              + "THREAD  => "
              + Thread.currentThread().getName()
              + "\n"
              + "RESULT  => "
              + result
              + "\n");
    }
  }
  /**
   * Invoke POST
   *
   * @param item DataSet
   */
  public void create(DataSet item) {
    Representation rep =
        GetRepresentationUtils.getRepresentationDataset(item, MediaType.APPLICATION_JSON);
    ClientResource cr = new ClientResource(getBaseUrl());
    Representation result = cr.post(rep, MediaType.APPLICATION_JSON);
    assertTrue(cr.getStatus().isSuccess());
    assertNotNull(result);

    Response response = getResponse(MediaType.APPLICATION_JSON, result, DataSet.class);
    assertTrue(response.getSuccess());
    assertNotNull(response.getItem());

    DataSet rs = (DataSet) response.getItem();
    assertEquals(rs, item);
    RIAPUtils.exhaust(result);
    cr.release();
  }
 public StartSession getStartSession() {
   StartSession res = null;
   String post =
       "{\"method\":\"startSession\",\"header\":{\"wsKey\":\"" + KEY + "\"},\"parameters\":[]}";
   String sig = getSignatures(post);
   ClientResource cr = new ClientResource(uri + sig);
   try {
     res = gson.fromJson(cr.post(post).getText(), StartSession.class);
   } catch (JsonSyntaxException e) {
     e.printStackTrace();
   } catch (ResourceException e) {
     e.printStackTrace();
   } catch (IOException e) {
     e.printStackTrace();
   }
   return res;
 }
  /**
   * Invoke an order and return the status returned
   *
   * @param urlAttach2 the url attachment of the resource
   * @return the TaskModel returned representing the status of the Task resource
   */
  protected TaskModel invokeOrder(String urlAttach2, String parameters) {
    String url = getHostUrl() + PROJECT_URL + urlAttach2 + parameters;
    Representation result = null;
    try {
      ClientResource cr = new ClientResource(url);
      ChallengeResponse chal =
          new ChallengeResponse(ChallengeScheme.HTTP_BASIC, userLogin, password);
      cr.setChallengeResponse(chal);
      result = cr.post(null, getMediaTest());
      assertNotNull(result);
      assertTrue(cr.getStatus().isSuccess());
      Response response = getResponse(getMediaTest(), result, TaskModel.class);
      assertTrue(response.getSuccess());

      return (TaskModel) response.getItem();
    } finally {
      RIAPUtils.exhaust(result);
    }
  }
  public static void main(String[] args) throws ResourceException, IOException {

    if (args.length != 1) {
      System.err.println("Please specify name of file that includes the request.");
    } else {

      Properties properties = new Properties();
      properties.load(new FileInputStream(args[0]));

      ClientResource comparisonsResource = new ClientResource(properties.getProperty("endpoint"));
      try {
        comparisonsResource.get().write(System.out);
        System.out.println("\n");
      } catch (ResourceException e) {
        System.out.println(e);
      }
      try {
        // first comparison
        String firstComparisonId = UUID.randomUUID().toString();
        Comparison comparison =
            new Comparison(
                firstComparisonId,
                properties.getProperty("dataset1"),
                properties.getProperty("dataset2"),
                properties.getProperty("adapter"),
                properties.getProperty("extractor"),
                properties.getProperty("measure"));
        Representation post = comparisonsResource.post(getComparisonRepresentation(comparison));
        post.write(System.out);
        System.out.println("\n");

        try {
          Thread.sleep(1000);
        } catch (InterruptedException e) {
          // TODO Auto-generated catch block
          e.printStackTrace();
        }
      } catch (ResourceException e) {
        logger.log(Level.SEVERE, "Error connecting to server", e);
      }
    }
  }
  @Test
  public void shouldPostWithEmptyQueryParameters() throws ResourceException {

    // Given
    final String uri = "URI";
    final Map<String, String> queryParameters = new HashMap<String, String>();
    final Map<String, String> headers = new HashMap<String, String>();
    final JSONObject restResponse = mock(JSONObject.class);

    given(resource.post(anyObject(), eq(JSONObject.class))).willReturn(restResponse);
    given(restResponse.toString()).willReturn("{}");

    // When
    final JsonValue response = restClient.post(uri, queryParameters, headers);

    // Then
    verify(resource, never()).addQueryParameter(anyString(), anyString());
    verify(requestHeaders, never()).set(anyString(), anyString());
    verify(resource, never()).getContext();
    assertEquals(response.size(), 0);
  }
  /** Post some JSON to the user userstorage */
  private void postJSON() {
    // http://localhost:8182/sitools/userstorage/admin?filepath=%2Ftmp&filename=SvaRecordDefinitionFile.json
    StringRepresentation repr =
        new StringRepresentation(urlFileContent, MediaType.APPLICATION_JSON);

    Reference reference =
        new Reference(
            getBaseUrl()
                + settings
                    .getString(Consts.APP_USERSTORAGE_USER_URL)
                    .replace("{identifier}", userLogin)
                + "/files");
    reference.addQueryParameter("filename", cartFileName);
    reference.addQueryParameter("filepath", cartFilePath);

    ClientResource cr = new ClientResource(reference);
    ChallengeResponse challenge =
        new ChallengeResponse(ChallengeScheme.HTTP_BASIC, userLogin, password);
    cr.setChallengeResponse(challenge);
    Representation result = cr.post(repr, MediaType.APPLICATION_JSON);
    assertNotNull(result);
    RIAPUtils.exhaust(result);
  }
 /**
  * Handles the HTTP <code>POST</code> method.
  *
  * @param request servlet request
  * @param response servlet response
  * @throws ServletException if a servlet-specific error occurs
  * @throws IOException if an I/O error occurs
  */
 @Override
 protected void doPost(HttpServletRequest request, HttpServletResponse response)
     throws ServletException, IOException {
   response.setContentType("text/html;charset=UTF-8");
   PrintWriter out = response.getWriter();
   String nom2 = request.getParameter("nom");
   String prenom2 = request.getParameter("prenom");
   String tel2 = request.getParameter("telephone");
   String mail2 = request.getParameter("mail");
   String adresse2 = request.getParameter("adresse");
   String diplome2 = request.getParameter("diplome");
   String competence2 = request.getParameter("competence");
   String situationPro2 = request.getParameter("situationPro");
   String url6 = CANDIDAT;
   ClientResource resource6 = new ClientResource(url6);
   Form form2 =
       new Form(
           "nom="
               + nom2
               + "&prenom="
               + prenom2
               + "&tel="
               + tel2
               + "&mail="
               + mail2
               + "&adresse="
               + adresse2
               + "&diplome="
               + diplome2
               + "&competence="
               + competence2
               + "&situationPro="
               + situationPro2);
   form2.encode(CharacterSet.UTF_8);
   Representation rep2 = form2.getWebRepresentation();
   resource6.post(rep2);
 }
  public GetSongSearchResults getSongSearchResults(
      String query, Integer limit, Integer offset, GetCountry country) {

    GetSongSearchResults res = null;
    ClientResource cr = null;
    String post =
        "{\"method\":\"getSongSearchResults\",\"header\":{\"wsKey\":\""
            + KEY
            + "\"},\"parameters\":{\"query\":\""
            + query
            + "\",\"country\":"
            + country.getResult()
            + ",\"limit\":\""
            + limit
            + "\",\"offset\":\""
            + offset
            + "\"}}";
    //		String post = "{\"method\":\"getSongSearchResults\",\"header\":{\"wsKey\":\""+ KEY
    //						+ "\"},\"parameters\":{\"query\":\""+query
    //						+"\",\"country\":\"\",\"limit\":\""+limit
    //						+"\",\"offset\":\""+offset+"\"}}";
    String sig = getSignatures(post);

    cr = new ClientResource(uri + sig);
    try {

      res = gson.fromJson(cr.post(post).getText(), GetSongSearchResults.class);
    } catch (JsonSyntaxException e) {
      e.printStackTrace();
    } catch (ResourceException e) {
      e.printStackTrace();
    } catch (IOException e) {
      e.printStackTrace();
    }
    return res;
  }
  @Deployment
  public void testSubmitFormData() throws Exception {
    Map<String, Object> variableMap = new HashMap<String, Object>();
    variableMap.put("SpeakerName", "John Doe");
    Address address = new Address();
    variableMap.put("address", address);
    ProcessInstance processInstance =
        runtimeService.startProcessInstanceByKey("oneTaskProcess", variableMap);
    String processInstanceId = processInstance.getId();
    String processDefinitionId = processInstance.getProcessDefinitionId();
    Task task = taskService.createTaskQuery().processInstanceId(processInstanceId).singleResult();

    ClientResource client =
        getAuthenticatedClient(RestUrls.createRelativeResourceUrl(RestUrls.URL_FORM_DATA));
    ObjectNode requestNode = objectMapper.createObjectNode();
    requestNode.put("taskId", task.getId());
    ArrayNode propertyArray = objectMapper.createArrayNode();
    requestNode.put("properties", propertyArray);
    ObjectNode propNode = objectMapper.createObjectNode();
    propNode.put("id", "room");
    propNode.put("value", 123l);
    propertyArray.add(propNode);
    try {
      client.post(requestNode);
    } catch (Exception e) {
      // expected
      assertEquals(Status.SERVER_ERROR_INTERNAL, client.getResponse().getStatus());
    }

    propNode = objectMapper.createObjectNode();
    propNode.put("id", "street");
    propNode.put("value", "test");
    propertyArray.add(propNode);
    client.release();
    client.post(requestNode);

    assertEquals(Status.SUCCESS_NO_CONTENT, client.getResponse().getStatus());
    task = taskService.createTaskQuery().processInstanceId(processInstanceId).singleResult();
    assertNull(task);
    processInstance =
        runtimeService
            .createProcessInstanceQuery()
            .processInstanceId(processInstanceId)
            .singleResult();
    assertNull(processInstance);
    List<HistoricVariableInstance> variables =
        historyService
            .createHistoricVariableInstanceQuery()
            .processInstanceId(processInstanceId)
            .list();
    Map<String, HistoricVariableInstance> historyMap =
        new HashMap<String, HistoricVariableInstance>();
    for (HistoricVariableInstance historicVariableInstance : variables) {
      historyMap.put(historicVariableInstance.getVariableName(), historicVariableInstance);
    }

    assertEquals("123", historyMap.get("room").getValue());
    assertEquals(processInstanceId, historyMap.get("room").getProcessInstanceId());

    processInstance = runtimeService.startProcessInstanceByKey("oneTaskProcess", variableMap);
    processInstanceId = processInstance.getId();
    task = taskService.createTaskQuery().processInstanceId(processInstanceId).singleResult();

    requestNode.put("taskId", task.getId());
    propNode = objectMapper.createObjectNode();
    propNode.put("id", "direction");
    propNode.put("value", "nowhere");
    propertyArray.add(propNode);
    try {
      client.release();
      client.post(requestNode);
    } catch (Exception e) {
      // expected
      assertEquals(Status.CLIENT_ERROR_BAD_REQUEST, client.getResponse().getStatus());
    }

    propNode.put("value", "up");
    client.release();
    client.post(requestNode);
    assertEquals(Status.SUCCESS_NO_CONTENT, client.getResponse().getStatus());
    task = taskService.createTaskQuery().processInstanceId(processInstanceId).singleResult();
    assertNull(task);
    processInstance =
        runtimeService
            .createProcessInstanceQuery()
            .processInstanceId(processInstanceId)
            .singleResult();
    assertNull(processInstance);
    variables =
        historyService
            .createHistoricVariableInstanceQuery()
            .processInstanceId(processInstanceId)
            .list();
    historyMap.clear();
    for (HistoricVariableInstance historicVariableInstance : variables) {
      historyMap.put(historicVariableInstance.getVariableName(), historicVariableInstance);
    }

    assertEquals("123", historyMap.get("room").getValue());
    assertEquals(processInstanceId, historyMap.get("room").getProcessInstanceId());
    assertEquals("up", historyMap.get("direction").getValue());

    requestNode = objectMapper.createObjectNode();
    requestNode.put("processDefinitionId", processDefinitionId);
    propertyArray = objectMapper.createArrayNode();
    requestNode.put("properties", propertyArray);
    propNode = objectMapper.createObjectNode();
    propNode.put("id", "number");
    propNode.put("value", 123);
    propertyArray.add(propNode);
    client.release();
    Representation response = client.post(requestNode);
    assertEquals(Status.SUCCESS_OK, client.getResponse().getStatus());
    JsonNode responseNode = objectMapper.readTree(response.getStream());
    assertNotNull(responseNode.get("id").asText());
    assertEquals(processDefinitionId, responseNode.get("processDefinitionId").asText());
    task =
        taskService
            .createTaskQuery()
            .processInstanceId(responseNode.get("id").asText())
            .singleResult();
    assertNotNull(task);
  }