public function testJsonSerialization() { $backend = $this->getMockBuilder('\\OCA\\Files_External\\Lib\\Backend\\Backend')->disableOriginalConstructor()->getMock(); $parameter = $this->getMockBuilder('\\OCA\\Files_External\\Lib\\DefinitionParameter')->disableOriginalConstructor()->getMock(); $parameter->expects($this->once())->method('getType')->willReturn(1); $backend->expects($this->once())->method('getParameters')->willReturn(['secure' => $parameter]); $backend->method('getIdentifier')->willReturn('storage::identifier'); $authMech = $this->getMockBuilder('\\OCA\\Files_External\\Lib\\Auth\\AuthMechanism')->disableOriginalConstructor()->getMock(); $authMech->method('getIdentifier')->willReturn('auth::identifier'); $storageConfig = new StorageConfig(1); $storageConfig->setMountPoint('test'); $storageConfig->setBackend($backend); $storageConfig->setAuthMechanism($authMech); $storageConfig->setBackendOptions(['user' => 'test', 'password' => 'password123', 'secure' => '1']); $storageConfig->setPriority(128); $storageConfig->setApplicableUsers(['user1', 'user2']); $storageConfig->setApplicableGroups(['group1', 'group2']); $storageConfig->setMountOptions(['preview' => false]); $json = $storageConfig->jsonSerialize(); $this->assertSame(1, $json['id']); $this->assertSame('/test', $json['mountPoint']); $this->assertSame('storage::identifier', $json['backend']); $this->assertSame('auth::identifier', $json['authMechanism']); $this->assertSame('test', $json['backendOptions']['user']); $this->assertSame('password123', $json['backendOptions']['password']); $this->assertSame(true, $json['backendOptions']['secure']); $this->assertSame(128, $json['priority']); $this->assertSame(['user1', 'user2'], $json['applicableUsers']); $this->assertSame(['group1', 'group2'], $json['applicableGroups']); $this->assertSame(['preview' => false], $json['mountOptions']); }
public function testListAuthIdentifier() { $l10n = $this->getMock('\\OC_L10N', null, [], '', false); $credentialsManager = $this->getMock('\\OCP\\Security\\ICredentialsManager'); $instance = $this->getInstance(); $mount1 = new StorageConfig(); $mount1->setAuthMechanism(new Password($l10n)); $mount1->setBackend(new Local($l10n, new NullMechanism($l10n))); $mount2 = new StorageConfig(); $mount2->setAuthMechanism(new UserProvided($l10n, $credentialsManager)); $mount2->setBackend(new Local($l10n, new NullMechanism($l10n))); $input = $this->getInput($instance, [], ['output' => 'json']); $output = new BufferedOutput(); $instance->listMounts('', [$mount1, $mount2], $input, $output); $output = json_decode($output->fetch(), true); $this->assertNotEquals($output[0]['authentication_type'], $output[1]['authentication_type']); }
public function testAddOrUpdateStorageDisallowedBackend() { $backend = $this->getBackendMock(); $backend->method('isVisibleFor')->with(BackendService::VISIBILITY_PERSONAL)->willReturn(false); $authMech = $this->getAuthMechMock(); $storageConfig = new StorageConfig(1); $storageConfig->setMountPoint('mount'); $storageConfig->setBackend($backend); $storageConfig->setAuthMechanism($authMech); $storageConfig->setBackendOptions([]); $this->service->expects($this->exactly(2))->method('createStorage')->will($this->returnValue($storageConfig)); $this->service->expects($this->never())->method('addStorage'); $this->service->expects($this->never())->method('updateStorage'); $response = $this->controller->create('mount', '\\OC\\Files\\Storage\\SMB', '\\Auth\\Mechanism', array(), [], [], [], null); $this->assertEquals(Http::STATUS_UNPROCESSABLE_ENTITY, $response->getStatus()); $response = $this->controller->update(1, 'mount', '\\OC\\Files\\Storage\\SMB', '\\Auth\\Mechanism', array(), [], [], [], null); $this->assertEquals(Http::STATUS_UNPROCESSABLE_ENTITY, $response->getStatus()); }
/** * Copy legacy storage options into the given storage config object. * * @param StorageConfig $storageConfig storage config to populate * @param string $mountType mount type * @param string $applicable applicable user or group * @param array $storageOptions legacy storage options * * @return StorageConfig populated storage config */ protected function populateStorageConfigWithLegacyOptions(&$storageConfig, $mountType, $applicable, $storageOptions) { $backend = $this->backendService->getBackend($storageOptions['backend']); if (!$backend) { throw new \UnexpectedValueException('Invalid backend ' . $storageOptions['backend']); } $storageConfig->setBackend($backend); if (isset($storageOptions['authMechanism']) && $storageOptions['authMechanism'] !== 'builtin::builtin') { $authMechanism = $this->backendService->getAuthMechanism($storageOptions['authMechanism']); } else { $authMechanism = $backend->getLegacyAuthMechanism($storageOptions); $storageOptions['authMechanism'] = 'null'; // to make error handling easier } if (!$authMechanism) { throw new \UnexpectedValueException('Invalid authentication mechanism ' . $storageOptions['authMechanism']); } $storageConfig->setAuthMechanism($authMechanism); $storageConfig->setBackendOptions($storageOptions['options']); if (isset($storageOptions['mountOptions'])) { $storageConfig->setMountOptions($storageOptions['mountOptions']); } if (!isset($storageOptions['priority'])) { $storageOptions['priority'] = $backend->getPriority(); } $storageConfig->setPriority($storageOptions['priority']); if ($mountType === \OC_Mount_Config::MOUNT_TYPE_USER) { $applicableUsers = $storageConfig->getApplicableUsers(); if ($applicable !== 'all') { $applicableUsers[] = $applicable; $storageConfig->setApplicableUsers($applicableUsers); } } else { if ($mountType === \OC_Mount_Config::MOUNT_TYPE_GROUP) { $applicableGroups = $storageConfig->getApplicableGroups(); $applicableGroups[] = $applicable; $storageConfig->setApplicableGroups($applicableGroups); } } return $storageConfig; }
public function testGetStoragesAuthMechanismNotVisible() { $backend = $this->backendService->getBackend('identifier:\\OCA\\Files_External\\Lib\\Backend\\SMB'); $backend->method('isVisibleFor')->with($this->service->getVisibilityType())->willReturn(true); $authMechanism = $this->backendService->getAuthMechanism('identifier:\\Auth\\Mechanism'); $authMechanism->expects($this->once())->method('isVisibleFor')->with($this->service->getVisibilityType())->willReturn(false); $storage = new StorageConfig(255); $storage->setMountPoint('mountpoint'); $storage->setBackend($backend); $storage->setAuthMechanism($authMechanism); $storage->setBackendOptions(['password' => 'testPassword']); $newStorage = $this->service->addStorage($storage); $this->assertCount(1, $this->service->getAllStorages()); $this->assertEmpty($this->service->getStorages()); }
/** * Create a storage from its parameters * * @param string $mountPoint storage mount point * @param string $backendIdentifier backend identifier * @param string $authMechanismIdentifier authentication mechanism identifier * @param array $backendOptions backend-specific options * @param array|null $mountOptions mount-specific options * @param array|null $applicableUsers users for which to mount the storage * @param array|null $applicableGroups groups for which to mount the storage * @param int|null $priority priority * * @return StorageConfig */ public function createStorage($mountPoint, $backendIdentifier, $authMechanismIdentifier, $backendOptions, $mountOptions = null, $applicableUsers = null, $applicableGroups = null, $priority = null) { $backend = $this->backendService->getBackend($backendIdentifier); if (!$backend) { throw new \InvalidArgumentException('Unable to get backend for ' . $backendIdentifier); } $authMechanism = $this->backendService->getAuthMechanism($authMechanismIdentifier); if (!$authMechanism) { throw new \InvalidArgumentException('Unable to get authentication mechanism for ' . $authMechanismIdentifier); } $newStorage = new StorageConfig(); $newStorage->setMountPoint($mountPoint); $newStorage->setBackend($backend); $newStorage->setAuthMechanism($authMechanism); $newStorage->setBackendOptions($backendOptions); if (isset($mountOptions)) { $newStorage->setMountOptions($mountOptions); } if (isset($applicableUsers)) { $newStorage->setApplicableUsers($applicableUsers); } if (isset($applicableGroups)) { $newStorage->setApplicableGroups($applicableGroups); } if (isset($priority)) { $newStorage->setPriority($priority); } return $newStorage; }
/** * @dataProvider getUniqueStoragesProvider */ public function testGetUniqueStorages($priority1, $applicableUsers1, $applicableGroups1, $priority2, $applicableUsers2, $applicableGroups2, $expectedPrecedence) { $backend = $this->backendService->getBackend('identifier:\\OCA\\Files_External\\Lib\\Backend\\SMB'); $authMechanism = $this->backendService->getAuthMechanism('identifier:\\Auth\\Mechanism'); $storage1 = new StorageConfig(); $storage1->setMountPoint('mountpoint'); $storage1->setBackend($backend); $storage1->setAuthMechanism($authMechanism); $storage1->setBackendOptions(['password' => 'testPassword']); $storage1->setPriority($priority1); $storage1->setApplicableUsers($applicableUsers1); $storage1->setApplicableGroups($applicableGroups1); $storage1 = $this->globalStoragesService->addStorage($storage1); $storage2 = new StorageConfig(); $storage2->setMountPoint('mountpoint'); $storage2->setBackend($backend); $storage2->setAuthMechanism($authMechanism); $storage2->setBackendOptions(['password' => 'testPassword']); $storage2->setPriority($priority2); $storage2->setApplicableUsers($applicableUsers2); $storage2->setApplicableGroups($applicableGroups2); $storage2 = $this->globalStoragesService->addStorage($storage2); $storages = $this->service->getUniqueStorages(); $this->assertCount(1, $storages); if ($expectedPrecedence === 1) { $this->assertArrayHasKey($storage1->getID(), $storages); } elseif ($expectedPrecedence === 2) { $this->assertArrayHasKey($storage2->getID(), $storages); } }
public function testUpdateStorageMountPoint() { $backend = $this->backendService->getBackend('identifier:\\OCA\\Files_External\\Lib\\Backend\\SMB'); $authMechanism = $this->backendService->getAuthMechanism('identifier:\\Auth\\Mechanism'); $storage = new StorageConfig(); $storage->setMountPoint('mountpoint'); $storage->setBackend($backend); $storage->setAuthMechanism($authMechanism); $storage->setBackendOptions(['password' => 'testPassword']); $savedStorage = $this->service->addStorage($storage); $newAuthMechanism = $this->backendService->getAuthMechanism('identifier:\\Other\\Auth\\Mechanism'); $updatedStorage = new StorageConfig($savedStorage->getId()); $updatedStorage->setMountPoint('mountpoint2'); $updatedStorage->setBackend($backend); $updatedStorage->setAuthMechanism($newAuthMechanism); $updatedStorage->setBackendOptions(['password' => 'password2']); $this->service->updateStorage($updatedStorage); $savedStorage = $this->service->getStorage($updatedStorage->getId()); $this->assertEquals('/mountpoint2', $savedStorage->getMountPoint()); $this->assertEquals($newAuthMechanism, $savedStorage->getAuthMechanism()); $this->assertEquals('password2', $savedStorage->getBackendOption('password')); }
/** * @expectedException \OCA\Files_External\NotFoundException */ public function testGetAdminStorage() { $backend = $this->backendService->getBackend('identifier:\\OCA\\Files_External\\Lib\\Backend\\SMB'); $authMechanism = $this->backendService->getAuthMechanism('identifier:\\Auth\\Mechanism'); $storage = new StorageConfig(); $storage->setMountPoint('mountpoint'); $storage->setBackend($backend); $storage->setAuthMechanism($authMechanism); $storage->setBackendOptions(['password' => 'testPassword']); $storage->setApplicableUsers([$this->userId]); $newStorage = $this->globalStoragesService->addStorage($storage); $this->assertInstanceOf('\\OCA\\Files_External\\Lib\\StorageConfig', $this->globalStoragesService->getStorage($newStorage->getId())); $this->service->getStorage($newStorage->getId()); }
/** * @dataProvider validateStorageProvider */ public function testValidateStorage($backendValidate, $authMechValidate, $expectSuccess) { $backend = $this->getBackendMock(); $backend->method('validateStorage')->willReturn($backendValidate); $backend->method('isVisibleFor')->willReturn(true); $authMech = $this->getAuthMechMock(); $authMech->method('validateStorage')->will($this->returnValue($authMechValidate)); $storageConfig = new StorageConfig(); $storageConfig->setMountPoint('mount'); $storageConfig->setBackend($backend); $storageConfig->setAuthMechanism($authMech); $storageConfig->setBackendOptions([]); $this->service->expects($this->once())->method('createStorage')->will($this->returnValue($storageConfig)); if ($expectSuccess) { $this->service->expects($this->once())->method('addStorage')->with($storageConfig)->will($this->returnValue($storageConfig)); } else { $this->service->expects($this->never())->method('addStorage'); } $response = $this->controller->create('mount', '\\OC\\Files\\Storage\\SMB', '\\OCA\\Files_External\\Lib\\Auth\\NullMechanism', array(), [], [], [], null); if ($expectSuccess) { $this->assertEquals(Http::STATUS_CREATED, $response->getStatus()); } else { $this->assertEquals(Http::STATUS_UNPROCESSABLE_ENTITY, $response->getStatus()); } }
protected function execute(InputInterface $input, OutputInterface $output) { $user = $input->getOption('user'); $mountPoint = $input->getArgument('mount_point'); $storageIdentifier = $input->getArgument('storage_backend'); $authIdentifier = $input->getArgument('authentication_backend'); $configInput = $input->getOption('config'); $storageBackend = $this->backendService->getBackend($storageIdentifier); $authBackend = $this->backendService->getAuthMechanism($authIdentifier); if (!Filesystem::isValidPath($mountPoint)) { $output->writeln('<error>Invalid mountpoint "' . $mountPoint . '"</error>'); return 1; } if (is_null($storageBackend)) { $output->writeln('<error>Storage backend with identifier "' . $storageIdentifier . '" not found (see `occ files_external:backends` for possible values)</error>'); return 404; } if (is_null($authBackend)) { $output->writeln('<error>Authentication backend with identifier "' . $authIdentifier . '" not found (see `occ files_external:backends` for possible values)</error>'); return 404; } $supportedSchemes = array_keys($storageBackend->getAuthSchemes()); if (!in_array($authBackend->getScheme(), $supportedSchemes)) { $output->writeln('<error>Authentication backend "' . $authIdentifier . '" not valid for storage backend "' . $storageIdentifier . '" (see `occ files_external:backends storage ' . $storageIdentifier . '` for possible values)</error>'); return 1; } $config = []; foreach ($configInput as $configOption) { if (!strpos($configOption, '=')) { $output->writeln('<error>Invalid mount configuration option "' . $configOption . '"</error>'); return 1; } list($key, $value) = explode('=', $configOption, 2); if (!$this->validateParam($key, $value, $storageBackend, $authBackend)) { $output->writeln('<error>Unknown configuration for backends "' . $key . '"</error>'); return 1; } $config[$key] = $value; } $mount = new StorageConfig(); $mount->setMountPoint($mountPoint); $mount->setBackend($storageBackend); $mount->setAuthMechanism($authBackend); $mount->setBackendOptions($config); if ($user) { if (!$this->userManager->userExists($user)) { $output->writeln('<error>User "' . $user . '" not found</error>'); return 1; } $mount->setApplicableUsers([$user]); } if ($input->getOption('dry')) { $this->showMount($user, $mount, $input, $output); } else { $this->getStorageService($user)->addStorage($mount); if ($input->getOption('output') === self::OUTPUT_FORMAT_PLAIN) { $output->writeln('<info>Storage created with id ' . $mount->getId() . '</info>'); } else { $output->writeln($mount->getId()); } } return 0; }
public function testDeleteStorage() { $backend = $this->backendService->getBackend('identifier:\\OCA\\Files_External\\Lib\\Backend\\SMB'); $authMechanism = $this->backendService->getAuthMechanism('identifier:\\Auth\\Mechanism'); $storage = new StorageConfig(255); $storage->setMountPoint('mountpoint'); $storage->setBackend($backend); $storage->setAuthMechanism($authMechanism); $storage->setBackendOptions(['password' => 'testPassword']); $newStorage = $this->service->addStorage($storage); $this->assertEquals(1, $newStorage->getId()); $newStorage = $this->service->removeStorage(1); $caught = false; try { $this->service->getStorage(1); } catch (NotFoundException $e) { $caught = true; } $this->assertTrue($caught); }
private function parseData(array $data) { $mount = new StorageConfig($data['mount_id']); $mount->setMountPoint($data['mount_point']); $mount->setBackend($this->getBackendByClass($data['storage'])); $authBackend = $this->backendService->getAuthMechanism($data['authentication_type']); $mount->setAuthMechanism($authBackend); $mount->setBackendOptions($data['configuration']); $mount->setMountOptions($data['options']); $mount->setApplicableUsers(isset($data['applicable_users']) ? $data['applicable_users'] : []); $mount->setApplicableGroups(isset($data['applicable_groups']) ? $data['applicable_groups'] : []); return $mount; }
/** * @expectedException \DomainException */ public function testDeleteStorage() { $backend = $this->backendService->getBackend('identifier:\\OCA\\Files_External\\Lib\\Backend\\SMB'); $authMechanism = $this->backendService->getAuthMechanism('identifier:\\Auth\\Mechanism'); $storage = new StorageConfig(255); $storage->setMountPoint('mountpoint'); $storage->setBackend($backend); $storage->setAuthMechanism($authMechanism); $storage->setBackendOptions(['password' => 'testPassword']); $newStorage = $this->globalStoragesService->addStorage($storage); $this->assertEquals(1, $newStorage->getId()); $this->service->removeStorage(1); }