use of org.camunda.bpm.engine.identity.User in project camunda-bpm-platform by camunda.
the class TaskQueryExpressionTest method tearDown.
@After
public void tearDown() {
Mocks.reset();
for (Group group : identityService.createGroupQuery().list()) {
identityService.deleteGroup(group.getId());
}
for (User user : identityService.createUserQuery().list()) {
identityService.deleteUser(user.getId());
}
for (Task task : taskService.createTaskQuery().list()) {
if (task.getProcessInstanceId() == null) {
taskService.deleteTask(task.getId(), true);
}
}
identityService.clearAuthentication();
}
use of org.camunda.bpm.engine.identity.User in project camunda-bpm-platform by camunda.
the class DemoDataGenerator method createUsers.
public void createUsers(ProcessEngine engine) {
final IdentityService identityService = engine.getIdentityService();
if (identityService.isReadOnly()) {
LOGGER.info("Identity service provider is Read Only, not creating any demo users.");
return;
}
User singleResult = identityService.createUserQuery().userId("demo").singleResult();
if (singleResult != null) {
return;
}
LOGGER.info("Generating demo data for invoice showcase");
User user = identityService.newUser("demo");
user.setFirstName("Demo");
user.setLastName("Demo");
user.setPassword("demo");
user.setEmail("demo@camunda.org");
identityService.saveUser(user);
User user2 = identityService.newUser("john");
user2.setFirstName("John");
user2.setLastName("Doe");
user2.setPassword("john");
user2.setEmail("john@camunda.org");
identityService.saveUser(user2);
User user3 = identityService.newUser("mary");
user3.setFirstName("Mary");
user3.setLastName("Anne");
user3.setPassword("mary");
user3.setEmail("mary@camunda.org");
identityService.saveUser(user3);
User user4 = identityService.newUser("peter");
user4.setFirstName("Peter");
user4.setLastName("Meter");
user4.setPassword("peter");
user4.setEmail("peter@camunda.org");
identityService.saveUser(user4);
Group salesGroup = identityService.newGroup("sales");
salesGroup.setName("Sales");
salesGroup.setType("WORKFLOW");
identityService.saveGroup(salesGroup);
Group accountingGroup = identityService.newGroup("accounting");
accountingGroup.setName("Accounting");
accountingGroup.setType("WORKFLOW");
identityService.saveGroup(accountingGroup);
Group managementGroup = identityService.newGroup("management");
managementGroup.setName("Management");
managementGroup.setType("WORKFLOW");
identityService.saveGroup(managementGroup);
final AuthorizationService authorizationService = engine.getAuthorizationService();
// create group
if (identityService.createGroupQuery().groupId(Groups.CAMUNDA_ADMIN).count() == 0) {
Group camundaAdminGroup = identityService.newGroup(Groups.CAMUNDA_ADMIN);
camundaAdminGroup.setName("camunda BPM Administrators");
camundaAdminGroup.setType(Groups.GROUP_TYPE_SYSTEM);
identityService.saveGroup(camundaAdminGroup);
}
// create ADMIN authorizations on all built-in resources
for (Resource resource : Resources.values()) {
if (authorizationService.createAuthorizationQuery().groupIdIn(Groups.CAMUNDA_ADMIN).resourceType(resource).resourceId(ANY).count() == 0) {
AuthorizationEntity userAdminAuth = new AuthorizationEntity(AUTH_TYPE_GRANT);
userAdminAuth.setGroupId(Groups.CAMUNDA_ADMIN);
userAdminAuth.setResource(resource);
userAdminAuth.setResourceId(ANY);
userAdminAuth.addPermission(ALL);
authorizationService.saveAuthorization(userAdminAuth);
}
}
identityService.createMembership("demo", "sales");
identityService.createMembership("demo", "accounting");
identityService.createMembership("demo", "management");
identityService.createMembership("demo", "camunda-admin");
identityService.createMembership("john", "sales");
identityService.createMembership("mary", "accounting");
identityService.createMembership("peter", "management");
// authorize groups for tasklist only:
Authorization salesTasklistAuth = authorizationService.createNewAuthorization(AUTH_TYPE_GRANT);
salesTasklistAuth.setGroupId("sales");
salesTasklistAuth.addPermission(ACCESS);
salesTasklistAuth.setResourceId("tasklist");
salesTasklistAuth.setResource(APPLICATION);
authorizationService.saveAuthorization(salesTasklistAuth);
Authorization salesReadProcessDefinition = authorizationService.createNewAuthorization(AUTH_TYPE_GRANT);
salesReadProcessDefinition.setGroupId("sales");
salesReadProcessDefinition.addPermission(Permissions.READ);
salesReadProcessDefinition.addPermission(Permissions.READ_HISTORY);
salesReadProcessDefinition.setResource(Resources.PROCESS_DEFINITION);
// restrict to invoice process definition only
salesReadProcessDefinition.setResourceId("invoice");
authorizationService.saveAuthorization(salesReadProcessDefinition);
Authorization accountingTasklistAuth = authorizationService.createNewAuthorization(AUTH_TYPE_GRANT);
accountingTasklistAuth.setGroupId("accounting");
accountingTasklistAuth.addPermission(ACCESS);
accountingTasklistAuth.setResourceId("tasklist");
accountingTasklistAuth.setResource(APPLICATION);
authorizationService.saveAuthorization(accountingTasklistAuth);
Authorization accountingReadProcessDefinition = authorizationService.createNewAuthorization(AUTH_TYPE_GRANT);
accountingReadProcessDefinition.setGroupId("accounting");
accountingReadProcessDefinition.addPermission(Permissions.READ);
accountingReadProcessDefinition.addPermission(Permissions.READ_HISTORY);
accountingReadProcessDefinition.setResource(Resources.PROCESS_DEFINITION);
// restrict to invoice process definition only
accountingReadProcessDefinition.setResourceId("invoice");
authorizationService.saveAuthorization(accountingReadProcessDefinition);
Authorization managementTasklistAuth = authorizationService.createNewAuthorization(AUTH_TYPE_GRANT);
managementTasklistAuth.setGroupId("management");
managementTasklistAuth.addPermission(ACCESS);
managementTasklistAuth.setResourceId("tasklist");
managementTasklistAuth.setResource(APPLICATION);
authorizationService.saveAuthorization(managementTasklistAuth);
Authorization managementReadProcessDefinition = authorizationService.createNewAuthorization(AUTH_TYPE_GRANT);
managementReadProcessDefinition.setGroupId("management");
managementReadProcessDefinition.addPermission(Permissions.READ);
managementReadProcessDefinition.addPermission(Permissions.READ_HISTORY);
managementReadProcessDefinition.setResource(Resources.PROCESS_DEFINITION);
// restrict to invoice process definition only
managementReadProcessDefinition.setResourceId("invoice");
authorizationService.saveAuthorization(managementReadProcessDefinition);
Authorization salesDemoAuth = authorizationService.createNewAuthorization(AUTH_TYPE_GRANT);
salesDemoAuth.setGroupId("sales");
salesDemoAuth.setResource(USER);
salesDemoAuth.setResourceId("demo");
salesDemoAuth.addPermission(READ);
authorizationService.saveAuthorization(salesDemoAuth);
Authorization salesJohnAuth = authorizationService.createNewAuthorization(AUTH_TYPE_GRANT);
salesJohnAuth.setGroupId("sales");
salesJohnAuth.setResource(USER);
salesJohnAuth.setResourceId("john");
salesJohnAuth.addPermission(READ);
authorizationService.saveAuthorization(salesJohnAuth);
Authorization manDemoAuth = authorizationService.createNewAuthorization(AUTH_TYPE_GRANT);
manDemoAuth.setGroupId("management");
manDemoAuth.setResource(USER);
manDemoAuth.setResourceId("demo");
manDemoAuth.addPermission(READ);
authorizationService.saveAuthorization(manDemoAuth);
Authorization manPeterAuth = authorizationService.createNewAuthorization(AUTH_TYPE_GRANT);
manPeterAuth.setGroupId("management");
manPeterAuth.setResource(USER);
manPeterAuth.setResourceId("peter");
manPeterAuth.addPermission(READ);
authorizationService.saveAuthorization(manPeterAuth);
Authorization accDemoAuth = authorizationService.createNewAuthorization(AUTH_TYPE_GRANT);
accDemoAuth.setGroupId("accounting");
accDemoAuth.setResource(USER);
accDemoAuth.setResourceId("demo");
accDemoAuth.addPermission(READ);
authorizationService.saveAuthorization(accDemoAuth);
Authorization accMaryAuth = authorizationService.createNewAuthorization(AUTH_TYPE_GRANT);
accMaryAuth.setGroupId("accounting");
accMaryAuth.setResource(USER);
accMaryAuth.setResourceId("mary");
accMaryAuth.addPermission(READ);
authorizationService.saveAuthorization(accMaryAuth);
Authorization taskMaryAuth = authorizationService.createNewAuthorization(AUTH_TYPE_GRANT);
taskMaryAuth.setUserId("mary");
taskMaryAuth.setResource(TASK);
taskMaryAuth.setResourceId(ANY);
taskMaryAuth.addPermission(READ);
taskMaryAuth.addPermission(UPDATE);
authorizationService.saveAuthorization(taskMaryAuth);
// create default filters
FilterService filterService = engine.getFilterService();
Map<String, Object> filterProperties = new HashMap<String, Object>();
filterProperties.put("description", "Tasks assigned to me");
filterProperties.put("priority", -10);
addVariables(filterProperties);
TaskService taskService = engine.getTaskService();
TaskQuery query = taskService.createTaskQuery().taskAssigneeExpression("${currentUser()}");
Filter myTasksFilter = filterService.newTaskFilter().setName("My Tasks").setProperties(filterProperties).setOwner("demo").setQuery(query);
filterService.saveFilter(myTasksFilter);
filterProperties.clear();
filterProperties.put("description", "Tasks assigned to my Groups");
filterProperties.put("priority", -5);
addVariables(filterProperties);
query = taskService.createTaskQuery().taskCandidateGroupInExpression("${currentUserGroups()}").taskUnassigned();
Filter groupTasksFilter = filterService.newTaskFilter().setName("My Group Tasks").setProperties(filterProperties).setOwner("demo").setQuery(query);
filterService.saveFilter(groupTasksFilter);
// global read authorizations for these filters
Authorization globalMyTaskFilterRead = authorizationService.createNewAuthorization(Authorization.AUTH_TYPE_GLOBAL);
globalMyTaskFilterRead.setResource(FILTER);
globalMyTaskFilterRead.setResourceId(myTasksFilter.getId());
globalMyTaskFilterRead.addPermission(READ);
authorizationService.saveAuthorization(globalMyTaskFilterRead);
Authorization globalGroupFilterRead = authorizationService.createNewAuthorization(Authorization.AUTH_TYPE_GLOBAL);
globalGroupFilterRead.setResource(FILTER);
globalGroupFilterRead.setResourceId(groupTasksFilter.getId());
globalGroupFilterRead.addPermission(READ);
authorizationService.saveAuthorization(globalGroupFilterRead);
// management filter
filterProperties.clear();
filterProperties.put("description", "Tasks for Group Accounting");
filterProperties.put("priority", -3);
addVariables(filterProperties);
query = taskService.createTaskQuery().taskCandidateGroupIn(Arrays.asList("accounting")).taskUnassigned();
Filter candidateGroupTasksFilter = filterService.newTaskFilter().setName("Accounting").setProperties(filterProperties).setOwner("demo").setQuery(query);
filterService.saveFilter(candidateGroupTasksFilter);
Authorization managementGroupFilterRead = authorizationService.createNewAuthorization(Authorization.AUTH_TYPE_GRANT);
managementGroupFilterRead.setResource(FILTER);
managementGroupFilterRead.setResourceId(candidateGroupTasksFilter.getId());
managementGroupFilterRead.addPermission(READ);
managementGroupFilterRead.setGroupId("accounting");
authorizationService.saveAuthorization(managementGroupFilterRead);
// john's tasks
filterProperties.clear();
filterProperties.put("description", "Tasks assigned to John");
filterProperties.put("priority", -1);
addVariables(filterProperties);
query = taskService.createTaskQuery().taskAssignee("john");
Filter johnsTasksFilter = filterService.newTaskFilter().setName("John's Tasks").setProperties(filterProperties).setOwner("demo").setQuery(query);
filterService.saveFilter(johnsTasksFilter);
// mary's tasks
filterProperties.clear();
filterProperties.put("description", "Tasks assigned to Mary");
filterProperties.put("priority", -1);
addVariables(filterProperties);
query = taskService.createTaskQuery().taskAssignee("mary");
Filter marysTasksFilter = filterService.newTaskFilter().setName("Mary's Tasks").setProperties(filterProperties).setOwner("demo").setQuery(query);
filterService.saveFilter(marysTasksFilter);
// peter's tasks
filterProperties.clear();
filterProperties.put("description", "Tasks assigned to Peter");
filterProperties.put("priority", -1);
addVariables(filterProperties);
query = taskService.createTaskQuery().taskAssignee("peter");
Filter petersTasksFilter = filterService.newTaskFilter().setName("Peter's Tasks").setProperties(filterProperties).setOwner("demo").setQuery(query);
filterService.saveFilter(petersTasksFilter);
// all tasks
filterProperties.clear();
filterProperties.put("description", "All Tasks - Not recommended to be used in production :)");
filterProperties.put("priority", 10);
addVariables(filterProperties);
query = taskService.createTaskQuery();
Filter allTasksFilter = filterService.newTaskFilter().setName("All Tasks").setProperties(filterProperties).setOwner("demo").setQuery(query);
filterService.saveFilter(allTasksFilter);
}
use of org.camunda.bpm.engine.identity.User in project camunda-bpm-platform by camunda.
the class DeployUserWithoutSaltForPasswordHashingScenario method initUser.
@DescribesScenario("initUser")
@Times(1)
public static ScenarioSetup initUser() {
return new ScenarioSetup() {
public void execute(ProcessEngine engine, String scenarioName) {
// given
IdentityService identityService = engine.getIdentityService();
User user = identityService.newUser(USER_NAME);
user.setPassword(USER_PWD);
// when
identityService.saveUser(user);
}
};
}
use of org.camunda.bpm.engine.identity.User in project camunda-bpm-platform by camunda.
the class AuthorizationScenario method createUser.
// user ////////////////////////////////////////////////////////////////
protected User createUser(IdentityService identityService, String userId) {
User user = identityService.newUser(userId);
identityService.saveUser(user);
return user;
}
use of org.camunda.bpm.engine.identity.User in project camunda-bpm-platform by camunda.
the class TaskRestServiceQueryTest method testSimpleHalTaskQuery.
@Test
public void testSimpleHalTaskQuery() {
String queryName = "name";
// setup user query mock
List<User> mockUsers = MockProvider.createMockUsers();
UserQuery sampleUserQuery = mock(UserQuery.class);
when(sampleUserQuery.listPage(0, 1)).thenReturn(mockUsers);
when(sampleUserQuery.userIdIn(MockProvider.EXAMPLE_TASK_ASSIGNEE_NAME)).thenReturn(sampleUserQuery);
when(sampleUserQuery.userIdIn(MockProvider.EXAMPLE_TASK_OWNER)).thenReturn(sampleUserQuery);
when(sampleUserQuery.count()).thenReturn(1l);
when(processEngine.getIdentityService().createUserQuery()).thenReturn(sampleUserQuery);
// setup process definition query mock
List<ProcessDefinition> mockDefinitions = MockProvider.createMockDefinitions();
ProcessDefinitionQuery sampleProcessDefinitionQuery = mock(ProcessDefinitionQuery.class);
when(sampleProcessDefinitionQuery.listPage(0, 1)).thenReturn(mockDefinitions);
when(sampleProcessDefinitionQuery.processDefinitionIdIn(MockProvider.EXAMPLE_PROCESS_DEFINITION_ID)).thenReturn(sampleProcessDefinitionQuery);
when(sampleProcessDefinitionQuery.count()).thenReturn(1l);
when(processEngine.getRepositoryService().createProcessDefinitionQuery()).thenReturn(sampleProcessDefinitionQuery);
// setup case definition query mock
List<CaseDefinition> mockCaseDefinitions = MockProvider.createMockCaseDefinitions();
CaseDefinitionQuery sampleCaseDefinitionQuery = mock(CaseDefinitionQuery.class);
when(sampleCaseDefinitionQuery.listPage(0, 1)).thenReturn(mockCaseDefinitions);
when(sampleCaseDefinitionQuery.caseDefinitionIdIn(MockProvider.EXAMPLE_CASE_DEFINITION_ID)).thenReturn(sampleCaseDefinitionQuery);
when(sampleCaseDefinitionQuery.count()).thenReturn(1l);
when(processEngine.getRepositoryService().createCaseDefinitionQuery()).thenReturn(sampleCaseDefinitionQuery);
// setup example process application context path
when(processEngine.getManagementService().getProcessApplicationForDeployment(MockProvider.EXAMPLE_DEPLOYMENT_ID)).thenReturn(MockProvider.EXAMPLE_PROCESS_APPLICATION_NAME);
// replace the runtime container delegate & process application service with a mock
ProcessApplicationService processApplicationService = mock(ProcessApplicationService.class);
ProcessApplicationInfo appMock = MockProvider.createMockProcessApplicationInfo();
when(processApplicationService.getProcessApplicationInfo(MockProvider.EXAMPLE_PROCESS_APPLICATION_NAME)).thenReturn(appMock);
RuntimeContainerDelegate delegate = mock(RuntimeContainerDelegate.class);
when(delegate.getProcessApplicationService()).thenReturn(processApplicationService);
RuntimeContainerDelegate.INSTANCE.set(delegate);
Response response = given().queryParam("name", queryName).header("accept", Hal.APPLICATION_HAL_JSON).then().expect().statusCode(Status.OK.getStatusCode()).contentType(Hal.APPLICATION_HAL_JSON).when().get(TASK_QUERY_URL);
InOrder inOrder = inOrder(mockQuery);
inOrder.verify(mockQuery).taskName(queryName);
inOrder.verify(mockQuery).list();
// validate embedded tasks
String content = response.asString();
List<Map<String, Object>> instances = from(content).getList("_embedded.task");
Assert.assertEquals("There should be one task returned.", 1, instances.size());
Assert.assertNotNull("The returned task should not be null.", instances.get(0));
Map<String, Object> taskObject = instances.get(0);
String returnedTaskName = (String) taskObject.get("name");
String returnedId = (String) taskObject.get("id");
String returnedAssignee = (String) taskObject.get("assignee");
String returnedCreateTime = (String) taskObject.get("created");
String returnedDueDate = (String) taskObject.get("due");
String returnedFollowUpDate = (String) taskObject.get("followUp");
String returnedDelegationState = (String) taskObject.get("delegationState");
String returnedDescription = (String) taskObject.get("description");
String returnedExecutionId = (String) taskObject.get("executionId");
String returnedOwner = (String) taskObject.get("owner");
String returnedParentTaskId = (String) taskObject.get("parentTaskId");
int returnedPriority = (Integer) taskObject.get("priority");
String returnedProcessDefinitionId = (String) taskObject.get("processDefinitionId");
String returnedProcessInstanceId = (String) taskObject.get("processInstanceId");
String returnedTaskDefinitionKey = (String) taskObject.get("taskDefinitionKey");
String returnedCaseDefinitionId = (String) taskObject.get("caseDefinitionId");
String returnedCaseInstanceId = (String) taskObject.get("caseInstanceId");
String returnedCaseExecutionId = (String) taskObject.get("caseExecutionId");
boolean returnedSuspensionState = (Boolean) taskObject.get("suspended");
String returnedFormKey = (String) taskObject.get("formKey");
String returnedTenantId = (String) taskObject.get("tenantId");
Assert.assertEquals(MockProvider.EXAMPLE_TASK_NAME, returnedTaskName);
Assert.assertEquals(MockProvider.EXAMPLE_TASK_ID, returnedId);
Assert.assertEquals(MockProvider.EXAMPLE_TASK_ASSIGNEE_NAME, returnedAssignee);
Assert.assertEquals(MockProvider.EXAMPLE_TASK_CREATE_TIME, returnedCreateTime);
Assert.assertEquals(MockProvider.EXAMPLE_TASK_DUE_DATE, returnedDueDate);
Assert.assertEquals(MockProvider.EXAMPLE_FOLLOW_UP_DATE, returnedFollowUpDate);
Assert.assertEquals(MockProvider.EXAMPLE_TASK_DELEGATION_STATE.toString(), returnedDelegationState);
Assert.assertEquals(MockProvider.EXAMPLE_TASK_DESCRIPTION, returnedDescription);
Assert.assertEquals(MockProvider.EXAMPLE_TASK_EXECUTION_ID, returnedExecutionId);
Assert.assertEquals(MockProvider.EXAMPLE_TASK_OWNER, returnedOwner);
Assert.assertEquals(MockProvider.EXAMPLE_TASK_PARENT_TASK_ID, returnedParentTaskId);
Assert.assertEquals(MockProvider.EXAMPLE_TASK_PRIORITY, returnedPriority);
Assert.assertEquals(MockProvider.EXAMPLE_PROCESS_DEFINITION_ID, returnedProcessDefinitionId);
Assert.assertEquals(MockProvider.EXAMPLE_PROCESS_INSTANCE_ID, returnedProcessInstanceId);
Assert.assertEquals(MockProvider.EXAMPLE_TASK_DEFINITION_KEY, returnedTaskDefinitionKey);
Assert.assertEquals(MockProvider.EXAMPLE_CASE_DEFINITION_ID, returnedCaseDefinitionId);
Assert.assertEquals(MockProvider.EXAMPLE_CASE_INSTANCE_ID, returnedCaseInstanceId);
Assert.assertEquals(MockProvider.EXAMPLE_CASE_EXECUTION_ID, returnedCaseExecutionId);
Assert.assertEquals(MockProvider.EXAMPLE_TASK_SUSPENSION_STATE, returnedSuspensionState);
Assert.assertEquals(MockProvider.EXAMPLE_TENANT_ID, returnedTenantId);
// validate the task count
Assert.assertEquals(1l, from(content).getLong("count"));
// validate links
Map<String, Object> selfReference = from(content).getMap("_links.self");
Assert.assertNotNull(selfReference);
Assert.assertEquals("/task", selfReference.get("href"));
// validate embedded assignees:
List<Map<String, Object>> embeddedAssignees = from(content).getList("_embedded.assignee");
Assert.assertEquals("There should be one assignee returned.", 1, embeddedAssignees.size());
Map<String, Object> embeddedAssignee = embeddedAssignees.get(0);
Assert.assertNotNull("The returned assignee should not be null.", embeddedAssignee);
Assert.assertEquals(MockProvider.EXAMPLE_USER_ID, embeddedAssignee.get("id"));
Assert.assertEquals(MockProvider.EXAMPLE_USER_FIRST_NAME, embeddedAssignee.get("firstName"));
Assert.assertEquals(MockProvider.EXAMPLE_USER_LAST_NAME, embeddedAssignee.get("lastName"));
Assert.assertEquals(MockProvider.EXAMPLE_USER_EMAIL, embeddedAssignee.get("email"));
// validate embedded owners:
List<Map<String, Object>> embeddedOwners = from(content).getList("_embedded.owner");
Assert.assertEquals("There should be one owner returned.", 1, embeddedOwners.size());
Map<String, Object> embeddedOwner = embeddedOwners.get(0);
Assert.assertNotNull("The returned owner should not be null.", embeddedOwner);
Assert.assertEquals(MockProvider.EXAMPLE_USER_ID, embeddedOwner.get("id"));
Assert.assertEquals(MockProvider.EXAMPLE_USER_FIRST_NAME, embeddedOwner.get("firstName"));
Assert.assertEquals(MockProvider.EXAMPLE_USER_LAST_NAME, embeddedOwner.get("lastName"));
Assert.assertEquals(MockProvider.EXAMPLE_USER_EMAIL, embeddedOwner.get("email"));
// validate embedded processDefinitions:
List<Map<String, Object>> embeddedDefinitions = from(content).getList("_embedded.processDefinition");
Assert.assertEquals("There should be one processDefinition returned.", 1, embeddedDefinitions.size());
Map<String, Object> embeddedProcessDefinition = embeddedDefinitions.get(0);
Assert.assertNotNull("The returned processDefinition should not be null.", embeddedProcessDefinition);
Assert.assertEquals(MockProvider.EXAMPLE_PROCESS_DEFINITION_ID, embeddedProcessDefinition.get("id"));
Assert.assertEquals(MockProvider.EXAMPLE_PROCESS_DEFINITION_KEY, embeddedProcessDefinition.get("key"));
Assert.assertEquals(MockProvider.EXAMPLE_PROCESS_DEFINITION_CATEGORY, embeddedProcessDefinition.get("category"));
Assert.assertEquals(MockProvider.EXAMPLE_PROCESS_DEFINITION_NAME, embeddedProcessDefinition.get("name"));
Assert.assertEquals(MockProvider.EXAMPLE_PROCESS_DEFINITION_DESCRIPTION, embeddedProcessDefinition.get("description"));
Assert.assertEquals(MockProvider.EXAMPLE_PROCESS_DEFINITION_VERSION, embeddedProcessDefinition.get("version"));
Assert.assertEquals(MockProvider.EXAMPLE_PROCESS_DEFINITION_RESOURCE_NAME, embeddedProcessDefinition.get("resource"));
Assert.assertEquals(MockProvider.EXAMPLE_DEPLOYMENT_ID, embeddedProcessDefinition.get("deploymentId"));
Assert.assertEquals(MockProvider.EXAMPLE_PROCESS_DEFINITION_DIAGRAM_RESOURCE_NAME, embeddedProcessDefinition.get("diagram"));
Assert.assertEquals(MockProvider.EXAMPLE_PROCESS_DEFINITION_IS_SUSPENDED, embeddedProcessDefinition.get("suspended"));
Assert.assertEquals(MockProvider.EXAMPLE_PROCESS_APPLICATION_CONTEXT_PATH, embeddedProcessDefinition.get("contextPath"));
// validate embedded caseDefinitions:
List<Map<String, Object>> embeddedCaseDefinitions = from(content).getList("_embedded.caseDefinition");
Assert.assertEquals("There should be one caseDefinition returned.", 1, embeddedCaseDefinitions.size());
Map<String, Object> embeddedCaseDefinition = embeddedCaseDefinitions.get(0);
Assert.assertNotNull("The returned caseDefinition should not be null.", embeddedCaseDefinition);
Assert.assertEquals(MockProvider.EXAMPLE_CASE_DEFINITION_ID, embeddedCaseDefinition.get("id"));
Assert.assertEquals(MockProvider.EXAMPLE_CASE_DEFINITION_KEY, embeddedCaseDefinition.get("key"));
Assert.assertEquals(MockProvider.EXAMPLE_CASE_DEFINITION_CATEGORY, embeddedCaseDefinition.get("category"));
Assert.assertEquals(MockProvider.EXAMPLE_CASE_DEFINITION_NAME, embeddedCaseDefinition.get("name"));
Assert.assertEquals(MockProvider.EXAMPLE_CASE_DEFINITION_VERSION, embeddedCaseDefinition.get("version"));
Assert.assertEquals(MockProvider.EXAMPLE_CASE_DEFINITION_RESOURCE_NAME, embeddedCaseDefinition.get("resource"));
Assert.assertEquals(MockProvider.EXAMPLE_DEPLOYMENT_ID, embeddedCaseDefinition.get("deploymentId"));
Assert.assertEquals(MockProvider.EXAMPLE_PROCESS_APPLICATION_CONTEXT_PATH, embeddedCaseDefinition.get("contextPath"));
}
Aggregations