mbk-lab
/
nextcloud
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

allow multiply group backends

This commit is contained in:
Robin Appelman 2012-04-13 01:58:53 +02:00
parent e9c1f8b4e6
commit 1d8fdf52d5
10 changed files with 710 additions and 142 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
lib/base.php
View File

@ -346,7 +346,7 @@ class OC{
OC_User::useBackend( OC_Config::getValue( "userbackend", "database" )); 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 // Set up file system unless forbidden
global $RUNTIME_NOSETUPFS; global $RUNTIME_NOSETUPFS;

161
lib/group.php
View File

@ -34,57 +34,25 @@
* post_removeFromGroup(uid, gid) * post_removeFromGroup(uid, gid)
*/ */
class OC_Group { class OC_Group {
// The backend used for user management // The backend used for group management
private static $_backend; private static $_usedBackends = array();
// 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;
}
/** /**
* @brief set the group backend * @brief set the group backend
* @param string $backend The backend to use for user managment * @param string $backend The backend to use for user managment
* @returns true/false * @returns true/false
*/ */
public static function setBackend( $backend = 'database' ){ public static function useBackend( $backend ){
// You'll never know what happens if($backend instanceof OC_Group_Backend){
if( null === $backend OR !is_string( $backend )){ self::$_usedBackends[]=$backend;
$backend = 'database';
} }
}
// Load backend /**
switch( $backend ){ * remove all used backends
case 'database': */
case 'mysql': public static function clearBackends(){
case 'sqlite': self::$_usedBackends=array();
self::$_backend = new OC_Group_Database();
break;
default:
$className = 'OC_GROUP_' . strToUpper($backend);
self::$_backend = new $className();
break;
}
} }
/** /**
@ -115,11 +83,18 @@ class OC_Group {
$run = true; $run = true;
OC_Hook::emit( "OC_Group", "pre_createGroup", array( "run" => &$run, "gid" => $gid )); OC_Hook::emit( "OC_Group", "pre_createGroup", array( "run" => &$run, "gid" => $gid ));
if( $run && self::$_backend->createGroup( $gid )){ if($run){
OC_Hook::emit( "OC_Group", "post_createGroup", array( "gid" => $gid )); //create the user in the first backend that supports creating users
return true; foreach(self::$_usedBackends as $backend){
} if(!$backend->implementsActions(OC_GROUP_BACKEND_CREATE_GROUP))
else{ continue;
$backend->createGroup($gid);
OC_Hook::emit( "OC_User", "post_createGroup", array( "gid" => $gid ));
return true;
}
}else{
return false; return false;
} }
} }
@ -140,11 +115,18 @@ class OC_Group {
$run = true; $run = true;
OC_Hook::emit( "OC_Group", "pre_deleteGroup", array( "run" => &$run, "gid" => $gid )); OC_Hook::emit( "OC_Group", "pre_deleteGroup", array( "run" => &$run, "gid" => $gid ));
if( $run && self::$_backend->deleteGroup( $gid )){ if($run){
OC_Hook::emit( "OC_Group", "post_deleteGroup", array( "gid" => $gid )); //delete the group from all backends
return true; foreach(self::$_usedBackends as $backend){
} if(!$backend->implementsActions(OC_GROUP_BACKEND_DELETE_GROUP))
else{ continue;
$backend->deleteGroup($gid);
OC_Hook::emit( "OC_User", "post_deleteGroup", array( "gid" => $gid ));
return true;
}
}else{
return false; return false;
} }
} }
@ -158,7 +140,15 @@ class OC_Group {
* Checks whether the user is member of a group or not. * Checks whether the user is member of a group or not.
*/ */
public static function inGroup( $uid, $gid ){ 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. * Adds a user to a group.
*/ */
public static function addToGroup( $uid, $gid ){ public static function addToGroup( $uid, $gid ){
// Does the user exist?
if( !OC_User::userExists($uid)){
return false;
}
// Does the group exist? // Does the group exist?
if( !OC_Group::groupExists($gid)){ if( !OC_Group::groupExists($gid)){
return false; return false;
@ -183,11 +169,19 @@ class OC_Group {
$run = true; $run = true;
OC_Hook::emit( "OC_Group", "pre_addToGroup", array( "run" => &$run, "uid" => $uid, "gid" => $gid )); OC_Hook::emit( "OC_Group", "pre_addToGroup", array( "run" => &$run, "uid" => $uid, "gid" => $gid ));
if( $run && self::$_backend->addToGroup( $uid, $gid )){ if($run){
OC_Hook::emit( "OC_Group", "post_addToGroup", array( "uid" => $uid, "gid" => $gid )); $succes=false;
return true;
} //add the user to the all backends that have the group
else{ 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; return false;
} }
} }
@ -204,11 +198,17 @@ class OC_Group {
$run = true; $run = true;
OC_Hook::emit( "OC_Group", "pre_removeFromGroup", array( "run" => &$run, "uid" => $uid, "gid" => $gid )); OC_Hook::emit( "OC_Group", "pre_removeFromGroup", array( "run" => &$run, "uid" => $uid, "gid" => $gid ));
if( $run && self::$_backend->removeFromGroup( $uid, $gid )){ if($run){
OC_Hook::emit( "OC_Group", "post_removeFromGroup", array( "uid" => $uid, "gid" => $gid )); //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; return true;
} }else{
else{
return false; return false;
} }
} }
@ -222,7 +222,14 @@ class OC_Group {
* if the user exists at all. * if the user exists at all.
*/ */
public static function getUserGroups( $uid ){ 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 * Returns a list with all groups
*/ */
public static function getGroups(){ 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 * @returns array with user ids
*/ */
public static function usersInGroup($gid){ 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;
} }
} }

123
lib/group/backend.php
View File

@ -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 base class for user management
*/ */
abstract class OC_Group_Backend { abstract class OC_Group_Backend {
/** protected $possibleActions = array(
* @brief Try to create a new group OC_GROUP_BACKEND_CREATE_GROUP => 'createGroup',
* @param $gid The name of the group to create OC_GROUP_BACKEND_DELETE_GROUP => 'deleteGroup',
* @returns true/false OC_GROUP_BACKEND_IN_GROUP => 'inGroup',
* OC_GROUP_BACKEND_ADD_TO_GROUP => 'addToGroup',
* Trys to create a new group. If the group name already exists, false will OC_GROUP_BACKEND_REMOVE_FROM_GOUP => 'removeFromGroup',
* be returned. OC_GROUP_BACKEND_GET_USER_GROUPS => 'getUserGroups',
*/ OC_GROUP_BACKEND_GET_USERS => 'usersInGroup',
public static function createGroup($gid){} OC_GROUP_BACKEND_GET_GROUPS => 'getGroups'
);
/**
* @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 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 * @brief Get all supported actions
* @returns array with user ids * @returns bitwise-or'ed actions
*/ *
public static function usersInGroup($gid){} * 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;
}
}
return $actions;
}
/**
* @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);
}
} }

4
lib/group/database.php
View File

@ -117,8 +117,10 @@ class OC_Group_Database extends OC_Group_Backend {
if( !self::inGroup( $uid, $gid )){ if( !self::inGroup( $uid, $gid )){
$query = OC_DB::prepare( "INSERT INTO `*PREFIX*group_user` ( `uid`, `gid` ) VALUES( ?, ? )" ); $query = OC_DB::prepare( "INSERT INTO `*PREFIX*group_user` ( `uid`, `gid` ) VALUES( ?, ? )" );
$result = $query->execute( array( $uid, $gid )); $result = $query->execute( array( $uid, $gid ));
return true;
}else{
return false;
} }
return true;
} }
/** /**

159
lib/group/dummy.php Normal file
View File

@ -0,0 +1,159 @@
<?php
/**
* ownCloud
*
* @author Frank Karlitschek
* @copyright 2010 Frank Karlitschek karlitschek@kde.org
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU AFFERO GENERAL PUBLIC LICENSE
* License as published by the Free Software Foundation; either
* version 3 of the License, or any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU AFFERO GENERAL PUBLIC LICENSE for more details.
*
* You should have received a copy of the GNU Affero General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*
*/
/**
* 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();
}
}
}

102
lib/group/example.php Normal file
View File

@ -0,0 +1,102 @@
<?php
/**
* ownCloud
*
* @author Frank Karlitschek
* @copyright 2010 Frank Karlitschek karlitschek@kde.org
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU AFFERO GENERAL PUBLIC LICENSE
* License as published by the Free Software Foundation; either
* version 3 of the License, or any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU AFFERO GENERAL PUBLIC LICENSE for more details.
*
* You should have received a copy of the GNU Affero General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*
*/
/**
* 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){}
}

114
tests/lib/group.php Normal file
View File

@ -0,0 +1,114 @@
<?php
/**
* ownCloud
*
* @author Robin Appelman
* @copyright 2012 Robin Appelman icewind@owncloud.com
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU AFFERO GENERAL PUBLIC LICENSE
* License as published by the Free Software Foundation; either
* version 3 of the License, or any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU AFFERO GENERAL PUBLIC LICENSE for more details.
*
* You should have received a copy of the GNU Affero General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*
*/
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));
}
}

105
tests/lib/group/backend.php Normal file
View File

@ -0,0 +1,105 @@
<?php
/**
* ownCloud
*
* @author Robin Appelman
* @copyright 2012 Robin Appelman icewind@owncloud.com
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU AFFERO GENERAL PUBLIC LICENSE
* License as published by the Free Software Foundation; either
* version 3 of the License, or any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU AFFERO GENERAL PUBLIC LICENSE for more details.
*
* You should have received a copy of the GNU Affero General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*
*/
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));
}
}

55
tests/lib/group/database.php Normal file
View File

@ -0,0 +1,55 @@
<?php
/**
* ownCloud
*
* @author Robin Appelman
* @copyright 2012 Robin Appelman icewind@owncloud.com
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU AFFERO GENERAL PUBLIC LICENSE
* License as published by the Free Software Foundation; either
* version 3 of the License, or any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU AFFERO GENERAL PUBLIC LICENSE for more details.
*
* You should have received a copy of the GNU Affero General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*
*/
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);
}
}
}

27
tests/lib/group/dummy.php Normal file
View File

@ -0,0 +1,27 @@
<?php
/**
* ownCloud
*
* @author Robin Appelman
* @copyright 2012 Robin Appelman icewind@owncloud.com
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU AFFERO GENERAL PUBLIC LICENSE
* License as published by the Free Software Foundation; either
* version 3 of the License, or any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU AFFERO GENERAL PUBLIC LICENSE for more details.
*
* You should have received a copy of the GNU Affero General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*
*/
class Test_Group_Dummy extends Test_Group_Backend {
public function setUp(){
$this->backend=new OC_Group_Dummy();
}
}