Java Code Examples for io.restassured.response.Response#asString()

@Test
public void testTenantIdListParameter() {
  mockedQuery = setUpMockHistoricProcessInstanceQuery(createMockHistoricProcessInstancesTwoTenants());

  Response response = given()
    .queryParam("tenantIdIn", MockProvider.EXAMPLE_TENANT_ID_LIST)
  .then().expect()
    .statusCode(Status.OK.getStatusCode())
  .when()
    .get(HISTORIC_PROCESS_INSTANCE_RESOURCE_URL);

  verify(mockedQuery).tenantIdIn(MockProvider.EXAMPLE_TENANT_ID, MockProvider.ANOTHER_EXAMPLE_TENANT_ID);
  verify(mockedQuery).list();

  String content = response.asString();
  List<String> executions = from(content).getList("");
  assertThat(executions).hasSize(2);

  String returnedTenantId1 = from(content).getString("[0].tenantId");
  String returnedTenantId2 = from(content).getString("[1].tenantId");

  assertThat(returnedTenantId1).isEqualTo(MockProvider.EXAMPLE_TENANT_ID);
  assertThat(returnedTenantId2).isEqualTo(MockProvider.ANOTHER_EXAMPLE_TENANT_ID);
}
 

@Test
public void testGetErrorDetails() {
  String errorDetails = "someErrorDetails";
  when(mockHistoryService.getHistoricExternalTaskLogErrorDetails(MockProvider.EXAMPLE_HISTORIC_EXTERNAL_TASK_LOG_ID)).thenReturn(errorDetails);

  Response response =
    given()
      .pathParam("id", MockProvider.EXAMPLE_HISTORIC_EXTERNAL_TASK_LOG_ID)
  .then()
    .expect()
      .statusCode(Status.OK.getStatusCode())
      .contentType(ContentType.TEXT)
  .when()
    .get(HISTORIC_EXTERNAL_TASK_LOG_RESOURCE_GET_ERROR_DETAILS_URL);

  String content = response.asString();
  assertEquals(errorDetails, content);
}
 

@Test
public void testGetFilterWithMultipleSorting() {
  TaskQuery query = new TaskQueryImpl()
    .orderByDueDate().asc()
    .orderByCaseExecutionId().desc();

  Filter filter = new FilterEntity("Task").setName("test").setQuery(query);
  when(filterServiceMock.getFilter(EXAMPLE_FILTER_ID)).thenReturn(filter);

  Response response = given()
    .pathParam("id", EXAMPLE_FILTER_ID)
  .then().expect()
    .statusCode(Status.OK.getStatusCode())
  .when()
    .get(SINGLE_FILTER_URL);

  // validate sorting content
  String content = response.asString();
  List<Map<String, Object>> sortings = from(content).getJsonObject("query.sorting");
  assertThat(sortings).hasSize(2);
  assertSorting(sortings.get(0), SORT_BY_DUE_DATE_VALUE, SORT_ORDER_ASC_VALUE);
  assertSorting(sortings.get(1), SORT_BY_CASE_EXECUTION_ID_VALUE, SORT_ORDER_DESC_VALUE);
}
 

@Test
public void testGetRenderedForm() {
  String expectedResult = "<formField>anyContent</formField>";

  when(formServiceMock.getRenderedTaskForm(EXAMPLE_TASK_ID)).thenReturn(expectedResult);

  Response response = given()
    .pathParam("id", EXAMPLE_TASK_ID)
    .then()
      .expect()
        .statusCode(Status.OK.getStatusCode())
        .contentType(XHTML_XML_CONTENT_TYPE)
    .when()
      .get(RENDERED_FORM_URL);

  String responseContent = response.asString();
  Assertions.assertThat(responseContent).isEqualTo(expectedResult);
}
 

@Test
public void testGetDeploymentJpgResourceData() {
  Resource resource = MockProvider.createMockDeploymentJpgResource();

  List<Resource> resources = new ArrayList<Resource>();
  resources.add(resource);

  InputStream input = new ByteArrayInputStream(createMockDeploymentResourceByteData());

  when(mockRepositoryService.getDeploymentResources(eq(EXAMPLE_DEPLOYMENT_ID))).thenReturn(resources);
  when(mockRepositoryService.getResourceAsStreamById(eq(EXAMPLE_DEPLOYMENT_ID), eq(EXAMPLE_DEPLOYMENT_JPG_RESOURCE_ID))).thenReturn(input);

  Response response = given()
      .pathParam("id", EXAMPLE_DEPLOYMENT_ID)
      .pathParam("resourceId", EXAMPLE_DEPLOYMENT_JPG_RESOURCE_ID)
    .then()
      .expect()
        .statusCode(Status.OK.getStatusCode())
        .contentType("image/jpeg")
        .header("Content-Disposition", "attachment; filename=\"" + MockProvider.EXAMPLE_DEPLOYMENT_JPG_RESOURCE_NAME + "\"")
    .when().get(SINGLE_RESOURCE_DATA_URL);

  String responseContent = response.asString();
  assertNotNull(responseContent);
}
 

@Test
public void testWithoutTenantIdPostParameter() {
  mockedQuery = setUpMockHistoricProcessInstanceQuery(Collections.singletonList(MockProvider.createMockHistoricProcessInstance(null)));

  Map<String, Object> queryParameters = new HashMap<String, Object>();
  queryParameters.put("withoutTenantId", true);

  Response response = given()
    .contentType(POST_JSON_CONTENT_TYPE)
    .body(queryParameters)
    .expect()
    .statusCode(Status.OK.getStatusCode())
    .when()
    .post(HISTORIC_PROCESS_INSTANCE_RESOURCE_URL);

  verify(mockedQuery).withoutTenantId();
  verify(mockedQuery).list();

  String content = response.asString();
  List<String> definitions = from(content).getList("");
  assertThat(definitions).hasSize(1);

  String returnedTenantId1 = from(content).getString("[0].tenantId");
  assertThat(returnedTenantId1).isEqualTo(null);
}
 

@Test
public void testTenantIdListParameter() {
  mockedQuery = setUpMockHistoricTaskInstanceQuery(createMockHistoricTaskInstancesTwoTenants());

  Response response = given()
    .queryParam("tenantIdIn", MockProvider.EXAMPLE_TENANT_ID_LIST)
  .then().expect()
    .statusCode(Status.OK.getStatusCode())
  .when()
    .get(HISTORIC_TASK_INSTANCE_RESOURCE_URL);

  verify(mockedQuery).tenantIdIn(MockProvider.EXAMPLE_TENANT_ID, MockProvider.ANOTHER_EXAMPLE_TENANT_ID);
  verify(mockedQuery).list();

  String content = response.asString();
  List<String> executions = from(content).getList("");
  assertThat(executions).hasSize(2);

  String returnedTenantId1 = from(content).getString("[0].tenantId");
  String returnedTenantId2 = from(content).getString("[1].tenantId");

  assertThat(returnedTenantId1).isEqualTo(MockProvider.EXAMPLE_TENANT_ID);
  assertThat(returnedTenantId2).isEqualTo(MockProvider.ANOTHER_EXAMPLE_TENANT_ID);
}
 

@Test
public void testWithoutTenantIdParameter() {
  mockedQuery = setUpMockHistoricCaseInstanceQuery(Arrays.asList(MockProvider.createMockHistoricCaseInstance(null)));

  Response response = given()
    .queryParam("withoutTenantId", true)
  .then().expect()
    .statusCode(Status.OK.getStatusCode())
  .when()
    .get(HISTORIC_CASE_INSTANCE_RESOURCE_URL);

  verify(mockedQuery).withoutTenantId();
  verify(mockedQuery).list();

  String content = response.asString();
  List<String> definitions = from(content).getList("");
  assertThat(definitions).hasSize(1);

  String returnedTenantId1 = from(content).getString("[0].tenantId");
  assertThat(returnedTenantId1).isEqualTo(null);
}
 

@Test
public void testDecisionRequirementsDefinitionRetrievalByList() {
  mockedQuery = createMockQuery(MockProvider.createMockTwoDecisionRequirementsDefinitions());

  Response response = given()
    .queryParam("decisionRequirementsDefinitionIdIn", MockProvider.EXAMPLE_DECISION_REQUIREMENTS_DEFINITION_ID_LIST)
    .then().expect()
      .statusCode(Status.OK.getStatusCode())
    .when()
      .get(DECISION_REQUIREMENTS_DEFINITION_QUERY_URL);

  // assert query invocation
  InOrder inOrder = Mockito.inOrder(mockedQuery);
  inOrder.verify(mockedQuery).decisionRequirementsDefinitionIdIn(MockProvider.EXAMPLE_DECISION_REQUIREMENTS_DEFINITION_ID, MockProvider.ANOTHER_EXAMPLE_DECISION_REQUIREMENTS_DEFINITION_ID);
  inOrder.verify(mockedQuery).list();

  String content = response.asString();
  List<String> definitions = from(content).getList("");
  assertThat(definitions).hasSize(2);

  String returnedDefinitionId1 = from(content).getString("[0].id");
  String returnedDefinitionId2 = from(content).getString("[1].id");

  assertThat(returnedDefinitionId1).isEqualTo(MockProvider.EXAMPLE_DECISION_REQUIREMENTS_DEFINITION_ID);
  assertThat(returnedDefinitionId2).isEqualTo(MockProvider.ANOTHER_EXAMPLE_DECISION_REQUIREMENTS_DEFINITION_ID);
}
 

@Test
public void testWithoutTenantIdPostParameter() {
  mockedQuery = setUpMockHistoricCaseInstanceQuery(Arrays.asList(MockProvider.createMockHistoricCaseInstance(null)));

  Map<String, Object> queryParameters = new HashMap<String, Object>();
  queryParameters.put("withoutTenantId", true);

  Response response = given()
      .contentType(POST_JSON_CONTENT_TYPE)
      .body(queryParameters)
  .expect()
    .statusCode(Status.OK.getStatusCode())
  .when()
    .post(HISTORIC_CASE_INSTANCE_RESOURCE_URL);

  verify(mockedQuery).withoutTenantId();
  verify(mockedQuery).list();

  String content = response.asString();
  List<String> definitions = from(content).getList("");
  assertThat(definitions).hasSize(1);

  String returnedTenantId1 = from(content).getString("[0].tenantId");
  assertThat(returnedTenantId1).isEqualTo(null);
}
 

private void assertCounter(String counterPath) {
    Response response = given().when().get(counterPath);
    String body = response.asString();
    int count = Integer.valueOf(body);
    assertTrue(count > 0);
    response
            .then()
            .statusCode(200);
}
 

@Test
public void testTriggerOnProperty() throws Exception {
    String callback = "validate";
    String propName = "tagId";
    Response response = given().accept(ServiceConstants.UI_SPEC_CONTENT_TYPE) //
                               .expect() //
                               .statusCode(200).log().ifError() //
                               .with() //
                               .body(buildTestDataStoreFormData()) //
                               .contentType(ServiceConstants.UI_SPEC_CONTENT_TYPE) //
                               .post(getVersionPrefix() + "/properties/trigger/{callback}/{propName}", callback, propName);
    assertNotNull(response);
    String content = response.asString();
    assertNotNull(content);
}
 

@Test
public void testJobIdListPostParameter() {
  mockQuery = setUpMockJobQuery(createMockJobsTwoJobIds());

  Map<String, Object> queryParameters = new HashMap<>();
  queryParameters.put("jobIds", MockProvider.EXAMPLE_JOB_ID_LIST.split(","));

  Response response = given()
    .contentType(POST_JSON_CONTENT_TYPE)
    .body(queryParameters)
  .expect()
    .statusCode(Status.OK.getStatusCode())
  .when()
    .post(JOBS_RESOURCE_URL);

  Set<String> expectedIds = new HashSet<>();
  Collections.addAll(expectedIds, MockProvider.EXAMPLE_JOB_ID, MockProvider.ANOTHER_EXAMPLE_JOB_ID);
  verify(mockQuery).jobIds(expectedIds);
  verify(mockQuery).list();

  String content = response.asString();
  List<String> jobs = from(content).getList("");
  assertThat(jobs).hasSize(2);

  String returnedJobId1 = from(content).getString("[0].id");
  String returnedJobId2 = from(content).getString("[1].id");

  assertThat(returnedJobId1).isEqualTo(MockProvider.EXAMPLE_JOB_ID);
  assertThat(returnedJobId2).isEqualTo(MockProvider.ANOTHER_EXAMPLE_JOB_ID);
}
 

@Test
public void testIncludeInputs() {
  mockedQuery = setUpMockHistoricDecisionInstanceQuery(Collections.singletonList(MockProvider.createMockHistoricDecisionInstanceWithInputs()));

  String decisionDefinitionId = MockProvider.EXAMPLE_DECISION_DEFINITION_ID;

  Response response = given()
      .queryParam("decisionDefinitionId", decisionDefinitionId)
      .queryParam("includeInputs", true)
    .then().expect()
      .statusCode(Status.OK.getStatusCode())
    .when()
      .get(HISTORIC_DECISION_INSTANCE_RESOURCE_URL);

  InOrder inOrder = inOrder(mockedQuery);
  inOrder.verify(mockedQuery).decisionDefinitionId(decisionDefinitionId);
  inOrder.verify(mockedQuery).includeInputs();
  inOrder.verify(mockedQuery, never()).includeOutputs();
  inOrder.verify(mockedQuery).list();

  String content = response.asString();
  List<String> instances = from(content).getList("");
  assertEquals(1, instances.size());
  Assert.assertNotNull(instances.get(0));

  List<Map<String, Object>> returnedInputs = from(content).getList("[0].inputs");
  List<Map<String, Object>> returnedOutputs = from(content).getList("[0].outputs");

  assertThat(returnedInputs, is(notNullValue()));
  assertThat(returnedOutputs, is(nullValue()));

  verifyHistoricDecisionInputInstances(returnedInputs);
}
 

@Test
public void testProcessQueryUnfinishedAsPost() {
  List<HistoricProcessInstance> mockedHistoricProcessInstances = MockProvider.createMockRunningHistoricProcessInstances();
  HistoricProcessInstanceQuery mockedhistoricProcessInstanceQuery = mock(HistoricProcessInstanceQuery.class);
  when(mockedhistoricProcessInstanceQuery.list()).thenReturn(mockedHistoricProcessInstances);
  when(processEngine.getHistoryService().createHistoricProcessInstanceQuery()).thenReturn(mockedhistoricProcessInstanceQuery);

  Map<String, Boolean> body = new HashMap<String, Boolean>();
  body.put("unfinished", true);

  Response response = given()
      .contentType(POST_JSON_CONTENT_TYPE)
      .body(body)
    .then()
      .expect()
        .statusCode(Status.OK.getStatusCode())
      .when()
        .post(HISTORIC_PROCESS_INSTANCE_RESOURCE_URL);

  InOrder inOrder = inOrder(mockedhistoricProcessInstanceQuery);
  inOrder.verify(mockedhistoricProcessInstanceQuery).unfinished();
  inOrder.verify(mockedhistoricProcessInstanceQuery).list();

  String content = response.asString();
  List<String> instances = from(content).getList("");
  Assert.assertEquals("There should be one process instance returned.", 1, instances.size());
  Assert.assertNotNull("The returned process instance should not be null.", instances.get(0));

  String returnedProcessInstanceId = from(content).getString("[0].id");
  String returnedEndTime = from(content).getString("[0].endTime");

  Assert.assertEquals(MockProvider.EXAMPLE_PROCESS_INSTANCE_ID, returnedProcessInstanceId);
  Assert.assertEquals(null, returnedEndTime);
}
 

@Test
public void testQueryByTenantIdListPost() {
  mockQuery = setUpMockExternalTaskQuery(createMockExternalTasksTwoTenants());

  Map<String, Object> queryParameters = new HashMap<>();
  queryParameters.put("tenantIdIn", MockProvider.EXAMPLE_TENANT_ID_LIST.split(","));

  Response response = given()
      .contentType(POST_JSON_CONTENT_TYPE)
      .body(queryParameters)
  .expect()
    .statusCode(Status.OK.getStatusCode())
  .when()
    .post(EXTERNAL_TASK_QUERY_URL);

  verify(mockQuery).tenantIdIn(MockProvider.EXAMPLE_TENANT_ID, MockProvider.ANOTHER_EXAMPLE_TENANT_ID);
  verify(mockQuery).list();

  String content = response.asString();
  List<String> executions = from(content).getList("");
  assertThat(executions).hasSize(2);

  String returnedTenantId1 = from(content).getString("[0].tenantId");
  String returnedTenantId2 = from(content).getString("[1].tenantId");

  assertThat(returnedTenantId1).isEqualTo(MockProvider.EXAMPLE_TENANT_ID);
  assertThat(returnedTenantId2).isEqualTo(MockProvider.ANOTHER_EXAMPLE_TENANT_ID);
}
 

@Test
public void testInstanceRetrievalByList() {
  List<ProcessInstance> mockProcessInstanceList = new ArrayList<ProcessInstance>();

  mockProcessInstanceList.add(MockProvider.createMockInstance());
  mockProcessInstanceList.add(MockProvider.createAnotherMockInstance());

  ProcessInstanceQuery instanceQuery = mock(ProcessInstanceQuery.class);

  when(processEngine.getRuntimeService().createProcessInstanceQuery()).thenReturn(instanceQuery);
  when(instanceQuery.list()).thenReturn(mockProcessInstanceList);

  Response response = given()
      .queryParam("processInstanceIds", MockProvider.EXAMPLE_PROCESS_INSTANCE_ID_LIST)
    .then()
      .expect()
        .statusCode(Status.OK.getStatusCode())
      .when()
        .get(PROCESS_INSTANCE_QUERY_URL);

  // assert query invocation
  InOrder inOrder = Mockito.inOrder(instanceQuery);
  Set<String> expectedSet = MockProvider.createMockSetFromList(MockProvider.EXAMPLE_PROCESS_INSTANCE_ID_LIST);

  inOrder.verify(instanceQuery).processInstanceIds(expectedSet);
  inOrder.verify(instanceQuery).list();

  String content = response.asString();
  List<String> instances = from(content).getList("");
  Assert.assertEquals("There should be two process definitions returned.", 2, instances.size());

  String returnedInstanceId1 = from(content).getString("[0].id");
  String returnedInstanceId2 = from(content).getString("[1].id");

  Assert.assertEquals(MockProvider.EXAMPLE_PROCESS_INSTANCE_ID, returnedInstanceId1);
  Assert.assertEquals(MockProvider.ANOTHER_EXAMPLE_PROCESS_INSTANCE_ID, returnedInstanceId2);
}
 

@Test
public void testCorrelationAllWithVariablesInResult() {
  // given
  when(messageCorrelationBuilderMock.correlateAllWithResultAndVariables(false)).thenReturn(execResultWithVariablesList);

  String messageName = "aMessageName";
  Map<String, Object> messageParameters = new HashMap<>();
  messageParameters.put("messageName", messageName);
  messageParameters.put("all", true);
  messageParameters.put("resultEnabled", true);
  messageParameters.put("variablesInResultEnabled", true);

  // when
  Response response = given().contentType(POST_JSON_CONTENT_TYPE)
         .body(messageParameters)
  .then().expect()
         .contentType(ContentType.JSON)
         .statusCode(Status.OK.getStatusCode())
  .when().post(MESSAGE_URL);

  // then
  assertNotNull(response);
  String content = response.asString();
  assertTrue(!content.isEmpty());

  List<HashMap<Object, Object>> results = from(content).getList("");
  assertEquals(1, results.size());
  checkVariablesInResult(content, 0);

  verify(runtimeServiceMock).createMessageCorrelation(eq(messageName));
  verify(messageCorrelationBuilderMock).correlateAllWithResultAndVariables(false);
}
 

@Test
public void testQueryWithoutTenantIdQueryParameter() {
  // given
  List<HistoricDetail> details = new ArrayList<HistoricDetail>();

  historicUpdateBuilder = MockProvider.mockHistoricVariableUpdate(null);
  historicUpdateMock = historicUpdateBuilder.build();
  historicFormFieldMock = MockProvider.createMockHistoricFormField(null);

  details.add(historicUpdateMock);
  details.add(historicFormFieldMock);

  mockedQuery = setUpMockedDetailsQuery(details);

  // when
  Response response = given()
      .queryParam("withoutTenantId", true)
      .then().expect()
      .statusCode(Status.OK.getStatusCode())
      .when()
      .get(HISTORIC_DETAIL_RESOURCE_URL);

  // then
  verify(mockedQuery).withoutTenantId();
  verify(mockedQuery).list();

  String content = response.asString();
  List<String> definitions = from(content).getList("");
  assertThat(definitions).hasSize(2);

  String returnedTenantId = from(content).getString("[0].tenantId");
  assertThat(returnedTenantId).isEqualTo(null);
}
 

@Test
public void testGetSingleHistoricCaseInstance() {
  Response response = given()
      .pathParam("id", MockProvider.EXAMPLE_HISTORIC_CASE_ACTIVITY_INSTANCE_ID)
    .then().expect()
      .statusCode(Status.OK.getStatusCode())
    .when()
      .get(HISTORIC_SINGLE_CASE_ACTIVITY_INSTANCE_URL);

  String content = response.asString();

  String returnedCaseActivityInstanceId = from(content).getString("id");
  String returnedParentCaseActivityInstanceId = from(content).getString("parentCaseActivityInstanceId");
  String returnedCaseActivityId = from(content).getString("caseActivityId");
  String returnedCaseActivityName = from(content).getString("caseActivityName");
  String returnedCaseActivityType = from(content).getString("caseActivityType");
  String returnedCaseDefinitionId = from(content).getString("caseDefinitionId");
  String returnedCaseInstanceId = from(content).getString("caseInstanceId");
  String returnedCaseExecutionId = from(content).getString("caseExecutionId");
  String returnedTaskId = from(content).getString("taskId");
  String returnedCalledProcessInstanceId = from(content).getString("calledProcessInstanceId");
  String returnedCalledCaseInstanceId = from(content).getString("calledCaseInstanceId");
  String returnedCreateTime = from(content).getString("createTime");
  String returnedEndTime = from(content).getString("endTime");
  String returnedTenantId = from(content).getString("tenantId");
  long returnedDurationInMillis = from(content).getLong("durationInMillis");
  boolean required = from(content).getBoolean("required");
  boolean available = from(content).getBoolean("available");
  boolean enabled = from(content).getBoolean("enabled");
  boolean disabled = from(content).getBoolean("disabled");
  boolean active = from(content).getBoolean("active");
  boolean completed = from(content).getBoolean("completed");
  boolean terminated = from(content).getBoolean("terminated");

  Assert.assertEquals(MockProvider.EXAMPLE_HISTORIC_CASE_ACTIVITY_INSTANCE_ID, returnedCaseActivityInstanceId);
  Assert.assertEquals(MockProvider.EXAMPLE_HISTORIC_CASE_ACTIVITY_INSTANCE_PARENT_CASE_ACTIVITY_INSTANCE_ID, returnedParentCaseActivityInstanceId);
  Assert.assertEquals(MockProvider.EXAMPLE_HISTORIC_CASE_ACTIVITY_ID, returnedCaseActivityId);
  Assert.assertEquals(MockProvider.EXAMPLE_HISTORIC_CASE_ACTIVITY_NAME, returnedCaseActivityName);
  Assert.assertEquals(MockProvider.EXAMPLE_HISTORIC_CASE_ACTIVITY_TYPE, returnedCaseActivityType);
  Assert.assertEquals(MockProvider.EXAMPLE_CASE_DEFINITION_ID, returnedCaseDefinitionId);
  Assert.assertEquals(MockProvider.EXAMPLE_CASE_INSTANCE_ID, returnedCaseInstanceId);
  Assert.assertEquals(MockProvider.EXAMPLE_CASE_EXECUTION_ID, returnedCaseExecutionId);
  Assert.assertEquals(MockProvider.EXAMPLE_TASK_ID, returnedTaskId);
  Assert.assertEquals(MockProvider.EXAMPLE_HISTORIC_CASE_ACTIVITY_INSTANCE_CALLED_PROCESS_INSTANCE_ID, returnedCalledProcessInstanceId);
  Assert.assertEquals(MockProvider.EXAMPLE_HISTORIC_CASE_ACTIVITY_INSTANCE_CALLED_CASE_INSTANCE_ID, returnedCalledCaseInstanceId);
  Assert.assertEquals(MockProvider.EXAMPLE_HISTORIC_CASE_ACTIVITY_INSTANCE_CREATE_TIME, returnedCreateTime);
  Assert.assertEquals(MockProvider.EXAMPLE_HISTORIC_CASE_ACTIVITY_INSTANCE_END_TIME, returnedEndTime);
  Assert.assertEquals(MockProvider.EXAMPLE_TENANT_ID, returnedTenantId);
  Assert.assertEquals(MockProvider.EXAMPLE_HISTORIC_CASE_ACTIVITY_INSTANCE_DURATION, returnedDurationInMillis);
  Assert.assertEquals(MockProvider.EXAMPLE_HISTORIC_CASE_ACTIVITY_INSTANCE_IS_REQUIRED, required);
  Assert.assertEquals(MockProvider.EXAMPLE_HISTORIC_CASE_ACTIVITY_INSTANCE_IS_AVAILABLE, available);
  Assert.assertEquals(MockProvider.EXAMPLE_HISTORIC_CASE_ACTIVITY_INSTANCE_IS_ENABLED, enabled);
  Assert.assertEquals(MockProvider.EXAMPLE_HISTORIC_CASE_ACTIVITY_INSTANCE_IS_DISABLED, disabled);
  Assert.assertEquals(MockProvider.EXAMPLE_HISTORIC_CASE_ACTIVITY_INSTANCE_IS_ACTIVE, active);
  Assert.assertEquals(MockProvider.EXAMPLE_HISTORIC_CASE_ACTIVITY_INSTANCE_IS_COMPLETED, completed);
  Assert.assertEquals(MockProvider.EXAMPLE_HISTORIC_CASE_ACTIVITY_INSTANCE_IS_TERMINATED, terminated);
}