Merge pull request #3995 from owncloud/groups

Refactoring of group management code
2013-07-24 06:13:05 -07:00 · 2013-07-24 06:13:05 -07:00 · 98858e6f00
parent b91c6827b7 60ce492fac
commit 98858e6f00
9 changed files with 1202 additions and 176 deletions
--- a/lib/group.php
+++ b/lib/group.php
@ -34,28 +34,43 @@
 *   post_removeFromGroup(uid, gid)
 */
 class OC_Group {
-	// The backend used for group management
 	/**
-	 * @var OC_Group_Interface[]
+	 * @var \OC\Group\Manager $manager
 	 */
-	private static $_usedBackends = array();
+	private static $manager;
+
+	/**
+	 * @var \OC\User\Manager
+	 */
+	private static $userManager;
+
+	/**
+	 * @return \OC\Group\Manager
+	 */
+	public static function getManager() {
+		if (self::$manager) {
+			return self::$manager;
+		}
+		self::$userManager = \OC_User::getManager();
+		self::$manager = new \OC\Group\Manager(self::$userManager);
+		return self::$manager;
+	}

 	/**
 	 * @brief set the group backend
-	 * @param  string  $backend  The backend to use for user managment
+	 * @param  \OC_Group_Backend $backend  The backend to use for user managment
 	 * @return bool
 	 */
-	public static function useBackend( $backend ) {
-		if($backend instanceof OC_Group_Interface) {
-			self::$_usedBackends[]=$backend;
-		}
+	public static function useBackend($backend) {
+		self::getManager()->addBackend($backend);
+		return true;
 	}

 	/**
 	 * remove all used backends
 	 */
 	public static function clearBackends() {
-		self::$_usedBackends=array();
+		self::getManager()->clearBackends();
 	}

 	/**
@ -66,32 +81,13 @@ class OC_Group {
 	 * Tries to create a new group. If the group name already exists, false will
 	 * be returned. Basic checking of Group name
 	 */
-	public static function createGroup( $gid ) {
-		// No empty group names!
-		if( !$gid ) {
-			return false;
-		}
-		// No duplicate group names
-		if( in_array( $gid, self::getGroups())) {
-			return false;
-		}
+	public static function createGroup($gid) {
+		OC_Hook::emit("OC_Group", "pre_createGroup", array("run" => true, "gid" => $gid));

-		$run = true;
-		OC_Hook::emit( "OC_Group", "pre_createGroup", array( "run" => &$run, "gid" => $gid ));
-
-		if($run) {
-			//create the group in the first backend that supports creating groups
-			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;
-			}
-			return false;
-		}else{
+		if (self::getManager()->createGroup($gid)) {
+			OC_Hook::emit("OC_User", "post_createGroup", array("gid" => $gid));
+			return true;
+		} else {
 			return false;
 		}
 	}
@ -103,30 +99,22 @@ class OC_Group {
 	 *
 	 * Deletes a group and removes it from the group_user-table
 	 */
-	public static function deleteGroup( $gid ) {
+	public static function deleteGroup($gid) {
 		// Prevent users from deleting group admin
-		if( $gid == "admin" ) {
+		if ($gid == "admin") {
 			return false;
 		}

-		$run = true;
-		OC_Hook::emit( "OC_Group", "pre_deleteGroup", array( "run" => &$run, "gid" => $gid ));
-
-		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 ));
+		OC_Hook::emit("OC_Group", "pre_deleteGroup", array("run" => true, "gid" => $gid));

+		$group = self::getManager()->get($gid);
+		if ($group) {
+			if ($group->delete()) {
+				OC_Hook::emit("OC_User", "post_deleteGroup", array("gid" => $gid));
 				return true;
 			}
-			return false;
-		}else{
-			return false;
 		}
+		return false;
 	}

 	/**
@ -137,11 +125,11 @@ class OC_Group {
 	 *
 	 * Checks whether the user is member of a group or not.
 	 */
-	public static function inGroup( $uid, $gid ) {
-		foreach(self::$_usedBackends as $backend) {
-			if($backend->inGroup($uid, $gid)) {
-				return true;
-			}
+	public static function inGroup($uid, $gid) {
+		$group = self::getManager()->get($gid);
+		$user = self::$userManager->get($uid);
+		if ($group and $user) {
+			return $group->inGroup($user);
 		}
 		return false;
 	}
@ -154,33 +142,15 @@ class OC_Group {
 	 *
 	 * Adds a user to a group.
 	 */
-	public static function addToGroup( $uid, $gid ) {
-		// Does the group exist?
-		if( !OC_Group::groupExists($gid)) {
-			return false;
-		}
-
-		// Go go go
-		$run = true;
-		OC_Hook::emit( "OC_Group", "pre_addToGroup", array( "run" => &$run, "uid" => $uid, "gid" => $gid ));
-
-		if($run) {
-			$success=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;
-
-				if($backend->groupExists($gid)) {
-					$success|=$backend->addToGroup($uid, $gid);
-				}
-			}
-			if($success) {
-				OC_Hook::emit( "OC_User", "post_addToGroup", array( "uid" => $uid, "gid" => $gid ));
-			}
-			return $success;
-		}else{
+	public static function addToGroup($uid, $gid) {
+		$group = self::getManager()->get($gid);
+		$user = self::$userManager->get($uid);
+		if ($group and $user) {
+			OC_Hook::emit("OC_Group", "pre_addToGroup", array("run" => true, "uid" => $uid, "gid" => $gid));
+			$group->addUser($user);
+			OC_Hook::emit("OC_User", "post_addToGroup", array("uid" => $uid, "gid" => $gid));
+			return true;
+		} else {
 			return false;
 		}
 	}
@ -193,21 +163,15 @@ class OC_Group {
 	 *
 	 * removes the user from a group.
 	 */
-	public static function removeFromGroup( $uid, $gid ) {
-		$run = true;
-		OC_Hook::emit( "OC_Group", "pre_removeFromGroup", array( "run" => &$run, "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 ));
-			}
+	public static function removeFromGroup($uid, $gid) {
+		$group = self::getManager()->get($gid);
+		$user = self::$userManager->get($uid);
+		if ($group and $user) {
+			OC_Hook::emit("OC_Group", "pre_removeFromGroup", array("run" => true, "uid" => $uid, "gid" => $gid));
+			$group->removeUser($user);
+			OC_Hook::emit("OC_User", "post_removeFromGroup", array("uid" => $uid, "gid" => $gid));
 			return true;
-		}else{
+		} else {
 			return false;
 		}
 	}
@ -220,13 +184,18 @@ class OC_Group {
 	 * This function fetches all groups a user belongs to. It does not check
 	 * if the user exists at all.
 	 */
-	public static function getUserGroups( $uid ) {
-		$groups=array();
-		foreach(self::$_usedBackends as $backend) {
-			$groups=array_merge($backend->getUserGroups($uid), $groups);
+	public static function getUserGroups($uid) {
+		$user = self::$userManager->get($uid);
+		if ($user) {
+			$groups = self::getManager()->getUserGroups($user);
+			$groupIds = array();
+			foreach ($groups as $group) {
+				$groupIds[] = $group->getGID();
+			}
+			return $groupIds;
+		} else {
+			return array();
 		}
-		asort($groups);
-		return $groups;
 	}

 	/**
@ -235,27 +204,23 @@ class OC_Group {
 	 *
 	 * Returns a list with all groups
 	 */
-	public static function getGroups($search = '', $limit = -1, $offset = 0) {
-		$groups = array();
-		foreach (self::$_usedBackends as $backend) {
-			$groups = array_merge($backend->getGroups($search, $limit, $offset), $groups);
+	public static function getGroups($search = '', $limit = null, $offset = null) {
+		$groups = self::getManager()->search($search, $limit, $offset);
+		$groupIds = array();
+		foreach ($groups as $group) {
+			$groupIds[] = $group->getGID();
 		}
-		asort($groups);
-		return $groups;
+		return $groupIds;
 	}

 	/**
 	 * check if a group exists
+	 *
 	 * @param string $gid
 	 * @return bool
 	 */
 	public static function groupExists($gid) {
-		foreach(self::$_usedBackends as $backend) {
-			if ($backend->groupExists($gid)) {
-				return true;
-			}
-		}
-		return false;
+		return self::getManager()->groupExists($gid);
 	}

 	/**
@ -263,11 +228,17 @@ class OC_Group {
 	 * @returns array with user ids
 	 */
 	public static function usersInGroup($gid, $search = '', $limit = -1, $offset = 0) {
-		$users=array();
-		foreach(self::$_usedBackends as $backend) {
-			$users = array_merge($backend->usersInGroup($gid, $search, $limit, $offset), $users);
+		$group = self::getManager()->get($gid);
+		if ($group) {
+			$users = $group->searchUsers($search . $limit, $offset);
+			$userIds = array();
+			foreach ($users as $user) {
+				$userIds[] = $user->getUID();
+			}
+			return $userIds;
+		} else {
+			return array();
 		}
-		return $users;
 	}

 	/**
@ -292,17 +263,17 @@ class OC_Group {
 	 * @returns array with display names (value) and user ids(key)
 	 */
 	public static function displayNamesInGroup($gid, $search = '', $limit = -1, $offset = 0) {
-		$displayNames=array();
-		foreach(self::$_usedBackends as $backend) {
-			if($backend->implementsActions(OC_GROUP_BACKEND_GET_DISPLAYNAME)) {
-				$displayNames = array_merge($backend->displayNamesInGroup($gid, $search, $limit, $offset), $displayNames);
-			} else {
-				$users = $backend->usersInGroup($gid, $search, $limit, $offset);
-				$names = array_combine($users, $users);
-				$displayNames = array_merge($names, $displayNames);
+		$group = self::getManager()->get($gid);
+		if ($group) {
+			$users = $group->searchDisplayName($search . $limit, $offset);
+			$displayNames = array();
+			foreach ($users as $user) {
+				$displayNames[] = $user->getDisplayName();
 			}
+			return $displayNames;
+		} else {
+			return array();
 		}
-		return $displayNames;
 	}

 	/**
--- a/lib/group/group.php
+++ b/lib/group/group.php
@ -0,0 +1,238 @@
+<?php
+
+/**
+ * Copyright (c) 2013 Robin Appelman <icewind@owncloud.com>
+ * This file is licensed under the Affero General Public License version 3 or
+ * later.
+ * See the COPYING-README file.
+ */
+
+namespace OC\Group;
+
+class Group {
+	/**
+	 * @var string $id
+	 */
+	private $fid;
+
+	/**
+	 * @var \OC\User\User[] $users
+	 */
+	private $users;
+
+	/**
+	 * @var \OC_Group_Backend[] | \OC_Group_Database[] $backend
+	 */
+	private $backends;
+
+	/**
+	 * @var \OC\Hooks\PublicEmitter $emitter;
+	 */
+	private $emitter;
+
+	/**
+	 * @var \OC\User\Manager $userManager
+	 */
+	private $userManager;
+
+	/**
+	 * @param string $gid
+	 * @param \OC_Group_Backend[] $backends
+	 * @param \OC\User\Manager $userManager
+	 * @param \OC\Hooks\PublicEmitter $emitter
+	 */
+	public function __construct($gid, $backends, $userManager, $emitter = null) {
+		$this->gid = $gid;
+		$this->backends = $backends;
+		$this->userManager = $userManager;
+		$this->emitter = $emitter;
+	}
+
+	public function getGID() {
+		return $this->gid;
+	}
+
+	/**
+	 * get all users in the group
+	 *
+	 * @return \OC\User\User[]
+	 */
+	public function getUsers() {
+		if ($this->users) {
+			return $this->users;
+		}
+
+		$users = array();
+		$userIds = array();
+		foreach ($this->backends as $backend) {
+			$diff = array_diff(
+				$backend->usersInGroup($this->gid),
+				$userIds
+			);
+			if ($diff) {
+				$userIds = array_merge($userIds, $diff);
+			}
+		}
+
+		foreach ($userIds as $userId) {
+			$users[] = $this->userManager->get($userId);
+		}
+		$this->users = $users;
+		return $users;
+	}
+
+	/**
+	 * check if a user is in the group
+	 *
+	 * @param \OC\User\User $user
+	 * @return bool
+	 */
+	public function inGroup($user) {
+		foreach ($this->backends as $backend) {
+			if ($backend->inGroup($user->getUID(), $this->gid)) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	/**
+	 * add a user to the group
+	 *
+	 * @param \OC\User\User $user
+	 */
+	public function addUser($user) {
+		if ($this->inGroup($user)) {
+			return;
+		}
+
+		if ($this->emitter) {
+			$this->emitter->emit('\OC\Group', 'preAddUser', array($this, $user));
+		}
+		foreach ($this->backends as $backend) {
+			if ($backend->implementsActions(OC_GROUP_BACKEND_ADD_TO_GROUP)) {
+				$backend->addToGroup($user->getUID(), $this->gid);
+				if ($this->users) {
+					$this->users[] = $user;
+				}
+				if ($this->emitter) {
+					$this->emitter->emit('\OC\Group', 'postAddUser', array($this, $user));
+				}
+				return;
+			}
+		}
+	}
+
+	/**
+	 * remove a user from the group
+	 *
+	 * @param \OC\User\User $user
+	 */
+	public function removeUser($user) {
+		$result = false;
+		if ($this->emitter) {
+			$this->emitter->emit('\OC\Group', 'preRemoveUser', array($this, $user));
+		}
+		foreach ($this->backends as $backend) {
+			if ($backend->implementsActions(OC_GROUP_BACKEND_REMOVE_FROM_GOUP) and $backend->inGroup($user->getUID(), $this->gid)) {
+				$backend->removeFromGroup($user->getUID(), $this->gid);
+				$result = true;
+			}
+		}
+		if ($result) {
+			if ($this->emitter) {
+				$this->emitter->emit('\OC\Group', 'postRemoveUser', array($this, $user));
+			}
+			if ($this->users) {
+				foreach ($this->users as $index => $groupUser) {
+					if ($groupUser->getUID() === $user->getUID()) {
+						unset($this->users[$index]);
+						return;
+					}
+				}
+			}
+		}
+	}
+
+	/**
+	 * search for users in the group by userid
+	 *
+	 * @param string $search
+	 * @param int $limit
+	 * @param int $offset
+	 * @return \OC\User\User[]
+	 */
+	public function searchUsers($search, $limit = null, $offset = null) {
+		$users = array();
+		foreach ($this->backends as $backend) {
+			$userIds = $backend->usersInGroup($this->gid, $search, $limit, $offset);
+			if (!is_null($limit)) {
+				$limit -= count($userIds);
+			}
+			if (!is_null($offset)) {
+				$offset -= count($userIds);
+			}
+			foreach ($userIds as $userId) {
+				$users[$userId] = $this->userManager->get($userId);
+			}
+			if (!is_null($limit) and $limit <= 0) {
+				return array_values($users);
+			}
+		}
+		return array_values($users);
+	}
+
+	/**
+	 * search for users in the group by displayname
+	 *
+	 * @param string $search
+	 * @param int $limit
+	 * @param int $offset
+	 * @return \OC\User\User[]
+	 */
+	public function searchDisplayName($search, $limit = null, $offset = null) {
+		$users = array();
+		foreach ($this->backends as $backend) {
+			if ($backend->implementsActions(OC_GROUP_BACKEND_GET_DISPLAYNAME)) {
+				$userIds = array_keys($backend->displayNamesInGroup($this->gid, $search, $limit, $offset));
+			} else {
+				$userIds = $backend->usersInGroup($this->gid, $search, $limit, $offset);
+			}
+			if (!is_null($limit)) {
+				$limit -= count($userIds);
+			}
+			if (!is_null($offset)) {
+				$offset -= count($userIds);
+			}
+			foreach ($userIds as $userId) {
+				$users[$userId] = $this->userManager->get($userId);
+			}
+			if (!is_null($limit) and $limit <= 0) {
+				return array_values($users);
+			}
+		}
+		return array_values($users);
+	}
+
+	/**
+	 * delete the group
+	 *
+	 * @return bool
+	 */
+	public function delete() {
+		$result = false;
+		if ($this->emitter) {
+			$this->emitter->emit('\OC\Group', 'preDelete', array($this));
+		}
+		foreach ($this->backends as $backend) {
+			if ($backend->implementsActions(OC_GROUP_BACKEND_DELETE_GROUP)) {
+				$result = true;
+				$backend->deleteGroup($this->gid);
+			}
+		}
+		if ($result and $this->emitter) {
+			$this->emitter->emit('\OC\Group', 'postDelete', array($this));
+		}
+		return $result;
+	}
+}
--- a/lib/group/manager.php
+++ b/lib/group/manager.php
@ -0,0 +1,169 @@
+<?php
+
+/**
+ * Copyright (c) 2013 Robin Appelman <icewind@owncloud.com>
+ * This file is licensed under the Affero General Public License version 3 or
+ * later.
+ * See the COPYING-README file.
+ */
+
+namespace OC\Group;
+
+use OC\Hooks\PublicEmitter;
+
+/**
+ * Class Manager
+ *
+ * Hooks available in scope \OC\Group:
+ * - preAddUser(\OC\Group\Group $group, \OC\User\User $user)
+ * - postAddUser(\OC\Group\Group $group, \OC\User\User $user)
+ * - preRemoveUser(\OC\Group\Group $group, \OC\User\User $user)
+ * - postRemoveUser(\OC\Group\Group $group, \OC\User\User $user)
+ * - preDelete(\OC\Group\Group $group)
+ * - postDelete(\OC\Group\Group $group)
+ * - preCreate(string $groupId)
+ * - postCreate(\OC\Group\Group $group)
+ *
+ * @package OC\Group
+ */
+class Manager extends PublicEmitter {
+	/**
+	 * @var \OC_Group_Backend[] | \OC_Group_Database[] $backends
+	 */
+	private $backends = array();
+
+	/**
+	 * @var \OC\User\Manager $userManager
+	 */
+	private $userManager;
+
+	/**
+	 * @var \OC\Group\Group[]
+	 */
+	private $cachedGroups;
+
+	/**
+	 * @param \OC\User\Manager $userManager
+	 */
+	public function __construct($userManager) {
+		$this->userManager = $userManager;
+		$cache = & $this->cachedGroups;
+		$this->listen('\OC\Group', 'postDelete', function ($group) use (&$cache) {
+			/**
+			 * @var \OC\Group\Group $group
+			 */
+			unset($cache[$group->getGID()]);
+		});
+	}
+
+	/**
+	 * @param \OC_Group_Backend $backend
+	 */
+	public function addBackend($backend) {
+		$this->backends[] = $backend;
+	}
+
+	public function clearBackends() {
+		$this->backends = array();
+		$this->cachedGroups = array();
+	}
+
+	/**
+	 * @param string $gid
+	 * @return \OC\Group\Group
+	 */
+	public function get($gid) {
+		if (isset($this->cachedGroups[$gid])) {
+			return $this->cachedGroups[$gid];
+		}
+		foreach ($this->backends as $backend) {
+			if ($backend->groupExists($gid)) {
+				return $this->getGroupObject($gid);
+			}
+		}
+		return null;
+	}
+
+	protected function getGroupObject($gid) {
+		$backends = array();
+		foreach ($this->backends as $backend) {
+			if ($backend->groupExists($gid)) {
+				$backends[] = $backend;
+			}
+		}
+		$this->cachedGroups[$gid] = new Group($gid, $backends, $this->userManager, $this);
+		return $this->cachedGroups[$gid];
+	}
+
+	/**
+	 * @param string $gid
+	 * @return bool
+	 */
+	public function groupExists($gid) {
+		return !is_null($this->get($gid));
+	}
+
+	/**
+	 * @param string $gid
+	 * @return \OC\Group\Group
+	 */
+	public function createGroup($gid) {
+		if (!$gid) {
+			return false;
+		} else if ($this->groupExists($gid)) {
+			return $this->get($gid);
+		} else {
+			$this->emit('\OC\Group', 'preCreate', array($gid));
+			foreach ($this->backends as $backend) {
+				if ($backend->implementsActions(OC_GROUP_BACKEND_CREATE_GROUP)) {
+					$backend->createGroup($gid);
+					$group = $this->getGroupObject($gid);
+					$this->emit('\OC\Group', 'postCreate', array($group));
+					return $group;
+				}
+			}
+			return null;
+		}
+	}
+
+	/**
+	 * @param string $search
+	 * @param int $limit
+	 * @param int $offset
+	 * @return \OC\Group\Group[]
+	 */
+	public function search($search, $limit = null, $offset = null) {
+		$groups = array();
+		foreach ($this->backends as $backend) {
+			$groupIds = $backend->getGroups($search, $limit, $offset);
+			if (!is_null($limit)) {
+				$limit -= count($groupIds);
+			}
+			if (!is_null($offset)) {
+				$offset -= count($groupIds);
+			}
+			foreach ($groupIds as $groupId) {
+				$groups[$groupId] = $this->getGroupObject($groupId);
+			}
+			if (!is_null($limit) and $limit <= 0) {
+				return array_values($groups);
+			}
+		}
+		return array_values($groups);
+	}
+
+	/**
+	 * @param \OC\User\User $user
+	 * @return \OC\Group\Group[]
+	 */
+	public function getUserGroups($user) {
+		$groups = array();
+		foreach ($this->backends as $backend) {
+			$groupIds = $backend->getUserGroups($user->getUID());
+			foreach ($groupIds as $groupId) {
+				$groups[$groupId] = $this->getGroupObject($groupId);
+			}
+		}
+		return array_values($groups);
+	}
+}
--- a/lib/user.php
+++ b/lib/user.php
@ -39,7 +39,7 @@
 class OC_User {
 	public static $userSession = null;

-	private static function getUserSession() {
+	public static function getUserSession() {
 		if (!self::$userSession) {
 			$manager = new \OC\User\Manager();
 			self::$userSession = new \OC\User\Session($manager, \OC::$session);
@ -83,7 +83,7 @@ class OC_User {
 	/**
 	 * @return \OC\User\Manager
 	 */
-	private static function getManager() {
+	public static function getManager() {
 		return self::getUserSession()->getManager();
 	}

--- a/lib/user/manager.php
+++ b/lib/user/manager.php
@ -30,6 +30,9 @@ class Manager extends PublicEmitter {
 	 */
 	private $backends = array();

+	/**
+	 * @var \OC\User\User[] $cachedUsers
+	 */
 	private $cachedUsers = array();

 	public function __construct() {
--- a/lib/user/user.php
+++ b/lib/user/user.php
@ -44,7 +44,7 @@ class User {
 	 */
 	public function __construct($uid, $backend, $emitter = null) {
 		$this->uid = $uid;
-		if ($backend->implementsActions(OC_USER_BACKEND_GET_DISPLAYNAME)) {
+		if ($backend and $backend->implementsActions(OC_USER_BACKEND_GET_DISPLAYNAME)) {
 			$this->displayName = $backend->getDisplayName($uid);
 		} else {
 			$this->displayName = $uid;
--- a/tests/lib/group.php
+++ b/tests/lib/group.php
@ -1,56 +1,61 @@
 <?php
 /**
-* ownCloud
-*
-* @author Robin Appelman
-* @author Bernhard Posselt
-* @copyright 2012 Robin Appelman icewind@owncloud.com
-* @copyright 2012 Bernhard Posselt nukeawhale@gmail.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/>.
-*
-*/
+ * ownCloud
+ *
+ * @author Robin Appelman
+ * @author Bernhard Posselt
+ * @copyright 2012 Robin Appelman icewind@owncloud.com
+ * @copyright 2012 Bernhard Posselt nukeawhale@gmail.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 PHPUnit_Framework_TestCase {
 	function setUp() {
 		OC_Group::clearBackends();
+		OC_User::clearBackends();
 	}

 	function testSingleBackend() {
+		$userBackend = new \OC_User_Dummy();
+		\OC_User::getManager()->registerBackend($userBackend);
 		OC_Group::useBackend(new OC_Group_Dummy());
-		
-		$group1=uniqid();
-		$group2=uniqid();
+
+		$group1 = uniqid();
+		$group2 = uniqid();
 		OC_Group::createGroup($group1);
 		OC_Group::createGroup($group2);

-		$user1=uniqid();
-		$user2=uniqid();
+		$user1 = uniqid();
+		$user2 = uniqid();
+		$userBackend->createUser($user1, '');
+		$userBackend->createUser($user2, '');

 		$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((bool)OC_Group::addToGroup($user1, $group1));
+		$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((bool)OC_Group::addToGroup($user1, $group1));
+		$this->assertTrue(OC_Group::addToGroup($user1, $group1));

 		$this->assertEquals(array($user1), OC_Group::usersInGroup($group1));
 		$this->assertEquals(array(), OC_Group::usersInGroup($group2));
@ -65,37 +70,37 @@ class Test_Group extends PHPUnit_Framework_TestCase {
 	}


-	public function testNoEmptyGIDs(){
+	public function testNoEmptyGIDs() {
 		OC_Group::useBackend(new OC_Group_Dummy());
 		$emptyGroup = null;

-		$this->assertEquals(false, OC_Group::createGroup($emptyGroup));
+		$this->assertFalse(OC_Group::createGroup($emptyGroup));
 	}


-	public function testNoGroupsTwice(){
+	public function testNoGroupsTwice() {
 		OC_Group::useBackend(new OC_Group_Dummy());
 		$group = uniqid();
 		OC_Group::createGroup($group);

 		$groupCopy = $group;

-		$this->assertEquals(false, OC_Group::createGroup($groupCopy));
+		OC_Group::createGroup($groupCopy);
 		$this->assertEquals(array($group), OC_Group::getGroups());
 	}


-	public function testDontDeleteAdminGroup(){
+	public function testDontDeleteAdminGroup() {
 		OC_Group::useBackend(new OC_Group_Dummy());
 		$adminGroup = 'admin';
 		OC_Group::createGroup($adminGroup);

-		$this->assertEquals(false, OC_Group::deleteGroup($adminGroup));
+		$this->assertFalse(OC_Group::deleteGroup($adminGroup));
 		$this->assertEquals(array($adminGroup), OC_Group::getGroups());
 	}


-	public function testDontAddUserToNonexistentGroup(){
+	public function testDontAddUserToNonexistentGroup() {
 		OC_Group::useBackend(new OC_Group_Dummy());
 		$groupNonExistent = 'notExistent';
 		$user = uniqid();
@ -105,8 +110,11 @@ class Test_Group extends PHPUnit_Framework_TestCase {
 	}


-	public function testUsersInGroup(){
+	public function testUsersInGroup() {
 		OC_Group::useBackend(new OC_Group_Dummy());
+		$userBackend = new \OC_User_Dummy();
+		\OC_User::getManager()->registerBackend($userBackend);
+
 		$group1 = uniqid();
 		$group2 = uniqid();
 		$group3 = uniqid();
@ -117,27 +125,32 @@ class Test_Group extends PHPUnit_Framework_TestCase {
 		OC_Group::createGroup($group2);
 		OC_Group::createGroup($group3);

+		$userBackend->createUser($user1, '');
+		$userBackend->createUser($user2, '');
+		$userBackend->createUser($user3, '');
+
 		OC_Group::addToGroup($user1, $group1);
 		OC_Group::addToGroup($user2, $group1);
 		OC_Group::addToGroup($user3, $group1);
 		OC_Group::addToGroup($user3, $group2);

 		$this->assertEquals(array($user1, $user2, $user3),
-					OC_Group::usersInGroups(array($group1, $group2, $group3)));
+			OC_Group::usersInGroups(array($group1, $group2, $group3)));

 		// FIXME: needs more parameter variation
 	}


-
 	function testMultiBackend() {
-		$backend1=new OC_Group_Dummy();
-		$backend2=new OC_Group_Dummy();
+		$userBackend = new \OC_User_Dummy();
+		\OC_User::getManager()->registerBackend($userBackend);
+		$backend1 = new OC_Group_Dummy();
+		$backend2 = new OC_Group_Dummy();
 		OC_Group::useBackend($backend1);
 		OC_Group::useBackend($backend2);

-		$group1=uniqid();
-		$group2=uniqid();
+		$group1 = uniqid();
+		$group2 = uniqid();
 		OC_Group::createGroup($group1);

 		//groups should be added to the first registered backend
@ -154,20 +167,23 @@ class Test_Group extends PHPUnit_Framework_TestCase {
 		$this->assertTrue(OC_Group::groupExists($group1));
 		$this->assertTrue(OC_Group::groupExists($group2));

-		$user1=uniqid();
-		$user2=uniqid();
+		$user1 = uniqid();
+		$user2 = uniqid();
+
+		$userBackend->createUser($user1, '');
+		$userBackend->createUser($user2, '');

 		$this->assertFalse(OC_Group::inGroup($user1, $group1));
 		$this->assertFalse(OC_Group::inGroup($user2, $group1));


-		$this->assertTrue((bool)OC_Group::addToGroup($user1, $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((bool)OC_Group::addToGroup($user1, $group1));
+		OC_Group::addToGroup($user1, $group1);

 		$this->assertEquals(array($user1), OC_Group::usersInGroup($group1));

--- a/tests/lib/group/group.php
+++ b/tests/lib/group/group.php
@ -0,0 +1,316 @@
+<?php
+
+/**
+ * Copyright (c) 2013 Robin Appelman <icewind@owncloud.com>
+ * This file is licensed under the Affero General Public License version 3 or
+ * later.
+ * See the COPYING-README file.
+ */
+
+namespace Test\Group;
+
+use OC\User\User;
+
+class Group extends \PHPUnit_Framework_TestCase {
+	/**
+	 * @return \PHPUnit_Framework_MockObject_MockObject | \OC\User\Manager
+	 */
+	protected function getUserManager() {
+		$userManager = $this->getMock('\OC\User\Manager');
+		$user1 = new User('user1', null);
+		$user2 = new User('user2', null);
+		$user3 = new User('user3', null);
+		$userManager->expects($this->any())
+			->method('get')
+			->will($this->returnValueMap(array(
+				array('user1', $user1),
+				array('user2', $user2),
+				array('user3', $user3)
+			)));
+		return $userManager;
+	}
+
+	public function testGetUsersSingleBackend() {
+		$backend = $this->getMock('OC_Group_Database');
+		$userManager = $this->getUserManager();
+		$group = new \OC\Group\Group('group1', array($backend), $userManager);
+
+		$backend->expects($this->once())
+			->method('usersInGroup')
+			->with('group1')
+			->will($this->returnValue(array('user1', 'user2')));
+
+		$users = $group->getUsers();
+
+		$this->assertEquals(2, count($users));
+		$user1 = $users[0];
+		$user2 = $users[1];
+		$this->assertEquals('user1', $user1->getUID());
+		$this->assertEquals('user2', $user2->getUID());
+	}
+
+	public function testGetUsersMultipleBackends() {
+		$backend1 = $this->getMock('OC_Group_Database');
+		$backend2 = $this->getMock('OC_Group_Database');
+		$userManager = $this->getUserManager();
+		$group = new \OC\Group\Group('group1', array($backend1, $backend2), $userManager);
+
+		$backend1->expects($this->once())
+			->method('usersInGroup')
+			->with('group1')
+			->will($this->returnValue(array('user1', 'user2')));
+
+		$backend2->expects($this->once())
+			->method('usersInGroup')
+			->with('group1')
+			->will($this->returnValue(array('user2', 'user3')));
+
+		$users = $group->getUsers();
+
+		$this->assertEquals(3, count($users));
+		$user1 = $users[0];
+		$user2 = $users[1];
+		$user3 = $users[2];
+		$this->assertEquals('user1', $user1->getUID());
+		$this->assertEquals('user2', $user2->getUID());
+		$this->assertEquals('user3', $user3->getUID());
+	}
+
+	public function testInGroupSingleBackend() {
+		$backend = $this->getMock('OC_Group_Database');
+		$userManager = $this->getUserManager();
+		$group = new \OC\Group\Group('group1', array($backend), $userManager);
+
+		$backend->expects($this->once())
+			->method('inGroup')
+			->with('user1', 'group1')
+			->will($this->returnValue(true));
+
+		$this->assertTrue($group->inGroup(new User('user1', null)));
+	}
+
+	public function testInGroupMultipleBackends() {
+		$backend1 = $this->getMock('OC_Group_Database');
+		$backend2 = $this->getMock('OC_Group_Database');
+		$userManager = $this->getUserManager();
+		$group = new \OC\Group\Group('group1', array($backend1, $backend2), $userManager);
+
+		$backend1->expects($this->once())
+			->method('inGroup')
+			->with('user1', 'group1')
+			->will($this->returnValue(false));
+
+		$backend2->expects($this->once())
+			->method('inGroup')
+			->with('user1', 'group1')
+			->will($this->returnValue(true));
+
+		$this->assertTrue($group->inGroup(new User('user1', null)));
+	}
+
+	public function testAddUser() {
+		$backend = $this->getMock('OC_Group_Database');
+		$userManager = $this->getUserManager();
+		$group = new \OC\Group\Group('group1', array($backend), $userManager);
+
+		$backend->expects($this->once())
+			->method('inGroup')
+			->with('user1', 'group1')
+			->will($this->returnValue(false));
+		$backend->expects($this->any())
+			->method('implementsActions')
+			->will($this->returnValue(true));
+
+		$backend->expects($this->once())
+			->method('addToGroup')
+			->with('user1', 'group1');
+
+		$group->addUser(new User('user1', null));
+	}
+
+	public function testAddUserAlreadyInGroup() {
+		$backend = $this->getMock('OC_Group_Database');
+		$userManager = $this->getUserManager();
+		$group = new \OC\Group\Group('group1', array($backend), $userManager);
+
+		$backend->expects($this->once())
+			->method('inGroup')
+			->with('user1', 'group1')
+			->will($this->returnValue(true));
+		$backend->expects($this->any())
+			->method('implementsActions')
+			->will($this->returnValue(true));
+
+		$backend->expects($this->never())
+			->method('addToGroup');
+
+		$group->addUser(new User('user1', null));
+	}
+
+	public function testRemoveUser() {
+		$backend = $this->getMock('OC_Group_Database');
+		$userManager = $this->getUserManager();
+		$group = new \OC\Group\Group('group1', array($backend), $userManager);
+
+		$backend->expects($this->once())
+			->method('inGroup')
+			->with('user1', 'group1')
+			->will($this->returnValue(true));
+		$backend->expects($this->any())
+			->method('implementsActions')
+			->will($this->returnValue(true));
+
+		$backend->expects($this->once())
+			->method('removeFromGroup')
+			->with('user1', 'group1');
+
+		$group->removeUser(new User('user1', null));
+	}
+
+	public function testRemoveUserNotInGroup() {
+		$backend = $this->getMock('OC_Group_Database');
+		$userManager = $this->getUserManager();
+		$group = new \OC\Group\Group('group1', array($backend), $userManager);
+
+		$backend->expects($this->once())
+			->method('inGroup')
+			->with('user1', 'group1')
+			->will($this->returnValue(false));
+		$backend->expects($this->any())
+			->method('implementsActions')
+			->will($this->returnValue(true));
+
+		$backend->expects($this->never())
+			->method('removeFromGroup');
+
+		$group->removeUser(new User('user1', null));
+	}
+
+	public function testRemoveUserMultipleBackends() {
+		$backend1 = $this->getMock('OC_Group_Database');
+		$backend2 = $this->getMock('OC_Group_Database');
+		$userManager = $this->getUserManager();
+		$group = new \OC\Group\Group('group1', array($backend1, $backend2), $userManager);
+
+		$backend1->expects($this->once())
+			->method('inGroup')
+			->with('user1', 'group1')
+			->will($this->returnValue(true));
+		$backend1->expects($this->any())
+			->method('implementsActions')
+			->will($this->returnValue(true));
+
+		$backend1->expects($this->once())
+			->method('removeFromGroup')
+			->with('user1', 'group1');
+
+		$backend2->expects($this->once())
+			->method('inGroup')
+			->with('user1', 'group1')
+			->will($this->returnValue(true));
+		$backend2->expects($this->any())
+			->method('implementsActions')
+			->will($this->returnValue(true));
+
+		$backend2->expects($this->once())
+			->method('removeFromGroup')
+			->with('user1', 'group1');
+
+		$group->removeUser(new User('user1', null));
+	}
+
+	public function testSearchUsers() {
+		$backend = $this->getMock('OC_Group_Database');
+		$userManager = $this->getUserManager();
+		$group = new \OC\Group\Group('group1', array($backend), $userManager);
+
+		$backend->expects($this->once())
+			->method('usersInGroup')
+			->with('group1', '2')
+			->will($this->returnValue(array('user2')));
+
+		$users = $group->searchUsers('2');
+
+		$this->assertEquals(1, count($users));
+		$user2 = $users[0];
+		$this->assertEquals('user2', $user2->getUID());
+	}
+
+	public function testSearchUsersMultipleBackends() {
+		$backend1 = $this->getMock('OC_Group_Database');
+		$backend2 = $this->getMock('OC_Group_Database');
+		$userManager = $this->getUserManager();
+		$group = new \OC\Group\Group('group1', array($backend1, $backend2), $userManager);
+
+		$backend1->expects($this->once())
+			->method('usersInGroup')
+			->with('group1', '2')
+			->will($this->returnValue(array('user2')));
+		$backend2->expects($this->once())
+			->method('usersInGroup')
+			->with('group1', '2')
+			->will($this->returnValue(array('user2')));
+
+		$users = $group->searchUsers('2');
+
+		$this->assertEquals(1, count($users));
+		$user2 = $users[0];
+		$this->assertEquals('user2', $user2->getUID());
+	}
+
+	public function testSearchUsersLimitAndOffset() {
+		$backend = $this->getMock('OC_Group_Database');
+		$userManager = $this->getUserManager();
+		$group = new \OC\Group\Group('group1', array($backend), $userManager);
+
+		$backend->expects($this->once())
+			->method('usersInGroup')
+			->with('group1', 'user', 1, 1)
+			->will($this->returnValue(array('user2')));
+
+		$users = $group->searchUsers('user', 1, 1);
+
+		$this->assertEquals(1, count($users));
+		$user2 = $users[0];
+		$this->assertEquals('user2', $user2->getUID());
+	}
+
+	public function testSearchUsersMultipleBackendsLimitAndOffset() {
+		$backend1 = $this->getMock('OC_Group_Database');
+		$backend2 = $this->getMock('OC_Group_Database');
+		$userManager = $this->getUserManager();
+		$group = new \OC\Group\Group('group1', array($backend1, $backend2), $userManager);
+
+		$backend1->expects($this->once())
+			->method('usersInGroup')
+			->with('group1', 'user', 2, 1)
+			->will($this->returnValue(array('user2')));
+		$backend2->expects($this->once())
+			->method('usersInGroup')
+			->with('group1', 'user', 1, 0)
+			->will($this->returnValue(array('user1')));
+
+		$users = $group->searchUsers('user', 2, 1);
+
+		$this->assertEquals(2, count($users));
+		$user2 = $users[0];
+		$user1 = $users[1];
+		$this->assertEquals('user2', $user2->getUID());
+		$this->assertEquals('user1', $user1->getUID());
+	}
+
+	public function testDelete() {
+		$backend = $this->getMock('OC_Group_Database');
+		$userManager = $this->getUserManager();
+		$group = new \OC\Group\Group('group1', array($backend), $userManager);
+
+		$backend->expects($this->once())
+			->method('deleteGroup')
+			->with('group1');
+		$backend->expects($this->any())
+			->method('implementsActions')
+			->will($this->returnValue(true));
+
+		$group->delete();
+	}
+}
--- a/tests/lib/group/manager.php
+++ b/tests/lib/group/manager.php
@ -0,0 +1,313 @@
+<?php
+
+/**
+ * Copyright (c) 2013 Robin Appelman <icewind@owncloud.com>
+ * This file is licensed under the Affero General Public License version 3 or
+ * later.
+ * See the COPYING-README file.
+ */
+
+namespace Test\Group;
+
+use OC\User\User;
+
+class Manager extends \PHPUnit_Framework_TestCase {
+	public function testGet() {
+		/**
+		 * @var \PHPUnit_Framework_MockObject_MockObject | \OC_Group_Backend $backend
+		 */
+		$backend = $this->getMock('\OC_Group_Database');
+		$backend->expects($this->any())
+			->method('groupExists')
+			->with('group1')
+			->will($this->returnValue(true));
+
+		/**
+		 * @var \OC\User\Manager $userManager
+		 */
+		$userManager = $this->getMock('\OC\User\Manager');
+		$manager = new \OC\Group\Manager($userManager);
+		$manager->addBackend($backend);
+
+		$group = $manager->get('group1');
+		$this->assertNotNull($group);
+		$this->assertEquals('group1', $group->getGID());
+	}
+
+	public function testGetNoBackend() {
+		/**
+		 * @var \OC\User\Manager $userManager
+		 */
+		$userManager = $this->getMock('\OC\User\Manager');
+		$manager = new \OC\Group\Manager($userManager);
+
+		$this->assertNull($manager->get('group1'));
+	}
+
+	public function testGetNotExists() {
+		/**
+		 * @var \PHPUnit_Framework_MockObject_MockObject | \OC_Group_Backend $backend
+		 */
+		$backend = $this->getMock('\OC_Group_Database');
+		$backend->expects($this->once())
+			->method('groupExists')
+			->with('group1')
+			->will($this->returnValue(false));
+
+		/**
+		 * @var \OC\User\Manager $userManager
+		 */
+		$userManager = $this->getMock('\OC\User\Manager');
+		$manager = new \OC\Group\Manager($userManager);
+		$manager->addBackend($backend);
+
+		$this->assertNull($manager->get('group1'));
+	}
+
+	public function testGetDeleted() {
+		$backend = new \OC_Group_Dummy();
+		$backend->createGroup('group1');
+
+		/**
+		 * @var \OC\User\Manager $userManager
+		 */
+		$userManager = $this->getMock('\OC\User\Manager');
+		$manager = new \OC\Group\Manager($userManager);
+		$manager->addBackend($backend);
+
+		$group = $manager->get('group1');
+		$group->delete();
+		$this->assertNull($manager->get('group1'));
+	}
+
+	public function testGetMultipleBackends() {
+		/**
+		 * @var \PHPUnit_Framework_MockObject_MockObject | \OC_Group_Backend $backend1
+		 */
+		$backend1 = $this->getMock('\OC_Group_Database');
+		$backend1->expects($this->any())
+			->method('groupExists')
+			->with('group1')
+			->will($this->returnValue(false));
+
+		/**
+		 * @var \PHPUnit_Framework_MockObject_MockObject | \OC_Group_Backend $backend2
+		 */
+		$backend2 = $this->getMock('\OC_Group_Database');
+		$backend2->expects($this->any())
+			->method('groupExists')
+			->with('group1')
+			->will($this->returnValue(true));
+
+		/**
+		 * @var \OC\User\Manager $userManager
+		 */
+		$userManager = $this->getMock('\OC\User\Manager');
+		$manager = new \OC\Group\Manager($userManager);
+		$manager->addBackend($backend1);
+		$manager->addBackend($backend2);
+
+		$group = $manager->get('group1');
+		$this->assertNotNull($group);
+		$this->assertEquals('group1', $group->getGID());
+	}
+
+	public function testCreate() {
+		/**
+		 * @var \PHPUnit_Framework_MockObject_MockObject | \OC_Group_Backend $backend
+		 */
+		$backend = $this->getMock('\OC_Group_Database');
+		$backend->expects($this->any())
+			->method('groupExists')
+			->with('group1')
+			->will($this->returnValue(false));
+		$backend->expects($this->once())
+			->method('implementsActions')
+			->will($this->returnValue(true));
+		$backend->expects($this->once())
+			->method('createGroup');
+
+		/**
+		 * @var \OC\User\Manager $userManager
+		 */
+		$userManager = $this->getMock('\OC\User\Manager');
+		$manager = new \OC\Group\Manager($userManager);
+		$manager->addBackend($backend);
+
+		$group = $manager->createGroup('group1');
+		$this->assertEquals('group1', $group->getGID());
+	}
+
+	public function testCreateExists() {
+		/**
+		 * @var \PHPUnit_Framework_MockObject_MockObject | \OC_Group_Backend $backend
+		 */
+		$backend = $this->getMock('\OC_Group_Database');
+		$backend->expects($this->any())
+			->method('groupExists')
+			->with('group1')
+			->will($this->returnValue(true));
+		$backend->expects($this->never())
+			->method('createGroup');
+
+		/**
+		 * @var \OC\User\Manager $userManager
+		 */
+		$userManager = $this->getMock('\OC\User\Manager');
+		$manager = new \OC\Group\Manager($userManager);
+		$manager->addBackend($backend);
+
+		$group = $manager->createGroup('group1');
+		$this->assertEquals('group1', $group->getGID());
+	}
+
+	public function testSearch() {
+		/**
+		 * @var \PHPUnit_Framework_MockObject_MockObject | \OC_Group_Backend $backend
+		 */
+		$backend = $this->getMock('\OC_Group_Database');
+		$backend->expects($this->once())
+			->method('getGroups')
+			->with('1')
+			->will($this->returnValue(array('group1')));
+
+		/**
+		 * @var \OC\User\Manager $userManager
+		 */
+		$userManager = $this->getMock('\OC\User\Manager');
+		$manager = new \OC\Group\Manager($userManager);
+		$manager->addBackend($backend);
+
+		$groups = $manager->search('1');
+		$this->assertEquals(1, count($groups));
+		$group1 = $groups[0];
+		$this->assertEquals('group1', $group1->getGID());
+	}
+
+	public function testSearchMultipleBackends() {
+		/**
+		 * @var \PHPUnit_Framework_MockObject_MockObject | \OC_Group_Backend $backend1
+		 */
+		$backend1 = $this->getMock('\OC_Group_Database');
+		$backend1->expects($this->once())
+			->method('getGroups')
+			->with('1')
+			->will($this->returnValue(array('group1')));
+
+		/**
+		 * @var \PHPUnit_Framework_MockObject_MockObject | \OC_Group_Backend $backend2
+		 */
+		$backend2 = $this->getMock('\OC_Group_Database');
+		$backend2->expects($this->once())
+			->method('getGroups')
+			->with('1')
+			->will($this->returnValue(array('group12', 'group1')));
+
+		/**
+		 * @var \OC\User\Manager $userManager
+		 */
+		$userManager = $this->getMock('\OC\User\Manager');
+		$manager = new \OC\Group\Manager($userManager);
+		$manager->addBackend($backend1);
+		$manager->addBackend($backend2);
+
+		$groups = $manager->search('1');
+		$this->assertEquals(2, count($groups));
+		$group1 = $groups[0];
+		$group12 = $groups[1];
+		$this->assertEquals('group1', $group1->getGID());
+		$this->assertEquals('group12', $group12->getGID());
+	}
+
+	public function testSearchMultipleBackendsLimitAndOffset() {
+		/**
+		 * @var \PHPUnit_Framework_MockObject_MockObject | \OC_Group_Backend $backend1
+		 */
+		$backend1 = $this->getMock('\OC_Group_Database');
+		$backend1->expects($this->once())
+			->method('getGroups')
+			->with('1', 2, 1)
+			->will($this->returnValue(array('group1')));
+
+		/**
+		 * @var \PHPUnit_Framework_MockObject_MockObject | \OC_Group_Backend $backend2
+		 */
+		$backend2 = $this->getMock('\OC_Group_Database');
+		$backend2->expects($this->once())
+			->method('getGroups')
+			->with('1', 1, 0)
+			->will($this->returnValue(array('group12')));
+
+		/**
+		 * @var \OC\User\Manager $userManager
+		 */
+		$userManager = $this->getMock('\OC\User\Manager');
+		$manager = new \OC\Group\Manager($userManager);
+		$manager->addBackend($backend1);
+		$manager->addBackend($backend2);
+
+		$groups = $manager->search('1', 2, 1);
+		$this->assertEquals(2, count($groups));
+		$group1 = $groups[0];
+		$group12 = $groups[1];
+		$this->assertEquals('group1', $group1->getGID());
+		$this->assertEquals('group12', $group12->getGID());
+	}
+
+	public function testGetUserGroups() {
+		/**
+		 * @var \PHPUnit_Framework_MockObject_MockObject | \OC_Group_Backend $backend
+		 */
+		$backend = $this->getMock('\OC_Group_Database');
+		$backend->expects($this->once())
+			->method('getUserGroups')
+			->with('user1')
+			->will($this->returnValue(array('group1')));
+
+		/**
+		 * @var \OC\User\Manager $userManager
+		 */
+		$userManager = $this->getMock('\OC\User\Manager');
+		$manager = new \OC\Group\Manager($userManager);
+		$manager->addBackend($backend);
+
+		$groups = $manager->getUserGroups(new User('user1', null));
+		$this->assertEquals(1, count($groups));
+		$group1 = $groups[0];
+		$this->assertEquals('group1', $group1->getGID());
+	}
+
+	public function testGetUserGroupsMultipleBackends() {
+		/**
+		 * @var \PHPUnit_Framework_MockObject_MockObject | \OC_Group_Backend $backend1
+		 */
+		$backend1 = $this->getMock('\OC_Group_Database');
+		$backend1->expects($this->once())
+			->method('getUserGroups')
+			->with('user1')
+			->will($this->returnValue(array('group1')));
+		/**
+		 * @var \PHPUnit_Framework_MockObject_MockObject | \OC_Group_Backend $backend2
+		 */
+		$backend2 = $this->getMock('\OC_Group_Database');
+		$backend2->expects($this->once())
+			->method('getUserGroups')
+			->with('user1')
+			->will($this->returnValue(array('group1', 'group2')));
+
+		/**
+		 * @var \OC\User\Manager $userManager
+		 */
+		$userManager = $this->getMock('\OC\User\Manager');
+		$manager = new \OC\Group\Manager($userManager);
+		$manager->addBackend($backend1);
+		$manager->addBackend($backend2);
+
+		$groups = $manager->getUserGroups(new User('user1', null));
+		$this->assertEquals(2, count($groups));
+		$group1 = $groups[0];
+		$group2 = $groups[1];
+		$this->assertEquals('group1', $group1->getGID());
+		$this->assertEquals('group2', $group2->getGID());
+	}
+}