GroupControllerTest.php

Go to the documentation of this file.

<?php
/*
 * SPDX-FileCopyrightText: © 2022 Samuel Dushimimana <dushsam100@gmail.com>
 *
 * SPDX-License-Identifier: GPL-2.0-only
*/
namespace Fossology\UI\Api\Test\Controllers;
 
require_once dirname(__DIR__, 4) . '/lib/php/Plugin/FO_Plugin.php';
 
 
use Fossology\Lib\Auth\Auth;
use Fossology\Lib\Dao\UserDao;
use Fossology\Lib\Db\DbManager;
use Fossology\UI\Api\Controllers\GroupController;
use Fossology\UI\Api\Exceptions\HttpBadRequestException;
use Fossology\UI\Api\Exceptions\HttpForbiddenException;
use Fossology\UI\Api\Exceptions\HttpNotFoundException;
use Fossology\UI\Api\Helper\DbHelper;
use Fossology\UI\Api\Helper\ResponseHelper;
use Fossology\UI\Api\Helper\RestHelper;
use Fossology\UI\Api\Models\Info;
use Fossology\UI\Api\Models\InfoType;
use Fossology\UI\Api\Models\ApiVersion;
use Fossology\UI\Api\Models\User;
use Fossology\UI\Api\Models\UserGroupMember;
use Mockery as M;
use Slim\Psr7\Factory\StreamFactory;
use Slim\Psr7\Headers;
use Slim\Psr7\Request;
use Slim\Psr7\Uri;
 
 
class GroupControllerTest extends \PHPUnit\Framework\TestCase
{
 
  const YAML_LOC = __DIR__ . '/../../../ui/api/documentation/openapi.yaml';
 
  private $assertCountBefore;
 
  private $dbHelper;
 
  private $restHelper;
 
  private $adminPlugin;
 
  protected function setUp() : void
  {
    global $container;
    $container = M::mock('ContainerBuilder');
    $this->dbHelper = M::mock(DbHelper::class);
    $this->restHelper = M::mock(RestHelper::class);
    $this->userDao = M::mock(UserDao::class);
    $this->adminPlugin = M::mock('AdminGroupUsers');
 
    $this->restHelper->shouldReceive('getDbHelper')->andReturn($this->dbHelper);
    $this->restHelper->shouldReceive('getUserDao')
      ->andReturn($this->userDao);
 
    $this->restHelper->shouldReceive('getPlugin')
      ->withArgs(array('group_manage_users'))->andReturn($this->adminPlugin);
 
    $container->shouldReceive('get')->withArgs(array(
      'helper.restHelper'))->andReturn($this->restHelper);
    $this->groupController = new GroupController($container);
    $this->assertCountBefore = \Hamcrest\MatcherAssert::getCount();
    $this->dbManager = M::mock(DbManager::class);
    $this->dbHelper->shouldReceive('getDbManager')->andReturn($this->dbManager);
    $this->streamFactory = new StreamFactory();
  }
 
 
  protected function tearDown() : void
  {
    $this->addToAssertionCount(
      \Hamcrest\MatcherAssert::getCount() - $this->assertCountBefore);
    M::close();
  }
 
  private function getResponseJson($response)
  {
    $response->getBody()->seek(0);
    return json_decode($response->getBody()->getContents(), true);
  }
 
  private function getGroupMembers($userIds)
  {
    $groupPermissions = array("NONE" => -1, UserDao::USER => 0,
      UserDao::ADMIN => 1, UserDao::ADVISOR => 2);
 
    $memberList = array();
    foreach ($userIds as $userId) {
      $key = array_rand($groupPermissions);
      $userGroupMember =  new UserGroupMember(new User($userId, "user$userId", "User $userId",
        null, null, null, null, null),$groupPermissions[$key]) ;
      $memberList[] = $userGroupMember->getArray();
    }
    return $memberList;
  }
 
  private function getUsersWithGroup($userIds)
  {
    $groupPermissions = array("NONE" => -1, UserDao::USER => 0,
      UserDao::ADMIN => 1, UserDao::ADVISOR => 2);
 
    $usersWithGroup = array();
    foreach ($userIds as $userId) {
      $perm = array_rand($groupPermissions);
      $user = [
        "user_pk"   => $userId,
        "group_perm"=> $perm,
        "user_name" => $userId."username",
        "user_desc" => $userId."desc",
        "user_status"=> 'active'
      ];
      $usersWithGroup[] = $user;
    }
    return $usersWithGroup;
  }
  public function testCreateGroupV1()
  {
    $this->testCreateGroup(ApiVersion::V1);
  }
  public function testCreateGroupV2()
  {
    $this->testCreateGroup();
  }
  private function testCreateGroup($version = ApiVersion::V2)
  {
    $groupName = 'fossyGroup';
    $groupId = 4;
    $userId = 1;
 
    $this->restHelper->shouldReceive('getUserId')->andReturn($userId);
    $this->userDao->shouldReceive('addGroup')->withArgs([$groupName])
      ->andReturn($groupId);
    $this->userDao->shouldReceive('addGroupMembership')
      ->withArgs([$groupId, $userId]);
 
    $requestHeaders = new Headers();
    if ($version == ApiVersion::V2) {
      $request = new Request("POST",
        new Uri("HTTP", "localhost", null, "/groups", "name=" . $groupName),
        $requestHeaders, [], [], $this->streamFactory->createStream());
    } else {
      $requestHeaders->setHeader('name', $groupName);
      $request = new Request("POST", new Uri("HTTP", "localhost"),
        $requestHeaders, [], [], $this->streamFactory->createStream());
    }
    $request = $request->withAttribute(ApiVersion::ATTRIBUTE_NAME, $version);
 
    $expectedCode = $version == ApiVersion::V2 ? 201 : 200;
    $expectedResponse = new Info($expectedCode,
      "Group $groupName added.", InfoType::INFO);
 
    $actualResponse = $this->groupController->createGroup($request,
      new ResponseHelper(), []);
 
    $this->assertEquals($expectedResponse->getCode(),
      $actualResponse->getStatusCode());
    $this->assertEquals($expectedResponse->getArray(),
      $this->getResponseJson($actualResponse));
  }
  public function testDeleteGroupV1()
  {
    $this->testDeleteGroup(ApiVersion::V1);
  }
  public function testDeleteGroupV2()
  {
    $this->testDeleteGroup();
  }
  private function testDeleteGroup($version = ApiVersion::V2)
  {
    $groupId = 4;
    $userId = 1;
    $userPk = 1;
    $newUser = 2;
    $request = M::mock(Request::class);
    $userArray = ['user_pk' => $newUser];
 
    $_SESSION[Auth::USER_LEVEL] = Auth::PERM_WRITE;
    if ($version == ApiVersion::V2) {
      $this->restHelper->getUserDao()->shouldReceive('getGroupIdByName')->withArgs([$groupId])->andReturn($groupId);
      $this->restHelper->getUserDao()->shouldReceive('getUserByName')->withArgs([$userPk])->andReturn($userArray);
    }
    $request->shouldReceive('getAttribute')->andReturn($version);
    $this->restHelper->shouldReceive('getUserId')->andReturn($userId);
    $this->dbHelper->shouldReceive('doesIdExist')
      ->withArgs(["groups", "group_pk", $groupId])->andReturn(true);
    $_SESSION[Auth::USER_LEVEL] = Auth::PERM_WRITE;
    $this->userDao->shouldReceive('getDeletableAdminGroupMap')->withArgs([$userId,$_SESSION[Auth::USER_LEVEL]]);
    $this->userDao->shouldReceive('deleteGroup')->withArgs([$groupId]);
 
    $info = new Info(202, "User Group will be deleted", InfoType::INFO);
    $expectedResponse = (new ResponseHelper())->withJson($info->getArray(),
      $info->getCode());
    $actualResponse = $this->groupController->deleteGroup($request, new ResponseHelper(),
      ['pathParam' => $groupId]);
 
    $this->assertEquals($expectedResponse->getStatusCode(),
      $actualResponse->getStatusCode());
    $this->assertEquals($this->getResponseJson($expectedResponse),
      $this->getResponseJson($actualResponse));
  }
  public function testGetDeletableGroupsV1()
  {
    $this->testGetDeletableGroups(ApiVersion::V1);
  }
  public function testGetDeletableGroupsV2()
  {
    $this->testGetDeletableGroups();
  }
  private function testGetDeletableGroups($version = ApiVersion::V2)
  {
    $userId = 2;
    $groupList = array();
    $this->restHelper->shouldReceive('getUserId')->andReturn($userId);
    $_SESSION[Auth::USER_LEVEL] = Auth::PERM_WRITE;
    $this->userDao->shouldReceive('getDeletableAdminGroupMap')->withArgs([$userId,
      $_SESSION[Auth::USER_LEVEL]])->andReturn([]);
    $expectedResponse = (new ResponseHelper())->withJson($groupList, 200);
    $actualResponse = $this->groupController->getDeletableGroups(null, new ResponseHelper(), []);
    $this->assertEquals($expectedResponse->getStatusCode(), $actualResponse->getStatusCode());
    $this->assertEquals($this->getResponseJson($expectedResponse), $this->getResponseJson($actualResponse));
  }
  public function testGetGroupMembersV2()
  {
    $this->testGetGroupMembers();
  }
  public function testGetGroupMembersV1()
  {
    $this->testGetGroupMembers(APiVersion::V1);
  }
  private function testGetGroupMembers($version = ApiVersion::V2)
  {
    $userIds = [2];
    $groupName = 'fossy';
    $groupId = 1;
    $newuser = 3;
    $userPk = 2;
    $memberList = $this->getGroupMembers($userIds);
    $request = M::mock(Request::class);
    $groupIds = [1,2,3,4,5,6];
    $userArray = ['user_pk' => $newuser];
 
    $_SESSION[Auth::USER_LEVEL] = Auth::PERM_WRITE;
    if ($version == ApiVersion::V2) {
      $this->restHelper->getUserDao()->shouldReceive('getGroupIdByName')->withArgs([$groupIds[0]])->andReturn($groupIds[0]);
      $this->restHelper->getUserDao()->shouldReceive('getUserByName')->withArgs([$userPk])->andReturn($userArray);
    }
    $request->shouldReceive('getAttribute')->andReturn($version);
    $this->restHelper->getUserDao()->shouldReceive('getGroupIdByName')->withArgs([$groupName])->andReturn($groupId);
    $this->restHelper->shouldReceive('getUserId')->andReturn($userIds[0]);
    $this->userDao->shouldReceive('getAdminGroupMap')->withArgs([$userIds[0],$_SESSION[Auth::USER_LEVEL]])->andReturn([1]);
 
    $this->dbManager->shouldReceive('prepare')->withArgs([M::any(),M::any()]);
    $this->dbManager->shouldReceive('execute')->withArgs([M::any(),array($groupId)])->andReturn(1);
    $this->dbManager->shouldReceive('fetchAll')->withArgs([1])->andReturn($this->getUsersWithGroup($userIds));
    $this->dbManager->shouldReceive('freeResult')->withArgs([1]);
 
    $user = $this->getUsersWithGroup($userIds)[0];
    $users = [];
    $users[] = new User($user["user_pk"], $user["user_name"], $user["user_desc"],
      null, null, null, null, null);
    $this->dbHelper->shouldReceive("getUsers")->withArgs([$user['user_pk']])->andReturn($users);
 
    $expectedResponse = (new ResponseHelper())->withJson($memberList, 200);
 
    $actualResponse = $this->groupController->getGroupMembers($request, new ResponseHelper(), ['pathParam' => $groupId]);
    $this->assertEquals($expectedResponse->getStatusCode(),$actualResponse->getStatusCode());
  }
  public function testAddMemberUserNotMemberV1()
  {
    $this->testAddMemberUserNotMember(ApiVersion::V1);
  }
  public function testAddMemberUserNotMemberV2()
  {
    $this->testAddMemberUserNotMember();
  }
  public function testAddMemberUserNotMember($version = ApiVersion::V2)
  {
    $groupId = 1;
    $newuser = 1;
    $newPerm = 2;
    $emptyArr=[];
    $groupIds = [1,2,3,4,5,6];
    $userArray = ['user_pk' => $newuser];
    $userId = 1;
 
    $_SESSION[Auth::USER_LEVEL] = Auth::PERM_ADMIN;
    if ($version == ApiVersion::V2) {
      $this->restHelper->getUserDao()->shouldReceive('getGroupIdByName')->withArgs([$groupIds[0]])->andReturn($groupId);
      $this->restHelper->getUserDao()->shouldReceive('getUserByName')->withArgs([$userId])->andReturn($userArray);
    }
    $this->dbHelper->shouldReceive('doesIdExist')->withArgs(["groups", "group_pk", $groupId])->andReturn(true);
    $this->dbHelper->shouldReceive('doesIdExist')->withArgs(["users","user_pk",$newuser])->andReturn(true);
    $this->dbManager->shouldReceive('getSingleRow')->withArgs([M::any(),M::any(),M::any()])->andReturn($emptyArr);
    $this->restHelper->shouldReceive('getUserId')->andReturn($userId);
    $this->userDao->shouldReceive('isAdvisorOrAdmin')->withArgs([$userId, $groupId])->andReturn(true);
 
    $this->dbManager->shouldReceive('prepare')->withArgs([M::any(),M::any()]);
    $this->dbManager->shouldReceive('execute')->withArgs([M::any(),array($groupId, $newuser,$newPerm)])->andReturn(1);
    $this->dbManager->shouldReceive('freeResult')->withArgs([1]);
 
    $body = $this->streamFactory->createStream(json_encode([
      "perm" => $newPerm
    ]));
    $requestHeaders = new Headers();
    $requestHeaders->setHeader('Content-Type', 'application/json');
    $request = new Request("POST", new Uri("HTTP", "localhost"),
      $requestHeaders, [], [], $body);
    $request = $request->withAttribute(ApiVersion::ATTRIBUTE_NAME,$version);
    $expectedResponse =  new Info(201, "User added to group.", InfoType::INFO);
 
    $actualResponse = $this->groupController->addMember($request, new ResponseHelper(), ['pathParam' => $groupId,'userPathParam' => $newuser]);
    $this->assertEquals($expectedResponse->getCode(),$actualResponse->getStatusCode());
    $this->assertEquals($expectedResponse->getArray(),$this->getResponseJson($actualResponse));
  }
  public function testAddMemberUserNotAdminV2()
  {
    $this->testAddMemberUserNotAdmin();
  }
  public function testAddMemberUserNotAdminV1()
  {
    $this->testAddMemberUserNotAdmin(ApiVersion::V1);
  }
  private function testAddMemberUserNotAdmin($version = ApiVersion::V2)
  {
    $groupId = 1;
    $newuser = 1;
    $newPerm = 2;
    $groupIds = [1,2,3,4,5,6];
    $userArray = ['user_pk' => $newuser];
    $userId = 1;
 
    $_SESSION[Auth::USER_LEVEL] = Auth::PERM_WRITE;
    if ($version == ApiVersion::V2) {
      $this->restHelper->getUserDao()->shouldReceive('getGroupIdByName')->withArgs([$groupIds[0]])->andReturn($groupId);
      $this->restHelper->getUserDao()->shouldReceive('getUserByName')->withArgs([$userId])->andReturn($userArray);
    }
    $this->dbHelper->shouldReceive('doesIdExist')->withArgs(["groups", "group_pk", $groupId])->andReturn(true);
    $this->dbHelper->shouldReceive('doesIdExist')->withArgs(["users","user_pk",$newuser])->andReturn(true);
    $this->restHelper->shouldReceive('getUserId')->andReturn($userId);
    $this->userDao->shouldReceive('isAdvisorOrAdmin')->withArgs([$userId, $groupId])->andReturn(false);
 
    $body = $this->streamFactory->createStream(json_encode([
      "perm" => $newPerm
    ]));
    $requestHeaders = new Headers();
    $requestHeaders->setHeader('Content-Type', 'application/json');
    $request = new Request("POST", new Uri("HTTP", "localhost"),
      $requestHeaders, [], [], $body);
    $request = $request->withAttribute(ApiVersion::ATTRIBUTE_NAME,$version);
    $this->expectException(HttpForbiddenException::class);
 
    $this->groupController->addMember($request, new ResponseHelper(),
      ['pathParam' => $groupId,'userPathParam' => $newuser]);
  }
 
  public function testAddMemberUserGroupAdminV1()
  {
    $this->testAddMemberUserGroupAdmin(ApiVersion::V1);
  }
  public function testAddMemberUserGroupAdminV2()
  {
    $this->testAddMemberUserGroupAdmin();
  }
  private  function testAddMemberUserGroupAdmin($version = ApiVersion::V2)
  {
    $groupId = 1;
    $newuser = 1;
    $newPerm = 2;
    $emptyArr=[];
    $groupIds = [1,2,3,4,5,6];
    $userArray = ['user_pk' => $newuser];
    $userId = 1;
 
    $_SESSION[Auth::USER_LEVEL] = Auth::PERM_WRITE;
    if ($version == ApiVersion::V2) {
      $this->restHelper->getUserDao()->shouldReceive('getGroupIdByName')->withArgs([$groupIds[0]])->andReturn($groupId);
      $this->restHelper->getUserDao()->shouldReceive('getUserByName')->withArgs([$userId])->andReturn($userArray);
    }
    $this->dbHelper->shouldReceive('doesIdExist')->withArgs(["groups", "group_pk", $groupId])->andReturn(true);
    $this->dbHelper->shouldReceive('doesIdExist')->withArgs(["users","user_pk",$newuser])->andReturn(true);
    $this->dbManager->shouldReceive('getSingleRow')->withArgs([M::any(),M::any(),M::any()])->andReturn($emptyArr);
    $this->restHelper->shouldReceive('getUserId')->andReturn($userId);
    $this->userDao->shouldReceive('isAdvisorOrAdmin')->withArgs([$userId, $groupId])->andReturn(true);
 
    $this->dbManager->shouldReceive('prepare')->withArgs([M::any(),M::any()]);
    $this->dbManager->shouldReceive('execute')->withArgs([M::any(),array($groupId, $newuser,$newPerm)])->andReturn(1);
    $this->dbManager->shouldReceive('freeResult')->withArgs([1]);
 
    $body = $this->streamFactory->createStream(json_encode([
      "perm" => $newPerm
    ]));
    $requestHeaders = new Headers();
    $requestHeaders->setHeader('Content-Type', 'application/json');
    $request = new Request("POST", new Uri("HTTP", "localhost"),
      $requestHeaders, [], [], $body);
    $request = $request->withAttribute(ApiVersion::ATTRIBUTE_NAME,$version);
    $expectedResponse =  new Info(201, "User added to group.", InfoType::INFO);
 
    $actualResponse = $this->groupController->addMember($request, new ResponseHelper(), ['pathParam' => $groupId,'userPathParam' => $newuser]);
    $this->assertEquals($expectedResponse->getCode(),$actualResponse->getStatusCode());
    $this->assertEquals($expectedResponse->getArray(),$this->getResponseJson($actualResponse));
  }
 
  public function testAddMemberUserAlreadyMemberV2()
  {
    $this->testAddMemberUserAlreadyMember();
  }
  public function testAddMemberUserAlreadyMemberV1()
  {
    $this->testAddMemberUserAlreadyMember(ApiVersion::V1);
  }
 
  private function testAddMemberUserAlreadyMember($version = ApiVersion::V2)
  {
    $groupId = 1;
    $newuser = 1;
    $newPerm = 2;
    $groupIds = [1,2,3,4,5,6];
    $userArray = ['user_pk' => $newuser];
    $userId = 1;
 
    $_SESSION[Auth::USER_LEVEL] = Auth::PERM_ADMIN;
    if ($version == ApiVersion::V2) {
      $this->restHelper->getUserDao()->shouldReceive('getGroupIdByName')->withArgs([$groupIds[0]])->andReturn($groupId);
      $this->restHelper->getUserDao()->shouldReceive('getUserByName')->withArgs([$userId])->andReturn($userArray);
    }
    $this->dbHelper->shouldReceive('doesIdExist')->withArgs(["groups", "group_pk", $groupId])->andReturn(true);
    $this->dbHelper->shouldReceive('doesIdExist')->withArgs(["users","user_pk",$newuser])->andReturn(true);
    $this->dbManager->shouldReceive('getSingleRow')->withArgs([M::any(),M::any(),M::any()])->andReturn(true);
    $this->restHelper->shouldReceive('getUserId')->andReturn($userId);
    $this->userDao->shouldReceive('isAdvisorOrAdmin')->withArgs([$userId, $groupId])->andReturn(true);
 
    $body = $this->streamFactory->createStream(json_encode([
      "perm" => $newPerm
    ]));
    $requestHeaders = new Headers();
    $requestHeaders->setHeader('Content-Type', 'application/json');
    $request = new Request("POST", new Uri("HTTP", "localhost"),
      $requestHeaders, [], [], $body);
    $request = $request->withAttribute(ApiVersion::ATTRIBUTE_NAME,$version);
    $this->expectException(HttpBadRequestException::class);
 
    $this->groupController->addMember($request, new ResponseHelper(),
      ['pathParam' => $groupId,'userPathParam' => $newuser]);
  }
 
  public function testChangeUserPermissionV2()
  {
    $this->testChangeUserPermission();
  }
  public function testChangeUserPermissionV1()
  {
    $this->testChangeUserPermission(ApiVersion::V1);
  }
  private function testChangeUserPermission($version = ApiVersion::V2)
  {
    $group_user_member_pk = 1;
    $newPerm = 2;
    $userPk = 1;
    $groupId = 1;
    $groupIds = [1,2,3,4,5,6];
    $userArray = ['user_pk' => $userPk];
    $userId = 1;
 
    $_SESSION[Auth::USER_LEVEL] = Auth::PERM_ADMIN;
    if ($version == ApiVersion::V2) {
      $this->restHelper->getUserDao()->shouldReceive('getGroupIdByName')->withArgs([$groupIds[0]])->andReturn($groupId);
      $this->restHelper->getUserDao()->shouldReceive('getUserByName')->withArgs([$userId])->andReturn($userArray);
    }
    $this->dbHelper->shouldReceive('doesIdExist')->withArgs(["groups", "group_pk", $groupIds[0]])->andReturn(true);
    $this->dbHelper->shouldReceive('doesIdExist')->withArgs(["users","user_pk",$userPk])->andReturn(true);
    $this->dbManager->shouldReceive('getSingleRow')->withArgs([M::any(),M::any(),M::any()])->andReturn(['group_pk'=>$groupIds[0],'group_user_member_pk'=>$group_user_member_pk,'permission'=>$newPerm]);
    $this->restHelper->shouldReceive('getUserId')->andReturn($userId);
    $this->userDao->shouldReceive('isAdvisorOrAdmin')->withArgs([$userPk, $groupIds[0]])->andReturn(true);
    $this->userDao->shouldReceive('getUserByName')->withArgs([M::any(),M::any()]);
 
    $this->adminPlugin->shouldReceive('updateGUMPermission')->withArgs([$group_user_member_pk,$newPerm, $this->dbManager ]);
 
    $body = $this->streamFactory->createStream(json_encode([
      "perm" => $newPerm
    ]));
    $requestHeaders = new Headers();
    $requestHeaders->setHeader('Content-Type', 'application/json');
    $request = new Request("POST", new Uri("HTTP", "localhost"),
      $requestHeaders, [], [], $body);
    $request = $request->withAttribute(ApiVersion::ATTRIBUTE_NAME,$version);
    $expectedResponse = new Info(202, "Permission updated successfully.", InfoType::INFO);
 
    $actualResponse = $this->groupController->changeUserPermission($request, new ResponseHelper(), ['pathParam' => $groupIds[0],'userPathParam' => $userId]);
    $this->assertEquals($expectedResponse->getCode(),$actualResponse->getStatusCode());
    $this->assertEquals($expectedResponse->getArray(),$this->getResponseJson($actualResponse));
  }
 
  public function testDeleteGroupMemberSuccessV2()
  {
    $this->testDeleteGroupMemberSuccess();
  }
 
  public function testDeleteGroupMemberSuccessV1()
  {
    $this->testDeleteGroupMemberSuccess(ApiVersion::V1);
  }
 
  private function testDeleteGroupMemberSuccess($version = ApiVersion::V2)
  {
    $groupId = 1;
    $userId = 2;
    $groupMemberPk = 5;
    $userArray = ['user_pk' => $userId];
 
    $_SESSION[Auth::USER_LEVEL] = Auth::PERM_ADMIN;
    if ($version == ApiVersion::V2) {
      $this->userDao->shouldReceive('getUserByName')
        ->withArgs([$userId])->andReturn($userArray);
      $this->userDao->shouldReceive('getGroupIdByName')
        ->withArgs([$groupId])->andReturn($groupId);
    }
    $this->restHelper->shouldReceive('getUserId')->andReturn(1);
    $this->dbHelper->shouldReceive('doesIdExist')
      ->withArgs(["groups", "group_pk", $groupId])->andReturn(true);
    $this->dbHelper->shouldReceive('doesIdExist')
      ->withArgs(["users", "user_pk", $userId])->andReturn(true);
    $this->userDao->shouldReceive('isAdvisorOrAdmin')->andReturn(true);
    $this->dbManager->shouldReceive('getSingleRow')->withArgs([M::any(), M::any(), M::any()])
      ->andReturn(['group_user_member_pk' => $groupMemberPk]);
    $this->adminPlugin->shouldReceive('updateGUMPermission')
      ->withArgs([$groupMemberPk, -1, $this->dbManager]);
 
    $requestHeaders = new Headers();
    $request = new Request("DELETE", new Uri("HTTP", "localhost"),
      $requestHeaders, [], [], $this->streamFactory->createStream());
    $request = $request->withAttribute(ApiVersion::ATTRIBUTE_NAME, $version);
 
    $expectedResponse = new Info(202, "User will be removed from group.", InfoType::INFO);
    $actualResponse = $this->groupController->deleteGroupMember($request,
      new ResponseHelper(), ['pathParam' => $groupId, 'userPathParam' => $userId]);
 
    $this->assertEquals($expectedResponse->getCode(), $actualResponse->getStatusCode());
    $this->assertEquals($expectedResponse->getArray(), $this->getResponseJson($actualResponse));
  }
 
  public function testDeleteGroupMemberUserNotFoundV2()
  {
    $groupId = 1;
    $userId = 99;
 
    $_SESSION[Auth::USER_LEVEL] = Auth::PERM_ADMIN;
    $this->userDao->shouldReceive('getUserByName')
      ->withArgs([$userId])->andReturn(null);
 
    $requestHeaders = new Headers();
    $request = new Request("DELETE", new Uri("HTTP", "localhost"),
      $requestHeaders, [], [], $this->streamFactory->createStream());
    $request = $request->withAttribute(ApiVersion::ATTRIBUTE_NAME, ApiVersion::V2);
 
    $this->expectException(HttpNotFoundException::class);
    $this->groupController->deleteGroupMember($request,
      new ResponseHelper(), ['pathParam' => $groupId, 'userPathParam' => $userId]);
  }
 
  public function testAddMemberUserNotFoundV2()
  {
    $groupId = 1;
    $userId = 99;
    $newPerm = 1;
 
    $_SESSION[Auth::USER_LEVEL] = Auth::PERM_ADMIN;
    $this->userDao->shouldReceive('getUserByName')
      ->withArgs([$userId])->andReturn(null);
 
    $body = $this->streamFactory->createStream(json_encode(["perm" => $newPerm]));
    $requestHeaders = new Headers();
    $requestHeaders->setHeader('Content-Type', 'application/json');
    $request = new Request("POST", new Uri("HTTP", "localhost"),
      $requestHeaders, [], [], $body);
    $request = $request->withAttribute(ApiVersion::ATTRIBUTE_NAME, ApiVersion::V2);
 
    $this->expectException(HttpNotFoundException::class);
    $this->groupController->addMember($request,
      new ResponseHelper(), ['pathParam' => $groupId, 'userPathParam' => $userId]);
  }
 
  public function testChangeUserPermissionUserNotFoundV2()
  {
    $groupId = 1;
    $userId = 99;
    $newPerm = 1;
 
    $_SESSION[Auth::USER_LEVEL] = Auth::PERM_ADMIN;
    $this->userDao->shouldReceive('getUserByName')
      ->withArgs([$userId])->andReturn(null);
 
    $body = $this->streamFactory->createStream(json_encode(["perm" => $newPerm]));
    $requestHeaders = new Headers();
    $requestHeaders->setHeader('Content-Type', 'application/json');
    $request = new Request("PATCH", new Uri("HTTP", "localhost"),
      $requestHeaders, [], [], $body);
    $request = $request->withAttribute(ApiVersion::ATTRIBUTE_NAME, ApiVersion::V2);
 
    $this->expectException(HttpNotFoundException::class);
    $this->groupController->changeUserPermission($request,
      new ResponseHelper(), ['pathParam' => $groupId, 'userPathParam' => $userId]);
  }
}