diff options
Diffstat (limited to 'server/vendor/php-opencloud/common/tests')
41 files changed, 2795 insertions, 0 deletions
diff --git a/server/vendor/php-opencloud/common/tests/integration/DefaultLogger.php b/server/vendor/php-opencloud/common/tests/integration/DefaultLogger.php new file mode 100644 index 0000000..a546c70 --- /dev/null +++ b/server/vendor/php-opencloud/common/tests/integration/DefaultLogger.php @@ -0,0 +1,20 @@ +<?php + +namespace OpenCloud\integration; + +use Psr\Log\AbstractLogger; + +class DefaultLogger extends AbstractLogger +{ + public function log($level, $message, array $context = []) + { + echo $this->format($level, $message, $context); + } + + private function format($level, $message, $context) + { + $msg = strtr($message, $context); + + return sprintf("%s: %s\n", strtoupper($level), $msg); + } +} diff --git a/server/vendor/php-opencloud/common/tests/integration/Runner.php b/server/vendor/php-opencloud/common/tests/integration/Runner.php new file mode 100644 index 0000000..98d094c --- /dev/null +++ b/server/vendor/php-opencloud/common/tests/integration/Runner.php @@ -0,0 +1,112 @@ +<?php + +namespace OpenCloud\integration; + +class Runner +{ + private $basePath; + private $logger; + private $services = []; + + public function __construct($basePath) + { + $this->basePath = $basePath; + $this->logger = new DefaultLogger(); + $this->assembleServicesFromSamples(); + } + + private function traverse($path) + { + return new \RecursiveDirectoryIterator($path, \FilesystemIterator::SKIP_DOTS); + } + + private function assembleServicesFromSamples() + { + foreach ($this->traverse($this->basePath) as $servicePath) { + if ($servicePath->isDir()) { + foreach ($this->traverse($servicePath) as $versionPath) { + $this->services[$servicePath->getBasename()][] = $versionPath->getBasename(); + } + } + } + } + + private function getOpts() + { + $opts = getopt('s:v:t:', ['service:', 'version:', 'test::', 'debug::', 'help::']); + + $getOpt = function (array $keys, $default) use ($opts) { + foreach ($keys as $key) { + if (isset($opts[$key])) { + return $opts[$key]; + } + } + return $default; + }; + + return [ + $getOpt(['s', 'service'], 'all'), + $getOpt(['n', 'version'], 'all'), + $getOpt(['t', 'test'], ''), + isset($opts['debug']) ? (int) $opts['debug'] : 0, + ]; + } + + private function getRunnableServices($service, $version) + { + $services = $this->services; + + if ($service != 'all') { + if (!isset($this->services[$service])) { + throw new \InvalidArgumentException(sprintf("%s service does not exist", $service)); + } + + $versions = ($version == 'all') ? $this->services[$service] : [$version]; + $services = [$service => $versions]; + } + + return $services; + } + + /** + * @return TestInterface + */ + private function getTest($serviceName, $version, $verbosity) + { + $namespace = (new \ReflectionClass($this))->getNamespaceName(); + $className = sprintf("%s\\%s\\%sTest", $namespace, Utils::toCamelCase($serviceName), ucfirst($version)); + + if (!class_exists($className)) { + throw new \RuntimeException(sprintf("%s does not exist", $className)); + } + + $basePath = $this->basePath . DIRECTORY_SEPARATOR . $serviceName . DIRECTORY_SEPARATOR . $version; + $smClass = sprintf("%s\\SampleManager", $namespace); + $class = new $className($this->logger, new $smClass($basePath, $verbosity)); + + if (!($class instanceof TestInterface)) { + throw new \RuntimeException(sprintf("%s does not implement TestInterface", $className)); + } + + return $class; + } + + public function runServices() + { + list($serviceOpt, $versionOpt, $testMethodOpt, $verbosityOpt) = $this->getOpts(); + + foreach ($this->getRunnableServices($serviceOpt, $versionOpt) as $serviceName => $versions) { + foreach ($versions as $version) { + $testRunner = $this->getTest($serviceName, $version, $verbosityOpt); + + if ($testMethodOpt) { + $testRunner->runOneTest($testMethodOpt); + } else { + $testRunner->runTests(); + } + + $testRunner->teardown(); + } + } + } +} diff --git a/server/vendor/php-opencloud/common/tests/integration/SampleManager.php b/server/vendor/php-opencloud/common/tests/integration/SampleManager.php new file mode 100644 index 0000000..4bd8b9a --- /dev/null +++ b/server/vendor/php-opencloud/common/tests/integration/SampleManager.php @@ -0,0 +1,104 @@ +<?php + +namespace OpenCloud\integration; + +class SampleManager implements SampleManagerInterface +{ + protected $basePath; + protected $paths = []; + protected $verbosity; + + public function __construct($basePath, $verbosity) + { + $this->basePath = $basePath; + $this->verbosity = $verbosity; + } + + public function deletePaths() + { + if (!empty($this->paths)) { + foreach ($this->paths as $path) { + unlink($path); + } + } + } + + protected function getGlobalReplacements() + { + return [ + '{userId}' => getenv('OS_USER_ID'), + '{username}' => getenv('OS_USERNAME'), + '{password}' => getenv('OS_PASSWORD'), + '{domainId}' => getenv('OS_DOMAIN_ID'), + '{authUrl}' => getenv('OS_AUTH_URL'), + '{tenantId}' => getenv('OS_TENANT_ID'), + '{region}' => getenv('OS_REGION'), + '{projectId}' => getenv('OS_PROJECT_ID'), + '{projectName}' => getenv('OS_PROJECT_NAME'), + ]; + } + + protected function getConnectionTemplate() + { + if ($this->verbosity === 1) { + $subst = <<<'EOL' +use OpenCloud\Integration\DefaultLogger; +use OpenCloud\Integration\Utils; +use GuzzleHttp\MessageFormatter; + +$options = [ + 'debugLog' => true, + 'logger' => new DefaultLogger(), + 'messageFormatter' => new MessageFormatter(), +]; +$openstack = new OpenCloud\OpenCloud(Utils::getAuthOpts($options)); +EOL; + } elseif ($this->verbosity === 2) { + $subst = <<<'EOL' +use OpenCloud\Integration\DefaultLogger; +use OpenCloud\Integration\Utils; +use GuzzleHttp\MessageFormatter; + +$options = [ + 'debugLog' => true, + 'logger' => new DefaultLogger(), + 'messageFormatter' => new MessageFormatter(MessageFormatter::DEBUG), +]; +$openstack = new OpenCloud\OpenCloud(Utils::getAuthOpts($options)); +EOL; + } else { + $subst = <<<'EOL' +use OpenCloud\Integration\Utils; + +$openstack = new OpenCloud\OpenCloud(Utils::getAuthOpts()); +EOL; + } + + return $subst; + } + + public function write($path, array $replacements) + { + $replacements = array_merge($this->getGlobalReplacements(), $replacements); + + $sampleFile = rtrim($this->basePath, DIRECTORY_SEPARATOR) . DIRECTORY_SEPARATOR . $path; + + if (!file_exists($sampleFile) || !is_readable($sampleFile)) { + throw new \RuntimeException(sprintf("%s either does not exist or is not readable", $sampleFile)); + } + + $content = strtr(file_get_contents($sampleFile), $replacements); + $content = str_replace("'vendor/'", "'" . dirname(dirname(__DIR__)) . DIRECTORY_SEPARATOR . "vendor'", $content); + + $subst = $this->getConnectionTemplate(); + $content = preg_replace('/\([^)]+\)/', '', $content, 1); + $content = str_replace('$openstack = new OpenCloud\OpenCloud;', $subst, $content); + + $tmp = tempnam(sys_get_temp_dir(), 'openstack'); + file_put_contents($tmp, $content); + + $this->paths[] = $tmp; + + return $tmp; + } +} diff --git a/server/vendor/php-opencloud/common/tests/integration/SampleManagerInterface.php b/server/vendor/php-opencloud/common/tests/integration/SampleManagerInterface.php new file mode 100644 index 0000000..f0fe848 --- /dev/null +++ b/server/vendor/php-opencloud/common/tests/integration/SampleManagerInterface.php @@ -0,0 +1,10 @@ +<?php + +namespace OpenCloud\integration; + +interface SampleManagerInterface +{ + public function write($path, array $replacements); + + public function deletePaths(); +} diff --git a/server/vendor/php-opencloud/common/tests/integration/TestCase.php b/server/vendor/php-opencloud/common/tests/integration/TestCase.php new file mode 100644 index 0000000..687760a --- /dev/null +++ b/server/vendor/php-opencloud/common/tests/integration/TestCase.php @@ -0,0 +1,115 @@ +<?php + +namespace OpenCloud\integration; + +use Psr\Log\LoggerInterface; + +abstract class TestCase extends \PHPUnit_Framework_TestCase implements TestInterface +{ + private $logger; + private $startPoint; + private $lastPoint; + private $sampleManager; + + public function __construct(LoggerInterface $logger, SampleManagerInterface $sampleManager) + { + $this->logger = $logger; + $this->sampleManager = $sampleManager; + } + + public function teardown() + { + $this->sampleManager->deletePaths(); + } + + public function runOneTest($name) + { + if (!method_exists($this, $name)) { + throw new \InvalidArgumentException(sprintf("%s method does not exist", $name)); + } + + $this->startTimer(); + $this->$name(); + $this->outputTimeTaken(); + } + + protected function startTimer() + { + $this->startPoint = $this->lastPoint = microtime(true); + } + + private function wrapColor($message, $colorPrefix) + { + return sprintf("%s%s", $colorPrefix, $message) . "\033[0m\033[1;0m"; + } + + protected function logStep($message, array $context = []) + { + $duration = microtime(true) - $this->lastPoint; + + $stepTimeTaken = sprintf('(%s)', $this->formatSecDifference($duration)); + + if ($duration >= 10) { + $color = "\033[0m\033[1;31m"; // red + } elseif ($duration >= 2) { + $color = "\033[0m\033[1;33m"; // yellow + } else { + $color = "\033[0m\033[1;32m"; // green + } + + $message = '{timeTaken} ' . $message; + $context['{timeTaken}'] = $this->wrapColor($stepTimeTaken, $color); + + $this->logger->info($message, $context); + + $this->lastPoint = microtime(true); + } + + protected function randomStr($length = 5) + { + $chars = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'; + $charsLen = strlen($chars); + + $randomString = ''; + for ($i = 0; $i < $length; $i++) { + $randomString .= $chars[rand(0, $charsLen - 1)]; + } + + return 'phptest_' . $randomString; + } + + private function formatMinDifference($duration) + { + $output = ''; + + if (($minutes = floor($duration / 60)) > 0) { + $output .= $minutes . 'min' . (($minutes > 1) ? 's' : ''); + } + + if (($seconds = number_format(fmod($duration, 60), 2)) > 0) { + if ($minutes > 0) { + $output .= ' '; + } + $output .= $seconds . 's'; + } + + return $output; + } + + private function formatSecDifference($duration) + { + return number_format($duration, 2) . 's'; + } + + protected function outputTimeTaken() + { + $output = $this->formatMinDifference(microtime(true) - $this->startPoint); + + $this->logger->info('Finished all tests! Time taken: {output}.', ['{output}' => $output]); + } + + protected function sampleFile(array $replacements, $path) + { + return $this->sampleManager->write($path, $replacements); + } +} diff --git a/server/vendor/php-opencloud/common/tests/integration/TestInterface.php b/server/vendor/php-opencloud/common/tests/integration/TestInterface.php new file mode 100644 index 0000000..a89e8af --- /dev/null +++ b/server/vendor/php-opencloud/common/tests/integration/TestInterface.php @@ -0,0 +1,16 @@ +<?php + +namespace OpenCloud\integration; + +use Psr\Log\LoggerInterface; + +interface TestInterface +{ + public function __construct(LoggerInterface $logger, SampleManagerInterface $sampleManager); + + public function runTests(); + + public function runOneTest($name); + + public function teardown(); +} diff --git a/server/vendor/php-opencloud/common/tests/integration/Utils.php b/server/vendor/php-opencloud/common/tests/integration/Utils.php new file mode 100644 index 0000000..daa1426 --- /dev/null +++ b/server/vendor/php-opencloud/common/tests/integration/Utils.php @@ -0,0 +1,59 @@ +<?php + +namespace OpenCloud\integration; + +use GuzzleHttp\Client; +use OpenCloud\Identity\v2\Api; +use OpenCloud\Identity\v2\Service; +use OpenCloud\Common\Transport\HandlerStack; +use OpenCloud\Common\Transport\Utils as CommonUtils; + +class Utils +{ + public static function getAuthOptsV3() + { + return [ + 'authUrl' => getenv('OS_AUTH_URL'), + 'region' => getenv('OS_REGION_NAME'), + 'user' => [ + 'id' => getenv('OS_USER_ID'), + 'password' => getenv('OS_PASSWORD'), + ], + 'scope' => [ + 'project' => [ + 'id' => getenv('OS_PROJECT_ID'), + ] + ] + ]; + } + + public static function getAuthOptsV2() + { + $httpClient = new Client([ + 'base_uri' => CommonUtils::normalizeUrl(getenv('OS_AUTH_URL')), + 'handler' => HandlerStack::create(), + ]); + return [ + 'authUrl' => getenv('OS_AUTH_URL'), + 'region' => getenv('OS_REGION_NAME'), + 'username' => getenv('OS_USERNAME'), + 'password' => getenv('OS_PASSWORD'), + 'tenantName' => getenv('OS_TENANT_NAME'), + 'identityService' => new Service($httpClient, new Api), + ]; + } + + public static function getAuthOpts(array $options = []) + { + $authOptions = getenv('OS_IDENTITY_API_VERSION') == '2.0' + ? self::getAuthOptsV2() + : self::getAuthOptsV3(); + + return array_merge($authOptions, $options); + } + + public static function toCamelCase($word, $separator = '_') + { + return str_replace($separator, '', ucwords($word, $separator)); + } +} diff --git a/server/vendor/php-opencloud/common/tests/integration/run.php b/server/vendor/php-opencloud/common/tests/integration/run.php new file mode 100644 index 0000000..5bc5548 --- /dev/null +++ b/server/vendor/php-opencloud/common/tests/integration/run.php @@ -0,0 +1,10 @@ +<?php + +$rootDir = dirname(dirname(__DIR__)); + +require_once $rootDir . '/vendor/autoload.php'; + +$basePath = $rootDir . '/samples'; + +$runner = new \OpenCloud\Integration\Runner($basePath); +$runner->runServices(); diff --git a/server/vendor/php-opencloud/common/tests/integration/script/compute_v2 b/server/vendor/php-opencloud/common/tests/integration/script/compute_v2 new file mode 100755 index 0000000..5e90b05 --- /dev/null +++ b/server/vendor/php-opencloud/common/tests/integration/script/compute_v2 @@ -0,0 +1,3 @@ +#!/bin/bash + +php tests/integration/Runner.php -s compute -v v2 diff --git a/server/vendor/php-opencloud/common/tests/integration/script/identity_v3 b/server/vendor/php-opencloud/common/tests/integration/script/identity_v3 new file mode 100755 index 0000000..cd175b5 --- /dev/null +++ b/server/vendor/php-opencloud/common/tests/integration/script/identity_v3 @@ -0,0 +1,3 @@ +#!/bin/bash + +php tests/integration/Runner.php -s identity -v v3 diff --git a/server/vendor/php-opencloud/common/tests/integration/script/networking_v2 b/server/vendor/php-opencloud/common/tests/integration/script/networking_v2 new file mode 100755 index 0000000..9583f68 --- /dev/null +++ b/server/vendor/php-opencloud/common/tests/integration/script/networking_v2 @@ -0,0 +1,3 @@ +#!/bin/bash + +php tests/integration/Runner.php -s networking -v v2 diff --git a/server/vendor/php-opencloud/common/tests/integration/script/objectstore_v2 b/server/vendor/php-opencloud/common/tests/integration/script/objectstore_v2 new file mode 100755 index 0000000..3fb893a --- /dev/null +++ b/server/vendor/php-opencloud/common/tests/integration/script/objectstore_v2 @@ -0,0 +1,3 @@ +#!/bin/bash + +php tests/integration/Runner.php -s objectstore -v v2 diff --git a/server/vendor/php-opencloud/common/tests/unit/Common/Api/OperationTest.php b/server/vendor/php-opencloud/common/tests/unit/Common/Api/OperationTest.php new file mode 100644 index 0000000..ea0f7c8 --- /dev/null +++ b/server/vendor/php-opencloud/common/tests/unit/Common/Api/OperationTest.php @@ -0,0 +1,74 @@ +<?php + +namespace OpenCloud\Test\Common\Api; + +use OpenCloud\Common\Api\Operation; +use OpenCloud\Common\Api\Parameter; +use OpenCloud\Test\Fixtures\ComputeV2Api; + +class OperationTest extends \PHPUnit_Framework_TestCase +{ + private $operation; + + public function setUp() + { + $def = (new ComputeV2Api())->postServer(); + + $this->operation = new Operation($def); + } + + public function test_it_reveals_whether_params_are_set_or_not() + { + $this->assertFalse($this->operation->hasParam('foo')); + $this->assertTrue($this->operation->hasParam('name')); + } + + public function test_it_gets_params() + { + $this->assertInstanceOf(Parameter::class, $this->operation->getParam('name')); + } + + public function test_it_validates_params() + { + $this->assertTrue($this->operation->validate([ + 'name' => 'foo', + 'imageId' => 'bar', + 'flavorId' => 'baz', + ])); + } + + /** + * @expectedException \Exception + */ + public function test_exceptions_are_propagated() + { + $this->assertFalse($this->operation->validate([ + 'name' => true, + 'imageId' => 'bar', + 'flavorId' => 'baz', + ])); + } + + /** + * @expectedException \Exception + */ + public function test_an_exception_is_thrown_when_user_does_not_provide_required_options() + { + $this->operation->validate([]); + } + + /** + * @expectedException \Exception + */ + public function test_it_throws_exception_when_user_provides_undefined_options() + { + $userData = ['name' => 'new_server', 'undefined_opt' => 'bah']; + + $this->operation->validate($userData); + } + + public function test_it_gets_json_key() + { + $this->assertEquals('server', $this->operation->getJsonKey()); + } +} diff --git a/server/vendor/php-opencloud/common/tests/unit/Common/Api/OperatorTest.php b/server/vendor/php-opencloud/common/tests/unit/Common/Api/OperatorTest.php new file mode 100644 index 0000000..43c5804 --- /dev/null +++ b/server/vendor/php-opencloud/common/tests/unit/Common/Api/OperatorTest.php @@ -0,0 +1,137 @@ +<?php + +namespace OpenCloud\Test\Common\Api; + +use function GuzzleHttp\Psr7\uri_for; +use GuzzleHttp\Promise\Promise; +use GuzzleHttp\Psr7\Request; +use GuzzleHttp\Psr7\Response; +use GuzzleHttp\Psr7\Uri; +use OpenCloud\Common\Api\Operator; +use OpenCloud\Common\Resource\AbstractResource; +use OpenCloud\Common\Resource\ResourceInterface; +use OpenCloud\Compute\v2\Models\Server; +use OpenCloud\Test\Fixtures\ComputeV2Api; +use OpenCloud\Test\TestCase; +use Prophecy\Argument; + +class OperatorTest extends TestCase +{ + private $operator; + private $def; + + public function setUp() + { + parent::setUp(); + + $this->rootFixturesDir = __DIR__; + + $this->def = [ + 'method' => 'GET', + 'path' => 'test', + 'params' => [], + ]; + + $this->operator = new TestOperator($this->client->reveal(), new ComputeV2Api()); + } + + public function test_it_returns_operations() + { + $this->assertInstanceOf( + 'OpenCloud\Common\Api\Operation', + $this->operator->getOperation($this->def, []) + ); + } + + public function test_it_sends_a_request_when_operations_are_executed() + { + $this->client->request('GET', 'test', ['headers' => []])->willReturn(new Request('GET', 'test')); + + $this->operator->execute($this->def, []); + } + + public function test_it_sends_a_request_when_async_operations_are_executed() + { + $this->client->requestAsync('GET', 'test', ['headers' => []])->willReturn(new Promise()); + + $this->operator->executeAsync($this->def, []); + } + + public function test_it_returns_a_model_instance() + { + $this->assertInstanceOf(ResourceInterface::class, $this->operator->model(TestResource::class)); + } + + public function test_it_populates_models_from_response() + { + $this->assertInstanceOf(ResourceInterface::class, $this->operator->model(TestResource::class, new Response(200))); + } + + public function test_it_populates_models_from_arrays() + { + $data = ['flavor' => [], 'image' => []]; + $this->assertInstanceOf(ResourceInterface::class, $this->operator->model(TestResource::class, $data)); + } + + public function test_it_wraps_sequential_ops_in_promise_when_async_is_appended_to_method_name() + { + $promise = $this->operator->createAsync('something'); + + $this->assertInstanceOf(Promise::class, $promise); + + $promise->then(function ($val) { + $this->assertEquals('Created something', $val); + }); + + $promise->wait(); + } + + /** + * @expectedException \RuntimeException + */ + public function test_it_throws_exception_when_async_is_called_on_a_non_existent_method() + { + $this->operator->fooAsync(); + } + + public function test_it_retrieves_base_http_url() + { + $returnedUri = uri_for('http://foo.com'); + + $this->client->getConfig('base_uri')->shouldBeCalled()->willReturn($returnedUri); + + $uri = $this->operator->testBaseUri(); + + $this->assertInstanceOf(Uri::class, $uri); + $this->assertEquals($returnedUri, $uri); + } + + /** + * @expectedException \Exception + */ + public function test_undefined_methods_result_in_error() + { + $this->operator->foo(); + } +} + +class TestResource extends AbstractResource +{ +} + +class TestOperator extends Operator +{ + public function testBaseUri() + { + return $this->getHttpBaseUrl(); + } + + public function create($str) + { + return 'Created ' . $str; + } + + public function fail() + { + } +} diff --git a/server/vendor/php-opencloud/common/tests/unit/Common/Api/ParameterTest.php b/server/vendor/php-opencloud/common/tests/unit/Common/Api/ParameterTest.php new file mode 100644 index 0000000..65d4760 --- /dev/null +++ b/server/vendor/php-opencloud/common/tests/unit/Common/Api/ParameterTest.php @@ -0,0 +1,203 @@ +<?php + +namespace OpenCloud\Test\Common\Api; + +use OpenCloud\Common\Api\Parameter; +use OpenCloud\Test\Fixtures\ComputeV2Api; + +class ParameterTest extends \PHPUnit_Framework_TestCase +{ + const PARAMETER_CLASS = 'OpenCloud\Common\Api\Parameter'; + + private $param; + private $data; + private $api; + + public function setUp() + { + $this->api = new ComputeV2Api(); + + $this->data = $this->api->postServer()['params']['name'] + ['name' => 'name']; + $this->param = new Parameter($this->data); + } + + /** + * @expectedException \RuntimeException + */ + public function test_exception_is_thrown_for_invalid_locations() + { + $data = $this->data; + $data['location'] = 'foo'; + new Parameter($data); + } + + public function test_it_should_provide_access_to_a_name() + { + $this->assertEquals($this->data['name'], $this->param->getName()); + } + + public function test_it_should_use_sentAs_alias_for_name_if_one_is_set() + { + $data = $this->data + ['sentAs' => 'foo']; + $param = new Parameter($data); + + $this->assertEquals($data['sentAs'], $param->getName()); + } + + public function test_it_indicates_whether_it_is_required_or_not() + { + $this->assertTrue($this->param->isRequired()); + } + + public function test_it_indicates_its_item_schema() + { + $data = $this->api->postServer()['params']['networks'] + ['name' => 'networks']; + $param = new Parameter($data); + + $this->assertInstanceOf(self::PARAMETER_CLASS, $param->getItemSchema()); + } + + public function test_it_allows_property_retrieval() + { + $definition = $this->api->postServer()['params']['networks']['items'] + ['name' => 'network']; + $param = new Parameter($definition); + + $this->assertInstanceOf(self::PARAMETER_CLASS, $param->getProperty('uuid')); + } + + public function test_it_indicates_its_path() + { + $path = 'foo.bar.baz'; + $param = new Parameter($this->data + ['path' => $path]); + + $this->assertEquals($path, $param->getPath()); + } + + public function test_it_verifies_a_given_location_with_a_boolean() + { + $this->assertFalse($this->param->hasLocation('foo')); + $this->assertTrue($this->param->hasLocation('json')); + } + + public function test_it_should_return_true_when_required_attributes_are_provided_and_match_their_definitions() + { + $this->assertTrue($this->param->validate('TestName')); + } + + /** + * @expectedException \Exception + */ + public function test_it_throws_exception_when_values_do_not_match_their_definition_types() + { + $data = $this->api->postServer()['params']['networks'] + ['name' => 'networks']; + $param = new Parameter($data); + + $param->validate('a_network!'); // should be an array + } + + /** + * @expectedException \Exception + */ + public function test_it_throws_exception_when_deeply_nested_values_have_wrong_types() + { + $data = $this->api->postServer()['params']['networks'] + ['name' => 'networks']; + + $param = new Parameter($data); + $param->validate(['name' => false]); // value should be a string, not bool + } + + public function test_metadata_properties_are_handled_differently() + { + $params = [ + 'name' => 'metadata', + 'type' => 'object', + 'properties' => [ + 'type' => 'string', + ], + ]; + + $userValues = ['some' => 'value']; + + $param = new Parameter($params); + $this->assertTrue($param->validate($userValues)); + } + + public function test_it_passes_validation_when_array_values_pass() + { + $params = [ + 'name' => 'foo', + 'type' => 'array', + 'items' => ['type' => 'string'], + ]; + + $userVals = ['1', '2', '3']; + + $param = new Parameter($params); + $this->assertTrue($param->validate($userVals)); + } + + /** + * @expectedException \Exception + */ + public function test_an_exception_is_thrown_when_an_undefined_property_is_provided() + { + $params = ['type' => 'object', 'properties' => ['foo' => ['type' => 'string']]]; + $userVals = ['bar' => 'baz']; + + $param = new Parameter($params); + $param->validate($userVals); + } + + public function test_it_passes_validation_when_all_subproperties_pass() + { + $params = ['type' => 'object', 'properties' => ['foo' => ['type' => 'string']]]; + $userVals = ['foo' => 'baz']; + + $param = new Parameter($params); + $this->assertTrue($param->validate($userVals)); + } + + public function test_it_sets_name() + { + $this->param->setName('foo'); + $this->assertEquals($this->param->getName(), 'foo'); + } + + public function test_it_gets_property() + { + $property = new Parameter([ + 'name' => 'metadata', + 'properties' => [ + 'type' => 'string', + 'prefix' => 'foo', + ], + ]); + + $prop = $property->getProperty('metadata'); + + $this->assertInstanceOf(Parameter::class, $prop); + $this->assertEquals('foo', $prop->getPrefix()); + } + + public function test_it_gets_prefixed_name() + { + $property = new Parameter([ + 'name' => 'metadata', + 'prefix' => 'foo-', + ]); + + $this->assertEquals('foo-metadata', $property->getPrefixedName()); + } + + /** + * @expectedException \Exception + */ + public function test_exception_is_thrown_when_value_is_not_in_enum_list() + { + $data = $this->data; + $data['enum'] = ['foo']; + + $param = new Parameter($data); + $param->validate('blah'); + } +} diff --git a/server/vendor/php-opencloud/common/tests/unit/Common/Api/fixtures/headers.php b/server/vendor/php-opencloud/common/tests/unit/Common/Api/fixtures/headers.php new file mode 100644 index 0000000..f428992 --- /dev/null +++ b/server/vendor/php-opencloud/common/tests/unit/Common/Api/fixtures/headers.php @@ -0,0 +1,25 @@ +<?php + +return [ + 'method' => 'POST', + 'path' => 'something', + 'params' => [ + 'name' => [ + 'type' => 'string', + 'location' => 'header', + 'sentAs' => 'X-Foo-Name' + ], + 'age' => [ + 'type' => 'integer', + 'location' => 'header' + ], + 'metadata' => [ + 'type' => 'object', + 'location' => 'header', + 'items' => [ + 'prefix' => 'X-Meta-' + ] + ], + 'other' => ['type' => 'string'] // should not be a header + ], +]; diff --git a/server/vendor/php-opencloud/common/tests/unit/Common/Api/fixtures/jsonBody.php b/server/vendor/php-opencloud/common/tests/unit/Common/Api/fixtures/jsonBody.php new file mode 100644 index 0000000..350affd --- /dev/null +++ b/server/vendor/php-opencloud/common/tests/unit/Common/Api/fixtures/jsonBody.php @@ -0,0 +1,27 @@ +<?php + +return [ + 'method' => 'POST', + 'path' => 'something', + 'params' => [ + 'name' => [ + 'type' => 'string', + 'sentAs' => 'server_name', + ], + 'other' => [ + 'type' => 'array', + 'sentAs' => 'other_params', + 'items' => [ + 'type' => 'string' + ] + ], + 'etc' => [ + 'type' => 'object', + 'sentAs' => 'etcetc', + 'properties' => [ + 'dob' => ['type' => 'string'], + 'age' => ['type' => 'integer', 'sentAs' => 'current_age'], + ] + ], + ], +]; diff --git a/server/vendor/php-opencloud/common/tests/unit/Common/ArrayAccessTraitTest.php b/server/vendor/php-opencloud/common/tests/unit/Common/ArrayAccessTraitTest.php new file mode 100644 index 0000000..f5d1fdb --- /dev/null +++ b/server/vendor/php-opencloud/common/tests/unit/Common/ArrayAccessTraitTest.php @@ -0,0 +1,59 @@ +<?php + +namespace OpenCloud\Test\Common; + +use OpenCloud\Common\ArrayAccessTrait; +use OpenCloud\Test\TestCase; + +class ArrayAccessTraitTest extends TestCase +{ + private $aa; + + public function setUp() + { + $this->aa = new ArrayAccess(); + } + + public function test_offset_is_set() + { + $this->aa->offsetSet('foo', 'bar'); + $this->assertEquals(['foo' => 'bar'], $this->aa->getElements()); + } + + public function test_it_appends_if_no_key_is_set() + { + $this->aa->offsetSet(null, 'bar'); + $this->assertEquals(['bar'], $this->aa->getElements()); + } + + public function test_if_checks_if_offset_exists() + { + $this->aa->offsetSet('bar', 'foo'); + $this->assertTrue($this->aa->offsetExists('bar')); + $this->assertFalse($this->aa->offsetExists('baz')); + } + + public function test_if_gets_offset() + { + $this->aa->offsetSet('bar', 'foo'); + $this->assertEquals('foo', $this->aa->offsetGet('bar')); + $this->assertNull($this->aa->offsetGet('baz')); + } + + public function test_it_unsets_offset() + { + $this->aa->offsetSet('bar', 'foo'); + $this->aa->offsetUnset('bar'); + $this->assertNull($this->aa->offsetGet('bar')); + } +} + +class ArrayAccess +{ + use ArrayAccessTrait; + + public function getElements() + { + return $this->internalState; + } +} diff --git a/server/vendor/php-opencloud/common/tests/unit/Common/Auth/AuthHandlerTest.php b/server/vendor/php-opencloud/common/tests/unit/Common/Auth/AuthHandlerTest.php new file mode 100644 index 0000000..3c77dde --- /dev/null +++ b/server/vendor/php-opencloud/common/tests/unit/Common/Auth/AuthHandlerTest.php @@ -0,0 +1,59 @@ +<?php + +namespace OpenCloud\Test\Common\Auth; + +use GuzzleHttp\Psr7\Request; +use OpenCloud\Common\Auth\AuthHandler; +use OpenCloud\Common\Auth\Token; +use OpenCloud\Test\TestCase; +use Psr\Http\Message\RequestInterface; + +class AuthHandlerTest extends TestCase +{ + const TOKEN_ID = 'tokenId'; + + private $generator; + private $handler; + + public function setUp() + { + $this->generator = function () { + $token = $this->prophesize(FakeToken::class); + $token->getId()->shouldBeCalled()->willReturn(self::TOKEN_ID); + return $token->reveal(); + }; + + $this->handler = function (RequestInterface $r) { + return $r; + }; + + $this->handler = new AuthHandler($this->handler, $this->generator); + } + + public function test_it_should_bypass_auth_http_requests() + { + // Fake a Keystone request + $request = new Request('POST', 'https://my-openstack.org:5000/v2.0/tokens'); + + $this->assertEquals($request, call_user_func_array($this->handler, [$request, []])); + } + + public function test_it_should_generate_a_new_token_if_the_current_token_is_either_expired_or_not_set() + { + $token = $this->prophesize(Token::class); + + // force the mock token to indicate that its expired + $token->getId()->willReturn(''); + $token->hasExpired()->willReturn(true); + + $request = new Request('GET', ''); + + $handler = new AuthHandler($this->handler, $this->generator, $token->reveal()); + $handler($request, []); + } +} + +class FakeToken implements Token { + public function getId() {} + public function hasExpired() {} +}
\ No newline at end of file diff --git a/server/vendor/php-opencloud/common/tests/unit/Common/DateTime.php b/server/vendor/php-opencloud/common/tests/unit/Common/DateTime.php new file mode 100644 index 0000000..512ba30 --- /dev/null +++ b/server/vendor/php-opencloud/common/tests/unit/Common/DateTime.php @@ -0,0 +1,16 @@ +<?php + +namespace OpenCloud\Test\Common; + +class DateTime extends \DateTime +{ + public static function factory($time) + { + return new static($time); + } + + public function toIso8601() + { + return $this->format(self::ISO8601); + } +} diff --git a/server/vendor/php-opencloud/common/tests/unit/Common/Error/BadResponseErrorTest.php b/server/vendor/php-opencloud/common/tests/unit/Common/Error/BadResponseErrorTest.php new file mode 100644 index 0000000..7aa4bf1 --- /dev/null +++ b/server/vendor/php-opencloud/common/tests/unit/Common/Error/BadResponseErrorTest.php @@ -0,0 +1,34 @@ +<?php + +namespace OpenCloud\Test\Common\Error; + +use GuzzleHttp\Psr7\Request; +use GuzzleHttp\Psr7\Response; +use OpenCloud\Common\Error\BadResponseError; +use OpenCloud\Test\TestCase; + +class BadResponseErrorTest extends TestCase +{ + private $e; + + public function setUp() + { + $this->e = new BadResponseError(); + } + + public function test_it_gets_request() + { + $r = new Request('GET', ''); + + $this->e->setRequest($r); + $this->assertEquals($this->e->getRequest(), $r); + } + + public function test_it_gets_response() + { + $r = new Response(500); + + $this->e->setResponse($r); + $this->assertEquals($this->e->getResponse(), $r); + } +} diff --git a/server/vendor/php-opencloud/common/tests/unit/Common/Error/BuilderTest.php b/server/vendor/php-opencloud/common/tests/unit/Common/Error/BuilderTest.php new file mode 100644 index 0000000..e23806d --- /dev/null +++ b/server/vendor/php-opencloud/common/tests/unit/Common/Error/BuilderTest.php @@ -0,0 +1,117 @@ +<?php + +namespace OpenCloud\Test\Common\Error; + +use function GuzzleHttp\Psr7\{stream_for,str}; + +use GuzzleHttp\ClientInterface; +use GuzzleHttp\Exception\ClientException; +use GuzzleHttp\Psr7\{Request,Response}; +use OpenCloud\Common\Error\{BadResponseError,Builder,UserInputError}; + +class BuilderTest extends \PHPUnit_Framework_TestCase +{ + private $builder; + private $client; + + public function __construct() + { + $this->client = $this->prophesize(ClientInterface::class); + $this->builder = new Builder($this->client->reveal()); + } + + public function test_it_injects_client() + { + $this->assertInstanceOf(Builder::class, new Builder($this->client->reveal())); + } + + public function test_it_builds_http_errors() + { + $request = new Request('POST', '/servers'); + $response = new Response(400, [], stream_for('Invalid parameters')); + + $requestStr = trim($this->builder->str($request)); + $responseStr = trim($this->builder->str($response)); + + $errorMessage = <<<EOT +HTTP Error +~~~~~~~~~~ +The remote server returned a "400 Bad Request" error for the following transaction: + +Request +~~~~~~~ +$requestStr + +Response +~~~~~~~~ +$responseStr + +Further information +~~~~~~~~~~~~~~~~~~~ +Please ensure that your input values are valid and well-formed. Visit http://docs.php-opencloud.com/en/latest/http-codes for more information about debugging HTTP status codes, or file a support issue on https://github.com/php-opencloud/openstack/issues. +EOT; + + $e = new BadResponseError($errorMessage); + $e->setRequest($request); + $e->setResponse($response); + + $this->assertEquals($e, $this->builder->httpError($request, $response)); + } + + public function test_it_builds_user_input_errors() + { + $expected = 'A well-formed string'; + $value = ['foo' => true]; + $link = 'http://docs.php-opencloud.com/en/latest/index.html'; + + $errorMessage = <<<EOT +User Input Error +~~~~~~~~~~~~~~~~ +A well-formed string was expected, but the following value was passed in: + +Array +( + [foo] => 1 +) + +Please ensure that the value adheres to the expectation above. Visit $link for more information about input arguments. If you run into trouble, please open a support issue on https://github.com/php-opencloud/openstack/issues. +EOT; + + $this->client + ->request('HEAD', $link) + ->shouldBeCalled() + ->willReturn(new Response(200)); + + $e = new UserInputError($errorMessage); + + $this->assertEquals($e, $this->builder->userInputError($expected, $value, 'index.html')); + } + + public function test_dead_links_are_ignored() + { + $expected = 'A well-formed string'; + $value = ['foo' => true]; + + $errorMessage = <<<EOT +User Input Error +~~~~~~~~~~~~~~~~ +A well-formed string was expected, but the following value was passed in: + +Array +( + [foo] => 1 +) + +Please ensure that the value adheres to the expectation above. If you run into trouble, please open a support issue on https://github.com/php-opencloud/openstack/issues. +EOT; + + $this->client + ->request('HEAD', 'http://docs.php-opencloud.com/en/latest/sdffsda') + ->shouldBeCalled() + ->willThrow(ClientException::class); + + $e = new UserInputError($errorMessage); + + $this->assertEquals($e, $this->builder->userInputError($expected, $value, 'sdffsda')); + } +} diff --git a/server/vendor/php-opencloud/common/tests/unit/Common/HydratorStrategyTraitTes.php b/server/vendor/php-opencloud/common/tests/unit/Common/HydratorStrategyTraitTes.php new file mode 100644 index 0000000..6841002 --- /dev/null +++ b/server/vendor/php-opencloud/common/tests/unit/Common/HydratorStrategyTraitTes.php @@ -0,0 +1,52 @@ +<?php + +namespace OpenCloud\Test\Common; + +use OpenCloud\Common\HydratorStrategyTrait; +use OpenCloud\Test\TestCase; + +class HydratorStrategyTraitTest extends TestCase +{ + private $fixture; + + public function setUp() + { + $this->fixture = new Fixture(); + } + + public function test_it_hydrates() + { + $data = ['foo' => 1, 'bar' => 2, 'baz' => 3, 'boo' => 4]; + + $this->fixture->hydrate($data); + + $this->assertEquals(1, $this->fixture->foo); + $this->assertEquals(2, $this->fixture->getBar()); + $this->assertEquals(3, $this->fixture->getBaz()); + } + + public function test_it_hydrates_aliases() + { + $this->fixture->hydrate(['FOO!' => 1], ['FOO!' => 'foo']); + + $this->assertEquals(1, $this->fixture->foo); + } +} + +class Fixture +{ + public $foo; + protected $bar; + private $baz; + + use HydratorStrategyTrait; + + public function getBar() + { + return $this->bar; + } + public function getBaz() + { + return $this->baz; + } +} diff --git a/server/vendor/php-opencloud/common/tests/unit/Common/JsonPathTest.php b/server/vendor/php-opencloud/common/tests/unit/Common/JsonPathTest.php new file mode 100644 index 0000000..1410076 --- /dev/null +++ b/server/vendor/php-opencloud/common/tests/unit/Common/JsonPathTest.php @@ -0,0 +1,70 @@ +<?php + +namespace OpenCloud\Test\Common; + +use OpenCloud\Common\JsonPath; + +class JsonPathTest extends \PHPUnit_Framework_TestCase +{ + private $jsonPath; + + public function setUp() + { + $this->jsonPath = new JsonPath([]); + } + + public function test_it_sets_values_according_to_paths() + { + $this->jsonPath->set('foo.bar.baz', 'VALUE'); + + $expected = [ + 'foo' => [ + 'bar' => [ + 'baz' => 'VALUE', + ] + ] + ]; + + $this->assertEquals($expected, $this->jsonPath->getStructure()); + } + + public function test_it_sets_arrays_according_to_paths() + { + $jsonPath = new JsonPath([ + 'foo' => [ + 'bar' => [ + 'value' => 'VALUE', + ] + ] + ]); + + $jsonPath->set('foo.bar.items', ['item_1', 'item_2']); + + $expected = [ + 'foo' => [ + 'bar' => [ + 'value' => 'VALUE', + 'items' => ['item_1', 'item_2'], + ] + ] + ]; + + $this->assertEquals($expected, $jsonPath->getStructure()); + } + + public function test_it_gets_values_according_to_paths() + { + $jsonPath = new JsonPath([ + 'foo' => [ + 'bar' => [ + 'baz' => 'VALUE_1', + 'lol' => 'VALUE_2', + ] + ] + ]); + + $this->assertEquals('VALUE_1', $jsonPath->get('foo.bar.baz')); + $this->assertEquals('VALUE_2', $jsonPath->get('foo.bar.lol')); + $this->assertNull($jsonPath->get('foo.bar.boo')); + } +} diff --git a/server/vendor/php-opencloud/common/tests/unit/Common/JsonSchema/Fixtures/jsonPatchTests.json b/server/vendor/php-opencloud/common/tests/unit/Common/JsonSchema/Fixtures/jsonPatchTests.json new file mode 100644 index 0000000..e7f3579 --- /dev/null +++ b/server/vendor/php-opencloud/common/tests/unit/Common/JsonSchema/Fixtures/jsonPatchTests.json @@ -0,0 +1,231 @@ +[ + { "comment": "empty list, empty docs", + "doc": {}, + "patch": [], + "expected": {} }, + + { "comment": "empty patch list", + "doc": {"foo": 1}, + "patch": [], + "expected": {"foo": 1} }, + + { "comment": "rearrangements OK?", + "doc": {"foo": 1, "bar": 2}, + "patch": [], + "expected": {"bar":2, "foo": 1} }, + + { "comment": "rearrangements OK? How about one level down ... array", + "doc": [{"foo": 1, "bar": 2}], + "patch": [], + "expected": [{"bar":2, "foo": 1}] }, + + { "comment": "rearrangements OK? How about one level down...", + "doc": {"foo":{"foo": 1, "bar": 2}}, + "patch": [], + "expected": {"foo":{"bar":2, "foo": 1}} }, + + { "comment": "toplevel array", + "doc": [], + "patch": [{"op": "add", "path": "/0", "value": "foo"}], + "expected": ["foo"] }, + + { "comment": "toplevel array, no change", + "doc": ["foo"], + "patch": [], + "expected": ["foo"] }, + + { "comment": "toplevel object, numeric string", + "doc": {}, + "patch": [{"op": "add", "path": "/foo", "value": "1"}], + "expected": {"foo":"1"} }, + + { "comment": "toplevel object, integer", + "doc": {}, + "patch": [{"op": "add", "path": "/foo", "value": 1}], + "expected": {"foo":1} }, + + { "comment": "Toplevel scalar values OK?", + "doc": "foo", + "patch": [{"op": "replace", "path": "", "value": "bar"}], + "expected": "bar", + "disabled": true }, + + { "comment": "Add, / target", + "doc": {}, + "patch": [ {"op": "add", "path": "/", "value":1 } ], + "expected": {"":1} }, + + { "comment": "Add composite value at top level", + "doc": {"foo": 1}, + "patch": [{"op": "add", "path": "/bar", "value": [1, 2]}], + "expected": {"foo": 1, "bar": [1, 2]} }, + + { "comment": "Add into composite value", + "doc": {"foo": 1, "baz": [{"qux": "hello"}]}, + "patch": [{"op": "add", "path": "/baz/0/foo", "value": "world"}], + "expected": {"foo": 1, "baz": [{"qux": "hello", "foo": "world"}]} }, + + { "doc": {"bar": [1, 2]}, + "patch": [{"op": "add", "path": "/bar/8", "value": "5"}], + "error": "Out of bounds (upper)" }, + + { "doc": {"bar": [1, 2]}, + "patch": [{"op": "add", "path": "/bar/-1", "value": "5"}], + "error": "Out of bounds (lower)" }, + + { "doc": {"foo": 1}, + "patch": [{"op": "add", "path": "/bar", "value": true}], + "expected": {"foo": 1, "bar": true} }, + + { "doc": {"foo": 1}, + "patch": [{"op": "add", "path": "/bar", "value": false}], + "expected": {"foo": 1, "bar": false} }, + + { "doc": {"foo": 1}, + "patch": [{"op": "add", "path": "/bar", "value": null}], + "expected": {"foo": 1, "bar": null} }, + + { "comment": "0 can be an array index or object element name", + "doc": {"foo": 1}, + "patch": [{"op": "add", "path": "/0", "value": "bar"}], + "expected": {"foo": 1, "0": "bar" } }, + + { "doc": ["foo"], + "patch": [{"op": "add", "path": "/1", "value": "bar"}], + "expected": ["foo", "bar"] }, + + { "doc": ["foo", "sil"], + "patch": [{"op": "add", "path": "/1", "value": "bar"}], + "expected": ["foo", "bar", "sil"] }, + + { "doc": ["foo", "sil"], + "patch": [{"op": "add", "path": "/0", "value": "bar"}], + "expected": ["bar", "foo", "sil"] }, + + { "comment": "push item to array via last index + 1", + "doc": ["foo", "sil"], + "patch": [{"op":"add", "path": "/2", "value": "bar"}], + "expected": ["foo", "sil", "bar"] }, + + { "comment": "add item to array at index > length should fail", + "doc": ["foo", "sil"], + "patch": [{"op":"add", "path": "/3", "value": "bar"}], + "error": "index is greater than number of items in array" }, + + { "doc": ["foo", "sil"], + "patch": [{"op": "add", "path": "/bar", "value": 42}], + "error": "Object operation on array target" }, + + { "doc": ["foo", "sil"], + "patch": [{"op": "add", "path": "/1", "value": ["bar", "baz"]}], + "expected": ["foo", ["bar", "baz"], "sil"], + "comment": "value in array add not flattened" }, + + { "doc": {"foo": 1, "bar": [1, 2, 3, 4]}, + "patch": [{"op": "remove", "path": "/bar"}], + "expected": {"foo": 1} }, + + { "doc": {"foo": 1, "baz": [{"qux": "hello"}]}, + "patch": [{"op": "remove", "path": "/baz/0/qux"}], + "expected": {"foo": 1, "baz": [{}]} }, + + { "doc": {"foo": 1, "baz": [{"qux": "hello"}]}, + "patch": [{"op": "replace", "path": "/foo", "value": [1, 2, 3, 4]}], + "expected": {"foo": [1, 2, 3, 4], "baz": [{"qux": "hello"}]} }, + + { "doc": {"foo": [1, 2, 3, 4], "baz": [{"qux": "hello"}]}, + "patch": [{"op": "replace", "path": "/baz/0/qux", "value": "world"}], + "expected": {"foo": [1, 2, 3, 4], "baz": [{"qux": "world"}]} }, + + { "doc": ["foo"], + "patch": [{"op": "replace", "path": "/0", "value": "bar"}], + "expected": ["bar"] }, + + { "doc": [""], + "patch": [{"op": "replace", "path": "/0", "value": 0}], + "expected": [0] }, + + { "doc": [""], + "patch": [{"op": "replace", "path": "/0", "value": true}], + "expected": [true] }, + + { "doc": [""], + "patch": [{"op": "replace", "path": "/0", "value": false}], + "expected": [false] }, + + { "doc": [""], + "patch": [{"op": "replace", "path": "/0", "value": null}], + "expected": [null] }, + + { "doc": ["foo", "sil"], + "patch": [{"op": "replace", "path": "/1", "value": ["bar", "baz"]}], + "expected": ["foo", ["bar", "baz"]], + "comment": "value in array replace not flattened" }, + + { "comment": "replace whole document", + "disabled": true, + "doc": {"foo": "bar"}, + "patch": [{"op": "replace", "path": "", "value": {"baz": "qux"}}], + "expected": {"baz": "qux"} }, + + { "doc": {"foo": null}, + "patch": [{"op": "replace", "path": "/foo", "value": "truthy"}], + "expected": {"foo": "truthy"}, + "comment": "null value should be valid obj property to be replaced with something truthy" }, + + { "doc": {"foo": null}, + "patch": [{"op": "remove", "path": "/foo"}], + "expected": {}, + "comment": "null value should be valid obj property to be removed" }, + + { "doc": {"foo": "bar"}, + "patch": [{"op": "replace", "path": "/foo", "value": null}], + "expected": {"foo": null}, + "comment": "null value should still be valid obj property replace other value" }, + + { "comment": "test remove with bad number should fail", + "doc": {"foo": 1, "baz": [{"qux": "hello"}]}, + "patch": [{"op": "remove", "path": "/baz/1e0/qux"}], + "error": "remove op shouldn't remove from array with bad number" }, + + { "comment": "test remove on array", + "doc": [1, 2, 3, 4], + "patch": [{"op": "remove", "path": "/0"}], + "expected": [2, 3, 4] }, + + { "comment": "test repeated removes", + "doc": [1, 2, 3, 4], + "patch": [{ "op": "remove", "path": "/1" }, + { "op": "remove", "path": "/3" }], + "expected": [1, 3] }, + + { "comment": "test remove with bad index should fail", + "doc": [1, 2, 3, 4], + "patch": [{"op": "remove", "path": "/1e0"}], + "error": "remove op shouldn't remove from array with bad number" }, + + { "comment": "test replace with bad number should fail", + "doc": [""], + "patch": [{"op": "replace", "path": "/1e0", "value": false}], + "error": "replace op shouldn't replace in array with bad number" }, + + { "comment": "test add with bad number should fail", + "doc": ["foo", "sil"], + "patch": [{"op": "add", "path": "/1e0", "value": "bar"}], + "error": "add op shouldn't add to array with bad number" }, + + { "comment": "missing 'value' parameter to add", + "doc": [ 1 ], + "patch": [ { "op": "add", "path": "/-" } ], + "error": "missing 'value' parameter" }, + + { "comment": "missing 'value' parameter to replace", + "doc": [ 1 ], + "patch": [ { "op": "replace", "path": "/0" } ], + "error": "missing 'value' parameter" }, + + { "comment": "unrecognized op should fail", + "doc": {"foo": 1}, + "patch": [{"op": "spam", "path": "/foo", "value": 1}], + "error": "Unrecognized op 'spam'" } +]
\ No newline at end of file diff --git a/server/vendor/php-opencloud/common/tests/unit/Common/JsonSchema/JsonPatchTest.php b/server/vendor/php-opencloud/common/tests/unit/Common/JsonSchema/JsonPatchTest.php new file mode 100644 index 0000000..ee7db9e --- /dev/null +++ b/server/vendor/php-opencloud/common/tests/unit/Common/JsonSchema/JsonPatchTest.php @@ -0,0 +1,28 @@ +<?php + +namespace OpenCloud\Test\Common\JsonSchema; + +use OpenCloud\Common\JsonSchema\JsonPatch; +use OpenCloud\Test\TestCase; + +class JsonPatchTest extends TestCase +{ + public function testAll() + { + $fixtures = json_decode(file_get_contents(__DIR__ . '/Fixtures/jsonPatchTests.json')); + + foreach ($fixtures as $fixture) { + if (isset($fixture->disabled) || !isset($fixture->expected)) { + continue; + } + + $actual = JsonPatch::diff($fixture->doc, $fixture->expected); + + $this->assertEquals( + json_encode($fixture->patch, JSON_UNESCAPED_SLASHES), + json_encode($actual, JSON_UNESCAPED_SLASHES), + isset($fixture->comment) ? sprintf("Failed asserting test: %s\n", $fixture->comment) : '' + ); + } + } +} diff --git a/server/vendor/php-opencloud/common/tests/unit/Common/JsonSchema/SchemaTest.php b/server/vendor/php-opencloud/common/tests/unit/Common/JsonSchema/SchemaTest.php new file mode 100644 index 0000000..22663ef --- /dev/null +++ b/server/vendor/php-opencloud/common/tests/unit/Common/JsonSchema/SchemaTest.php @@ -0,0 +1,102 @@ +<?php + +namespace OpenCloud\Test\Common\JsonSchema; + +use JsonSchema\Validator; +use OpenCloud\Common\JsonSchema\Schema; +use OpenCloud\Test\TestCase; + +class SchemaTest extends TestCase +{ + /** @var Schema */ + private $schema; + + /** @var Validator */ + private $validator; + private $body; + + public function setUp() + { + $this->body = [ + 'properties' => [ + 'foo' => (object)[], + 'bar' => (object)[], + 'baz' => (object)['readOnly' => true], + ], + ]; + + $this->validator = $this->prophesize(Validator::class); + $this->schema = new Schema($this->body, $this->validator->reveal()); + } + + public function test_it_gets_errors() + { + $this->validator->getErrors() + ->shouldBeCalled() + ->willReturn([]); + + $this->assertEquals([], $this->schema->getErrors()); + } + + public function test_it_gets_error_string() + { + $this->validator->getErrors() + ->shouldBeCalled() + ->willReturn([['property' => 'foo', 'message' => 'bar']]); + + $errorMsg = sprintf("Provided values do not validate. Errors:\n[foo] bar\n"); + + $this->assertEquals($errorMsg, $this->schema->getErrorString()); + } + + public function test_it_gets_property_paths() + { + $this->assertEquals(['/foo', '/bar', '/baz'], $this->schema->getPropertyPaths()); + } + + public function test_it_ignores_readOnly_attrs() + { + $expected = (object)[ + 'foo' => true, + 'bar' => false, + ]; + + $subject = (object)[ + 'foo' => true, + 'bar' => false, + 'baz' => true, + ]; + + $this->assertEquals((object)$expected, $this->schema->normalizeObject((object)$subject, [])); + } + + public function test_it_stocks_aliases() + { + $subject = (object)[ + 'fooAlias' => true, + 'bar' => false, + 'other' => true, + ]; + + $expected = (object)[ + 'foo' => true, + 'bar' => false, + ]; + + $this->assertEquals($expected, $this->schema->normalizeObject($subject, ['foo' => 'fooAlias', 'bar' => 'lol'])); + } + + public function test_it_validates() + { + $this->validator->check([], (object) $this->body)->shouldBeCalled(); + + $this->schema->validate([]); + } + + public function test_it_checks_validity() + { + $this->validator->isValid()->shouldBeCalled(); + + $this->schema->isValid(); + } +} diff --git a/server/vendor/php-opencloud/common/tests/unit/Common/Resource/AbstractResourceTest.php b/server/vendor/php-opencloud/common/tests/unit/Common/Resource/AbstractResourceTest.php new file mode 100644 index 0000000..f334292 --- /dev/null +++ b/server/vendor/php-opencloud/common/tests/unit/Common/Resource/AbstractResourceTest.php @@ -0,0 +1,161 @@ +<?php + +namespace OpenCloud\Test\Common\Resource; + +use function GuzzleHttp\Psr7\stream_for; +use GuzzleHttp\Psr7\Response; +use OpenCloud\Common\Resource\AbstractResource; +use OpenCloud\Common\Resource\Generator; +use OpenCloud\Test\Fixtures\ComputeV2Api; +use OpenCloud\Test\TestCase; +use Prophecy\Argument; + +class AbstractResourceTest extends TestCase +{ + private $resource; + + public function setUp() + { + parent::setUp(); + + $this->rootFixturesDir = __DIR__; + $this->resource = new TestResource($this->client->reveal(), new ComputeV2Api()); + } + + public function test_it_populates_from_response() + { + $response = new Response(200, ['Content-Type' => 'application/json'], stream_for( + json_encode(['foo' => ['bar' => '1']]) + )); + + $this->resource->populateFromResponse($response); + + $this->assertEquals('1', $this->resource->bar); + } + + public function test_it_populates_datetimes_from_arrays() + { + $dt = new \DateTimeImmutable('2015'); + + $this->resource->populateFromArray(['created' => '2015']); + + $this->assertEquals($this->resource->created, $dt); + } + + public function test_it_populates_arrays_from_arrays() + { + $this->resource->populateFromArray(['children' => [$this->resource, $this->resource]]); + + $this->assertInstanceOf(TestResource::class, $this->resource->children[0]); + } + + public function test_it_gets_attrs() + { + $this->resource->bar = 'foo'; + + $this->assertEquals(['bar' => 'foo'], $this->resource->getAttrs(['bar'])); + } + + public function test_it_executes_with_state() + { + $this->resource->id = 'foo'; + $this->resource->bar = 'bar'; + + $expectedJson = ['id' => 'foo', 'bar' => 'bar']; + + $this->setupMock('GET', 'foo', $expectedJson, [], new Response(204)); + + $this->resource->executeWithState((new ComputeV2Api())->test()); + } + + public function test_it_executes_operations_until_a_204_is_received() + { + $this->client + ->request('GET', 'servers', ['headers' => []]) + ->shouldBeCalled() + ->willReturn($this->getFixture('servers-page1')); + + $this->client + ->request('GET', 'servers', ['query' => ['marker' => '5'], 'headers' => []]) + ->shouldBeCalled() + ->willReturn(new Response(204)); + + $count = 0; + + $api = new ComputeV2Api(); + + foreach ($this->resource->enumerate($api->getServers()) as $item) { + $count++; + $this->assertInstanceOf(TestResource::class, $item); + } + + $this->assertEquals(5, $count); + } + + public function test_it_invokes_function_if_provided() + { + $this->client + ->request('GET', 'servers', ['headers' => []]) + ->shouldBeCalled() + ->willReturn($this->getFixture('servers-page1')); + + $this->client + ->request('GET', 'servers', ['query' => ['marker' => '5'], 'headers' => []]) + ->shouldBeCalled() + ->willReturn(new Response(204)); + + $api = new ComputeV2Api(); + + $count = 0; + + $fn = function () use (&$count) { + $count++; + }; + + foreach ($this->resource->enumerate($api->getServers(), [], $fn) as $item) { + } + + $this->assertEquals(5, $count); + } + + public function test_it_halts_when_user_provided_limit_is_reached() + { + $this->client + ->request('GET', 'servers', ['query' => ['limit' => 2], 'headers' => []]) + ->shouldBeCalled() + ->willReturn($this->getFixture('servers-page1')); + + $count = 0; + + $api = new ComputeV2Api(); + + foreach ($this->resource->enumerate($api->getServers(), ['limit' => 2]) as $item) { + $count++; + } + + $this->assertEquals(2, $count); + } +} + +class TestResource extends AbstractResource +{ + protected $resourceKey = 'foo'; + protected $resourcesKey = 'servers'; + protected $markerKey = 'id'; + + /** @var string */ + public $bar; + + public $id; + + /** @var \DateTimeImmutable */ + public $created; + + /** @var []TestResource */ + public $children; + + public function getAttrs(array $keys) + { + return parent::getAttrs($keys); + } +} diff --git a/server/vendor/php-opencloud/common/tests/unit/Common/Resource/Fixtures/servers-empty.resp b/server/vendor/php-opencloud/common/tests/unit/Common/Resource/Fixtures/servers-empty.resp new file mode 100644 index 0000000..655a35b --- /dev/null +++ b/server/vendor/php-opencloud/common/tests/unit/Common/Resource/Fixtures/servers-empty.resp @@ -0,0 +1,6 @@ +HTTP/1.1 200 OK +Content-Type: application/json + +{ + "servers": [] +}
\ No newline at end of file diff --git a/server/vendor/php-opencloud/common/tests/unit/Common/Resource/Fixtures/servers-page1.resp b/server/vendor/php-opencloud/common/tests/unit/Common/Resource/Fixtures/servers-page1.resp new file mode 100644 index 0000000..adebcaf --- /dev/null +++ b/server/vendor/php-opencloud/common/tests/unit/Common/Resource/Fixtures/servers-page1.resp @@ -0,0 +1,77 @@ +HTTP/1.1 200 OK +Content-Type: application/json + +{ + "servers": [ + { + "id": "1", + "links": [ + { + "href": "http://openstack.example.com/v2/openstack/servers/616fb98f-46ca-475e-917e-2563e5a8cd19", + "rel": "self" + }, + { + "href": "http://openstack.example.com/openstack/servers/616fb98f-46ca-475e-917e-2563e5a8cd19", + "rel": "bookmark" + } + ], + "name": "server1" + }, + { + "id": "2", + "links": [ + { + "href": "http://openstack.example.com/v2/openstack/servers/616fb98f-46ca-475e-917e-2563e5a8cd19", + "rel": "self" + }, + { + "href": "http://openstack.example.com/openstack/servers/616fb98f-46ca-475e-917e-2563e5a8cd19", + "rel": "bookmark" + } + ], + "name": "server2" + }, + { + "id": "3", + "links": [ + { + "href": "http://openstack.example.com/v2/openstack/servers/616fb98f-46ca-475e-917e-2563e5a8cd19", + "rel": "self" + }, + { + "href": "http://openstack.example.com/openstack/servers/616fb98f-46ca-475e-917e-2563e5a8cd19", + "rel": "bookmark" + } + ], + "name": "server3" + }, + { + "id": "4", + "links": [ + { + "href": "http://openstack.example.com/v2/openstack/servers/616fb98f-46ca-475e-917e-2563e5a8cd19", + "rel": "self" + }, + { + "href": "http://openstack.example.com/openstack/servers/616fb98f-46ca-475e-917e-2563e5a8cd19", + "rel": "bookmark" + } + ], + "name": "server4" + }, + { + "id": "5", + "links": [ + { + "href": "http://openstack.example.com/v2/openstack/servers/616fb98f-46ca-475e-917e-2563e5a8cd19", + "rel": "self" + }, + { + "href": "http://openstack.example.com/openstack/servers/616fb98f-46ca-475e-917e-2563e5a8cd19", + "rel": "bookmark" + } + ], + "name": "server5" + } + ] +}
\ No newline at end of file diff --git a/server/vendor/php-opencloud/common/tests/unit/Common/Resource/Fixtures/servers-page2.resp b/server/vendor/php-opencloud/common/tests/unit/Common/Resource/Fixtures/servers-page2.resp new file mode 100644 index 0000000..6be6b04 --- /dev/null +++ b/server/vendor/php-opencloud/common/tests/unit/Common/Resource/Fixtures/servers-page2.resp @@ -0,0 +1,77 @@ +HTTP/1.1 200 OK +Content-Type: application/json + +{ + "servers": [ + { + "id": "6", + "links": [ + { + "href": "http://openstack.example.com/v2/openstack/servers/616fb98f-46ca-475e-917e-2563e5a8cd19", + "rel": "self" + }, + { + "href": "http://openstack.example.com/openstack/servers/616fb98f-46ca-475e-917e-2563e5a8cd19", + "rel": "bookmark" + } + ], + "name": "server6" + }, + { + "id": "7", + "links": [ + { + "href": "http://openstack.example.com/v2/openstack/servers/616fb98f-46ca-475e-917e-2563e5a8cd19", + "rel": "self" + }, + { + "href": "http://openstack.example.com/openstack/servers/616fb98f-46ca-475e-917e-2563e5a8cd19", + "rel": "bookmark" + } + ], + "name": "server7" + }, + { + "id": "8", + "links": [ + { + "href": "http://openstack.example.com/v2/openstack/servers/616fb98f-46ca-475e-917e-2563e5a8cd19", + "rel": "self" + }, + { + "href": "http://openstack.example.com/openstack/servers/616fb98f-46ca-475e-917e-2563e5a8cd19", + "rel": "bookmark" + } + ], + "name": "server8" + }, + { + "id": "9", + "links": [ + { + "href": "http://openstack.example.com/v2/openstack/servers/616fb98f-46ca-475e-917e-2563e5a8cd19", + "rel": "self" + }, + { + "href": "http://openstack.example.com/openstack/servers/616fb98f-46ca-475e-917e-2563e5a8cd19", + "rel": "bookmark" + } + ], + "name": "server9" + }, + { + "id": "10", + "links": [ + { + "href": "http://openstack.example.com/v2/openstack/servers/616fb98f-46ca-475e-917e-2563e5a8cd19", + "rel": "self" + }, + { + "href": "http://openstack.example.com/openstack/servers/616fb98f-46ca-475e-917e-2563e5a8cd19", + "rel": "bookmark" + } + ], + "name": "server10" + } + ] +}
\ No newline at end of file diff --git a/server/vendor/php-opencloud/common/tests/unit/Common/Service/BuilderTest.php b/server/vendor/php-opencloud/common/tests/unit/Common/Service/BuilderTest.php new file mode 100644 index 0000000..09e9918 --- /dev/null +++ b/server/vendor/php-opencloud/common/tests/unit/Common/Service/BuilderTest.php @@ -0,0 +1,164 @@ +<?php + +namespace OpenCloud\Test\Common\Service; + +use GuzzleHttp\ClientInterface; +use OpenCloud\Common\Service\Builder; +use OpenCloud\Identity\v2\Models\Token; +use OpenCloud\Identity\v2\Service as IdentityV2; +use OpenCloud\Identity\v3\Service as IdentityV3; +use OpenCloud\Compute\v2\Service as ComputeV2; +use OpenCloud\Test\Common\Auth\FakeToken; +use OpenCloud\Test\TestCase; +use Prophecy\Argument; + +class BuilderTest extends TestCase +{ + private $builder; + private $opts; + + public function setUp() + { + $this->builder = new Builder([]); + + $this->opts = [ + 'username' => '1', + 'password' => '2', + 'tenantId' => '3', + 'authUrl' => '4', + 'region' => '5', + 'catalogName' => '6', + 'catalogType' => '7', + ]; + } + + /** + * @expectedException \Exception + */ + public function test_it_throws_exception_if_username_is_missing() + { + $this->builder->createService('Compute', 2, []); + } + + /** + * @expectedException \Throwable + */ + public function test_it_throws_exception_if_password_is_missing() + { + $this->builder->createService('Compute', 2, ['username' => 1]); + } + + /** + * @expectedException \Throwable + */ + public function test_it_throws_exception_if_both_tenantId_and_tenantName_is_missing() + { + $this->builder->createService('Compute', 2, [ + 'username' => 1, 'password' => 2, 'authUrl' => 4, 'region' => 5, 'catalogName' => 6, 'catalogType' => 7, + ]); + } + + /** + * @expectedException \Throwable + */ + public function test_it_throws_exception_if_authUrl_is_missing() + { + $this->builder->createService('Compute', 2, ['username' => 1, 'password' => 2, 'tenantId' => 3]); + } + + /** + * @expectedException \Throwable + */ + public function test_it_throws_exception_if_region_is_missing() + { + $this->builder->createService('Compute', 2, [ + 'username' => 1, 'password' => 2, 'tenantId' => 3, 'authUrl' => 4, + ]); + } + + /** + * @expectedException \Throwable + */ + public function test_it_throws_exception_if_catalogName_is_missing() + { + $this->builder->createService('Compute', 2, [ + 'username' => 1, 'password' => 2, 'tenantId' => 3, 'authUrl' => 4, + ]); + } + + /** + * @expectedException \Throwable + */ + public function test_it_throws_exception_if_catalogType_is_missing() + { + $this->builder->createService('Compute', 2, [ + 'username' => 1, 'password' => 2, 'tenantId' => 3, 'authUrl' => 4, 'region' => 5, 'catalogName' => 6, + ]); + } + +// public function test_it_builds_services_with_custom_identity_service() +// { +// $this->rootFixturesDir = dirname(dirname(__DIR__)) . '/Identity/v2/'; +// +// $token = $this->prophesize(FakeToken::class)->reveal(); +// $service = $this->prophesize(IdentityService::class); +// $service->authenticate(Argument::type('array'))->shouldBeCalled()->willReturn([$token, '']); +// +// $this->opts += [ +// 'identityService' => $service->reveal(), +// 'catalogName' => 'nova', +// 'catalogType' => 'compute', +// 'region' => 'RegionOne', +// ]; +// +// $service = $this->builder->createService('Compute', 2, $this->opts); +// $this->assertInstanceOf(ComputeV2::class, $service); +// } + + private function setupHttpClient() + { + $this->rootFixturesDir = dirname(dirname(__DIR__)) . '/Identity/v3/'; + + $response = $this->getFixture('token-get'); + + $expectedJson = [ + 'auth' => [ + 'identity' => [ + 'methods' => ['password'], + 'password' => ['user' => ['id' => '0ca8f6', 'password' => 'secretsecret']] + ] + ] + ]; + + $httpClient = $this->prophesize(ClientInterface::class); + $httpClient->request('POST', 'tokens', ['json' => $expectedJson])->shouldBeCalled()->willReturn($response); + + return $httpClient; + } + + public function it_builds_services_with_default_identity() + { + $httpClient = $this->setupHttpClient(); + + $options = [ + 'httpClient' => $httpClient->reveal(), + 'catalogName' => 'nova', + 'catalogType' => 'compute', + 'region' => 'RegionOne', + 'user' => [ + 'id' => '0ca8f6', + 'password' => 'secretsecret', + ] + ]; + + $service = $this->builder->createService('Compute', 2, $options); + $this->assertInstanceOf(ComputeV2::class, $service); + } + +// public function test_it_does_not_authenticate_when_creating_identity_services() +// { +// $this->assertInstanceOf(IdentityV3::class, $this->builder->createService('Identity', 3, [ +// 'authUrl' => 'foo.com', +// ])); +// } +}
\ No newline at end of file diff --git a/server/vendor/php-opencloud/common/tests/unit/Common/Transport/HandlerStackTest.php b/server/vendor/php-opencloud/common/tests/unit/Common/Transport/HandlerStackTest.php new file mode 100644 index 0000000..ec1cf85 --- /dev/null +++ b/server/vendor/php-opencloud/common/tests/unit/Common/Transport/HandlerStackTest.php @@ -0,0 +1,15 @@ +<?php + +namespace OpenCloud\Test\Common\Transport; + +use GuzzleHttp\Handler\MockHandler; +use OpenCloud\Common\Transport\HandlerStack; +use OpenCloud\Test\TestCase; + +class HandlerStackTest extends TestCase +{ + public function test_it_is_created() + { + $this->assertInstanceOf(HandlerStack::class, HandlerStack::create(new MockHandler())); + } +} diff --git a/server/vendor/php-opencloud/common/tests/unit/Common/Transport/JsonSerializerTest.php b/server/vendor/php-opencloud/common/tests/unit/Common/Transport/JsonSerializerTest.php new file mode 100644 index 0000000..9075594 --- /dev/null +++ b/server/vendor/php-opencloud/common/tests/unit/Common/Transport/JsonSerializerTest.php @@ -0,0 +1,85 @@ +<?php + +namespace OpenCloud\Test\Common\Transport; + +use OpenCloud\Common\Api\Parameter; +use OpenCloud\Common\Transport\JsonSerializer; + +class JsonSerializerTest extends \PHPUnit_Framework_TestCase +{ + private $serializer; + + public function setUp() + { + $this->serializer = new JsonSerializer(); + } + + public function test_it_embeds_params_according_to_path() + { + $param = $this->prophesize(Parameter::class); + $param->isArray()->shouldBeCalled()->willReturn(false); + $param->isObject()->shouldBeCalled()->willReturn(false); + $param->getName()->shouldBeCalled()->willReturn('username'); + $param->getPath()->shouldBeCalled()->willReturn('auth.passwordCredentials'); + + $userValue = 'fooBar'; + + $expected = [ + 'auth' => [ + 'passwordCredentials' => [ + 'username' => $userValue, + ], + ], + ]; + + $actual = $this->serializer->stockJson($param->reveal(), $userValue, []); + + $this->assertEquals($expected, $actual); + } + + public function test_it_serializes_arrays() + { + $param = $this->prophesize(Parameter::class); + $param->isArray()->shouldBeCalled()->willReturn(true); + $param->getName()->shouldBeCalled()->willReturn('fooBar'); + $param->getPath()->shouldBeCalled()->willReturn(false); + + $itemSchema = $this->prophesize(Parameter::class); + $itemSchema->isArray()->shouldBeCalled()->willReturn(false); + $itemSchema->isObject()->shouldBeCalled()->willReturn(false); + $itemSchema->getName()->shouldBeCalled()->willReturn(null); + $itemSchema->getPath()->shouldBeCalled()->willReturn(null); + + $param->getItemSchema()->shouldBeCalled()->willReturn($itemSchema); + + $userValues = ['1', '2', '3']; + + $expected = ['fooBar' => $userValues]; + + $actual = $this->serializer->stockJson($param->reveal(), $userValues, []); + + $this->assertEquals($expected, $actual); + } + + public function test_it_serializes_objects() + { + $prop = $this->prophesize(Parameter::class); + $prop->isArray()->shouldBeCalled()->willReturn(false); + $prop->isObject()->shouldBeCalled()->willReturn(false); + $prop->getName()->shouldBeCalled()->willReturn('foo'); + $prop->getPath()->shouldBeCalled()->willReturn(null); + + $param = $this->prophesize(Parameter::class); + $param->isArray()->shouldBeCalled()->willReturn(false); + $param->isObject()->shouldBeCalled()->willReturn(true); + $param->getName()->shouldBeCalled()->willReturn('topLevel'); + $param->getPath()->shouldBeCalled()->willReturn(false); + $param->getProperty('foo')->shouldBeCalled()->willReturn($prop); + + $expected = ['topLevel' => ['foo' => true]]; + + $json = $this->serializer->stockJson($param->reveal(), ['foo' => true], []); + + $this->assertEquals($expected, $json); + } +} diff --git a/server/vendor/php-opencloud/common/tests/unit/Common/Transport/MiddlewareTest.php b/server/vendor/php-opencloud/common/tests/unit/Common/Transport/MiddlewareTest.php new file mode 100644 index 0000000..c445783 --- /dev/null +++ b/server/vendor/php-opencloud/common/tests/unit/Common/Transport/MiddlewareTest.php @@ -0,0 +1,59 @@ +<?php + +namespace unit\Common\Transport; + +use GuzzleHttp\Handler\MockHandler; +use GuzzleHttp\Psr7\Request; +use GuzzleHttp\Psr7\Response; +use OpenCloud\Common\Transport\Middleware; +use OpenCloud\Test\TestCase; +use OpenCloud\Common\Auth\AuthHandler; + +class MiddlewareTest extends TestCase +{ + /** + * @expectedException \OpenCloud\Common\Error\BadResponseError + */ + public function test_exception_is_thrown_for_4xx_statuses() + { + $middleware = Middleware::httpErrors(); + + $handler = new MockHandler([new Response(404)]); + $fn = $middleware($handler); + + $promise = $fn(new Request('GET', 'http://foo.com'), []); + $this->assertEquals('pending', $promise->getState()); + + $promise->wait(); + $this->assertEquals('rejected', $promise->getState()); + } + + public function test_responses_are_left_alone_when_status_under_400() + { + $middleware = Middleware::httpErrors(); + + $response = new Response(204); + $handler = new MockHandler([$response]); + $fn = $middleware($handler); + + $promise = $fn(new Request('GET', 'http://foo.com'), []); + + $promise->then(function ($val) use ($response) { + $this->assertEquals($val, $response); + }); + + $promise->wait(); + } + + public function test_auth_handler_is_returned() + { + $generator = function () {}; + + $middleware = Middleware::authHandler($generator); + + $handler = new MockHandler([new Response(204)]); + $fn = $middleware($handler); + + $this->assertInstanceOf(AuthHandler::class, $fn); + } +} diff --git a/server/vendor/php-opencloud/common/tests/unit/Common/Transport/RequestSerializerTest.php b/server/vendor/php-opencloud/common/tests/unit/Common/Transport/RequestSerializerTest.php new file mode 100644 index 0000000..cf06220 --- /dev/null +++ b/server/vendor/php-opencloud/common/tests/unit/Common/Transport/RequestSerializerTest.php @@ -0,0 +1,112 @@ +<?php + +namespace OpenCloud\Test\Common\Transport; + +use OpenCloud\Common\Api\Operation; +use OpenCloud\Common\Api\Parameter; +use OpenCloud\Common\Transport\JsonSerializer; +use OpenCloud\Common\Transport\RequestSerializer; +use OpenCloud\Test\TestCase; + +class RequestSerializerTest extends TestCase +{ + private $rs; + private $js; + + public function setUp() + { + $this->js = $this->prophesize(JsonSerializer::class); + + $this->rs = new RequestSerializer($this->js->reveal()); + } + + public function test_it_ignores_undefined_params() + { + $op = $this->prophesize(Operation::class); + $op->getParam('foo')->shouldBeCalled()->willReturn(null); + + $this->assertEquals(['headers' => []], $this->rs->serializeOptions($op->reveal(), ['foo' => 'bar'])); + } + + public function test_it_serializes_queries() + { + $sch = $this->prophesize(Parameter::class); + $sch->getName()->shouldBeCalled()->willReturn('fooAlias'); + $sch->getLocation()->shouldBeCalled()->willReturn('query'); + + $op = $this->prophesize(Operation::class); + $op->getParam('foo')->shouldBeCalled()->willReturn($sch); + + $actual = $this->rs->serializeOptions($op->reveal(), ['foo' => 'bar']); + $expected = ['query' => ['fooAlias' => 'bar'], 'headers' => []]; + + $this->assertEquals($expected, $actual); + } + + public function test_it_serializes_headers() + { + $sch = $this->prophesize(Parameter::class); + $sch->getLocation()->shouldBeCalled()->willReturn('header'); + $sch->getName()->shouldBeCalled()->willReturn('fooAlias'); + $sch->getPrefixedName()->shouldBeCalled()->willReturn('prefix-fooAlias'); + + $op = $this->prophesize(Operation::class); + $op->getParam('foo')->shouldBeCalled()->willReturn($sch); + + $actual = $this->rs->serializeOptions($op->reveal(), ['foo' => 'bar']); + $expected = ['headers' => ['prefix-fooAlias' => 'bar']]; + + $this->assertEquals($expected, $actual); + } + + public function test_it_serializes_metadata_headers() + { + $itemSch = $this->prophesize(Parameter::class); + $itemSch->getName()->shouldBeCalled()->willReturn('foo'); + $itemSch->getPrefixedName()->shouldBeCalled()->willReturn('prefix-foo'); + + $sch = $this->prophesize(Parameter::class); + $sch->getItemSchema()->shouldBeCalled()->willReturn($itemSch); + $sch->getLocation()->shouldBeCalled()->willReturn('header'); + $sch->getName()->shouldBeCalled()->willReturn('metadata'); + + $op = $this->prophesize(Operation::class); + $op->getParam('metadata')->shouldBeCalled()->willReturn($sch); + + $actual = $this->rs->serializeOptions($op->reveal(), ['metadata' => ['foo' => 'bar']]); + $expected = ['headers' => ['prefix-foo' => 'bar']]; + + $this->assertEquals($expected, $actual); + } + + public function test_it_serializes_json() + { + $sch = $this->prophesize(Parameter::class); + $sch->getLocation()->shouldBeCalled()->willReturn('json'); + + $op = $this->prophesize(Operation::class); + $op->getParam('foo')->shouldBeCalled()->willReturn($sch); + $op->getJsonKey()->shouldBeCalled()->willReturn('jsonKey'); + + $this->js->stockJson($sch, 'bar', [])->shouldBeCalled()->willReturn(['foo' => 'bar']); + + $actual = $this->rs->serializeOptions($op->reveal(), ['foo' => 'bar']); + $expected = ['json' => ['jsonKey' => ['foo' => 'bar']], 'headers' => []]; + + $this->assertEquals($expected, $actual); + } + + public function test_it_serializes_raw_vals() + { + $sch = $this->prophesize(Parameter::class); + $sch->getLocation()->shouldBeCalled()->willReturn('raw'); + + $op = $this->prophesize(Operation::class); + $op->getParam('foo')->shouldBeCalled()->willReturn($sch); + + $actual = $this->rs->serializeOptions($op->reveal(), ['foo' => 'bar']); + $expected = ['body' => 'bar', 'headers' => []]; + + $this->assertEquals($expected, $actual); + } +} diff --git a/server/vendor/php-opencloud/common/tests/unit/Common/Transport/UtilsTest.php b/server/vendor/php-opencloud/common/tests/unit/Common/Transport/UtilsTest.php new file mode 100644 index 0000000..3103ad4 --- /dev/null +++ b/server/vendor/php-opencloud/common/tests/unit/Common/Transport/UtilsTest.php @@ -0,0 +1,30 @@ +<?php + +namespace OpenCloud\Test\Common\Transport; + +use GuzzleHttp\Psr7\Response; +use function GuzzleHttp\Psr7\uri_for; +use GuzzleHttp\Psr7\Uri; +use OpenCloud\Common\Transport\Utils; +use OpenCloud\Test\TestCase; + +class UtilsTest extends TestCase +{ + /** + * @expectedException \InvalidArgumentException + */ + public function test_decoding_malformed_json_throws_error() + { + $response = new Response(200, [], \GuzzleHttp\Psr7\stream_for('{')); + + Utils::jsonDecode($response); + } + + public function test_it_adds_paths() + { + $uri = Utils::addPaths(uri_for('http://openstack.org/foo'), 'bar', 'baz', '1', '2'); + + $this->assertInstanceOf(Uri::class, $uri); + $this->assertEquals(uri_for('http://openstack.org/foo/bar/baz/1/2'), $uri); + } +} diff --git a/server/vendor/php-opencloud/common/tests/unit/Fixtures/ComputeV2Api.php b/server/vendor/php-opencloud/common/tests/unit/Fixtures/ComputeV2Api.php new file mode 100644 index 0000000..d395d10 --- /dev/null +++ b/server/vendor/php-opencloud/common/tests/unit/Fixtures/ComputeV2Api.php @@ -0,0 +1,107 @@ +<?php + +namespace OpenCloud\Test\Fixtures; + +use OpenCloud\Common\Api\ApiInterface; + +class ComputeV2Api implements ApiInterface +{ + private $idParam = ['type' => 'string', 'required' => true, 'location' => 'url']; + + public function getImage() + { + return [ + 'method' => 'GET', + 'path' => 'images/{id}', + 'params' => [self::$idParam] + ]; + } + + public function postServer() + { + return [ + 'path' => 'servers', + 'method' => 'POST', + 'jsonKey' => 'server', + 'params' => [ + 'removeMetadata' => [ + 'type' => 'object', + 'properties' => ['type' => 'string'], + ], + 'securityGroups' => [ + 'type' => 'array', + 'items' => [ + 'type' => 'object', + 'properties' => [ + 'name' => ['type' => 'string'] + ] + ], + 'sentAs' => 'security_groups', + ], + 'userData' => ['type' => 'string', 'sentAs' => 'user_data'], + 'availabilityZone' => ['type' => 'string', 'sentAs' => 'availability_zone'], + 'imageId' => ['type' => 'string', 'required' => true, 'sentAs' => 'imageRef'], + 'flavorId' => ['type' => 'string', 'required' => true, 'sentAs' => 'flavorRef'], + 'networks' => [ + 'type' => 'array', + 'items' => [ + 'type' => 'object', + 'properties' => [ + 'uuid' => ['type' => 'string'], + 'port' => ['type' => 'string'], + ] + ] + ], + 'name' => ['type' => 'string', 'required' => true], + 'metadata' => ['type' => 'object', 'location' => 'json'], + 'personality' => ['type' => 'string'], + 'blockDeviceMapping' => [ + 'type' => 'array', + 'sentAs' => 'block_device_mapping_v2', + 'items' => [ + 'type' => 'object', + 'properties' => [ + 'configDrive' => ['type' => 'string', 'sentAs' => 'config_drive'], + 'bootIndex' => ['type' => 'string', 'sentAs' => 'boot_index'], + 'deleteOnTermination' => ['type' => 'boolean', 'sentAs' => 'delete_on_termination'], + 'guestFormat' => ['type' => 'string', 'sentAs' => 'guest_format'], + 'destinationType' => ['type' => 'string', 'sentAs' => 'destination_type'], + 'sourceType' => ['type' => 'string', 'sentAs' => 'source_type'], + 'deviceName' => ['type' => 'string', 'sentAs' => 'device_name'], + ] + ], + ], + ] + ]; + } + + public function test() + { + return [ + 'method' => 'GET', + 'path' => 'foo', + 'params' => [ + 'id' => ['type' => 'string', 'location' => 'json'], + 'bar' => ['type' => 'string', 'location' => 'json'], + ] + ]; + } + + public function getServers() + { + return [ + 'method' => 'GET', + 'path' => 'servers', + 'params' => [ + 'changesSince' => ['sentAs' => 'changes-since', 'type' => 'string', 'location' => 'query'], + 'imageId' => ['sentAs' => 'image', 'type' => 'string', 'location' => 'query'], + 'flavorId' => ['sentAs' => 'flavor', 'type' => 'string', 'location' => 'query'], + 'name' => ['type' => 'string', 'location' => 'query'], + 'marker' => ['type' => 'string', 'location' => 'query'], + 'limit' => ['type' => 'integer', 'location' => 'query'], + 'status' => ['type' => 'string', 'location' => 'query'], + 'host' => ['type' => 'string', 'location' => 'query'] + ], + ]; + } +} diff --git a/server/vendor/php-opencloud/common/tests/unit/Fixtures/IdentityV2Api.php b/server/vendor/php-opencloud/common/tests/unit/Fixtures/IdentityV2Api.php new file mode 100644 index 0000000..4cc66b5 --- /dev/null +++ b/server/vendor/php-opencloud/common/tests/unit/Fixtures/IdentityV2Api.php @@ -0,0 +1,36 @@ +<?php + +namespace OpenCloud\Test\Fixtures; + +use OpenCloud\Common\Api\ApiInterface; + +class IdentityV2Api implements ApiInterface +{ + public function postToken() + { + return [ + 'method' => 'POST', + 'path' => 'tokens', + 'params' => [ + 'username' => [ + 'type' => 'string', + 'required' => true, + 'path' => 'auth.passwordCredentials' + ], + 'password' => [ + 'type' => 'string', + 'required' => true, + 'path' => 'auth.passwordCredentials' + ], + 'tenantId' => [ + 'type' => 'string', + 'path' => 'auth', + ], + 'tenantName' => [ + 'type' => 'string', + 'path' => 'auth', + ] + ], + ]; + } +} diff --git a/server/vendor/php-opencloud/common/tests/unit/Fixtures/IdentityV3Api.php b/server/vendor/php-opencloud/common/tests/unit/Fixtures/IdentityV3Api.php new file mode 100644 index 0000000..2fc922f --- /dev/null +++ b/server/vendor/php-opencloud/common/tests/unit/Fixtures/IdentityV3Api.php @@ -0,0 +1,75 @@ +<?php + +namespace OpenCloud\Test\Fixtures; + +class IdentityV3Api +{ + private function domainParam() + { + return [ + 'type' => 'object', + 'params' => [ + 'id' => ['type' => 'string'], + 'name' => ['type' => 'string'] + ] + ]; + } + + private function projectParam() + { + return [ + 'type' => 'object', + 'params' => [ + 'id' => ['type' => 'string'], + 'name' => ['type' => 'string'], + 'domain' => $this->domainParam(), + ] + ]; + } + + public function postTokens() + { + return [ + 'method' => 'POST', + 'path' => 'tokens', + 'params' => [ + 'methods' => [ + 'type' => 'array', + 'path' => 'auth.identity', + 'items' => [ + 'type' => 'string' + ] + ], + 'user' => [ + 'path' => 'auth.identity.password', + 'type' => 'object', + 'properties' => [ + 'id' => [ + 'type' => 'string', + ], + 'name' => [ + 'type' => 'string', + ], + 'password' => [ + 'type' => 'string', + ], + 'domain' => $this->domainParam() + ] + ], + 'tokenId' => [ + 'type' => 'string', + 'path' => 'auth.identity.token', + 'sentAs' => 'id', + ], + 'scope' => [ + 'type' => 'object', + 'path' => 'auth', + 'properties' => [ + 'project' => $this->projectParam(), + 'domain' => $this->domainParam() + ] + ] + ] + ]; + } +} diff --git a/server/vendor/php-opencloud/common/tests/unit/TestCase.php b/server/vendor/php-opencloud/common/tests/unit/TestCase.php new file mode 100644 index 0000000..610d88a --- /dev/null +++ b/server/vendor/php-opencloud/common/tests/unit/TestCase.php @@ -0,0 +1,99 @@ +<?php + +namespace OpenCloud\Test; + +use function GuzzleHttp\Psr7\stream_for; +use function GuzzleHttp\Psr7\parse_response; +use GuzzleHttp\ClientInterface; +use GuzzleHttp\Psr7\Response; +use Prophecy\Argument; + +abstract class TestCase extends \PHPUnit_Framework_TestCase +{ + /** @var \Prophecy\Prophecy\ObjectProphecy */ + protected $client; + + /** @var string */ + protected $rootFixturesDir; + + protected $api; + + protected function setUp() + { + $this->client = $this->prophesize(ClientInterface::class); + } + + protected function createResponse($status, array $headers, array $json) + { + return new Response($status, $headers, stream_for(json_encode($json))); + } + + protected function getFixture($file) + { + if (!$this->rootFixturesDir) { + throw new \RuntimeException('Root fixtures dir not set'); + } + + $path = $this->rootFixturesDir . '/Fixtures/' . $file . '.resp'; + + if (!file_exists($path)) { + throw new \RuntimeException(sprintf("%s does not exist", $path)); + } + + return parse_response(file_get_contents($path)); + } + + protected function setupMock($method, $path, $body = null, array $headers = [], $response) + { + $options = ['headers' => $headers]; + + if (!empty($body)) { + $options[is_array($body) ? 'json' : 'body'] = $body; + } + + if (is_string($response)) { + $response = $this->getFixture($response); + } + + $this->client + ->request($method, $path, $options) + ->shouldBeCalled() + ->willReturn($response); + } + + protected function createFn($receiver, $method, $args) + { + return function () use ($receiver, $method, $args) { + return $receiver->$method($args); + }; + } + + protected function listTest(callable $call, $urlPath, $modelName = null, $responseFile = null) + { + $modelName = $modelName ?: $urlPath; + $responseFile = $responseFile ?: $urlPath; + + $this->setupMock('GET', $urlPath, null, [], $responseFile); + + $resources = call_user_func($call); + + $this->assertInstanceOf('\Generator', $resources); + + $count = 0; + + foreach ($resources as $resource) { + $this->assertInstanceOf('OpenStack\Identity\v3\Models\\' . ucfirst($modelName), $resource); + ++$count; + } + + $this->assertEquals(2, $count); + } + + protected function getTest(callable $call, $modelName) + { + $resource = call_user_func($call); + + $this->assertInstanceOf('OpenStack\Identity\v3\Models\\' . ucfirst($modelName), $resource); + $this->assertEquals('id', $resource->id); + } +} |