def decorator(func):
auth_data = ObjectStorageAuthComposite()
objectstorage_api_config = ObjectStorageAPIConfig()
client = ObjectStorageAPIClient(auth_data.storage_url,
auth_data.auth_token)
behaviors = ObjectStorageAPI_Behaviors(
client=client, config=objectstorage_api_config)
features = behaviors.get_configured_features()
if features == objectstorage_api_config.ALL_FEATURES:
return func
if features == objectstorage_api_config.NO_FEATURES:
setattr(func, '__unittest_skip__', True)
setattr(func, '__unittest_skip_why__', 'Skipping All Features')
features = features.split()
missing_reqs = False
for req in required_features:
if req not in features:
missing_reqs = True
break
if missing_reqs:
setattr(func, '__unittest_skip__', True)
setattr(
func, '__unittest_skip_why__',
'requires features: {0}'.format(
', '.join(required_features)))
return func
def setUpClass(cls):
super(ObjectStorageIntegrationFixture, cls).setUpClass()
cls.object_storage_config = ObjectStorageConfig()
cls.object_storage_api_config = ObjectStorageAPIConfig()
objectstorage_service = cls.access_data.get_service(
cls.object_storage_config.identity_service_name)
objectstorage_url_check = objectstorage_service.get_endpoint(
cls.object_storage_config.region)
# If endpoint validation fails, fail immediately
if objectstorage_url_check is None:
cls.assertClassSetupFailure('Endpoint validation failed')
alt_objectstorage_service = cls.alt_access_data.get_service(
cls.object_storage_config.identity_service_name)
alt_objectstorage_url_check = alt_objectstorage_service.get_endpoint(
cls.object_storage_config.region)
# If endpoint validation fails, fail immediately
if alt_objectstorage_url_check is None:
cls.assertClassSetupFailure('Endpoint validation failed')
cls.storage_url = objectstorage_service.get_endpoint(
cls.object_storage_config.region).public_url
cls.alt_storage_url = alt_objectstorage_service.get_endpoint(
cls.object_storage_config.region).public_url
cls.object_storage_client = ObjectStorageAPIClient(
cls.storage_url, cls.access_data.token.id_)
cls.alt_object_storage_client = ObjectStorageAPIClient(
cls.alt_storage_url, cls.alt_access_data.token.id_)
cls.object_storage_behaviors = ObjectStorageAPI_Behaviors(
cls.object_storage_client, cls.object_storage_api_config)
cls.alt_object_storage_behaviors = ObjectStorageAPI_Behaviors(
cls.alt_object_storage_client, cls.object_storage_api_config)
def decorator(func):
auth_data = ObjectStorageAuthComposite()
objectstorage_api_config = ObjectStorageAPIConfig()
client = ObjectStorageAPIClient(auth_data.storage_url,
auth_data.auth_token)
behaviors = ObjectStorageAPI_Behaviors(
client=client, config=objectstorage_api_config)
features = behaviors.get_configured_features()
if features == objectstorage_api_config.ALL_FEATURES:
return func
if features == objectstorage_api_config.NO_FEATURES:
setattr(func, '__unittest_skip__', True)
setattr(func, '__unittest_skip_why__', 'Skipping All Features')
features = features.split()
missing_reqs = False
for req in required_features:
if req not in features:
missing_reqs = True
break
if missing_reqs:
setattr(func, '__unittest_skip__', True)
setattr(
func, '__unittest_skip_why__',
'requires features: {0}'.format(
', '.join(required_features)))
return func
def __init__(self, exclude=None):
api_config = ObjectStorageAPIConfig()
auth_data = ObjectStorageAuthComposite()
client = ObjectStorageAPIClient(
auth_data.storage_url, auth_data.auth_token)
behaviors = ObjectStorageAPI_Behaviors(client, api_config)
features = behaviors.get_configured_features()
if features == api_config.ALL_FEATURES:
features = ['dlo', 'slo']
generator = ObjectStorageGenerator(client)
if exclude is None:
exclude = []
if 'standard' not in exclude:
self.append_new_dataset(
'standard',
{'object_type': 'standard',
'generate_object': generator.generate_object})
if 'dlo' in features and 'dlo' not in exclude:
self.append_new_dataset(
'dlo',
{'object_type': 'dlo',
'generate_object': generator.generate_dynamic_large_object})
if 'slo' in features and 'slo' not in exclude:
self.append_new_dataset(
'slo',
{'object_type': 'slo',
'generate_object': generator.generate_static_large_object})
def test_throws_exception_if_create_container_fails(self):
response = Mock(spec=Response)
response.ok = False
client = Mock(spec=ObjectStorageAPIClient)
client.create_container = MagicMock(return_value=response)
config = Mock(spec=ObjectStorageAPIConfig)
behavior = ObjectStorageAPI_Behaviors(client, config)
with self.assertRaises(Exception):
behavior.create_container(client_test.VALID_CONTAINER_NAME)
def test_create_container(self):
response = Mock(spec=Response)
response.ok = True
client = Mock(spec=ObjectStorageAPIClient)
client.create_container = MagicMock(return_value=response)
config = Mock(spec=ObjectStorageAPIConfig)
behavior = ObjectStorageAPI_Behaviors(client, config)
behavior.create_container(client_test.VALID_CONTAINER_NAME)
client.create_container.assert_called_with(
client_test.VALID_CONTAINER_NAME)
def setUpClass(cls):
super(ObjectStorageFixture, cls).setUpClass()
endpoint_config = UserAuthConfig()
user_config = UserConfig()
objectstorage_config = ObjectStorageConfig()
objectstorage_api_config = ObjectStorageAPIConfig()
auth_provider = AuthProvider()
access_data = auth_provider.get_access_data(endpoint_config,
user_config)
service = access_data.get_service(
objectstorage_config.identity_service_name)
endpoint = service.get_endpoint(objectstorage_config.region)
storage_url = endpoint.public_url
auth_token = access_data.token.id_
cls.base_container_name = objectstorage_api_config.base_container_name
cls.base_object_name = objectstorage_api_config.base_object_name
cls.client = ObjectStorageAPIClient(storage_url, auth_token)
cls.behaviors = ObjectStorageAPI_Behaviors(client=cls.client)
def decorator(func):
# TODO: This is not ideal, should change this to support
# multiple versions
required_version = required_versions[0]
auth_data = ObjectStorageAuthComposite()
objectstorage_api_config = ObjectStorageAPIConfig()
client = ObjectStorageAPIClient(auth_data.storage_url,
auth_data.auth_token)
behaviors = ObjectStorageAPI_Behaviors(
client=client, config=objectstorage_api_config)
swift_version = objectstorage_api_config.version
if not swift_version and objectstorage_api_config.use_swift_info:
info = behaviors.get_swift_info()
swift_version = info.get('swift', {
'version': None
}).get('version', None)
if not swift_version:
return func
if required_version.startswith('<'):
required_version = required_version.lstrip('<')
compare_func = lambda sv, tv: sv < tv
extra_message = ' less than'
elif required_version.startswith('>'):
required_version = required_version.lstrip('>')
compare_func = lambda sv, tv: sv > tv
extra_message = ' greater than'
else:
required_version = required_version.lstrip('=')
compare_func = lambda sv, tv: sv.startswith(tv)
extra_message = ''
if compare_func(swift_version, required_version):
func
setattr(func, '__unittest_skip__', True)
setattr(
func, '__unittest_skip_why__',
'swift running version {0}, requires version{1}: {2}'.format(
swift_version, extra_message, required_version))
return func
def required_features(cls, *required_features):
"""
Test decorator to skip tests if features are not configured in swift.
Configuration of what features are enabled can be done from the
objectstorage config file.
Note: "lambda func: func" is from the Python unit tests example
"25.3.6. Skipping tests and expected failures":
def skipUnlessHasattr(obj, attr):
if hasattr(obj, attr):
return lambda func: func
return unittest.skip("{!r} doesn't have {!r}".format(obj, attr))
http://docs.python.org/2/library/unittest.html
"""
auth_data = ObjectStorageAuthComposite()
objectstorage_api_config = ObjectStorageAPIConfig()
client = ObjectStorageAPIClient(auth_data.storage_url,
auth_data.auth_token)
behaviors = ObjectStorageAPI_Behaviors(
client=client, config=objectstorage_api_config)
features = behaviors.get_configured_features()
if features == objectstorage_api_config.ALL_FEATURES:
return lambda func: func
if features == objectstorage_api_config.NO_FEATURES:
return unittest.skip('skipping all features')
features = features.split()
missing_reqs = False
for req in required_features:
if req not in features:
missing_reqs = True
break
if missing_reqs:
return unittest.skip(
'requires features: {0}'.format(', '.join(required_features)))
return lambda func: func
def decorator(func):
# TODO: This is not ideal, should change this to support
# multiple versions
required_version = required_versions[0]
auth_data = ObjectStorageAuthComposite()
objectstorage_api_config = ObjectStorageAPIConfig()
client = ObjectStorageAPIClient(auth_data.storage_url,
auth_data.auth_token)
behaviors = ObjectStorageAPI_Behaviors(
client=client, config=objectstorage_api_config)
swift_version = objectstorage_api_config.version
if not swift_version and objectstorage_api_config.use_swift_info:
info = behaviors.get_swift_info()
swift_version = info.get(
'swift', {'version': None}).get('version', None)
if not swift_version:
return func
if required_version.startswith('<'):
required_version = required_version.lstrip('<')
compare_func = lambda sv, tv: sv < tv
extra_message = ' less than'
elif required_version.startswith('>'):
required_version = required_version.lstrip('>')
compare_func = lambda sv, tv: sv > tv
extra_message = ' greater than'
else:
required_version = required_version.lstrip('=')
compare_func = lambda sv, tv: sv.startswith(tv)
extra_message = ''
if compare_func(swift_version, required_version):
func
setattr(func, '__unittest_skip__', True)
setattr(
func, '__unittest_skip_why__',
'swift running version {0}, requires version{1}: {2}'.format(
swift_version, extra_message, required_version))
return func
def setUpClass(cls):
super(ObjectStorageFixture, cls).setUpClass()
cls.auth_data = ObjectStorageAuthComposite()
cls.objectstorage_api_config = ObjectStorageAPIConfig()
cls.storage_url = cls.auth_data.storage_url
cls.auth_token = cls.auth_data.auth_token
cls.base_container_name = (
cls.objectstorage_api_config.base_container_name)
cls.client = ObjectStorageAPIClient(cls.storage_url, cls.auth_token)
cls.behaviors = ObjectStorageAPI_Behaviors(
client=cls.client, config=cls.objectstorage_api_config)
def setUpClass(cls):
super(ObjectStorageFixture, cls).setUpClass()
auth_data = cls.get_auth_data()
storage_url = auth_data['storage_url']
auth_token = auth_data['auth_token']
objectstorage_api_config = ObjectStorageAPIConfig()
cls.base_container_name = objectstorage_api_config.base_container_name
cls.base_object_name = objectstorage_api_config.base_object_name
cls.client = ObjectStorageAPIClient(storage_url, auth_token)
cls.behaviors = ObjectStorageAPI_Behaviors(client=cls.client)
def __init__(self):
self.config = ObjectStorageAPIConfig()
self.auth_info = self._auth_composite()
self.storage_url = self.auth_info.public_url
self.auth_token = self.auth_info.token_id
if self.auth_info.auth_strategy == 'saio_tempauth':
self.storage_url = self.auth_info.access_data.storage_url
self.auth_token = self.auth_info.access_data.auth_token
self.client = ObjectStorageAPIClient(self.storage_url, self.auth_token)
self.behaviors = ObjectStorageAPI_Behaviors(client=self.client,
config=self.config)
def __init__(self, exclude=None):
api_config = ObjectStorageAPIConfig()
auth_data = ObjectStorageAuthComposite()
client = ObjectStorageAPIClient(auth_data.storage_url,
auth_data.auth_token)
behaviors = ObjectStorageAPI_Behaviors(client, api_config)
features = behaviors.get_configured_features()
if features == api_config.ALL_FEATURES:
features = ['dlo', 'slo']
generator = ObjectStorageGenerator(client)
if exclude is None:
exclude = []
if 'standard' not in exclude:
self.append_new_dataset(
'standard', {
'object_type': 'standard',
'generate_object': generator.generate_object
})
if 'dlo' in features and 'dlo' not in exclude:
self.append_new_dataset(
'dlo', {
'object_type': 'dlo',
'generate_object': generator.generate_dynamic_large_object
})
if 'slo' in features and 'slo' not in exclude:
self.append_new_dataset(
'slo', {
'object_type': 'slo',
'generate_object': generator.generate_static_large_object
})
def setUpClass(cls):
super(ImagesIntegrationFixture, cls).setUpClass()
cls.object_storage_client = cls.client
cls.object_storage_behaviors = cls.behaviors
# Work around to create compute/obj storage additional user composites
auth_endpoint_config = UserAuthConfig()
compute_endpoint = ComputeEndpointConfig()
images_config = ImagesConfig()
flavors_config = FlavorsConfig()
marshalling_config = MarshallingConfig()
object_storage_config = ObjectStorageConfig()
object_storage_api_config = ObjectStorageAPIConfig()
servers_config = ServersConfig()
user_config_alt_one = AltOneUserConfig()
access_data_alt_one = AuthProvider.get_access_data(
auth_endpoint_config, user_config_alt_one)
# Create compute clients and behaviors for alt_one user
compute_service_alt_one = access_data_alt_one.get_service(
compute_endpoint.compute_endpoint_name)
compute_url_check_alt_one = compute_service_alt_one.get_endpoint(
compute_endpoint.region)
# If compute endpoint validation fails, fail immediately
if compute_url_check_alt_one is None:
cls.assertClassSetupFailure('Compute endpoint validation failed')
compute_url_alt_one = compute_service_alt_one.get_endpoint(
compute_endpoint.region).public_url
cls.compute_alt_one_images_client = ComputeImagesClient(
compute_url_alt_one, access_data_alt_one.token.id_,
marshalling_config.serializer, marshalling_config.deserializer)
cls.compute_alt_one_servers_client = ServersClient(
compute_url_alt_one, access_data_alt_one.token.id_,
marshalling_config.serializer, marshalling_config.deserializer)
cls.compute_alt_one_images_behaviors = ComputeImageBehaviors(
images_client=cls.compute_alt_one_images_client,
servers_client=cls.compute_alt_one_servers_client,
config=images_config)
cls.compute_alt_one_servers_behaviors = ServerBehaviors(
servers_client=cls.compute_alt_one_servers_client,
images_client=cls.compute_alt_one_images_client,
servers_config=servers_config, images_config=images_config,
flavors_config=flavors_config)
# Create object storage client and behaviors for alt_one user
object_storage_service_alt_one = access_data_alt_one.get_service(
object_storage_config.identity_service_name)
object_storage_url_check_alt_one = (
object_storage_service_alt_one.get_endpoint(
object_storage_config.region))
# If endpoint validation fails, fail immediately
if object_storage_url_check_alt_one is None:
cls.assertClassSetupFailure('Endpoint validation failed')
storage_url_alt_one = object_storage_service_alt_one.get_endpoint(
object_storage_config.region).public_url
cls.object_storage_alt_one_client = ObjectStorageAPIClient(
storage_url_alt_one, access_data_alt_one.token.id_)
cls.object_storage_alt_one_behaviors = ObjectStorageAPI_Behaviors(
cls.object_storage_alt_one_client, object_storage_api_config)
# Needed in order to allow assertions on exceptions
cls.compute.flavors.client.delete_exception_handler(
cls.compute_exception_handler)
def required_version(cls, required_version):
"""
Test decorator to skip tests if the version of swift does not
match the required version provided. If unable to retrieve the
version, the default behavior will be to run the test.
Configuration of what version swift is running can be done from the
objectstorage config file.
Note: "lambda func: func" is from the Python unit tests example
"25.3.6. Skipping tests and expected failures":
def skipUnlessHasattr(obj, attr):
if hasattr(obj, attr):
return lambda func: func
return unittest.skip("{!r} doesn't have {!r}".format(obj, attr))
http://docs.python.org/2/library/unittest.html
@param required_version: condition and version required to run the
test. examples:
'=1.11.0.54' - run if swift version is ==
'1.11.0.54' - same as above
'<1.11.0.54' - run if swift version is <
'>1.11.0.54' - run if swift version is >
@type required_version: string
@return: a function indicating either to run or skip the test
based on the results of the version comparison.
@rtype: function
"""
auth_data = ObjectStorageAuthComposite()
objectstorage_api_config = ObjectStorageAPIConfig()
client = ObjectStorageAPIClient(auth_data.storage_url,
auth_data.auth_token)
behaviors = ObjectStorageAPI_Behaviors(
client=client, config=objectstorage_api_config)
swift_version = objectstorage_api_config.version
if not swift_version and objectstorage_api_config.use_swift_info:
info = behaviors.get_swift_info()
swift_version = info.get(
'swift', {'version': None}).get('version', None)
if not swift_version:
return lambda func: func
if required_version.startswith('<'):
required_version = required_version.lstrip('<')
compare_func = lambda sv, tv: sv < tv
extra_message = ' less than'
elif required_version.startswith('>'):
required_version = required_version.lstrip('>')
compare_func = lambda sv, tv: sv > tv
extra_message = ' greater than'
else:
required_version = required_version.lstrip('=')
compare_func = lambda sv, tv: sv.startswith(tv)
extra_message = ''
if compare_func(swift_version, required_version):
return lambda func: func
return unittest.skip(
'swift running version {0}, requires version{1}: {2}'.format(
swift_version, extra_message, required_version))
