org.camunda.bpm.engine.batch.history.HistoricBatchQuery Java Examples

@Test
public void testGetNonExistingHistoricBatch() {
  String nonExistingId = MockProvider.NON_EXISTING_ID;
  HistoricBatchQuery historicBatchQuery = mock(HistoricBatchQuery.class);
  when(historicBatchQuery.batchId(nonExistingId)).thenReturn(historicBatchQuery);
  when(historicBatchQuery.singleResult()).thenReturn(null);
  when(historyServiceMock.createHistoricBatchQuery()).thenReturn(historicBatchQuery);

  given()
    .pathParam("id", nonExistingId)
  .then().expect()
    .statusCode(Status.NOT_FOUND.getStatusCode())
    .body("type", equalTo(InvalidRequestException.class.getSimpleName()))
    .body("message", equalTo("Historic batch with id '" + nonExistingId + "' does not exist"))
  .when()
    .get(HISTORIC_SINGLE_BATCH_RESOURCE_URL);
}
 

@Test
public void shouldThrowBadUserRequestExceptionForBatch() {
  // given

  // then
  thrown.expect(BadUserRequestException.class);
  thrown.expectMessage("historicBatches is empty");

  HistoricBatchQuery query = historyService.createHistoricBatchQuery();

  // when
  historyService.setRemovalTimeToHistoricBatches()
    .absoluteRemovalTime(REMOVAL_TIME)
    .byQuery(query)
    .executeAsync();
}
 

@Test
public void shouldProduceHistoryForBatch() {
  // given
  String processInstanceId = testRule.process().serviceTask().deploy().start();
  Batch batch = historyService.deleteHistoricProcessInstancesAsync(Collections.singletonList(processInstanceId), "");

  testRule.syncExec(batch);

  HistoricBatchQuery query = historyService.createHistoricBatchQuery();

  // when
  testRule.syncExec(
    historyService.setRemovalTimeToHistoricBatches()
      .calculatedRemovalTime()
      .byQuery(query)
      .executeAsync()
  );

  HistoricBatch historicBatch = historyService.createHistoricBatchQuery()
    .type("batch-set-removal-time")
    .singleResult();

  // then
  assertThat(historicBatch.getStartTime()).isEqualTo(CURRENT_DATE);
  assertThat(historicBatch.getEndTime()).isEqualTo(CURRENT_DATE);
}
 

@Test
public void shouldWriteUserOperationLogForBatches() {
  // given
  createBatch(1);

  identityService.setAuthenticatedUserId("aUserId");

  HistoricBatchQuery historicBatchQuery = historyService.createHistoricBatchQuery();

  // when
  historyService.setRemovalTimeToHistoricBatches()
    .calculatedRemovalTime()
    .byQuery(historicBatchQuery)
    .executeAsync();

  List<UserOperationLogEntry> userOperationLogEntries = historyService.createUserOperationLogQuery().list();

  // then
  assertProperties(userOperationLogEntries, "mode", "removalTime", "nrOfInstances", "async");
  assertOperationType(userOperationLogEntries, "SetRemovalTime");
  assertEntityType(userOperationLogEntries, "Batch");
  assertCategory(userOperationLogEntries, "Operator");
}
 

@Test
public void shouldWriteUserOperationLogForBatches_ModeCalculatedRemovalTime() {
  // given
  createBatch(1);

  identityService.setAuthenticatedUserId("aUserId");

  HistoricBatchQuery historicBatchQuery = historyService.createHistoricBatchQuery();

  // when
  historyService.setRemovalTimeToHistoricBatches()
    .calculatedRemovalTime()
    .byQuery(historicBatchQuery)
    .executeAsync();

  UserOperationLogEntry userOperationLogEntry = historyService.createUserOperationLogQuery()
    .property("mode")
    .singleResult();

  // then
  assertThat(userOperationLogEntry.getOrgValue()).isNull();
  assertThat(userOperationLogEntry.getNewValue()).isEqualTo("CALCULATED_REMOVAL_TIME");
}
 

@Test
public void shouldWriteUserOperationLogForBatches_ModeAbsoluteRemovalTime() {
  // given
  createBatch(1);

  identityService.setAuthenticatedUserId("aUserId");

  HistoricBatchQuery historicBatchQuery = historyService.createHistoricBatchQuery();

  // when
  historyService.setRemovalTimeToHistoricBatches()
    .absoluteRemovalTime(new Date())
    .byQuery(historicBatchQuery)
    .executeAsync();

  UserOperationLogEntry userOperationLogEntry = historyService.createUserOperationLogQuery()
    .property("mode")
    .singleResult();

  // then
  assertThat(userOperationLogEntry.getOrgValue()).isNull();
  assertThat(userOperationLogEntry.getNewValue()).isEqualTo("ABSOLUTE_REMOVAL_TIME");
}
 

@Test
public void shouldWriteUserOperationLogForBatches_RemovalTime() {
  // given
  Date removalTime = new Date();

  createBatch(1);

  identityService.setAuthenticatedUserId("aUserId");

  HistoricBatchQuery historicBatchQuery = historyService.createHistoricBatchQuery();

  // when
  historyService.setRemovalTimeToHistoricBatches()
    .absoluteRemovalTime(removalTime)
    .byQuery(historicBatchQuery)
    .executeAsync();

  UserOperationLogEntry userOperationLogEntry = historyService.createUserOperationLogQuery()
    .property("removalTime")
    .singleResult();

  // then
  assertThat(userOperationLogEntry.getOrgValue()).isNull();
  assertThat(fromMillis(userOperationLogEntry.getNewValue())).isEqualToIgnoringMillis(removalTime);
}
 

@Test
public void shouldWriteUserOperationLogForBatches_RemovalTimeNull() {
  // given
  createBatch(1);

  identityService.setAuthenticatedUserId("aUserId");

  HistoricBatchQuery historicBatchQuery = historyService.createHistoricBatchQuery();

  // when
  historyService.setRemovalTimeToHistoricBatches()
    .clearedRemovalTime()
    .byQuery(historicBatchQuery)
    .executeAsync();

  UserOperationLogEntry userOperationLogEntry = historyService.createUserOperationLogQuery()
    .property("removalTime")
    .singleResult();

  // then
  assertThat(userOperationLogEntry.getOrgValue()).isNull();
  assertThat(userOperationLogEntry.getNewValue()).isNull();
}
 

@Test
public void shouldWriteUserOperationLogForBatches_NrOfInstances() {
  // given
  createBatch(2);

  identityService.setAuthenticatedUserId("aUserId");

  HistoricBatchQuery historicBatchQuery = historyService.createHistoricBatchQuery();

  // when
  historyService.setRemovalTimeToHistoricBatches()
    .clearedRemovalTime()
    .byQuery(historicBatchQuery)
    .executeAsync();

  UserOperationLogEntry userOperationLogEntry = historyService.createUserOperationLogQuery()
    .property("nrOfInstances")
    .singleResult();

  // then
  assertThat(userOperationLogEntry.getOrgValue()).isNull();
  assertThat(userOperationLogEntry.getNewValue()).isEqualTo("2");
}
 

protected void applyFilters(HistoricBatchQuery query) {
  if (batchId != null) {
    query.batchId(batchId);
  }
  if (type != null) {
    query.type(type);
  }
  if (completed != null) {
    query.completed(completed);
  }
  if (Boolean.TRUE.equals(withoutTenantId)) {
    query.withoutTenantId();
  }
  if (tenantIds != null && !tenantIds.isEmpty()) {
    query.tenantIdIn(tenantIds.toArray(new String[tenantIds.size()]));
  }
}
 

@SuppressWarnings("unchecked")
@Override
public List<HistoricBatchDto> getHistoricBatches(UriInfo uriInfo, Integer firstResult, Integer maxResults) {
  HistoricBatchQueryDto queryDto = new HistoricBatchQueryDto(objectMapper, uriInfo.getQueryParameters());
  HistoricBatchQuery query = queryDto.toQuery(processEngine);

  List<HistoricBatch> matchingBatches;
  if (firstResult != null || maxResults != null) {
    matchingBatches = (List<HistoricBatch>) executePaginatedQuery(query, firstResult, maxResults);
  }
  else {
    matchingBatches = query.list();
  }

  List<HistoricBatchDto> batchResults = new ArrayList<HistoricBatchDto>();
  for (HistoricBatch matchingBatch : matchingBatches) {
    batchResults.add(HistoricBatchDto.fromBatch(matchingBatch));
  }
  return batchResults;
}
 

@Test
public void shouldWriteUserOperationLogForBatches_AsyncTrue() {
  // given
  createBatch(1);

  identityService.setAuthenticatedUserId("aUserId");

  HistoricBatchQuery historicBatchQuery = historyService.createHistoricBatchQuery();

  // when
  historyService.setRemovalTimeToHistoricBatches()
    .clearedRemovalTime()
    .byQuery(historicBatchQuery)
    .executeAsync();

  UserOperationLogEntry userOperationLogEntry = historyService.createUserOperationLogQuery()
    .property("async")
    .singleResult();

  // then
  assertThat(userOperationLogEntry.getOrgValue()).isNull();
  assertThat(userOperationLogEntry.getNewValue()).isEqualTo("true");
}
 

@Test
public void shouldSetRemovalTimeToBatch_Incident() {
  // given
  String processInstance = testRule.process().failingCustomListener().deploy().start();
  Batch batch = runtimeService.deleteProcessInstancesAsync(Collections.singletonList(processInstance), "aDeleteReason");

  String jobId = managementService.createJobQuery().singleResult().getId();
  managementService.setJobRetries(jobId, 0);

  HistoricIncident historicIncident = historyService.createHistoricIncidentQuery().singleResult();

  // assume
  assertThat(historicIncident.getRemovalTime()).isNull();

  HistoricBatchQuery query = historyService.createHistoricBatchQuery();

  // when
  testRule.syncExec(
    historyService.setRemovalTimeToHistoricBatches()
      .absoluteRemovalTime(REMOVAL_TIME)
      .byQuery(query)
      .executeAsync()
  );

  historicIncident = historyService.createHistoricIncidentQuery().singleResult();

  // then
  assertThat(historicIncident.getRemovalTime()).isEqualTo(REMOVAL_TIME);

  // clear database
  managementService.deleteBatch(batch.getId(), true);
  runtimeService.deleteProcessInstance(processInstance, "", true);
}
 

@Test
public void shouldSetRemovalTimeForBatch_Null() {
  // given
  ProcessEngineConfigurationImpl configuration = testRule.getProcessEngineConfiguration();

  configuration.setBatchOperationHistoryTimeToLive("P5D");
  configuration.initHistoryCleanup();

  String processInstanceId = testRule.process().serviceTask().deploy().start();
  Batch batch = historyService.deleteHistoricProcessInstancesAsync(Collections.singletonList(processInstanceId), "");

  HistoricBatch historicBatch = historyService.createHistoricBatchQuery()
    .type(Batch.TYPE_HISTORIC_PROCESS_INSTANCE_DELETION)
    .singleResult();

  // assume
  assertThat(historicBatch.getRemovalTime()).isNotNull();

  HistoricBatchQuery query = historyService.createHistoricBatchQuery()
    .type(Batch.TYPE_HISTORIC_PROCESS_INSTANCE_DELETION);

  // when
  testRule.syncExec(
    historyService.setRemovalTimeToHistoricBatches()
      .clearedRemovalTime()
      .byQuery(query)
      .executeAsync()
  );

  historicBatch = historyService.createHistoricBatchQuery()
    .type(Batch.TYPE_HISTORIC_PROCESS_INSTANCE_DELETION)
    .singleResult();

  // then
  assertThat(historicBatch.getRemovalTime()).isNull();

  // clear database
  managementService.deleteBatch(batch.getId(), true);
}
 

@Test
public void shouldSetRemovalTimeForBatch_Absolute() {
  // given
  String processInstanceId = testRule.process().serviceTask().deploy().start();
  Batch batch = historyService.deleteHistoricProcessInstancesAsync(Collections.singletonList(processInstanceId), "");

  HistoricBatch historicBatch = historyService.createHistoricBatchQuery()
    .type(Batch.TYPE_HISTORIC_PROCESS_INSTANCE_DELETION)
    .singleResult();

  // assume
  assertThat(historicBatch.getRemovalTime()).isNull();

  HistoricBatchQuery query = historyService.createHistoricBatchQuery()
    .type(Batch.TYPE_HISTORIC_PROCESS_INSTANCE_DELETION);

  // when
  testRule.syncExec(
    historyService.setRemovalTimeToHistoricBatches()
      .absoluteRemovalTime(REMOVAL_TIME)
      .byQuery(query)
      .executeAsync()
  );

  historicBatch = historyService.createHistoricBatchQuery()
    .type(Batch.TYPE_HISTORIC_PROCESS_INSTANCE_DELETION)
    .singleResult();

  // then
  assertThat(historicBatch.getRemovalTime()).isEqualTo(REMOVAL_TIME);

  // clear database
  managementService.deleteBatch(batch.getId(), true);
}
 

@Test
public void shouldClearRemovalTimeForBatch_BaseTimeEnd() {
  // given
  ProcessEngineConfigurationImpl configuration = testRule.getProcessEngineConfiguration();
  configuration.setBatchOperationHistoryTimeToLive("P5D");
  configuration.initHistoryCleanup();

  String processInstanceId = testRule.process().serviceTask().deploy().start();
  Batch batch = historyService.deleteHistoricProcessInstancesAsync(Collections.singletonList(processInstanceId), "");

  HistoricBatch historicBatch = historyService.createHistoricBatchQuery()
    .type(Batch.TYPE_HISTORIC_PROCESS_INSTANCE_DELETION)
    .singleResult();

  // assume
  assertThat(historicBatch.getRemovalTime()).isNotNull();

  configuration.setHistoryRemovalTimeStrategy(HISTORY_REMOVAL_TIME_STRATEGY_END);

  HistoricBatchQuery query = historyService.createHistoricBatchQuery()
    .type(Batch.TYPE_HISTORIC_PROCESS_INSTANCE_DELETION);

  // when
  testRule.syncExec(
    historyService.setRemovalTimeToHistoricBatches()
      .calculatedRemovalTime()
      .byQuery(query)
      .executeAsync()
  );

  historicBatch = historyService.createHistoricBatchQuery()
    .type(Batch.TYPE_HISTORIC_PROCESS_INSTANCE_DELETION)
    .singleResult();

  // then
  assertThat(historicBatch.getRemovalTime()).isNull();

  // clear database
  managementService.deleteBatch(batch.getId(), true);
}
 

@Test
public void shouldSetRemovalTimeForBatch_BaseTimeStart() {
  // given
  String processInstanceId = testRule.process().serviceTask().deploy().start();
  Batch batch = historyService.deleteHistoricProcessInstancesAsync(Collections.singletonList(processInstanceId), "");

  HistoricBatch historicBatch = historyService.createHistoricBatchQuery()
    .type(Batch.TYPE_HISTORIC_PROCESS_INSTANCE_DELETION)
    .singleResult();

  // assume
  assertThat(historicBatch.getRemovalTime()).isNull();

  ProcessEngineConfigurationImpl configuration = testRule.getProcessEngineConfiguration();
  configuration.setBatchOperationHistoryTimeToLive("P5D");
  configuration.initHistoryCleanup();

  HistoricBatchQuery query = historyService.createHistoricBatchQuery()
    .type(Batch.TYPE_HISTORIC_PROCESS_INSTANCE_DELETION);

  // when
  testRule.syncExec(
    historyService.setRemovalTimeToHistoricBatches()
      .calculatedRemovalTime()
      .byQuery(query)
      .executeAsync()
  );

  historicBatch = historyService.createHistoricBatchQuery()
    .type(Batch.TYPE_HISTORIC_PROCESS_INSTANCE_DELETION)
    .singleResult();

  // then
  assertThat(historicBatch.getRemovalTime()).isEqualTo(addDays(CURRENT_DATE, 5));

  // clear database
  managementService.deleteBatch(batch.getId(), true);
}
 

@Before
public void setUpHistoricBatchQueryMock() {
  HistoricBatch historicBatchMock = MockProvider.createMockHistoricBatch();

  queryMock = mock(HistoricBatchQuery.class);
  when(queryMock.batchId(eq(MockProvider.EXAMPLE_BATCH_ID))).thenReturn(queryMock);
  when(queryMock.singleResult()).thenReturn(historicBatchMock);

  historyServiceMock = mock(HistoryService.class);
  when(historyServiceMock.createHistoricBatchQuery()).thenReturn(queryMock);

  when(processEngine.getHistoryService()).thenReturn(historyServiceMock);
}
 

@Test
public void shouldThrowExceptionIfNoRemovalTimeSettingDefinedForBatch() {
  // given
  HistoricBatchQuery query = historyService.createHistoricBatchQuery();

  SetRemovalTimeToHistoricBatchesBuilder batchBuilder = historyService.setRemovalTimeToHistoricBatches()
    .byQuery(query);

  // then
  thrown.expect(BadUserRequestException.class);
  thrown.expectMessage("removalTime is null");

  // when
  batchBuilder.executeAsync();
}
 

@Before
public void setUpHistoricBatchQueryMock() {
  List<HistoricBatch> mockHistoricBatches = MockProvider.createMockHistoricBatches();
  queryMock = mock(HistoricBatchQuery.class);

  when(queryMock.list()).thenReturn(mockHistoricBatches);
  when(queryMock.count()).thenReturn((long) mockHistoricBatches.size());

  when(processEngine.getHistoryService().createHistoricBatchQuery()).thenReturn(queryMock);
}
 

@Override
public CountResultDto getHistoricBatchesCount(UriInfo uriInfo) {
  HistoricBatchQueryDto queryDto = new HistoricBatchQueryDto(objectMapper, uriInfo.getQueryParameters());
  HistoricBatchQuery query = queryDto.toQuery(processEngine);

  long count = query.count();
  return new CountResultDto(count);
}
 

@Test
public void shouldSetRemovalTimeToBatch_JobLog() {
  // given
  String processInstanceId = testRule.process().userTask().deploy().start();

  Batch batch = runtimeService.deleteProcessInstancesAsync(Collections.singletonList(processInstanceId), "aDeleteReason");

  HistoricJobLog historicJobLog = historyService.createHistoricJobLogQuery()
    .jobDefinitionConfiguration(batch.getId())
    .singleResult();

  // assume
  assertThat(historicJobLog.getRemovalTime()).isNull();

  HistoricBatchQuery query = historyService.createHistoricBatchQuery();

  // when
  testRule.syncExec(
    historyService.setRemovalTimeToHistoricBatches()
      .absoluteRemovalTime(REMOVAL_TIME)
      .byQuery(query)
      .executeAsync()
  );

  historicJobLog = historyService.createHistoricJobLogQuery()
    .jobDefinitionConfiguration(batch.getId())
    .singleResult();

  // then
  assertThat(historicJobLog.getRemovalTime()).isEqualTo(REMOVAL_TIME);

  // clear database
  managementService.deleteBatch(batch.getId(), true);
}
 

@Test
public void shouldSetRemovalTimeToBatch() {
  // given
  String processInstanceId = testRule.process().userTask().deploy().start();

  Batch batch = runtimeService.deleteProcessInstancesAsync(Collections.singletonList(processInstanceId), "aDeleteReason");

  HistoricBatch historicBatch = historyService.createHistoricBatchQuery().singleResult();

  // assume
  assertThat(historicBatch.getRemovalTime()).isNull();

  HistoricBatchQuery query = historyService.createHistoricBatchQuery();

  // when
  testRule.syncExec(
    historyService.setRemovalTimeToHistoricBatches()
      .absoluteRemovalTime(REMOVAL_TIME)
      .byQuery(query)
      .executeAsync()
  );

  historicBatch = historyService.createHistoricBatchQuery()
    .type(Batch.TYPE_PROCESS_INSTANCE_DELETION)
    .singleResult();

  // then
  assertThat(historicBatch.getRemovalTime()).isEqualTo(REMOVAL_TIME);

  // clear database
  managementService.deleteBatch(batch.getId(), true);
}
 

@Test
@RequiredHistoryLevel(ProcessEngineConfiguration.HISTORY_FULL)
public void shouldAuthorizeSetRemovalTimeForHistoricBatchesBatch() {
  // given
  String batchId = engineRule.getHistoryService()
    .deleteHistoricProcessInstancesAsync(Collections.singletonList(processInstance.getId()), "aDeleteReason").getId();

  authRule
      .init(scenario)
      .withUser("userId")
      .bindResource("batchId", "*")
      .start();

  HistoricBatchQuery query = historyService.createHistoricBatchQuery().batchId(batchId);

  // when
  historyService.setRemovalTimeToHistoricBatches()
    .absoluteRemovalTime(new Date())
    .byQuery(query)
    .executeAsync();

  // then
  authRule.assertScenario(scenario);

  // clear database
  managementService.deleteBatch(batchId, true);
}
 

protected void applySortBy(HistoricBatchQuery query, String sortBy, Map<String, Object> parameters, ProcessEngine engine) {
  if (sortBy.equals(SORT_BY_BATCH_ID_VALUE)) {
    query.orderById();
  }
  if (sortBy.equals(SORT_BY_BATCH_START_TIME_VALUE)) {
    query.orderByStartTime();
  }
  if (sortBy.equals(SORT_BY_BATCH_END_TIME_VALUE)) {
    query.orderByEndTime();
  }
  if (sortBy.equals(SORT_BY_TENANT_ID_VALUE)) {
    query.orderByTenantId();
  }
}
 

@Override
public Batch execute(CommandContext commandContext) {
  List<String> instanceIds = builder.getIds();
  HistoricBatchQuery instanceQuery = builder.getQuery();
  if (instanceQuery == null && instanceIds == null) {
    throw new BadUserRequestException("Neither query nor ids provided.");

  }

  Collection<String> collectedInstanceIds = new HashSet<>();
  if (instanceQuery != null) {
    for (HistoricBatch historicBatch : instanceQuery.list()) {
      collectedInstanceIds.add(historicBatch.getId());

    }
  }

  if (instanceIds != null) {
    collectedInstanceIds.addAll(findHistoricInstanceIds(instanceIds, commandContext));

  }

  ensureNotNull(BadUserRequestException.class, "removalTime", builder.getMode());
  ensureNotEmpty(BadUserRequestException.class, "historicBatches", collectedInstanceIds);

  return new BatchBuilder(commandContext)
      .type(Batch.TYPE_BATCH_SET_REMOVAL_TIME)
      .config(getConfiguration(collectedInstanceIds))
      .permission(BatchPermissions.CREATE_BATCH_SET_REMOVAL_TIME)
      .operationLogHandler(this::writeUserOperationLog)
      .build();
}
 

@Test
public void shouldSetRemovalTimeForBatch_BothQueryAndIdsDefined() {
  // given
  String processInstanceId = testRule.process().serviceTask().deploy().start();
  Batch batchOne = historyService.deleteHistoricProcessInstancesAsync(Collections.singletonList(processInstanceId), "");
  Batch batchTwo = historyService.deleteHistoricProcessInstancesAsync(Collections.singletonList(processInstanceId), "");

  List<HistoricBatch> historicBatches = historyService.createHistoricBatchQuery()
    .type(Batch.TYPE_HISTORIC_PROCESS_INSTANCE_DELETION)
    .list();

  // assume
  assertThat(historicBatches.get(0).getRemovalTime()).isNull();
  assertThat(historicBatches.get(1).getRemovalTime()).isNull();

  ProcessEngineConfigurationImpl configuration = testRule.getProcessEngineConfiguration();
  configuration.setBatchOperationHistoryTimeToLive("P5D");
  configuration.initHistoryCleanup();

  HistoricBatchQuery query = historyService.createHistoricBatchQuery()
    .type(Batch.TYPE_HISTORIC_PROCESS_INSTANCE_DELETION)
    .batchId(batchOne.getId());

  // when
  testRule.syncExec(
    historyService.setRemovalTimeToHistoricBatches()
      .calculatedRemovalTime()
      .byQuery(query)
      .byIds(batchTwo.getId())
      .executeAsync()
  );

  historicBatches = historyService.createHistoricBatchQuery()
    .type(Batch.TYPE_HISTORIC_PROCESS_INSTANCE_DELETION)
    .list();

  // then
  assertThat(historicBatches.get(0).getRemovalTime()).isEqualTo(addDays(CURRENT_DATE, 5));
  assertThat(historicBatches.get(1).getRemovalTime()).isEqualTo(addDays(CURRENT_DATE, 5));

  // clear database
  managementService.deleteBatch(batchOne.getId(), true);
  managementService.deleteBatch(batchTwo.getId(), true);
}
 

@Test
public void shouldNotSetRemovalTimeForBatch_BaseTimeEnd() {
  // given
  ProcessEngineConfigurationImpl configuration = testRule.getProcessEngineConfiguration();

  configuration
    .setHistoryRemovalTimeStrategy(HISTORY_REMOVAL_TIME_STRATEGY_END);

  String processInstanceId = testRule.process().serviceTask().deploy().start();
  Batch batch = historyService.deleteHistoricProcessInstancesAsync(Collections.singletonList(processInstanceId), "");

  HistoricBatch historicBatch = historyService.createHistoricBatchQuery()
    .type(Batch.TYPE_HISTORIC_PROCESS_INSTANCE_DELETION)
    .singleResult();

  // assume
  assertThat(historicBatch.getRemovalTime()).isNull();

  configuration.setBatchOperationHistoryTimeToLive("P5D");
  configuration.initHistoryCleanup();

  HistoricBatchQuery query = historyService.createHistoricBatchQuery()
    .type(Batch.TYPE_HISTORIC_PROCESS_INSTANCE_DELETION);

  // when
  testRule.syncExec(
    historyService.setRemovalTimeToHistoricBatches()
      .calculatedRemovalTime()
      .byQuery(query)
      .executeAsync()
  );

  historicBatch = historyService.createHistoricBatchQuery()
    .type(Batch.TYPE_HISTORIC_PROCESS_INSTANCE_DELETION)
    .singleResult();

  // then
  assertThat(historicBatch.getRemovalTime()).isNull();

  // clear database
  managementService.deleteBatch(batch.getId(), true);
}
 

protected HistoricBatchQuery createNewQuery(ProcessEngine engine) {
  return engine.getHistoryService().createHistoricBatchQuery();
}
 

protected HistoricBatchQuery createHistoricBatchQuery(CommandContext commandContext) {
  return commandContext.getProcessEngineConfiguration()
    .getHistoryService()
    .createHistoricBatchQuery();
}