public function testExecutes_ForkCrossProject_ActionWithForkRepositoriesView()
{
$groupId = 101;
$toProjectId = 100;
$toProject = new MockProject();
$toProject->setReturnValue('getId', $toProjectId);
$repo = new GitRepository();
$repos = array($repo);
$repo_ids = array(200);
$user = new MockUser();
$user->setReturnValue('isMember', true);
$usermanager = new MockUserManager();
$usermanager->setReturnValue('getCurrentUser', $user);
$projectManager = new MockProjectManager();
$projectManager->setReturnValue('getProject', $toProject, array($toProjectId));
$repositoryFactory = new MockGitRepositoryFactory();
$repositoryFactory->setReturnValue('getRepositoryById', $repo, array($repo_ids[0]));
$request = new Codendi_Request(array('choose_destination' => 'project', 'to_project' => $toProjectId, 'repos' => $repo_ids));
$git = TestHelper::getPartialMock('Git', array('definePermittedActions', '_informAboutPendingEvents', 'addAction', 'addView', 'checkSynchronizerToken'));
$git->setGroupId($groupId);
$git->setRequest($request);
$git->setUserManager($usermanager);
$git->setProjectManager($projectManager);
$git->setFactory($repositoryFactory);
$git->expectCallCount('addAction', 2);
$git->expectAt(0, 'addAction', array('fork', array($repos, $toProject, '', GitRepository::REPO_SCOPE_PROJECT, $user, $GLOBALS['HTML'], '/plugins/git/?group_id=100')));
$git->expectAt(1, 'addAction', array('getProjectRepositoryList', array($groupId)));
$git->expectOnce('addView', array('forkRepositories'));
$git->_dispatchActionAndView('do_fork_repositories', null, null, $user);
}
function testStoreEventsDoNotOverrideUsers()
{
$listeningUsers = new ArrayIterator(array(array('user_id' => 1, 'object_id' => 1), array('user_id' => 2, 'object_id' => 1), array('user_id' => 3, 'object_id' => 1)));
$user1 = mock('PFUser');
$user1->setReturnValue('getId', 1);
$user2 = mock('PFUser');
$user2->setReturnValue('getId', 2);
$user3 = mock('PFUser');
$user3->setReturnValue('getId', 3);
$um = new MockUserManager();
$um->setReturnValueAt(0, 'getUserById', $user1);
$um->setReturnValueAt(1, 'getUserById', $user2);
$um->setReturnValueAt(2, 'getUserById', $user3);
$dpm = new MockDocman_PermissionsManager();
$dpm->setReturnValue('userCanRead', true);
$dpm->setReturnValue('userCanAccess', true);
$item = new MockDocman_Item();
$item->setReturnValue('getId', 1);
$params = array('item' => $item);
$nm = new Docman_NotificationsManager_DeleteTestVersion();
$nm->setReturnValue('_getListeningUsers', $listeningUsers);
$nm->setReturnValue('_getUserManager', $um);
$nm->setReturnValue('_getPermissionsManager', $dpm);
$nm->_listeners = array();
$nm->_storeEvents(1, 'removed', $params);
$this->assertEqual($user1, $nm->_listeners[1]['user']);
$this->assertEqual($user2, $nm->_listeners[2]['user']);
$this->assertEqual($user3, $nm->_listeners[3]['user']);
}
public function testGetUser()
{
$u = new MockUser();
$uh = new MockUserManager();
$uh->setReturnValue('getUserById', $u, array(123));
$bv = new Tracker_FormElement_Field_List_Bind_UsersValueTestVersion();
$bv->setReturnValue('getId', 123);
$bv->setReturnReference('getUserManager', $uh);
$this->assertReference($bv->getUser(), $u);
}
private function GivenAUserManagerThatIsProgrammedToThrow($exception)
{
$adminUser = new MockUser();
$adminUser->setReturnValue('isLoggedIn', true);
$um = new MockUserManager();
$um->setReturnValue('getCurrentUser', $adminUser);
$um->throwOn('loginAs', $exception);
$server = new User_SOAPServer($um);
return new UserManagerAsserter($server, $this);
}
public function setUp()
{
$GLOBALS['Language'] = new MockBaseLanguage($this);
// Mock instanciation
$controller = new MockDocman_SOAPController();
$controller->feedback = new MockFeedback();
$version = new MockDocman_Version();
$version->setReturnValue('getNumber', 0);
$this->itemFactory = new MockDocman_ItemFactory();
$folderFactory = new MockDocman_FolderFactory();
$this->fileStorage = new MockDocman_FileStorage();
// Item MD5 Map: id => md5sum
$this->MD5Map = array(128000 => '99999999999999999999999999999999');
foreach ($this->MD5Map as $itemId => $md5) {
$file = new MockDocman_File();
$file->setReturnValue('getID', $itemId);
$file->setReturnValue('getCurrentVersion', $version);
$this->itemFactory->setReturnValue('getItemFromDb', $file, array($itemId));
$this->itemFactory->setReturnValue('getItemTypeForItem', PLUGIN_DOCMAN_ITEM_TYPE_FILE, array($file));
$this->fileStorage->setReturnValue('getFileMD5sum', $md5);
}
$user = mock('PFUser');
$user->setReturnValue('getId', 9);
$userManager = new MockUserManager();
$userManager->setReturnValue('getUserById', $user);
$userManager->setReturnValue('getUserByUserName', $user);
$userManager->setReturnValue('getCurrentUser', $user);
$controller->setReturnValue('getUser', $user);
$versionFactory = new MockDocman_VersionFactory();
$versionFactory->setReturnValue('getAllVersionForItem', array($version));
$this->lockFactory = new MockDocman_LockFactory();
$this->permissionManager = new MockPermissionsManager();
$this->docmanPermissionsManager = new MockDocman_PermissionsManager();
$this->docmanPermissionsManager->setReturnValue('getLockFactory', $this->lockFactory);
// Partial mock of Docman_SOAPActions
$this->action = new Docman_SOAPActions_Test();
$this->action->setReturnValue('_getItemFactory', $this->itemFactory);
$this->action->setReturnValue('_getFolderFactory', $folderFactory);
$this->action->setReturnValue('_checkOwnerChange', 101, array('*', '*'));
$this->action->setReturnValue('_getUserManagerInstance', $userManager);
$this->action->setReturnValue('_getVersionFactory', $versionFactory);
$this->action->setReturnValue('_getPermissionsManagerInstance', $this->permissionManager);
$this->action->setReturnValue('_getDocmanPermissionsManagerInstance', $this->docmanPermissionsManager);
$this->action->setReturnValue('_getEventManager', new MockEventManager());
$this->action->setReturnValue('_getFileStorage', $this->fileStorage);
$this->action->__construct($controller);
}
function testUpdateShouldUpdateAllProjects()
{
$id = 1002;
$type = LDAP_UserManager::EVENT_UPDATE_LOGIN;
$parameters = '101::102';
$priority = SystemEvent::PRIORITY_MEDIUM;
$status = SystemEvent::STATUS_RUNNING;
$create_date = '';
$process_date = '';
$end_date = '';
$log = '';
$se = TestHelper::getPartialMock('SystemEvent_PLUGIN_LDAP_UPDATE_LOGIN', array('getUserManager', 'getBackendSVN', 'getProject'));
$user1 = new MockUser();
$user1->setReturnValue('getAllProjects', array(201, 202));
$user1->setReturnValue('isActive', true);
$user2 = new MockUser();
$user2->setReturnValue('getAllProjects', array(202, 203));
$user2->setReturnValue('isActive', true);
$um = new MockUserManager();
$um->setReturnValue('getUserById', $user1, array('101'));
$um->setReturnValue('getUserById', $user2, array('102'));
$se->setReturnValue('getUserManager', $um);
$prj1 = new MockProject();
$prj2 = new MockProject();
$prj3 = new MockProject();
$se->setReturnValue('getProject', $prj1, array(201));
$se->setReturnValue('getProject', $prj2, array(202));
$se->setReturnValue('getProject', $prj3, array(203));
$backend = new MockBackendSVN();
$backend->expectCallCount('updateProjectSVNAccessFile', 3);
$backend->expect('updateProjectSVNAccessFile', array($prj1));
$backend->expect('updateProjectSVNAccessFile', array($prj2));
$backend->expect('updateProjectSVNAccessFile', array($prj3));
$se->setReturnValue('getBackendSVN', $backend);
$se->__construct($id, $type, $parameters, $priority, $status, $create_date, $process_date, $end_date, $log);
$se->process();
}
function testValidNamesAreValid()
{
$um = new MockUserManager($this);
$um->setReturnValue('getUserByUserName', null);
$pm = new MockProjectManager($this);
$pm->setReturnValue('getProjectByUnixName', null);
$backend = new MockBackend($this);
$backend->setReturnValue('unixUserExists', false);
$backend->setReturnValue('unixGroupExists', false);
$sm = new MockSystemEventManager($this);
$sm->setReturnValue('isUserNameAvailable', true);
$sm->setReturnValue('isProjectNameAvailable', true);
$r = new Rule_ProjectNameIntegration($this);
$r->setReturnValue('_getUserManager', $um);
$r->setReturnValue('_getProjectManager', $pm);
$r->setReturnValue('_getBackend', $backend);
$r->setReturnValue('_getSystemEventManager', $sm);
$r->setReturnValue('isNameAvailable', true, array("group-test"));
$r->setReturnValue('isNameAvailable', true, array("test"));
$r->setReturnValue('isNameAvailable', true, array("test1"));
$this->assertTrue($r->isValid("group-test"));
$this->assertTrue($r->isValid("test"));
$this->assertTrue($r->isValid("test1"));
}
function testInternalCachingByUserName()
{
$dao = new MockUserDao($this);
$dar = new MockDataAccessResult($this);
$dao->setReturnReference('searchByUserName', $dar);
$dar->setReturnValueAt(0, 'getRow', array('user_name' => 'user_name', 'realname' => 'realname', 'user_id' => 123));
$dar->setReturnValueAt(1, 'getRow', false);
$dao->expectNever('searchByUserId', 'User should be cached');
$um = new MockUserManager();
$um->setReturnValue('isUserLoadedById', false, array(123));
$um->setReturnValue('isUserLoadedByUserName', false, array('user_name'));
$um->expectNever('getUserById');
$um->expectNever('getUserByUserName');
$uh = new UserHelperTestVersion($this);
$uh->setReturnValue('_getUserManager', $um);
$uh->setReturnValue('_isUserNameNone', false);
$uh->setReturnValue('_getCurrentUserUsernameDisplayPreference', 1);
$uh->setReturnReference('_getUserDao', $dao);
$uh->__construct();
$this->assertEqual("user_name (realname)", $uh->getDisplayNameFromUserName('user_name'));
$this->assertEqual("user_name (realname)", $uh->getDisplayNameFromUserId(123));
}
private function buildChangeSet($user)
{
$uh = new MockUserHelper();
$tracker = new MockTracker();
$a = new MockTracker_Artifact();
stub($a)->getId()->returns(111);
$a->setReturnValue('getTracker', $tracker);
$um = new MockUserManager();
$um->setReturnValue('getUserById', $user);
$languageFactory = new MockBaseLanguageFactory();
$changeset = TestHelper::getPartialMock('Tracker_Artifact_Changeset', array('getUserHelper', 'getUserManager', 'getArtifact', 'getComment', 'getLanguageFactory', 'getUserFromRecipientName', 'getRecipientFactory', 'getTrackerPluginConfig'));
$changeset->setReturnValue('getUserHelper', $uh);
$changeset->setReturnValue('getUserManager', $um);
$changeset->setReturnValue('getArtifact', $a);
$changeset->setReturnValue('getLanguageFactory', $languageFactory);
$changeset->setReturnValue('getRecipientFactory', $this->recipient_factory);
return $changeset;
}
function testRestoreDeletedItemFileWithSomeVersionRestoreFailure()
{
$itemFactory = new Docman_ItemFactoryTestRestore($this);
$item = new MockDocman_File($this);
$item->setReturnValue('getId', 112);
$item->setReturnValue('getGroupId', 114);
$itemFactory->setReturnValue('getItemTypeForItem', PLUGIN_DOCMAN_ITEM_TYPE_FILE);
$dao = new MockDocman_ItemDao($this);
$dao->expectOnce('restore', array(112));
$dao->setReturnValue('restore', true);
$itemFactory->setReturnValue('_getItemDao', $dao);
$v1 = new MockDocman_Version($this);
$v2 = new MockDocman_Version($this);
$versionFactory = new MockDocman_VersionFactory($this);
$versionFactory->expectOnce('listVersionsToPurgeForItem', array($item));
$versionFactory->setReturnValue('listVersionsToPurgeForItem', array($v1, $v2));
$versionFactory->expectAt(0, 'restore', array($v1));
$versionFactory->setReturnValueAt(0, 'restore', true);
$versionFactory->expectAt(1, 'restore', array($v2));
$versionFactory->setReturnValueAt(1, 'restore', false);
$itemFactory->setReturnValue('_getVersionFactory', $versionFactory);
// Event
$user = new MockUser($this);
$um = new MockUserManager($this);
$um->setReturnValue('getCurrentUser', $user);
$itemFactory->setReturnValue('_getUserManager', $um);
$em = new MockEventManager($this);
$em->expectOnce('processEvent', array('plugin_docman_event_restore', array('group_id' => 114, 'item' => $item, 'user' => $user)));
$itemFactory->setReturnValue('_getEventManager', $em);
$this->assertTrue($itemFactory->restore($item));
}
function testUserNameExists()
{
$u = mock('PFUser');
$um = new MockUserManager($this);
$um->setReturnValue('getUserByUserName', $u, array("usertest"));
$r = new Rule_UserNameTestVersion($this);
$r->setReturnValue('_getUserManager', $um);
$this->assertTrue($r->isAlreadyUserName("usertest"));
}
public function testLogGitPushSuccess()
{
$user = new MockUser();
$user->setReturnValue('getId', 2);
$um = new MockUserManager();
$um->setReturnValue('getUserByIdentifier', $user);
$repo = new GitRepositoryTestVersion();
$repo->setReturnValue('_getUserManager', $um);
$dao = new MockGitDao();
$dao->setReturnValue('logGitPush', true);
$repo->setReturnValue('getDao', $dao);
$this->assertTrue($repo->logGitPush('repo', 'user', 'prj', 1327577111, 3));
$repo->expectOnce('_getUserManager');
$um->expectOnce('getUserByIdentifier');
$user->expectOnce('getId');
$dao->expectOnce('logGitPush');
}
function testGetCommentators()
{
$c1 = new MockTracker_Artifact_Changeset();
$c2 = new MockTracker_Artifact_Changeset();
$c3 = new MockTracker_Artifact_Changeset();
$c4 = new MockTracker_Artifact_Changeset();
$u1 = mock('PFUser');
$u1->setReturnValue('getUserName', 'sandrae');
$u2 = mock('PFUser');
$u2->setReturnValue('getUserName', 'marc');
$um = new MockUserManager();
$um->setReturnReference('getUserById', $u1, array(101));
$um->setReturnReference('getUserById', $u2, array(102));
$artifact = new Tracker_ArtifactTestVersion();
$artifact->setReturnValue('getChangesets', array($c1, $c2, $c3, $c4));
$artifact->setReturnValue('getUserManager', $um);
$c1->setReturnValue('getSubmittedBy', 101);
$c2->setReturnValue('getSubmittedBy', 102);
$c2->setReturnValue('getEmail', '*****@*****.**');
$c3->setReturnValue('getSubmittedBy', null);
$c3->setReturnValue('getEmail', '*****@*****.**');
$c4->setReturnValue('getSubmittedBy', null);
$c4->setReturnValue('getEmail', '');
$this->assertEqual($artifact->getCommentators(), array('sandrae', 'marc', '*****@*****.**'));
}
function testUgroupCountProjectAdminsMixed()
{
$this->skipUnless(MOCKFUNCTION_AVAILABLE, "Function mocking not available");
if (MOCKFUNCTION_AVAILABLE) {
MockFunction::setReturnValueAt(0, 'db_fetch_array', array('user_id' => 1));
MockFunction::setReturnValueAt(1, 'db_fetch_array', array('user_id' => 2));
MockFunction::setReturnValueAt(2, 'db_fetch_array', null);
MockFunction::expectCallCount('db_fetch_array', 3);
$user = new MockUser();
$user->setReturnValueAt(0, 'isMember', true);
$user->setReturnValueAt(1, 'isMember', false);
$user->expectCallCount('isMeMber', 2);
$um = new MockUserManager();
$um->setReturnValue('getUserById', $user);
MockFunction::setReturnValue('ugroup_get_user_manager', $um);
$result = ugroup_count_project_admins(1, '');
$this->assertEqual(1, $result['admins']);
$this->assertEqual(1, $result['non_admins']);
}
}
private function buildChangeSet($user)
{
$uh = new MockUserHelper();
$tracker = new MockTracker();
$a = new MockTracker_Artifact();
$a->setReturnValue('getTracker', $tracker);
$um = new MockUserManager();
$um->setReturnValue('getUserById', $user);
$languageFactory = new MockBaseLanguageFactory();
$changeset = TestHelper::getPartialMock('Tracker_Artifact_Changeset', array('getUserHelper', 'getUserManager', 'getArtifact', 'getComment', 'getLanguageFactory'));
$changeset->setReturnValue('getUserHelper', $uh);
$changeset->setReturnValue('getUserManager', $um);
$changeset->setReturnValue('getArtifact', $a);
$changeset->setReturnValue('getLanguageFactory', $languageFactory);
return $changeset;
}
function testArchiveUserHome()
{
// We use codendiadm uid/gid to avoid chown warnings (because test is not run as root)
$user = aUser()->withUserName('codendiadm')->build();
$backend = new BackendTestVersion();
$backend->createUserHome($user);
$this->assertTrue(is_dir($GLOBALS['homedir_prefix'] . "/codendiadm"), "Home dir should be created");
//
// Run test
//
$um = new MockUserManager();
$um->setReturnReference('getUserById', $user, array(104));
$backend->setReturnValue('getUserManager', $um);
$this->assertEqual($backend->archiveUserHome(104), True);
$this->assertFalse(is_dir($GLOBALS['homedir_prefix'] . "/codendiadm"), "Home dir should be deleted");
$this->assertTrue(is_file(ForgeConfig::get('sys_project_backup_path') . "/codendiadm.tgz"), "Archive should be created");
// Cleanup
unlink(ForgeConfig::get('sys_project_backup_path') . "/codendiadm.tgz");
}
function testMereMortalCannotCreate()
{
// Setup test
$frspf = new FRSPackageFactoryTestVersion($this);
$user = mock('PFUser');
$um = new MockUserManager($this);
$um->setReturnValue('getUserById', $user);
$frspf->setReturnValue('getUserManager', $um);
$this->assertFalse($frspf->userCanCreate($this->group_id, $this->user_id));
}
function testUserCanViewTrackerAccessSubmitterOrAssignee()
{
$ugroup_ass = 101;
$ugroup_sub = 102;
// $assignee and $u_ass are in the same ugroup (UgroupAss - ugroup_id=101)
// $submitter and $u_sub are in the same ugroup (UgroupSub - ugroup_id=102)
// $other and $u are neither in UgroupAss nor in UgroupSub
//
$u = new MockUser();
$u->setReturnValue('getId', 120);
$u->setReturnValue('isMemberOfUgroup', false);
$u->setReturnValue('isSuperUser', false);
//
$assignee = new MockUser();
$assignee->setReturnValue('getId', 121);
$assignee->setReturnValue('isMemberOfUgroup', true, array(101, 222));
$assignee->setReturnValue('isMemberOfUgroup', false, array(102, 222));
$assignee->setReturnValue('isSuperUser', false);
//
$u_ass = new MockUser();
$u_ass->setReturnValue('getId', 122);
$u_ass->setReturnValue('isMemberOfUgroup', true, array(101, 222));
$u_ass->setReturnValue('isMemberOfUgroup', false, array(102, 222));
$u_ass->setReturnValue('isSuperUser', false);
//
$submitter = new MockUser();
$submitter->setReturnValue('getId', 123);
$submitter->setReturnValue('isMemberOfUgroup', false, array(101, 222));
$submitter->setReturnValue('isMemberOfUgroup', true, array(102, 222));
$submitter->setReturnValue('isSuperUser', false);
//
$u_sub = new MockUser();
$u_sub->setReturnValue('getId', 124);
$u_sub->setReturnValue('isMemberOfUgroup', false, array(101, 222));
$u_sub->setReturnValue('isMemberOfUgroup', true, array(102, 222));
$u_sub->setReturnValue('isSuperUser', false);
//
$other = new MockUser();
$other->setReturnValue('getId', 125);
$other->setReturnValue('isMemberOfUgroup', false);
$other->setReturnValue('isSuperUser', false);
$user_manager = new MockUserManager();
$user_manager->setReturnReference('getUserById', $u, array(120));
$user_manager->setReturnReference('getUserById', $assignee, array(121));
$user_manager->setReturnReference('getUserById', $u_ass, array(122));
$user_manager->setReturnReference('getUserById', $submitter, array(123));
$user_manager->setReturnReference('getUserById', $u_sub, array(124));
$user_manager->setReturnReference('getUserById', $other, array(125));
// $artifact_subass has been submitted by $submitter and assigned to $assignee
// $assignee, $u_ass, $submitter, $u_sub should have the right to see it.
// $other and $u should not have the right to see it
$tracker = new MockTracker();
$tracker->setReturnValue('getId', 666);
$tracker->setReturnValue('getGroupId', 222);
$perms_tracker_access_full = array();
$perms_tracker_access_assignee = array(array('ugroup_id' => $ugroup_ass));
$perms_tracker_access_submitter = array(array('ugroup_id' => $ugroup_sub));
$tracker->setReturnReference('permission_db_authorized_ugroups', $perms_tracker_access_full, array('PLUGIN_TRACKER_ACCESS_FULL'));
$tracker->setReturnReference('permission_db_authorized_ugroups', $perms_tracker_access_assignee, array('PLUGIN_TRACKER_ACCESS_ASSIGNEE'));
$tracker->setReturnReference('permission_db_authorized_ugroups', $perms_tracker_access_submitter, array('PLUGIN_TRACKER_ACCESS_SUBMITTER'));
$contributor_field = new MockTracker_FormElement_Field();
$tracker->setReturnReference('getContributorField', $contributor_field);
$artifact_subass = new Tracker_ArtifactTestPermissions();
$artifact_subass->setReturnReference('getUserManager', $user_manager);
$artifact_subass->setReturnReference('getTracker', $tracker);
$artifact_subass->setReturnValue('useArtifactPermissions', false);
$artifact_subass->setReturnValue('getSubmittedBy', 123);
$user_changeset_value = new MockTracker_Artifact_ChangesetValue();
$contributors = array(121);
$user_changeset_value->setReturnReference('getValue', $contributors);
$artifact_subass->setReturnReference('getValue', $user_changeset_value, array($contributor_field));
$this->assertTrue($artifact_subass->userCanView($submitter));
$this->assertTrue($artifact_subass->userCanView($u_sub));
$this->assertTrue($artifact_subass->userCanView($assignee));
$this->assertTrue($artifact_subass->userCanView($u_ass));
$this->assertFalse($artifact_subass->userCanView($other));
$this->assertFalse($artifact_subass->userCanView($u));
}
function testGetMailPrefsShouldReturnHTMLUsersWhithAnonymous()
{
$mm = TestHelper::getPartialMock('MailManager', array('getUserManager', 'getConfig'));
$um = new MockUserManager();
$um->setReturnValue('getAllUsersByEmail', array());
$mm->setReturnValue('getUserManager', $um);
$mm->setReturnValue('getConfig', 'fr_BE');
$prefs = $mm->getMailPreferencesByEmail(array('*****@*****.**'));
$this->assertEqual($prefs['text'], array());
$this->assertEqual(count($prefs['html']), 1);
$this->assertEqual($prefs['html'][0]->getEmail(), '*****@*****.**');
$this->assertEqual($prefs['html'][0]->isAnonymous(), true);
$this->assertEqual($prefs['html'][0]->getLanguageID(), 'fr_BE');
}
function testRestoreOneVersion()
{
$filePath = dirname(__FILE__) . '/_fixtures/version.test';
touch($filePath);
$versionFactory = new Docman_VersionFactoryTestVersion($this);
$dao = new MockDocman_VersionDao($this);
$versionFactory->setReturnValue('_getVersionDao', $dao);
$dar = new MockDataAccessResult($this);
$dar->setReturnValue('isError', false);
$dar->setReturnValue('getRow', array('purge_date' => null, 'label' => 'Ho hisse la saucisse', 'path' => $filePath));
$dao->expectOnce('searchDeletedVersion', array(1664, 2));
$dao->setReturnValue('searchDeletedVersion', $dar);
$file = new MockDocman_File($this);
$file->setReturnValue('getGroupId', 114);
$if = new MockDocman_ItemFactory($this);
$if->expectOnce('getItemFromDb', array(1664, array('ignore_deleted' => true)));
$if->setReturnValue('getItemFromDb', $file);
$versionFactory->setReturnValue('_getItemFactory', $if);
$user = new MockUser($this);
$um = new MockUserManager($this);
$um->setReturnValue('getCurrentUser', $user);
$versionFactory->setReturnValue('_getUserManager', $um);
$em = new MockEventManager($this);
$em->expectOnce('processEvent', array('plugin_docman_event_restore_version', array('group_id' => 114, 'item' => $file, 'old_value' => '2 (Ho hisse la saucisse)', 'user' => $user)));
$versionFactory->setReturnValue('_getEventManager', $em);
$dao->expectOnce('restore', array(1664, 2));
$dao->setReturnValue('restore', true);
$version = new MockDocman_Version($this);
$version->setReturnValue('getNumber', 2);
$version->setReturnValue('getItemId', 1664);
$this->assertTrue($versionFactory->restore($version));
unlink($filePath);
}
function testUserInSecondBranch()
{
$sync = new LDAP_DirectorySynchronizationTestVersion($this);
$res = new MockLDAPResult($this);
$res->setReturnValue('getLogin', 'mis_1234');
$lri = new MockLDAPResultIterator($this);
$lri->setReturnValue('count', 1);
$lri->setReturnValueAt(0, 'valid', true);
$lri->setReturnValueAt(1, 'valid', false);
$lri->setReturnReference('current', $res);
$ldap = new MockInhLDAP($this);
$ldap->setReturnValue('getErrno', LDAP::ERR_SUCCESS);
$param1 = 'ou=People,dc=st,dc=com ';
$param2 = ' ou=Intranet,dc=st,dc=com ';
$ldap->setReturnValueAt(0, 'search', false);
$ldap->setReturnValueAt(1, 'search', $lri);
$ldap->setReturnValueAt(2, 'search', false);
$ldap->expectCallCount('search', 2);
$ldap->setReturnValue('getLDAPParam', 'ou=People,dc=st,dc=com ; ou=Intranet,dc=st,dc=com ; ou=Extranet,dc=st,dc=com');
$sync->__construct($ldap, mock('TruncateLevelLogger'));
$um = new MockUserManager($this);
$um->expectNever('updateDb');
$sync->setReturnValue('getUserManager', $um);
$lum = new MockLDAP_UserManager($this);
$lum->expectNever('updateLdapUid');
$sync->setReturnValue('getLdapUserManager', $lum);
$lus = new MockLDAP_UserSync($this);
$lus->setReturnValue('sync', false);
$lus->expectOnce('sync');
$sync->setReturnValue('getLdapUserSync', $lus);
$syncReminderManager = new MockLDAP_SyncReminderNotificationManager($this);
$sync->setReturnValue('getLdapSyncReminderNotificationManager', $syncReminderManager);
$row = array('user_id' => '4321', 'ldap_id' => 'ed1234', 'ldap_uid' => 'mis_1234');
$sync->ldapSync($row, 1);
}
function testCheckRestrictedAccessUserIsMember()
{
$GLOBALS['sys_allow_restricted_users'] = 1;
$pm = new ProjectManagerTestVersion();
$um = new MockUserManager();
$user = new MockUser();
$user->setReturnValue('isRestricted', true);
$um->setReturnValue('getCurrentUser', $user);
$pm->setReturnValue('_getUserManager', $um);
$project = new MockProject();
$project->setReturnValue('userIsMember', true);
$this->assertTrue($pm->checkRestrictedAccess($project));
$pm->expectOnce('_getUserManager');
}
function testRestoreFileDBUpdateFails()
{
$fileFactory = new FRSFileFactoryTestRestore();
// Create temp file
$filepath = dirname(__FILE__) . '/_fixtures/DELETED/prj/p3_r1/toto.xls.12';
mkdir(dirname($filepath), 0750, true);
touch($filepath);
$this->assertTrue(is_dir(dirname($filepath)));
$file = new MockFRSFile($this);
$file->setReturnValue('getFileID', 12);
$file->setReturnValue('getFileName', 'p3_r1/toto.xls');
$file->setReturnValue('getFileLocation', $GLOBALS['ftp_frs_dir_prefix'] . '/prj/p3_r1/toto.xls');
$project = new MockProject($this);
$file->setReturnValue('getGroup', $project);
$this->assertTrue(is_dir(dirname($GLOBALS['ftp_frs_dir_prefix'] . '/prj/p3_r1/')));
$dao = new MockFRSFileDao($this);
$dao->expectOnce('restoreFile');
$dao->setReturnValue('restoreFile', false);
$fileFactory->setReturnValue('_getFRSFileDao', $dao);
$backend = new MockBackendSystem($this);
$backend->setReturnValue('chgrp', true);
$user = new MockUser($this);
$um = new MockUserManager($this);
$um->setReturnValue('getCurrentUser', $user);
$fileFactory->setReturnValue('_getUserManager', $um);
$em = new MockEventManager($this);
$fileFactory->setReturnValue('_getEventManager', $em);
$release = new MockFRSRelease($this);
$release->setReturnValue('isDeleted', false);
$releaseFactory = new MockFRSReleaseFactory($this);
$releaseFactory->setReturnValue('getFRSReleaseFromDb', $release);
$fileFactory->setReturnValue('_getFRSReleaseFactory', $releaseFactory);
$this->assertFalse($fileFactory->restoreFile($file, $backend));
// Cleanup
rmdir($GLOBALS['ftp_frs_dir_prefix'] . '/DELETED/prj/p3_r1');
rmdir($GLOBALS['ftp_frs_dir_prefix'] . '/DELETED/prj');
unlink($GLOBALS['ftp_frs_dir_prefix'] . '/prj/p3_r1/toto.xls');
rmdir($GLOBALS['ftp_frs_dir_prefix'] . '/prj/p3_r1');
}
function testSendMailToSDFailure()
{
$um = new MockUserManager();
$user = mock('PFUser');
$um->setReturnValue('getCurrentUser', $user);
$validParams = array('ticket_id' => 'QA0000000000001', 'summary' => 'valid summary', 'description' => 'valid description', 'type' => 1, 'text_type' => 'ASSISTANCE REQUEST', 'severity' => 1, 'text_severity' => 'Minor', 'cc' => '*****@*****.**');
$GLOBALS['Language']->setReturnValue('getText', 'Generic subject to SD', array('plugin_requesthelp', 'requesthelp_mail_subject', array('Minor', 'valid summary')));
$requesthelp_user_mail_content = 'this is fake body';
$requesthelp_mail_content = 'this is fake body';
$requesthelp_Failure_mail_content = 'this is fake body';
$pm = new MockPluginManager();
$p = new MockProperties();
$pm->setReturnValue('getPluginByName', $p);
$p->setReturnValue('getProperty', '*****@*****.**');
$actions = new RequestHelpActionsTestVersion3();
$actions->setReturnValue('_getUserManager', $um);
$actions->setReturnValue('_getPluginManager', $pm);
$mail = new MockCodendi_Mail();
$mail->expect('setTo', array('*****@*****.**'));
$mail->expect('setSubject', array('Generic subject to SD'));
$mail->expectOnce('setBodyHtml');
$mail->setReturnValue('send', false);
$actions->setReturnValue('_getCodendiMail', $mail);
$this->assertFalse($actions->sendMail($validParams));
}
