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)); }