nextcloud/apps/files_external/tests/mountconfig.php

1175 lines
30 KiB
PHP
Raw Normal View History

<?php
/**
2015-03-26 13:44:34 +03:00
* @author Björn Schießle <schiessle@owncloud.com>
* @author Joas Schilling <nickvergessen@owncloud.com>
* @author Morris Jobke <hey@morrisjobke.de>
* @author Robin Appelman <icewind@owncloud.com>
* @author Robin McCorkell <rmccorkell@karoshi.org.uk>
* @author Vincent Petry <pvince81@owncloud.com>
*
2015-03-26 13:44:34 +03:00
* @copyright Copyright (c) 2015, ownCloud, Inc.
* @license AGPL-3.0
*
2015-03-26 13:44:34 +03:00
* This code is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License, version 3,
* as published by the Free Software Foundation.
*
2015-03-26 13:44:34 +03:00
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
2015-03-26 13:44:34 +03:00
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
2015-03-26 13:44:34 +03:00
* You should have received a copy of the GNU Affero General Public License, version 3,
* along with this program. If not, see <http://www.gnu.org/licenses/>
*
*/
class Test_Mount_Config_Dummy_Storage extends \OC\Files\Storage\Common {
public function __construct($params) {
if (isset($params['simulateFail']) && $params['simulateFail'] == true) {
throw new \Exception('Simulated config validation fail');
}
}
public function getId() {
return 'dummy_storage';
}
public function mkdir($path) {
return false;
}
public function rmdir($path) {
return false;
}
public function opendir($path) {
return false;
}
public function filetype($path) {
return false;
}
public function file_exists($path) {
return false;
}
public function unlink($path) {
return false;
}
public function fopen($path, $mode) {
return false;
}
public function touch($path, $mtime = null) {
return false;
}
public function stat($path) {
return false;
}
public function test() {
return true;
}
}
class Test_Mount_Config_Storage_No_Personal extends Test_Mount_Config_Dummy_Storage {
}
class Test_Mount_Config_Hook_Test {
static $signal;
static $params;
public static function setUpHooks() {
self::clear();
\OCP\Util::connectHook(
\OC\Files\Filesystem::CLASSNAME,
\OC\Files\Filesystem::signal_create_mount,
'\Test_Mount_Config_Hook_Test', 'createHookCallback');
\OCP\Util::connectHook(
\OC\Files\Filesystem::CLASSNAME,
\OC\Files\Filesystem::signal_delete_mount,
'\Test_Mount_Config_Hook_Test', 'deleteHookCallback');
}
public static function clear() {
self::$signal = null;
self::$params = null;
}
public static function createHookCallback($params) {
self::$signal = \OC\Files\Filesystem::signal_create_mount;
self::$params = $params;
}
public static function deleteHookCallback($params) {
2014-09-28 18:32:27 +04:00
self::$signal = \OC\Files\Filesystem::signal_delete_mount;
self::$params = $params;
}
public static function getLastCall() {
return array(self::$signal, self::$params);
}
}
/**
* Class Test_Mount_Config
*/
class Test_Mount_Config extends \Test\TestCase {
private $dataDir;
private $userHome;
private $oldAllowedBackends;
const TEST_USER1 = 'user1';
const TEST_USER2 = 'user2';
const TEST_GROUP1 = 'group1';
2014-05-14 23:32:19 +04:00
const TEST_GROUP1B = 'group1b';
const TEST_GROUP2 = 'group2';
2014-05-14 23:32:19 +04:00
const TEST_GROUP2B = 'group2b';
private $users = [];
private $groups = [];
protected function setUp() {
parent::setUp();
OC_Mount_Config::registerBackend('Test_Mount_Config_Dummy_Storage', array(
'backend' => 'dummy',
'priority' => 150,
'configuration' => array()
)
);
OC_Mount_Config::registerBackend('Test_Mount_Config_Storage_No_Personal', array(
'backend' => 'dummy no personal',
'priority' => 150,
'configuration' => array()
)
);
$userManager = \OC::$server->getUserManager();
$groupManager = \OC::$server->getGroupManager();
$this->users[self::TEST_USER1] = $userManager->createUser(
self::TEST_USER1,
self::TEST_USER1
);
$this->users[self::TEST_USER2] = $userManager->createUser(
self::TEST_USER2,
self::TEST_USER2
);
$this->groups[self::TEST_GROUP1] = $groupManager->createGroup(self::TEST_GROUP1);
$this->groups[self::TEST_GROUP1B] = $groupManager->createGroup(self::TEST_GROUP1B);
$this->groups[self::TEST_GROUP2] = $groupManager->createGroup(self::TEST_GROUP2);
$this->groups[self::TEST_GROUP2B] = $groupManager->createGroup(self::TEST_GROUP2B);
$this->groups[self::TEST_GROUP1]->addUser($this->users[self::TEST_USER1]);
$this->groups[self::TEST_GROUP1B]->addUser($this->users[self::TEST_USER1]);
$this->groups[self::TEST_GROUP2]->addUser($this->users[self::TEST_USER2]);
$this->groups[self::TEST_GROUP2B]->addUser($this->users[self::TEST_USER2]);
\OC::$server->getUserSession()->setUser($this->users[self::TEST_USER1]);
$this->userHome = $this->users[self::TEST_USER1]->getHome();
2014-08-28 18:08:18 +04:00
@mkdir($this->userHome);
$config = \OC::$server->getConfig();
$this->dataDir = $config->getSystemValue(
'datadirectory',
\OC::$SERVERROOT . '/data/'
);
$this->oldAllowedBackends = $config->getAppValue(
'files_external',
'user_mounting_backends',
''
);
$config->setAppValue(
'files_external',
'user_mounting_backends',
'Test_Mount_Config_Dummy_Storage'
);
OC_Mount_Config::$skipTest = true;
Test_Mount_Config_Hook_Test::setupHooks();
}
protected function tearDown() {
Test_Mount_Config_Hook_Test::clear();
OC_Mount_Config::$skipTest = false;
foreach ($this->users as $user) {
$user->delete();
}
foreach ($this->groups as $group) {
$group->delete();
}
$this->users = [];
$this->groups = [];
@unlink($this->dataDir . '/mount.json');
$config = \OC::$server->getConfig();
$config->setAppValue(
'files_external',
'user_mounting_backends',
$this->oldAllowedBackends
);
parent::tearDown();
}
/**
* Reads the global config, for checking
*/
private function readGlobalConfig() {
$configFile = $this->dataDir . '/mount.json';
return json_decode(file_get_contents($configFile), true);
}
private function writeGlobalConfig($config) {
$configFile = $this->dataDir . '/mount.json';
file_put_contents($configFile, json_encode($config));
}
/**
* Reads the user config, for checking
*/
private function readUserConfig() {
$configFile = $this->userHome . '/mount.json';
return json_decode(file_get_contents($configFile), true);
}
/**
* Write the user config, to simulate existing files
*/
private function writeUserConfig($config) {
$configFile = $this->userHome . '/mount.json';
file_put_contents($configFile, json_encode($config));
}
/**
* Test mount point validation
*/
public function testAddMountPointValidation() {
$storageClass = 'Test_Mount_Config_Dummy_Storage';
$mountType = 'user';
$applicable = 'all';
$isPersonal = false;
$this->assertFalse(OC_Mount_Config::addMountPoint('', $storageClass, array(), $mountType, $applicable, $isPersonal));
$this->assertFalse(OC_Mount_Config::addMountPoint('/', $storageClass, array(), $mountType, $applicable, $isPersonal));
}
/**
* Test adding a global mount point
*/
public function testAddGlobalMountPoint() {
$mountType = OC_Mount_Config::MOUNT_TYPE_USER;
$applicable = 'all';
$isPersonal = false;
$storageOptions = array(
'host' => 'localhost',
'user' => 'testuser',
'password' => '12345',
);
$this->assertEquals(0, OC_Mount_Config::addMountPoint('/ext', 'Test_Mount_Config_Dummy_Storage', $storageOptions, $mountType, $applicable, $isPersonal));
$config = $this->readGlobalConfig();
$this->assertEquals(1, count($config));
$this->assertTrue(isset($config[$mountType]));
$this->assertTrue(isset($config[$mountType][$applicable]));
$this->assertTrue(isset($config[$mountType][$applicable]['/$user/files/ext']));
$this->assertEquals(
'Test_Mount_Config_Dummy_Storage',
$config[$mountType][$applicable]['/$user/files/ext']['class']
);
}
/**
* Test adding a personal mount point
*/
public function testAddMountPointSingleUser() {
$mountType = OC_Mount_Config::MOUNT_TYPE_USER;
$applicable = self::TEST_USER1;
$isPersonal = true;
$storageOptions = array(
'host' => 'localhost',
'user' => 'testuser',
'password' => '12345',
);
$this->assertEquals(0, OC_Mount_Config::addMountPoint('/ext', 'Test_Mount_Config_Dummy_Storage', $storageOptions, $mountType, $applicable, $isPersonal));
$config = $this->readUserConfig();
$this->assertEquals(1, count($config));
$this->assertTrue(isset($config[$mountType]));
$this->assertTrue(isset($config[$mountType][$applicable]));
$this->assertTrue(isset($config[$mountType][$applicable]['/' . self::TEST_USER1 . '/files/ext']));
$this->assertEquals(
'Test_Mount_Config_Dummy_Storage',
$config[$mountType][$applicable]['/' . self::TEST_USER1 . '/files/ext']['class']
);
}
/**
* Test adding a personal mount point using disallowed backend
*/
public function testAddDisallowedBackendMountPointSingleUser() {
$mountType = OC_Mount_Config::MOUNT_TYPE_USER;
$applicable = self::TEST_USER1;
$isPersonal = true;
// local
$this->assertFalse(OC_Mount_Config::addMountPoint('/ext', '\OC\Files\Storage\Local', array(), $mountType, $applicable, $isPersonal));
$storageOptions = array(
'host' => 'localhost',
'user' => 'testuser',
'password' => '12345',
);
// non-local but forbidden
$this->assertFalse(OC_Mount_Config::addMountPoint('/ext', 'Test_Mount_Config_Storage_No_Personal', $storageOptions, $mountType, $applicable, $isPersonal));
$this->assertFalse(file_exists($this->userHome . '/mount.json'));
}
/**
* Test adding a mount point with an non-existant backend
*/
public function testAddMountPointUnexistClass() {
$storageClass = 'Unexist_Storage';
$mountType = OC_Mount_Config::MOUNT_TYPE_USER;
$applicable = self::TEST_USER1;
$isPersonal = false;
$this->assertFalse(OC_Mount_Config::addMountPoint('/ext', $storageClass, array(), $mountType, $applicable, $isPersonal));
}
/**
* Provider for testing configurations with different
* "applicable" values (all, user, groups)
*/
public function applicableConfigProvider() {
return array(
// applicable to "all"
array(
OC_Mount_Config::MOUNT_TYPE_USER,
'all',
array(
'users' => array('all'),
'groups' => array()
)
),
// applicable to single user
array(
OC_Mount_Config::MOUNT_TYPE_USER,
self::TEST_USER1,
array(
'users' => array(self::TEST_USER1),
'groups' => array()
)
),
// applicable to single group
array(
OC_Mount_Config::MOUNT_TYPE_GROUP,
self::TEST_GROUP1,
array(
'users' => array(),
'groups' => array(self::TEST_GROUP1)
)
),
);
}
/**
* Test reading and writing global config
*
* @dataProvider applicableConfigProvider
*/
public function testReadWriteGlobalConfig($mountType, $applicable, $expectApplicableArray) {
$mountType = $mountType;
$applicable = $applicable;
$isPersonal = false;
$options = array(
'host' => 'smbhost',
'user' => 'smbuser',
'password' => 'smbpassword',
'share' => 'smbshare',
'root' => 'smbroot'
);
// write config
$this->assertEquals(
0,
OC_Mount_Config::addMountPoint(
'/ext',
'Test_Mount_Config_Dummy_Storage',
$options,
$mountType,
$applicable,
$isPersonal
)
);
// re-read config
$config = OC_Mount_Config::getSystemMountPoints();
$this->assertEquals(1, count($config));
$this->assertEquals('Test_Mount_Config_Dummy_Storage', $config[0]['class']);
$this->assertEquals('ext', $config[0]['mountpoint']);
$this->assertEquals($expectApplicableArray, $config[0]['applicable']);
$savedOptions = $config[0]['options'];
$this->assertEquals($options, $savedOptions);
// key order needs to be preserved for the UI...
$this->assertEquals(array_keys($options), array_keys($savedOptions));
}
/**
* Test reading and writing config
*/
public function testReadWritePersonalConfig() {
$mountType = OC_Mount_Config::MOUNT_TYPE_USER;
$applicable = self::TEST_USER1;
$isPersonal = true;
$options = array(
'host' => 'smbhost',
'user' => 'smbuser',
'password' => 'smbpassword',
'share' => 'smbshare',
'root' => 'smbroot'
);
// write config
$this->assertEquals(
0,
OC_Mount_Config::addMountPoint(
'/ext',
'Test_Mount_Config_Dummy_Storage',
$options,
$mountType,
$applicable,
$isPersonal
)
);
// re-read config
$config = OC_Mount_Config::getPersonalMountPoints();
$this->assertEquals(1, count($config));
$this->assertEquals('Test_Mount_Config_Dummy_Storage', $config[0]['class']);
$this->assertEquals('ext', $config[0]['mountpoint']);
$savedOptions = $config[0]['options'];
$this->assertEquals($options, $savedOptions);
// key order needs to be preserved for the UI...
$this->assertEquals(array_keys($options), array_keys($savedOptions));
}
public function testHooks() {
$mountPoint = '/test';
$mountType = 'user';
$applicable = 'all';
$isPersonal = false;
$mountConfig = array(
'host' => 'smbhost',
'user' => 'smbuser',
'password' => 'smbpassword',
'share' => 'smbshare',
'root' => 'smbroot'
);
// write config
$this->assertEquals(
0,
OC_Mount_Config::addMountPoint(
$mountPoint,
'Test_Mount_Config_Dummy_Storage',
$mountConfig,
$mountType,
$applicable,
$isPersonal
)
);
list($hookName, $params) = Test_Mount_Config_Hook_Test::getLastCall();
$this->assertEquals(
\OC\Files\Filesystem::signal_create_mount,
$hookName
);
$this->assertEquals(
$mountPoint,
$params[\OC\Files\Filesystem::signal_param_path]
);
$this->assertEquals(
$mountType,
$params[\OC\Files\Filesystem::signal_param_mount_type]
);
$this->assertEquals(
$applicable,
2014-09-28 18:32:27 +04:00
$params[\OC\Files\Filesystem::signal_param_users]
);
Test_Mount_Config_Hook_Test::clear();
// edit
$mountConfig['host'] = 'anothersmbhost';
$this->assertEquals(
0,
OC_Mount_Config::addMountPoint(
$mountPoint,
'Test_Mount_Config_Dummy_Storage',
$mountConfig,
$mountType,
$applicable,
$isPersonal
)
);
// hook must not be called on edit
list($hookName, $params) = Test_Mount_Config_Hook_Test::getLastCall();
$this->assertEquals(
null,
$hookName
);
Test_Mount_Config_Hook_Test::clear();
$this->assertTrue(
OC_Mount_Config::removeMountPoint(
2014-09-28 18:32:27 +04:00
$mountPoint,
$mountType,
$applicable,
$isPersonal
)
);
list($hookName, $params) = Test_Mount_Config_Hook_Test::getLastCall();
$this->assertEquals(
\OC\Files\Filesystem::signal_delete_mount,
$hookName
);
$this->assertEquals(
$mountPoint,
$params[\OC\Files\Filesystem::signal_param_path]
);
$this->assertEquals(
$mountType,
$params[\OC\Files\Filesystem::signal_param_mount_type]
);
$this->assertEquals(
$applicable,
2014-09-28 18:32:27 +04:00
$params[\OC\Files\Filesystem::signal_param_users]
);
}
/**
* Test password obfuscation
*/
public function testPasswordObfuscation() {
$mountType = OC_Mount_Config::MOUNT_TYPE_USER;
$applicable = self::TEST_USER1;
$isPersonal = true;
$mountConfig = array(
'host' => 'smbhost',
'user' => 'smbuser',
'password' => 'smbpassword',
'share' => 'smbshare',
'root' => 'smbroot'
);
// write config
$this->assertEquals(
0,
OC_Mount_Config::addMountPoint(
'/ext',
'Test_Mount_Config_Dummy_Storage',
$mountConfig,
$mountType,
$applicable,
$isPersonal
)
);
// note: password re-reading is covered by testReadWritePersonalConfig
// check that password inside the file is NOT in plain text
$config = $this->readUserConfig();
$savedConfig = $config[$mountType][$applicable]['/' . self::TEST_USER1 . '/files/ext']['options'];
// no more clear text password in file (kept because of key order)
$this->assertEquals('', $savedConfig['password']);
// encrypted password is present
$this->assertNotEquals($mountConfig['password'], $savedConfig['password_encrypted']);
}
/**
* Test read legacy passwords
*/
public function testReadLegacyPassword() {
$mountType = OC_Mount_Config::MOUNT_TYPE_USER;
$applicable = self::TEST_USER1;
$isPersonal = true;
$mountConfig = array(
'host' => 'smbhost',
'user' => 'smbuser',
'password' => 'smbpassword',
'share' => 'smbshare',
'root' => 'smbroot'
);
// write config
$this->assertEquals(
0,
OC_Mount_Config::addMountPoint(
'/ext',
'Test_Mount_Config_Dummy_Storage',
$mountConfig,
$mountType,
$applicable,
$isPersonal
)
);
$config = $this->readUserConfig();
// simulate non-encrypted password situation
$config[$mountType][$applicable]['/' . self::TEST_USER1 . '/files/ext']['options']['password'] = 'smbpasswd';
$this->writeUserConfig($config);
// re-read config, password was read correctly
$config = OC_Mount_Config::getPersonalMountPoints();
$savedMountConfig = $config[0]['options'];
$this->assertEquals($mountConfig, $savedMountConfig);
}
public function testVariableSubstitution() {
$legacyBackendOptions = [
'user' => 'someuser',
'password' => 'somepassword',
'replacethis' => '$user',
];
$legacyBackendOptions = \OC_Mount_Config::encryptPasswords($legacyBackendOptions);
$legacyConfig = [
'class' => '\OC\Files\Storage\SMB',
'options' => $legacyBackendOptions,
'mountOptions' => ['preview' => false, 'int' => 1],
];
// different mount options
$legacyConfig2 = [
'class' => '\OC\Files\Storage\SMB',
'options' => $legacyBackendOptions,
'mountOptions' => ['preview' => true, 'string' => 'abc'],
];
$json = [
'user' => [
self::TEST_USER1 => [
'/$user/files/somemount' => $legacyConfig,
'/$user/files/anothermount' => $legacyConfig2,
],
],
];
$this->writeGlobalConfig($json);
// re-read config, password was read correctly
$config = OC_Mount_Config::getAbsoluteMountPoints(self::TEST_USER1);
$config1 = $config['/' . self::TEST_USER1 . '/files/somemount'];
$config2 = $config['/' . self::TEST_USER1 . '/files/anothermount'];
$this->assertSame(self::TEST_USER1, $config1['options']['replacethis']);
$this->assertSame(self::TEST_USER1, $config1['options']['replacethis']);
$this->assertSame(1, $config1['mountOptions']['int']);
$this->assertSame(true, $config2['mountOptions']['preview']);
$this->assertSame('abc', $config2['mountOptions']['string']);
}
public function mountDataProvider() {
return array(
// Tests for visible mount points
// system mount point for all users
array(
false,
OC_Mount_Config::MOUNT_TYPE_USER,
'all',
self::TEST_USER1,
true,
),
// system mount point for a specific user
array(
false,
OC_Mount_Config::MOUNT_TYPE_USER,
self::TEST_USER1,
self::TEST_USER1,
true,
),
// system mount point for a specific group
array(
false,
OC_Mount_Config::MOUNT_TYPE_GROUP,
self::TEST_GROUP1,
self::TEST_USER1,
true,
),
// user mount point
array(
true,
OC_Mount_Config::MOUNT_TYPE_USER,
self::TEST_USER1,
self::TEST_USER1,
true,
),
// Tests for non-visible mount points
// system mount point for another user
array(
false,
OC_Mount_Config::MOUNT_TYPE_USER,
self::TEST_USER2,
self::TEST_USER1,
false,
),
// system mount point for a specific group
array(
false,
OC_Mount_Config::MOUNT_TYPE_GROUP,
self::TEST_GROUP2,
self::TEST_USER1,
false,
),
// user mount point
array(
true,
OC_Mount_Config::MOUNT_TYPE_USER,
self::TEST_USER1,
self::TEST_USER2,
false,
),
);
}
/**
* Test mount points used at mount time, making sure
* the configuration is prepared properly.
*
* @dataProvider mountDataProvider
* @param bool $isPersonal true for personal mount point, false for system mount point
* @param string $mountType mount type
* @param string $applicable target user/group or "all"
* @param string $testUser user for which to retrieve the mount points
* @param bool $expectVisible whether to expect the mount point to be visible for $testUser
*/
public function testMount($isPersonal, $mountType, $applicable, $testUser, $expectVisible) {
$mountConfig = array(
'host' => 'someost',
'user' => 'someuser',
'password' => 'somepassword',
'root' => 'someroot',
'share' => '',
);
// add mount point as "test" user
$this->assertEquals(
0,
OC_Mount_Config::addMountPoint(
'/ext',
'Test_Mount_Config_Dummy_Storage',
$mountConfig,
$mountType,
$applicable,
$isPersonal
)
);
// check mount points in the perspective of user $testUser
\OC::$server->getUserSession()->setUser($this->users[$testUser]);
$mountPoints = OC_Mount_Config::getAbsoluteMountPoints($testUser);
if ($expectVisible) {
$this->assertEquals(1, count($mountPoints));
$this->assertTrue(isset($mountPoints['/' . self::TEST_USER1 . '/files/ext']));
$this->assertEquals('Test_Mount_Config_Dummy_Storage', $mountPoints['/' . self::TEST_USER1 . '/files/ext']['class']);
$this->assertEquals($mountConfig, $mountPoints['/' . self::TEST_USER1 . '/files/ext']['options']);
}
else {
$this->assertEquals(0, count($mountPoints));
}
}
/**
* Test the same config for multiple users.
* The config will be merged by getSystemMountPoints().
*/
public function testConfigMerging() {
$mountType = OC_Mount_Config::MOUNT_TYPE_USER;
$isPersonal = false;
$options = array(
'host' => 'smbhost',
'user' => 'smbuser',
'password' => 'smbpassword',
'share' => 'smbshare',
'root' => 'smbroot'
);
// write config
$this->assertEquals(
0,
OC_Mount_Config::addMountPoint(
'/ext',
'Test_Mount_Config_Dummy_Storage',
$options,
OC_Mount_Config::MOUNT_TYPE_USER,
self::TEST_USER1,
$isPersonal
)
);
$this->assertEquals(
0,
OC_Mount_Config::addMountPoint(
'/ext',
'Test_Mount_Config_Dummy_Storage',
$options,
OC_Mount_Config::MOUNT_TYPE_USER,
self::TEST_USER2,
$isPersonal
)
);
$this->assertEquals(
0,
OC_Mount_Config::addMountPoint(
'/ext',
'Test_Mount_Config_Dummy_Storage',
$options,
OC_Mount_Config::MOUNT_TYPE_GROUP,
self::TEST_GROUP2,
$isPersonal
)
);
$this->assertEquals(
0,
OC_Mount_Config::addMountPoint(
'/ext',
'Test_Mount_Config_Dummy_Storage',
$options,
OC_Mount_Config::MOUNT_TYPE_GROUP,
self::TEST_GROUP1,
$isPersonal
)
);
// re-read config
$config = OC_Mount_Config::getSystemMountPoints();
$this->assertEquals(1, count($config));
$this->assertEquals('Test_Mount_Config_Dummy_Storage', $config[0]['class']);
$this->assertEquals('ext', $config[0]['mountpoint']);
$this->assertEquals($options, $config[0]['options']);
$this->assertEquals(array(self::TEST_USER1, self::TEST_USER2), $config[0]['applicable']['users']);
$this->assertEquals(array(self::TEST_GROUP2, self::TEST_GROUP1), $config[0]['applicable']['groups']);
}
/**
* Create then re-read mount points configs where the mount points
* have the same path, the config must NOT be merged.
*/
public function testRereadMountpointWithSamePath() {
$mountType = OC_Mount_Config::MOUNT_TYPE_USER;
$isPersonal = false;
$options1 = array(
'host' => 'smbhost',
'user' => 'smbuser',
'password' => 'smbpassword',
'share' => 'smbshare',
'root' => 'smbroot'
);
// write config
$this->assertEquals(
0,
OC_Mount_Config::addMountPoint(
'/ext',
'Test_Mount_Config_Dummy_Storage',
$options1,
$mountType,
self::TEST_USER1,
$isPersonal
)
);
$options2 = array(
'host' => 'anothersmbhost',
'user' => 'anothersmbuser',
'password' => 'anothersmbpassword',
'share' => 'anothersmbshare',
'root' => 'anothersmbroot'
);
$this->assertEquals(
0,
OC_Mount_Config::addMountPoint(
'/ext',
'Test_Mount_Config_Dummy_Storage',
$options2,
$mountType,
self::TEST_USER2,
$isPersonal
)
);
// re-read config
$config = OC_Mount_Config::getSystemMountPoints();
$this->assertEquals(2, count($config));
$this->assertEquals('Test_Mount_Config_Dummy_Storage', $config[0]['class']);
$this->assertEquals('ext', $config[0]['mountpoint']);
$this->assertEquals($options1, $config[0]['options']);
$this->assertEquals('Test_Mount_Config_Dummy_Storage', $config[1]['class']);
$this->assertEquals('ext', $config[1]['mountpoint']);
$this->assertEquals($options2, $config[1]['options']);
}
2014-05-14 23:32:19 +04:00
public function priorityDataProvider() {
return array(
// test 1 - group vs group
array(
array(
array(
'isPersonal' => false,
'mountType' => OC_Mount_Config::MOUNT_TYPE_GROUP,
'applicable' => self::TEST_GROUP1,
'priority' => 50
),
array(
'isPersonal' => false,
'mountType' => OC_Mount_Config::MOUNT_TYPE_GROUP,
'applicable' => self::TEST_GROUP1B,
'priority' => 60
)
),
1
),
// test 2 - user vs personal
array(
array(
array(
'isPersonal' => false,
'mountType' => OC_Mount_Config::MOUNT_TYPE_USER,
'applicable' => self::TEST_USER1,
'priority' => 2000
),
array(
'isPersonal' => true,
'mountType' => OC_Mount_Config::MOUNT_TYPE_USER,
'applicable' => self::TEST_USER1,
'priority' => null
)
),
1
),
// test 3 - all vs group vs user
array(
array(
array(
'isPersonal' => false,
'mountType' => OC_Mount_Config::MOUNT_TYPE_USER,
'applicable' => 'all',
'priority' => 70
),
array(
'isPersonal' => false,
'mountType' => OC_Mount_Config::MOUNT_TYPE_GROUP,
'applicable' => self::TEST_GROUP1,
'priority' => 60
),
array(
'isPersonal' => false,
'mountType' => OC_Mount_Config::MOUNT_TYPE_USER,
'applicable' => self::TEST_USER1,
'priority' => 50
)
),
2
)
);
}
/**
* Ensure priorities are being respected
* Test user is self::TEST_USER1
*
* @dataProvider priorityDataProvider
* @param array[] $mounts array of associative array of mount parameters:
* bool $isPersonal
* string $mountType
* string $applicable
* int|null $priority null for personal
* @param int $expected index of expected visible mount
*/
public function testPriority($mounts, $expected) {
2014-05-14 23:32:19 +04:00
$mountConfig = array(
'host' => 'somehost',
'user' => 'someuser',
'password' => 'somepassword',
'root' => 'someroot',
'share' => '',
2014-05-14 23:32:19 +04:00
);
// Add mount points
foreach($mounts as $i => $mount) {
$this->assertEquals(
0,
2014-05-14 23:32:19 +04:00
OC_Mount_Config::addMountPoint(
'/ext',
'Test_Mount_Config_Dummy_Storage',
2014-05-14 23:32:19 +04:00
$mountConfig + array('id' => $i),
$mount['mountType'],
$mount['applicable'],
$mount['isPersonal'],
$mount['priority']
)
);
}
// Get mount points for user
$mountPoints = OC_Mount_Config::getAbsoluteMountPoints(self::TEST_USER1);
$this->assertEquals(1, count($mountPoints));
$this->assertEquals($expected, $mountPoints['/'.self::TEST_USER1.'/files/ext']['options']['id']);
}
/**
* Test for persistence of priority when changing mount options
*/
public function testPriorityPersistence() {
$class = 'Test_Mount_Config_Dummy_Storage';
$priority = 123;
$mountConfig = array(
'host' => 'somehost',
'user' => 'someuser',
'password' => 'somepassword',
'root' => 'someroot',
'share' => '',
);
$this->assertEquals(
0,
OC_Mount_Config::addMountPoint(
'/ext',
$class,
$mountConfig,
OC_Mount_Config::MOUNT_TYPE_USER,
self::TEST_USER1,
false,
$priority
)
);
// Check for correct priority
$mountPoints = OC_Mount_Config::getAbsoluteMountPoints(self::TEST_USER1);
$this->assertEquals($priority,
$mountPoints['/'.self::TEST_USER1.'/files/ext']['priority']);
// Simulate changed mount options (without priority set)
$this->assertEquals(
0,
OC_Mount_Config::addMountPoint(
'/ext',
$class,
$mountConfig,
OC_Mount_Config::MOUNT_TYPE_USER,
self::TEST_USER1,
false
)
);
// Check for correct priority
$mountPoints = OC_Mount_Config::getAbsoluteMountPoints(self::TEST_USER1);
$this->assertEquals($priority,
$mountPoints['/'.self::TEST_USER1.'/files/ext']['priority']);
}
/*
* Test for correct personal configuration loading in file sharing scenarios
*/
public function testMultiUserPersonalConfigLoading() {
$mountConfig = array(
'host' => 'somehost',
'user' => 'someuser',
'password' => 'somepassword',
'root' => 'someroot',
'share' => '',
);
// Create personal mount point
$this->assertEquals(
0,
OC_Mount_Config::addMountPoint(
'/ext',
'Test_Mount_Config_Dummy_Storage',
$mountConfig,
OC_Mount_Config::MOUNT_TYPE_USER,
self::TEST_USER1,
true
)
);
// Ensure other user can read mount points
\OC::$server->getUserSession()->setUser($this->users[self::TEST_USER2]);
$mountPointsMe = OC_Mount_Config::getAbsoluteMountPoints(self::TEST_USER2);
$mountPointsOther = OC_Mount_Config::getAbsoluteMountPoints(self::TEST_USER1);
$this->assertEquals(0, count($mountPointsMe));
$this->assertEquals(1, count($mountPointsOther));
$this->assertTrue(isset($mountPointsOther['/'.self::TEST_USER1.'/files/ext']));
$this->assertEquals('Test_Mount_Config_Dummy_Storage',
$mountPointsOther['/'.self::TEST_USER1.'/files/ext']['class']);
$this->assertEquals($mountConfig,
$mountPointsOther['/'.self::TEST_USER1.'/files/ext']['options']);
}
public function testAllowWritingIncompleteConfigIfStorageContructorFails() {
$storageClass = 'Test_Mount_Config_Dummy_Storage';
$mountType = 'user';
$applicable = 'all';
$isPersonal = false;
$this->assertEquals(
0,
OC_Mount_Config::addMountPoint(
'/ext',
$storageClass,
array('simulateFail' => true),
$mountType,
$applicable,
$isPersonal
)
);
// config can be retrieved afterwards
$mounts = OC_Mount_Config::getSystemMountPoints();
$this->assertEquals(1, count($mounts));
// no storage id was set
$this->assertFalse(isset($mounts[0]['storage_id']));
}
}