From 0a93d4eccf405f7145694a21c4412ba213b50a4a Mon Sep 17 00:00:00 2001 From: Robin Appelman Date: Thu, 22 Mar 2012 19:54:24 +0100 Subject: loosen tests for mtime and ctime a bit --- tests/lib/filestorage.php | 18 ++++++++++-------- 1 file changed, 10 insertions(+), 8 deletions(-) (limited to 'tests') diff --git a/tests/lib/filestorage.php b/tests/lib/filestorage.php index 9ffa0eca9cb..4858234a2d8 100644 --- a/tests/lib/filestorage.php +++ b/tests/lib/filestorage.php @@ -135,10 +135,12 @@ abstract class Test_FileStorage extends UnitTestCase { $ctimeEnd=time(); $cTime=$this->instance->filectime('/lorem.txt'); $mTime=$this->instance->filemtime('/lorem.txt'); - $this->assertTrue($ctimeStart<=$cTime); - $this->assertTrue($cTime<=$ctimeEnd); - $this->assertTrue($ctimeStart<=$mTime); - $this->assertTrue($mTime<=$ctimeEnd); + if($cTime!=-1){//not everything can support ctime + $this->assertTrue(($ctimeStart-1)<=$cTime); + $this->assertTrue($cTime<=($ctimeEnd+1)); + } + $this->assertTrue(($ctimeStart-1)<=$mTime); + $this->assertTrue($mTime<=($ctimeEnd+1)); $this->assertEqual(filesize($textFile),$this->instance->filesize('/lorem.txt')); $stat=$this->instance->stat('/lorem.txt'); @@ -153,8 +155,8 @@ abstract class Test_FileStorage extends UnitTestCase { $originalCTime=$cTime; $cTime=$this->instance->filectime('/lorem.txt'); $mTime=$this->instance->filemtime('/lorem.txt'); - $this->assertTrue($mtimeStart<=$mTime); - $this->assertTrue($mTime<=$mtimeEnd); + $this->assertTrue(($mtimeStart-1)<=$mTime); + $this->assertTrue($mTime<=($mtimeEnd+1)); $this->assertEqual($cTime,$originalCTime); if($this->instance->touch('/lorem.txt',100)!==false){ @@ -170,8 +172,8 @@ abstract class Test_FileStorage extends UnitTestCase { $mtimeEnd=time(); $originalCTime=$cTime; $mTime=$this->instance->filemtime('/lorem.txt'); - $this->assertTrue($mtimeStart<=$mTime); - $this->assertTrue($mTime<=$mtimeEnd); + $this->assertTrue(($mtimeStart-1)<=$mTime); + $this->assertTrue($mTime<=($mtimeEnd+1)); } public function testSearch(){ -- cgit v1.2.3 From f42897344fd938edcdc955c0dd0094391f5df18a Mon Sep 17 00:00:00 2001 From: Robin Appelman Date: Wed, 28 Mar 2012 16:26:23 +0200 Subject: allow running a single test or group of tests --- tests/index.php | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) (limited to 'tests') diff --git a/tests/index.php b/tests/index.php index 2e86366740b..a6f678b3bc2 100644 --- a/tests/index.php +++ b/tests/index.php @@ -38,6 +38,7 @@ foreach($apps as $app){ } function loadTests($dir=''){ + $test=isset($_GET['test'])?$_GET['test']:false; if($dh=opendir($dir)){ while($name=readdir($dh)){ if(substr($name,0,1)!='.'){//no hidden files, '.' or '..' @@ -45,10 +46,13 @@ function loadTests($dir=''){ if(is_dir($file)){ loadTests($file); }elseif(substr($file,-4)=='.php' and $file!=__FILE__){ - $testCase=new TestSuite(getTestName($file)); - $testCase->addFile($file); - if($testCase->getSize()>0){ - $testCase->run(new HtmlReporter()); + $name=getTestName($file); + if($test===false or $test==$name or substr($name,0,strlen($test))==$test){ + $testCase=new TestSuite($name); + $testCase->addFile($file); + if($testCase->getSize()>0){ + $testCase->run(new HtmlReporter()); + } } } } -- cgit v1.2.3 From 0466437fa7878fa1681ee01651d7d41cdef7454a Mon Sep 17 00:00:00 2001 From: Robin Appelman Date: Thu, 12 Apr 2012 15:55:56 +0200 Subject: tests for oc_filesystem --- lib/filesystem.php | 8 ++++++ tests/lib/filestorage/local.php | 5 +--- tests/lib/filesystem.php | 64 +++++++++++++++++++++++++++++++++++++++++ 3 files changed, 73 insertions(+), 4 deletions(-) create mode 100644 tests/lib/filesystem.php (limited to 'tests') diff --git a/lib/filesystem.php b/lib/filesystem.php index b6909f5acdf..dc678fba74c 100644 --- a/lib/filesystem.php +++ b/lib/filesystem.php @@ -248,6 +248,14 @@ class OC_Filesystem{ return self::$defaultInstance->getRoot(); } + /** + * clear all mounts and storage backends + */ + public static function clearMounts(){ + self::$mounts=array(); + self::$storages=array(); + } + /** * mount an OC_Filestorage in our virtual filesystem * @param OC_Filestorage storage diff --git a/tests/lib/filestorage/local.php b/tests/lib/filestorage/local.php index 0a2d46c5ebc..692f05f9fca 100644 --- a/tests/lib/filestorage/local.php +++ b/tests/lib/filestorage/local.php @@ -26,10 +26,7 @@ class Test_Filestorage_Local extends Test_FileStorage { */ private $tmpDir; public function setUp(){ - $this->tmpDir=get_temp_dir().'/filestoragelocal'; - if(!file_exists($this->tmpDir)){ - mkdir($this->tmpDir); - } + $this->tmpDir=OC_Helper::tmpFolder(); $this->instance=new OC_Filestorage_Local(array('datadir'=>$this->tmpDir)); } diff --git a/tests/lib/filesystem.php b/tests/lib/filesystem.php new file mode 100644 index 00000000000..3e28d8c06e5 --- /dev/null +++ b/tests/lib/filesystem.php @@ -0,0 +1,64 @@ +. +* +*/ + +class Test_Filesystem extends UnitTestCase{ + /** + * @var array tmpDirs + */ + private $tmpDirs; + + /** + * @return array + */ + private function getStorageData(){ + $dir=OC_Helper::tmpFolder(); + $this->tmpDirs[]=$dir; + return array('datadir'=>$dir); + } + + public function tearDown(){ + foreach($this->tmpDirs as $dir){ + OC_Helper::rmdirr($dir); + } + } + + public function setUp(){ + OC_Filesystem::clearMounts(); + } + + public function testMount(){ + OC_Filesystem::mount('OC_Filestorage_Local',self::getStorageData(),'/'); + $this->assertEqual('/',OC_Filesystem::getMountPoint('/')); + $this->assertEqual('/',OC_Filesystem::getMountPoint('/some/folder')); + $this->assertEqual('',OC_Filesystem::getInternalPath('/')); + $this->assertEqual('some/folder',OC_Filesystem::getInternalPath('/some/folder')); + + OC_Filesystem::mount('OC_Filestorage_Local',self::getStorageData(),'/some'); + $this->assertEqual('/',OC_Filesystem::getMountPoint('/')); + $this->assertEqual('/some/',OC_Filesystem::getMountPoint('/some/folder')); + $this->assertEqual('/some/',OC_Filesystem::getMountPoint('/some/')); + $this->assertEqual('/',OC_Filesystem::getMountPoint('/some')); + $this->assertEqual('folder',OC_Filesystem::getInternalPath('/some/folder')); + } +} + +?> \ No newline at end of file -- cgit v1.2.3 From 1d8fdf52d52f4a73cb0a59b5d2c3a088ae1e9247 Mon Sep 17 00:00:00 2001 From: Robin Appelman Date: Fri, 13 Apr 2012 01:58:53 +0200 Subject: allow multiply group backends --- lib/base.php | 2 +- lib/group.php | 161 ++++++++++++++++++++++++------------------- lib/group/backend.php | 119 ++++++++++++++------------------ lib/group/database.php | 4 +- lib/group/dummy.php | 159 ++++++++++++++++++++++++++++++++++++++++++ lib/group/example.php | 102 +++++++++++++++++++++++++++ tests/lib/group.php | 114 ++++++++++++++++++++++++++++++ tests/lib/group/backend.php | 105 ++++++++++++++++++++++++++++ tests/lib/group/database.php | 55 +++++++++++++++ tests/lib/group/dummy.php | 27 ++++++++ 10 files changed, 708 insertions(+), 140 deletions(-) create mode 100644 lib/group/dummy.php create mode 100644 lib/group/example.php create mode 100644 tests/lib/group.php create mode 100644 tests/lib/group/backend.php create mode 100644 tests/lib/group/database.php create mode 100644 tests/lib/group/dummy.php (limited to 'tests') diff --git a/lib/base.php b/lib/base.php index 15c90227fec..f3dacdc0f76 100644 --- a/lib/base.php +++ b/lib/base.php @@ -346,7 +346,7 @@ class OC{ OC_User::useBackend( OC_Config::getValue( "userbackend", "database" )); - OC_Group::setBackend( OC_Config::getValue( "groupbackend", "database" )); + OC_Group::useBackend(new OC_Group_Database()); // Set up file system unless forbidden global $RUNTIME_NOSETUPFS; diff --git a/lib/group.php b/lib/group.php index fbff41e30e9..4ae9302f78b 100644 --- a/lib/group.php +++ b/lib/group.php @@ -34,57 +34,25 @@ * post_removeFromGroup(uid, gid) */ class OC_Group { - // The backend used for user management - private static $_backend; - - // Backends available (except database) - private static $_backends = array(); - - /** - * @brief registers backend - * @param $name name of the backend - * @returns true/false - * - * Makes a list of backends that can be used by other modules - */ - public static function registerBackend( $name ){ - self::$_backends[] = $name; - return true; - } - - /** - * @brief gets available backends - * @returns array of backends - * - * Returns the names of all backends. - */ - public static function getBackends(){ - return self::$_backends; - } + // The backend used for group management + private static $_usedBackends = array(); /** * @brief set the group backend * @param string $backend The backend to use for user managment * @returns true/false */ - public static function setBackend( $backend = 'database' ){ - // You'll never know what happens - if( null === $backend OR !is_string( $backend )){ - $backend = 'database'; + public static function useBackend( $backend ){ + if($backend instanceof OC_Group_Backend){ + self::$_usedBackends[]=$backend; } + } - // Load backend - switch( $backend ){ - case 'database': - case 'mysql': - case 'sqlite': - self::$_backend = new OC_Group_Database(); - break; - default: - $className = 'OC_GROUP_' . strToUpper($backend); - self::$_backend = new $className(); - break; - } + /** + * remove all used backends + */ + public static function clearBackends(){ + self::$_usedBackends=array(); } /** @@ -115,11 +83,18 @@ class OC_Group { $run = true; OC_Hook::emit( "OC_Group", "pre_createGroup", array( "run" => &$run, "gid" => $gid )); - if( $run && self::$_backend->createGroup( $gid )){ - OC_Hook::emit( "OC_Group", "post_createGroup", array( "gid" => $gid )); - return true; - } - else{ + if($run){ + //create the user in the first backend that supports creating users + foreach(self::$_usedBackends as $backend){ + if(!$backend->implementsActions(OC_GROUP_BACKEND_CREATE_GROUP)) + continue; + + $backend->createGroup($gid); + OC_Hook::emit( "OC_User", "post_createGroup", array( "gid" => $gid )); + + return true; + } + }else{ return false; } } @@ -140,11 +115,18 @@ class OC_Group { $run = true; OC_Hook::emit( "OC_Group", "pre_deleteGroup", array( "run" => &$run, "gid" => $gid )); - if( $run && self::$_backend->deleteGroup( $gid )){ - OC_Hook::emit( "OC_Group", "post_deleteGroup", array( "gid" => $gid )); - return true; - } - else{ + if($run){ + //delete the group from all backends + foreach(self::$_usedBackends as $backend){ + if(!$backend->implementsActions(OC_GROUP_BACKEND_DELETE_GROUP)) + continue; + + $backend->deleteGroup($gid); + OC_Hook::emit( "OC_User", "post_deleteGroup", array( "gid" => $gid )); + + return true; + } + }else{ return false; } } @@ -158,7 +140,15 @@ class OC_Group { * Checks whether the user is member of a group or not. */ public static function inGroup( $uid, $gid ){ - return self::$_backend->inGroup($uid, $gid); + foreach(self::$_usedBackends as $backend){ + if(!$backend->implementsActions(OC_GROUP_BACKEND_IN_GROUP)) + continue; + + if($backend->inGroup($uid,$gid)){ + return true; + } + } + return false; } /** @@ -170,10 +160,6 @@ class OC_Group { * Adds a user to a group. */ public static function addToGroup( $uid, $gid ){ - // Does the user exist? - if( !OC_User::userExists($uid)){ - return false; - } // Does the group exist? if( !OC_Group::groupExists($gid)){ return false; @@ -183,11 +169,19 @@ class OC_Group { $run = true; OC_Hook::emit( "OC_Group", "pre_addToGroup", array( "run" => &$run, "uid" => $uid, "gid" => $gid )); - if( $run && self::$_backend->addToGroup( $uid, $gid )){ - OC_Hook::emit( "OC_Group", "post_addToGroup", array( "uid" => $uid, "gid" => $gid )); - return true; - } - else{ + if($run){ + $succes=false; + + //add the user to the all backends that have the group + foreach(self::$_usedBackends as $backend){ + if(!$backend->implementsActions(OC_GROUP_BACKEND_ADD_TO_GROUP)) + continue; + + $succes|=$backend->addToGroup($uid, $gid); + OC_Hook::emit( "OC_User", "post_addToGroup", array( "uid" => $uid, "gid" => $gid )); + } + return $succes; + }else{ return false; } } @@ -204,11 +198,17 @@ class OC_Group { $run = true; OC_Hook::emit( "OC_Group", "pre_removeFromGroup", array( "run" => &$run, "uid" => $uid, "gid" => $gid )); - if( $run && self::$_backend->removeFromGroup( $uid, $gid )){ - OC_Hook::emit( "OC_Group", "post_removeFromGroup", array( "uid" => $uid, "gid" => $gid )); + if($run){ + //remove the user from the all backends that have the group + foreach(self::$_usedBackends as $backend){ + if(!$backend->implementsActions(OC_GROUP_BACKEND_REMOVE_FROM_GOUP)) + continue; + + $backend->removeFromGroup($uid, $gid); + OC_Hook::emit( "OC_User", "post_removeFromGroup", array( "uid" => $uid, "gid" => $gid )); + } return true; - } - else{ + }else{ return false; } } @@ -222,7 +222,14 @@ class OC_Group { * if the user exists at all. */ public static function getUserGroups( $uid ){ - return self::$_backend->getUserGroups($uid); + $groups=array(); + foreach(self::$_usedBackends as $backend){ + if(!$backend->implementsActions(OC_GROUP_BACKEND_GET_USER_GROUPS)) + continue; + + $groups=array_merge($backend->getUserGroups($uid),$groups); + } + return $groups; } /** @@ -232,7 +239,14 @@ class OC_Group { * Returns a list with all groups */ public static function getGroups(){ - return self::$_backend->getGroups(); + $groups=array(); + foreach(self::$_usedBackends as $backend){ + if(!$backend->implementsActions(OC_GROUP_BACKEND_GET_GROUPS)) + continue; + + $groups=array_merge($backend->getGroups(),$groups); + } + return $groups; } /** @@ -249,6 +263,13 @@ class OC_Group { * @returns array with user ids */ public static function usersInGroup($gid){ - return self::$_backend->usersInGroup($gid); + $users=array(); + foreach(self::$_usedBackends as $backend){ + if(!$backend->implementsActions(OC_GROUP_BACKEND_GET_USERS)) + continue; + + $users=array_merge($backend->usersInGroup($gid),$users); + } + return $users; } } diff --git a/lib/group/backend.php b/lib/group/backend.php index 43f94e7ea1a..b3fc06ac9a8 100644 --- a/lib/group/backend.php +++ b/lib/group/backend.php @@ -21,82 +21,65 @@ * */ +/** + * error code for functions not provided by the group backend + */ +define('OC_GROUP_BACKEND_NOT_IMPLEMENTED', -501); +/** + * actions that user backends can define + */ +define('OC_GROUP_BACKEND_CREATE_GROUP', 0x00000001); +define('OC_GROUP_BACKEND_DELETE_GROUP', 0x00000010); +define('OC_GROUP_BACKEND_IN_GROUP', 0x00000100); +define('OC_GROUP_BACKEND_ADD_TO_GROUP', 0x00001000); +define('OC_GROUP_BACKEND_REMOVE_FROM_GOUP', 0x00010000); +define('OC_GROUP_BACKEND_GET_USER_GROUPS', 0x00100000); +define('OC_GROUP_BACKEND_GET_USERS', 0x01000000); +define('OC_GROUP_BACKEND_GET_GROUPS', 0x10000000); /** * Abstract base class for user management */ abstract class OC_Group_Backend { + protected $possibleActions = array( + OC_GROUP_BACKEND_CREATE_GROUP => 'createGroup', + OC_GROUP_BACKEND_DELETE_GROUP => 'deleteGroup', + OC_GROUP_BACKEND_IN_GROUP => 'inGroup', + OC_GROUP_BACKEND_ADD_TO_GROUP => 'addToGroup', + OC_GROUP_BACKEND_REMOVE_FROM_GOUP => 'removeFromGroup', + OC_GROUP_BACKEND_GET_USER_GROUPS => 'getUserGroups', + OC_GROUP_BACKEND_GET_USERS => 'usersInGroup', + OC_GROUP_BACKEND_GET_GROUPS => 'getGroups' + ); + /** - * @brief Try to create a new group - * @param $gid The name of the group to create - * @returns true/false - * - * Trys to create a new group. If the group name already exists, false will - * be returned. - */ - public static function createGroup($gid){} - - /** - * @brief delete a group - * @param $gid gid of the group to delete - * @returns true/false - * - * Deletes a group and removes it from the group_user-table - */ - public static function removeGroup($gid){} - - /** - * @brief is user in group? - * @param $uid uid of the user - * @param $gid gid of the group - * @returns true/false - * - * Checks whether the user is member of a group or not. - */ - public static function inGroup($uid, $gid){} - - /** - * @brief Add a user to a group - * @param $uid Name of the user to add to group - * @param $gid Name of the group in which add the user - * @returns true/false - * - * Adds a user to a group. - */ - public static function addToGroup($uid, $gid){} - - /** - * @brief Removes a user from a group - * @param $uid Name of the user to remove from group - * @param $gid Name of the group from which remove the user - * @returns true/false - * - * removes the user from a group. - */ - public static function removeFromGroup($uid,$gid){} - - /** - * @brief Get all groups a user belongs to - * @param $uid Name of the user - * @returns array with group names - * - * This function fetches all groups a user belongs to. It does not check - * if the user exists at all. - */ - public static function getUserGroups($uid){} + * @brief Get all supported actions + * @returns bitwise-or'ed actions + * + * Returns the supported actions as int to be + * compared with OC_USER_BACKEND_CREATE_USER etc. + */ + public function getSupportedActions(){ + $actions = 0; + foreach($this->possibleActions AS $action => $methodName){ + if(method_exists($this, $methodName)) { + $actions |= $action; + } + } - /** - * @brief get a list of all groups - * @returns array with group names - * - * Returns a list with all groups - */ - public static function getGroups(){} + return $actions; + } /** - * @brief get a list of all users in a group - * @returns array with user ids - */ - public static function usersInGroup($gid){} + * @brief Check if backend implements actions + * @param $actions bitwise-or'ed actions + * @returns boolean + * + * Returns the supported actions as int to be + * compared with OC_GROUP_BACKEND_CREATE_GROUP etc. + */ + public function implementsActions($actions){ + return (bool)($this->getSupportedActions() & $actions); + } } diff --git a/lib/group/database.php b/lib/group/database.php index 1afd4b5fe4c..d401acf43b3 100644 --- a/lib/group/database.php +++ b/lib/group/database.php @@ -117,8 +117,10 @@ class OC_Group_Database extends OC_Group_Backend { if( !self::inGroup( $uid, $gid )){ $query = OC_DB::prepare( "INSERT INTO `*PREFIX*group_user` ( `uid`, `gid` ) VALUES( ?, ? )" ); $result = $query->execute( array( $uid, $gid )); + return true; + }else{ + return false; } - return true; } /** diff --git a/lib/group/dummy.php b/lib/group/dummy.php new file mode 100644 index 00000000000..5220237ecbf --- /dev/null +++ b/lib/group/dummy.php @@ -0,0 +1,159 @@ +. +* +*/ + +/** + * dummy group backend, does not keep state, only for testing use + */ +class OC_Group_Dummy extends OC_Group_Backend { + private $groups=array(); + /** + * @brief Try to create a new group + * @param $gid The name of the group to create + * @returns true/false + * + * Trys to create a new group. If the group name already exists, false will + * be returned. + */ + public function createGroup($gid){ + if(!isset($this->groups[$gid])){ + $this->groups[$gid]=array(); + return true; + }else{ + return false; + } + } + + /** + * @brief delete a group + * @param $gid gid of the group to delete + * @returns true/false + * + * Deletes a group and removes it from the group_user-table + */ + public function deleteGroup($gid){ + if(isset($this->groups[$gid])){ + unset($this->groups[$gid]); + return true; + }else{ + return false; + } + } + + /** + * @brief is user in group? + * @param $uid uid of the user + * @param $gid gid of the group + * @returns true/false + * + * Checks whether the user is member of a group or not. + */ + public function inGroup($uid, $gid){ + if(isset($this->groups[$gid])){ + return (array_search($uid,$this->groups[$gid])!==false); + }else{ + return false; + } + } + + /** + * @brief Add a user to a group + * @param $uid Name of the user to add to group + * @param $gid Name of the group in which add the user + * @returns true/false + * + * Adds a user to a group. + */ + public function addToGroup($uid, $gid){ + if(isset($this->groups[$gid])){ + if(array_search($uid,$this->groups[$gid])===false){ + $this->groups[$gid][]=$uid; + return true; + }else{ + return false; + } + }else{ + return false; + } + } + + /** + * @brief Removes a user from a group + * @param $uid NameUSER of the user to remove from group + * @param $gid Name of the group from which remove the user + * @returns true/false + * + * removes the user from a group. + */ + public function removeFromGroup($uid,$gid){ + if(isset($this->groups[$gid])){ + if(($index=array_search($uid,$this->groups[$gid]))!==false){ + unset($this->groups[$gid][$index]); + }else{ + return false; + } + }else{ + return false; + } + } + + /** + * @brief Get all groups a user belongs to + * @param $uid Name of the user + * @returns array with group names + * + * This function fetches all groups a user belongs to. It does not check + * if the user exists at all. + */ + public function getUserGroups($uid){ + $groups=array(); + foreach($this->groups as $group=>$user){ + if($this->inGroup($uid,$group)){ + $groups[]=$group; + } + } + return $groups; + } + + /** + * @brief get a list of all groups + * @returns array with group names + * + * Returns a list with all groups + */ + public function getGroups(){ + return array_keys($this->groups); + } + + /** + * @brief get a list of all users in a group + * @returns array with user ids + */ + public function usersInGroup($gid){ + if(isset($this->groups[$gid])){ + return $this->groups[$gid]; + }else{ + return array(); + } + } + +} diff --git a/lib/group/example.php b/lib/group/example.php new file mode 100644 index 00000000000..a88159f91be --- /dev/null +++ b/lib/group/example.php @@ -0,0 +1,102 @@ +. +* +*/ + +/** + * abstract reference class for group management + * this class should only be used as a reference for method signatures and their descriptions + */ +abstract class OC_Group_Example { + /** + * @brief Try to create a new group + * @param $gid The name of the group to create + * @returns true/false + * + * Trys to create a new group. If the group name already exists, false will + * be returned. + */ + public static function createGroup($gid){} + + /** + * @brief delete a group + * @param $gid gid of the group to delete + * @returns true/false + * + * Deletes a group and removes it from the group_user-table + */ + public static function deleteGroup($gid){} + + /** + * @brief is user in group? + * @param $uid uid of the user + * @param $gid gid of the group + * @returns true/false + * + * Checks whether the user is member of a group or not. + */ + public static function inGroup($uid, $gid){} + + /** + * @brief Add a user to a group + * @param $uid Name of the user to add to group + * @param $gid Name of the group in which add the user + * @returns true/false + * + * Adds a user to a group. + */ + public static function addToGroup($uid, $gid){} + + /** + * @brief Removes a user from a group + * @param $uid NameUSER of the user to remove from group + * @param $gid Name of the group from which remove the user + * @returns true/false + * + * removes the user from a group. + */ + public static function removeFromGroup($uid,$gid){} + + /** + * @brief Get all groups a user belongs to + * @param $uid Name of the user + * @returns array with group names + * + * This function fetches all groups a user belongs to. It does not check + * if the user exists at all. + */ + public static function getUserGroups($uid){} + + /** + * @brief get a list of all groups + * @returns array with group names + * + * Returns a list with all groups + */ + public static function getGroups(){} + + /** + * @brief get a list of all users in a group + * @returns array with user ids + */ + public static function usersInGroup($gid){} + +} diff --git a/tests/lib/group.php b/tests/lib/group.php new file mode 100644 index 00000000000..922613211bc --- /dev/null +++ b/tests/lib/group.php @@ -0,0 +1,114 @@ +. +* +*/ + +class Test_Group extends UnitTestCase { + function setUp(){ + OC_Group::clearBackends(); + } + + function testSingleBackend(){ + OC_Group::useBackend(new OC_Group_Dummy()); + + $group1=uniqid(); + $group2=uniqid(); + OC_Group::createGroup($group1); + OC_Group::createGroup($group2); + + $user1=uniqid(); + $user2=uniqid(); + + $this->assertFalse(OC_Group::inGroup($user1,$group1)); + $this->assertFalse(OC_Group::inGroup($user2,$group1)); + $this->assertFalse(OC_Group::inGroup($user1,$group2)); + $this->assertFalse(OC_Group::inGroup($user2,$group2)); + + $this->assertTrue(OC_Group::addToGroup($user1,$group1)); + + $this->assertTrue(OC_Group::inGroup($user1,$group1)); + $this->assertFalse(OC_Group::inGroup($user2,$group1)); + $this->assertFalse(OC_Group::inGroup($user1,$group2)); + $this->assertFalse(OC_Group::inGroup($user2,$group2)); + + $this->assertFalse(OC_Group::addToGroup($user1,$group1)); + + $this->assertEqual(array($user1),OC_Group::usersInGroup($group1)); + $this->assertEqual(array(),OC_Group::usersInGroup($group2)); + + $this->assertEqual(array($group1),OC_Group::getUserGroups($user1)); + $this->assertEqual(array(),OC_Group::getUserGroups($user2)); + + OC_Group::deleteGroup($group1); + $this->assertEqual(array(),OC_Group::getUserGroups($user1)); + $this->assertEqual(array(),OC_Group::usersInGroup($group1)); + $this->assertFalse(OC_Group::inGroup($user1,$group1)); + } + + function testMultiBackend(){ + $backend1=new OC_Group_Dummy(); + $backend2=new OC_Group_Dummy(); + OC_Group::useBackend($backend1); + OC_Group::useBackend($backend2); + + $group1=uniqid(); + $group2=uniqid(); + OC_Group::createGroup($group1); + + //groups should be added to the first registered backend + $this->assertEqual(array($group1),$backend1->getGroups()); + $this->assertEqual(array(),$backend2->getGroups()); + + $this->assertEqual(array($group1),OC_Group::getGroups()); + $this->assertTrue(OC_Group::groupExists($group1)); + $this->assertFalse(OC_Group::groupExists($group2)); + + $backend1->createGroup($group2); + + $this->assertEqual(array($group1,$group2),OC_Group::getGroups()); + $this->assertTrue(OC_Group::groupExists($group1)); + $this->assertTrue(OC_Group::groupExists($group2)); + + $user1=uniqid(); + $user2=uniqid(); + + $this->assertFalse(OC_Group::inGroup($user1,$group1)); + $this->assertFalse(OC_Group::inGroup($user2,$group1)); + + + $this->assertTrue(OC_Group::addToGroup($user1,$group1)); + + $this->assertTrue(OC_Group::inGroup($user1,$group1)); + $this->assertFalse(OC_Group::inGroup($user2,$group1)); + $this->assertFalse($backend2->inGroup($user1,$group1)); + + $this->assertFalse(OC_Group::addToGroup($user1,$group1)); + + $this->assertEqual(array($user1),OC_Group::usersInGroup($group1)); + + $this->assertEqual(array($group1),OC_Group::getUserGroups($user1)); + $this->assertEqual(array(),OC_Group::getUserGroups($user2)); + + OC_Group::deleteGroup($group1); + $this->assertEqual(array(),OC_Group::getUserGroups($user1)); + $this->assertEqual(array(),OC_Group::usersInGroup($group1)); + $this->assertFalse(OC_Group::inGroup($user1,$group1)); + } +} diff --git a/tests/lib/group/backend.php b/tests/lib/group/backend.php new file mode 100644 index 00000000000..9405e90aabf --- /dev/null +++ b/tests/lib/group/backend.php @@ -0,0 +1,105 @@ +. +* +*/ + +abstract class Test_Group_Backend extends UnitTestCase { + /** + * @var OC_Group_Backend $backend + */ + protected $backend; + + /** + * get a new unique group name + * test cases can override this in order to clean up created groups + * @return array + */ + public function getGroupName(){ + return uniqid('test_'); + } + + /** + * get a new unique user name + * test cases can override this in order to clean up created user + * @return array + */ + public function getUserName(){ + return uniqid('test_'); + } + + public function testAddRemove(){ + //get the number of groups we start with, in case there are exising groups + $startCount=count($this->backend->getGroups()); + + $name1=$this->getGroupName(); + $name2=$this->getGroupName(); + $this->backend->createGroup($name1); + $count=count($this->backend->getGroups())-$startCount; + $this->assertEqual(1,$count); + $this->assertTrue((array_search($name1,$this->backend->getGroups())!==false)); + $this->assertFalse((array_search($name2,$this->backend->getGroups())!==false)); + $this->backend->createGroup($name2); + $count=count($this->backend->getGroups())-$startCount; + $this->assertEqual(2,$count); + $this->assertTrue((array_search($name1,$this->backend->getGroups())!==false)); + $this->assertTrue((array_search($name2,$this->backend->getGroups())!==false)); + + $this->backend->deleteGroup($name2); + $count=count($this->backend->getGroups())-$startCount; + $this->assertEqual(1,$count); + $this->assertTrue((array_search($name1,$this->backend->getGroups())!==false)); + $this->assertFalse((array_search($name2,$this->backend->getGroups())!==false)); + } + + public function testUser(){ + $group1=$this->getGroupName(); + $group2=$this->getGroupName(); + $this->backend->createGroup($group1); + $this->backend->createGroup($group2); + + $user1=$this->getUserName(); + $user2=$this->getUserName(); + + $this->assertFalse($this->backend->inGroup($user1,$group1)); + $this->assertFalse($this->backend->inGroup($user2,$group1)); + $this->assertFalse($this->backend->inGroup($user1,$group2)); + $this->assertFalse($this->backend->inGroup($user2,$group2)); + + $this->assertTrue($this->backend->addToGroup($user1,$group1)); + + $this->assertTrue($this->backend->inGroup($user1,$group1)); + $this->assertFalse($this->backend->inGroup($user2,$group1)); + $this->assertFalse($this->backend->inGroup($user1,$group2)); + $this->assertFalse($this->backend->inGroup($user2,$group2)); + + $this->assertFalse($this->backend->addToGroup($user1,$group1)); + + $this->assertEqual(array($user1),$this->backend->usersInGroup($group1)); + $this->assertEqual(array(),$this->backend->usersInGroup($group2)); + + $this->assertEqual(array($group1),$this->backend->getUserGroups($user1)); + $this->assertEqual(array(),$this->backend->getUserGroups($user2)); + + $this->backend->deleteGroup($group1); + $this->assertEqual(array(),$this->backend->getUserGroups($user1)); + $this->assertEqual(array(),$this->backend->usersInGroup($group1)); + $this->assertFalse($this->backend->inGroup($user1,$group1)); + } +} diff --git a/tests/lib/group/database.php b/tests/lib/group/database.php new file mode 100644 index 00000000000..fb51bc8d8d9 --- /dev/null +++ b/tests/lib/group/database.php @@ -0,0 +1,55 @@ +. +* +*/ + +class Test_Group_Database extends Test_Group_Backend { + private $groups=array(); + + /** + * get a new unique group name + * test cases can override this in order to clean up created groups + * @return array + */ + public function getGroupName(){ + $name=uniqid('test_'); + $this->groups[]=$name; + return $name; + } + + /** + * get a new unique user name + * test cases can override this in order to clean up created user + * @return array + */ + public function getUserName(){ + return uniqid('test_'); + } + + public function setUp(){ + $this->backend=new OC_Group_Database(); + } + + public function tearDown(){ + foreach($this->groups as $group){ + $this->backend->deleteGroup($group); + } + } +} diff --git a/tests/lib/group/dummy.php b/tests/lib/group/dummy.php new file mode 100644 index 00000000000..d0b475d3ec5 --- /dev/null +++ b/tests/lib/group/dummy.php @@ -0,0 +1,27 @@ +. +* +*/ + +class Test_Group_Dummy extends Test_Group_Backend { + public function setUp(){ + $this->backend=new OC_Group_Dummy(); + } +} -- cgit v1.2.3 From d8e54acbf3856b3917912a73481ffb482a1a25e8 Mon Sep 17 00:00:00 2001 From: Robin Appelman Date: Fri, 13 Apr 2012 22:52:06 +0200 Subject: test cases for user backends --- lib/user/dummy.php | 114 ++++++++++++++++++++++++++++++++++++++++++++ tests/lib/user/backend.php | 89 ++++++++++++++++++++++++++++++++++ tests/lib/user/database.php | 45 +++++++++++++++++ tests/lib/user/dummy.php | 27 +++++++++++ 4 files changed, 275 insertions(+) create mode 100644 lib/user/dummy.php create mode 100644 tests/lib/user/backend.php create mode 100644 tests/lib/user/database.php create mode 100644 tests/lib/user/dummy.php (limited to 'tests') diff --git a/lib/user/dummy.php b/lib/user/dummy.php new file mode 100644 index 00000000000..cfc96c5c52d --- /dev/null +++ b/lib/user/dummy.php @@ -0,0 +1,114 @@ +. +* +*/ + +/** + * dummy user backend, does not keep state, only for testing use + */ +class OC_User_Dummy extends OC_User_Backend { + private $users=array(); + /** + * @brief Create a new user + * @param $uid The username of the user to create + * @param $password The password of the new user + * @returns true/false + * + * Creates a new user. Basic checking of username is done in OC_User + * itself, not in its subclasses. + */ + public function createUser($uid, $password){ + if(isset($this->users[$uid])){ + return false; + }else{ + $this->users[$uid]=$password; + return true; + } + } + + /** + * @brief delete a user + * @param $uid The username of the user to delete + * @returns true/false + * + * Deletes a user + */ + public function deleteUser( $uid ){ + if(isset($this->users[$uid])){ + unset($this->users[$uid]); + return true; + }else{ + return false; + } + } + + /** + * @brief Set password + * @param $uid The username + * @param $password The new password + * @returns true/false + * + * Change the password of a user + */ + public function setPassword($uid, $password){ + if(isset($this->users[$uid])){ + $this->users[$uid]=$password; + return true; + }else{ + return false; + } + } + + /** + * @brief Check if the password is correct + * @param $uid The username + * @param $password The password + * @returns true/false + * + * Check if the password is correct without logging in the user + */ + public function checkPassword($uid, $password){ + if(isset($this->users[$uid])){ + return ($this->users[$uid]==$password); + }else{ + return false; + } + } + + /** + * @brief Get a list of all users + * @returns array with all uids + * + * Get a list of all users. + */ + public function getUsers(){ + return array_keys($this->users); + } + + /** + * @brief check if a user exists + * @param string $uid the username + * @return boolean + */ + public function userExists($uid){ + return isset($this->users[$uid]); + } +} diff --git a/tests/lib/user/backend.php b/tests/lib/user/backend.php new file mode 100644 index 00000000000..5dab5afb186 --- /dev/null +++ b/tests/lib/user/backend.php @@ -0,0 +1,89 @@ +. +* +*/ + +abstract class Test_User_Backend extends UnitTestCase { + /** + * @var OC_User_Backend $backend + */ + protected $backend; + + /** + * get a new unique user name + * test cases can override this in order to clean up created user + * @return array + */ + public function getUser(){ + return uniqid('test_'); + } + + public function testAddRemove(){ + //get the number of groups we start with, in case there are exising groups + $startCount=count($this->backend->getUsers()); + + $name1=$this->getUser(); + $name2=$this->getUser(); + $this->backend->createUser($name1,''); + $count=count($this->backend->getUsers())-$startCount; + $this->assertEqual(1,$count); + $this->assertTrue((array_search($name1,$this->backend->getUsers())!==false)); + $this->assertFalse((array_search($name2,$this->backend->getUsers())!==false)); + $this->backend->createUser($name2,''); + $count=count($this->backend->getUsers())-$startCount; + $this->assertEqual(2,$count); + $this->assertTrue((array_search($name1,$this->backend->getUsers())!==false)); + $this->assertTrue((array_search($name2,$this->backend->getUsers())!==false)); + + $this->backend->deleteUser($name2); + $count=count($this->backend->getUsers())-$startCount; + $this->assertEqual(1,$count); + $this->assertTrue((array_search($name1,$this->backend->getUsers())!==false)); + $this->assertFalse((array_search($name2,$this->backend->getUsers())!==false)); + } + + public function testLogin(){ + $name1=$this->getUser(); + $name2=$this->getUser(); + + $this->assertFalse($this->backend->userExists($name1)); + $this->assertFalse($this->backend->userExists($name2)); + + $this->backend->createUser($name1,'pass1'); + $this->backend->createUser($name2,'pass2'); + + $this->assertTrue($this->backend->userExists($name1)); + $this->assertTrue($this->backend->userExists($name2)); + + $this->assertTrue($this->backend->checkPassword($name1,'pass1')); + $this->assertTrue($this->backend->checkPassword($name2,'pass2')); + + $this->assertFalse($this->backend->checkPassword($name1,'pass2')); + $this->assertFalse($this->backend->checkPassword($name2,'pass1')); + + $this->assertFalse($this->backend->checkPassword($name1,'dummy')); + $this->assertFalse($this->backend->checkPassword($name2,'foobar')); + + $this->backend->setPassword($name1,'newpass1'); + $this->assertFalse($this->backend->checkPassword($name1,'pass1')); + $this->assertTrue($this->backend->checkPassword($name1,'newpass1')); + $this->assertFalse($this->backend->checkPassword($name2,'newpass1')); + } +} diff --git a/tests/lib/user/database.php b/tests/lib/user/database.php new file mode 100644 index 00000000000..b2fcce93c5b --- /dev/null +++ b/tests/lib/user/database.php @@ -0,0 +1,45 @@ +. +* +*/ + +class Test_User_Database extends Test_User_Backend { + private $user=array(); + /** + * get a new unique user name + * test cases can override this in order to clean up created user + * @return array + */ + public function getUser(){ + $user=uniqid('test_'); + $this->users[]=$user; + return $user; + } + + public function setUp(){ + $this->backend=new OC_User_Dummy(); + } + + public function tearDown(){ + foreach($this->users as $user){ + $this->backend->deleteUser($user); + } + } +} diff --git a/tests/lib/user/dummy.php b/tests/lib/user/dummy.php new file mode 100644 index 00000000000..062f55ba079 --- /dev/null +++ b/tests/lib/user/dummy.php @@ -0,0 +1,27 @@ +. +* +*/ + +class Test_User_Dummy extends Test_User_Backend { + public function setUp(){ + $this->backend=new OC_User_Dummy(); + } +} -- cgit v1.2.3