public function testIsolatedActivity()
{
$processChecker = new wfAuthoring_models_classes_ProcessChecker($this->proc);
$activity1 = $this->authoringService->createActivity($this->proc);
$connector1 = $this->authoringService->createConnector($activity1);
$activity2 = $this->authoringService->createSequenceActivity($connector1);
$this->assertTrue($processChecker->checkNoIsolatedActivity());
wfAuthoring_models_classes_ConnectorService::singleton()->delete($connector1);
$this->assertFalse($processChecker->checkNoIsolatedActivity());
}
public function testSplitJoinVariable()
{
$process = wfAuthoring_models_classes_ProcessService::singleton()->createProcess('test process for ' . __FUNCTION__);
$activityAuthoring = wfAuthoring_models_classes_ActivityService::singleton();
$webservice = new core_kernel_classes_Resource('http://www.tao.lu/Ontologies/TAODelivery.rdf#ServiceWebService');
$activity = array();
for ($i = 1; $i <= 3; $i++) {
$activity[$i] = $activityAuthoring->createFromServiceDefinition($process, $webservice, array());
}
wfAuthoring_models_classes_ProcessService::singleton()->setFirstActivity($process, $activity[1]);
$c1 = $this->service->createSplit($activity[1], array($activity[2]));
$c2 = $this->service->createJoin(array($activity[2]), $activity[3]);
$this->service->setSplitCardinality($c1, array($activity[2]->getUri() => '3'));
$this->service->setJoinCardinality($c2, array($activity[2]->getUri() => '3'));
$this->runProcess($process, 5);
wfAuthoring_models_classes_ProcessService::singleton()->deleteProcess($process);
}
public function testCloneConditionnalProcess()
{
$this->processCloner->initCloningVariables();
$id = "P_condProc7_";
//for var_dump identification
$this->processCloner->setCloneLabel("__Clone7");
$activity1 = $this->authoringService->createActivity($this->proc, "{$id}Activity_1");
$activity1->editPropertyValues(new core_kernel_classes_Property(PROPERTY_ACTIVITIES_ISINITIAL), GENERIS_TRUE);
$connector1 = $this->authoringService->createConnector($activity1);
$then1 = $this->authoringService->createConditionalActivity($connector1, 'then', null, "{$id}Activity_2");
//create "Activity_2"
$else1 = $this->authoringService->createConditionalActivity($connector1, 'else', null, '', true);
//create another connector
// $else1 = $this->authoringService->createConditionalActivity($connector1, 'else');
$this->assertEquals($connector1->getUniquePropertyValue(new core_kernel_classes_Property(PROPERTY_CONNECTORS_TYPE))->getUri(), INSTANCE_TYPEOFCONNECTORS_CONDITIONAL);
$this->assertTrue($this->activityService->isActivity($then1));
$this->assertTrue($this->connectorService->isConnector($else1));
$transitionRule = $connector1->getUniquePropertyValue(new core_kernel_classes_Property(PROPERTY_CONNECTORS_TRANSITIONRULE));
$this->assertEquals($then1->getUri(), $transitionRule->getUniquePropertyValue(new core_kernel_classes_Property(PROPERTY_TRANSITIONRULES_THEN))->getUri());
$this->assertEquals($else1->getUri(), $transitionRule->getUniquePropertyValue(new core_kernel_classes_Property(PROPERTY_TRANSITIONRULES_ELSE))->getUri());
//create a sequential a
$connector2 = $this->authoringService->createConnector($then1);
$lastActivity = $this->authoringService->createSequenceActivity($connector2, null, "{$id}Activity_3");
//connector "else1": connect the "then" to the activity "then1" and the "else" to
$then2 = $this->authoringService->createConditionalActivity($else1, 'then', $connector2);
//connect to the activity $then1
$else2 = $this->authoringService->createConditionalActivity($else1, 'else', $lastActivity);
//connect to the connector of the activity $then1
$this->assertEquals($then2->getUri(), $connector2->getUri());
$this->assertEquals($else2->getUri(), $lastActivity->getUri());
//clone the process now!
$processClone = $this->processCloner->cloneProcess($this->proc);
$this->assertIsA($processClone, 'core_kernel_classes_Resource');
$this->assertEquals(count($this->processCloner->getClonedActivities()), 3);
$this->assertEquals(count($this->processCloner->getClonedConnectors()), 3);
//count the number of activities in the cloned process
$activities = $this->authoringService->getActivitiesByProcess($processClone);
$this->assertEquals(count($activities), 3);
foreach ($activities as $activity) {
$this->assertTrue($this->activityService->isActivity($activity));
}
$this->authoringService->deleteProcess($processClone);
}
/**
* Test the tokens into a parallel process
*/
public function testVirtualParallelJoinProcess()
{
error_reporting(E_ALL);
$t_start = microtime(true);
//init services
$activityService = wfEngine_models_classes_ActivityService::singleton();
$processVariableService = wfEngine_models_classes_VariableService::singleton();
$authoringService = wfAuthoring_models_classes_ProcessService::singleton();
$activityExecutionService = wfEngine_models_classes_ActivityExecutionService::singleton();
$activityExecutionService->cache = (bool) self::SERVICE_CACHE;
//process definition
$processDefinitionClass = new core_kernel_classes_Class(CLASS_PROCESS);
$processDefinition = $processDefinitionClass->createInstance('PJ processForUnitTest_' . date(DATE_ISO8601), 'created for the unit test of process execution');
$this->assertNotNull($processDefinition);
/*
+---------------+
| activity 0 |
+-------+-------+
|
+---v---+
| c 0 | split
+--+-+--+
| |
3 +---------+ +---------+ unit_var_12345678
| |
+-------v--------+ +-------v------+
| activity 1 | | activity 2 |
+-------+--------+ +--------+-----+
| |
+--------+ +--------+
+--v----v--+
| c 2 | join
+----+-----+
|
+-------v--------+
| activity 3 |
+----------------+
*/
//activities definitions
$activity0 = $authoringService->createActivity($processDefinition, 'activity0');
$this->assertNotNull($activity0);
$connector0 = null;
$authoringService->setFirstActivity($processDefinition, $activity0);
$connector0 = $authoringService->createConnector($activity0);
$connectorParallele = new core_kernel_classes_Resource(INSTANCE_TYPEOFCONNECTORS_PARALLEL);
$authoringService->setConnectorType($connector0, $connectorParallele);
$this->assertNotNull($connector0);
$parallelActivity1 = $authoringService->createActivity($processDefinition, 'activity1');
$this->assertNotNull($parallelActivity1);
$roleRestrictedUser = new core_kernel_classes_Resource(INSTANCE_ACL_ROLE_RESTRICTED_USER);
$activityService->setAcl($parallelActivity1, $roleRestrictedUser, $this->testUserRole);
//!!! it is mendatory to set the role restricted user ACL mode to make this parallel process test case work
$connector1 = null;
$connector1 = $authoringService->createConnector($parallelActivity1);
$this->assertNotNull($connector1);
$parallelActivity2 = $authoringService->createActivity($processDefinition, 'activity2');
$this->assertNotNull($parallelActivity2);
$activityService->setAcl($parallelActivity2, $roleRestrictedUser, $this->testUserRole);
//!!! it is mendatory to set the role restricted user ACL mode to make this parallel process test case work
$connector2 = null;
$connector2 = $authoringService->createConnector($parallelActivity2);
$this->assertNotNull($connector2);
//define parallel activities, first branch with constant cardinality value, while the second listens to a process variable:
$parallelCount1 = 3;
$parallelCount2 = 5;
$parallelCount2_processVar_key = 'unit_var_' . time();
$parallelCount2_processVar = $processVariableService->createProcessVariable('Var for unit test', $parallelCount2_processVar_key);
$prallelActivitiesArray = array($parallelActivity1->getUri() => $parallelCount1, $parallelActivity2->getUri() => $parallelCount2_processVar);
$result = $authoringService->setParallelActivities($connector0, $prallelActivitiesArray);
$this->assertTrue($result);
//set several split variables:
$splitVariable1_key = 'unit_split_var1_' . time();
$splitVariable1 = $processVariableService->createProcessVariable('Split Var1 for unit test', $splitVariable1_key);
$splitVariable2_key = 'unit_split_var2_' . time();
$splitVariable2 = $processVariableService->createProcessVariable('Split Var2 for unit test', $splitVariable2_key);
$splitVariablesArray = array($parallelActivity1->getUri() => array($splitVariable1), $parallelActivity2->getUri() => array($splitVariable1, $splitVariable2));
$connectorService = wfAuthoring_models_classes_ConnectorService::singleton();
$connectorService->setSplitVariables($connector0, $splitVariablesArray);
$prallelActivitiesArray[$parallelActivity2->getUri()] = $parallelCount2;
$joinActivity = $authoringService->createActivity($processDefinition, 'activity3');
//join parallel Activity 1 and 2 to "joinActivity"
$connector1 = wfAuthoring_models_classes_ConnectorService::singleton()->createJoin(array($parallelActivity1, $parallelActivity2), $joinActivity);
/*
$authoringService->createJoinActivity($connector1, $joinActivity, '', $parallelActivity1);
$authoringService->createJoinActivity($connector2, $joinActivity, '', $parallelActivity2);
*/
//run the process
$processExecName = 'Test Parallel Process Execution';
$processExecComment = 'created for processExecustionService test case by ' . __METHOD__;
$processInstance = $this->service->createProcessExecution($processDefinition, $processExecName, $processExecComment);
$this->assertTrue($this->service->checkStatus($processInstance, 'started'));
$this->out(__METHOD__, true);
$this->out("<strong>Forward transitions:</strong>", true);
$previousActivityExecution = null;
$numberActivities = 2 + $parallelCount1 + $parallelCount2;
$createdUsers = array();
$loginProperty = new core_kernel_classes_Property(PROPERTY_USER_LOGIN);
for ($i = 1; $i <= $numberActivities; $i++) {
$activitieExecs = $this->service->getCurrentActivityExecutions($processInstance);
$countActivities = count($activitieExecs);
$activity = null;
$activityExecution = null;
if ($countActivities > 1) {
//select one of the available activities in the parallel branch:
foreach ($activitieExecs as $activityExecUri => $activityExec) {
if (!$activityExecutionService->isFinished($activityExec)) {
$activityDefinition = $activityExecutionService->getExecutionOf($activityExec);
$activityUri = $activityDefinition->getUri();
if (isset($prallelActivitiesArray[$activityUri])) {
if ($prallelActivitiesArray[$activityUri] > 0) {
$prallelActivitiesArray[$activityUri]--;
$activityExecution = $activityExec;
$activity = $activityDefinition;
break;
}
}
}
}
} else {
if ($countActivities == 1) {
$activityExecution = reset($activitieExecs);
$activity = $activityExecutionService->getExecutionOf($activityExecution);
} else {
$this->fail('no current activity definition found for the iteration ' . $i);
}
}
$this->out("<strong> Iteration {$i} :</strong>", true);
$this->out("<strong>" . (is_null($activity) ? 'null' : $activity->getLabel()) . "</strong> (among {$countActivities})");
//issue : no activity found for the last iteration...
//init execution
$activityExecution = $this->service->initCurrentActivityExecution($processInstance, $activityExecution, $this->currentUser);
$this->assertNotNull($activityExecution);
if ($i == 1) {
//set value of the parallel thread:
$processVariableService->push($parallelCount2_processVar_key, $parallelCount2);
//set some values to the split variables:
$values1 = array();
for ($j = 1; $j <= $parallelCount1; $j++) {
$values1[] = 'A' . $j;
}
$values2 = array();
for ($j = 1; $j <= $parallelCount2; $j++) {
$values2[] = 'B' . $j;
}
$processVariableService->push($splitVariable1_key, serialize($values1));
$processVariableService->push($splitVariable2_key, serialize($values2));
} else {
//check dispatched value:
// $value1 = $processVariableService->get($splitVariable1_key);
// $value2 = $processVariableService->get($splitVariable2_key);
// var_dump($value1, $value2);
}
$activityExecStatus = $activityExecutionService->getStatus($activityExecution);
$this->assertNotNull($activityExecStatus);
$this->assertEquals($activityExecStatus->getUri(), INSTANCE_PROCESSSTATUS_STARTED);
//transition to next activity
$this->out("current user: "******"' . $this->currentUser->getUri() . '"');
$this->out("performing transition ...");
//transition to next activity
$performed = $this->service->performTransition($processInstance, $activityExecution);
if (!$performed) {
$this->out('transition failed.');
}
$this->out("activity status: " . $activityExecutionService->getStatus($activityExecution)->getLabel());
$this->out("process status: " . $this->service->getStatus($processInstance)->getLabel());
//try undoing the transition:
switch ($i) {
case 1:
$this->assertTrue($this->service->undoForwardTransition($processInstance, $activityExecution));
$activitieExecs = $this->service->getCurrentActivityExecutions($processInstance);
$this->assertEquals(count($activitieExecs), 1);
$activityBis = $activityExecutionService->getExecutionOf(reset($activitieExecs));
$this->assertTrue($activity->getUri() == $activityBis->getUri());
$transitionResult = $this->service->performTransition($processInstance, $activityExecution);
break;
case 1 + $parallelCount1:
$this->assertFalse($this->service->undoForwardTransition($processInstance, $activityExecution));
$history = $this->service->getExecutionHistory($processInstance);
$this->assertEquals(count($history), 2 * ($parallelCount1 + $parallelCount2) + 1);
//activity 1, 2(closed), 2, 3 and 4
$this->assertFalse($this->service->undoForwardTransition($processInstance, new core_kernel_classes_Resource(reset($history))));
$this->assertNotNull($previousActivityExecution);
$this->assertFalse($this->service->undoForwardTransition($processInstance, $previousActivityExecution));
break;
case 1 + $parallelCount1 + $parallelCount2:
$this->assertTrue($this->service->undoForwardTransition($processInstance, $activityExecution));
$activitieExecs = $this->service->getCurrentActivityExecutions($processInstance);
$this->assertEquals(count($activitieExecs), $parallelCount1 + $parallelCount2);
$transitionResult = $this->service->performTransition($processInstance, $activityExecution);
break;
}
$previousActivityExecution = $activityExecution;
if ($this->service->isPaused($processInstance)) {
//Login another user to execute parallel branch
$this->userService->logout();
$this->out("logout " . $this->currentUser->getOnePropertyValue($loginProperty) . ' "' . $this->currentUser->getUri() . '"', true);
list($usec, $sec) = explode(" ", microtime());
$login = '******' . $i . '-' . $usec;
$pass = '******';
$userData = array(PROPERTY_USER_LOGIN => $login, PROPERTY_USER_PASSWORD => core_kernel_users_Service::getPasswordHash()->encrypt($pass), PROPERTY_USER_DEFLG => 'http://www.tao.lu/Ontologies/TAO.rdf#Lang' . DEFAULT_LANG, PROPERTY_USER_UILG => 'http://www.tao.lu/Ontologies/TAO.rdf#Lang' . DEFAULT_LANG, PROPERTY_USER_ROLES => INSTANCE_ROLE_WORKFLOW, RDFS_LABEL => $login);
if (!$this->userService->loginAvailable($login)) {
$this->fail('test login already taken');
}
$otherUser = $this->testUserClass->createInstanceWithProperties($userData);
$createdUsers[$otherUser->getUri()] = $otherUser;
if ($this->userService->loginUser($login, $pass)) {
$this->currentUser = $this->userService->getCurrentUser();
$this->out("new user logged in: " . $this->currentUser->getOnePropertyValue($loginProperty) . ' "' . $this->currentUser->getUri() . '"');
} else {
$this->fail("unable to login user {$login}");
}
}
}
$this->assertTrue($this->service->isFinished($processInstance));
$this->assertTrue($this->service->resume($processInstance));
$this->out("<strong>Backward transitions:</strong>", true);
// var_dump($this->service->getAllActivityExecutions($processInstance));
$j = 0;
$iterationNumber = 2;
while ($j < $iterationNumber) {
$activitieExecs = $this->service->getCurrentActivityExecutions($processInstance);
$activityExecution = null;
$activity = null;
switch ($j) {
case 0:
$this->assertEquals(count($activitieExecs), 1);
//check
$activityExecution = reset($activitieExecs);
$activity = $activityExecutionService->getExecutionOf($activityExecution);
break;
case 1:
$this->assertEquals(count($activitieExecs), $parallelCount1 + $parallelCount2);
//check
$activity = $parallelActivity2;
foreach ($this->service->getCurrentActivityExecutions($processInstance, $activity) as $activityExec) {
if ($activityExecutionService->getActivityExecutionUser($activityExec)->getUri() == $this->currentUser->getUri()) {
$activityExecution = $activityExec;
}
}
if (is_null($activityExecution)) {
$activity = $parallelActivity1;
foreach ($this->service->getCurrentActivityExecutions($processInstance, $activity) as $activityExec) {
if ($activityExecutionService->getActivityExecutionUser($activityExec)->getUri() == $this->currentUser->getUri()) {
$activityExecution = $activityExec;
}
}
}
$this->assertNotNull($activityExecution);
break;
}
$this->out("<strong>" . $activity->getLabel() . "</strong>", true);
//init execution
$activityExecution = $this->service->initCurrentActivityExecution($processInstance, $activityExecution, $this->currentUser);
$this->assertNotNull($activityExecution);
$activityExecStatus = $activityExecutionService->getStatus($activityExecution);
$this->assertNotNull($activityExecStatus);
$this->assertEquals($activityExecStatus->getUri(), INSTANCE_PROCESSSTATUS_RESUMED);
$this->out("current user: "******"' . $this->currentUser->getUri() . '"');
$this->out("performing transition ...");
//transition to next activity
$transitionResult = $this->service->performBackwardTransition($processInstance, $activityExecution);
if ($j == 0) {
$this->assertTrue(count($transitionResult) > 0);
} else {
if ($j == $iterationNumber - 1) {
//var_dump($transitionResult);
$this->assertFalse($transitionResult);
}
}
$processStatus = $this->service->getStatus($processInstance);
$this->assertNotNull($processStatus);
$this->out("activity status: " . $activityExecutionService->getStatus($activityExecution)->getLabel());
$this->out("process status: " . $processStatus->getLabel());
$this->assertEquals($processStatus->getUri(), INSTANCE_PROCESSSTATUS_PAUSED);
$j++;
}
$this->out("<strong>Forward transitions again:</strong>", true);
$currentActivityExecutions = $this->service->getCurrentActivityExecutions($processInstance);
$currentActivityExecutionsCount = count($currentActivityExecutions);
$this->assertEquals($currentActivityExecutionsCount, $parallelCount1 + $parallelCount2);
for ($i = 0; $i < $currentActivityExecutionsCount; $i++) {
$currentActivityExecution = array_pop($currentActivityExecutions);
$user = $activityExecutionService->getActivityExecutionUser($currentActivityExecution);
$activityDefinition = $activityExecutionService->getExecutionOf($currentActivityExecution);
$this->assertNotNull($user);
$this->assertNotNull($activityDefinition);
if (!is_null($user) && !is_null($activityDefinition)) {
$this->userService->logout();
$this->out("logout " . $this->currentUser->getOnePropertyValue($loginProperty) . ' "' . $this->currentUser->getUri() . '"', true);
$login = (string) $user->getUniquePropertyValue($loginProperty);
$pass = '******';
if ($this->userService->loginUser($login, $pass)) {
$this->currentUser = $this->userService->getCurrentUser();
$this->out("new user logged in: " . $this->currentUser->getOnePropertyValue($loginProperty) . ' "' . $this->currentUser->getUri() . '"');
} else {
$this->fail("unable to login user {$login}<br>");
}
$iterationNo = $i + 1;
$this->out("<strong>Iteration {$iterationNo}: " . $activityDefinition->getLabel() . "</strong>", true);
//execute activity:
$activityExecution = $this->service->initCurrentActivityExecution($processInstance, $currentActivityExecution, $this->currentUser);
$this->assertNotNull($activityExecution);
$activityExecStatus = $activityExecutionService->getStatus($activityExecution);
$this->assertNotNull($activityExecStatus);
$this->assertEquals($activityExecStatus->getUri(), INSTANCE_PROCESSSTATUS_RESUMED);
//transition to next activity
$this->out("current user: "******"' . $this->currentUser->getUri() . '"');
$this->out("performing transition ...");
//transition to next activity
$this->service->performTransition($processInstance, $activityExecution);
$this->out("activity status: " . $activityExecutionService->getStatus($activityExecution)->getLabel());
$this->out("process status: " . $this->service->getStatus($processInstance)->getLabel());
//try undoing the transition:
if ($i < $currentActivityExecutionsCount - 1) {
$this->assertFalse($this->service->undoForwardTransition($processInstance, $activityExecution));
}
}
}
//try undoing the transition:
$this->assertTrue($this->service->undoForwardTransition($processInstance, $activityExecution));
$activitieExecs = $this->service->getCurrentActivityExecutions($processInstance);
$this->assertEquals(count($activitieExecs), $parallelCount1 + $parallelCount2);
$transitionResult = $this->service->performTransition($processInstance, $activityExecution);
$this->assertEquals(count($transitionResult), 1);
$activitieExecs = $this->service->getCurrentActivityExecutions($processInstance);
$this->assertEquals(count($activitieExecs), 1);
$activityExecution = reset($activitieExecs);
$activity = $activityExecutionService->getExecutionOf($activityExecution);
$this->assertEquals($activity->getUri(), $joinActivity->getUri());
$this->out("<strong>Executing last activity: " . $activity->getLabel() . "</strong>", true);
//init execution
$activityExecution = $this->service->initCurrentActivityExecution($processInstance, $activityExecution, $this->currentUser);
$this->assertNotNull($activityExecution);
$activityExecStatus = $activityExecutionService->getStatus($activityExecution);
$this->assertNotNull($activityExecStatus);
$this->assertEquals($activityExecStatus->getUri(), INSTANCE_PROCESSSTATUS_STARTED);
//transition to next activity
$this->out("current user: "******"' . $this->currentUser->getUri() . '"');
$this->out("performing transition ...");
//transition to next activity
$this->service->performTransition($processInstance, $activityExecution);
$this->out("activity status: " . $activityExecutionService->getStatus($activityExecution)->getLabel());
$this->out("process status: " . $this->service->getStatus($processInstance)->getLabel());
$this->assertTrue($this->service->isFinished($processInstance));
$t_end = microtime(true);
$duration = $t_end - $t_start;
$this->out('Elapsed time: ' . $duration . 's', true);
$this->out('deleting created resources:', true);
//delete process exec:
$this->assertTrue($this->service->deleteProcessExecution($processInstance));
//delete processdef:
$this->assertTrue($authoringService->deleteProcess($processDefinition));
$parallelCount2_processVar->delete();
//delete created users:
foreach ($createdUsers as $createdUser) {
$this->out('deleting ' . $createdUser->getLabel() . ' "' . $createdUser->getUri() . '"');
$this->assertTrue($this->userService->removeUser($createdUser));
}
if (!is_null($this->currentUser)) {
$this->userService->logout();
$this->userService->removeUser($this->currentUser);
}
}
protected function createLinearSuperProcess($processes)
{
$processDefinitionClass = new core_kernel_classes_Class(CLASS_PROCESS);
$processDefinition = $processDefinitionClass->createInstance('process for ' . __CLASS__);
$this->assertIsA($processDefinition, 'core_kernel_classes_Resource');
$activityService = wfAuthoring_models_classes_ActivityService::singleton();
$connectorService = wfAuthoring_models_classes_ConnectorService::singleton();
$processRunnerService = new core_kernel_classes_Resource(INSTANCE_SERVICE_PROCESSRUNNER);
$processRunnerParam = new core_kernel_classes_Resource(INSTANCE_FORMALPARAM_PROCESSDEFINITION);
$last = null;
foreach ($processes as $subProcess) {
$serviceCall = new tao_models_classes_service_ServiceCall($processRunnerService);
$serviceCall->addInParameter(new tao_models_classes_service_ConstantParameter($processRunnerParam, $subProcess));
$current = $activityService->createActivity($processDefinition);
$current->setPropertyValue(new core_kernel_classes_Property(PROPERTY_ACTIVITIES_INTERACTIVESERVICES), $serviceCall->toOntology());
if (is_null($last)) {
$current->editPropertyValues(new core_kernel_classes_Property(PROPERTY_ACTIVITIES_ISINITIAL), GENERIS_TRUE);
} else {
$connectorService->createSequential($last, $current);
}
$last = $current;
}
return $processDefinition;
}
/**
* Short description of method setConnectorType
*
* @access public
* @author Joel Bout, <*****@*****.**>
* @param Resource connector
* @param Resource type
* @return boolean
*/
public function setConnectorType(core_kernel_classes_Resource $connector, core_kernel_classes_Resource $type)
{
$returnValue = (bool) false;
$connectorService = wfAuthoring_models_classes_ConnectorService::singleton();
$returnValue = $connectorService->setConnectorType($connector, $type);
return (bool) $returnValue;
}
/**
* Short description of method setTestItems
*
* @access public
* @author Joel Bout, <*****@*****.**>
* @param
* Resource test
* @param
* array items
* @return boolean
*/
public function setTestItems(core_kernel_classes_Resource $test, $items)
{
$returnValue = (bool) false;
$authoringService = wfAuthoring_models_classes_ProcessService::singleton();
// get the current process:
$process = $test->getUniquePropertyValue(new core_kernel_classes_Property(TEST_TESTCONTENT_PROP));
// get formal param associated to the 3 required service input parameters:
$itemUriParam = new core_kernel_classes_Resource(INSTANCE_FORMALPARAM_ITEMURI);
// delete all related activities:
$activities = $authoringService->getAllActivities($process);
foreach ($activities as $activity) {
if (!$authoringService->deleteActivity($activity)) {
throw new common_exception_Error('Unable to delete Activity ' . $activity->getUri());
}
}
// create the list of activities and interactive services and items plus their appropriate property values:
$previousActivity = null;
$connectorService = wfAuthoring_models_classes_ConnectorService::singleton();
foreach ($items as $item) {
if (!$item instanceof core_kernel_classes_Resource) {
throw new common_Exception("An item provided to " . __FUNCTION__ . " is not a resource but " . gettype($item));
}
// create an activity
$activity = null;
$activity = $authoringService->createActivity($process, "item: {$item->getLabel()}");
// set property value visible to true
$activity->editPropertyValues(new core_kernel_classes_Property(PROPERTY_ACTIVITIES_ISHIDDEN), GENERIS_FALSE);
// set ACL mode to role user restricted with role=subject
$extManager = common_ext_ExtensionsManager::singleton();
$activity->editPropertyValues(new core_kernel_classes_Property(PROPERTY_ACTIVITIES_ACL_MODE), INSTANCE_ACL_ROLE_RESTRICTED_USER_DELIVERY);
$activity->editPropertyValues(new core_kernel_classes_Property(PROPERTY_ACTIVITIES_RESTRICTED_ROLE), INSTANCE_ROLE_DELIVERY);
// get the item runner service definition: must exists!
$itemRunnerServiceDefinition = new core_kernel_classes_Resource(INSTANCE_ITEMCONTAINER_SERVICE);
if (!$itemRunnerServiceDefinition->exists()) {
throw new common_exception_InconsistentData('required service definition item runner does not exists');
}
// create a call of service and associate the service definition to it:
$interactiveService = $authoringService->createInteractiveService($activity);
$interactiveService->setPropertyValue(new core_kernel_classes_Property(PROPERTY_CALLOFSERVICES_SERVICEDEFINITION), $itemRunnerServiceDefinition->getUri());
$authoringService->setActualParameter($interactiveService, $itemUriParam, $item->getUri(), PROPERTY_CALLOFSERVICES_ACTUALPARAMETERIN);
// constant: we know it!
if (!is_null($previousActivity)) {
$connectorService->createSequential($previousActivity, $activity);
} else {
// set the property value as initial
$activity->editPropertyValues(new core_kernel_classes_Property(PROPERTY_ACTIVITIES_ISINITIAL), GENERIS_TRUE);
}
$previousActivity = $activity;
}
$returnValue = true;
return (bool) $returnValue;
}
public function testCreateCBAProcess()
{
if (!$this->createProcess) {
return;
}
$authoringService = wfAuthoring_models_classes_ProcessService::singleton();
$activityService = wfEngine_models_classes_ActivityService::singleton();
$connectorService = wfAuthoring_models_classes_ConnectorService::singleton();
$processVariableService = wfEngine_models_classes_VariableService::singleton();
$cardinalityService = wfEngine_models_classes_ActivityCardinalityService::singleton();
//create some process variables:
$varCodes = array('unitUri', 'countryCode', 'languageCode', 'npm', 'translatorsCount', 'translator', 'reconciler', 'verifier', 'translatorSelected', 'translationFinished', 'TDreview', 'layoutCheck', 'finalCheck', 'opticalCheck', 'TDsignOff', 'countrySignOff', 'xliff', 'vff', 'xliff_working', 'vff_working');
//"workingFiles" holds the working versions of the xliff and vff files, plus their revision number, in an serialized array()
//during translation: workingFiles = array('user'=>#007, 'xliff' => array('uri' => #123456, 'revision'=>3), 'vff'=> array('uri' => #456789, 'revision'=>5))
$this->populateVariables($varCodes);
$aclUser = new core_kernel_classes_Resource(INSTANCE_ACL_USER);
$aclRole = new core_kernel_classes_Resource(INSTANCE_ACL_ROLE);
$processDefinition = $authoringService->createProcess($this->processLabel['CBA'], 'For Unit test');
$this->assertIsA($processDefinition, 'core_kernel_classes_Resource');
//set process initialization rights:
$this->assertTrue($authoringService->setAcl($processDefinition, $aclRole, $this->roles['consortium']));
//define activities and connectors
//Select translators:
$activitySelectTranslators = $authoringService->createActivity($processDefinition, 'Select Translator');
$this->assertNotNull($activitySelectTranslators);
$authoringService->setFirstActivity($processDefinition, $activitySelectTranslators);
$activityService->setAcl($activitySelectTranslators, $aclUser, $this->vars['npm']);
$activityService->setControls($activitySelectTranslators, array(INSTANCE_CONTROL_FORWARD));
$connectorSelectTranslators = $authoringService->createConnector($activitySelectTranslators);
$this->assertNotNull($connectorSelectTranslators);
//translate:
$activityTranslate = $authoringService->createActivity($processDefinition, 'Translate');
$this->assertNotNull($activityTranslate);
$activityService->setAcl($activityTranslate, $aclUser, $this->vars['translator']);
$activityService->setControls($activityTranslate, array(INSTANCE_CONTROL_FORWARD));
$result = $authoringService->setParallelActivities($connectorSelectTranslators, array($activityTranslate->getUri() => $this->vars['translatorsCount']));
$this->assertTrue($result);
$this->assertTrue($connectorService->setSplitVariables($connectorSelectTranslators, array($activityTranslate->getUri() => $this->vars['translator'])));
$nextActivities = $connectorService->getNextActivities($connectorSelectTranslators);
$this->assertEqual(count($nextActivities), 1);
$cardinality = reset($nextActivities);
$this->assertTrue($cardinalityService->isCardinality($cardinality));
$this->assertEqual($cardinalityService->getDestination($cardinality)->getUri(), $activityTranslate->getUri());
$this->assertEqual($cardinalityService->getCardinality($cardinality)->getUri(), $this->vars['translatorsCount']->getUri());
$connectorTranslate = $authoringService->createConnector($activityTranslate);
$this->assertNotNull($connectorTranslate);
//reconciliation:
$activityReconciliation = $authoringService->createJoinActivity($connectorTranslate, null, 'Reconciliation', $activityTranslate);
$prevActivities = $connectorService->getPreviousActivities($connectorTranslate);
$this->assertEqual(count($prevActivities), 1);
$cardinality = reset($prevActivities);
$this->assertTrue($cardinalityService->isCardinality($cardinality));
$this->assertEqual($cardinalityService->getSource($cardinality)->getUri(), $activityTranslate->getUri());
$this->assertEqual($cardinalityService->getCardinality($cardinality)->getUri(), $this->vars['translatorsCount']->getUri());
$this->assertNotNull($activityReconciliation);
$activityService->setAcl($activityReconciliation, $aclUser, $this->vars['reconciler']);
$activityService->setControls($activityReconciliation, array(INSTANCE_CONTROL_FORWARD));
$connectorReconciliation = $authoringService->createConnector($activityReconciliation);
$this->assertNotNull($connectorReconciliation);
//verify translations
$activityVerifyTranslations = $authoringService->createSequenceActivity($connectorReconciliation, null, 'Verify Translations');
$this->assertNotNull($activityVerifyTranslations);
$activityService->setAcl($activityVerifyTranslations, $aclUser, $this->vars['verifier']);
$activityService->setControls($activityVerifyTranslations, array(INSTANCE_CONTROL_FORWARD));
$connectorVerifyTranslations = $authoringService->createConnector($activityVerifyTranslations);
$this->assertNotNull($connectorVerifyTranslations);
//correct verification
$activityCorrectVerification = $authoringService->createSequenceActivity($connectorVerifyTranslations, null, 'Correct Verification Issues');
$this->assertNotNull($activityCorrectVerification);
$activityService->setAcl($activityCorrectVerification, $aclUser, $this->vars['reconciler']);
$activityService->setControls($activityCorrectVerification, array(INSTANCE_CONTROL_FORWARD));
$connectorCorrectVerification = $authoringService->createConnector($activityCorrectVerification);
$this->assertNotNull($connectorCorrectVerification);
//TD review :
$activityTDreview = $authoringService->createSequenceActivity($connectorCorrectVerification, null, 'TD review');
$this->assertNotNull($activityTDreview);
$activityService->setAcl($activityTDreview, $aclRole, $this->roles['testDeveloper']);
$activityService->setControls($activityTDreview, array(INSTANCE_CONTROL_FORWARD));
$connectorTDreview = $authoringService->createConnector($activityTDreview);
$this->assertNotNull($connectorTDreview);
//if TD review not ok, return to correct verification issues:
$transitionRule = $authoringService->createTransitionRule($connectorTDreview, '^TDreview == 1');
$this->assertNotNull($transitionRule);
$activityCorrectVerificationBis = $authoringService->createConditionalActivity($connectorTDreview, 'else', $activityCorrectVerification);
//if ^TDreview != 1
$this->assertEqual($activityCorrectVerification->getUri(), $activityCorrectVerificationBis->getUri());
//correct layout :
$activityCorrectLayout = $authoringService->createConditionalActivity($connectorTDreview, 'then', null, 'Correct Layout Issues');
//if ^TDreview == 1
$this->assertNotNull($activityCorrectLayout);
$activityService->setAcl($activityCorrectLayout, $aclRole, $this->roles['developer']);
$activityService->setControls($activityCorrectLayout, array(INSTANCE_CONTROL_FORWARD));
$connectorCorrectLayout = $authoringService->createConnector($activityCorrectLayout);
$this->assertNotNull($connectorCorrectLayout);
//if correct layout needs verification :
$transitionRule = $authoringService->createTransitionRule($connectorCorrectLayout, '^layoutCheck == 1');
$this->assertNotNull($transitionRule);
$activityVerification = $authoringService->createConditionalActivity($connectorCorrectLayout, 'else', null, 'Verification Followup');
//if ^layoutCheck != 1
$this->assertNotNull($activityVerification);
$activityService->setAcl($activityVerification, $aclUser, $this->vars['verifier']);
$activityService->setControls($activityVerification, array(INSTANCE_CONTROL_FORWARD));
$connectorVerification = $authoringService->createConnector($activityVerification);
$this->assertNotNull($connectorVerification);
//final check :
$activityFinalCheck = $authoringService->createConditionalActivity($connectorCorrectLayout, 'then', null, 'Final Check');
//if ^layoutCheck == 1
$this->assertNotNull($activityFinalCheck);
$activityService->setAcl($activityFinalCheck, $aclRole, $this->roles['testDeveloper']);
$activityService->setControls($activityFinalCheck, array(INSTANCE_CONTROL_FORWARD));
$connectorFinalCheck = $authoringService->createConnector($activityFinalCheck);
$this->assertNotNull($connectorFinalCheck);
//if final check ok, go to scoring definition :
$transitionRule = $authoringService->createTransitionRule($connectorFinalCheck, '^finalCheck == 1');
$this->assertNotNull($transitionRule);
$activityScoringDefinition = $authoringService->createConditionalActivity($connectorFinalCheck, 'then', null, 'Scoring Definition and Testing');
//if ^finalCheck == 1
$this->assertNotNull($activityScoringDefinition);
$activityService->setAcl($activityScoringDefinition, $aclUser, $this->vars['reconciler']);
$activityService->setControls($activityScoringDefinition, array(INSTANCE_CONTROL_FORWARD));
$connectorScoringDefinition = $authoringService->createConnector($activityScoringDefinition);
$this->assertNotNull($connectorScoringDefinition);
//if not ok, return to correct layout :
$activityCorrectLayoutBis = $authoringService->createConditionalActivity($connectorFinalCheck, 'else', $activityCorrectLayout);
//if ^finalCheck != 1
$this->assertEqual($activityCorrectLayout->getUri(), $activityCorrectLayoutBis->getUri());
//verification :
$transitionRule = $authoringService->createTransitionRule($connectorVerification, '^opticalCheck == 1');
$this->assertNotNull($transitionRule);
$activityFinalCheckBis = $authoringService->createConditionalActivity($connectorVerification, 'then', $activityFinalCheck);
//if ^opticalCheck == 1
$this->assertEqual($activityFinalCheckBis->getUri(), $activityFinalCheck->getUri());
$activityCorrectLayoutBis = $authoringService->createConditionalActivity($connectorVerification, 'else', $activityCorrectLayout);
//if ^opticalCheck != 1
$this->assertEqual($activityCorrectLayoutBis->getUri(), $activityCorrectLayout->getUri());
//scoring verification:
$activityScoringVerification = $authoringService->createSequenceActivity($connectorScoringDefinition, null, 'Scoring Verification');
$this->assertNotNull($activityScoringVerification);
$activityService->setAcl($activityScoringVerification, $aclUser, $this->vars['verifier']);
$activityService->setControls($activityScoringVerification, array(INSTANCE_CONTROL_FORWARD));
$connectorScoringVerification = $authoringService->createConnector($activityScoringVerification);
$this->assertNotNull($connectorScoringVerification);
//final sign off :
$activityTDSignOff = $authoringService->createSequenceActivity($connectorScoringVerification, null, 'Test Developer Sign Off');
$this->assertNotNull($activityTDSignOff);
$activityService->setAcl($activityTDSignOff, $aclRole, $this->roles['testDeveloper']);
$activityService->setControls($activityTDSignOff, array(INSTANCE_CONTROL_FORWARD));
$connectorTDSignOff = $authoringService->createConnector($activityTDSignOff);
$this->assertNotNull($connectorTDSignOff);
//link back to final check:
$transitionRule = $authoringService->createTransitionRule($connectorTDSignOff, '^TDsignOff == 1');
$this->assertNotNull($transitionRule);
$authoringService->createConditionalActivity($connectorTDSignOff, 'else', $activityFinalCheck);
//sign off :
$activityCountrySignOff = $authoringService->createConditionalActivity($connectorTDSignOff, 'then', null, 'Country Sign Off');
$activityService->setAcl($activityCountrySignOff, $aclUser, $this->vars['reconciler']);
$activityService->setControls($activityCountrySignOff, array(INSTANCE_CONTROL_FORWARD));
//complete the process:
$connectorCountrySignOff = $authoringService->createConnector($activityCountrySignOff);
$this->assertNotNull($connectorCountrySignOff);
$transitionRule = $authoringService->createTransitionRule($connectorCountrySignOff, '^countrySignOff == 1');
$this->assertNotNull($transitionRule);
$activityFinal = $authoringService->createConditionalActivity($connectorCountrySignOff, 'then', null, 'Completed');
$activityService->setAcl($activityFinal, $aclUser, $this->vars['reconciler']);
$activityService->setControls($activityFinal, array(INSTANCE_CONTROL_FORWARD));
$activityService->setHidden($activityFinal, true);
$activityTDSignOffBis = $authoringService->createConditionalActivity($connectorCountrySignOff, 'else', $activityTDSignOff);
$this->assertEqual($activityTDSignOff->getUri(), $activityTDSignOffBis->getUri());
//end of process definition
$this->processDefinition['CBA'] = $processDefinition;
}
public function testGetPreviousActivities()
{
/*
* activity > connector1(COND)
* -> THEN > thenConnector(SQ)
* -> ELSE > elseConnector (SQ)
* -> Act3 > connector2(PARA)
* -> Act4 > connector3(JOIN)
* -> Act5 > connector4(JOIN)
* -> Acto6
*
*/
$connector1 = $this->authoringService->createConnector($this->activity);
$then = $this->authoringService->createConditionalActivity($connector1, 'then');
//create "Activity_2"
$thenConnector = $this->authoringService->createConnector($then, 'then Connector');
//create "Activity_2"
$else = $this->authoringService->createConditionalActivity($connector1, 'else', null, '', true);
//create another connector
$elseConnector = $this->authoringService->createConnector($else, 'else Connector');
//create "Activity_2"
$activity3 = $this->authoringService->createSequenceActivity($thenConnector, null, 'Act3');
$this->authoringService->createSequenceActivity($elseConnector, $activity3);
$connector1PrevAct = $this->service->getPreviousActivities($connector1);
$this->assertInternalType('array', $connector1PrevAct);
$this->assertTrue(sizeof($connector1PrevAct) == 1);
if (isset($connector1PrevAct[0]) && $connector1PrevAct[0] instanceof core_kernel_classes_Resource) {
$this->assertTrue($connector1PrevAct[0]->getUri() == $this->activity->getUri());
}
$elsePrevAct = $this->service->getPreviousActivities($elseConnector);
$this->assertInternalType('array', $elsePrevAct);
$this->assertTrue(sizeof($elsePrevAct) == 1);
if (isset($elsePrevAct[0]) && $elsePrevAct[0] instanceof core_kernel_classes_Resource) {
$this->assertTrue($elsePrevAct[0]->getUri() == $else->getUri());
}
$thenPrevAct = $this->service->getPreviousActivities($thenConnector);
$this->assertInternalType('array', $thenPrevAct);
$this->assertTrue(sizeof($thenPrevAct) == 1);
if (isset($thenPrevAct[0]) && $thenPrevAct[0] instanceof core_kernel_classes_Resource) {
$this->assertTrue($thenPrevAct[0]->getUri() == $then->getUri());
}
$myProcessVar1 = $this->variableService->getProcessVariable('myProcessVarCode1', true);
$transitionRule = $this->authoringService->createTransitionRule($connector1, '^myProcessVarCode1 == 1');
$connector2 = $this->authoringService->createConnector($activity3);
$activity4 = $this->authoringService->createActivity($this->processDefinition, 'activity4 for interactive service unit test');
$connector3 = $this->authoringService->createConnector($activity4);
$activity5 = $this->authoringService->createActivity($this->processDefinition, 'activity5 for interactive service unit test');
$connector4 = $this->authoringService->createConnector($activity5);
$newActivitiesArray = array($activity4->getUri() => 2, $activity5->getUri() => 3);
$this->authoringService->setParallelActivities($connector2, $newActivitiesArray);
$activity6 = $this->authoringService->createActivity($this->processDefinition);
$connector3 = wfAuthoring_models_classes_ConnectorService::singleton()->createJoin(array($activity4, $activity5), $activity6);
/*
$activity6 = $this->authoringService->createJoinActivity($connector3, null, '', $activity4);
$activity7 = $this->authoringService->createJoinActivity($connector4, $activity6, '', $activity5);
*/
$this->assertEquals(count($this->service->getNextActivities($connector2)), 2);
$activity3PrevActi = $this->service->getPreviousActivities($connector2);
$this->assertInternalType('array', $activity3PrevActi);
$this->assertTrue(sizeof($activity3PrevActi) == 1);
if (isset($activity3PrevActi[0]) && $activity3PrevActi[0] instanceof core_kernel_classes_Resource) {
$this->assertTrue($activity3PrevActi[0]->getUri() == $activity3->getUri());
}
$activity4PrevActi = $this->service->getPreviousSteps($connector3);
$this->assertInternalType('array', $activity4PrevActi);
$this->assertEquals(sizeof($activity4PrevActi), 2);
$cardinalityService = wfEngine_models_classes_ActivityCardinalityService::singleton();
$prevActivitiesarrayCount = array();
foreach ($activity4PrevActi as $cardinality) {
$this->assertTrue($cardinalityService->isCardinality($cardinality));
$activities = $cardinalityService->getPreviousSteps($cardinality);
$this->assertEquals(count($activities), 1);
$activity = current($activities);
$keyExists = array_key_exists($activity->getUri(), $newActivitiesArray);
$this->assertTrue($keyExists);
if ($keyExists) {
$prevActivitiesarrayCount[$activity->getUri()] = $cardinalityService->getCardinality($cardinality);
}
}
$this->assertEquals($prevActivitiesarrayCount, $newActivitiesArray);
$then->delete(true);
$else->delete(true);
$activity3->delete(true);
$activity4->delete(true);
$activity5->delete(true);
$activity6->delete(true);
$transitionRule->delete(true);
$connector1->delete(true);
$connector2->delete(true);
$connector3->delete(true);
$connector4->delete(true);
}
/**
* Short description of method delete
*
* @access public
* @author Joel Bout, <*****@*****.**>
* @param Resource activity
* @return boolean
*/
public function delete(core_kernel_classes_Resource $activity)
{
$returnValue = (bool) false;
$connectorService = wfAuthoring_models_classes_ConnectorService::singleton();
$interactiveServiceService = wfEngine_models_classes_InteractiveServiceService::singleton();
$connectorClass = new core_kernel_classes_Class(CLASS_CONNECTORS);
$connectors = $connectorClass->searchInstances(array(PROPERTY_CONNECTORS_ACTIVITYREFERENCE => $activity->getUri()), array('like' => false, 'recursive' => 0));
foreach ($connectors as $connector) {
$connectorService->delete($connector);
}
//deleting resource "acitivty" with its references should be enough normally to remove all references... to be tested
//delete call of service!!
foreach ($this->getInteractiveServices($activity) as $service) {
$interactiveServiceService->deleteInteractiveService($service);
}
//delete referenced actiivty cardinality resources:
$activityCardinalityClass = new core_kernel_classes_Class(CLASS_ACTIVITYCARDINALITY);
$cardinalities = $activityCardinalityClass->searchInstances(array(PROPERTY_STEP_NEXT => $activity->getUri()), array('like' => false));
foreach ($cardinalities as $cardinality) {
$cardinality->delete(true);
}
//delete activity itself:
$returnValue = $activity->delete(true);
return (bool) $returnValue;
}
