def test_arbitrary_string(self):
actual = data_utils.arbitrary_string()
self.assertEqual(actual, "test")
actual = data_utils.arbitrary_string(size=30, base_text="abc")
self.assertEqual(actual, "abc" * int(30 / len("abc")))
actual = data_utils.arbitrary_string(size=5, base_text="deadbeaf")
self.assertEqual(actual, "deadb")
def test_identity_update_user(self):
user_create = self.user()
# create user in other domain
user_create['domain_id'] = self.other_domain['id']
user = self.admin_users_client.create_user(**user_create)['user']
self.addCleanup(self.admin_users_client.delete_user, user['id'])
user_update = {
'user_id': user['id'],
'description': data_utils.arbitrary_string()
}
self.do_request('update_user',
expected_status=exceptions.Forbidden,
**user_update)
# create user in own domain
user_create['domain_id'] = self.persona.credentials.domain_id
user = self.admin_users_client.create_user(**user_create)['user']
self.addCleanup(self.admin_users_client.delete_user, user['id'])
user_update = {
'user_id': user['id'],
'description': data_utils.arbitrary_string()
}
self.do_request('update_user',
expected_status=exceptions.Forbidden,
**user_update)
# user gets a 403 for nonexistent user
user_update = {
'user_id': 'fakeuser',
'description': data_utils.arbitrary_string()
}
self.do_request('update_user',
expected_status=exceptions.Forbidden,
**user_update)
def test_arbitrary_string(self):
actual = data_utils.arbitrary_string()
self.assertEqual(actual, "test")
actual = data_utils.arbitrary_string(size=30, base_text="abc")
self.assertEqual(actual, "abc" * int(30 / len("abc")))
actual = data_utils.arbitrary_string(size=5, base_text="deadbeaf")
self.assertEqual(actual, "deadb")
def test_create_subscriptions_with_invalid_body(self):
# Missing subscriber parameter in body
message_ttl = data_utils.\
rand_int_id(start=60, end=CONF.messaging.max_message_ttl)
key = data_utils.arbitrary_string(size=20, base_text='MessagingKey')
value = data_utils.arbitrary_string(size=20,
base_text='MessagingValue')
option_body = {key: value}
rbody = {'options': option_body, 'ttl': message_ttl}
self.assertRaises(lib_exc.BadRequest,
self.create_subscription, self.queue_name, rbody)
def test_create_subscriptions_with_invalid_body(self):
# Missing subscriber parameter in body
message_ttl = data_utils.\
rand_int_id(start=60, end=CONF.messaging.max_message_ttl)
key = data_utils.arbitrary_string(size=20, base_text='MessagingKey')
value = data_utils.arbitrary_string(size=20,
base_text='MessagingValue')
option_body = {key: value}
rbody = {'options': option_body, 'ttl': message_ttl}
self.assertRaises(lib_exc.BadRequest, self.create_subscription,
self.queue_name, rbody)
def generate_message_body(cls, repeat=1):
"""Wrapper utility that sets the metadata of a queue."""
message_ttl = data_utils.\
rand_int_id(start=60, end=CONF.messaging.max_message_ttl)
key = data_utils.arbitrary_string(size=20, base_text='MessagingKey')
value = data_utils.arbitrary_string(size=20,
base_text='MessagingValue')
message_body = {key: value}
rbody = ([{'body': message_body, 'ttl': message_ttl}] * repeat)
return rbody
def test_identity_update_project(self):
project_id = self.admin_projects_client.create_project(
name=data_utils.rand_name())['project']['id']
self.addCleanup(self.admin_projects_client.delete_project, project_id)
self.do_request('update_project',
project_id=project_id,
description=data_utils.arbitrary_string())
# user gets a 404 for nonexistent domain
self.do_request('update_project',
expected_status=exceptions.NotFound,
project_id=data_utils.rand_uuid_hex(),
description=data_utils.arbitrary_string())
def generate_message_body(cls, repeat=1):
"""Wrapper utility that sets the metadata of a queue."""
message_ttl = data_utils.\
rand_int_id(start=60, end=CONF.messaging.max_message_ttl)
key = data_utils.arbitrary_string(size=20, base_text='MessagingKey')
value = data_utils.arbitrary_string(size=20,
base_text='MessagingValue')
message_body = {key: value}
rbody = ([{'body': message_body, 'ttl': message_ttl}] * repeat)
return rbody
def test_create_namespace(self):
# Check non-admin role of 'project' not allowed to create namespace
self.do_request('create_namespace',
expected_status=exceptions.Forbidden,
client=self.namespace_client,
namespace=data_utils.arbitrary_string())
# Check non-admin role of 'alt_project' not allowed to create namespace
self.do_request('create_namespace',
expected_status=exceptions.Forbidden,
client=self.alt_namespace_client,
namespace=data_utils.arbitrary_string())
def test_identity_update_role(self):
# user can update role
role = self.admin_roles_client.create_role(**self.role())['role']
self.addCleanup(self.admin_roles_client.delete_role, role['id'])
self.do_request('update_role',
role_id=role['id'],
description=data_utils.arbitrary_string())
# user gets a 404 for nonexistent role
self.do_request('update_role',
expected_status=exceptions.NotFound,
role_id=data_utils.rand_uuid_hex(),
description=data_utils.arbitrary_string())
def generate_subscription_body(cls):
message_ttl = data_utils.\
rand_int_id(start=60, end=CONF.messaging.max_message_ttl)
key = data_utils.arbitrary_string(size=20, base_text='MessagingKey')
value = data_utils.arbitrary_string(size=20,
base_text='MessagingValue')
option_body = {key: value}
subscribers = ['http://*****:*****@123.com']
rbody = [{'options': option_body, 'ttl': message_ttl,
'subscriber': subscriber} for subscriber in subscribers]
return rbody
def test_create_subscriptions_with_non_integer_value_for_ttl(self):
# The subscriber type of subscription must be supported in the list
# ['http', 'https', 'mailto']
message_ttl = "123"
key = data_utils.arbitrary_string(size=20, base_text='MessagingKey')
value = data_utils.arbitrary_string(size=20,
base_text='MessagingValue')
option_body = {key: value}
subscriber = 'http://fake:8080'
rbody = {'options': option_body, 'ttl': message_ttl,
'subscriber': subscriber}
self.assertRaises(lib_exc.BadRequest,
self.create_subscription, self.queue_name, rbody)
def test_create_subscriptions_with_non_integer_value_for_ttl(self):
# The subscriber type of subscription must be supported in the list
# ['http', 'https', 'mailto']
message_ttl = "123"
key = data_utils.arbitrary_string(size=20, base_text='MessagingKey')
value = data_utils.arbitrary_string(size=20,
base_text='MessagingValue')
option_body = {key: value}
subscriber = 'http://fake:8080'
rbody = {'options': option_body, 'ttl': message_ttl,
'subscriber': subscriber}
self.assertRaises(lib_exc.BadRequest,
self.create_subscription, self.queue_name, rbody)
def test_identity_update_service_provider(self):
sp_id = self.admin_sp_client.create_service_provider(
sp_id=data_utils.rand_name(),
auth_url=data_utils.rand_url(),
sp_url=data_utils.rand_url())['service_provider']['id']
self.addCleanup(self.admin_sp_client.delete_service_provider, sp_id)
self.do_request('update_service_provider',
sp_id=sp_id,
description=data_utils.arbitrary_string())
# user gets a 404 for nonexistent sp
self.do_request('update_service_provider',
expected_status=exceptions.NotFound,
sp_id=data_utils.rand_uuid_hex(),
description=data_utils.arbitrary_string())
def test_post_messages_without_TTL(self):
# TTL for a message may not exceed 1209600 seconds, and
# must be at least 60 seconds long.
queue_name = self.queues[data_utils.rand_int_id(0,
len(self.queues) - 1)]
key = data_utils.arbitrary_string(size=20, base_text='MessagingKey')
value = data_utils.arbitrary_string(size=20,
base_text='MessagingValue')
message_body = {key: value}
rbody = ([{'body': message_body}] * 1)
self.assertRaises(lib_exc.BadRequest,
self.client.post_messages, queue_name, rbody)
def test_create_subscriptions_with_invalid_subscriber(self):
# The subscriber type of subscription must be supported in the list
# ['http', 'https', 'mailto']
message_ttl = data_utils.\
rand_int_id(start=60, end=CONF.messaging.max_message_ttl)
key = data_utils.arbitrary_string(size=20, base_text='MessagingKey')
value = data_utils.arbitrary_string(size=20,
base_text='MessagingValue')
option_body = {key: value}
subscriber = 'fake'
rbody = {'options': option_body, 'ttl': message_ttl,
'subscriber': subscriber}
self.assertRaises(lib_exc.BadRequest,
self.create_subscription, self.queue_name, rbody)
def test_post_messages_without_TTL(self):
# TTL for a message may not exceed 1209600 seconds, and
# must be at least 60 seconds long.
queue_name = self.queues[data_utils.rand_int_id(0,
len(self.queues) - 1)]
key = data_utils.arbitrary_string(size=20, base_text='MessagingKey')
value = data_utils.arbitrary_string(size=20,
base_text='MessagingValue')
message_body = {key: value}
rbody = ([{'body': message_body}] * 1)
self.assertRaises(lib_exc.BadRequest,
self.client.post_messages, queue_name, rbody)
def test_create_subscriptions_with_unsupported_subscriber(self):
# The subscriber type of subscription must be supported in the list
# ['http', 'https', 'mailto']
message_ttl = data_utils.\
rand_int_id(start=60, end=CONF.messaging.max_message_ttl)
key = data_utils.arbitrary_string(size=20, base_text='MessagingKey')
value = data_utils.arbitrary_string(size=20,
base_text='MessagingValue')
option_body = {key: value}
subscriber = 'email://fake'
rbody = {'options': option_body, 'ttl': message_ttl,
'subscriber': subscriber}
self.assertRaises(lib_exc.BadRequest,
self.create_subscription, self.queue_name, rbody)
def test_post_messages_with_invalid_body_size(self):
# Maximum number of queue message per page
# while posting messages is 20
queue_name = self.queues[data_utils.rand_int_id(0,
len(self.queues) - 1)]
key = data_utils.arbitrary_string(size=20, base_text='MessagingKey')
value = data_utils.arbitrary_string(size=20,
base_text='MessagingValue')
message_ttl = data_utils.\
rand_int_id(start=60, end=CONF.messaging.max_message_ttl)
message_body = {key: value}
rbody = ([{'body': message_body, 'ttl': message_ttl}] * 21)
self.assertRaises(lib_exc.BadRequest,
self.client.post_messages, queue_name, rbody)
def test_post_messages_with_invalid_body_size(self):
# Maximum number of queue message per page
# while posting messages is 20
queue_name = self.queues[data_utils.rand_int_id(0,
len(self.queues) - 1)]
key = data_utils.arbitrary_string(size=20, base_text='MessagingKey')
value = data_utils.arbitrary_string(size=20,
base_text='MessagingValue')
message_ttl = data_utils.\
rand_int_id(start=60, end=CONF.messaging.max_message_ttl)
message_body = {key: value}
rbody = ([{'body': message_body, 'ttl': message_ttl}] * 21)
self.assertRaises(lib_exc.BadRequest,
self.client.post_messages, queue_name, rbody)
def test_identity_update_endpoint_group(self):
eg = self.admin_eg_client.create_endpoint_group(
**self.endpoint_group())['endpoint_group']['id']
self.addCleanup(self.admin_eg_client.delete_endpoint_group, eg)
# user can update an endpoint group
self.do_request('update_endpoint_group',
client=self.eg_client,
endpoint_group_id=eg,
description=data_utils.arbitrary_string())
# nonexistent endpoint group gives a 404
self.do_request('update_endpoint_group',
client=self.eg_client,
expected_status=exceptions.NotFound,
endpoint_group_id=data_utils.rand_uuid_hex(),
description=data_utils.arbitrary_string())
def test_update_node_resource_class_old_api(self):
"""Try to update a node with resource class using older api version."""
resource_class = data_utils.arbitrary_string()
self.assertRaises(lib_exc.UnexpectedResponseCode,
self.client.update_node,
self.node['uuid'],
resource_class=resource_class)
def test_update_node_resource_class_too_long(self):
"""Try to update a node with too long resource class name."""
resource_class = data_utils.arbitrary_string(81)
self.assertRaises(lib_exc.BadRequest,
self.client.update_node,
self.node['uuid'],
resource_class=resource_class)
def test_upload_valid_object(self):
object_name = data_utils.rand_name(name="TestObject")
data = data_utils.arbitrary_string()
resp, _ = self.object_client.create_object(self.container_name,
object_name, data)
self.assertHeaders(resp, 'Object', 'PUT')
def test_identity_update_user(self):
user = self.admin_users_client.create_user(**self.user())['user']
self.addCleanup(self.admin_users_client.delete_user, user['id'])
user_update = {
'user_id': user['id'],
'description': data_utils.arbitrary_string()
}
self.do_request('update_user', **user_update)
# user gets a 404 for nonexistent user
user_update = {
'user_id': 'fakeuser',
'description': data_utils.arbitrary_string()
}
self.do_request('update_user',
expected_status=exceptions.NotFound,
**user_update)
def test_create_node_resource_class_long(self):
"""Create new node with specified longest name of resource class."""
res_class_long_name = data_utils.arbitrary_string(80)
_, body = self.create_node(
self.chassis['uuid'],
resource_class=res_class_long_name)
self.assertEqual(res_class_long_name, body['resource_class'])
def test_identity_update_limit(self):
reg_limit_id = self.admin_limits_client.create_limits(
payload=self.limits())['limits'][0]['id']
self.addCleanup(self.admin_limits_client.delete_limit,
limit_id=reg_limit_id)
updated = {'description': data_utils.arbitrary_string()}
self.do_request('update_limit', limit_id=reg_limit_id, limit=updated)
def verify_metadata(self):
if self.run_ssh and CONF.compute_feature_enabled.metadata_service:
# Verify metadata service
md_url = 'http://169.254.169.254/latest/meta-data/public-ipv4'
def exec_cmd_and_verify_output():
cmd = 'curl ' + md_url
result = self.ssh_client.exec_command(cmd)
if result:
msg = ('Failed while verifying metadata on server. Result '
'of command "%s" is NOT "%s".' % (cmd, self.fip))
self.assertEqual(self.fip, result, msg)
return 'Verification is successful!'
if not test_utils.call_until_true(exec_cmd_and_verify_output,
CONF.compute.build_timeout,
CONF.compute.build_interval):
raise exceptions.TimeoutException('Timed out while waiting to '
'verify metadata on server. '
'%s is empty.' % md_url)
# Also, test a POST
md_url = 'http://169.254.169.254/openstack/2013-10-17/password'
data = data_utils.arbitrary_string(100)
cmd = 'curl -X POST -d ' + data + ' ' + md_url
self.ssh_client.exec_command(cmd)
result = self.servers_client.show_password(self.instance['id'])
self.assertEqual(data, result['password'])
def test_upload_valid_object(self):
object_name = data_utils.rand_name(name="TestObject")
data = data_utils.arbitrary_string()
resp, _ = self.object_client.create_object(self.container_name,
object_name, data)
self.assertHeaders(resp, 'Object', 'PUT')
def verify_metadata(self):
if self.run_ssh and CONF.compute_feature_enabled.metadata_service:
# Verify metadata service
md_url = 'http://169.254.169.254/latest/meta-data/public-ipv4'
def exec_cmd_and_verify_output():
cmd = 'curl ' + md_url
result = self.ssh_client.exec_command(cmd)
if result:
msg = ('Failed while verifying metadata on server. Result '
'of command "%s" is NOT "%s".' % (cmd, self.fip))
self.assertEqual(self.fip, result, msg)
return 'Verification is successful!'
if not test_utils.call_until_true(exec_cmd_and_verify_output,
CONF.compute.build_timeout,
CONF.compute.build_interval):
raise exceptions.TimeoutException('Timed out while waiting to '
'verify metadata on server. '
'%s is empty.' % md_url)
# Also, test a POST
md_url = 'http://169.254.169.254/openstack/2013-10-17/password'
data = data_utils.arbitrary_string(100)
cmd = 'curl -X POST -d ' + data + ' ' + md_url
self.ssh_client.exec_command(cmd)
result = self.servers_client.show_password(self.instance['id'])
self.assertEqual(data, result['password'])
def test_create_node_resource_class_long(self):
"""Create new node with specified longest name of resource class."""
res_class_long_name = data_utils.arbitrary_string(80)
_, body = self.create_node(
self.chassis['uuid'],
resource_class=res_class_long_name)
self.assertEqual(res_class_long_name, body['resource_class'])
def test_web_error(self):
"""Test web error"""
headers = {'web-listings': 'true',
'web-error': self.object_name}
self.container_client.create_update_or_delete_container_metadata(
self.container_name, create_update_metadata=headers)
# Create object to return when requested object not found
object_name_404 = "404" + self.object_name
object_data_404 = data_utils.arbitrary_string()
self.object_client.create_object(self.container_name,
object_name_404,
object_data_404)
# Do not set auth in HTTP headers for next request
self.object_client.auth_provider.set_alt_auth_data(
request_part='headers',
auth_data=None
)
# Request non-existing object
self.assertRaises(
lib_exc.NotFound, self.object_client.get_object,
self.container_name, "notexisting")
def test_add_node_trait_long(self):
"""Add a node trait of the largest possible length."""
trait_long_name = 'CUSTOM_' + data_utils.arbitrary_string(248).upper()
self.client.add_node_trait(self.node['uuid'], trait_long_name)
_, body = self.client.list_node_traits(self.node['uuid'])
self.assertEqual([trait_long_name], body['traits'])
def test_identity_update_consumer(self):
consumer = self.admin_client.create_consumer(
**self.consumer())['consumer']
self.addCleanup(self.admin_client.delete_consumer, consumer['id'])
self.do_request('update_consumer',
expected_status=exceptions.Forbidden,
consumer_id=consumer['id'],
description=data_utils.arbitrary_string())
def upload_object_to_container(self, container_name):
obj_name = data_utils.rand_name('swift-scenario-object')
obj_data = data_utils.arbitrary_string()
self.object_client.create_object(container_name, obj_name, obj_data)
self.addCleanup(self.object_client.delete_object,
container_name,
obj_name)
return obj_name
def test_create_persistent_object(self):
object_name = data_utils.rand_name(name='TestObject')
data = data_utils.arbitrary_string(15)
resp, _ = self.object_client.create_object(self.containers[0],
object_name, data)
self.assertHeaders(resp, 'Object', 'PUT')
self.objects.append(object_name)
self.object_data.append(data)
def registered_limits(self):
return [{
"service_id": self.service_id,
"region_id": self.region_id,
"resource_name": data_utils.rand_name(),
"default_limit": 5,
"description": data_utils.arbitrary_string()
}]
def generate_subscription_body(cls):
message_ttl = data_utils.\
rand_int_id(start=60, end=CONF.messaging.max_message_ttl)
key = data_utils.arbitrary_string(size=20, base_text='MessagingKey')
value = data_utils.arbitrary_string(size=20,
base_text='MessagingValue')
option_body = {key: value}
subscribers = [
'http://*****:*****@123.com'
]
rbody = [{
'options': option_body,
'ttl': message_ttl,
'subscriber': subscriber
} for subscriber in subscribers]
return rbody
def test_post_messages_with_TTL_less_than_60(self):
# TTL for a message may not exceed 1209600 seconds,
# and must be at least 60 seconds long.
queue_name = self.queues[data_utils.rand_int_id(0,
len(self.queues) - 1)]
message_ttl = data_utils.\
rand_int_id(start=0, end=60)
key = data_utils.arbitrary_string(size=20, base_text='MessagingKey')
value = data_utils.arbitrary_string(size=20,
base_text='MessagingValue')
message_body = {key: value}
rbody = ([{'body': message_body, 'ttl': message_ttl}] * 1)
self.assertRaises(lib_exc.BadRequest,
self.client.post_messages, queue_name, rbody)
def test_post_messages_with_TTL_less_than_60(self):
# TTL for a message may not exceed 1209600 seconds,
# and must be at least 60 seconds long.
queue_name = self.queues[data_utils.rand_int_id(0,
len(self.queues) - 1)]
message_ttl = data_utils.\
rand_int_id(start=0, end=60)
key = data_utils.arbitrary_string(size=20, base_text='MessagingKey')
value = data_utils.arbitrary_string(size=20,
base_text='MessagingValue')
message_body = {key: value}
rbody = ([{'body': message_body, 'ttl': message_ttl}] * 1)
self.assertRaises(lib_exc.BadRequest,
self.client.post_messages, queue_name, rbody)
def test_add_node_trait_too_long(self):
"""Try to add a node trait longer than the largest possible length."""
trait_long_name = 'CUSTOM_' + data_utils.arbitrary_string(249).upper()
self.assertRaises(lib_exc.BadRequest, self.client.add_node_trait,
self.node['uuid'], trait_long_name)
_, body = self.client.list_node_traits(self.node['uuid'])
self.assertEqual([], body['traits'])
def test_list_nodes_by_resource_class_old_api(self):
"""Try to list nodes with resource class using older api version."""
resource_class = data_utils.arbitrary_string()
self.assertRaises(
lib_exc.UnexpectedResponseCode,
self.client.list_nodes, resource_class=resource_class)
self.assertRaises(
lib_exc.UnexpectedResponseCode,
self.client.list_nodes_detail, resource_class=resource_class)
def test_identity_update_identity_provider(self):
idp = self.admin_idp_client.create_identity_provider(
idp_id=data_utils.rand_name())['identity_provider']
self.addCleanup(self.admin_client.domains_client.delete_domain,
idp['domain_id'])
self.addCleanup(self.admin_client.domains_client.update_domain,
idp['domain_id'],
enabled=False)
self.addCleanup(self.admin_idp_client.delete_identity_provider,
idp['id'])
self.do_request('update_identity_provider',
idp_id=idp['id'],
description=data_utils.arbitrary_string())
# user gets a 404 for nonexistent idp
self.do_request('update_identity_provider',
expected_status=exceptions.NotFound,
idp_id=data_utils.rand_uuid_hex(),
description=data_utils.arbitrary_string())
def test_create_a_subscription_without_a_token(self):
# X-Auth-Token is not provided
message_ttl = data_utils.\
rand_int_id(start=60, end=CONF.messaging.max_message_ttl)
key = data_utils.arbitrary_string(size=20, base_text='MessagingKey')
value = data_utils.arbitrary_string(size=20,
base_text='MessagingValue')
option_body = {key: value}
subscriber = 'http://fake:8080'
rbody = {'options': option_body, 'ttl': message_ttl,
'subscriber': subscriber}
self.client.auth_provider.set_alt_auth_data(
request_part='headers',
auth_data=None
)
self.assertRaises(lib_exc.Unauthorized,
self.create_subscription, self.queue_name, rbody)
def _create_object(self, container_name, object_name=None):
# setup object
if object_name is None:
object_name = data_utils.rand_name(name='TestObject')
data = data_utils.arbitrary_string()
self.object_client.create_object(container_name,
object_name,
data)
return object_name
def test_create_container_name_exceeds_max_length(self):
# Attempts to create a container name that is longer than max
max_length = self.constraints['max_container_name_length']
# create a container with long name
container_name = data_utils.arbitrary_string(size=max_length + 1)
ex = self.assertRaises(exceptions.BadRequest,
self.container_client.create_container,
container_name)
self.assertIn('Container name length of ' + str(max_length + 1) +
' longer than ' + str(max_length), str(ex))
def test_create_container_metadata_value_exceeds_max_length(self):
# Attempts to create container with metadata value
# that is longer than max.
max_length = self.constraints['max_meta_value_length']
container_name = data_utils.rand_name(name='TestContainer')
metadata_value = data_utils.arbitrary_string(size=max_length + 1)
metadata = {'animal': metadata_value}
ex = self.assertRaises(exceptions.BadRequest,
self.container_client.create_container,
container_name, metadata=metadata)
self.assertIn('Metadata value longer than ' + str(max_length), str(ex))
def _upload_segments(self):
# create object
object_name = data_utils.rand_name(name='LObject')
data = data_utils.arbitrary_string()
segments = 10
data_segments = [data + str(i) for i in range(segments)]
# uploading segments
for i in range(segments):
self.object_client.create_object_segments(
self.container_name, object_name, i, data_segments[i])
return object_name, data_segments
def test_upload_valid_object(self):
"""Attempts to uploads an object smaller than the bytes quota."""
object_name = data_utils.rand_name(name="TestObject")
data = data_utils.arbitrary_string(QUOTA_BYTES)
nbefore = self._get_bytes_used()
resp, _ = self.object_client.create_object(
self.container_name, object_name, data)
self.assertHeaders(resp, 'Object', 'PUT')
nafter = self._get_bytes_used()
self.assertEqual(nbefore + len(data), nafter)
def test_create_container_metadata_name_exceeds_max_length(self):
# Attempts to create container with metadata name
# that is longer than max.
max_length = self.constraints['max_meta_name_length']
container_name = data_utils.rand_name(name='TestContainer')
metadata_name = 'X-Container-Meta-' + data_utils.arbitrary_string(
size=max_length + 1)
metadata = {metadata_name: 'penguin'}
ex = self.assertRaises(
exceptions.BadRequest,
self.container_client.update_container,
container_name, **metadata)
self.assertIn('Metadata name too long', str(ex))
def test_upload_large_object(self):
"""Attempts to upload an object larger than the bytes quota."""
object_name = data_utils.rand_name(name="TestObject")
data = data_utils.arbitrary_string(QUOTA_BYTES + 1)
nbefore = self._get_bytes_used()
self.assertRaises(lib_exc.OverLimit,
self.object_client.create_object,
self.container_name, object_name, data)
nafter = self._get_bytes_used()
self.assertEqual(nbefore, nafter)
def create_object(cls, container_name, object_name=None,
data=None, metadata=None):
# wrapper that returns a test object
if object_name is None:
object_name = data_utils.rand_name(name='TestObject')
if data is None:
data = data_utils.arbitrary_string()
cls.object_client.create_object(container_name,
object_name,
data,
metadata=metadata)
return object_name, data
def test_post_messages_exceeding_message_post_size(self):
# Post messages with greater message size
queue_name = self.queues[data_utils.rand_int_id(0,
len(self.queues) - 1)]
key = data_utils.arbitrary_string(size=20, base_text='MessagingKey')
value = 'a' * 1024
message_ttl = data_utils.\
rand_int_id(start=60, end=CONF.messaging.max_message_ttl)
message_body = {key: value}
rbody = ([{'body': message_body, 'ttl': message_ttl}] * 1)
self.assertRaises(lib_exc.BadRequest,
self.client.post_messages, queue_name, rbody)
def setUp(self):
super(ObjectTempUrlNegativeTest, self).setUp()
# make sure the metadata has been set
self.assertIn('x-account-meta-temp-url-key',
self.account_client_metadata)
self.assertEqual(
self.account_client_metadata['x-account-meta-temp-url-key'],
self.key)
# create object
self.object_name = data_utils.rand_name(name='ObjectTemp')
content = data_utils.arbitrary_string(size=len(self.object_name),
base_text=self.object_name)
self.object_client.create_object(self.container_name,
self.object_name, content)
def test_object_upload_in_segments(self):
# create object
object_name = data_utils.rand_name(name='LObject')
data = data_utils.arbitrary_string()
segments = 10
data_segments = [data + str(i) for i in range(segments)]
# uploading segments
for i in range(segments):
obj_name = "%s/%s" % (object_name, i)
resp, _ = self.object_client.create_object(
self.container_name, obj_name, data_segments[i])
# creating a manifest file
metadata = {'X-Object-Manifest': '%s/%s/'
% (self.container_name, object_name)}
resp, _ = self.object_client.create_object(self.container_name,
object_name, data='')
self.assertHeaders(resp, 'Object', 'PUT')
resp, _ = self.object_client.create_or_update_object_metadata(
self.container_name, object_name, headers=metadata)
self.assertHeaders(resp, 'Object', 'POST')
resp, _ = self.object_client.list_object_metadata(
self.container_name, object_name)
# Etag value of a large object is enclosed in double-quotations.
# After etag quotes are checked they are removed and the response is
# checked if all common headers are present and well formatted
self.assertTrue(resp['etag'].startswith('\"'))
self.assertTrue(resp['etag'].endswith('\"'))
resp['etag'] = resp['etag'].strip('"')
self.assertHeaders(resp, 'Object', 'HEAD')
self.assertIn('x-object-manifest', resp)
self.assertEqual(resp['x-object-manifest'],
'%s/%s/' % (self.container_name, object_name))
# downloading the object
resp, body = self.object_client.get_object(
self.container_name, object_name)
self.assertEqual(''.join(data_segments), body.decode())
def test_update_object_metadata_with_x_remove_object_metakey(self):
# update object metadata with a blank value of remove metadata
object_name = data_utils.rand_name(name='TestObject')
data = data_utils.arbitrary_string()
create_metadata = {'X-Object-Meta-test-meta': 'Meta'}
self.object_client.create_object(self.container_name,
object_name,
data,
metadata=create_metadata)
update_metadata = {'X-Remove-Object-Meta-test-meta': ''}
resp, _ = self.object_client.create_or_update_object_metadata(
self.container_name,
object_name,
headers=update_metadata)
self.assertHeaders(resp, 'Object', 'POST')
resp, _ = self.object_client.list_object_metadata(
self.container_name,
object_name)
self.assertNotIn('x-object-meta-test-meta', resp)
def test_web_error(self):
headers = {'web-listings': 'true',
'web-error': self.object_name}
self.container_client.update_container_metadata(
self.container_name, metadata=headers)
# Create object to return when requested object not found
object_name_404 = "404" + self.object_name
object_data_404 = data_utils.arbitrary_string()
self.object_client.create_object(self.container_name,
object_name_404,
object_data_404)
# Do not set auth in HTTP headers for next request
self.object_client.auth_provider.set_alt_auth_data(
request_part='headers',
auth_data=None
)
# Request non-existing object
self.assertRaises(
lib_exc.NotFound, self.object_client.get_object,
self.container_name, "notexisting")
def test_update_node_resource_class_too_long(self):
"""Try to update a node with too long resource class name."""
resource_class = data_utils.arbitrary_string(81)
self.assertRaises(lib_exc.BadRequest, self.client.update_node,
self.node['uuid'], resource_class=resource_class)
def test_update_node_resource_class_old_api(self):
"""Try to update a node with resource class using older api version."""
resource_class = data_utils.arbitrary_string()
self.assertRaises(lib_exc.UnexpectedResponseCode,
self.client.update_node,
self.node['uuid'], resource_class=resource_class)
