//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testDeleteCascadeProcessDefinitionDisabledTenantCheck()
public virtual void testDeleteCascadeProcessDefinitionDisabledTenantCheck()
{
//given deployment with a process definition and process instances
BpmnModelInstance bpmnModel = Bpmn.createExecutableProcess("process").startEvent().userTask().endEvent().done();
testRule.deployForTenant(TENANT_ONE, bpmnModel);
//tenant check disabled
processEngineConfiguration.TenantCheckEnabled = false;
ProcessDefinitionQuery processDefinitionQuery = repositoryService.createProcessDefinitionQuery();
ProcessDefinition processDefinition = processDefinitionQuery.processDefinitionKey("process").singleResult();
engineRule.RuntimeService.createProcessInstanceByKey("process").executeWithVariablesInReturn();
//user with no authentication
identityService.setAuthentication("user", null, null);
//when the corresponding process definition is cascading deleted from the deployment
repositoryService.deleteProcessDefinition(processDefinition.Id, true);
//then exist no process instance and one definition, because test case deployes per default one definition
identityService.clearAuthentication();
assertEquals(0, engineRule.RuntimeService.createProcessInstanceQuery().count());
if (processEngineConfiguration.HistoryLevel.Id >= org.camunda.bpm.engine.impl.history.HistoryLevel_Fields.HISTORY_LEVEL_ACTIVITY.Id)
{
assertEquals(0, engineRule.HistoryService.createHistoricActivityInstanceQuery().count());
}
assertThat(repositoryService.createProcessDefinitionQuery().count(), @is(1L));
assertThat(repositoryService.createProcessDefinitionQuery().tenantIdIn(TENANT_ONE).count(), @is(1L));
}
public virtual void testNotNullAndNullDeploymentSourceShouldDeployNewVersion()
{
// given
string key = "process";
string name = "my-deployment";
BpmnModelInstance model = Bpmn.createExecutableProcess(key).done();
ProcessDefinitionQuery processDefinitionQuery = repositoryService.createProcessDefinitionQuery().processDefinitionKey(key);
DeploymentQuery deploymentQuery = repositoryService.createDeploymentQuery().deploymentName(name);
// when
ProcessApplicationDeployment deployment1 = repositoryService.createDeployment(processApplication.Reference).name(name).source("my-source1").addModelInstance("process.bpmn", model).enableDuplicateFiltering(true).deploy();
assertEquals(1, processDefinitionQuery.count());
assertEquals(1, deploymentQuery.count());
ProcessApplicationDeployment deployment2 = repositoryService.createDeployment(processApplication.Reference).name(name).source(null).addModelInstance("process.bpmn", model).enableDuplicateFiltering(true).deploy();
// then
assertEquals(2, processDefinitionQuery.count());
assertEquals(2, deploymentQuery.count());
deleteDeployments(deployment1, deployment2);
}
public async void LatestProcessDefinitions_最终流程定义列表()
{
Exception ex = await Record.ExceptionAsync(async() =>
{
IProcessDefinitionController client = ctx.CreateWorkflowHttpProxy().GetProcessDefinitionClient();
ProcessDefinitionQuery query = new ProcessDefinitionQuery();
query.TenantId = ctx.TenantId;
query.Pageable = new Pageable
{
PageNo = 1,
PageSize = int.MaxValue,
Sort = new Sort(new Sort.Order[]
{
new Sort.Order
{
Property = "name",
Direction = Sort.Direction.ASC
}
})
};
Resources <ProcessDefinition> list = await client.LatestProcessDefinitions(query).ConfigureAwait(false);
Assert.True(list.TotalCount == list.List.Count());
Assert.True(list.TotalCount == list.RecordCount);
}).ConfigureAwait(false);
Assert.Null(ex);
}
public virtual IList <ProcessDefinitionDto> getProcessDefinitions(UriInfo uriInfo, int?firstResult, int?maxResults)
{
ProcessDefinitionQueryDto queryDto = new ProcessDefinitionQueryDto(ObjectMapper, uriInfo.QueryParameters);
IList <ProcessDefinitionDto> definitions = new List <ProcessDefinitionDto>();
ProcessEngine engine = ProcessEngine;
ProcessDefinitionQuery query = queryDto.toQuery(engine);
IList <ProcessDefinition> matchingDefinitions = null;
if (firstResult != null || maxResults != null)
{
matchingDefinitions = executePaginatedQuery(query, firstResult, maxResults);
}
else
{
matchingDefinitions = query.list();
}
foreach (ProcessDefinition definition in matchingDefinitions)
{
ProcessDefinitionDto def = ProcessDefinitionDto.fromProcessDefinition(definition);
definitions.Add(def);
}
return(definitions);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Before public void setUpHttpClientAndRuntimeData()
public virtual void setUpHttpClientAndRuntimeData()
{
client = HttpClients.createDefault();
reqConfig = RequestConfig.custom().setConnectTimeout(3 * 60 * 1000).setSocketTimeout(10 * 60 * 1000).build();
ProcessDefinition mockDefinition = MockProvider.createMockDefinition();
runtimeServiceMock = mock(typeof(RuntimeService));
when(processEngine.RuntimeService).thenReturn(runtimeServiceMock);
mockInstantiationBuilder = mock(typeof(ProcessInstantiationBuilder));
when(mockInstantiationBuilder.setVariables(any(typeof(System.Collections.IDictionary)))).thenReturn(mockInstantiationBuilder);
when(mockInstantiationBuilder.businessKey(anyString())).thenReturn(mockInstantiationBuilder);
when(mockInstantiationBuilder.caseInstanceId(anyString())).thenReturn(mockInstantiationBuilder);
when(runtimeServiceMock.createProcessInstanceById(anyString())).thenReturn(mockInstantiationBuilder);
ProcessInstanceWithVariables resultInstanceWithVariables = MockProvider.createMockInstanceWithVariables();
when(mockInstantiationBuilder.executeWithVariablesInReturn(anyBoolean(), anyBoolean())).thenReturn(resultInstanceWithVariables);
ProcessDefinitionQuery processDefinitionQueryMock = mock(typeof(ProcessDefinitionQuery));
when(processDefinitionQueryMock.processDefinitionKey(MockProvider.EXAMPLE_PROCESS_DEFINITION_KEY)).thenReturn(processDefinitionQueryMock);
when(processDefinitionQueryMock.withoutTenantId()).thenReturn(processDefinitionQueryMock);
when(processDefinitionQueryMock.latestVersion()).thenReturn(processDefinitionQueryMock);
when(processDefinitionQueryMock.singleResult()).thenReturn(mockDefinition);
RepositoryService repositoryServiceMock = mock(typeof(RepositoryService));
when(processEngine.RepositoryService).thenReturn(repositoryServiceMock);
when(repositoryServiceMock.createProcessDefinitionQuery()).thenReturn(processDefinitionQueryMock);
}
public virtual void testQueryByInvalidVersion()
{
ProcessDefinitionQuery query = repositoryService.createProcessDefinitionQuery().processDefinitionVersion(3);
verifyQueryResults(query, 0);
try
{
repositoryService.createProcessDefinitionQuery().processDefinitionVersion(-1).list();
fail();
}
catch (ProcessEngineException)
{
// Expected Exception
}
try
{
repositoryService.createProcessDefinitionQuery().processDefinitionVersion(null).list();
fail();
}
catch (ProcessEngineException)
{
// Expected Exception
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Before public void setup()
public virtual void setup()
{
authorizationServiceMock = mock(typeof(AuthorizationServiceImpl));
identityServiceMock = mock(typeof(IdentityServiceImpl));
repositoryServiceMock = mock(typeof(RepositoryService));
when(processEngine.AuthorizationService).thenReturn(authorizationServiceMock);
when(processEngine.IdentityService).thenReturn(identityServiceMock);
when(processEngine.RepositoryService).thenReturn(repositoryServiceMock);
// for authentication
userMock = MockProvider.createMockUser();
IList <Group> groupMocks = MockProvider.createMockGroups();
groupIds = setupGroupQueryMock(groupMocks);
IList <Tenant> tenantMocks = Collections.singletonList(MockProvider.createMockTenant());
tenantIds = setupTenantQueryMock(tenantMocks);
// example method
ProcessDefinition mockDefinition = MockProvider.createMockDefinition();
IList <ProcessDefinition> mockDefinitions = Arrays.asList(mockDefinition);
ProcessDefinitionQuery mockQuery = mock(typeof(ProcessDefinitionQuery));
when(repositoryServiceMock.createProcessDefinitionQuery()).thenReturn(mockQuery);
when(mockQuery.list()).thenReturn(mockDefinitions);
}
public virtual void testQueryNoAuthenticatedTenants()
{
identityService.setAuthentication("user", null, null);
ProcessDefinitionQuery query = repositoryService.createProcessDefinitionQuery();
assertThat(query.count(), @is(1L));
}
public virtual void testQueryByKeyLike()
{
ProcessDefinitionQuery query = repositoryService.createProcessDefinitionQuery().processDefinitionKeyLike("%o%");
verifyQueryResults(query, 3);
query = query.processDefinitionKeyLike("%z\\_%");
verifyQueryResults(query, 1);
}
public virtual void testQueryByVersion()
{
ProcessDefinitionQuery query = repositoryService.createProcessDefinitionQuery().processDefinitionVersion(2);
verifyQueryResults(query, 1);
query = repositoryService.createProcessDefinitionQuery().processDefinitionVersion(1);
verifyQueryResults(query, 3);
}
public virtual void testQueryByName()
{
ProcessDefinitionQuery query = repositoryService.createProcessDefinitionQuery().processDefinitionName("Two");
verifyQueryResults(query, 1);
query = repositoryService.createProcessDefinitionQuery().processDefinitionName("One");
verifyQueryResults(query, 2);
}
public virtual void testQueryDisabledTenantCheck()
{
processEngineConfiguration.TenantCheckEnabled = false;
identityService.setAuthentication("user", null, null);
ProcessDefinitionQuery query = repositoryService.createProcessDefinitionQuery();
assertThat(query.count(), @is(3L));
}
private ProcessDefinitionQuery setUpMockDefinitionQuery(IList <ProcessDefinition> mockedDefinitions)
{
ProcessDefinitionQuery sampleDefinitionsQuery = mock(typeof(ProcessDefinitionQuery));
when(sampleDefinitionsQuery.list()).thenReturn(mockedDefinitions);
when(sampleDefinitionsQuery.count()).thenReturn((long)mockedDefinitions.Count);
when(processEngine.RepositoryService.createProcessDefinitionQuery()).thenReturn(sampleDefinitionsQuery);
return(sampleDefinitionsQuery);
}
public virtual Task <Resources <ProcessDefinition> > ProcessDefinitions(ProcessDefinitionQuery queryObj)
{
IPage <ProcessDefinition> defs = new QueryProcessDefinitionCmd().LoadPage(this.repositoryService, this.pageableRepositoryService, queryObj);
IList <ProcessDefinitionResource> resources = resourceAssembler.ToResources(defs.GetContent());
Resources <ProcessDefinition> list = new Resources <ProcessDefinition>(resources.Select(x => x.Content), defs.GetTotalItems(), queryObj.Pageable.PageNo, queryObj.Pageable.PageSize);
return(Task.FromResult(list));
}
public virtual void testQueryByTenantId()
{
ProcessDefinitionQuery query = repositoryService.createProcessDefinitionQuery().tenantIdIn(TENANT_ONE);
assertThat(query.count(), @is(1L));
query = repositoryService.createProcessDefinitionQuery().tenantIdIn(TENANT_TWO);
assertThat(query.count(), @is(1L));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testStartableInTasklistPermissionCheck()
public virtual void testStartableInTasklistPermissionCheck()
{
IList <ProcessDefinition> processDefinitions = Arrays.asList(MockProvider.mockDefinition().isStartableInTasklist(false).build());
mockedQuery = setUpMockDefinitionQuery(processDefinitions);
given().queryParam("startablePermissionCheck", true).then().expect().statusCode(Status.OK.StatusCode).when().get(PROCESS_DEFINITION_QUERY_URL);
verify(mockedQuery).startablePermissionCheck();
verify(mockedQuery).list();
}
public virtual void testQueryAuthenticatedTenants()
{
identityService.setAuthentication("user", null, Arrays.asList(TENANT_ONE, TENANT_TWO));
ProcessDefinitionQuery query = repositoryService.createProcessDefinitionQuery();
assertThat(query.count(), @is(3L));
assertThat(query.tenantIdIn(TENANT_ONE).count(), @is(1L));
assertThat(query.tenantIdIn(TENANT_TWO).count(), @is(1L));
assertThat(query.withoutTenantId().count(), @is(1L));
}
public virtual void testQueryByKey()
{
// process one
ProcessDefinitionQuery query = repositoryService.createProcessDefinitionQuery().processDefinitionKey("one");
verifyQueryResults(query, 2);
// process two
query = repositoryService.createProcessDefinitionQuery().processDefinitionKey("two");
verifyQueryResults(query, 1);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testProcessDefinitionVersionTag()
public virtual void testProcessDefinitionVersionTag()
{
IList <ProcessDefinition> processDefinitions = Arrays.asList(MockProvider.mockDefinition().versionTag(MockProvider.EXAMPLE_VERSION_TAG).build(), MockProvider.mockDefinition().id(MockProvider.ANOTHER_EXAMPLE_PROCESS_DEFINITION_ID).versionTag(MockProvider.ANOTHER_EXAMPLE_VERSION_TAG).build());
mockedQuery = setUpMockDefinitionQuery(processDefinitions);
given().queryParam("versionTag", MockProvider.EXAMPLE_VERSION_TAG).then().expect().statusCode(Status.OK.StatusCode).when().get(PROCESS_DEFINITION_QUERY_URL);
verify(mockedQuery).versionTag(MockProvider.EXAMPLE_VERSION_TAG);
verify(mockedQuery).list();
}
public virtual void testQueryByLatest()
{
ProcessDefinitionQuery query = repositoryService.createProcessDefinitionQuery().latestVersion();
verifyQueryResults(query, 3);
query = repositoryService.createProcessDefinitionQuery().processDefinitionKey("one").latestVersion();
verifyQueryResults(query, 1);
query = repositoryService.createProcessDefinitionQuery().processDefinitionKey("two").latestVersion();
verifyQueryResults(query, 1);
}
private IList <ProcessDefinition> executePaginatedQuery(ProcessDefinitionQuery query, int?firstResult, int?maxResults)
{
if (firstResult == null)
{
firstResult = 0;
}
if (maxResults == null)
{
maxResults = int.MaxValue;
}
return(query.listPage(firstResult, maxResults));
}
public virtual void testQueryByCategoryLike()
{
ProcessDefinitionQuery query = repositoryService.createProcessDefinitionQuery().processDefinitionCategoryLike("%Example%");
verifyQueryResults(query, 3);
query = repositoryService.createProcessDefinitionQuery().processDefinitionCategoryLike("%amples2");
verifyQueryResults(query, 1);
query = repositoryService.createProcessDefinitionQuery().processDefinitionCategoryLike("%z\\_%");
verifyQueryResults(query, 1);
}
public virtual CountResultDto getProcessDefinitionsCount(UriInfo uriInfo)
{
ProcessDefinitionQueryDto queryDto = new ProcessDefinitionQueryDto(ObjectMapper, uriInfo.QueryParameters);
ProcessEngine engine = ProcessEngine;
ProcessDefinitionQuery query = queryDto.toQuery(engine);
long count = query.count();
CountResultDto result = new CountResultDto();
result.Count = count;
return(result);
}
public virtual void testQueryByTenantIdsIncludeDefinitionsWithoutTenantId()
{
ProcessDefinitionQuery query = repositoryService.createProcessDefinitionQuery().tenantIdIn(TENANT_ONE).includeProcessDefinitionsWithoutTenantId();
assertThat(query.count(), @is(2L));
query = repositoryService.createProcessDefinitionQuery().tenantIdIn(TENANT_TWO).includeProcessDefinitionsWithoutTenantId();
assertThat(query.count(), @is(2L));
query = repositoryService.createProcessDefinitionQuery().tenantIdIn(TENANT_ONE, TENANT_TWO).includeProcessDefinitionsWithoutTenantId();
assertThat(query.count(), @is(3L));
}
public virtual void testQueryByLatestWithoutTenantId()
{
// deploy a second version without tenant id
deployment(emptyProcess);
ProcessDefinitionQuery query = repositoryService.createProcessDefinitionQuery().processDefinitionKey(PROCESS_DEFINITION_KEY).latestVersion().withoutTenantId();
assertThat(query.count(), @is(1L));
ProcessDefinition processDefinition = query.singleResult();
assertThat(processDefinition.TenantId, @is(nullValue()));
assertThat(processDefinition.Version, @is(2));
}
private void setupProcessDefinitionMock()
{
ProcessDefinition mockDefinition = MockProvider.createMockDefinition();
processDefinitionQueryMock = mock(typeof(ProcessDefinitionQuery));
when(processDefinitionQueryMock.processDefinitionKey(MockProvider.EXAMPLE_PROCESS_DEFINITION_KEY)).thenReturn(processDefinitionQueryMock);
when(processDefinitionQueryMock.tenantIdIn(anyString())).thenReturn(processDefinitionQueryMock);
when(processDefinitionQueryMock.withoutTenantId()).thenReturn(processDefinitionQueryMock);
when(processDefinitionQueryMock.latestVersion()).thenReturn(processDefinitionQueryMock);
when(processDefinitionQueryMock.singleResult()).thenReturn(mockDefinition);
when(processDefinitionQueryMock.list()).thenReturn(Collections.singletonList(mockDefinition));
when(processDefinitionQueryMock.count()).thenReturn(1L);
when(processEngine.RepositoryService.createProcessDefinitionQuery()).thenReturn(processDefinitionQueryMock);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void suspendProcessDefinitionForNonTenant()
public virtual void suspendProcessDefinitionForNonTenant()
{
// given activated process definitions
ProcessDefinitionQuery query = engineRule.RepositoryService.createProcessDefinitionQuery();
assertThat(query.active().count(), @is(3L));
assertThat(query.suspended().count(), @is(0L));
engineRule.RepositoryService.updateProcessDefinitionSuspensionState().byProcessDefinitionKey(PROCESS_DEFINITION_KEY).processDefinitionWithoutTenantId().suspend();
assertThat(query.active().count(), @is(2L));
assertThat(query.suspended().count(), @is(1L));
assertThat(query.suspended().withoutTenantId().count(), @is(1L));
}
public virtual void testQueryByLatestWithTenantIds()
{
// deploy a second version for tenant one
deploymentForTenant(TENANT_ONE, emptyProcess);
ProcessDefinitionQuery query = repositoryService.createProcessDefinitionQuery().processDefinitionKey(PROCESS_DEFINITION_KEY).latestVersion().tenantIdIn(TENANT_ONE, TENANT_TWO);
// one definition for each tenant
assertThat(query.count(), @is(2L));
IDictionary <string, ProcessDefinition> processDefinitionsForTenant = getProcessDefinitionsForTenant(query.list());
assertThat(processDefinitionsForTenant[TENANT_ONE].Version, @is(2));
assertThat(processDefinitionsForTenant[TENANT_TWO].Version, @is(1));
}
public virtual void testQueryByLatestAndNameLike_NotFound()
{
string firstDeployment = repositoryService.createDeployment().addClasspathResource("org/camunda/bpm/engine/test/api/repository/first-process.bpmn20.xml").deploy().Id;
string secondDeployment = repositoryService.createDeployment().addClasspathResource("org/camunda/bpm/engine/test/api/repository/second-process.bpmn20.xml").deploy().Id;
ProcessDefinitionQuery query = repositoryService.createProcessDefinitionQuery();
query.processDefinitionNameLike("First%").latestVersion();
verifyQueryResults(query, 0);
repositoryService.deleteDeployment(firstDeployment, true);
repositoryService.deleteDeployment(secondDeployment, true);
}
public virtual void testQueryByKey()
{
ProcessDefinitionQuery query = repositoryService.createProcessDefinitionQuery().processDefinitionKey(PROCESS_DEFINITION_KEY);
// one definition for each tenant
assertThat(query.count(), @is(3L));
query = repositoryService.createProcessDefinitionQuery().processDefinitionKey(PROCESS_DEFINITION_KEY).withoutTenantId();
// one definition without tenant id
assertThat(query.count(), @is(1L));
query = repositoryService.createProcessDefinitionQuery().processDefinitionKey(PROCESS_DEFINITION_KEY).tenantIdIn(TENANT_ONE);
// one definition for tenant one
assertThat(query.count(), @is(1L));
}
