public virtual void testQueryAfterDeletingDeploymentWithReadHistoryVariable()
{
setReadHistoryVariableAsDefaultReadPermission();
startProcessInstanceByKey(PROCESS_KEY, Variables);
startProcessInstanceByKey(PROCESS_KEY, Variables);
startProcessInstanceByKey(PROCESS_KEY, Variables);
createGrantAuthorization(PROCESS_DEFINITION, PROCESS_KEY, userId, READ_HISTORY_VARIABLE);
disableAuthorization();
IList <Task> tasks = taskService.createTaskQuery().list();
foreach (Task task in tasks)
{
taskService.complete(task.Id);
}
enableAuthorization();
disableAuthorization();
repositoryService.deleteDeployment(deploymentId);
enableAuthorization();
// when
HistoricVariableInstanceQuery query = historyService.createHistoricVariableInstanceQuery();
// then
verifyQueryResults(query, 3);
cleanUpAfterDeploymentDeletion();
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Deployment public void testMultipleAsyncEndEvents()
public virtual void testMultipleAsyncEndEvents()
{
ProcessInstance pi = runtimeService.startProcessInstanceByKey("multipleAsyncEndEvent");
assertEquals(1, runtimeService.createProcessInstanceQuery().count());
// should stop at both end events
IList <Job> jobs = managementService.createJobQuery().withRetriesLeft().list();
assertEquals(2, jobs.Count);
// execute one of the end events
managementService.executeJob(jobs[0].Id);
jobs = managementService.createJobQuery().withRetriesLeft().list();
assertEquals(1, jobs.Count);
// execute the second one
managementService.executeJob(jobs[0].Id);
// assert that we have finished our instance now
assertEquals(0, runtimeService.createProcessInstanceQuery().count());
if (processEngineConfiguration.HistoryLevel.Id > ProcessEngineConfigurationImpl.HISTORYLEVEL_ACTIVITY)
{
// after the end event we have a event listener
HistoricVariableInstanceQuery name = historyService.createHistoricVariableInstanceQuery().processInstanceId(pi.Id).variableName("message");
Assert.assertNotNull(name);
Assert.assertEquals(true, name.singleResult().Value);
}
}
public virtual IList <HistoricVariableInstanceDto> queryHistoricVariableInstances(HistoricVariableInstanceQueryDto queryDto, int?firstResult, int?maxResults, bool deserializeObjectValues)
{
queryDto.ObjectMapper = objectMapper;
HistoricVariableInstanceQuery query = queryDto.toQuery(processEngine);
query.disableBinaryFetching();
if (!deserializeObjectValues)
{
query.disableCustomObjectDeserialization();
}
IList <HistoricVariableInstance> matchingHistoricVariableInstances;
if (firstResult != null || maxResults != null)
{
matchingHistoricVariableInstances = executePaginatedQuery(query, firstResult, maxResults);
}
else
{
matchingHistoricVariableInstances = query.list();
}
IList <HistoricVariableInstanceDto> historicVariableInstanceDtoResults = new List <HistoricVariableInstanceDto>();
foreach (HistoricVariableInstance historicVariableInstance in matchingHistoricVariableInstances)
{
HistoricVariableInstanceDto resultHistoricVariableInstance = HistoricVariableInstanceDto.fromHistoricVariableInstance(historicVariableInstance);
historicVariableInstanceDtoResults.Add(resultHistoricVariableInstance);
}
return(historicVariableInstanceDtoResults);
}
public virtual void testSetVariableLocalOnUserTask()
{
ProcessInstance pi = runtimeService.startProcessInstanceByKey("oneTaskProcess");
Task task = taskService.createTaskQuery().singleResult();
assertNotNull(task);
taskService.setVariableLocal(task.Id, "testVar", "testValue");
ExecutionEntity taskExecution = (ExecutionEntity)runtimeService.createExecutionQuery().executionId(task.ExecutionId).singleResult();
assertNotNull(taskExecution);
HistoricVariableInstanceQuery query = historyService.createHistoricVariableInstanceQuery();
assertEquals(1, query.count());
HistoricVariableInstance variable = query.singleResult();
assertNotNull(variable);
// the variable is in the task scope
assertEquals(taskExecution.ActivityInstanceId, variable.ActivityInstanceId);
taskService.complete(task.Id);
assertProcessEnded(pi.Id);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void deleteHistoricVariableInstancesWithDisabledTenantCheck()
public virtual void deleteHistoricVariableInstancesWithDisabledTenantCheck()
{
testRule.deployForTenant(TENANT_ONE, BPMN_ONETASK_PROCESS);
testRule.deployForTenant(TENANT_TWO, BPMN_ONETASK_PROCESS);
string processInstanceIdOne = startProcessInstance(TENANT_ONE);
string processInstanceIdTwo = startProcessInstance(TENANT_TWO);
runtimeService.setVariable(processInstanceIdOne, "myVariable", "testValue");
runtimeService.setVariable(processInstanceIdOne, "mySecondVariable", "testValue2");
runtimeService.setVariable(processInstanceIdTwo, "myVariable", "testValue");
runtimeService.setVariable(processInstanceIdTwo, "mySecondVariable", "testValue2");
HistoricVariableInstanceQuery variableQueryOne = historyService.createHistoricVariableInstanceQuery().processInstanceId(processInstanceIdOne);
HistoricVariableInstanceQuery variableQueryTwo = historyService.createHistoricVariableInstanceQuery().processInstanceId(processInstanceIdTwo);
assertThat(variableQueryOne.count(), @is(2L));
assertThat(variableQueryTwo.count(), @is(2L));
identityService.setAuthentication("user", null, null);
processEngineConfiguration.TenantCheckEnabled = false;
historyService.deleteHistoricVariableInstancesByProcessInstanceId(processInstanceIdOne);
assertThat(variableQueryOne.count(), @is(0L));
assertThat(variableQueryTwo.count(), @is(2L));
historyService.deleteHistoricVariableInstancesByProcessInstanceId(processInstanceIdTwo);
assertThat(variableQueryTwo.count(), @is(0L));
cleanUpAfterVariableInstanceTest(processInstanceIdOne, processInstanceIdTwo);
}
public virtual void testQueryNoAuthenticatedTenants()
{
identityService.setAuthentication("user", null, null);
HistoricVariableInstanceQuery query = historyService.createHistoricVariableInstanceQuery();
assertThat(query.count(), @is(0L));
}
public virtual void testQueryDisabledTenantCheck()
{
processEngineConfiguration.TenantCheckEnabled = false;
identityService.setAuthentication("user", null, null);
HistoricVariableInstanceQuery query = historyService.createHistoricVariableInstanceQuery();
assertThat(query.count(), @is(2L));
}
public virtual void testQueryAuthenticatedTenants()
{
identityService.setAuthentication("user", null, Arrays.asList(TENANT_ONE, TENANT_TWO));
HistoricVariableInstanceQuery query = historyService.createHistoricVariableInstanceQuery();
assertThat(query.count(), @is(2L));
assertThat(query.tenantIdIn(TENANT_ONE).count(), @is(1L));
assertThat(query.tenantIdIn(TENANT_TWO).count(), @is(1L));
}
// historic variable instance query (multiple process instances) ////////////////////////
public virtual void testQueryWithoutAuthorization()
{
startMultipleProcessInstances();
// when
HistoricVariableInstanceQuery query = historyService.createHistoricVariableInstanceQuery();
// then
verifyQueryResults(query, 0);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Before public void setUpRuntimeData()
public virtual void setUpRuntimeData()
{
mockInstanceBuilder = MockProvider.mockHistoricVariableInstance();
mockInstance = mockInstanceBuilder.build();
IList <HistoricVariableInstance> mocks = new List <HistoricVariableInstance>();
mocks.Add(mockInstance);
mockedQuery = setUpMockHistoricVariableInstanceQuery(mocks);
}
// historic variable instance query (process variables) ///////////////////////////////////////////
public virtual void testSimpleQueryWithoutAuthorization()
{
// given
startProcessInstanceByKey(PROCESS_KEY, Variables);
// when
HistoricVariableInstanceQuery query = historyService.createHistoricVariableInstanceQuery();
// then
verifyQueryResults(query, 0);
}
private HistoricVariableInstanceQuery setUpMockHistoricVariableInstanceQuery(IList <HistoricVariableInstance> mockedHistoricVariableInstances)
{
HistoricVariableInstanceQuery mockedHistoricVariableInstanceQuery = mock(typeof(HistoricVariableInstanceQuery));
when(mockedHistoricVariableInstanceQuery.list()).thenReturn(mockedHistoricVariableInstances);
when(mockedHistoricVariableInstanceQuery.count()).thenReturn((long)mockedHistoricVariableInstances.Count);
when(processEngine.HistoryService.createHistoricVariableInstanceQuery()).thenReturn(mockedHistoricVariableInstanceQuery);
return(mockedHistoricVariableInstanceQuery);
}
// historic variable instance query (case variables) /////////////////////////////////////////////
public virtual void testQueryAfterCaseVariables()
{
// given
createCaseInstanceByKey(CASE_KEY, Variables);
// when
HistoricVariableInstanceQuery query = historyService.createHistoricVariableInstanceQuery();
// then
verifyQueryResults(query, 1);
}
public virtual void testQueryByTenantId()
{
HistoricVariableInstanceQuery query = historyService.createHistoricVariableInstanceQuery().tenantIdIn(TENANT_ONE);
assertThat(query.count(), @is(1L));
assertEquals(query.list().get(0).Value, TENANT_ONE_VAR);
query = historyService.createHistoricVariableInstanceQuery().tenantIdIn(TENANT_TWO);
assertThat(query.count(), @is(1L));
assertEquals(query.list().get(0).Value, TENANT_TWO_VAR);
}
public virtual void testQueryWithReadHistoryPermissionOnProcessDefinition()
{
startMultipleProcessInstances();
createGrantAuthorization(PROCESS_DEFINITION, PROCESS_KEY, userId, READ_HISTORY);
// when
HistoricVariableInstanceQuery query = historyService.createHistoricVariableInstanceQuery();
// then
verifyQueryResults(query, 3);
}
public virtual void deleteHistoricVariableInstancesByTaskId(string taskId)
{
if (HistoryEnabled)
{
HistoricVariableInstanceQuery historicProcessVariableQuery = (new HistoricVariableInstanceQueryImpl()).taskIdIn(taskId);
IList <HistoricVariableInstance> historicProcessVariables = historicProcessVariableQuery.list();
foreach (HistoricVariableInstance historicProcessVariable in historicProcessVariables)
{
((HistoricVariableInstanceEntity)historicProcessVariable).delete();
}
}
}
public virtual void testSimpleQueryWithReadHistoryPermissionOnAnyProcessDefinition()
{
// given
startProcessInstanceByKey(PROCESS_KEY, Variables);
createGrantAuthorization(PROCESS_DEFINITION, ANY, userId, READ_HISTORY);
// when
HistoricVariableInstanceQuery query = historyService.createHistoricVariableInstanceQuery();
// then
verifyQueryResults(query, 1);
}
private IList <HistoricVariableInstance> executePaginatedQuery(HistoricVariableInstanceQuery query, int?firstResult, int?maxResults)
{
if (firstResult == null)
{
firstResult = 0;
}
if (maxResults == null)
{
maxResults = int.MaxValue;
}
return(query.listPage(firstResult, maxResults));
}
public virtual CountResultDto queryHistoricVariableInstancesCount(HistoricVariableInstanceQueryDto queryDto)
{
queryDto.ObjectMapper = objectMapper;
HistoricVariableInstanceQuery query = queryDto.toQuery(processEngine);
long count = query.count();
CountResultDto result = new CountResultDto();
result.Count = count;
return(result);
}
private void createHistoricVariableInstanceMock()
{
IList <HistoricVariableInstance> variables = new List <HistoricVariableInstance>();
HistoricVariableInstance mockInstance = MockProvider.createMockHistoricVariableInstance();
variables.Add(mockInstance);
HistoricVariableInstanceQuery mockHistoricVariableInstanceQuery = mock(typeof(HistoricVariableInstanceQuery));
when(mockHistoricVariableInstanceQuery.list()).thenReturn(variables);
when(mockHistoryService.createHistoricVariableInstanceQuery()).thenReturn(mockHistoricVariableInstanceQuery);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testSpinVariableInstanceRetrieval()
public virtual void testSpinVariableInstanceRetrieval()
{
MockHistoricVariableInstanceBuilder builder = MockProvider.mockHistoricVariableInstance().typedValue(Variables.serializedObjectValue("aSpinSerializedValue").serializationDataFormat("aDataFormat").objectTypeName("aRootType").create());
IList <HistoricVariableInstance> mockInstances = new List <HistoricVariableInstance>();
mockInstances.Add(builder.build());
mockedQuery = setUpMockHistoricVariableInstanceQuery(mockInstances);
given().then().expect().statusCode(Status.OK.StatusCode).and().body("size()", @is(1)).body("[0].type", equalTo(VariableTypeHelper.toExpectedValueTypeName(ValueType.OBJECT))).body("[0].value", equalTo("aSpinSerializedValue")).body("[0].valueInfo." + SerializableValueType.VALUE_INFO_OBJECT_TYPE_NAME, equalTo("aRootType")).body("[0].valueInfo." + SerializableValueType.VALUE_INFO_SERIALIZATION_DATA_FORMAT, equalTo("aDataFormat")).when().get(HISTORIC_VARIABLE_INSTANCE_RESOURCE_URL);
}
public virtual void testQueryWithReadHistoryVariablePermissionOnAnyProcessDefinition()
{
setReadHistoryVariableAsDefaultReadPermission();
startMultipleProcessInstances();
createGrantAuthorization(PROCESS_DEFINITION, ANY, userId, READ_HISTORY_VARIABLE);
// when
HistoricVariableInstanceQuery query = historyService.createHistoricVariableInstanceQuery();
// then
verifyQueryResults(query, 7);
}
public virtual void testSimpleQueryWithMultipleReadHistoryVariable()
{
setReadHistoryVariableAsDefaultReadPermission();
startProcessInstanceByKey(PROCESS_KEY, Variables);
createGrantAuthorization(PROCESS_DEFINITION, ANY, userId, READ_HISTORY_VARIABLE);
createGrantAuthorization(PROCESS_DEFINITION, PROCESS_KEY, userId, READ_HISTORY_VARIABLE);
// when
HistoricVariableInstanceQuery query = historyService.createHistoricVariableInstanceQuery();
// then
verifyQueryResults(query, 1);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Deployment public void testSetVariableOnServiceTaskInsideParallelBranch()
public virtual void testSetVariableOnServiceTaskInsideParallelBranch()
{
ProcessInstance pi = runtimeService.startProcessInstanceByKey("process");
HistoricVariableInstanceQuery query = historyService.createHistoricVariableInstanceQuery();
assertEquals(1, query.count());
HistoricVariableInstance variable = query.singleResult();
// the variable is in the process instance scope
assertEquals(pi.Id, variable.ActivityInstanceId);
assertProcessEnded(pi.Id);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void deleteHistoricVariableInstanceWithAuthenticatedTenant()
public virtual void deleteHistoricVariableInstanceWithAuthenticatedTenant()
{
testRule.deployForTenant(TENANT_ONE, BPMN_ONETASK_PROCESS);
string processInstanceId = startProcessInstance(null);
runtimeService.setVariable(processInstanceId, "myVariable", "testValue");
HistoricVariableInstanceQuery variableQuery = historyService.createHistoricVariableInstanceQuery().processInstanceId(processInstanceId);
assertThat(variableQuery.count(), @is(1L));
string variableInstanceId = variableQuery.singleResult().Id;
identityService.setAuthentication("user", null, Arrays.asList(TENANT_ONE));
historyService.deleteHistoricVariableInstance(variableInstanceId);
assertThat(variableQuery.count(), @is(0L));
cleanUpAfterVariableInstanceTest(processInstanceId);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Deployment public void testSetVariableLocalOnServiceTaskInsideSubProcess()
public virtual void testSetVariableLocalOnServiceTaskInsideSubProcess()
{
ProcessInstance pi = runtimeService.startProcessInstanceByKey("process");
HistoricVariableInstanceQuery query = historyService.createHistoricVariableInstanceQuery();
assertEquals(1, query.count());
string activityInstanceId = historyService.createHistoricActivityInstanceQuery().activityId("SubProcess_1").singleResult().Id;
HistoricVariableInstance variable = query.singleResult();
// the variable is in the sub process scope
assertEquals(activityInstanceId, variable.ActivityInstanceId);
assertProcessEnded(pi.Id);
}
// historic variable instance query (mixed variables) ////////////////////////////////////
public virtual void testMixedQueryWithoutAuthorization()
{
startMultipleProcessInstances();
setupMultipleMixedVariables();
// when
HistoricVariableInstanceQuery query = historyService.createHistoricVariableInstanceQuery();
// then
verifyQueryResults(query, 7);
deleteTask("one", true);
deleteTask("two", true);
deleteTask("three", true);
deleteTask("four", true);
deleteTask("five", true);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testSerializableVariableInstanceRetrieval()
public virtual void testSerializableVariableInstanceRetrieval()
{
//JAVA TO C# CONVERTER WARNING: The .NET Type.FullName property will not always yield results identical to the Java Class.getName method:
MockHistoricVariableInstanceBuilder builder = MockProvider.mockHistoricVariableInstance().typedValue(MockObjectValue.fromObjectValue(Variables.objectValue("a serialized value").serializationDataFormat(Variables.SerializationDataFormats.JAVA).create()).objectTypeName(typeof(string).FullName));
IList <HistoricVariableInstance> mockInstances = new List <HistoricVariableInstance>();
mockInstances.Add(builder.build());
mockedQuery = setUpMockHistoricVariableInstanceQuery(mockInstances);
//JAVA TO C# CONVERTER WARNING: The .NET Type.FullName property will not always yield results identical to the Java Class.getName method:
given().then().expect().statusCode(Status.OK.StatusCode).and().body("[0].type", equalTo(VariableTypeHelper.toExpectedValueTypeName(ValueType.OBJECT))).body("[0].value", equalTo("a serialized value")).body("[0].valueInfo." + SerializableValueType.VALUE_INFO_OBJECT_TYPE_NAME, equalTo(typeof(string).FullName)).body("[0].valueInfo." + SerializableValueType.VALUE_INFO_SERIALIZATION_DATA_FORMAT, equalTo(Variables.SerializationDataFormats.JAVA.Name)).when().get(HISTORIC_VARIABLE_INSTANCE_RESOURCE_URL);
// should not resolve custom objects but existing API requires it
// verify(mockedQuery).disableCustomObjectDeserialization();
verify(mockedQuery, never()).disableCustomObjectDeserialization();
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Ignore @Test public void testHistoryServiceEngineAccess_HistoricVariableInstanceBinaryFile()
public virtual void testHistoryServiceEngineAccess_HistoricVariableInstanceBinaryFile()
{
HistoricVariableInstanceQuery query = mock(typeof(HistoricVariableInstanceQuery));
HistoricVariableInstance instance = mock(typeof(HistoricVariableInstance));
string filename = "test.txt";
sbyte[] byteContent = "test".GetBytes();
string encoding = "UTF-8";
FileValue variableValue = Variables.fileValue(filename).file(byteContent).mimeType(ContentType.TEXT.ToString()).encoding(encoding).create();
when(instance.TypedValue).thenReturn(variableValue);
when(query.singleResult()).thenReturn(instance);
when(mockHistoryService.createHistoricVariableInstanceQuery()).thenReturn(query);
given().pathParam("name", EXAMPLE_ENGINE_NAME).pathParam("id", MockProvider.EXAMPLE_PROCESS_DEFINITION_ID).then().expect().statusCode(Status.OK.StatusCode).body(@is(equalTo(StringHelper.NewString(byteContent)))).and().header("Content-Disposition", "attachment; filename=" + filename).contentType(CoreMatchers.either <string>(equalTo(ContentType.TEXT.ToString() + ";charset=UTF-8")).or(equalTo(ContentType.TEXT.ToString() + " ;charset=UTF-8"))).when().get(HISTORY_BINARY_VARIABLE_INSTANCE_URL);
verify(mockHistoryService).createHistoricVariableInstanceQuery();
verifyZeroInteractions(processEngine);
}
// historic variable instance query (standalone task) /////////////////////////////////////////////
public virtual void testQueryAfterStandaloneTaskVariables()
{
// given
string taskId = "myTask";
createTask(taskId);
disableAuthorization();
taskService.setVariables(taskId, Variables);
enableAuthorization();
// when
HistoricVariableInstanceQuery query = historyService.createHistoricVariableInstanceQuery();
// then
verifyQueryResults(query, 1);
deleteTask(taskId, true);
}
