/**
* Copyright 2010 JBoss Inc
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.drools.task.service;
import java.io.StringReader;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
import org.apache.commons.collections.map.HashedMap;
import org.drools.task.AccessType;
import org.drools.task.BaseTest;
import org.drools.task.Content;
import org.drools.task.Status;
import org.drools.task.Task;
import org.drools.task.service.responsehandlers.BlockingAddTaskResponseHandler;
import org.drools.task.service.responsehandlers.BlockingGetContentResponseHandler;
import org.drools.task.service.responsehandlers.BlockingGetTaskResponseHandler;
import org.drools.task.service.responsehandlers.BlockingTaskOperationResponseHandler;
public abstract class TaskServiceLifeCycleBaseTest extends BaseTest {
private static final int DEFAULT_WAIT_TIME = 5000;
protected TaskServer server;
protected TaskClient client;
public void testNewTaskWithNoPotentialOwners() {
Map vars = new HashedMap();
vars.put( "users", users );
vars.put( "groups", groups );
vars.put( "now", new Date() );
// One potential owner, should go straight to state Reserved
String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
str += "peopleAssignments = (with ( new PeopleAssignments() ) { }),";
str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
Task task = ( Task ) eval( new StringReader( str ), vars );
client.addTask( task, null, addTaskResponseHandler );
long taskId = addTaskResponseHandler.getTaskId();
// Task should remain in Created state with no actual owner
BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task1 = getTaskResponseHandler.getTask();
assertEquals( task1.getTaskData().getStatus(), Status.Created );
assertNull( task1.getTaskData().getActualOwner() );
}
public void testNewTaskWithSinglePotentialOwner() {
Map vars = new HashedMap();
vars.put( "users", users );
vars.put( "groups", groups );
vars.put( "now", new Date() );
// One potential owner, should go straight to state Reserved
String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ] ], }),";
str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
Task task = ( Task ) eval( new StringReader( str ), vars );
client.addTask( task, null, addTaskResponseHandler );
long taskId = addTaskResponseHandler.getTaskId();
// Task should be assigned to the single potential owner and state set to Reserved
BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task1 = getTaskResponseHandler.getTask();
assertEquals( Status.Reserved, task1.getTaskData().getStatus() );
assertEquals( users.get( "bobba" ), task1.getTaskData().getActualOwner() );
}
public void testNewTaskWithContent() {
Map vars = new HashedMap();
vars.put( "users", users );
vars.put( "groups", groups );
vars.put( "now", new Date() );
String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ] ], }),";
str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
ContentData data = new ContentData();
data.setAccessType(AccessType.Inline);
data.setType("type");
data.setContent("content".getBytes());
BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
Task task = ( Task ) eval( new StringReader( str ), vars );
client.addTask( task, data, addTaskResponseHandler );
long taskId = addTaskResponseHandler.getTaskId();
// Task should be assigned to the single potential owner and state set to Reserved
BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task1 = getTaskResponseHandler.getTask();
assertEquals( AccessType.Inline, task1.getTaskData().getDocumentAccessType() );
assertEquals( "type", task1.getTaskData().getDocumentType() );
long contentId = task1.getTaskData().getDocumentContentId();
assertTrue( contentId != -1 );
BlockingGetContentResponseHandler getContentResponseHandler = new BlockingGetContentResponseHandler();
client.getContent(contentId, getContentResponseHandler);
Content content = getContentResponseHandler.getContent();
assertEquals("content", new String(content.getContent()));
}
public void testNewTaskWithLargeContent() {
Map vars = new HashedMap();
vars.put( "users", users );
vars.put( "groups", groups );
vars.put( "now", new Date() );
String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ] ], }),";
str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
ContentData data = new ContentData();
data.setAccessType(AccessType.Inline);
data.setType("type");
String largeContent = "";
for (int i = 0; i < 1000; i++) {
largeContent += i + "xxxxxxxxx";
}
data.setContent(largeContent.getBytes());
BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
Task task = ( Task ) eval( new StringReader( str ), vars );
client.addTask( task, data, addTaskResponseHandler );
long taskId = addTaskResponseHandler.getTaskId();
// Task should be assigned to the single potential owner and state set to Reserved
BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task1 = getTaskResponseHandler.getTask();
assertEquals( AccessType.Inline, task1.getTaskData().getDocumentAccessType() );
assertEquals( "type", task1.getTaskData().getDocumentType() );
long contentId = task1.getTaskData().getDocumentContentId();
assertTrue( contentId != -1 );
BlockingGetContentResponseHandler getContentResponseHandler = new BlockingGetContentResponseHandler();
client.getContent(contentId, getContentResponseHandler);
Content content = getContentResponseHandler.getContent();
System.out.println(new String(content.getContent()));
assertEquals(largeContent, new String(content.getContent()));
}
public void testClaimWithMultiplePotentialOwners() throws Exception {
Map vars = new HashedMap();
vars.put( "users", users );
vars.put( "groups", groups );
vars.put( "now", new Date() );
// One potential owner, should go straight to state Reserved
String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";
str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
Task task = ( Task ) eval( new StringReader( str ), vars );
client.addTask( task, null, addTaskResponseHandler );
long taskId = addTaskResponseHandler.getTaskId();
// A Task with multiple potential owners moves to "Ready" state until someone claims it.
BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task1 = getTaskResponseHandler.getTask();
assertEquals( Status.Ready , task1.getTaskData().getStatus() );
BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
client.claim( taskId, users.get( "darth" ).getId(), responseHandler );
responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task2 = getTaskResponseHandler.getTask();
assertEquals( Status.Reserved, task2.getTaskData().getStatus() );
assertEquals( users.get( "darth" ), task2.getTaskData().getActualOwner() );
}
public void testClaimWithGroupAssignee() throws Exception {
Map vars = new HashedMap();
vars.put( "users", users );
vars.put( "groups", groups );
vars.put( "now", new Date() );
// One potential owner, should go straight to state Reserved
String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [groups['knightsTempler' ]], }),";
str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
Task task = ( Task ) eval( new StringReader( str ), vars );
client.addTask( task, null, addTaskResponseHandler );
long taskId = addTaskResponseHandler.getTaskId();
// A Task with multiple potential owners moves to "Ready" state until someone claims it.
BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task1 = getTaskResponseHandler.getTask();
assertEquals( Status.Ready , task1.getTaskData().getStatus() );
BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
List<String> groupIds = new ArrayList<String>();
groupIds.add("Dummy Group");
groupIds.add("Knights Templer");
client.claim( taskId, users.get( "darth" ).getId(), groupIds, responseHandler );
responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task2 = getTaskResponseHandler.getTask();
assertEquals( Status.Reserved, task2.getTaskData().getStatus() );
assertEquals( users.get( "darth" ), task2.getTaskData().getActualOwner() );
}
public void testStartFromReadyStateWithPotentialOwner() throws Exception {
Map vars = new HashedMap();
vars.put( "users", users );
vars.put( "groups", groups );
vars.put( "now", new Date() );
// One potential owner, should go straight to state Reserved
String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";
str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
Task task = ( Task ) eval( new StringReader( str ), vars );
client.addTask( task, null, addTaskResponseHandler );
long taskId = addTaskResponseHandler.getTaskId();
// A Task with multiple potential owners moves to "Ready" state until someone claims it.
BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task1 = getTaskResponseHandler.getTask();
assertEquals( Status.Ready , task1.getTaskData().getStatus() );
// Go straight from Ready to Inprogress
BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
client.start( taskId, users.get( "darth" ).getId(), responseHandler );
responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task2 = getTaskResponseHandler.getTask();
assertEquals( Status.InProgress, task2.getTaskData().getStatus() );
assertEquals( users.get( "darth" ), task2.getTaskData().getActualOwner() );
}
public void testStartFromReadyStateWithIncorrectPotentialOwner() {
Map vars = new HashedMap();
vars.put( "users", users );
vars.put( "groups", groups );
vars.put( "now", new Date() );
// One potential owner, should go straight to state Reserved
String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";
str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
Task task = ( Task ) eval( new StringReader( str ), vars );
client.addTask( task, null, addTaskResponseHandler );
long taskId = addTaskResponseHandler.getTaskId();
// A Task with multiple potential owners moves to "Ready" state until someone claims it.
BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task1 = getTaskResponseHandler.getTask();
assertEquals( Status.Ready , task1.getTaskData().getStatus() );
// State should not change as user isn't potential owner
BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
client.start( taskId, users.get( "tony" ).getId(), responseHandler );
PermissionDeniedException denied = null;
try {
responseHandler.waitTillDone( DEFAULT_WAIT_TIME );
} catch(PermissionDeniedException e) {
denied = e;
}
assertNotNull("Should get permissed denied exception", denied);
getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task2 = getTaskResponseHandler.getTask();
assertEquals( Status.Ready, task2.getTaskData().getStatus() );
assertNull( task2.getTaskData().getActualOwner() );
}
public void testStartFromReserved() throws Exception {
Map vars = new HashedMap();
vars.put( "users", users );
vars.put( "groups", groups );
vars.put( "now", new Date() );
// One potential owner, should go straight to state Reserved
String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ] ], }),";
str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
Task task = ( Task ) eval( new StringReader( str ), vars );
client.addTask( task, null, addTaskResponseHandler );
long taskId = addTaskResponseHandler.getTaskId();
// Task should be assigned to the single potential owner and state set to Reserved
BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task1 = getTaskResponseHandler.getTask();
assertEquals( Status.Reserved, task1.getTaskData().getStatus());
assertEquals( users.get( "bobba" ), task1.getTaskData().getActualOwner() );
// Should change to InProgress
BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
client.start( taskId, users.get( "bobba" ).getId(), responseHandler );
responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task2 = getTaskResponseHandler.getTask();
assertEquals( Status.InProgress, task2.getTaskData().getStatus() );
assertEquals( users.get( "bobba" ), task1.getTaskData().getActualOwner() );
}
public void testStartFromReservedWithIncorrectUser() {
Map vars = new HashedMap();
vars.put( "users", users );
vars.put( "groups", groups );
vars.put( "now", new Date() );
// One potential owner, should go straight to state Reserved
String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ] ], }),";
str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
Task task = ( Task ) eval( new StringReader( str ), vars );
client.addTask( task, null, addTaskResponseHandler );
long taskId = addTaskResponseHandler.getTaskId();
// Task should be assigned to the single potential owner and state set to Reserved
BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task1 = getTaskResponseHandler.getTask();
assertEquals( Status.Reserved , task1.getTaskData().getStatus());
assertEquals( users.get( "bobba" ), task1.getTaskData().getActualOwner() );
// Should change not change
BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
client.start( taskId, users.get( "tony" ).getId(), responseHandler );
PermissionDeniedException denied = null;
try{
responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
} catch (PermissionDeniedException e) {
denied = e;
}
assertNotNull("Should get permissed denied exception", denied);
getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task2 = getTaskResponseHandler.getTask();
assertEquals( Status.Reserved, task2.getTaskData().getStatus() );
assertEquals( users.get( "bobba" ), task1.getTaskData().getActualOwner() );
}
public void testStop() {
Map vars = new HashedMap();
vars.put( "users", users );
vars.put( "groups", groups );
vars.put( "now", new Date() );
// One potential owner, should go straight to state Reserved
String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";
str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
Task task = ( Task ) eval( new StringReader( str ), vars );
client.addTask( task, null, addTaskResponseHandler );
long taskId = addTaskResponseHandler.getTaskId();
// Go straight from Ready to Inprogress
BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
client.start( taskId, users.get( "darth" ).getId(), responseHandler );
BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task1 = getTaskResponseHandler.getTask();
assertEquals( Status.InProgress, task1.getTaskData().getStatus() );
assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );
// Now Stop
responseHandler = new BlockingTaskOperationResponseHandler();
client.stop( taskId, users.get( "darth" ).getId(), responseHandler );
responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task2 = getTaskResponseHandler.getTask();
assertEquals( Status.Reserved, task2.getTaskData().getStatus() );
assertEquals( users.get( "darth" ), task2.getTaskData().getActualOwner() );
}
public void testStopWithIncorrectUser() {
Map vars = new HashedMap();
vars.put( "users", users );
vars.put( "groups", groups );
vars.put( "now", new Date() );
// One potential owner, should go straight to state Reserved
String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";
str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
Task task = ( Task ) eval( new StringReader( str ), vars );
client.addTask( task, null, addTaskResponseHandler );
long taskId = addTaskResponseHandler.getTaskId();
// Go straight from Ready to Inprogress
BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
client.start( taskId, users.get( "darth" ).getId(), responseHandler );
responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task1 = getTaskResponseHandler.getTask();
assertEquals( Status.InProgress, task1.getTaskData().getStatus() );
assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );
// Should not stop
responseHandler = new BlockingTaskOperationResponseHandler();
client.stop( taskId, users.get( "bobba" ).getId(), responseHandler );
PermissionDeniedException denied = null;
try{
responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
} catch(PermissionDeniedException e) {
denied = e;
}
assertNotNull("Should get permissed denied exception", denied);
getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task2 = getTaskResponseHandler.getTask();
assertEquals( Status.InProgress, task2.getTaskData().getStatus() );
assertEquals( users.get( "darth" ), task2.getTaskData().getActualOwner() );
}
public void testReleaseFromInprogress() throws Exception {
Map vars = new HashedMap();
vars.put( "users", users );
vars.put( "groups", groups );
vars.put( "now", new Date() );
// One potential owner, should go straight to state Reserved
String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";
str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
Task task = ( Task ) eval( new StringReader( str ), vars );
client.addTask( task, null, addTaskResponseHandler );
long taskId = addTaskResponseHandler.getTaskId();
// Go straight from Ready to Inprogress
BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
client.start( taskId, users.get( "darth" ).getId(), responseHandler );
responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task1 = getTaskResponseHandler.getTask();
assertEquals( Status.InProgress, task1.getTaskData().getStatus() );
assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );
// Check is Released
responseHandler = new BlockingTaskOperationResponseHandler();
client.release( taskId, users.get( "darth" ).getId(), responseHandler );
responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task2 = getTaskResponseHandler.getTask();
assertEquals( Status.Ready, task2.getTaskData().getStatus() );
assertNull( task2.getTaskData().getActualOwner() );
}
public void testReleaseFromReserved() {
Map vars = new HashedMap();
vars.put( "users", users );
vars.put( "groups", groups );
vars.put( "now", new Date() );
// One potential owner, should go straight to state Reserved
String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";
str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
Task task = ( Task ) eval( new StringReader( str ), vars );
client.addTask( task, null, addTaskResponseHandler );
long taskId = addTaskResponseHandler.getTaskId();
// Go straight from Ready to Inprogress
BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
client.claim( taskId, users.get( "darth" ).getId(), responseHandler );
responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task1 = getTaskResponseHandler.getTask();
assertEquals( Status.Reserved, task1.getTaskData().getStatus() );
assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );
// Check is Released
responseHandler = new BlockingTaskOperationResponseHandler();
client.release( taskId, users.get( "darth" ).getId(), responseHandler );
responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task2 = getTaskResponseHandler.getTask();
assertEquals( Status.Ready, task2.getTaskData().getStatus() );
assertNull( task2.getTaskData().getActualOwner() );
}
public void testReleaseWithIncorrectUser() {
Map vars = new HashedMap();
vars.put( "users", users );
vars.put( "groups", groups );
vars.put( "now", new Date() );
// One potential owner, should go straight to state Reserved
String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";
str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
Task task = ( Task ) eval( new StringReader( str ), vars );
client.addTask( task, null, addTaskResponseHandler );
long taskId = addTaskResponseHandler.getTaskId();
// Go straight from Ready to Inprogress
BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
client.claim( taskId, users.get( "darth" ).getId(), responseHandler );
responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task1 = getTaskResponseHandler.getTask();
assertEquals( Status.Reserved, task1.getTaskData().getStatus() );
assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );
// Check is not changed
responseHandler = new BlockingTaskOperationResponseHandler();
client.release( taskId, users.get( "bobba" ).getId(), responseHandler );
PermissionDeniedException denied = null;
try{
responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
} catch(PermissionDeniedException e) {
denied = e;
}
assertNotNull("Should get permissed denied exception", denied);
getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task2 = getTaskResponseHandler.getTask();
assertEquals( Status.Reserved, task1.getTaskData().getStatus() );
assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );
}
public void testSuspendFromReady() {
Map vars = new HashedMap();
vars.put( "users", users );
vars.put( "groups", groups );
vars.put( "now", new Date() );
// One potential owner, should go straight to state Reserved
String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";
str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
Task task = ( Task ) eval( new StringReader( str ), vars );
client.addTask( task, null, addTaskResponseHandler );
long taskId = addTaskResponseHandler.getTaskId();
// Check is Ready
BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task1 = getTaskResponseHandler.getTask();
assertEquals( Status.Ready, task1.getTaskData().getStatus() );
assertNull( task1.getTaskData().getActualOwner() );
// Check is Suspended
BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
client.suspend( taskId, users.get( "darth" ).getId(), responseHandler );
responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task2 = getTaskResponseHandler.getTask();
assertEquals( Status.Suspended, task2.getTaskData().getStatus() );
assertEquals( Status.Ready, task2.getTaskData().getPreviousStatus() );
assertNull( task1.getTaskData().getActualOwner() );
}
public void testSuspendFromReserved() {
Map vars = new HashedMap();
vars.put( "users", users );
vars.put( "groups", groups );
vars.put( "now", new Date() );
// One potential owner, should go straight to state Reserved
String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";
str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
Task task = ( Task ) eval( new StringReader( str ), vars );
client.addTask( task, null, addTaskResponseHandler );
long taskId = addTaskResponseHandler.getTaskId();
// Check is Reserved
BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
client.claim( taskId, users.get( "darth" ).getId(), responseHandler );
responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task1 = getTaskResponseHandler.getTask();
assertEquals( Status.Reserved, task1.getTaskData().getStatus() );
assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );
// Check is Suspended
responseHandler = new BlockingTaskOperationResponseHandler();
client.suspend( taskId, users.get( "darth" ).getId(), responseHandler );
responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task2 = getTaskResponseHandler.getTask();
assertEquals( Status.Reserved, task2.getTaskData().getPreviousStatus() );
assertEquals( Status.Suspended, task2.getTaskData().getStatus() );
assertEquals( users.get( "darth" ), task2.getTaskData().getActualOwner() );
}
public void testSuspendFromReservedWithIncorrectUser() {
Map vars = new HashedMap();
vars.put( "users", users );
vars.put( "groups", groups );
vars.put( "now", new Date() );
// One potential owner, should go straight to state Reserved
String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";
str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
Task task = ( Task ) eval( new StringReader( str ), vars );
client.addTask( task, null, addTaskResponseHandler );
long taskId = addTaskResponseHandler.getTaskId();
// Check is Reserved
BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
client.claim( taskId, users.get( "darth" ).getId(), responseHandler );
responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task1 = getTaskResponseHandler.getTask();
assertEquals( Status.Reserved, task1.getTaskData().getStatus() );
assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );
// Check is not changed
responseHandler = new BlockingTaskOperationResponseHandler();
client.suspend( taskId, users.get( "bobba" ).getId(), responseHandler );
PermissionDeniedException denied = null;
try{
responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
} catch(PermissionDeniedException e) {
denied = e;
}
assertNotNull("Should get permissed denied exception", denied);
getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task2 = getTaskResponseHandler.getTask();
assertEquals( Status.Reserved, task1.getTaskData().getStatus() );
assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );
}
public void testResumeFromReady() {
Map vars = new HashedMap();
vars.put( "users", users );
vars.put( "groups", groups );
vars.put( "now", new Date() );
// One potential owner, should go straight to state Reserved
String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";
str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
Task task = ( Task ) eval( new StringReader( str ), vars );
client.addTask( task, null, addTaskResponseHandler );
long taskId = addTaskResponseHandler.getTaskId();
// Check is Ready
BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task1 = getTaskResponseHandler.getTask();
assertEquals( Status.Ready, task1.getTaskData().getStatus() );
assertNull( task1.getTaskData().getActualOwner() );
// Check is Suspended
BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
client.suspend( taskId, users.get( "darth" ).getId(), responseHandler );
responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task2 = getTaskResponseHandler.getTask();
assertEquals( Status.Suspended, task2.getTaskData().getStatus() );
assertEquals( Status.Ready, task2.getTaskData().getPreviousStatus() );
assertNull( task1.getTaskData().getActualOwner() );
// Check is Resumed
responseHandler = new BlockingTaskOperationResponseHandler();
client.resume( taskId, users.get( "darth" ).getId(), responseHandler );
responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task3 = getTaskResponseHandler.getTask();
assertEquals( Status.Ready, task3.getTaskData().getStatus() );
assertEquals( Status.Suspended, task3.getTaskData().getPreviousStatus() );
assertNull( task3.getTaskData().getActualOwner() );
}
public void testResumeFromReserved() {
Map vars = new HashedMap();
vars.put( "users", users );
vars.put( "groups", groups );
vars.put( "now", new Date() );
// One potential owner, should go straight to state Reserved
String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";
str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
Task task = ( Task ) eval( new StringReader( str ), vars );
client.addTask( task, null, addTaskResponseHandler );
long taskId = addTaskResponseHandler.getTaskId();
// Check is Reserved
BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
client.claim( taskId, users.get( "darth" ).getId(), responseHandler );
responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task1 = getTaskResponseHandler.getTask();
assertEquals( Status.Reserved, task1.getTaskData().getStatus() );
assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );
// Check is suspended
responseHandler = new BlockingTaskOperationResponseHandler();
client.suspend( taskId, users.get( "darth" ).getId(), responseHandler );
responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task2 = getTaskResponseHandler.getTask();
assertEquals( Status.Reserved, task2.getTaskData().getPreviousStatus() );
assertEquals( Status.Suspended, task2.getTaskData().getStatus() );
assertEquals( users.get( "darth" ), task2.getTaskData().getActualOwner() );
// Check is Resumed
responseHandler = new BlockingTaskOperationResponseHandler();
client.resume( taskId, users.get( "darth" ).getId(), responseHandler );
responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task3 = getTaskResponseHandler.getTask();
assertEquals( Status.Reserved, task3.getTaskData().getStatus() );
assertEquals( Status.Suspended, task3.getTaskData().getPreviousStatus() );
assertEquals( users.get( "darth" ), task3.getTaskData().getActualOwner() );
}
public void testResumeFromReservedWithIncorrectUser() {
Map vars = new HashedMap();
vars.put( "users", users );
vars.put( "groups", groups );
vars.put( "now", new Date() );
// One potential owner, should go straight to state Reserved
String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";
str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
Task task = ( Task ) eval( new StringReader( str ), vars );
client.addTask( task, null, addTaskResponseHandler );
long taskId = addTaskResponseHandler.getTaskId();
// Check is Reserved
BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
client.claim( taskId, users.get( "darth" ).getId(), responseHandler );
responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task1 = getTaskResponseHandler.getTask();
assertEquals( Status.Reserved, task1.getTaskData().getStatus() );
assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );
// Check not changed
responseHandler = new BlockingTaskOperationResponseHandler();
client.suspend( taskId, users.get( "bobba" ).getId(), responseHandler );
PermissionDeniedException denied = null;
try{
responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
} catch(PermissionDeniedException e) {
denied = e;
}
assertNotNull("Should get permissed denied exception", denied);
getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task2 = getTaskResponseHandler.getTask();
assertEquals( Status.Reserved, task1.getTaskData().getStatus() );
assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );
}
public void testSkipFromReady() {
Map vars = new HashedMap();
vars.put( "users", users );
vars.put( "groups", groups );
vars.put( "now", new Date() );
String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { skipable = true} ), ";
str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ] }),";
str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
Task task = ( Task ) eval( new StringReader( str ), vars );
client.addTask( task, null, addTaskResponseHandler );
long taskId = addTaskResponseHandler.getTaskId();
// Check is Complete
BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
client.skip( taskId, users.get( "darth" ).getId(), responseHandler );
responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task1 = getTaskResponseHandler.getTask();
assertEquals( Status.Obsolete, task1.getTaskData().getStatus() );
assertNull( task1.getTaskData().getActualOwner() );
}
public void testSkipFromReserved() {
Map vars = new HashedMap();
vars.put( "users", users );
vars.put( "groups", groups );
vars.put( "now", new Date() );
String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { skipable = true} ), ";
str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ] }),";
str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
Task task = ( Task ) eval( new StringReader( str ), vars );
client.addTask( task, null, addTaskResponseHandler );
long taskId = addTaskResponseHandler.getTaskId();
// Go straight from Ready
BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
client.claim( taskId, users.get( "darth" ).getId(), responseHandler );
responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
// Check is Complete
responseHandler = new BlockingTaskOperationResponseHandler();
client.skip( taskId, users.get( "darth" ).getId(), responseHandler );
responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task1 = getTaskResponseHandler.getTask();
assertEquals( Status.Obsolete, task1.getTaskData().getStatus() );
assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );
}
public void testDelegateFromReady() throws Exception {
Map vars = new HashedMap();
vars.put( "users", users );
vars.put( "groups", groups );
vars.put( "now", new Date() );
// One potential owner, should go straight to state Reserved
String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";
str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
Task task = ( Task ) eval( new StringReader( str ), vars );
client.addTask( task, null, addTaskResponseHandler );
long taskId = addTaskResponseHandler.getTaskId();
// Check is Delegated
BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
client.delegate( taskId, users.get( "darth" ).getId(), users.get( "tony" ).getId(), responseHandler );
responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task2 = getTaskResponseHandler.getTask();
assertTrue( task2.getPeopleAssignments().getPotentialOwners().contains( users.get( "darth" ) ) );
assertTrue( task2.getPeopleAssignments().getPotentialOwners().contains( users.get( "tony" ) ) );
assertEquals( users.get( "tony" ), task2.getTaskData().getActualOwner() );
assertEquals( Status.Ready, task2.getTaskData().getStatus() );
}
public void testDelegateFromReserved() throws Exception {
Map vars = new HashedMap();
vars.put( "users", users );
vars.put( "groups", groups );
vars.put( "now", new Date() );
// One potential owner, should go straight to state Reserved
String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";
str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
Task task = ( Task ) eval( new StringReader( str ), vars );
client.addTask( task, null, addTaskResponseHandler );
long taskId = addTaskResponseHandler.getTaskId();
// Claim and Reserved
BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
client.claim( taskId, users.get( "darth" ).getId(), responseHandler );
responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task1 = getTaskResponseHandler.getTask();
assertEquals( Status.Reserved, task1.getTaskData().getStatus() );
assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );
// Check is Delegated
responseHandler = new BlockingTaskOperationResponseHandler();
client.delegate( taskId, users.get( "darth" ).getId(), users.get( "tony" ).getId(), responseHandler );
responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task2 = getTaskResponseHandler.getTask();
assertTrue( task2.getPeopleAssignments().getPotentialOwners().contains( users.get( "darth" ) ) );
assertTrue( task2.getPeopleAssignments().getPotentialOwners().contains( users.get( "tony" ) ) );
assertEquals( users.get( "tony" ), task2.getTaskData().getActualOwner() );
assertEquals( Status.Ready, task2.getTaskData().getStatus() );
}
public void testDelegateFromReservedWithIncorrectUser() throws Exception {
Map vars = new HashedMap();
vars.put( "users", users );
vars.put( "groups", groups );
vars.put( "now", new Date() );
// One potential owner, should go straight to state Reserved
String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";
str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
Task task = ( Task ) eval( new StringReader( str ), vars );
client.addTask( task, null, addTaskResponseHandler );
long taskId = addTaskResponseHandler.getTaskId();
// Claim and Reserved
BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
client.claim( taskId, users.get( "darth" ).getId(), responseHandler );
responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task1 = getTaskResponseHandler.getTask();
assertEquals( Status.Reserved, task1.getTaskData().getStatus() );
assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );
// Check was not delegated
responseHandler = new BlockingTaskOperationResponseHandler();
client.delegate( taskId, users.get( "bobba" ).getId(), users.get( "tony" ).getId(), responseHandler );
PermissionDeniedException denied = null;
try{
responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
} catch(PermissionDeniedException e) {
denied = e;
}
assertNotNull("Should get permissed denied exception", denied);
getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task2 = getTaskResponseHandler.getTask();
assertTrue( task2.getPeopleAssignments().getPotentialOwners().contains( users.get( "darth" ) ) );
assertFalse( task2.getPeopleAssignments().getPotentialOwners().contains( users.get( "tony" ) ) );
assertEquals( users.get( "darth" ), task2.getTaskData().getActualOwner() );
assertEquals( Status.Reserved, task2.getTaskData().getStatus() );
}
public void testForwardFromReady() throws Exception {
Map vars = new HashedMap();
vars.put( "users", users );
vars.put( "groups", groups );
vars.put( "now", new Date() );
// One potential owner, should go straight to state Reserved
String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";
str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
Task task = ( Task ) eval( new StringReader( str ), vars );
client.addTask( task, null, addTaskResponseHandler );
long taskId = addTaskResponseHandler.getTaskId();
// Check is Forwarded
BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
client.forward( taskId, users.get( "darth" ).getId(), users.get( "tony" ).getId(), responseHandler );
responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task2 = getTaskResponseHandler.getTask();
assertFalse( task2.getPeopleAssignments().getPotentialOwners().contains( users.get( "darth" ) ) );
assertTrue( task2.getPeopleAssignments().getPotentialOwners().contains( users.get( "tony" ) ) );
assertNull( task2.getTaskData().getActualOwner() );
assertEquals( Status.Ready, task2.getTaskData().getStatus() );
}
public void testForwardFromReserved() throws Exception {
Map vars = new HashedMap();
vars.put( "users", users );
vars.put( "groups", groups );
vars.put( "now", new Date() );
// One potential owner, should go straight to state Reserved
String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";
str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
Task task = ( Task ) eval( new StringReader( str ), vars );
client.addTask( task, null, addTaskResponseHandler );
long taskId = addTaskResponseHandler.getTaskId();
// Claim and Reserved
BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
client.claim( taskId, users.get( "darth" ).getId(), responseHandler );
responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task1 = getTaskResponseHandler.getTask();
assertEquals( Status.Reserved, task1.getTaskData().getStatus() );
assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );
// Check is Delegated
responseHandler = new BlockingTaskOperationResponseHandler();
client.forward( taskId, users.get( "darth" ).getId(), users.get( "tony" ).getId(), responseHandler );
responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task2 = getTaskResponseHandler.getTask();
assertFalse( task2.getPeopleAssignments().getPotentialOwners().contains( users.get( "darth" ) ) );
assertTrue( task2.getPeopleAssignments().getPotentialOwners().contains( users.get( "tony" ) ) );
assertNull( task2.getTaskData().getActualOwner() );
assertEquals( Status.Ready, task2.getTaskData().getStatus() );
}
public void testForwardFromReservedWithIncorrectUser() throws Exception {
Map vars = new HashedMap();
vars.put( "users", users );
vars.put( "groups", groups );
vars.put( "now", new Date() );
// One potential owner, should go straight to state Reserved
String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";
str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
Task task = ( Task ) eval( new StringReader( str ), vars );
client.addTask( task, null, addTaskResponseHandler );
long taskId = addTaskResponseHandler.getTaskId();
// Claim and Reserved
BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
client.claim( taskId, users.get( "darth" ).getId(), responseHandler );
responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task1 = getTaskResponseHandler.getTask();
assertEquals( Status.Reserved, task1.getTaskData().getStatus() );
assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );
// Check was not delegated
responseHandler = new BlockingTaskOperationResponseHandler();
client.forward( taskId, users.get( "bobba" ).getId(), users.get( "tony" ).getId(), responseHandler );
PermissionDeniedException denied = null;
try{
responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
} catch(PermissionDeniedException e) {
denied = e;
}
assertNotNull("Should get permissed denied exception", denied);
getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task2 = getTaskResponseHandler.getTask();
assertTrue( task2.getPeopleAssignments().getPotentialOwners().contains( users.get( "darth" ) ) );
assertFalse( task2.getPeopleAssignments().getPotentialOwners().contains( users.get( "tony" ) ) );
assertEquals( users.get( "darth" ), task2.getTaskData().getActualOwner() );
assertEquals( Status.Reserved, task2.getTaskData().getStatus() );
}
public void testComplete() {
Map vars = new HashedMap();
vars.put( "users", users );
vars.put( "groups", groups );
vars.put( "now", new Date() );
// One potential owner, should go straight to state Reserved
String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";
str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
Task task = ( Task ) eval( new StringReader( str ), vars );
client.addTask( task, null, addTaskResponseHandler );
long taskId = addTaskResponseHandler.getTaskId();
// Go straight from Ready to Inprogress
BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
client.start( taskId, users.get( "darth" ).getId(), responseHandler );
responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task1 = getTaskResponseHandler.getTask();
assertEquals( Status.InProgress, task1.getTaskData().getStatus() );
assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );
// Check is Complete
responseHandler = new BlockingTaskOperationResponseHandler();
client.complete( taskId, users.get( "darth" ).getId(), null, responseHandler );
responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task2 = getTaskResponseHandler.getTask();
assertEquals( Status.Completed, task2.getTaskData().getStatus() );
assertEquals( users.get( "darth" ), task2.getTaskData().getActualOwner() );
}
public void testCompleteWithIncorrectUser() {
Map vars = new HashedMap();
vars.put( "users", users );
vars.put( "groups", groups );
vars.put( "now", new Date() );
// One potential owner, should go straight to state Reserved
String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";
str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
Task task = ( Task ) eval( new StringReader( str ), vars );
client.addTask( task, null, addTaskResponseHandler );
long taskId = addTaskResponseHandler.getTaskId();
// Go straight from Ready to Inprogress
BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
client.start( taskId, users.get( "darth" ).getId(), responseHandler );
responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task1 = getTaskResponseHandler.getTask();
assertEquals( Status.InProgress, task1.getTaskData().getStatus() );
assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );
// Should not complete as wrong user
responseHandler = new BlockingTaskOperationResponseHandler();
client.complete( taskId, users.get( "bobba" ).getId(), null, responseHandler );
PermissionDeniedException denied = null;
try{
responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
} catch(PermissionDeniedException e) {
denied = e;
}
assertNotNull("Should get permissed denied exception", denied);
getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task2 = getTaskResponseHandler.getTask();
assertEquals( Status.InProgress, task2.getTaskData().getStatus() );
assertEquals( users.get( "darth" ), task2.getTaskData().getActualOwner() );
}
public void testCompleteWithContent() {
Map vars = new HashedMap();
vars.put( "users", users );
vars.put( "groups", groups );
vars.put( "now", new Date() );
// One potential owner, should go straight to state Reserved
String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";
str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
Task task = ( Task ) eval( new StringReader( str ), vars );
client.addTask( task, null, addTaskResponseHandler );
long taskId = addTaskResponseHandler.getTaskId();
// Go straight from Ready to Inprogress
BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
client.start( taskId, users.get( "darth" ).getId(), responseHandler );
responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task1 = getTaskResponseHandler.getTask();
assertEquals( Status.InProgress, task1.getTaskData().getStatus() );
assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );
ContentData data = new ContentData();
data.setAccessType(AccessType.Inline);
data.setType("type");
data.setContent("content".getBytes());
responseHandler = new BlockingTaskOperationResponseHandler();
client.complete( taskId, users.get( "darth" ).getId(), data, responseHandler );
responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task2 = getTaskResponseHandler.getTask();
assertEquals( AccessType.Inline, task2.getTaskData().getOutputAccessType() );
assertEquals( "type", task2.getTaskData().getOutputType() );
long contentId = task2.getTaskData().getOutputContentId();
assertTrue( contentId != -1 );
BlockingGetContentResponseHandler getContentResponseHandler = new BlockingGetContentResponseHandler();
client.getContent(contentId, getContentResponseHandler);
Content content = getContentResponseHandler.getContent();
assertEquals("content", new String(content.getContent()));
}
public void testFail() {
Map vars = new HashedMap();
vars.put( "users", users );
vars.put( "groups", groups );
vars.put( "now", new Date() );
// One potential owner, should go straight to state Reserved
String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";
str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
Task task = ( Task ) eval( new StringReader( str ), vars );
client.addTask( task, null, addTaskResponseHandler );
long taskId = addTaskResponseHandler.getTaskId();
// Go straight from Ready to Inprogress
BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
client.start( taskId, users.get( "darth" ).getId(), responseHandler );
responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task1 = getTaskResponseHandler.getTask();
assertEquals( Status.InProgress, task1.getTaskData().getStatus() );
assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );
// Check is Failed
responseHandler = new BlockingTaskOperationResponseHandler();
client.fail( taskId, users.get( "darth" ).getId(), null, responseHandler );
responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task2 = getTaskResponseHandler.getTask();
assertEquals( Status.Failed, task2.getTaskData().getStatus() );
assertEquals( users.get( "darth" ), task2.getTaskData().getActualOwner() );
}
public void testFailWithIncorrectUser() {
Map vars = new HashedMap();
vars.put( "users", users );
vars.put( "groups", groups );
vars.put( "now", new Date() );
// One potential owner, should go straight to state Reserved
String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";
str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
Task task = ( Task ) eval( new StringReader( str ), vars );
client.addTask( task, null, addTaskResponseHandler );
long taskId = addTaskResponseHandler.getTaskId();
// Go straight from Ready to Inprogress
BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
client.start( taskId, users.get( "darth" ).getId(), responseHandler );
responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task1 = getTaskResponseHandler.getTask();
assertEquals( Status.InProgress, task1.getTaskData().getStatus() );
assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );
// Should not fail as wrong user
responseHandler = new BlockingTaskOperationResponseHandler();
client.fail( taskId, users.get( "bobba" ).getId(), null, responseHandler );
PermissionDeniedException denied = null;
try{
responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
} catch(PermissionDeniedException e) {
denied = e;
}
assertNotNull("Should get permissed denied exception", denied);
getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task2 = getTaskResponseHandler.getTask();
assertEquals( Status.InProgress, task2.getTaskData().getStatus() );
assertEquals( users.get( "darth" ), task2.getTaskData().getActualOwner() );
}
public void testFailWithContent() {
Map vars = new HashedMap();
vars.put( "users", users );
vars.put( "groups", groups );
vars.put( "now", new Date() );
// One potential owner, should go straight to state Reserved
String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";
str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
Task task = ( Task ) eval( new StringReader( str ), vars );
client.addTask( task, null, addTaskResponseHandler );
long taskId = addTaskResponseHandler.getTaskId();
// Go straight from Ready to Inprogress
BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
client.start( taskId, users.get( "darth" ).getId(), responseHandler );
responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task1 = getTaskResponseHandler.getTask();
assertEquals( Status.InProgress, task1.getTaskData().getStatus() );
assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );
FaultData data = new FaultData();
data.setAccessType(AccessType.Inline);
data.setType("type");
data.setFaultName("faultName");
data.setContent("content".getBytes());
responseHandler = new BlockingTaskOperationResponseHandler();
client.fail( taskId, users.get( "darth" ).getId(), data, responseHandler );
responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask( taskId, getTaskResponseHandler );
Task task2 = getTaskResponseHandler.getTask();
assertEquals( Status.Failed, task2.getTaskData().getStatus() );
assertEquals( AccessType.Inline, task2.getTaskData().getFaultAccessType() );
assertEquals( "type", task2.getTaskData().getFaultType() );
assertEquals( "faultName", task2.getTaskData().getFaultName() );
long contentId = task2.getTaskData().getFaultContentId();
assertTrue( contentId != -1 );
BlockingGetContentResponseHandler getContentResponseHandler = new BlockingGetContentResponseHandler();
client.getContent(contentId, getContentResponseHandler);
Content content = getContentResponseHandler.getContent();
assertEquals("content", new String(content.getContent()));
}
}