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); }