/*
* Copyright 2004 The Apache Software Foundation.
*
* 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.apache.agila;
import junit.framework.TestCase;
import org.apache.agila.engine.Engine;
import org.apache.agila.engine.EngineMessage;
import org.apache.agila.engine.Instance;
import org.apache.agila.engine.InstanceID;
import org.apache.agila.engine.MessageProcessor;
import org.apache.agila.engine.Token;
import org.apache.agila.impl.EngineMessageImpl;
import org.apache.agila.impl.QueueServiceImpl;
import org.apache.agila.impl.StdoutLogService;
import org.apache.agila.impl.memory.UserServiceImpl;
import org.apache.agila.impl.memory.TokenServiceImpl;
import org.apache.agila.impl.memory.InstanceServiceImpl;
import org.apache.agila.impl.memory.BusinessProcessServiceImpl;
import org.apache.agila.impl.memory.TaskServiceImpl;
import org.apache.agila.impl.memory.TimerServiceImpl;
import org.apache.agila.impl.memory.NotificationServiceImpl;
import org.apache.agila.model.BusinessProcessID;
import org.apache.agila.services.BusinessProcessInfo;
import org.apache.agila.services.task.HTTPResponseHandler;
import org.apache.agila.services.task.ResponseHandler;
import org.apache.agila.services.task.ResponseHandlerResponse;
import org.apache.agila.services.task.Task;
import org.apache.agila.services.log.LogService;
import org.apache.agila.services.user.UserID;
import org.apache.agila.services.user.UserInfo;
import org.apache.agila.servletimpl.HttpServletRequestImpl;
import org.apache.agila.servletimpl.HttpServletResponseImpl;
import java.io.InputStreamReader;
import java.io.Reader;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* This class runs the leave application workflow and checks for validity
* every step of the way.
*/
public class LeaveApplicationTestCase extends TestCase {
private TokenServiceImpl tokenService;
private InstanceServiceImpl instanceService;
private BusinessProcessServiceImpl businessProcessService;
private TaskServiceImpl taskService;
private TimerServiceImpl timerService;
private MessageProcessor messageProcessor;
private QueueServiceImpl queueService;
private Engine engine;
private NotificationServiceImpl notifyService;
private UserServiceImpl userService;
private LogService logger;
public void testCreateInstance() {
InstanceID instanceID = createInstance();
// Check that the required parameters are saved
Instance instance = instanceService.getInstanceByID( instanceID );
assertNotNull( instance );
Map instanceVariables = instance.getInstanceVariables();
assertNotNull( instanceVariables );
assertTrue( instanceVariables.size() == 1 );
// TODO change variable to integer
String numdays = (String)instanceVariables.get( "numdays" );
assertEquals( "10", numdays );
}
public void testTokenCreatedForRootNode() {
InstanceID instanceID = createInstance();
// Allow the queue service to breath
try {
Thread.sleep( 1000 );
} catch( InterruptedException e ) {
fail( e.getMessage() );
}
List tokens = tokenService.getActiveTokensForInstance( instanceID );
assertNotNull( tokens );
assertEquals( 1, tokens.size() );
}
public void testTaskAssigned_OnInstantiation() {
InstanceID instanceID = createInstance();
// Allow the queue service to breath
try {
Thread.sleep( 1000 );
} catch( InterruptedException e ) {
fail( e.getMessage() );
}
List tasks = taskService.getTasksForUser( new UserID( 1 ), Task.TASK_INCOMPLETE );
assertNotNull( tasks );
assertEquals( 1, tasks.size() );
}
public void testPerform_ApplyLeaveTask_NoParamSupplied() {
InstanceID instanceID = createInstance();
// Allow the queue service to breath
try {
Thread.sleep( 1000 );
} catch( InterruptedException e ) {
fail( e.getMessage() );
}
List tasks = taskService.getTasksForUser( new UserID( 1 ), Task.TASK_INCOMPLETE );
Task task = (Task)tasks.get( 0 );
ResponseHandler handler = taskService.getResponseHandlerForTask( task.getTaskID(), null );
assertNotNull( handler );
HttpServletRequestImpl request = new HttpServletRequestImpl();
HttpServletResponseImpl response = new HttpServletResponseImpl();
ResponseHandlerResponse rhr = ((HTTPResponseHandler)handler).processAction( request, response );
assertNotNull( rhr );
assertFalse( "Without the required parameters the token should not be able to continue", rhr.isAbleToContinue() );
}
public void testPerform_ApplyLeaveTask_ParamSupplied() {
InstanceID instanceID = createInstance();
// Allow the queue service to breath
try {
Thread.sleep( 1000 );
} catch( InterruptedException e ) {
fail( e.getMessage() );
}
List tasks = taskService.getTasksForUser( new UserID( 1 ), Task.TASK_INCOMPLETE );
Task task = (Task)tasks.get( 0 );
ResponseHandler handler = taskService.getResponseHandlerForTask( task.getTaskID(), null );
assertNotNull( handler );
HttpServletRequestImpl request = new HttpServletRequestImpl();
HttpServletResponseImpl response = new HttpServletResponseImpl();
// Supply the parameters
request.addParameter( "numdays", "40" );
request.addParameter( "reason", "Expedition to Mount Everest" );
ResponseHandlerResponse rhr = ((HTTPResponseHandler)handler).processAction( request, response );
assertNotNull( rhr );
assertTrue( rhr.isAbleToContinue() );
}
/**
* After performing a task, data submitted should be available in the node context.
*/
public void testNodeInfoData() {
InstanceID instanceID = createInstance();
// Allow the queue service to breath
try {
Thread.sleep( 1000 );
} catch( InterruptedException e ) {
fail( e.getMessage() );
}
List tasks = taskService.getTasksForUser( new UserID( 1 ), Task.TASK_INCOMPLETE );
Task task = (Task)tasks.get( 0 );
ResponseHandler handler = taskService.getResponseHandlerForTask( task.getTaskID(), null );
assertNotNull( handler );
HttpServletRequestImpl request = new HttpServletRequestImpl();
HttpServletResponseImpl response = new HttpServletResponseImpl();
// Supply the parameters
request.addParameter( "numdays", "40" );
request.addParameter( "reason", "Expedition to Mount Everest" );
ResponseHandlerResponse rhr = ((HTTPResponseHandler)handler).processAction( request, response );
assertNotNull( rhr );
assertTrue( rhr.isAbleToContinue() );
// The task has been submitted so let's transition to the next node
EngineMessage engineMessage = new EngineMessageImpl();
engineMessage.setMessageType( EngineMessage.TYPE_MOVE_TOKEN );
engineMessage.setCurrentTokenID( rhr.getTokenID() );
engineMessage.addAppData( rhr.getActivityDataName(), rhr.getActivityData() );
queueService.enqueue( engineMessage );
taskService.setTaskStatus( task.getTaskID(), Task.TASK_COMPLETE );
try {
Thread.sleep(1000);
}
catch( InterruptedException e) {
fail( e.getMessage() );
}
// Instance variables should now reflect the new assigned values
tasks = taskService.getTasksForUser( new UserID( 1 ), Task.TASK_INCOMPLETE );
task = (Task)tasks.get( 0 );
Token token = tokenService.getTokenByID( task.getSourceTokenID() );
Instance instance = instanceService.getInstanceByID( token.getInstanceID() );
assertEquals( "40", instance.getInstanceVariables().get( "numdays" ) );
}
private InstanceID createInstance() {
// Get the workflow to instantiate
BusinessProcessID businessProcessID = businessProcessService.getGraphIDByName( "Leave Application Workflow" );
assertNotNull( businessProcessID );
BusinessProcessInfo businessProcessInfo = businessProcessService.getInfoByID( businessProcessID );
assertNotNull( businessProcessInfo );
// Fill required variables with value
Map requiredVariables = new HashMap();
requiredVariables.put( "numdays", "10" );
// Instantiate the workflow
InstanceID instanceID = engine.startNewInstance( businessProcessID.getID(), requiredVariables );
assertNotNull( instanceID );
return( instanceID );
}
public void setUp() throws Exception {
tokenService = new TokenServiceImpl();
instanceService = new InstanceServiceImpl();
businessProcessService = new BusinessProcessServiceImpl();
taskService = new TaskServiceImpl();
timerService = new TimerServiceImpl();
notifyService = new NotificationServiceImpl();
logger = new StdoutLogService();
userService = new UserServiceImpl();
//for temporary user to test user preference
UserInfo user = new UserInfo("user", "user","user", false);
user.setUserID(new UserID( 1 ));
userService.addUser(user);
taskService.setTokenService(tokenService);
taskService.setInstanceService( instanceService );
taskService.setBusinessProcessService( businessProcessService );
messageProcessor = new MessageProcessor();
messageProcessor.setTaskService( taskService );
messageProcessor.setTimerService( timerService );
messageProcessor.setExecutionInstanceService( instanceService );
messageProcessor.setTokenService( tokenService );
messageProcessor.setBusinessProcessService( businessProcessService );
messageProcessor.setNotificationService( notifyService );
messageProcessor.setLogService(logger);
queueService = new QueueServiceImpl( messageProcessor );
timerService.setQueueService( queueService );
messageProcessor.setQueueService( queueService );
instanceService.setBusinessProcessService( businessProcessService );
instanceService.setQueueService( queueService );
instanceService.setTokenService( tokenService );
/*
* now start the message pump for processing since we are all ready
*/
queueService.start();
engine = new Engine( tokenService, instanceService, businessProcessService, queueService );
Reader reader = new InputStreamReader( getClass().getClassLoader().getResourceAsStream( "org/apache/agila/LeaveApplication.xml" ) );
engine.addBusinessProcess( reader );
}
public void tearDown() {
tokenService = null;
instanceService = null;
businessProcessService = null;
taskService = null;
timerService = null;
messageProcessor = null;
queueService = null;
engine = null;
notifyService = null;
userService = null;
}
}