Java Code Examples for org.camunda.bpm.engine.impl.util.ClockUtil#reset()

@RequiredHistoryLevel(ProcessEngineConfiguration.HISTORY_FULL)
@Deployment(resources = { "org/camunda/bpm/engine/test/api/runtime/oneTaskProcess.bpmn20.xml" })
public void testTaskReturnedBeforeEndTime() {
  // given
  Task taskOne = taskService.newTask("taskOne");

  // when
  taskOne.setAssignee("aUserId");
  taskService.saveTask(taskOne);

  Calendar hourAgo = Calendar.getInstance();
  hourAgo.add(Calendar.HOUR_OF_DAY, -1);
  ClockUtil.setCurrentTime(hourAgo.getTime());

  taskService.complete(taskOne.getId());

  List<HistoricTaskInstance> list = historyService.createHistoricTaskInstanceQuery()
          .finishedBefore(hourAgo.getTime()).list();

  // then
  assertEquals(1, list.size());

  // cleanup
  taskService.deleteTask("taskOne",true);
  ClockUtil.reset();
}
 

@DescribesScenario("initExternalTaskLockExpTime")
@Times(1)
public static ScenarioSetup initExternalTaskLockExpTime() {
  return new ScenarioSetup() {
    @Override
    public void execute(ProcessEngine processEngine, String scenarioName) {

      ClockUtil.setCurrentTime(TIMESTAMP);

      deployModel(processEngine, PROCESS_DEFINITION_KEY, PROCESS_DEFINITION_KEY, EXT_TASK_MODEL);

      processEngine.getRuntimeService()
        .startProcessInstanceByKey(PROCESS_DEFINITION_KEY, scenarioName);

      processEngine.getExternalTaskService()
        .fetchAndLock(1, WORKER_ID)
        .topic(TOPIC_NAME, LOCK_TIME)
        .execute();

      ClockUtil.reset();
    }
  };
}
 

@DescribesScenario("initIncidentTimestamp")
@Times(1)
public static ScenarioSetup initIncidentTimestamp() {
  return new ScenarioSetup() {
    @Override
    public void execute(ProcessEngine processEngine, String scenarioName) {

      ClockUtil.setCurrentTime(TIMESTAMP);

      deployModel(processEngine, PROCESS_DEFINITION_KEY, PROCESS_DEFINITION_KEY, FAILING_SERVICE_TASK_MODEL);

      String processInstanceId = processEngine.getRuntimeService()
        .startProcessInstanceByKey(PROCESS_DEFINITION_KEY, scenarioName)
        .getId();

      causeIncident(processEngine, processInstanceId);

      ClockUtil.reset();
    }
  };
}
 

@AfterClass
public static void tearDownAfterAll() {
  if (engineConfiguration != null) {
    engineConfiguration
      .setHistoryRemovalTimeProvider(null)
      .setHistoryRemovalTimeStrategy(null)
      .initHistoryRemovalTime();

    engineConfiguration.setHistoryCleanupStrategy(HISTORY_CLEANUP_STRATEGY_END_TIME_BASED);

    engineConfiguration.setHistoryCleanupBatchSize(MAX_BATCH_SIZE);
    engineConfiguration.setHistoryCleanupBatchWindowStartTime(null);
    engineConfiguration.setHistoryCleanupDegreeOfParallelism(1);

    engineConfiguration.initHistoryCleanup();
  }

  ClockUtil.reset();
}
 

@Deployment(resources = { DECISION_PROCESS, DECISION_SINGLE_OUTPUT_DMN })
public void testQueryByEvaluatedAfter() {
  Date beforeEvaluated = new Date(1441612000);
  Date evaluated = new Date(1441613000);
  Date afterEvaluated = new Date(1441614000);

  ClockUtil.setCurrentTime(evaluated);
  startProcessInstanceAndEvaluateDecision();

  HistoricDecisionInstanceQuery query = historyService.createHistoricDecisionInstanceQuery();
  assertThat(query.evaluatedAfter(beforeEvaluated).count(), is(1L));
  assertThat(query.evaluatedAfter(evaluated).count(), is(1L));
  assertThat(query.evaluatedAfter(afterEvaluated).count(), is(0L));

  ClockUtil.reset();
}
 

@AfterClass
public static void tearDownAfterAll() {
  if (engineConfiguration != null) {
    engineConfiguration
      .setHistoryRemovalTimeProvider(null)
      .setHistoryRemovalTimeStrategy(null)
      .initHistoryRemovalTime();

    engineConfiguration.setHistoryCleanupStrategy(HISTORY_CLEANUP_STRATEGY_REMOVAL_TIME_BASED);

    engineConfiguration.setHistoryCleanupBatchSize(MAX_BATCH_SIZE);
    engineConfiguration.setHistoryCleanupBatchWindowStartTime(null);
    engineConfiguration.setHistoryCleanupDegreeOfParallelism(1);

    engineConfiguration.setBatchOperationHistoryTimeToLive(null);
    engineConfiguration.setBatchOperationsForHistoryCleanup(null);

    engineConfiguration.initHistoryCleanup();

    engineConfiguration.setAuthorizationEnabled(false);
    engineConfiguration.setEnableHistoricInstancePermissions(false);
  }

  ClockUtil.reset();
}
 

protected void finished(Description description) {
  getProcessEngineConfiguration()
    .setHistoryRemovalTimeProvider(null)
    .setHistoryRemovalTimeStrategy(null)
    .initHistoryRemovalTime();

  getProcessEngineConfiguration().setBatchOperationHistoryTimeToLive(null);
  getProcessEngineConfiguration().setBatchOperationsForHistoryCleanup(null);

  getProcessEngineConfiguration().setBatchOperationHistoryTimeToLive(null);
  getProcessEngineConfiguration().setHistoryCleanupStrategy(null);
  getProcessEngineConfiguration().initHistoryCleanup();

  getProcessEngineConfiguration().setInvocationsPerBatchJob(1);

  getProcessEngineConfiguration().setDmnEnabled(true);

  DefaultDmnEngineConfiguration dmnEngineConfiguration =
      getProcessEngineConfiguration().getDmnEngineConfiguration();

  ResetDmnConfigUtil.reset(dmnEngineConfiguration)
      .enableFeelLegacyBehavior(false)
      .init();

  ClockUtil.reset();

  clearDatabase();

  getProcessEngineConfiguration().setEnableHistoricInstancePermissions(false);
  getProcessEngineConfiguration().setAuthorizationEnabled(false);

  super.finished(description);
}
 

@After
public void cleanUp() {
  ClockUtil.reset();
  migrationHelper.removeAllRunningAndHistoricBatches();
  processEngineConfiguration.setBatchOperationHistoryTimeToLive(null);
  processEngineConfiguration.setBatchOperationsForHistoryCleanup(null);
}
 

@Test
public void resultIsSortedByEndTime() {
   // given
  BpmnModelInstance simpleDefinition = Bpmn.createExecutableProcess("process")
    .startEvent("startEvent")
    .serviceTask("ServiceTask1")
      .camundaExpression("${true}")
      .camundaExecutionListenerClass(EVENTNAME_START, ShiftTimeByOneMinuteListener.class.getName())
    .serviceTask("ServiceTask2")
      .camundaExpression("${true}")
      .camundaExecutionListenerClass(EVENTNAME_START, ShiftTimeByOneMinuteListener.class.getName())
    .serviceTask("ServiceTask3")
      .camundaExpression("${true}")
      .camundaExecutionListenerClass(EVENTNAME_START, ShiftTimeByOneMinuteListener.class.getName())
    .endEvent("endEvent")
      .camundaExecutionListenerClass(EVENTNAME_START, ShiftTimeByOneMinuteListener.class.getName())
    .done();
  testHelper.deploy(simpleDefinition);
  ClockUtil.setCurrentTime(new Date());
  engineRule.getRuntimeService().startProcessInstanceByKey("process");
  ClockUtil.reset();

  // when
  List<HistoricActivityInstance> completedHistoricActivityInstances =
    optimizeService.getCompletedHistoricActivityInstances(pastDate(), null, 4);

  // then
  assertThat(completedHistoricActivityInstances.size(), is(4));
  assertThat(completedHistoricActivityInstances.get(0).getActivityId(), is("startEvent"));
  assertThat(completedHistoricActivityInstances.get(1).getActivityId(), is("ServiceTask1"));
  assertThat(completedHistoricActivityInstances.get(2).getActivityId(), is("ServiceTask2"));
  assertThat(completedHistoricActivityInstances.get(3).getActivityId(), is("ServiceTask3"));
}
 

@RequiredHistoryLevel(ProcessEngineConfiguration.HISTORY_FULL)
@Deployment(resources = { "org/camunda/bpm/engine/test/api/runtime/oneTaskProcess.bpmn20.xml" })
public void testTaskNotReturnedAfterEndTime() {
  // given
  Task taskOne = taskService.newTask("taskOne");

  // when
  taskOne.setAssignee("aUserId");
  taskService.saveTask(taskOne);

  Calendar hourAgo = Calendar.getInstance();
  hourAgo.add(Calendar.HOUR_OF_DAY, -1);
  ClockUtil.setCurrentTime(hourAgo.getTime());

  taskService.complete(taskOne.getId());

  List<HistoricTaskInstance> list = historyService.createHistoricTaskInstanceQuery()
          .finishedAfter(Calendar.getInstance().getTime()).list();

  // then
  assertEquals(0, list.size());

  // cleanup
  taskService.deleteTask("taskOne",true);

  ClockUtil.reset();
}
 

@After
public void cleanUp() {
  for (User user : identityService.createUserQuery().list()) {
    identityService.deleteUser(user.getId());
  }
  for (Group group : identityService.createGroupQuery().list()) {
    identityService.deleteGroup(group.getId());
  }
  for (Authorization authorization : authorizationService.createAuthorizationQuery().list()) {
    authorizationService.deleteAuthorization(authorization.getId());
  }
  ClockUtil.reset();
}
 

@After
public void cleanUp() {
  for (User user : identityService.createUserQuery().list()) {
    identityService.deleteUser(user.getId());
  }
  for (Group group : identityService.createGroupQuery().list()) {
    identityService.deleteGroup(group.getId());
  }
  for (Authorization authorization : authorizationService.createAuthorizationQuery().list()) {
    authorizationService.deleteAuthorization(authorization.getId());
  }
  ClockUtil.reset();
}
 

@After
public void resetClock() {
  ClockUtil.reset();
}
 

protected void tearDown() throws Exception {
  ClockUtil.reset();
}
 

@After
public void tearDown() {
  ClockUtil.reset();
}
 

@After
public void resetClock() {
  ClockUtil.reset();
}
 

@After
public void resetClock() {
  ClockUtil.reset();
}
 

@After
public void resetClock() {
  ClockUtil.reset();
}
 

@After
public void resetClock() {
  ClockUtil.reset();
}
 

protected void startAndCompleteProcessInstance(String key, int year, int month, int dayOfMonth, int hourOfDay, int minute) {
  setCurrentTime(year, month, dayOfMonth , hourOfDay, minute);

  ProcessInstance pi = processEngineRule.getRuntimeService().startProcessInstanceByKey(key);

  addToCalendar(Calendar.MONTH, 5);
  completeTask(pi.getId());

  ClockUtil.reset();
}