* you may not use this file except in compliance with the License.

* You may obtain a copy of the License at

*

*      http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

* @author Tom Baeyens

* @author Frederik Heremans

* @author Joram Barrez

* @author Christian Lipphardt (camunda)

*/

  public FullHistoryTest() {

    super("org/camunda/bpm/engine/test/standalone/history/fullhistory.camunda.cfg.xml");

  }

  @Override

  protected void closeDownProcessEngine() {

    processEngine.close();

    super.closeDownProcessEngine();

  }

  @Deployment

  public void testVariableUpdates() {

    Map<String, Object> variables = new HashMap<String, Object>();

    variables.put("number", "one");

    variables.put("character", "a");

    variables.put("bytes", ":-(".getBytes());

    ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("receiveTask", variables);

    runtimeService.setVariable(processInstance.getId(), "number", "two");

    runtimeService.setVariable(processInstance.getId(), "bytes", ":-)".getBytes());

    // Start-task should be added to history

    HistoricActivityInstance historicStartEvent = historyService.createHistoricActivityInstanceQuery()

      .processInstanceId(processInstance.getId())

      .activityId("theStart")

      .singleResult();

    assertNotNull(historicStartEvent);

    HistoricActivityInstance waitStateActivity = historyService.createHistoricActivityInstanceQuery()

      .processInstanceId(processInstance.getId())

      .activityId("waitState")

      .singleResult();

    assertNotNull(waitStateActivity);

    HistoricActivityInstance serviceTaskActivity = historyService.createHistoricActivityInstanceQuery()

      .processInstanceId(processInstance.getId())

      .activityId("serviceTask")

      .singleResult();

    assertNotNull(serviceTaskActivity);

    List<HistoricDetail> historicDetails = historyService

      .createHistoricDetailQuery()

      .orderByVariableName().asc()

      .orderByVariableRevision().asc()

      .list();

    assertEquals(10, historicDetails.size());

    HistoricVariableUpdate historicVariableUpdate = (HistoricVariableUpdate) historicDetails.get(0);

    assertEquals("bytes", historicVariableUpdate.getVariableName());

    assertEquals(":-(", new String((byte[])historicVariableUpdate.getValue()));

    assertEquals(0, historicVariableUpdate.getRevision());

    assertEquals(historicStartEvent.getId(), historicVariableUpdate.getActivityInstanceId());

    // Variable is updated when process was in waitstate

    historicVariableUpdate = (HistoricVariableUpdate) historicDetails.get(1);

    assertEquals("bytes", historicVariableUpdate.getVariableName());

    assertEquals(":-)", new String((byte[])historicVariableUpdate.getValue()));

    assertEquals(1, historicVariableUpdate.getRevision());

    assertEquals(waitStateActivity.getId(), historicVariableUpdate.getActivityInstanceId());

    historicVariableUpdate = (HistoricVariableUpdate) historicDetails.get(2);

    assertEquals("character", historicVariableUpdate.getVariableName());

    assertEquals("a", historicVariableUpdate.getValue());

    assertEquals(0, historicVariableUpdate.getRevision());

    assertEquals(historicStartEvent.getId(), historicVariableUpdate.getActivityInstanceId());

    historicVariableUpdate = (HistoricVariableUpdate) historicDetails.get(3);

    assertEquals("number", historicVariableUpdate.getVariableName());

    assertEquals("one", historicVariableUpdate.getValue());

    assertEquals(0, historicVariableUpdate.getRevision());

    assertEquals(historicStartEvent.getId(), historicVariableUpdate.getActivityInstanceId());

    // Variable is updated when process was in waitstate

    historicVariableUpdate = (HistoricVariableUpdate) historicDetails.get(4);

    assertEquals("number", historicVariableUpdate.getVariableName());

    assertEquals("two", historicVariableUpdate.getValue());

    assertEquals(1, historicVariableUpdate.getRevision());

    assertEquals(waitStateActivity.getId(), historicVariableUpdate.getActivityInstanceId());

    // Variable set from process-start execution listener

    historicVariableUpdate = (HistoricVariableUpdate) historicDetails.get(5);

    assertEquals("zVar1", historicVariableUpdate.getVariableName());

    assertEquals("Event: start", historicVariableUpdate.getValue());

    assertEquals(0, historicVariableUpdate.getRevision());

    assertEquals(historicStartEvent.getId(), historicVariableUpdate.getActivityInstanceId());

    // Variable set from transition take execution listener

    historicVariableUpdate = (HistoricVariableUpdate) historicDetails.get(6);

    assertEquals("zVar2", historicVariableUpdate.getVariableName());

    assertEquals("Event: take", historicVariableUpdate.getValue());

    assertEquals(0, historicVariableUpdate.getRevision());

    assertNull(historicVariableUpdate.getActivityInstanceId());

    // Variable set from activity start execution listener on the servicetask

    historicVariableUpdate = (HistoricVariableUpdate) historicDetails.get(7);

    assertEquals("zVar3", historicVariableUpdate.getVariableName());

    assertEquals("Event: start", historicVariableUpdate.getValue());

    assertEquals(0, historicVariableUpdate.getRevision());

    assertEquals(serviceTaskActivity.getId(), historicVariableUpdate.getActivityInstanceId());

    // Variable set from activity end execution listener on the servicetask

    historicVariableUpdate = (HistoricVariableUpdate) historicDetails.get(8);

    assertEquals("zVar4", historicVariableUpdate.getVariableName());

    assertEquals("Event: end", historicVariableUpdate.getValue());

    assertEquals(0, historicVariableUpdate.getRevision());

    assertEquals(serviceTaskActivity.getId(), historicVariableUpdate.getActivityInstanceId());

    // Variable set from service-task

    historicVariableUpdate = (HistoricVariableUpdate) historicDetails.get(9);

    assertEquals("zzz", historicVariableUpdate.getVariableName());

    assertEquals(123456789L, historicVariableUpdate.getValue());

    assertEquals(0, historicVariableUpdate.getRevision());

    assertEquals(serviceTaskActivity.getId(), historicVariableUpdate.getActivityInstanceId());

    // trigger receive task

    runtimeService.signal(processInstance.getId());

    assertProcessEnded(processInstance.getId());

    // check for historic process variables set

    HistoricVariableInstanceQuery historicProcessVariableQuery = historyService

            .createHistoricVariableInstanceQuery()

            .orderByVariableName().asc();

    assertEquals(8, historicProcessVariableQuery.count());

    List<HistoricVariableInstance> historicVariables = historicProcessVariableQuery.list();

    // Variable status when process is finished

    HistoricVariableInstance historicVariable = historicVariables.get(0);

    assertEquals("bytes", historicVariable.getVariableName());

    assertEquals(":-)", new String((byte[])historicVariable.getValue()));

    historicVariable = historicVariables.get(1);

    assertEquals("character", historicVariable.getVariableName());

    assertEquals("a", historicVariable.getValue());

    historicVariable = historicVariables.get(2);

    assertEquals("number", historicVariable.getVariableName());

    assertEquals("two", historicVariable.getValue());

    historicVariable = historicVariables.get(3);

    assertEquals("zVar1", historicVariable.getVariableName());

    assertEquals("Event: start", historicVariable.getValue());

    historicVariable = historicVariables.get(4);

    assertEquals("zVar2", historicVariable.getVariableName());

    assertEquals("Event: take", historicVariable.getValue());

    historicVariable = historicVariables.get(5);

    assertEquals("zVar3", historicVariable.getVariableName());

    assertEquals("Event: start", historicVariable.getValue());

    historicVariable = historicVariables.get(6);

    assertEquals("zVar4", historicVariable.getVariableName());

    assertEquals("Event: end", historicVariable.getValue());

    historicVariable = historicVariables.get(7);

    assertEquals("zzz", historicVariable.getVariableName());

    assertEquals(123456789L, historicVariable.getValue());

  }

  @Deployment(resources="org/camunda/bpm/engine/test/standalone/history/FullHistoryTest.testVariableUpdates.bpmn20.xml")

  public void testHistoricVariableInstanceQuery() {

    Map<String, Object> variables = new HashMap<String, Object>();

    variables.put("process", "one");

    ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("receiveTask", variables);

    runtimeService.signal(processInstance.getProcessInstanceId());

    assertEquals(1, historyService.createHistoricVariableInstanceQuery().variableName("process").count());

    assertEquals(1, historyService.createHistoricVariableInstanceQuery().variableValueEquals("process", "one").count());

    Map<String, Object> variables2 = new HashMap<String, Object>();

    variables2.put("process", "two");

    ProcessInstance processInstance2 = runtimeService.startProcessInstanceByKey("receiveTask", variables2);

    runtimeService.signal(processInstance2.getProcessInstanceId());

    assertEquals(2, historyService.createHistoricVariableInstanceQuery().variableName("process").count());

    assertEquals(1, historyService.createHistoricVariableInstanceQuery().variableValueEquals("process", "one").count());

    assertEquals(1, historyService.createHistoricVariableInstanceQuery().variableValueEquals("process", "two").count());

    HistoricVariableInstance historicProcessVariable = historyService.createHistoricVariableInstanceQuery().variableValueEquals("process", "one").singleResult();

    assertEquals("process", historicProcessVariable.getVariableName());

    assertEquals("one", historicProcessVariable.getValue());

    assertEquals(ValueType.STRING.getName(), historicProcessVariable.getVariableTypeName());

    assertEquals(ValueType.STRING.getName(), historicProcessVariable.getTypeName());

    assertEquals(historicProcessVariable.getValue(), historicProcessVariable.getTypedValue().getValue());

    assertEquals(historicProcessVariable.getTypeName(), historicProcessVariable.getTypedValue().getType().getName());

    Map<String, Object> variables3 = new HashMap<String, Object>();

    variables3.put("long", 1000l);

    variables3.put("double", 25.43d);

    ProcessInstance processInstance3 = runtimeService.startProcessInstanceByKey("receiveTask", variables3);

    runtimeService.signal(processInstance3.getProcessInstanceId());

    assertEquals(1, historyService.createHistoricVariableInstanceQuery().variableName("long").count());

    assertEquals(1, historyService.createHistoricVariableInstanceQuery().variableValueEquals("long", 1000l).count());

    assertEquals(1, historyService.createHistoricVariableInstanceQuery().variableName("double").count());

    assertEquals(1, historyService.createHistoricVariableInstanceQuery().variableValueEquals("double",  25.43d).count());

  }

  @Deployment

  public void testHistoricVariableUpdatesAllTypes() throws Exception {

    SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy hh:mm:ss SSS");

    Map<String, Object> variables = new HashMap<String, Object>();

    variables.put("aVariable", "initial value");

    Date startedDate = sdf.parse("01/01/2001 01:23:45 000");

    // In the javaDelegate, the current time is manipulated

    Date updatedDate = sdf.parse("01/01/2001 01:23:46 000");

    ClockUtil.setCurrentTime(startedDate);

    ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("HistoricVariableUpdateProcess", variables);

    List<HistoricDetail> details = historyService.createHistoricDetailQuery()

      .variableUpdates()

      .processInstanceId(processInstance.getId())

      .orderByVariableName().asc()

      .orderByTime().asc()

      .list();

    // 8 variable updates should be present, one performed when starting process

    // the other 7 are set in VariableSetter serviceTask

    assertEquals(9, details.size());

    // Since we order by varName, first entry should be aVariable update from startTask

    HistoricVariableUpdate startVarUpdate = (HistoricVariableUpdate) details.get(0);

    assertEquals("aVariable", startVarUpdate.getVariableName());

    assertEquals("initial value", startVarUpdate.getValue());

    assertEquals(0, startVarUpdate.getRevision());

    assertEquals(processInstance.getId(), startVarUpdate.getProcessInstanceId());

    // Date should the the one set when starting

    assertEquals(startedDate, startVarUpdate.getTime());

    HistoricVariableUpdate updatedStringVariable = (HistoricVariableUpdate) details.get(1);

    assertEquals("aVariable", updatedStringVariable.getVariableName());

    assertEquals("updated value", updatedStringVariable.getValue());

    assertEquals(processInstance.getId(), updatedStringVariable.getProcessInstanceId());

    // Date should be the updated date

    assertEquals(updatedDate, updatedStringVariable.getTime());

    HistoricVariableUpdate intVariable = (HistoricVariableUpdate) details.get(2);

    assertEquals("bVariable", intVariable.getVariableName());

    assertEquals(123, intVariable.getValue());

    assertEquals(processInstance.getId(), intVariable.getProcessInstanceId());

    assertEquals(updatedDate, intVariable.getTime());

    HistoricVariableUpdate longVariable = (HistoricVariableUpdate) details.get(3);

    assertEquals("cVariable", longVariable.getVariableName());

    assertEquals(12345L, longVariable.getValue());

    assertEquals(processInstance.getId(), longVariable.getProcessInstanceId());

    assertEquals(updatedDate, longVariable.getTime());

    HistoricVariableUpdate doubleVariable = (HistoricVariableUpdate) details.get(4);

    assertEquals("dVariable", doubleVariable.getVariableName());

    assertEquals(1234.567, doubleVariable.getValue());

    assertEquals(processInstance.getId(), doubleVariable.getProcessInstanceId());

    assertEquals(updatedDate, doubleVariable.getTime());

    HistoricVariableUpdate shortVariable = (HistoricVariableUpdate) details.get(5);

    assertEquals("eVariable", shortVariable.getVariableName());

    assertEquals((short)12, shortVariable.getValue());

    assertEquals(processInstance.getId(), shortVariable.getProcessInstanceId());

    assertEquals(updatedDate, shortVariable.getTime());

    HistoricVariableUpdate dateVariable = (HistoricVariableUpdate) details.get(6);

    assertEquals("fVariable", dateVariable.getVariableName());

    assertEquals(sdf.parse("01/01/2001 01:23:45 678"), dateVariable.getValue());

    assertEquals(processInstance.getId(), dateVariable.getProcessInstanceId());

    assertEquals(updatedDate, dateVariable.getTime());

    HistoricVariableUpdate serializableVariable = (HistoricVariableUpdate) details.get(7);

    assertEquals("gVariable", serializableVariable.getVariableName());

    assertEquals(new SerializableVariable("hello hello"), serializableVariable.getValue());

    assertEquals(processInstance.getId(), serializableVariable.getProcessInstanceId());

    assertEquals(updatedDate, serializableVariable.getTime());

    HistoricVariableUpdate byteArrayVariable = (HistoricVariableUpdate) details.get(8);

    assertEquals("hVariable", byteArrayVariable.getVariableName());

    assertEquals(";-)", new String((byte[])byteArrayVariable.getValue()));

    assertEquals(processInstance.getId(), byteArrayVariable.getProcessInstanceId());

    assertEquals(updatedDate, byteArrayVariable.getTime());

    // end process instance

    List<Task> tasks = taskService.createTaskQuery().list();

    assertEquals(1, tasks.size());

    taskService.complete(tasks.get(0).getId());

    assertProcessEnded(processInstance.getId());

    // check for historic process variables set

    HistoricVariableInstanceQuery historicProcessVariableQuery = historyService

            .createHistoricVariableInstanceQuery()

            .orderByVariableName().asc();

    assertEquals(8, historicProcessVariableQuery.count());

    List<HistoricVariableInstance> historicVariables = historicProcessVariableQuery.list();

// Variable status when process is finished

    HistoricVariableInstance historicVariable = historicVariables.get(0);

    assertEquals("aVariable", historicVariable.getVariableName());

    assertEquals("updated value", historicVariable.getValue());

    assertEquals(processInstance.getId(), historicVariable.getProcessInstanceId());

    historicVariable = historicVariables.get(1);

    assertEquals("bVariable", historicVariable.getVariableName());

    assertEquals(123, historicVariable.getValue());

    assertEquals(processInstance.getId(), historicVariable.getProcessInstanceId());

    historicVariable = historicVariables.get(2);

    assertEquals("cVariable", historicVariable.getVariableName());

    assertEquals(12345L, historicVariable.getValue());

    assertEquals(processInstance.getId(), historicVariable.getProcessInstanceId());

    historicVariable = historicVariables.get(3);

    assertEquals("dVariable", historicVariable.getVariableName());

    assertEquals(1234.567, historicVariable.getValue());

    assertEquals(processInstance.getId(), historicVariable.getProcessInstanceId());

    historicVariable = historicVariables.get(4);

    assertEquals("eVariable", historicVariable.getVariableName());

    assertEquals((short) 12, historicVariable.getValue());

    assertEquals(processInstance.getId(), historicVariable.getProcessInstanceId());

    historicVariable = historicVariables.get(5);

    assertEquals("fVariable", historicVariable.getVariableName());

    assertEquals(sdf.parse("01/01/2001 01:23:45 678"), historicVariable.getValue());

    assertEquals(processInstance.getId(), historicVariable.getProcessInstanceId());

    historicVariable = historicVariables.get(6);

    assertEquals("gVariable", historicVariable.getVariableName());

    assertEquals(new SerializableVariable("hello hello"), historicVariable.getValue());

    assertEquals(processInstance.getId(), historicVariable.getProcessInstanceId());

    historicVariable = historicVariables.get(7);

    assertEquals("hVariable", historicVariable.getVariableName());

    assertEquals(";-)", ";-)", new String((byte[])historicVariable.getValue()));

    assertEquals(processInstance.getId(), historicVariable.getProcessInstanceId());

  }

  @Deployment

  public void testHistoricFormProperties() throws Exception {

    Date startedDate = new SimpleDateFormat("dd/MM/yyyy hh:mm:ss SSS").parse("01/01/2001 01:23:46 000");

    ClockUtil.setCurrentTime(startedDate);

    Map<String, String> formProperties = new HashMap<String, String>();

    formProperties.put("formProp1", "Activiti rocks");

    formProperties.put("formProp2", "12345");

    ProcessDefinition procDef = repositoryService.createProcessDefinitionQuery().processDefinitionKey("historicFormPropertiesProcess").singleResult();

    ProcessInstance processInstance = formService.submitStartFormData(procDef.getId() , formProperties);

    // Submit form-properties on the created task

    Task task = taskService.createTaskQuery().processInstanceId(processInstance.getId()).singleResult();

    assertNotNull(task);

    // Out execution only has a single activity waiting, the task

    List<String> activityIds = runtimeService.getActiveActivityIds(task.getExecutionId());

    assertNotNull(activityIds);

    assertEquals(1, activityIds.size());

    String taskActivityId = activityIds.get(0);

    // Submit form properties

    formProperties = new HashMap<String, String>();

    formProperties.put("formProp3", "Activiti still rocks!!!");

    formProperties.put("formProp4", "54321");

    formService.submitTaskFormData(task.getId(), formProperties);

    // 4 historic form properties should be created. 2 when process started, 2 when task completed

    List<HistoricDetail> props = historyService.createHistoricDetailQuery()

      .formProperties()

      .processInstanceId(processInstance.getId())

      .orderByFormPropertyId().asc()

      .list();

    HistoricFormProperty historicProperty1 = (HistoricFormProperty) props.get(0);

    assertEquals("formProp1", historicProperty1.getPropertyId());

    assertEquals("Activiti rocks", historicProperty1.getPropertyValue());

    assertEquals(startedDate, historicProperty1.getTime());

    assertEquals(processInstance.getId(), historicProperty1.getProcessInstanceId());

    assertNull(historicProperty1.getTaskId());

    assertNotNull(historicProperty1.getActivityInstanceId());

    HistoricActivityInstance historicActivityInstance = historyService.createHistoricActivityInstanceQuery().activityInstanceId(historicProperty1.getActivityInstanceId()).singleResult();

    assertNotNull(historicActivityInstance);

    assertEquals("start", historicActivityInstance.getActivityId());

    HistoricFormProperty historicProperty2 = (HistoricFormProperty) props.get(1);

    assertEquals("formProp2", historicProperty2.getPropertyId());

    assertEquals("12345", historicProperty2.getPropertyValue());

    assertEquals(startedDate, historicProperty2.getTime());

    assertEquals(processInstance.getId(), historicProperty2.getProcessInstanceId());

    assertNull(historicProperty2.getTaskId());

    assertNotNull(historicProperty2.getActivityInstanceId());

    historicActivityInstance = historyService.createHistoricActivityInstanceQuery().activityInstanceId(historicProperty2.getActivityInstanceId()).singleResult();

    assertNotNull(historicActivityInstance);

    assertEquals("start", historicActivityInstance.getActivityId());

    HistoricFormProperty historicProperty3 = (HistoricFormProperty) props.get(2);

    assertEquals("formProp3", historicProperty3.getPropertyId());

    assertEquals("Activiti still rocks!!!", historicProperty3.getPropertyValue());

    assertEquals(startedDate, historicProperty3.getTime());

    assertEquals(processInstance.getId(), historicProperty3.getProcessInstanceId());

    String activityInstanceId = historicProperty3.getActivityInstanceId();

    historicActivityInstance = historyService.createHistoricActivityInstanceQuery().activityInstanceId(activityInstanceId).singleResult();

    assertNotNull(historicActivityInstance);

    assertEquals(taskActivityId, historicActivityInstance.getActivityId());

    assertNotNull(historicProperty3.getTaskId());

    HistoricFormProperty historicProperty4 = (HistoricFormProperty) props.get(3);

    assertEquals("formProp4", historicProperty4.getPropertyId());

    assertEquals("54321", historicProperty4.getPropertyValue());

    assertEquals(startedDate, historicProperty4.getTime());

    assertEquals(processInstance.getId(), historicProperty4.getProcessInstanceId());

    activityInstanceId = historicProperty4.getActivityInstanceId();

    historicActivityInstance = historyService.createHistoricActivityInstanceQuery().activityInstanceId(activityInstanceId).singleResult();

    assertNotNull(historicActivityInstance);

    assertEquals(taskActivityId, historicActivityInstance.getActivityId());

    assertNotNull(historicProperty4.getTaskId());

    assertEquals(4, props.size());

  }

  @Deployment(

    resources={"org/camunda/bpm/engine/test/history/oneTaskProcess.bpmn20.xml"})

  public void testHistoricVariableQuery() throws Exception {

    Map<String, Object> variables = new HashMap<String, Object>();

    variables.put("stringVar", "activiti rocks!");

    variables.put("longVar", 12345L);

    ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("oneTaskProcess", variables);

    // Query on activity-instance, activity instance null will return all vars set when starting process

    assertEquals(2, historyService.createHistoricDetailQuery().variableUpdates().activityInstanceId(null).count());

    assertEquals(0, historyService.createHistoricDetailQuery().variableUpdates().activityInstanceId("unexisting").count());

    // Query on process-instance

    assertEquals(2, historyService.createHistoricDetailQuery().variableUpdates().processInstanceId(processInstance.getId()).count());

    assertEquals(0, historyService.createHistoricDetailQuery().variableUpdates().processInstanceId("unexisting").count());

    // Query both process-instance and activity-instance

    assertEquals(2, historyService.createHistoricDetailQuery().variableUpdates()

            .activityInstanceId(null)

            .processInstanceId(processInstance.getId()).count());

    // end process instance

    List<Task> tasks = taskService.createTaskQuery().list();

    assertEquals(1, tasks.size());

    taskService.complete(tasks.get(0).getId());

    assertProcessEnded(processInstance.getId());

    assertEquals(2, historyService.createHistoricVariableInstanceQuery().count());

    // Query on process-instance

    assertEquals(2, historyService.createHistoricVariableInstanceQuery().processInstanceId(processInstance.getId()).count());

    assertEquals(0, historyService.createHistoricVariableInstanceQuery().processInstanceId("unexisting").count());

  }

  @Deployment(

    resources={"org/camunda/bpm/engine/test/history/oneTaskProcess.bpmn20.xml"})

  public void testHistoricVariableQueryExcludeTaskRelatedDetails() throws Exception {

    Map<String, Object> variables = new HashMap<String, Object>();

    variables.put("stringVar", "activiti rocks!");

    variables.put("longVar", 12345L);

    ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("oneTaskProcess", variables);

    // Set a local task-variable

    Task task = taskService.createTaskQuery().processInstanceId(processInstance.getId()).singleResult();

    assertNotNull(task);

    taskService.setVariableLocal(task.getId(), "taskVar", "It is I, le Variable");

    // Query on process-instance

    assertEquals(3, historyService.createHistoricDetailQuery().variableUpdates().processInstanceId(processInstance.getId()).count());

    // Query on process-instance, excluding task-details

    assertEquals(2, historyService.createHistoricDetailQuery().variableUpdates().processInstanceId(processInstance.getId())

      .excludeTaskDetails().count());

    // Check task-id precedence on excluding task-details

    assertEquals(1, historyService.createHistoricDetailQuery().variableUpdates().processInstanceId(processInstance.getId())

            .excludeTaskDetails().taskId(task.getId()).count());

  }

  @Deployment(

    resources={"org/camunda/bpm/engine/test/history/oneTaskProcess.bpmn20.xml"})

  public void testHistoricFormPropertiesQuery() throws Exception {

    Map<String, String> formProperties = new HashMap<String, String>();

    formProperties.put("stringVar", "activiti rocks!");

    formProperties.put("longVar", "12345");

    ProcessDefinition procDef = repositoryService.createProcessDefinitionQuery().processDefinitionKey("oneTaskProcess").singleResult();

    ProcessInstance processInstance = formService.submitStartFormData(procDef.getId() , formProperties);

    // Query on activity-instance, activity instance null will return all vars set when starting process

    assertEquals(2, historyService.createHistoricDetailQuery().formProperties().activityInstanceId(null).count());

    assertEquals(0, historyService.createHistoricDetailQuery().formProperties().activityInstanceId("unexisting").count());

    // Query on process-instance

    assertEquals(2, historyService.createHistoricDetailQuery().formProperties().processInstanceId(processInstance.getId()).count());

    assertEquals(0, historyService.createHistoricDetailQuery().formProperties().processInstanceId("unexisting").count());

    // Complete the task by submitting the task properties

    Task task = taskService.createTaskQuery().singleResult();

    formProperties = new HashMap<String, String>();

    formProperties.put("taskVar", "task form property");

    formService.submitTaskFormData(task.getId(), formProperties);

    assertEquals(3, historyService.createHistoricDetailQuery().formProperties().processInstanceId(processInstance.getId()).count());

    assertEquals(0, historyService.createHistoricDetailQuery().formProperties().processInstanceId("unexisting").count());

  }

  @Deployment(

    resources={"org/camunda/bpm/engine/test/history/oneTaskProcess.bpmn20.xml"})

  public void testHistoricVariableQuerySorting() throws Exception {

    Map<String, Object> variables = new HashMap<String, Object>();

    variables.put("stringVar", "activiti rocks!");

    variables.put("longVar", 12345L);

    runtimeService.startProcessInstanceByKey("oneTaskProcess", variables);

    assertEquals(2, historyService.createHistoricDetailQuery().variableUpdates().orderByProcessInstanceId().asc().count());

    assertEquals(2, historyService.createHistoricDetailQuery().variableUpdates().orderByTime().asc().count());

    assertEquals(2, historyService.createHistoricDetailQuery().variableUpdates().orderByVariableName().asc().count());

    assertEquals(2, historyService.createHistoricDetailQuery().variableUpdates().orderByVariableRevision().asc().count());

    assertEquals(2, historyService.createHistoricDetailQuery().variableUpdates().orderByVariableType().asc().count());

    assertEquals(2, historyService.createHistoricDetailQuery().variableUpdates().orderByProcessInstanceId().desc().count());

    assertEquals(2, historyService.createHistoricDetailQuery().variableUpdates().orderByTime().desc().count());

    assertEquals(2, historyService.createHistoricDetailQuery().variableUpdates().orderByVariableName().desc().count());

    assertEquals(2, historyService.createHistoricDetailQuery().variableUpdates().orderByVariableRevision().desc().count());

    assertEquals(2, historyService.createHistoricDetailQuery().variableUpdates().orderByVariableType().desc().count());

    assertEquals(2, historyService.createHistoricDetailQuery().variableUpdates().orderByProcessInstanceId().asc().list().size());

    assertEquals(2, historyService.createHistoricDetailQuery().variableUpdates().orderByTime().asc().list().size());

    assertEquals(2, historyService.createHistoricDetailQuery().variableUpdates().orderByVariableName().asc().list().size());

    assertEquals(2, historyService.createHistoricDetailQuery().variableUpdates().orderByVariableRevision().asc().list().size());

    assertEquals(2, historyService.createHistoricDetailQuery().variableUpdates().orderByVariableType().asc().list().size());

    assertEquals(2, historyService.createHistoricDetailQuery().variableUpdates().orderByProcessInstanceId().desc().list().size());

    assertEquals(2, historyService.createHistoricDetailQuery().variableUpdates().orderByTime().desc().list().size());

    assertEquals(2, historyService.createHistoricDetailQuery().variableUpdates().orderByVariableName().desc().list().size());

    assertEquals(2, historyService.createHistoricDetailQuery().variableUpdates().orderByVariableRevision().desc().list().size());

    assertEquals(2, historyService.createHistoricDetailQuery().variableUpdates().orderByVariableType().desc().list().size());

  }

  @Deployment(

    resources={"org/camunda/bpm/engine/test/history/oneTaskProcess.bpmn20.xml"})

  public void testHistoricFormPropertySorting() throws Exception {

    Map<String, String> formProperties = new HashMap<String, String>();

    formProperties.put("stringVar", "activiti rocks!");

    formProperties.put("longVar", "12345");

    ProcessDefinition procDef = repositoryService.createProcessDefinitionQuery().processDefinitionKey("oneTaskProcess").singleResult();

    formService.submitStartFormData(procDef.getId() , formProperties);

    assertEquals(2, historyService.createHistoricDetailQuery().formProperties().orderByProcessInstanceId().asc().count());

    assertEquals(2, historyService.createHistoricDetailQuery().formProperties().orderByTime().asc().count());

    assertEquals(2, historyService.createHistoricDetailQuery().formProperties().orderByFormPropertyId().asc().count());

    assertEquals(2, historyService.createHistoricDetailQuery().formProperties().orderByProcessInstanceId().desc().count());

    assertEquals(2, historyService.createHistoricDetailQuery().formProperties().orderByTime().desc().count());

    assertEquals(2, historyService.createHistoricDetailQuery().formProperties().orderByFormPropertyId().desc().count());

    assertEquals(2, historyService.createHistoricDetailQuery().formProperties().orderByProcessInstanceId().asc().list().size());

    assertEquals(2, historyService.createHistoricDetailQuery().formProperties().orderByTime().asc().list().size());

    assertEquals(2, historyService.createHistoricDetailQuery().formProperties().orderByFormPropertyId().asc().list().size());

    assertEquals(2, historyService.createHistoricDetailQuery().formProperties().orderByProcessInstanceId().desc().list().size());

    assertEquals(2, historyService.createHistoricDetailQuery().formProperties().orderByTime().desc().list().size());

    assertEquals(2, historyService.createHistoricDetailQuery().formProperties().orderByFormPropertyId().desc().list().size());

  }

  @Deployment

  public void testHistoricDetailQueryMixed() throws Exception {

    Map<String, String> formProperties = new HashMap<String, String>();

    formProperties.put("formProp1", "activiti rocks!");

    formProperties.put("formProp2", "12345");

    ProcessDefinition procDef = repositoryService.createProcessDefinitionQuery().processDefinitionKey("historicDetailMixed").singleResult();

    ProcessInstance processInstance = formService.submitStartFormData(procDef.getId() , formProperties);

    List<HistoricDetail> details = historyService

      .createHistoricDetailQuery()

      .processInstanceId(processInstance.getId())

      .orderByVariableName().asc()

      .list();

    assertEquals(4, details.size());

    assertTrue(details.get(0) instanceof HistoricFormProperty);

    HistoricFormProperty formProp1 = (HistoricFormProperty) details.get(0);

    assertEquals("formProp1", formProp1.getPropertyId());

    assertEquals("activiti rocks!", formProp1.getPropertyValue());

    assertTrue(details.get(1) instanceof HistoricFormProperty);

    HistoricFormProperty formProp2 = (HistoricFormProperty) details.get(1);

    assertEquals("formProp2", formProp2.getPropertyId());

    assertEquals("12345", formProp2.getPropertyValue());

    assertTrue(details.get(2) instanceof HistoricVariableUpdate);

    HistoricVariableUpdate varUpdate1 = (HistoricVariableUpdate) details.get(2);

    assertEquals("variable1", varUpdate1.getVariableName());

    assertEquals("activiti rocks!", varUpdate1.getValue());

    // This variable should be of type LONG since this is defined in the process-definition

    assertTrue(details.get(3) instanceof HistoricVariableUpdate);

    HistoricVariableUpdate varUpdate2 = (HistoricVariableUpdate) details.get(3);

    assertEquals("variable2", varUpdate2.getVariableName());

    assertEquals(12345L, varUpdate2.getValue());

  }

  public void testHistoricDetailQueryInvalidSorting() throws Exception {

    try {

      historyService.createHistoricDetailQuery().asc().list();

      fail();

    } catch (ProcessEngineException e) {

    }

    try {

      historyService.createHistoricDetailQuery().desc().list();

      fail();

    } catch (ProcessEngineException e) {

    }

    try {

      historyService.createHistoricDetailQuery().orderByProcessInstanceId().list();

      fail();

    } catch (ProcessEngineException e) {

    }

    try {

      historyService.createHistoricDetailQuery().orderByTime().list();

      fail();

    } catch (ProcessEngineException e) {

    }

    try {

      historyService.createHistoricDetailQuery().orderByVariableName().list();

      fail();

    } catch (ProcessEngineException e) {

    }

    try {

      historyService.createHistoricDetailQuery().orderByVariableRevision().list();

      fail();

    } catch (ProcessEngineException e) {

    }

    try {

      historyService.createHistoricDetailQuery().orderByVariableType().list();

      fail();

    } catch (ProcessEngineException e) {

    }

  }

  @Deployment

  public void testHistoricTaskInstanceVariableUpdates() {

    String processInstanceId = runtimeService.startProcessInstanceByKey("HistoricTaskInstanceTest").getId();

    String taskId = taskService.createTaskQuery().singleResult().getId();

    runtimeService.setVariable(processInstanceId, "deadline", "yesterday");

    taskService.setVariableLocal(taskId, "bucket", "23c");

    taskService.setVariableLocal(taskId, "mop", "37i");

    taskService.complete(taskId);

    assertEquals(1, historyService.createHistoricTaskInstanceQuery().count());

    List<HistoricDetail> historicTaskVariableUpdates = historyService.createHistoricDetailQuery()

      .taskId(taskId)

      .variableUpdates()

      .orderByVariableName().asc()

      .list();

    assertEquals(2, historicTaskVariableUpdates.size());

    historyService.deleteHistoricTaskInstance(taskId);

    // Check if the variable updates have been removed as well

    historicTaskVariableUpdates = historyService.createHistoricDetailQuery()

      .taskId(taskId)

      .variableUpdates()

      .orderByVariableName().asc()

      .list();

     assertEquals(0, historicTaskVariableUpdates.size());

  }

  // ACT-592

  @Deployment

  public void testSetVariableOnProcessInstanceWithTimer() {

    ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("timerVariablesProcess");

    runtimeService.setVariable(processInstance.getId(), "myVar", 123456L);

    assertEquals(123456L, runtimeService.getVariable(processInstance.getId(), "myVar"));

  }

  @Deployment

  public void testDeleteHistoricProcessInstance() {

    // Start process-instance with some variables set

    Map<String, Object> vars = new HashMap<String, Object>();

    vars.put("processVar", 123L);

    vars.put("anotherProcessVar", new DummySerializable());

    ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("HistoricTaskInstanceTest", vars);

    assertNotNull(processInstance);

    // Set 2 task properties

    Task task = taskService.createTaskQuery().processInstanceId(processInstance.getId()).singleResult();

    taskService.setVariableLocal(task.getId(), "taskVar", 45678);

    taskService.setVariableLocal(task.getId(), "anotherTaskVar", "value");

    // Finish the task, this end the process-instance

    taskService.complete(task.getId());

    assertEquals(1, historyService.createHistoricProcessInstanceQuery().processInstanceId(processInstance.getId()).count());

    assertEquals(3, historyService.createHistoricActivityInstanceQuery().processInstanceId(processInstance.getId()).count());

    assertEquals(4, historyService.createHistoricVariableInstanceQuery().processInstanceId(processInstance.getId()).count());

    assertEquals(4, historyService.createHistoricDetailQuery().processInstanceId(processInstance.getId()).count());

    assertEquals(1, historyService.createHistoricTaskInstanceQuery().processInstanceId(processInstance.getId()).count());

    // Delete the historic process-instance

    historyService.deleteHistoricProcessInstance(processInstance.getId());

    // Verify no traces are left in the history tables

    assertEquals(0, historyService.createHistoricProcessInstanceQuery().processInstanceId(processInstance.getId()).count());

    assertEquals(0, historyService.createHistoricActivityInstanceQuery().processInstanceId(processInstance.getId()).count());

    assertEquals(0, historyService.createHistoricVariableInstanceQuery().processInstanceId(processInstance.getId()).count());

    assertEquals(0, historyService.createHistoricDetailQuery().processInstanceId(processInstance.getId()).count());

    assertEquals(0, historyService.createHistoricTaskInstanceQuery().processInstanceId(processInstance.getId()).count());

    try {

      // Delete the historic process-instance, which is still running

      historyService.deleteHistoricProcessInstance("unexisting");

      fail("Exception expected when deleting process-instance that is still running");

    } catch(ProcessEngineException ae) {

      // Expected exception

      assertTextPresent("No historic process instance found with id: unexisting", ae.getMessage());

    }

  }

  @Deployment

  public void testDeleteRunningHistoricProcessInstance() {

    ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("HistoricTaskInstanceTest");

    assertNotNull(processInstance);

    try {

      // Delete the historic process-instance, which is still running

      historyService.deleteHistoricProcessInstance(processInstance.getId());

      fail("Exception expected when deleting process-instance that is still running");

    } catch(ProcessEngineException ae) {

      // Expected exception

      assertTextPresent("Process instance is still running, cannot delete historic process instance", ae.getMessage());

    }

  }

  @Deployment

  public void testDeleteCachedHistoricDetails() {

    final String processDefinitionId = repositoryService.createProcessDefinitionQuery().singleResult().getId();

    processEngineConfiguration.getCommandExecutorTxRequired().execute(new Command<Void>() {

      public Void execute(CommandContext commandContext) {

        Map<String, Object> formProperties = new HashMap<String, Object>();

        formProperties.put("formProp1", "value1");

        ProcessInstance processInstance = new SubmitStartFormCmd(processDefinitionId, null, formProperties).execute(commandContext);

        // two historic details should be in cache: one form property and one variable update

        commandContext.getHistoricDetailManager().deleteHistoricDetailsByProcessInstanceId(processInstance.getId());

        return null;

      }

    });

    // the historic process instance should still be there

    assertEquals(1, historyService.createHistoricProcessInstanceQuery().count());

    // the historic details should be deleted

    assertEquals(0, historyService.createHistoricDetailQuery().count());

  }

  /**

   * Test created to validate ACT-621 fix.

   */

  @Deployment

  public void testHistoricFormPropertiesOnReEnteringActivity() {

    Map<String, Object> variables = new HashMap<String, Object>();

    variables.put("comeBack", Boolean.TRUE);

    ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("HistoricFormPropertiesProcess", variables);

    assertNotNull(processInstance);

    // Submit form on task

    Map<String, String> data = new HashMap<String, String>();

    data.put("formProp1", "Property value");

    Task task = taskService.createTaskQuery().processInstanceId(processInstance.getId()).singleResult();

    formService.submitTaskFormData(task.getId(), data);

    // Historic property should be available

    List<HistoricDetail> details = historyService.createHistoricDetailQuery()

      .formProperties()

      .processInstanceId(processInstance.getId())

      .list();

    assertNotNull(details);

    assertEquals(1, details.size());

    // Task should be active in the same activity as the previous one

    task = taskService.createTaskQuery().processInstanceId(processInstance.getId()).singleResult();

    formService.submitTaskFormData(task.getId(), data);

    details = historyService.createHistoricDetailQuery()

      .formProperties()

      .processInstanceId(processInstance.getId())

      .list();

    assertNotNull(details);

    assertEquals(2, details.size());

    // Should have 2 different historic activity instance ID's, with the same activityId

    Assert.assertNotSame(details.get(0).getActivityInstanceId(), details.get(1).getActivityInstanceId());

    HistoricActivityInstance historicActInst1 = historyService.createHistoricActivityInstanceQuery()

      .activityInstanceId(details.get(0).getActivityInstanceId())

      .singleResult();

    HistoricActivityInstance historicActInst2 = historyService.createHistoricActivityInstanceQuery()

      .activityInstanceId(details.get(1).getActivityInstanceId())

      .singleResult();

    assertEquals(historicActInst1.getActivityId(), historicActInst2.getActivityId());

  }

  @Deployment

  public void testHistoricTaskInstanceQueryTaskVariableValueEquals() throws Exception {

    ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("HistoricTaskInstanceTest");

    Task task = taskService.createTaskQuery().processInstanceId(processInstance.getId()).singleResult();

    // Set some variables on the task

    Map<String, Object> variables = new HashMap<String, Object>();

    variables.put("longVar", 12345L);

    variables.put("shortVar", (short) 123);

    variables.put("integerVar", 1234);

    variables.put("stringVar", "stringValue");

    variables.put("booleanVar", true);

    Date date = Calendar.getInstance().getTime();

    variables.put("dateVar", date);

    variables.put("nullVar", null);

    taskService.setVariablesLocal(task.getId(), variables);

    // Validate all variable-updates are present in DB

    assertEquals(7, historyService.createHistoricDetailQuery().variableUpdates().taskId(task.getId()).count());

    // Query Historic task instances based on variable

    assertEquals(1, historyService.createHistoricTaskInstanceQuery().taskVariableValueEquals("longVar", 12345L).count());

    assertEquals(1, historyService.createHistoricTaskInstanceQuery().taskVariableValueEquals("shortVar", (short) 123).count());

    assertEquals(1, historyService.createHistoricTaskInstanceQuery().taskVariableValueEquals("integerVar",1234).count());

    assertEquals(1, historyService.createHistoricTaskInstanceQuery().taskVariableValueEquals("stringVar","stringValue").count());

    assertEquals(1, historyService.createHistoricTaskInstanceQuery().taskVariableValueEquals("booleanVar", true).count());

    assertEquals(1, historyService.createHistoricTaskInstanceQuery().taskVariableValueEquals("dateVar", date).count());

    assertEquals(1, historyService.createHistoricTaskInstanceQuery().taskVariableValueEquals("nullVar", null).count());

    // Update the variables

    variables.put("longVar", 67890L);

    variables.put("shortVar", (short) 456);

    variables.put("integerVar", 5678);

    variables.put("stringVar", "updatedStringValue");

    variables.put("booleanVar", false);

    Calendar otherCal = Calendar.getInstance();

    otherCal.add(Calendar.DAY_OF_MONTH, 1);

    Date otherDate = otherCal.getTime();

    variables.put("dateVar", otherDate);

    variables.put("nullVar", null);

    taskService.setVariablesLocal(task.getId(), variables);

    // Validate all variable-updates are present in DB

    assertEquals(14, historyService.createHistoricDetailQuery().variableUpdates().taskId(task.getId()).count());

    // Previous values should NOT match

    assertEquals(0, historyService.createHistoricTaskInstanceQuery().taskVariableValueEquals("longVar", 12345L).count());