public virtual void testQueryByInvalidProcessInstanceIds() { // given IDictionary <string, object> variables1 = new Dictionary <string, object>(); variables1["stringVar"] = "test"; runtimeService.startProcessInstanceByKey(PROCESS_KEY, variables1); // when HistoricDetailQuery query = historyService.createHistoricDetailQuery(); try { // when query.processInstanceIdIn(null); fail("A ProcessEngineException was expected."); } catch (ProcessEngineException) { // then fails } try { // when query.processInstanceIdIn((string)null); fail("A ProcessEngineException was expected."); } catch (ProcessEngineException) { // then fails } }
public virtual void testQueryByOccurredAfterAndOccurredBefore() { // given DateTime startTime = new DateTime(); ClockUtil.CurrentTime = startTime; DateTime hourAgo = new DateTime(); hourAgo.AddHours(-1); DateTime hourFromNow = new DateTime(); hourFromNow.AddHours(1); IDictionary <string, object> variables = new Dictionary <string, object>(); variables["stringVar"] = "test"; runtimeService.startProcessInstanceByKey(PROCESS_KEY, variables); // when HistoricDetailQuery query = historyService.createHistoricDetailQuery(); // then assertEquals(0, query.occurredAfter(hourFromNow).occurredBefore(hourFromNow).count()); assertEquals(1, query.occurredAfter(hourAgo).occurredBefore(hourFromNow).count()); assertEquals(0, query.occurredAfter(hourFromNow).occurredBefore(hourAgo).count()); assertEquals(0, query.occurredAfter(hourAgo).occurredBefore(hourAgo).count()); }
public virtual void testDetailQueryWithReadHistoryOnAnyProcessDefinition() { // given startProcessInstanceByKey(PROCESS_KEY); string taskId = selectSingleTask().Id; disableAuthorization(); formService.submitTaskForm(taskId, Variables); enableAuthorization(); startProcessInstanceByKey(PROCESS_KEY); taskId = selectSingleTask().Id; disableAuthorization(); formService.submitTaskForm(taskId, Variables); enableAuthorization(); startProcessInstanceByKey(PROCESS_KEY, Variables); startProcessInstanceByKey(PROCESS_KEY, Variables); startProcessInstanceByKey(PROCESS_KEY, Variables); createGrantAuthorization(PROCESS_DEFINITION, ANY, userId, READ_HISTORY); // when HistoricDetailQuery query = historyService.createHistoricDetailQuery(); // then verifyQueryResults(query, 7); }
// historic detail query (variable update + form field) ////////// public virtual void testDetailQueryWithoutAuthorization() { // given startProcessInstanceByKey(PROCESS_KEY); string taskId = selectSingleTask().Id; disableAuthorization(); formService.submitTaskForm(taskId, Variables); enableAuthorization(); startProcessInstanceByKey(PROCESS_KEY); taskId = selectSingleTask().Id; disableAuthorization(); formService.submitTaskForm(taskId, Variables); enableAuthorization(); startProcessInstanceByKey(PROCESS_KEY, Variables); startProcessInstanceByKey(PROCESS_KEY, Variables); startProcessInstanceByKey(PROCESS_KEY, Variables); // when HistoricDetailQuery query = historyService.createHistoricDetailQuery(); // then verifyQueryResults(query, 0); }
public virtual void testQueryByVariableTypeInWithCapitalLetter() { // given IDictionary <string, object> variables1 = new Dictionary <string, object>(); variables1["stringVar"] = "test"; variables1["boolVar"] = true; runtimeService.startProcessInstanceByKey("oneTaskProcess", variables1); // when HistoricDetailQuery query = historyService.createHistoricDetailQuery().variableTypeIn("Boolean"); // then assertEquals(1, query.list().size()); assertEquals(1, query.count()); HistoricDetail historicDetail = query.list().get(0); if (historicDetail is HistoricVariableUpdate) { HistoricVariableUpdate variableUpdate = (HistoricVariableUpdate)historicDetail; assertEquals(variableUpdate.VariableName, "boolVar"); assertEquals(variableUpdate.TypeName, "boolean"); } else { fail("Historic detail should be a variable update!"); } }
private IList <HistoricDetailDto> executeHistoricDetailQuery(HistoricDetailQuery query, int?firstResult, int?maxResults, bool deserializeObjectValues) { query.disableBinaryFetching(); if (!deserializeObjectValues) { query.disableCustomObjectDeserialization(); } IList <HistoricDetail> queryResult; if (firstResult != null || maxResults != null) { queryResult = executePaginatedQuery(query, firstResult, maxResults); } else { queryResult = query.list(); } IList <HistoricDetailDto> result = new List <HistoricDetailDto>(); foreach (HistoricDetail historicDetail in queryResult) { HistoricDetailDto dto = HistoricDetailDto.fromHistoricDetail(historicDetail); result.Add(dto); } return(result); }
public virtual IList <HistoricDetailDto> getHistoricDetails(UriInfo uriInfo, int?firstResult, int?maxResults, bool deserializeObjectValues) { HistoricDetailQueryDto queryDto = new HistoricDetailQueryDto(objectMapper, uriInfo.QueryParameters); HistoricDetailQuery query = queryDto.toQuery(processEngine); return(executeHistoricDetailQuery(query, firstResult, maxResults, deserializeObjectValues)); }
public virtual void testQueryNoAuthenticatedTenants() { identityService.setAuthentication("user", null, null); HistoricDetailQuery query = historyService.createHistoricDetailQuery(); assertThat(query.count(), @is(0L)); }
private void createHistoricDetailMock() { IList <HistoricDetail> details = MockProvider.createMockHistoricDetails(); HistoricDetailQuery query = mock(typeof(HistoricDetailQuery)); when(mockHistoryService.createHistoricDetailQuery()).thenReturn(query); when(query.list()).thenReturn(details); }
public virtual void testQueryDisabledTenantCheck() { processEngineConfiguration.TenantCheckEnabled = false; identityService.setAuthentication("user", null, null); HistoricDetailQuery query = historyService.createHistoricDetailQuery(); assertThat(query.count(), @is(4L)); }
public virtual void testQueryAuthenticatedTenants() { identityService.setAuthentication("user", null, Arrays.asList(TENANT_ONE, TENANT_TWO)); HistoricDetailQuery query = historyService.createHistoricDetailQuery(); assertThat(query.count(), @is(4L)); assertThat(query.tenantIdIn(TENANT_ONE).count(), @is(2L)); assertThat(query.tenantIdIn(TENANT_TWO).count(), @is(2L)); }
public virtual void testQueryByTenantId() { HistoricDetailQuery query = historyService.createHistoricDetailQuery().variableUpdates().tenantIdIn(TENANT_ONE); assertThat(query.count(), @is(2L)); query = historyService.createHistoricDetailQuery().variableUpdates().tenantIdIn(TENANT_TWO); assertThat(query.count(), @is(2L)); }
// historic variable update query (case variables) ///////////////////////////////////////////// public virtual void testQueryAfterCaseVariables() { // given createCaseInstanceByKey(CASE_KEY, Variables); // when HistoricDetailQuery query = historyService.createHistoricDetailQuery().variableUpdates(); // then verifyQueryResults(query, 1); }
// historic variable update query (process task) ///////////////////////////////////////////// public virtual void testSimpleVariableUpdateQueryWithoutAuthorization() { // given startProcessInstanceByKey(PROCESS_KEY, Variables); // when HistoricDetailQuery query = historyService.createHistoricDetailQuery().variableUpdates(); // then verifyQueryResults(query, 0); }
public virtual CountResultDto getHistoricDetailsCount(UriInfo uriInfo) { HistoricDetailQueryDto queryDto = new HistoricDetailQueryDto(objectMapper, uriInfo.QueryParameters); HistoricDetailQuery query = queryDto.toQuery(processEngine); long count = query.count(); CountResultDto result = new CountResultDto(); result.Count = count; return(result); }
private IList <HistoricDetail> executePaginatedQuery(HistoricDetailQuery query, int?firstResult, int?maxResults) { if (firstResult == null) { firstResult = 0; } if (maxResults == null) { maxResults = int.MaxValue; } return(query.listPage(firstResult, maxResults)); }
public virtual void testSimpleVariableUpdateQueryWithReadHistoryPermissionOnProcessDefinition() { // given startProcessInstanceByKey(PROCESS_KEY, Variables); createGrantAuthorization(PROCESS_DEFINITION, PROCESS_KEY, userId, READ_HISTORY); // when HistoricDetailQuery query = historyService.createHistoricDetailQuery().variableUpdates(); // then verifyQueryResults(query, 1); }
// delete deployment (cascade = false) public virtual void testQueryAfterDeletingDeployment() { // given startProcessInstanceByKey(PROCESS_KEY); string taskId = selectSingleTask().Id; disableAuthorization(); formService.submitTaskForm(taskId, Variables); enableAuthorization(); startProcessInstanceByKey(PROCESS_KEY); taskId = selectSingleTask().Id; disableAuthorization(); formService.submitTaskForm(taskId, Variables); enableAuthorization(); startProcessInstanceByKey(PROCESS_KEY, Variables); startProcessInstanceByKey(PROCESS_KEY, Variables); startProcessInstanceByKey(PROCESS_KEY, Variables); createGrantAuthorization(PROCESS_DEFINITION, PROCESS_KEY, userId, READ_HISTORY); disableAuthorization(); IList <Task> tasks = taskService.createTaskQuery().list(); foreach (Task task in tasks) { taskService.complete(task.Id); } enableAuthorization(); disableAuthorization(); repositoryService.deleteDeployment(deploymentId); enableAuthorization(); // when HistoricDetailQuery query = historyService.createHistoricDetailQuery(); // then verifyQueryResults(query, 7); disableAuthorization(); IList <HistoricProcessInstance> instances = historyService.createHistoricProcessInstanceQuery().list(); foreach (HistoricProcessInstance instance in instances) { historyService.deleteHistoricProcessInstance(instance.Id); } enableAuthorization(); }
public virtual void testQueryByNonExistingProcessInstanceId() { // given IDictionary <string, object> variables = new Dictionary <string, object>(); variables["stringVar"] = "test"; runtimeService.startProcessInstanceByKey(PROCESS_KEY, variables); // when HistoricDetailQuery query = historyService.createHistoricDetailQuery().processInstanceIdIn("foo"); // then assertEquals(0, query.count()); }
public virtual void testQueryByInvalidExecutionId() { startProcessInstance(PROCESS_KEY); string taskId = taskService.createTaskQuery().singleResult().Id; // when taskService.resolveTask(taskId, Variables); //then HistoricDetailQuery query = historyService.createHistoricDetailQuery().executionId("invalid"); assertEquals(0, query.list().size()); assertEquals(0, query.count()); }
public virtual void testQueryBySingleProcessInstanceId() { // given IDictionary <string, object> variables = new Dictionary <string, object>(); variables["stringVar"] = "test"; ProcessInstance processInstance = runtimeService.startProcessInstanceByKey(PROCESS_KEY, variables); // when HistoricDetailQuery query = historyService.createHistoricDetailQuery().variableUpdates().processInstanceIdIn(processInstance.ProcessInstanceId); // then assertEquals(1, query.count()); assertEquals(query.list().get(0).ProcessInstanceId, processInstance.Id); }
// historic variable update query (multiple process instances) /////////////////////////////////////////// public virtual void testFormFieldQueryWithoutAuthorization() { // given startProcessInstanceByKey(PROCESS_KEY, Variables); startProcessInstanceByKey(PROCESS_KEY, Variables); startProcessInstanceByKey(PROCESS_KEY, Variables); startProcessInstanceByKey(MESSAGE_START_PROCESS_KEY, Variables); startProcessInstanceByKey(MESSAGE_START_PROCESS_KEY, Variables); startProcessInstanceByKey(MESSAGE_START_PROCESS_KEY, Variables); startProcessInstanceByKey(MESSAGE_START_PROCESS_KEY, Variables); // when HistoricDetailQuery query = historyService.createHistoricDetailQuery().formFields(); // then verifyQueryResults(query, 0); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Ignore @Test public void testHistoryServiceEngineAccess_HistoricDetailBinaryFile() public virtual void testHistoryServiceEngineAccess_HistoricDetailBinaryFile() { HistoricDetailQuery query = mock(typeof(HistoricDetailQuery)); HistoricVariableUpdate instance = mock(typeof(HistoricVariableUpdate)); 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.createHistoricDetailQuery()).thenReturn(query); given().pathParam("name", EXAMPLE_ENGINE_NAME).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_DETAIL_URL); verify(mockHistoryService).createHistoricDetailQuery(); verifyZeroInteractions(processEngine); }
// historic variable update query (standalone task) ///////////////////////////////////////////// public virtual void testQueryAfterStandaloneTaskVariableUpdates() { // given string taskId = "myTask"; createTask(taskId); disableAuthorization(); taskService.setVariables(taskId, Variables); enableAuthorization(); // when HistoricDetailQuery query = historyService.createHistoricDetailQuery().variableUpdates(); // then verifyQueryResults(query, 1); deleteTask(taskId, true); }
public virtual void testMixedQueryWithReadHistoryPermissionOnAnyProcessDefinition() { // given startProcessInstanceByKey(PROCESS_KEY, Variables); startProcessInstanceByKey(PROCESS_KEY, Variables); startProcessInstanceByKey(PROCESS_KEY, Variables); startProcessInstanceByKey(MESSAGE_START_PROCESS_KEY, Variables); startProcessInstanceByKey(MESSAGE_START_PROCESS_KEY, Variables); startProcessInstanceByKey(MESSAGE_START_PROCESS_KEY, Variables); startProcessInstanceByKey(MESSAGE_START_PROCESS_KEY, Variables); createTask("one"); createTask("two"); createTask("three"); createTask("four"); createTask("five"); disableAuthorization(); taskService.setVariables("one", Variables); taskService.setVariables("two", Variables); taskService.setVariables("three", Variables); taskService.setVariables("four", Variables); taskService.setVariables("five", Variables); enableAuthorization(); createCaseInstanceByKey(CASE_KEY, Variables); createCaseInstanceByKey(CASE_KEY, Variables); createGrantAuthorization(PROCESS_DEFINITION, ANY, userId, READ_HISTORY); // when HistoricDetailQuery query = historyService.createHistoricDetailQuery().variableUpdates(); // then verifyQueryResults(query, 14); deleteTask("one", true); deleteTask("two", true); deleteTask("three", true); deleteTask("four", true); deleteTask("five", true); }
public virtual void testQueryByUserOperationId() { startProcessInstance(PROCESS_KEY); identityService.AuthenticatedUserId = "demo"; string taskId = taskService.createTaskQuery().singleResult().Id; // when taskService.resolveTask(taskId, Variables); //then string userOperationId = historyService.createHistoricDetailQuery().singleResult().UserOperationId; HistoricDetailQuery query = historyService.createHistoricDetailQuery().userOperationId(userOperationId); assertEquals(1, query.list().size()); assertEquals(1, query.count()); }
// historic variable update query (mixed) //////////////////////////////////// public virtual void testMixedQueryWithoutAuthorization() { // given startProcessInstanceByKey(PROCESS_KEY, Variables); startProcessInstanceByKey(PROCESS_KEY, Variables); startProcessInstanceByKey(PROCESS_KEY, Variables); startProcessInstanceByKey(MESSAGE_START_PROCESS_KEY, Variables); startProcessInstanceByKey(MESSAGE_START_PROCESS_KEY, Variables); startProcessInstanceByKey(MESSAGE_START_PROCESS_KEY, Variables); startProcessInstanceByKey(MESSAGE_START_PROCESS_KEY, Variables); createTask("one"); createTask("two"); createTask("three"); createTask("four"); createTask("five"); disableAuthorization(); taskService.setVariables("one", Variables); taskService.setVariables("two", Variables); taskService.setVariables("three", Variables); taskService.setVariables("four", Variables); taskService.setVariables("five", Variables); enableAuthorization(); createCaseInstanceByKey(CASE_KEY, Variables); createCaseInstanceByKey(CASE_KEY, Variables); // when HistoricDetailQuery query = historyService.createHistoricDetailQuery().variableUpdates(); // then verifyQueryResults(query, 7); deleteTask("one", true); deleteTask("two", true); deleteTask("three", true); deleteTask("four", true); deleteTask("five", true); }
public virtual void testQueryByInvalidVariableTypeIn() { // given IDictionary <string, object> variables1 = new Dictionary <string, object>(); variables1["stringVar"] = "test"; variables1["boolVar"] = true; variables1["intVar"] = 5; runtimeService.startProcessInstanceByKey("oneTaskProcess", variables1); // when HistoricDetailQuery query = historyService.createHistoricDetailQuery().variableTypeIn("invalid"); // then assertEquals(0, query.count()); try { // when query.variableTypeIn(null); fail("A ProcessEngineException was expected."); } catch (ProcessEngineException) { // then fails } try { // when query.variableTypeIn((string)null); fail("A ProcessEngineException was expected."); } catch (ProcessEngineException) { // then fails } }
public virtual void testQueryBySeveralProcessInstanceIds() { // given IDictionary <string, object> variables = new Dictionary <string, object>(); variables["stringVar"] = "test"; ProcessInstance processInstance = runtimeService.startProcessInstanceByKey(PROCESS_KEY, variables); ProcessInstance processInstance2 = runtimeService.startProcessInstanceByKey(PROCESS_KEY, variables); runtimeService.startProcessInstanceByKey(PROCESS_KEY, variables); // when HistoricDetailQuery query = historyService.createHistoricDetailQuery().variableUpdates().processInstanceIdIn(processInstance.ProcessInstanceId, processInstance2.ProcessInstanceId); // then ISet <string> expectedProcessInstanceIds = new HashSet <string>(); expectedProcessInstanceIds.Add(processInstance.Id); expectedProcessInstanceIds.Add(processInstance2.Id); assertEquals(2, query.count()); assertTrue(expectedProcessInstanceIds.Contains(query.list().get(0).ProcessInstanceId)); assertTrue(expectedProcessInstanceIds.Contains(query.list().get(1).ProcessInstanceId)); }
public virtual void testQueryByVariableTypeInWithSeveralTypes() { // given IDictionary <string, object> variables1 = new Dictionary <string, object>(); variables1["stringVar"] = "test"; variables1["boolVar"] = true; variables1["intVar"] = 5; variables1["nullVar"] = null; variables1["pojoVar"] = new TestPojo("str", .0); runtimeService.startProcessInstanceByKey("oneTaskProcess", variables1); // when HistoricDetailQuery query = historyService.createHistoricDetailQuery().variableTypeIn("boolean", "integer", "Serializable"); // then assertEquals(3, query.list().size()); assertEquals(3, query.count()); ISet <string> allowedVariableTypes = new HashSet <string>(); allowedVariableTypes.Add("boolean"); allowedVariableTypes.Add("integer"); allowedVariableTypes.Add("object"); foreach (HistoricDetail detail in query.list()) { if (detail is HistoricVariableUpdate) { HistoricVariableUpdate variableUpdate = (HistoricVariableUpdate)detail; assertTrue(allowedVariableTypes.Contains(variableUpdate.TypeName)); } else { fail("Historic detail should be a variable update!"); } } }