2015-11-24 15:48:06 +03:00
|
|
|
<?php
|
2016-07-21 19:13:36 +03:00
|
|
|
/**
|
2017-11-06 17:56:42 +03:00
|
|
|
*
|
2016-07-21 19:13:36 +03:00
|
|
|
*
|
2020-03-31 11:49:10 +03:00
|
|
|
* @author Christoph Wurst <christoph@winzerhof-wurst.at>
|
2019-12-03 21:57:53 +03:00
|
|
|
* @author Daniel Calviño Sánchez <danxuliu@gmail.com>
|
2016-07-21 19:13:36 +03:00
|
|
|
* @author Joas Schilling <coding@schilljs.com>
|
2019-12-03 21:57:53 +03:00
|
|
|
* @author John Molakvoæ (skjnldsv) <skjnldsv@protonmail.com>
|
2016-07-21 19:13:36 +03:00
|
|
|
* @author Morris Jobke <hey@morrisjobke.de>
|
2019-12-03 21:57:53 +03:00
|
|
|
* @author Robin Appelman <robin@icewind.nl>
|
2016-07-21 19:13:36 +03:00
|
|
|
* @author Roeland Jago Douma <roeland@famdouma.nl>
|
|
|
|
* @author Sergio Bertolin <sbertolin@solidgear.es>
|
|
|
|
* @author Sergio Bertolín <sbertolin@solidgear.es>
|
|
|
|
* @author Thomas Müller <thomas.mueller@tmit.eu>
|
2020-12-16 16:54:15 +03:00
|
|
|
* @author Vincent Petry <vincent@nextcloud.com>
|
2016-07-21 19:13:36 +03:00
|
|
|
*
|
|
|
|
* @license GNU AGPL version 3 or any later version
|
|
|
|
*
|
|
|
|
* This program is free software: you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU Affero General Public License as
|
|
|
|
* published by the Free Software Foundation, either version 3 of the
|
|
|
|
* License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program 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
|
2019-12-03 21:57:53 +03:00
|
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
2016-07-21 19:13:36 +03:00
|
|
|
*
|
|
|
|
*/
|
2018-02-09 15:19:39 +03:00
|
|
|
|
2015-11-24 15:48:06 +03:00
|
|
|
use GuzzleHttp\Client;
|
|
|
|
use GuzzleHttp\Message\ResponseInterface;
|
2018-06-13 08:15:42 +03:00
|
|
|
use PHPUnit\Framework\Assert;
|
2015-11-24 15:48:06 +03:00
|
|
|
|
|
|
|
require __DIR__ . '/../../vendor/autoload.php';
|
|
|
|
|
|
|
|
trait Provisioning {
|
2016-03-11 12:23:11 +03:00
|
|
|
use BasicStructure;
|
2015-11-24 15:48:06 +03:00
|
|
|
|
|
|
|
/** @var array */
|
|
|
|
private $createdUsers = [];
|
|
|
|
|
|
|
|
/** @var array */
|
|
|
|
private $createdRemoteUsers = [];
|
|
|
|
|
|
|
|
/** @var array */
|
|
|
|
private $createdRemoteGroups = [];
|
2018-02-09 15:19:39 +03:00
|
|
|
|
2015-11-24 15:48:06 +03:00
|
|
|
/** @var array */
|
|
|
|
private $createdGroups = [];
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @Given /^user "([^"]*)" exists$/
|
2016-03-11 12:23:11 +03:00
|
|
|
* @param string $user
|
2015-11-24 15:48:06 +03:00
|
|
|
*/
|
|
|
|
public function assureUserExists($user) {
|
|
|
|
try {
|
|
|
|
$this->userExists($user);
|
|
|
|
} catch (\GuzzleHttp\Exception\ClientException $ex) {
|
|
|
|
$previous_user = $this->currentUser;
|
|
|
|
$this->currentUser = "admin";
|
|
|
|
$this->creatingTheUser($user);
|
|
|
|
$this->currentUser = $previous_user;
|
|
|
|
}
|
|
|
|
$this->userExists($user);
|
2018-06-13 08:15:42 +03:00
|
|
|
Assert::assertEquals(200, $this->response->getStatusCode());
|
2015-11-24 15:48:06 +03:00
|
|
|
}
|
|
|
|
|
2020-08-05 11:56:40 +03:00
|
|
|
/**
|
2020-09-18 19:32:59 +03:00
|
|
|
* @Given /^user "([^"]*)" with displayname "((?:[^"]|\\")*)" exists$/
|
2020-08-05 11:56:40 +03:00
|
|
|
* @param string $user
|
|
|
|
*/
|
|
|
|
public function assureUserWithDisplaynameExists($user, $displayname) {
|
|
|
|
try {
|
|
|
|
$this->userExists($user);
|
|
|
|
} catch (\GuzzleHttp\Exception\ClientException $ex) {
|
|
|
|
$previous_user = $this->currentUser;
|
|
|
|
$this->currentUser = "admin";
|
|
|
|
$this->creatingTheUser($user, $displayname);
|
|
|
|
$this->currentUser = $previous_user;
|
|
|
|
}
|
|
|
|
$this->userExists($user);
|
|
|
|
Assert::assertEquals(200, $this->response->getStatusCode());
|
|
|
|
}
|
|
|
|
|
2015-11-24 15:48:06 +03:00
|
|
|
/**
|
|
|
|
* @Given /^user "([^"]*)" does not exist$/
|
2016-03-11 12:23:11 +03:00
|
|
|
* @param string $user
|
2015-11-24 15:48:06 +03:00
|
|
|
*/
|
|
|
|
public function userDoesNotExist($user) {
|
|
|
|
try {
|
|
|
|
$this->userExists($user);
|
|
|
|
} catch (\GuzzleHttp\Exception\ClientException $ex) {
|
|
|
|
$this->response = $ex->getResponse();
|
2018-06-13 08:15:42 +03:00
|
|
|
Assert::assertEquals(404, $ex->getResponse()->getStatusCode());
|
2015-11-24 15:48:06 +03:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
$previous_user = $this->currentUser;
|
|
|
|
$this->currentUser = "admin";
|
|
|
|
$this->deletingTheUser($user);
|
|
|
|
$this->currentUser = $previous_user;
|
|
|
|
try {
|
|
|
|
$this->userExists($user);
|
|
|
|
} catch (\GuzzleHttp\Exception\ClientException $ex) {
|
|
|
|
$this->response = $ex->getResponse();
|
2018-06-13 08:15:42 +03:00
|
|
|
Assert::assertEquals(404, $ex->getResponse()->getStatusCode());
|
2015-11-24 15:48:06 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-08-05 11:56:40 +03:00
|
|
|
public function creatingTheUser($user, $displayname = '') {
|
2015-11-24 15:48:06 +03:00
|
|
|
$fullUrl = $this->baseUrl . "v{$this->apiVersion}.php/cloud/users";
|
|
|
|
$client = new Client();
|
|
|
|
$options = [];
|
|
|
|
if ($this->currentUser === 'admin') {
|
|
|
|
$options['auth'] = $this->adminUser;
|
|
|
|
}
|
|
|
|
|
2018-02-09 15:19:39 +03:00
|
|
|
$options['form_params'] = [
|
2016-08-12 11:46:33 +03:00
|
|
|
'userid' => $user,
|
|
|
|
'password' => '123456'
|
|
|
|
];
|
2020-08-05 11:56:40 +03:00
|
|
|
if ($displayname !== '') {
|
|
|
|
$options['form_params']['displayName'] = $displayname;
|
|
|
|
}
|
2016-08-12 11:46:33 +03:00
|
|
|
$options['headers'] = [
|
|
|
|
'OCS-APIREQUEST' => 'true',
|
|
|
|
];
|
2015-11-24 15:48:06 +03:00
|
|
|
|
2018-02-09 15:19:39 +03:00
|
|
|
$this->response = $client->post($fullUrl, $options);
|
|
|
|
if ($this->currentServer === 'LOCAL') {
|
2015-11-24 15:48:06 +03:00
|
|
|
$this->createdUsers[$user] = $user;
|
|
|
|
} elseif ($this->currentServer === 'REMOTE') {
|
|
|
|
$this->createdRemoteUsers[$user] = $user;
|
|
|
|
}
|
2015-12-15 11:55:25 +03:00
|
|
|
|
|
|
|
//Quick hack to login once with the current user
|
|
|
|
$options2 = [
|
|
|
|
'auth' => [$user, '123456'],
|
|
|
|
];
|
2016-08-12 11:46:33 +03:00
|
|
|
$options2['headers'] = [
|
|
|
|
'OCS-APIREQUEST' => 'true',
|
|
|
|
];
|
2018-02-09 15:19:39 +03:00
|
|
|
$url = $fullUrl . '/' . $user;
|
|
|
|
$client->get($url, $options2);
|
2015-11-24 15:48:06 +03:00
|
|
|
}
|
|
|
|
|
2017-04-05 15:51:55 +03:00
|
|
|
/**
|
|
|
|
* @Then /^user "([^"]*)" has$/
|
|
|
|
*
|
|
|
|
* @param string $user
|
|
|
|
* @param \Behat\Gherkin\Node\TableNode|null $settings
|
|
|
|
*/
|
|
|
|
public function userHasSetting($user, $settings) {
|
|
|
|
$fullUrl = $this->baseUrl . "v{$this->apiVersion}.php/cloud/users/$user";
|
|
|
|
$client = new Client();
|
|
|
|
$options = [];
|
2021-03-25 17:30:41 +03:00
|
|
|
if ($this->currentUser === 'admin') {
|
|
|
|
$options['auth'] = $this->adminUser;
|
|
|
|
} else {
|
|
|
|
$options['auth'] = [$this->currentUser, $this->regularUser];
|
|
|
|
}
|
2017-04-05 15:51:55 +03:00
|
|
|
$options['headers'] = [
|
|
|
|
'OCS-APIREQUEST' => 'true',
|
|
|
|
];
|
|
|
|
|
2018-02-09 15:19:39 +03:00
|
|
|
$response = $client->get($fullUrl, $options);
|
2017-04-05 15:51:55 +03:00
|
|
|
foreach ($settings->getRows() as $setting) {
|
2018-02-09 15:19:39 +03:00
|
|
|
$value = json_decode(json_encode(simplexml_load_string($response->getBody())->data->{$setting[0]}), 1);
|
2017-04-05 15:51:55 +03:00
|
|
|
if (isset($value[0])) {
|
2018-06-13 08:15:42 +03:00
|
|
|
Assert::assertEquals($setting[1], $value[0], "", 0.0, 10, true);
|
2017-04-05 15:51:55 +03:00
|
|
|
} else {
|
2018-06-13 08:15:42 +03:00
|
|
|
Assert::assertEquals('', $setting[1]);
|
2017-04-05 15:51:55 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-12-02 18:03:54 +03:00
|
|
|
/**
|
|
|
|
* @Then /^search users by phone for region "([^"]*)" with$/
|
|
|
|
*
|
|
|
|
* @param string $user
|
|
|
|
* @param \Behat\Gherkin\Node\TableNode|null $settings
|
|
|
|
*/
|
|
|
|
public function searchUserByPhone($region, \Behat\Gherkin\Node\TableNode $searchTable) {
|
|
|
|
$fullUrl = $this->baseUrl . "v{$this->apiVersion}.php/cloud/users/search/by-phone";
|
|
|
|
$client = new Client();
|
|
|
|
$options = [];
|
|
|
|
$options['auth'] = $this->adminUser;
|
|
|
|
$options['headers'] = [
|
|
|
|
'OCS-APIREQUEST' => 'true',
|
|
|
|
];
|
|
|
|
|
|
|
|
$search = [];
|
|
|
|
foreach ($searchTable->getRows() as $row) {
|
|
|
|
if (!isset($search[$row[0]])) {
|
|
|
|
$search[$row[0]] = [];
|
|
|
|
}
|
|
|
|
$search[$row[0]][] = $row[1];
|
|
|
|
}
|
|
|
|
|
|
|
|
$options['form_params'] = [
|
|
|
|
'location' => $region,
|
|
|
|
'search' => $search,
|
|
|
|
];
|
|
|
|
|
|
|
|
$this->response = $client->post($fullUrl, $options);
|
|
|
|
}
|
|
|
|
|
2015-11-24 15:48:06 +03:00
|
|
|
public function createUser($user) {
|
|
|
|
$previous_user = $this->currentUser;
|
|
|
|
$this->currentUser = "admin";
|
|
|
|
$this->creatingTheUser($user);
|
|
|
|
$this->userExists($user);
|
|
|
|
$this->currentUser = $previous_user;
|
|
|
|
}
|
|
|
|
|
|
|
|
public function deleteUser($user) {
|
|
|
|
$previous_user = $this->currentUser;
|
|
|
|
$this->currentUser = "admin";
|
|
|
|
$this->deletingTheUser($user);
|
|
|
|
$this->userDoesNotExist($user);
|
|
|
|
$this->currentUser = $previous_user;
|
|
|
|
}
|
|
|
|
|
|
|
|
public function createGroup($group) {
|
|
|
|
$previous_user = $this->currentUser;
|
|
|
|
$this->currentUser = "admin";
|
|
|
|
$this->creatingTheGroup($group);
|
|
|
|
$this->groupExists($group);
|
|
|
|
$this->currentUser = $previous_user;
|
|
|
|
}
|
|
|
|
|
|
|
|
public function deleteGroup($group) {
|
|
|
|
$previous_user = $this->currentUser;
|
|
|
|
$this->currentUser = "admin";
|
|
|
|
$this->deletingTheGroup($group);
|
|
|
|
$this->groupDoesNotExist($group);
|
|
|
|
$this->currentUser = $previous_user;
|
|
|
|
}
|
|
|
|
|
2018-02-09 15:19:39 +03:00
|
|
|
public function userExists($user) {
|
2015-11-24 15:48:06 +03:00
|
|
|
$fullUrl = $this->baseUrl . "v2.php/cloud/users/$user";
|
|
|
|
$client = new Client();
|
|
|
|
$options = [];
|
|
|
|
$options['auth'] = $this->adminUser;
|
2016-08-12 11:46:33 +03:00
|
|
|
$options['headers'] = [
|
|
|
|
'OCS-APIREQUEST' => 'true'
|
|
|
|
];
|
2015-11-24 15:48:06 +03:00
|
|
|
|
|
|
|
$this->response = $client->get($fullUrl, $options);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @Then /^check that user "([^"]*)" belongs to group "([^"]*)"$/
|
2016-03-11 12:23:11 +03:00
|
|
|
* @param string $user
|
|
|
|
* @param string $group
|
2015-11-24 15:48:06 +03:00
|
|
|
*/
|
|
|
|
public function checkThatUserBelongsToGroup($user, $group) {
|
|
|
|
$fullUrl = $this->baseUrl . "v2.php/cloud/users/$user/groups";
|
|
|
|
$client = new Client();
|
|
|
|
$options = [];
|
|
|
|
if ($this->currentUser === 'admin') {
|
|
|
|
$options['auth'] = $this->adminUser;
|
|
|
|
}
|
2016-08-12 11:46:33 +03:00
|
|
|
$options['headers'] = [
|
|
|
|
'OCS-APIREQUEST' => 'true',
|
|
|
|
];
|
2015-11-24 15:48:06 +03:00
|
|
|
|
|
|
|
$this->response = $client->get($fullUrl, $options);
|
|
|
|
$respondedArray = $this->getArrayOfGroupsResponded($this->response);
|
|
|
|
sort($respondedArray);
|
2018-06-13 08:15:42 +03:00
|
|
|
Assert::assertContains($group, $respondedArray);
|
|
|
|
Assert::assertEquals(200, $this->response->getStatusCode());
|
2015-11-24 15:48:06 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
public function userBelongsToGroup($user, $group) {
|
|
|
|
$fullUrl = $this->baseUrl . "v2.php/cloud/users/$user/groups";
|
|
|
|
$client = new Client();
|
|
|
|
$options = [];
|
|
|
|
if ($this->currentUser === 'admin') {
|
|
|
|
$options['auth'] = $this->adminUser;
|
|
|
|
}
|
2016-08-12 11:46:33 +03:00
|
|
|
$options['headers'] = [
|
|
|
|
'OCS-APIREQUEST' => 'true',
|
|
|
|
];
|
2015-11-24 15:48:06 +03:00
|
|
|
|
|
|
|
$this->response = $client->get($fullUrl, $options);
|
|
|
|
$respondedArray = $this->getArrayOfGroupsResponded($this->response);
|
|
|
|
|
|
|
|
if (array_key_exists($group, $respondedArray)) {
|
2018-02-09 15:19:39 +03:00
|
|
|
return true;
|
|
|
|
} else {
|
|
|
|
return false;
|
2015-11-24 15:48:06 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @Given /^user "([^"]*)" belongs to group "([^"]*)"$/
|
2016-03-11 12:23:11 +03:00
|
|
|
* @param string $user
|
|
|
|
* @param string $group
|
2015-11-24 15:48:06 +03:00
|
|
|
*/
|
2018-02-09 15:19:39 +03:00
|
|
|
public function assureUserBelongsToGroup($user, $group) {
|
2016-03-15 16:24:21 +03:00
|
|
|
$previous_user = $this->currentUser;
|
|
|
|
$this->currentUser = "admin";
|
|
|
|
|
2018-02-09 15:19:39 +03:00
|
|
|
if (!$this->userBelongsToGroup($user, $group)) {
|
2015-11-24 15:48:06 +03:00
|
|
|
$this->addingUserToGroup($user, $group);
|
|
|
|
}
|
|
|
|
|
2016-03-15 16:24:21 +03:00
|
|
|
$this->checkThatUserBelongsToGroup($user, $group);
|
|
|
|
$this->currentUser = $previous_user;
|
2015-11-24 15:48:06 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @Given /^user "([^"]*)" does not belong to group "([^"]*)"$/
|
2016-03-11 12:23:11 +03:00
|
|
|
* @param string $user
|
|
|
|
* @param string $group
|
2015-11-24 15:48:06 +03:00
|
|
|
*/
|
|
|
|
public function userDoesNotBelongToGroup($user, $group) {
|
|
|
|
$fullUrl = $this->baseUrl . "v2.php/cloud/users/$user/groups";
|
|
|
|
$client = new Client();
|
|
|
|
$options = [];
|
|
|
|
if ($this->currentUser === 'admin') {
|
|
|
|
$options['auth'] = $this->adminUser;
|
|
|
|
}
|
2016-08-12 11:46:33 +03:00
|
|
|
$options['headers'] = [
|
|
|
|
'OCS-APIREQUEST' => 'true',
|
|
|
|
];
|
2015-11-24 15:48:06 +03:00
|
|
|
|
|
|
|
$this->response = $client->get($fullUrl, $options);
|
2020-03-26 11:30:18 +03:00
|
|
|
$groups = [$group];
|
2015-11-24 15:48:06 +03:00
|
|
|
$respondedArray = $this->getArrayOfGroupsResponded($this->response);
|
2018-06-13 08:15:42 +03:00
|
|
|
Assert::assertNotEquals($groups, $respondedArray, "", 0.0, 10, true);
|
|
|
|
Assert::assertEquals(200, $this->response->getStatusCode());
|
2015-11-24 15:48:06 +03:00
|
|
|
}
|
|
|
|
|
2016-03-11 12:23:11 +03:00
|
|
|
/**
|
2015-11-24 15:48:06 +03:00
|
|
|
* @When /^creating the group "([^"]*)"$/
|
2016-03-11 12:23:11 +03:00
|
|
|
* @param string $group
|
2015-11-24 15:48:06 +03:00
|
|
|
*/
|
|
|
|
public function creatingTheGroup($group) {
|
|
|
|
$fullUrl = $this->baseUrl . "v{$this->apiVersion}.php/cloud/groups";
|
|
|
|
$client = new Client();
|
|
|
|
$options = [];
|
|
|
|
if ($this->currentUser === 'admin') {
|
|
|
|
$options['auth'] = $this->adminUser;
|
|
|
|
}
|
|
|
|
|
2018-02-09 15:19:39 +03:00
|
|
|
$options['form_params'] = [
|
2016-08-12 11:46:33 +03:00
|
|
|
'groupid' => $group,
|
|
|
|
];
|
|
|
|
$options['headers'] = [
|
|
|
|
'OCS-APIREQUEST' => 'true',
|
|
|
|
];
|
2015-11-24 15:48:06 +03:00
|
|
|
|
2018-02-09 15:19:39 +03:00
|
|
|
$this->response = $client->post($fullUrl, $options);
|
|
|
|
if ($this->currentServer === 'LOCAL') {
|
2015-11-24 15:48:06 +03:00
|
|
|
$this->createdGroups[$group] = $group;
|
|
|
|
} elseif ($this->currentServer === 'REMOTE') {
|
|
|
|
$this->createdRemoteGroups[$group] = $group;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-04-08 18:06:53 +03:00
|
|
|
/**
|
2016-04-19 12:13:24 +03:00
|
|
|
* @When /^assure user "([^"]*)" is disabled$/
|
2016-04-08 18:06:53 +03:00
|
|
|
*/
|
2016-04-19 12:13:24 +03:00
|
|
|
public function assureUserIsDisabled($user) {
|
2016-04-08 18:06:53 +03:00
|
|
|
$fullUrl = $this->baseUrl . "v{$this->apiVersion}.php/cloud/users/$user/disable";
|
|
|
|
$client = new Client();
|
|
|
|
$options = [];
|
|
|
|
if ($this->currentUser === 'admin') {
|
|
|
|
$options['auth'] = $this->adminUser;
|
|
|
|
}
|
2016-08-12 11:46:33 +03:00
|
|
|
$options['headers'] = [
|
|
|
|
'OCS-APIREQUEST' => 'true',
|
|
|
|
];
|
|
|
|
// TODO: fix hack
|
2018-02-09 15:19:39 +03:00
|
|
|
$options['form_params'] = [
|
2016-08-12 11:46:33 +03:00
|
|
|
'foo' => 'bar'
|
|
|
|
];
|
2016-04-08 18:06:53 +03:00
|
|
|
|
2018-02-09 15:19:39 +03:00
|
|
|
$this->response = $client->put($fullUrl, $options);
|
2016-04-08 18:06:53 +03:00
|
|
|
}
|
|
|
|
|
2015-11-24 15:48:06 +03:00
|
|
|
/**
|
|
|
|
* @When /^Deleting the user "([^"]*)"$/
|
2016-03-11 12:23:11 +03:00
|
|
|
* @param string $user
|
2015-11-24 15:48:06 +03:00
|
|
|
*/
|
|
|
|
public function deletingTheUser($user) {
|
|
|
|
$fullUrl = $this->baseUrl . "v{$this->apiVersion}.php/cloud/users/$user";
|
|
|
|
$client = new Client();
|
|
|
|
$options = [];
|
|
|
|
if ($this->currentUser === 'admin') {
|
|
|
|
$options['auth'] = $this->adminUser;
|
|
|
|
}
|
2016-08-12 11:46:33 +03:00
|
|
|
$options['headers'] = [
|
|
|
|
'OCS-APIREQUEST' => 'true',
|
|
|
|
];
|
2015-11-24 15:48:06 +03:00
|
|
|
|
2018-02-09 15:19:39 +03:00
|
|
|
$this->response = $client->delete($fullUrl, $options);
|
2015-11-24 15:48:06 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @When /^Deleting the group "([^"]*)"$/
|
2016-03-11 12:23:11 +03:00
|
|
|
* @param string $group
|
2015-11-24 15:48:06 +03:00
|
|
|
*/
|
|
|
|
public function deletingTheGroup($group) {
|
|
|
|
$fullUrl = $this->baseUrl . "v{$this->apiVersion}.php/cloud/groups/$group";
|
|
|
|
$client = new Client();
|
|
|
|
$options = [];
|
|
|
|
if ($this->currentUser === 'admin') {
|
|
|
|
$options['auth'] = $this->adminUser;
|
|
|
|
}
|
2016-08-12 11:46:33 +03:00
|
|
|
$options['headers'] = [
|
|
|
|
'OCS-APIREQUEST' => 'true',
|
|
|
|
];
|
2015-11-24 15:48:06 +03:00
|
|
|
|
2018-02-09 15:19:39 +03:00
|
|
|
$this->response = $client->delete($fullUrl, $options);
|
2017-03-17 16:38:27 +03:00
|
|
|
|
2018-02-09 15:19:39 +03:00
|
|
|
if ($this->currentServer === 'LOCAL') {
|
2017-03-17 16:38:27 +03:00
|
|
|
unset($this->createdGroups[$group]);
|
|
|
|
} elseif ($this->currentServer === 'REMOTE') {
|
|
|
|
unset($this->createdRemoteGroups[$group]);
|
|
|
|
}
|
2015-11-24 15:48:06 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @Given /^Add user "([^"]*)" to the group "([^"]*)"$/
|
2016-03-11 12:23:11 +03:00
|
|
|
* @param string $user
|
|
|
|
* @param string $group
|
2015-11-24 15:48:06 +03:00
|
|
|
*/
|
|
|
|
public function addUserToGroup($user, $group) {
|
|
|
|
$this->userExists($user);
|
|
|
|
$this->groupExists($group);
|
|
|
|
$this->addingUserToGroup($user, $group);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @When /^User "([^"]*)" is added to the group "([^"]*)"$/
|
2016-03-11 12:23:11 +03:00
|
|
|
* @param string $user
|
|
|
|
* @param string $group
|
2015-11-24 15:48:06 +03:00
|
|
|
*/
|
|
|
|
public function addingUserToGroup($user, $group) {
|
|
|
|
$fullUrl = $this->baseUrl . "v{$this->apiVersion}.php/cloud/users/$user/groups";
|
|
|
|
$client = new Client();
|
|
|
|
$options = [];
|
|
|
|
if ($this->currentUser === 'admin') {
|
|
|
|
$options['auth'] = $this->adminUser;
|
|
|
|
}
|
2016-08-12 11:46:33 +03:00
|
|
|
$options['headers'] = [
|
|
|
|
'OCS-APIREQUEST' => 'true',
|
|
|
|
];
|
2015-11-24 15:48:06 +03:00
|
|
|
|
2018-02-09 15:19:39 +03:00
|
|
|
$options['form_params'] = [
|
2016-08-12 11:46:33 +03:00
|
|
|
'groupid' => $group,
|
|
|
|
];
|
2015-11-24 15:48:06 +03:00
|
|
|
|
2020-10-05 16:12:57 +03:00
|
|
|
$this->response = $client->post($fullUrl, $options);
|
2015-11-24 15:48:06 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
public function groupExists($group) {
|
|
|
|
$fullUrl = $this->baseUrl . "v2.php/cloud/groups/$group";
|
|
|
|
$client = new Client();
|
|
|
|
$options = [];
|
|
|
|
$options['auth'] = $this->adminUser;
|
2016-08-12 11:46:33 +03:00
|
|
|
$options['headers'] = [
|
|
|
|
'OCS-APIREQUEST' => 'true',
|
|
|
|
];
|
2015-11-24 15:48:06 +03:00
|
|
|
|
|
|
|
$this->response = $client->get($fullUrl, $options);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @Given /^group "([^"]*)" exists$/
|
2016-03-11 12:23:11 +03:00
|
|
|
* @param string $group
|
2015-11-24 15:48:06 +03:00
|
|
|
*/
|
|
|
|
public function assureGroupExists($group) {
|
|
|
|
try {
|
|
|
|
$this->groupExists($group);
|
|
|
|
} catch (\GuzzleHttp\Exception\ClientException $ex) {
|
|
|
|
$previous_user = $this->currentUser;
|
|
|
|
$this->currentUser = "admin";
|
|
|
|
$this->creatingTheGroup($group);
|
|
|
|
$this->currentUser = $previous_user;
|
|
|
|
}
|
|
|
|
$this->groupExists($group);
|
2018-06-13 08:15:42 +03:00
|
|
|
Assert::assertEquals(200, $this->response->getStatusCode());
|
2015-11-24 15:48:06 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @Given /^group "([^"]*)" does not exist$/
|
2016-03-11 12:23:11 +03:00
|
|
|
* @param string $group
|
2015-11-24 15:48:06 +03:00
|
|
|
*/
|
|
|
|
public function groupDoesNotExist($group) {
|
|
|
|
try {
|
|
|
|
$this->groupExists($group);
|
|
|
|
} catch (\GuzzleHttp\Exception\ClientException $ex) {
|
|
|
|
$this->response = $ex->getResponse();
|
2018-06-13 08:15:42 +03:00
|
|
|
Assert::assertEquals(404, $ex->getResponse()->getStatusCode());
|
2015-11-24 15:48:06 +03:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
$previous_user = $this->currentUser;
|
|
|
|
$this->currentUser = "admin";
|
|
|
|
$this->deletingTheGroup($group);
|
|
|
|
$this->currentUser = $previous_user;
|
|
|
|
try {
|
|
|
|
$this->groupExists($group);
|
|
|
|
} catch (\GuzzleHttp\Exception\ClientException $ex) {
|
|
|
|
$this->response = $ex->getResponse();
|
2018-06-13 08:15:42 +03:00
|
|
|
Assert::assertEquals(404, $ex->getResponse()->getStatusCode());
|
2015-11-24 15:48:06 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @Given /^user "([^"]*)" is subadmin of group "([^"]*)"$/
|
2016-03-11 12:23:11 +03:00
|
|
|
* @param string $user
|
|
|
|
* @param string $group
|
2015-11-24 15:48:06 +03:00
|
|
|
*/
|
|
|
|
public function userIsSubadminOfGroup($user, $group) {
|
|
|
|
$fullUrl = $this->baseUrl . "v2.php/cloud/groups/$group/subadmins";
|
|
|
|
$client = new Client();
|
|
|
|
$options = [];
|
|
|
|
if ($this->currentUser === 'admin') {
|
|
|
|
$options['auth'] = $this->adminUser;
|
|
|
|
}
|
2016-08-12 11:46:33 +03:00
|
|
|
$options['headers'] = [
|
|
|
|
'OCS-APIREQUEST' => 'true',
|
|
|
|
];
|
2015-11-24 15:48:06 +03:00
|
|
|
|
|
|
|
$this->response = $client->get($fullUrl, $options);
|
|
|
|
$respondedArray = $this->getArrayOfSubadminsResponded($this->response);
|
|
|
|
sort($respondedArray);
|
2018-06-13 08:15:42 +03:00
|
|
|
Assert::assertContains($user, $respondedArray);
|
|
|
|
Assert::assertEquals(200, $this->response->getStatusCode());
|
2015-11-24 15:48:06 +03:00
|
|
|
}
|
|
|
|
|
2016-04-19 12:13:24 +03:00
|
|
|
/**
|
|
|
|
* @Given /^Assure user "([^"]*)" is subadmin of group "([^"]*)"$/
|
|
|
|
* @param string $user
|
|
|
|
* @param string $group
|
|
|
|
*/
|
|
|
|
public function assureUserIsSubadminOfGroup($user, $group) {
|
|
|
|
$fullUrl = $this->baseUrl . "v{$this->apiVersion}.php/cloud/users/$user/subadmins";
|
|
|
|
$client = new Client();
|
|
|
|
$options = [];
|
|
|
|
if ($this->currentUser === 'admin') {
|
|
|
|
$options['auth'] = $this->adminUser;
|
|
|
|
}
|
2018-02-09 15:19:39 +03:00
|
|
|
$options['form_params'] = [
|
2016-08-12 11:46:33 +03:00
|
|
|
'groupid' => $group
|
|
|
|
];
|
|
|
|
$options['headers'] = [
|
|
|
|
'OCS-APIREQUEST' => 'true',
|
|
|
|
];
|
2018-02-09 15:19:39 +03:00
|
|
|
$this->response = $client->post($fullUrl, $options);
|
2018-06-13 08:15:42 +03:00
|
|
|
Assert::assertEquals(200, $this->response->getStatusCode());
|
2016-04-19 12:13:24 +03:00
|
|
|
}
|
|
|
|
|
2015-11-24 15:48:06 +03:00
|
|
|
/**
|
|
|
|
* @Given /^user "([^"]*)" is not a subadmin of group "([^"]*)"$/
|
2016-03-11 12:23:11 +03:00
|
|
|
* @param string $user
|
|
|
|
* @param string $group
|
2015-11-24 15:48:06 +03:00
|
|
|
*/
|
|
|
|
public function userIsNotSubadminOfGroup($user, $group) {
|
|
|
|
$fullUrl = $this->baseUrl . "v2.php/cloud/groups/$group/subadmins";
|
|
|
|
$client = new Client();
|
|
|
|
$options = [];
|
|
|
|
if ($this->currentUser === 'admin') {
|
|
|
|
$options['auth'] = $this->adminUser;
|
|
|
|
}
|
2016-08-12 11:46:33 +03:00
|
|
|
$options['headers'] = [
|
|
|
|
'OCS-APIREQUEST' => 'true',
|
|
|
|
];
|
2015-11-24 15:48:06 +03:00
|
|
|
|
|
|
|
$this->response = $client->get($fullUrl, $options);
|
|
|
|
$respondedArray = $this->getArrayOfSubadminsResponded($this->response);
|
|
|
|
sort($respondedArray);
|
2018-06-13 08:15:42 +03:00
|
|
|
Assert::assertNotContains($user, $respondedArray);
|
|
|
|
Assert::assertEquals(200, $this->response->getStatusCode());
|
2015-11-24 15:48:06 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @Then /^users returned are$/
|
|
|
|
* @param \Behat\Gherkin\Node\TableNode|null $usersList
|
|
|
|
*/
|
|
|
|
public function theUsersShouldBe($usersList) {
|
|
|
|
if ($usersList instanceof \Behat\Gherkin\Node\TableNode) {
|
|
|
|
$users = $usersList->getRows();
|
|
|
|
$usersSimplified = $this->simplifyArray($users);
|
|
|
|
$respondedArray = $this->getArrayOfUsersResponded($this->response);
|
2018-06-13 08:15:42 +03:00
|
|
|
Assert::assertEquals($usersSimplified, $respondedArray, "", 0.0, 10, true);
|
2015-11-24 15:48:06 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-12-02 18:03:54 +03:00
|
|
|
/**
|
|
|
|
* @Then /^phone matches returned are$/
|
|
|
|
* @param \Behat\Gherkin\Node\TableNode|null $usersList
|
|
|
|
*/
|
|
|
|
public function thePhoneUsersShouldBe($usersList) {
|
|
|
|
if ($usersList instanceof \Behat\Gherkin\Node\TableNode) {
|
|
|
|
$users = $usersList->getRowsHash();
|
|
|
|
$listCheckedElements = simplexml_load_string($this->response->getBody())->data;
|
|
|
|
$respondedArray = json_decode(json_encode($listCheckedElements), true);
|
|
|
|
Assert::assertEquals($users, $respondedArray);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-08-05 11:56:40 +03:00
|
|
|
/**
|
|
|
|
* @Then /^detailed users returned are$/
|
|
|
|
* @param \Behat\Gherkin\Node\TableNode|null $usersList
|
|
|
|
*/
|
|
|
|
public function theDetailedUsersShouldBe($usersList) {
|
|
|
|
if ($usersList instanceof \Behat\Gherkin\Node\TableNode) {
|
|
|
|
$users = $usersList->getRows();
|
|
|
|
$usersSimplified = $this->simplifyArray($users);
|
|
|
|
$respondedArray = $this->getArrayOfDetailedUsersResponded($this->response);
|
|
|
|
$respondedArray = array_keys($respondedArray);
|
|
|
|
Assert::assertEquals($usersSimplified, $respondedArray);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-11-24 15:48:06 +03:00
|
|
|
/**
|
|
|
|
* @Then /^groups returned are$/
|
|
|
|
* @param \Behat\Gherkin\Node\TableNode|null $groupsList
|
|
|
|
*/
|
|
|
|
public function theGroupsShouldBe($groupsList) {
|
|
|
|
if ($groupsList instanceof \Behat\Gherkin\Node\TableNode) {
|
|
|
|
$groups = $groupsList->getRows();
|
|
|
|
$groupsSimplified = $this->simplifyArray($groups);
|
|
|
|
$respondedArray = $this->getArrayOfGroupsResponded($this->response);
|
2018-06-13 08:15:42 +03:00
|
|
|
Assert::assertEquals($groupsSimplified, $respondedArray, "", 0.0, 10, true);
|
2015-11-24 15:48:06 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @Then /^subadmin groups returned are$/
|
|
|
|
* @param \Behat\Gherkin\Node\TableNode|null $groupsList
|
|
|
|
*/
|
|
|
|
public function theSubadminGroupsShouldBe($groupsList) {
|
|
|
|
if ($groupsList instanceof \Behat\Gherkin\Node\TableNode) {
|
|
|
|
$groups = $groupsList->getRows();
|
|
|
|
$groupsSimplified = $this->simplifyArray($groups);
|
|
|
|
$respondedArray = $this->getArrayOfSubadminsResponded($this->response);
|
2018-06-13 08:15:42 +03:00
|
|
|
Assert::assertEquals($groupsSimplified, $respondedArray, "", 0.0, 10, true);
|
2015-11-24 15:48:06 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @Then /^apps returned are$/
|
|
|
|
* @param \Behat\Gherkin\Node\TableNode|null $appList
|
|
|
|
*/
|
|
|
|
public function theAppsShouldBe($appList) {
|
|
|
|
if ($appList instanceof \Behat\Gherkin\Node\TableNode) {
|
|
|
|
$apps = $appList->getRows();
|
|
|
|
$appsSimplified = $this->simplifyArray($apps);
|
|
|
|
$respondedArray = $this->getArrayOfAppsResponded($this->response);
|
2018-06-13 08:15:42 +03:00
|
|
|
Assert::assertEquals($appsSimplified, $respondedArray, "", 0.0, 10, true);
|
2015-11-24 15:48:06 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @Then /^subadmin users returned are$/
|
|
|
|
* @param \Behat\Gherkin\Node\TableNode|null $groupsList
|
|
|
|
*/
|
|
|
|
public function theSubadminUsersShouldBe($groupsList) {
|
|
|
|
$this->theSubadminGroupsShouldBe($groupsList);
|
|
|
|
}
|
|
|
|
|
2015-12-01 15:37:32 +03:00
|
|
|
/**
|
2015-11-24 15:48:06 +03:00
|
|
|
* Parses the xml answer to get the array of users returned.
|
2018-02-09 15:19:39 +03:00
|
|
|
*
|
2015-11-24 15:48:06 +03:00
|
|
|
* @param ResponseInterface $resp
|
|
|
|
* @return array
|
|
|
|
*/
|
|
|
|
public function getArrayOfUsersResponded($resp) {
|
2018-02-09 15:19:39 +03:00
|
|
|
$listCheckedElements = simplexml_load_string($resp->getBody())->data[0]->users[0]->element;
|
2015-11-24 15:48:06 +03:00
|
|
|
$extractedElementsArray = json_decode(json_encode($listCheckedElements), 1);
|
|
|
|
return $extractedElementsArray;
|
|
|
|
}
|
|
|
|
|
2020-08-05 11:56:40 +03:00
|
|
|
/**
|
|
|
|
* Parses the xml answer to get the array of detailed users returned.
|
|
|
|
*
|
|
|
|
* @param ResponseInterface $resp
|
|
|
|
* @return array
|
|
|
|
*/
|
|
|
|
public function getArrayOfDetailedUsersResponded($resp) {
|
|
|
|
$listCheckedElements = simplexml_load_string($resp->getBody())->data[0]->users;
|
|
|
|
$extractedElementsArray = json_decode(json_encode($listCheckedElements), 1);
|
|
|
|
return $extractedElementsArray;
|
|
|
|
}
|
|
|
|
|
2015-11-24 15:48:06 +03:00
|
|
|
/**
|
|
|
|
* Parses the xml answer to get the array of groups returned.
|
2018-02-09 15:19:39 +03:00
|
|
|
*
|
2015-11-24 15:48:06 +03:00
|
|
|
* @param ResponseInterface $resp
|
|
|
|
* @return array
|
|
|
|
*/
|
|
|
|
public function getArrayOfGroupsResponded($resp) {
|
2018-02-09 15:19:39 +03:00
|
|
|
$listCheckedElements = simplexml_load_string($resp->getBody())->data[0]->groups[0]->element;
|
2015-11-24 15:48:06 +03:00
|
|
|
$extractedElementsArray = json_decode(json_encode($listCheckedElements), 1);
|
|
|
|
return $extractedElementsArray;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Parses the xml answer to get the array of apps returned.
|
2018-02-09 15:19:39 +03:00
|
|
|
*
|
2015-11-24 15:48:06 +03:00
|
|
|
* @param ResponseInterface $resp
|
|
|
|
* @return array
|
|
|
|
*/
|
|
|
|
public function getArrayOfAppsResponded($resp) {
|
2018-02-09 15:19:39 +03:00
|
|
|
$listCheckedElements = simplexml_load_string($resp->getBody())->data[0]->apps[0]->element;
|
2015-11-24 15:48:06 +03:00
|
|
|
$extractedElementsArray = json_decode(json_encode($listCheckedElements), 1);
|
|
|
|
return $extractedElementsArray;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Parses the xml answer to get the array of subadmins returned.
|
2018-02-09 15:19:39 +03:00
|
|
|
*
|
2015-11-24 15:48:06 +03:00
|
|
|
* @param ResponseInterface $resp
|
|
|
|
* @return array
|
|
|
|
*/
|
|
|
|
public function getArrayOfSubadminsResponded($resp) {
|
2018-02-09 15:19:39 +03:00
|
|
|
$listCheckedElements = simplexml_load_string($resp->getBody())->data[0]->element;
|
2015-11-24 15:48:06 +03:00
|
|
|
$extractedElementsArray = json_decode(json_encode($listCheckedElements), 1);
|
|
|
|
return $extractedElementsArray;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @Given /^app "([^"]*)" is disabled$/
|
2016-03-11 12:23:11 +03:00
|
|
|
* @param string $app
|
2015-11-24 15:48:06 +03:00
|
|
|
*/
|
|
|
|
public function appIsDisabled($app) {
|
|
|
|
$fullUrl = $this->baseUrl . "v2.php/cloud/apps?filter=disabled";
|
|
|
|
$client = new Client();
|
|
|
|
$options = [];
|
|
|
|
if ($this->currentUser === 'admin') {
|
|
|
|
$options['auth'] = $this->adminUser;
|
|
|
|
}
|
2016-08-12 11:46:33 +03:00
|
|
|
$options['headers'] = [
|
|
|
|
'OCS-APIREQUEST' => 'true',
|
|
|
|
];
|
2015-11-24 15:48:06 +03:00
|
|
|
|
|
|
|
$this->response = $client->get($fullUrl, $options);
|
|
|
|
$respondedArray = $this->getArrayOfAppsResponded($this->response);
|
2018-06-13 08:15:42 +03:00
|
|
|
Assert::assertContains($app, $respondedArray);
|
|
|
|
Assert::assertEquals(200, $this->response->getStatusCode());
|
2015-11-24 15:48:06 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @Given /^app "([^"]*)" is enabled$/
|
2016-03-11 12:23:11 +03:00
|
|
|
* @param string $app
|
2015-11-24 15:48:06 +03:00
|
|
|
*/
|
|
|
|
public function appIsEnabled($app) {
|
|
|
|
$fullUrl = $this->baseUrl . "v2.php/cloud/apps?filter=enabled";
|
|
|
|
$client = new Client();
|
|
|
|
$options = [];
|
|
|
|
if ($this->currentUser === 'admin') {
|
|
|
|
$options['auth'] = $this->adminUser;
|
|
|
|
}
|
2016-08-12 11:46:33 +03:00
|
|
|
$options['headers'] = [
|
|
|
|
'OCS-APIREQUEST' => 'true',
|
|
|
|
];
|
2015-11-24 15:48:06 +03:00
|
|
|
|
|
|
|
$this->response = $client->get($fullUrl, $options);
|
|
|
|
$respondedArray = $this->getArrayOfAppsResponded($this->response);
|
2018-06-13 08:15:42 +03:00
|
|
|
Assert::assertContains($app, $respondedArray);
|
|
|
|
Assert::assertEquals(200, $this->response->getStatusCode());
|
2015-11-24 15:48:06 +03:00
|
|
|
}
|
|
|
|
|
2018-06-29 14:35:17 +03:00
|
|
|
/**
|
|
|
|
* @Given /^app "([^"]*)" is not enabled$/
|
|
|
|
*
|
|
|
|
* Checks that the app is disabled or not installed.
|
|
|
|
*
|
|
|
|
* @param string $app
|
|
|
|
*/
|
|
|
|
public function appIsNotEnabled($app) {
|
|
|
|
$fullUrl = $this->baseUrl . "v2.php/cloud/apps?filter=enabled";
|
|
|
|
$client = new Client();
|
|
|
|
$options = [];
|
|
|
|
if ($this->currentUser === 'admin') {
|
|
|
|
$options['auth'] = $this->adminUser;
|
|
|
|
}
|
|
|
|
$options['headers'] = [
|
|
|
|
'OCS-APIREQUEST' => 'true',
|
|
|
|
];
|
|
|
|
|
|
|
|
$this->response = $client->get($fullUrl, $options);
|
|
|
|
$respondedArray = $this->getArrayOfAppsResponded($this->response);
|
|
|
|
Assert::assertNotContains($app, $respondedArray);
|
|
|
|
Assert::assertEquals(200, $this->response->getStatusCode());
|
|
|
|
}
|
|
|
|
|
2016-04-19 12:13:24 +03:00
|
|
|
/**
|
|
|
|
* @Then /^user "([^"]*)" is disabled$/
|
|
|
|
* @param string $user
|
|
|
|
*/
|
|
|
|
public function userIsDisabled($user) {
|
|
|
|
$fullUrl = $this->baseUrl . "v{$this->apiVersion}.php/cloud/users/$user";
|
|
|
|
$client = new Client();
|
|
|
|
$options = [];
|
|
|
|
if ($this->currentUser === 'admin') {
|
|
|
|
$options['auth'] = $this->adminUser;
|
|
|
|
}
|
2016-08-12 11:46:33 +03:00
|
|
|
$options['headers'] = [
|
|
|
|
'OCS-APIREQUEST' => 'true',
|
|
|
|
];
|
2016-04-19 12:13:24 +03:00
|
|
|
|
|
|
|
$this->response = $client->get($fullUrl, $options);
|
2018-04-12 20:12:17 +03:00
|
|
|
// false in xml is empty
|
2018-06-13 08:15:42 +03:00
|
|
|
Assert::assertTrue(empty(simplexml_load_string($this->response->getBody())->data[0]->enabled));
|
2016-04-19 12:13:24 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @Then /^user "([^"]*)" is enabled$/
|
|
|
|
* @param string $user
|
|
|
|
*/
|
|
|
|
public function userIsEnabled($user) {
|
|
|
|
$fullUrl = $this->baseUrl . "v{$this->apiVersion}.php/cloud/users/$user";
|
|
|
|
$client = new Client();
|
|
|
|
$options = [];
|
|
|
|
if ($this->currentUser === 'admin') {
|
|
|
|
$options['auth'] = $this->adminUser;
|
|
|
|
}
|
2016-08-12 11:46:33 +03:00
|
|
|
$options['headers'] = [
|
|
|
|
'OCS-APIREQUEST' => 'true',
|
|
|
|
];
|
2016-04-19 12:13:24 +03:00
|
|
|
|
|
|
|
$this->response = $client->get($fullUrl, $options);
|
2018-04-12 20:12:17 +03:00
|
|
|
// boolean to string is integer
|
2018-06-13 08:15:42 +03:00
|
|
|
Assert::assertEquals("1", simplexml_load_string($this->response->getBody())->data[0]->enabled);
|
2016-04-19 12:13:24 +03:00
|
|
|
}
|
|
|
|
|
2015-12-01 15:36:55 +03:00
|
|
|
/**
|
|
|
|
* @Given user :user has a quota of :quota
|
2016-03-11 12:23:11 +03:00
|
|
|
* @param string $user
|
|
|
|
* @param string $quota
|
2015-12-01 15:36:55 +03:00
|
|
|
*/
|
2018-02-09 15:19:39 +03:00
|
|
|
public function userHasAQuotaOf($user, $quota) {
|
2015-12-01 15:36:55 +03:00
|
|
|
$body = new \Behat\Gherkin\Node\TableNode([
|
|
|
|
0 => ['key', 'quota'],
|
|
|
|
1 => ['value', $quota],
|
|
|
|
]);
|
|
|
|
|
|
|
|
// method used from BasicStructure trait
|
|
|
|
$this->sendingToWith("PUT", "/cloud/users/" . $user, $body);
|
|
|
|
}
|
|
|
|
|
2016-02-24 12:39:04 +03:00
|
|
|
/**
|
|
|
|
* @Given user :user has unlimited quota
|
2016-03-11 12:23:11 +03:00
|
|
|
* @param string $user
|
2016-02-24 12:39:04 +03:00
|
|
|
*/
|
2018-02-09 15:19:39 +03:00
|
|
|
public function userHasUnlimitedQuota($user) {
|
2016-02-24 12:39:04 +03:00
|
|
|
$this->userHasAQuotaOf($user, 'none');
|
|
|
|
}
|
|
|
|
|
2016-12-22 14:58:36 +03:00
|
|
|
/**
|
|
|
|
* Returns home path of the given user
|
2018-02-09 15:19:39 +03:00
|
|
|
*
|
2016-12-22 14:58:36 +03:00
|
|
|
* @param string $user
|
|
|
|
*/
|
2016-12-22 13:07:01 +03:00
|
|
|
public function getUserHome($user) {
|
|
|
|
$fullUrl = $this->baseUrl . "v{$this->apiVersion}.php/cloud/users/$user";
|
|
|
|
$client = new Client();
|
|
|
|
$options = [];
|
|
|
|
$options['auth'] = $this->adminUser;
|
|
|
|
$this->response = $client->get($fullUrl, $options);
|
2018-02-09 15:19:39 +03:00
|
|
|
return simplexml_load_string($this->response->getBody())->data[0]->home;
|
2016-12-22 13:07:01 +03:00
|
|
|
}
|
|
|
|
|
2015-11-24 15:48:06 +03:00
|
|
|
/**
|
|
|
|
* @BeforeScenario
|
|
|
|
* @AfterScenario
|
|
|
|
*/
|
2018-02-09 15:19:39 +03:00
|
|
|
public function cleanupUsers() {
|
2015-11-24 15:48:06 +03:00
|
|
|
$previousServer = $this->currentServer;
|
|
|
|
$this->usingServer('LOCAL');
|
2018-02-09 15:19:39 +03:00
|
|
|
foreach ($this->createdUsers as $user) {
|
2015-11-24 15:48:06 +03:00
|
|
|
$this->deleteUser($user);
|
|
|
|
}
|
|
|
|
$this->usingServer('REMOTE');
|
2018-02-09 15:19:39 +03:00
|
|
|
foreach ($this->createdRemoteUsers as $remoteUser) {
|
2015-11-24 15:48:06 +03:00
|
|
|
$this->deleteUser($remoteUser);
|
|
|
|
}
|
|
|
|
$this->usingServer($previousServer);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @BeforeScenario
|
|
|
|
* @AfterScenario
|
|
|
|
*/
|
2018-02-09 15:19:39 +03:00
|
|
|
public function cleanupGroups() {
|
2015-11-24 15:48:06 +03:00
|
|
|
$previousServer = $this->currentServer;
|
|
|
|
$this->usingServer('LOCAL');
|
2018-02-09 15:19:39 +03:00
|
|
|
foreach ($this->createdGroups as $group) {
|
2015-11-24 15:48:06 +03:00
|
|
|
$this->deleteGroup($group);
|
|
|
|
}
|
|
|
|
$this->usingServer('REMOTE');
|
2018-02-09 15:19:39 +03:00
|
|
|
foreach ($this->createdRemoteGroups as $remoteGroup) {
|
2017-03-17 16:38:27 +03:00
|
|
|
$this->deleteGroup($remoteGroup);
|
2015-11-24 15:48:06 +03:00
|
|
|
}
|
|
|
|
$this->usingServer($previousServer);
|
|
|
|
}
|
|
|
|
}
|