def test_object_list_with_xml_accept_header(self):
container_name = '{0}_{1}'.format(self.base_container_name,
randstring.get_random_string())
self.client.create_container(container_name)
self.addCleanup(self.client.force_delete_containers, [container_name])
object_data = 'Test file data'
content_length = str(len(object_data))
object_name = '{0}_{1}'.format(self.base_object_name,
randstring.get_random_string())
headers = {
'Content-Length': content_length,
'Content-Type': CONTENT_TYPE_TEXT
}
self.client.create_object(container_name,
object_name,
headers=headers,
data=object_data)
headers = {'Accept': 'application/xml'}
response = self.client.list_objects(container_name, headers=headers)
self.assertEqual(
response.status_code, 200,
'should list objects using content-type application/xml')
headers = {'Accept': 'text/xml'}
response = self.client.list_objects(container_name, headers=headers)
self.assertEqual(response.status_code, 200,
'should list objects using content-type text/xml')
def test_object_list_with_json_accept_header(self):
container_name = '{0}_{1}'.format(
self.base_container_name,
randstring.get_random_string())
self.client.create_container(container_name)
self.addCleanup(
self.client.force_delete_containers,
[container_name])
object_data = 'Test file data'
content_length = str(len(object_data))
object_name = '{0}_{1}'.format(
self.base_object_name,
randstring.get_random_string())
headers = {'Content-Length': content_length,
'Content-Type': CONTENT_TYPE_TEXT}
self.client.create_object(
container_name,
object_name,
headers=headers,
data=object_data)
headers = {'Accept': 'application/json'}
response = self.client.list_objects(
container_name,
headers=headers)
self.assertEqual(
response.status_code,
200,
'should list objects using content-type application/json')
def test_objects_list_with_format_xml_query_parameter(self):
container_name = '{0}_{1}'.format(
self.base_container_name,
randstring.get_random_string())
self.client.create_container(container_name)
self.addCleanup(
self.client.force_delete_containers,
[container_name])
object_data = 'Test file data'
content_length = str(len(object_data))
object_name = '{0}_{1}'.format(
self.base_object_name,
randstring.get_random_string())
headers = {'Content-Length': content_length,
'Content-Type': CONTENT_TYPE_TEXT}
self.client.create_object(
container_name,
object_name,
headers=headers,
data=object_data)
format_ = {'format': 'xml'}
response = self.client.list_objects(container_name, params=format_)
self.assertEqual(
response.status_code,
200,
'should list object using content-type xml')
def test_objects_list_with_delimiter_query_parameter(self):
container_name = '{0}_{1}'.format(self.base_container_name,
randstring.get_random_string())
self.client.create_container(container_name)
self.addCleanup(self.client.force_delete_containers, [container_name])
object_data = 'Test file data'
content_length = str(len(object_data))
object_name_prefix = 'delimiter_test/'
object_name_postfix = '{0}_{1}'.format(self.base_object_name,
randstring.get_random_string())
object_name = '{0}{1}'.format(object_name_prefix, object_name_postfix)
headers = {
'Content-Length': content_length,
'Content-Type': CONTENT_TYPE_TEXT
}
self.client.create_object(container_name,
object_name,
headers=headers,
data=object_data)
params = {'delimiter': '/'}
response = self.client.list_objects(container_name, params=params)
self.assertEqual(response.status_code, 200,
'should list the simulated directory')
params = {'prefix': object_name_prefix, 'delimiter': '/'}
response = self.client.list_objects(container_name, params=params)
self.assertEqual(response.status_code, 200,
'should list the object in the simulated directory')
def test_objects_list_with_format_xml_query_parameter(self):
container_name = '{0}_{1}'.format(self.base_container_name,
randstring.get_random_string())
self.client.create_container(container_name)
self.addCleanup(self.client.force_delete_containers, [container_name])
object_data = 'Test file data'
content_length = str(len(object_data))
object_name = '{0}_{1}'.format(self.base_object_name,
randstring.get_random_string())
headers = {
'Content-Length': content_length,
'Content-Type': CONTENT_TYPE_TEXT
}
self.client.create_object(container_name,
object_name,
headers=headers,
data=object_data)
format_ = {'format': 'xml'}
response = self.client.list_objects(container_name, params=format_)
self.assertEqual(response.status_code, 200,
'should list object using content-type xml')
def test_tempurl_object_download(self):
time.sleep(61)
container_name = '{0}_{1}'.format(
self.base_container_name,
randomstring.get_random_string())
self.client.create_container(container_name)
self.addCleanup(
self.client.force_delete_containers,
[container_name])
object_name = '{0}_{1}'.format(
self.base_object_name,
randomstring.get_random_string())
object_data = 'Test file data'
content_length = str(len(object_data))
etag = md5hash.get_md5_hash(object_data)
headers = {'Content-Length': content_length,
'Content-Type': CONTENT_TYPE_TEXT,
'Etag': etag}
self.client.create_object(
container_name,
object_name,
headers=headers,
data=object_data)
temp_key = '{0}_{1}'.format(
'temp_url_dl_test_key',
randomstring.get_random_string())
key = md5hash.get_md5_hash(temp_key)
headers = {'X-Account-Meta-Temp-URL-Key': key}
resp = self.client.set_temp_url_key(headers=headers)
self.assertEqual(resp.status_code, 204)
tempurl_data = self.client.create_temp_url(
'GET',
container_name,
object_name,
'86400',
key)
dl_tempurl = '{0}?temp_url_sig={1}&temp_url_expires={2}'.format(
tempurl_data['target_url'],
tempurl_data['signature'],
tempurl_data['expires'])
resp = self.client.get(dl_tempurl)
if resp.headers['content-disposition'] is not None:
expected = 'attachment; filename="{0}"'.format(object_name)
recieved = resp.headers['content-disposition']
self.assertEqual(expected, recieved)
else:
self.assertIsNotNone(resp.headers['content-disposition'])
def test_tempurl_object_upload(self):
time.sleep(61)
container_name = '{0}_{1}'.format(
self.base_container_name,
randomstring.get_random_string())
self.client.create_container(container_name)
self.addCleanup(
self.client.force_delete_containers,
[container_name])
object_name = '{0}_{1}'.format(
self.base_object_name,
randomstring.get_random_string())
headers = {'Content-Length': '0'}
self.client.create_object(
container_name,
object_name,
headers=headers)
temp_key = '{0}_{1}'.format(
'temp_url_dl_test_key',
randomstring.get_random_string())
key = md5hash.get_md5_hash(temp_key)
headers = {'X-Account-Meta-Temp-URL-Key': key}
resp = self.client.set_temp_url_key(headers=headers)
self.assertEqual(resp.status_code, 204)
tempurl_data = self.client.create_temp_url(
'PUT',
container_name,
object_name,
'86400',
key)
ul_tempurl = '{0}?temp_url_sig={1}&temp_url_expires={2}'.format(
tempurl_data['target_url'],
tempurl_data['signature'],
tempurl_data['expires'])
object_data = 'Test file data'
content_length = str(len(object_data))
etag = md5hash.get_md5_hash(object_data)
headers = {'Content-Length': content_length,
'Content-Type': CONTENT_TYPE_TEXT,
'Etag': etag}
resp = self.client.put(ul_tempurl, data=object_data, headers=headers)
self.assertEqual(resp.status_code, 201)
resp = self.client.get_object(container_name, object_name)
self.assertEqual(resp.content, object_data)
def test_objects_list_with_prefix_delimiter_query_parameters(self):
container_name = '{0}_{1}'.format(
self.base_container_name,
randstring.get_random_string())
self.client.create_container(container_name)
self.addCleanup(
self.client.force_delete_containers,
[container_name])
object_data = 'Test file data'
content_length = str(len(object_data))
object_name_prefix = 'delimiter_test/'
object_name_postfix = '{0}_{1}'.format(
self.base_object_name,
randstring.get_random_string())
object_name = '{0}{1}'.format(object_name_prefix, object_name_postfix)
headers = {'Content-Length': content_length,
'Content-Type': CONTENT_TYPE_TEXT}
self.client.create_object(
container_name,
object_name,
headers=headers,
data=object_data)
params = {'delimiter': '/'}
response = self.client.list_objects(self.container_name, params=params)
method = "simulated directory list"
expected = 200
received = response.status_code
self.assertEqual(
expected,
received,
msg=STATUS_CODE_MSG.format(
method=method,
expected=expected,
received=str(received)))
params = {'prefix': object_name_prefix, 'delimiter': '/'}
response = self.client.list_objects(container_name, params=params)
method = "simulated obj in directory list"
expected = 200
received = response.status_code
self.assertEqual(
expected,
received,
msg=STATUS_CODE_MSG.format(
method=method,
expected=expected,
received=str(received)))
def __init__(self):
alphanumeric = randomstring.get_random_string(prefix='1a2b')
random255 = randomstring.get_random_string(size=255)
punctuation = '~!@#$%^&*()_+`-={}[]|:;<>,.?"'
uuid = str(uuid4())
self.append_new_dataset('alphanumeric', {'name': alphanumeric})
self.append_new_dataset('punctuation', {'name': punctuation})
self.append_new_dataset('len_255', {'name': random255})
self.append_new_dataset('uuid', {'name': uuid})
def __init__(self):
alphanumeric = randomstring.get_random_string(prefix='1a2b')
random255 = randomstring.get_random_string(size=255)
punctuation = '~!@#$%^&*()_+`-={}[]|:;<>,.?"'
uuid = str(uuid4())
self.append_new_dataset('alphanumeric', {'name': alphanumeric})
self.append_new_dataset('punctuation', {'name': punctuation})
self.append_new_dataset('len_255', {'name': random255})
self.append_new_dataset('uuid', {'name': uuid})
def test_objects_list_with_prefix_delimiter_query_parameters(self):
container_name = '{0}_{1}'.format(self.base_container_name,
randstring.get_random_string())
self.client.create_container(container_name)
self.addCleanup(self.client.force_delete_containers, [container_name])
object_data = 'Test file data'
content_length = str(len(object_data))
object_name_prefix = 'delimiter_test/'
object_name_postfix = '{0}_{1}'.format(self.base_object_name,
randstring.get_random_string())
object_name = '{0}{1}'.format(object_name_prefix, object_name_postfix)
headers = {
'Content-Length': content_length,
'Content-Type': CONTENT_TYPE_TEXT
}
self.client.create_object(container_name,
object_name,
headers=headers,
data=object_data)
params = {'delimiter': '/'}
response = self.client.list_objects(self.container_name, params=params)
method = "simulated directory list"
expected = 200
received = response.status_code
self.assertEqual(expected,
received,
msg=STATUS_CODE_MSG.format(method=method,
expected=expected,
received=str(received)))
params = {'prefix': object_name_prefix, 'delimiter': '/'}
response = self.client.list_objects(container_name, params=params)
method = "simulated obj in directory list"
expected = 200
received = response.status_code
self.assertEqual(expected,
received,
msg=STATUS_CODE_MSG.format(method=method,
expected=expected,
received=str(received)))
def test_tempurl_object_download(self):
time.sleep(61)
container_name = '{0}_{1}'.format(self.base_container_name,
randomstring.get_random_string())
self.client.create_container(container_name)
self.addCleanup(self.client.force_delete_containers, [container_name])
object_name = '{0}_{1}'.format(self.base_object_name,
randomstring.get_random_string())
object_data = 'Test file data'
content_length = str(len(object_data))
etag = md5hash.get_md5_hash(object_data)
headers = {
'Content-Length': content_length,
'Content-Type': CONTENT_TYPE_TEXT,
'Etag': etag
}
self.client.create_object(container_name,
object_name,
headers=headers,
data=object_data)
temp_key = '{0}_{1}'.format('temp_url_dl_test_key',
randomstring.get_random_string())
key = md5hash.get_md5_hash(temp_key)
headers = {'X-Account-Meta-Temp-URL-Key': key}
resp = self.client.set_temp_url_key(headers=headers)
self.assertEqual(resp.status_code, 204)
tempurl_data = self.client.create_temp_url('GET', container_name,
object_name, '86400', key)
dl_tempurl = '{0}?temp_url_sig={1}&temp_url_expires={2}'.format(
tempurl_data['target_url'], tempurl_data['signature'],
tempurl_data['expires'])
resp = self.client.get(dl_tempurl)
if resp.headers['content-disposition'] is not None:
expected = 'attachment; filename="{0}"'.format(object_name)
recieved = resp.headers['content-disposition']
self.assertEqual(expected, recieved)
else:
self.assertIsNotNone(resp.headers['content-disposition'])
def ddtest_object_list_with_extended_accept_header(self, descriptor=None,
hdrs=None):
"""
test for openstack bug #1202453 fix
and expansion of accept to take 'q' and
arbitrary extensions
"""
container_name = '{0}_{1}'.format(
self.base_container_name,
randstring.get_random_string())
self.client.create_container(container_name)
self.addCleanup(
self.behaviors.force_delete_containers,
[container_name])
object_data = 'Test file data'
content_length = str(len(object_data))
object_name = '{0}_{1}'.format(
'extended_accept_header',
randstring.get_random_string())
headers = {'Content-Length': content_length,
'Content-Type': CONTENT_TYPE_TEXT}
self.client.create_object(
container_name,
object_name,
headers=headers,
data=object_data)
# headers from the data set
headers = hdrs
response = self.client.list_objects(
container_name,
headers=hdrs)
method = 'list objects'
expected = 200
received = response.status_code
self.assertEqual(
expected,
received,
msg=STATUS_CODE_MSG.format(
method=method,
expected=expected,
received=str(received),
headers=str(hdrs)))
def test_metadata_retrieval_with_newly_created_container(self):
container_name = '{0}_{1}'.format(self.base_container_name,
randstring.get_random_string())
metadata = {'ebooks': 'grok_volumes_1_through_10'}
response = self.client.create_container(container_name, metadata)
self.addCleanup(self.client.force_delete_containers, [container_name])
method = "container creation"
expected = 201
received = response.status_code
self.assertEqual(expected,
received,
msg=STATUS_CODE_MSG.format(method=method,
expected=expected,
received=str(received)))
response = self.client.get_container_metadata(container_name)
method = "container metadata retrieval"
expected = 204
received = response.status_code
self.assertEqual(expected,
received,
msg=STATUS_CODE_MSG.format(method=method,
expected=expected,
received=str(received)))
def test_container_creation_with_existing_container_name(self):
container_name = '{0}_{1}'.format(
self.base_container_name,
randstring.get_random_string())
response = self.client.create_container(container_name)
self.addCleanup(
self.client.force_delete_containers,
[container_name])
method = "container creation"
expected = 201
received = response.status_code
self.assertEqual(
expected,
received,
msg=STATUS_CODE_MSG.format(
method=method,
expected=expected,
received=str(received)))
response = self.client.create_container(container_name)
method = "container creation with existing container name"
expected = 202
received = response.status_code
self.assertEqual(
expected,
received,
msg=STATUS_CODE_MSG.format(
method=method,
expected=expected,
received=str(received)))
def test_metadata_update_with_container_possessing_metadata(self):
container_name = '{0}_{1}'.format(self.base_container_name,
randstring.get_random_string())
self.client.create_container(container_name)
self.addCleanup(self.client.force_delete_containers, [container_name])
metadata = {'ebooks': 'grok_volumes_1_through_10'}
response = self.client.set_container_metadata(container_name, metadata)
method = "set container metadata"
expected = 204
received = response.status_code
self.assertEqual(expected,
received,
msg=STATUS_CODE_MSG.format(method=method,
expected=expected,
received=str(received)))
metadata = {'ebooks': 'drok_volumes_10_through_20'}
response = self.client.set_container_metadata(container_name, metadata)
method = "container metadata update"
expected = 204
received = response.status_code
self.assertEqual(expected,
received,
msg=STATUS_CODE_MSG.format(method=method,
expected=expected,
received=str(received)))
def test_container_creation_with_existing_container_name(self):
container_name = '{0}_{1}'.format(self.base_container_name,
randstring.get_random_string())
response = self.client.create_container(container_name)
self.addCleanup(self.client.force_delete_containers, [container_name])
method = "container creation"
expected = 201
received = response.status_code
self.assertEqual(expected,
received,
msg=STATUS_CODE_MSG.format(method=method,
expected=expected,
received=str(received)))
response = self.client.create_container(container_name)
method = "container creation with existing container name"
expected = 202
received = response.status_code
self.assertEqual(expected,
received,
msg=STATUS_CODE_MSG.format(method=method,
expected=expected,
received=str(received)))
def test_metadata_retrieval_after_setting_metadata(self):
container_name = '{0}_{1}'.format(
self.base_container_name,
randstring.get_random_string())
self.client.create_container(container_name)
self.addCleanup(
self.client.force_delete_containers,
[container_name])
metadata = {'ebooks': 'grok_volumes_1_through_10'}
response = self.client.set_container_metadata(
container_name,
metadata)
response = self.client.get_container_metadata(container_name)
method = "container metadata retrieval"
expected = 204
received = response.status_code
self.assertEqual(
expected,
received,
msg=STATUS_CODE_MSG.format(
method=method,
expected=expected,
received=str(received)))
def test_failure_reported_with_invalid_tar_archive(self):
"""
Scenario: Verify behavior when an invalid archive file is uploaded
Expected Results: Errors are reported. Objects are not created
"""
container_name = "{0}_container_{1}".format(BASE_NAME, randstring.get_random_string())
self.behaviors.create_container(container_name)
self.addCleanup(self.behaviors.force_delete_containers, [container_name])
url = "{0}/{1}".format(self.storage_url, container_name)
params = {"extract-archive": "tar"}
headers = {"Accept": "application/json"}
response = self.client.put(url, data=self.bad_data, params=params, headers=headers)
expected = HTTP_OK
received = response.status_code
self.assertEqual(
expected,
received,
"upload corrupted tar.gz expected" " successful status code: {0} received: {1}".format(expected, received),
)
# inspect the body of the response
content = None
try:
content = json.loads(response.content)
except ValueError, error:
self.fixture_log.exception(error)
def test_container_creation_with_valid_container_name(self):
container_name = '{0}_{1}'.format(self.base_container_name,
randstring.get_random_string())
response = self.client.create_container(container_name)
self.addCleanup(self.client.force_delete_containers, [container_name])
self.assertEqual(response.status_code, 201, 'should be created')
def create_archive(self, object_names, compression_type,
archive_name=BULK_ARCHIVE_NAME):
"""
Bulk creates objects in the opencafe's temp directory specified in the
engine config. Each object's data will be the md5sum of the object's
name.
@type object_names: strings
@param object_names: a list of object names
@type object_names: string
@param object_names: file compression to apply to the archive
@rtype: string
@return: Returns full path of the archive that was created in
opencafe's temp directory specified in the engine config
"""
supported = [None, "gz", "bz2"]
if compression_type not in supported:
raise NameError("supported compression: {0}".format(supported))
ext = ''
if not compression_type:
ext = 'tar'
compression_type = ''
else:
ext = 'tar.{0}'.format(compression_type)
archive_name = '{0}.{1}.{2}'.format(
archive_name,
randstring.get_random_string(),
ext)
archive_dir = self.engine_config.temp_directory
archive_filename = '{0}/{1}'.format(archive_dir, archive_name)
archive = tarfile.open(
archive_filename,
'w:{0}'.format(compression_type))
for object_name in object_names:
object_data = get_md5_hash(object_name)
object_size = len(object_data)
object_time = int(mktime(datetime.now().timetuple()))
object_buffer = StringIO(object_data)
object_buffer.seek(0)
object_info = tarfile.TarInfo(name=object_name)
object_info.size = object_size
object_info.mtime = object_time
archive.addfile(tarinfo=object_info, fileobj=object_buffer)
archive.close()
archive_path = "{0}/{1}".format(
self.engine_config.temp_directory,
archive_name)
return archive_path
def setUpClass(cls):
super(ObjectVersioningTest, cls).setUpClass()
cls.container_name = CONTAINER_NAME
cls.object_name = "{0}_{1}".format(
cls.behaviors.VALID_OBJECT_NAME,
randstring.get_random_string())
def test_metadata_update_with_container_possessing_metadata(self):
container_name = '{0}_{1}'.format(
self.base_container_name,
randstring.get_random_string())
self.client.create_container(container_name)
self.addCleanup(
self.client.force_delete_containers,
[container_name])
metadata = {'Book-One': 'fight_club',
'Book-Two': 'a_clockwork_orange'}
response = self.client.set_container_metadata(
container_name,
metadata)
self.assertEqual(response.status_code, 204, 'metadata should be added')
metadata = {'Book-One': 'Fight_Club'}
response = self.client.set_container_metadata(
container_name,
metadata)
self.assertEqual(
response.status_code,
204,
'metadata should be updated')
def test_creating_secret_w_alphanumeric_name(self):
"""Covers case of creating secret with an alphanumeric name."""
name = randomstring.get_random_string(prefix='1a2b')
resps = self.behaviors.create_and_check_secret(name=name)
self.assertEqual(resps.create_resp.status_code, 201,
'Returned unexpected response code')
secret = resps.get_resp.entity
self.assertEqual(secret.name, name, 'Secret name is not correct')
def test_tempurl_object_upload(self):
time.sleep(61)
container_name = '{0}_{1}'.format(self.base_container_name,
randomstring.get_random_string())
self.client.create_container(container_name)
self.addCleanup(self.client.force_delete_containers, [container_name])
object_name = '{0}_{1}'.format(self.base_object_name,
randomstring.get_random_string())
headers = {'Content-Length': '0'}
self.client.create_object(container_name, object_name, headers=headers)
temp_key = '{0}_{1}'.format('temp_url_dl_test_key',
randomstring.get_random_string())
key = md5hash.get_md5_hash(temp_key)
headers = {'X-Account-Meta-Temp-URL-Key': key}
resp = self.client.set_temp_url_key(headers=headers)
self.assertEqual(resp.status_code, 204)
tempurl_data = self.client.create_temp_url('PUT', container_name,
object_name, '86400', key)
ul_tempurl = '{0}?temp_url_sig={1}&temp_url_expires={2}'.format(
tempurl_data['target_url'], tempurl_data['signature'],
tempurl_data['expires'])
object_data = 'Test file data'
content_length = str(len(object_data))
etag = md5hash.get_md5_hash(object_data)
headers = {
'Content-Length': content_length,
'Content-Type': CONTENT_TYPE_TEXT,
'Etag': etag
}
resp = self.client.put(ul_tempurl, data=object_data, headers=headers)
self.assertEqual(resp.status_code, 201)
resp = self.client.get_object(container_name, object_name)
self.assertEqual(resp.content, object_data)
def test_create_order_w_name_of_len_255(self):
"""Covers case of creating an order with a 255 character name."""
name = randomstring.get_random_string(size=255)
resps = self.behaviors.create_and_check_order(name=name)
self.assertEqual(resps.create_resp.status_code, 202,
'Returned unexpected response code')
secret = resps.get_resp.entity.secret
self.assertEqual(secret.name, name, 'Secret name is not correct')
def generate_unique_container_name(self, identifier=None):
if identifier:
identifier = '{0}_'.format(identifier)
container_name = '{0}({1}{2})'.format(self.config.base_container_name,
identifier,
randomstring.get_random_string())
return container_name
def generate_unique_container_name(self, identifier=None):
if identifier:
identifier = '{0}_'.format(identifier)
container_name = '{0}({1}{2})'.format(
self.config.base_container_name, identifier,
randomstring.get_random_string())
return container_name
def ddtest_object_list_with_extended_accept_header(self,
descriptor=None,
hdrs=None):
"""
test for openstack bug #1202453 fix
and expansion of accept to take 'q' and
arbitrary extensions
"""
container_name = '{0}_{1}'.format(self.base_container_name,
randstring.get_random_string())
self.client.create_container(container_name)
self.addCleanup(self.behaviors.force_delete_containers,
[container_name])
object_data = 'Test file data'
content_length = str(len(object_data))
object_name = '{0}_{1}'.format('extended_accept_header',
randstring.get_random_string())
headers = {
'Content-Length': content_length,
'Content-Type': CONTENT_TYPE_TEXT
}
self.client.create_object(container_name,
object_name,
headers=headers,
data=object_data)
# headers from the data set
headers = hdrs
response = self.client.list_objects(container_name, headers=hdrs)
method = 'list objects'
expected = 200
received = response.status_code
self.assertEqual(expected,
received,
msg=STATUS_CODE_MSG.format(method=method,
expected=expected,
received=str(received),
headers=str(hdrs)))
def test_container_creation_with_valid_container_name(self):
container_name = '{0}_{1}'.format(
self.base_container_name,
randstring.get_random_string())
response = self.client.create_container(container_name)
self.addCleanup(
self.client.force_delete_containers,
[container_name])
self.assertEqual(response.status_code, 201, 'should be created')
def test_container_creation_with_metadata(self):
container_name = '{0}_{1}'.format(self.base_container_name,
randstring.get_random_string())
metadata = {'Book-One': 'fight_club', 'Book-Two': 'a_clockwork_orange'}
response = self.client.create_container(container_name,
metadata=metadata)
self.addCleanup(self.client.force_delete_containers, [container_name])
self.assertEqual(response.status_code, 201, 'should be created')
def test_objects_list_with_delimiter_query_parameter(self):
container_name = '{0}_{1}'.format(
self.base_container_name,
randstring.get_random_string())
self.client.create_container(container_name)
self.addCleanup(
self.client.force_delete_containers,
[container_name])
object_data = 'Test file data'
content_length = str(len(object_data))
object_name_prefix = 'delimiter_test/'
object_name_postfix = '{0}_{1}'.format(
self.base_object_name,
randstring.get_random_string())
object_name = '{0}{1}'.format(object_name_prefix, object_name_postfix)
headers = {'Content-Length': content_length,
'Content-Type': CONTENT_TYPE_TEXT}
self.client.create_object(
container_name,
object_name,
headers=headers,
data=object_data)
params = {'delimiter': '/'}
response = self.client.list_objects(container_name, params=params)
self.assertEqual(
response.status_code, 200,
'should list the simulated directory')
params = {'prefix': object_name_prefix, 'delimiter': '/'}
response = self.client.list_objects(container_name, params=params)
self.assertEqual(
response.status_code,
200,
'should list the object in the simulated directory')
def test_psuedo_dirs_delimiter_test(self):
container_name = "{0}_{1}".format(
CONTAINER_NAME,
randstring.get_random_string())
obj_names = {"/": "music/grok",
"-": "music-drok",
">": "music>foo",
"|": "music|bar"}
content_length = str(len(self.default_obj_data))
headers = {"Content-Length": content_length,
"Content-Type": CONTENT_TYPE_TEXT}
for key in obj_names.keys():
self.behaviors.create_object(
container_name,
obj_names.get(key),
data=self.default_obj_data,
headers=headers)
self.addCleanup(
self.behaviors.force_delete_containers,
[container_name])
for delimiter in obj_names.keys():
prefix = "music{0}".format(delimiter)
params = {"prefix": prefix,
"delimiter": delimiter,
"format": "json"}
response = self.client.list_objects(container_name, params=params)
members = self.get_members(["subdir", "name"], response.content)
expected = 1
received = len(members)
self.assertEqual(
expected,
received,
msg="container list with prefix: {0} and delimiter: {1}"
" expected: {2} members received: {3}".format(
prefix,
delimiter,
expected,
received))
obj_name = obj_names.get(delimiter)
self.assertIn(
obj_name,
members,
msg="object name: {0} was not found in response body:"
" {1}".format(obj_name, members))
def setup_container(self, base_name, headers=None):
container_name = '{0}_{1}'.format(
base_name,
randomstring.get_random_string())
self.client.create_container(container_name, headers=headers)
self.addCleanup(
self.client.force_delete_containers,
[container_name])
return container_name
def setup_container(self, base_name, headers=None):
container_name = '{0}_{1}'.format(
base_name,
randomstring.get_random_string())
self.client.create_container(container_name, headers=headers)
self.addCleanup(
self.client.force_delete_containers,
[container_name])
return container_name
def ddtest_failure_reported_with_incorrect_archive_identifier(
self, archive_format, wrong_format):
"""
Scenario: archive file is uploaded with incorrect extract-archive
format identifier
Expected Results: Errors are reported. Objects are not created
@param archive_format: Type of archive file to upload.
@type archive_format: string
@param wrong_format: Format to incorrectly label the archive file as.
@type wrong_format: string
"""
container_name = '{0}_container_{1}'.format(
BASE_NAME,
randstring.get_random_string())
self.behaviors.create_container(container_name)
self.addCleanup(
self.behaviors.force_delete_containers,
[container_name])
url = "{0}/{1}".format(
self.storage_url,
container_name)
data = self.read_archive_data(self.archive_paths[archive_format])
params = {'extract-archive': wrong_format}
headers = {'Accept': 'application/json'}
response = self.client.put(
url,
data=data,
params=params,
headers=headers)
expected = HTTP_OK
received = response.status_code
self.assertEqual(
expected,
received,
"tar archive with data format tar.gz extraction expected"
" successful status code: {0} received: {1}".format(
expected,
received))
# inspect the body of the response
content = None
try:
content = json.loads(response.content)
except ValueError, error:
self.fixture_log.exception(error)
def test_metadata_retrieval_with_container_possessing_metadata(self):
container_name = '{0}_{1}'.format(self.base_container_name,
randstring.get_random_string())
self.client.create_container(container_name)
self.addCleanup(self.client.force_delete_containers, [container_name])
metadata = {'Book-One': 'fight_club', 'Book-Two': 'a_clockwork_orange'}
response = self.client.set_container_metadata(container_name, metadata)
response = self.client.get_container_metadata(container_name)
self.assertEqual(response.status_code, 204,
'container should return metadata')
def test_container_deletion_with_existing_empty_container(self):
container_name = '{0}_{1}'.format(self.base_container_name,
randstring.get_random_string())
response = self.client.create_container(container_name)
self.addCleanup(self.client.force_delete_containers, [container_name])
self.assertEqual(response.status_code, 201, 'should be created')
response = self.client.delete_container(container_name)
self.assertEqual(response.status_code, 204, 'should be deleted')
response = self.client.list_objects(container_name)
self.assertEqual(response.status_code, 404,
'should not exist after deletion')
def test_container_creation_with_metadata(self):
container_name = '{0}_{1}'.format(
self.base_container_name,
randstring.get_random_string())
metadata = {'Book-One': 'fight_club',
'Book-Two': 'a_clockwork_orange'}
response = self.client.create_container(
container_name,
metadata=metadata)
self.addCleanup(
self.client.force_delete_containers,
[container_name])
self.assertEqual(response.status_code, 201, 'should be created')
def ddtest_failure_reported_with_incorrect_archive_identifier(
self, archive_format, wrong_format, **kwargs):
"""
Scenario: archive file is uploaded with incorrect extract-archive
format identifier
Expected Results: Errors are reported. Objects are not created
@param archive_format: Type of archive file to upload.
@type archive_format: string
@param wrong_format: Format to incorrectly label the archive file as.
@type wrong_format: string
"""
container_name = '{0}_container_{1}'.format(
BASE_NAME, randstring.get_random_string())
self.behaviors.create_container(container_name)
self.addCleanup(self.behaviors.force_delete_containers,
[container_name])
url = "{0}/{1}".format(self.storage_url, container_name)
data = self.read_archive_data(self.archive_paths[archive_format])
params = {'extract-archive': wrong_format}
headers = {'Accept': 'application/json'}
response = self.client.put(url,
data=data,
params=params,
headers=headers)
expected = HTTP_OK
received = response.status_code
self.assertEqual(
expected, received,
"tar archive with data format tar.gz extraction expected"
" successful status code: {0} received: {1}".format(
expected, received))
# inspect the body of the response
content = None
try:
content = json.loads(response.content)
except ValueError, error:
self.fixture_log.exception(error)
def test_container_deletion_with_existing_empty_container(self):
container_name = '{0}_{1}'.format(
self.base_container_name,
randstring.get_random_string())
response = self.client.create_container(container_name)
self.addCleanup(
self.client.force_delete_containers,
[container_name])
self.assertEqual(response.status_code, 201, 'should be created')
response = self.client.delete_container(container_name)
self.assertEqual(response.status_code, 204, 'should be deleted')
response = self.client.list_objects(container_name)
self.assertEqual(
response.status_code,
404,
'should not exist after deletion')
def test_failure_reported_with_invalid_tar_archive(self):
"""
Scenario: Verify behavior when an invalid archive file is uploaded
Expected Results: Errors are reported. Objects are not created
"""
container_name = '{0}_container_{1}'.format(
BASE_NAME, randstring.get_random_string())
self.behaviors.create_container(container_name)
self.addCleanup(self.behaviors.force_delete_containers,
[container_name])
url = "{0}/{1}".format(self.storage_url, container_name)
params = {'extract-archive': 'tar'}
headers = {'Accept': 'application/json'}
response = self.client.put(url,
data=self.bad_data,
params=params,
headers=headers)
expected = HTTP_OK
received = response.status_code
self.assertEqual(
expected, received, "upload corrupted tar.gz expected"
" successful status code: {0} received: {1}".format(
expected, received))
# inspect the body of the response
content = None
try:
content = json.loads(response.content)
except ValueError, error:
self.fixture_log.exception(error)
def test_failure_reported_with_corrupt_tar_archive_bad_checksum(self):
"""
Scenario: Verify behavior when a corrupt archive file is uploaded.
Checksum is overwritten with Null Bytes.
Expected Results: Errors are reported. Objects are not created
"""
container_name = '{0}_container_{1}'.format(
BASE_NAME, randstring.get_random_string())
self.behaviors.create_container(container_name)
self.addCleanup(self.behaviors.force_delete_containers,
[container_name])
archive_format = "tar"
temp_data = self.read_archive_data(self.archive_paths[archive_format])
enumerated_data = enumerate(temp_data)
temp = []
for i, char in enumerated_data:
if (i >= TAR_CHKSUM_HEADER_OFFSET and i < TAR_CHKSUM_HEADER_END):
temp.append("\x00")
else:
temp.append(char)
data = ''.join(temp)
headers = {'Accept': 'application/json'}
response = self.client.create_archive_object(
data, archive_format, upload_path=container_name, headers=headers)
expected = HTTP_OK
received = response.status_code
self.assertEqual(
expected, received, "upload corrupted tar expected"
" successful status code: {0} received: {1}".format(
expected, received))
expected = 0
received = int(response.entity.num_files_created)
self.assertEqual(
expected,
received,
msg="response body 'Number Files Created' expected: {0}"
" received {1}".format(expected, received))
expected = '400 Bad Request'
received = response.entity.status
self.assertEqual(expected,
received,
msg="response body 'Response Status' expected: {0}"
" received {1}".format(expected, received))
expected = 0
received = len(response.entity.errors)
self.assertEqual(
expected,
received,
msg="response body 'Errors' expected None received {0}".format(
response.entity.errors))
expected = 'Invalid Tar File: bad checksum'
received = response.entity.body
self.assertIn(expected,
received,
msg=("response body 'Response Body' expected '{0}'"
" received {1}").format(expected,
response.entity.body))
def test_failure_reported_with_corrupt_tar_archive_bad_checksum(self):
"""
Scenario: Verify behavior when a corrupt archive file is uploaded.
Checksum is overwritten with Null Bytes.
Expected Results: Errors are reported. Objects are not created
"""
container_name = '{0}_container_{1}'.format(
BASE_NAME,
randstring.get_random_string())
self.behaviors.create_container(container_name)
self.addCleanup(
self.behaviors.force_delete_containers,
[container_name])
archive_format = "tar"
temp_data = self.read_archive_data(self.archive_paths[archive_format])
enumerated_data = enumerate(temp_data)
temp = []
for i, char in enumerated_data:
if (i >= TAR_CHKSUM_HEADER_OFFSET and i < TAR_CHKSUM_HEADER_END):
temp.append("\x00")
else:
temp.append(char)
data = ''.join(temp)
headers = {'Accept': 'application/json'}
response = self.client.create_archive_object(
data,
archive_format,
upload_path=container_name,
headers=headers)
expected = HTTP_OK
received = response.status_code
self.assertEqual(
expected,
received,
"upload corrupted tar expected"
" successful status code: {0} received: {1}".format(
expected,
received))
expected = 0
received = int(response.entity.num_files_created)
self.assertEqual(
expected,
received,
msg="response body 'Number Files Created' expected: {0}"
" received {1}".format(expected, received))
expected = '400 Bad Request'
received = response.entity.status
self.assertEqual(
expected,
received,
msg="response body 'Response Status' expected: {0}"
" received {1}".format(expected, received))
expected = 0
received = len(response.entity.errors)
self.assertEqual(
expected,
received,
msg="response body 'Errors' expected None received {0}".format(
response.entity.errors))
expected = 'Invalid Tar File: bad checksum'
received = response.entity.body
self.assertIn(
expected,
received,
msg=("response body 'Response Body' expected '{0}'"
" received {1}").format(expected, response.entity.body))
def test_psuedo_dirs_traversal(self):
container_name = "{0}_{1}".format(
CONTAINER_NAME,
randstring.get_random_string())
content_length = str(len(self.default_obj_data))
headers = {"Content-Length": content_length,
"Content-Type": CONTENT_TYPE_TEXT}
base_name = "music/the_best_of_grok_and_drok/grok_live/"
vol1_obj1 = "{0}{1}".format(base_name, "vol_1/rage_against_the_foo")
vol1_obj2 = "{0}{1}".format(base_name, "vol_1/a_fist_full_of_foo")
vol1_obj3 = "{0}{1}".format(base_name, "vol_1/nevermind_the_foo")
vol2_obj1 = "{0}{1}".format(base_name, "vol_2/iron_foo")
vol2_obj2 = "{0}{1}".format(base_name, "vol_2/foo_master")
self.behaviors.create_object(
container_name,
vol1_obj1,
data=self.default_obj_data,
headers=headers)
self.behaviors.create_object(
container_name,
vol1_obj2,
data=self.default_obj_data,
headers=headers)
self.behaviors.create_object(
container_name,
vol1_obj3,
data=self.default_obj_data,
headers=headers)
self.behaviors.create_object(
container_name,
vol2_obj1,
data=self.default_obj_data,
headers=headers)
self.behaviors.create_object(
container_name,
vol2_obj2,
data=self.default_obj_data,
headers=headers)
self.addCleanup(
self.behaviors.force_delete_containers,
[container_name])
delimiter = "/"
prefix = "music/"
params = {"prefix": prefix, "delimiter": delimiter, "format": "json"}
response = self.client.list_objects(container_name, params=params)
members = self.get_members(["subdir", "name"], response.content)
expected = 1
received = len(members)
self.assertEqual(
expected,
received,
msg="container list with prefix: {0} and delimiter: {1}"
" expected: {2} members received: {3}".format(
prefix,
delimiter,
expected,
received))
obj_name = "music/the_best_of_grok_and_drok/"
self.assertIn(
obj_name,
members,
msg="object name: {0} was not found in response body:"
" {1}".format(obj_name, members))
prefix = "music/the_best_of_grok_and_drok/"
params = {"prefix": prefix, "delimiter": delimiter, "format": "json"}
response = self.client.list_objects(container_name, params=params)
members = self.get_members(["subdir", "name"], response.content)
expected = 1
received = len(members)
self.assertEqual(
expected,
received,
msg="container list with prefix: {0} and delimiter: {1}"
" expected: {2} members received: {3}".format(
prefix,
delimiter,
expected,
received))
obj_name = "music/the_best_of_grok_and_drok/grok_live/"
self.assertIn(
obj_name,
members,
msg="object name: {0} was not found in response body:"
" {1}".format(obj_name, members))
prefix = "music/the_best_of_grok_and_drok/grok_live/"
params = {"prefix": prefix, "delimiter": delimiter, "format": "json"}
response = self.client.list_objects(container_name, params=params)
members = self.get_members(["subdir", "name"], response.content)
expected = 2
received = len(members)
self.assertEqual(
expected,
received,
msg="container list with prefix: {0} and delimiter: {1}"
" expected: {2} members received: {3}".format(
prefix,
delimiter,
expected,
received))
obj_name = "music/the_best_of_grok_and_drok/grok_live/vol_1/"
self.assertIn(
obj_name,
members,
msg="object name: {0} was not found in response body:"
" {1}".format(obj_name, members))
obj_name = "music/the_best_of_grok_and_drok/grok_live/vol_2/"
self.assertIn(
obj_name,
members,
msg="object name: {0} was not found in response body:"
" {1}".format(obj_name, members))
prefix = "music/the_best_of_grok_and_drok/grok_live/vol_1/"
params = {"prefix": prefix, "delimiter": delimiter, "format": "json"}
response = self.client.list_objects(container_name, params=params)
members = self.get_members(["subdir", "name"], response.content)
expected = 3
received = len(members)
self.assertEqual(
expected,
received,
msg="container list with prefix: {0} and delimiter: {1}"
" expected: {2} members received: {3}".format(
prefix,
delimiter,
expected,
received))
self.assertIn(
vol1_obj1,
members,
msg="object name: {0} was not found in response body:"
" {1}".format(vol1_obj1, members))
self.assertIn(
vol1_obj2,
members,
msg="object name: {0} was not found in response body:"
" {1}".format(vol1_obj2, members))
self.assertIn(
vol1_obj3,
members,
msg="object name: {0} was not found in response body:"
" {1}".format(vol1_obj3, members))
prefix = "music/the_best_of_grok_and_drok/grok_live/vol_2/"
params = {"prefix": prefix, "delimiter": delimiter, "format": "json"}
response = self.client.list_objects(container_name, params=params)
members = self.get_members(["subdir", "name"], response.content)
expected = 2
received = len(members)
self.assertEqual(
expected,
received,
msg="container list with prefix: {0} and delimiter: {1}"
" expected: {2} members received: {3}".format(
prefix,
delimiter,
expected,
received))
self.assertIn(
vol2_obj1,
members,
msg="object name: {0} was not found in response body:"
" {1}".format(vol2_obj1, members))
self.assertIn(
vol2_obj2,
members,
msg="object name: {0} was not found in response body:"
" {1}".format(vol2_obj2, members))
def test_psuedo_dirs_with_path_query_parameter(self):
"""
This is a depricated feature that has little documentation.
The following things need to be done for the path parameter to work.
1. For every "directory" a "directory marker" must be added as a
object. The directory marker does not need to contain data, and
thus can have a length of 0.
Example:
If you want a directory "foo/bar/", you would upload a object
named "foo/bar/" to your container.
2. You must upload your objects, prefixed with the "directory" path.
Example:
If you wanted to create an object in "foo/" and another in
"foo/bar/", you would have to name the objects as follows:
foo/object1.txt
foo/bar/object2.txt
3. Once this has been done, you can use the path query string
parameter to list the objects in the simulated directory structure.
Example:
Using the above examples, setting path to "foo/" should list
the following:
foo/object1.txt
foo/bar/
"""
container_name = "{0}_{1}".format(
CONTAINER_NAME,
randstring.get_random_string())
self.behaviors.create_container(container_name)
self.addCleanup(
self.behaviors.force_delete_containers,
[container_name])
"""
create dir markers
"""
dir_marker_headers = {"Content-Length": "0"}
lvl1_dir_marker = "level_1/"
lvl2_dir_marker = "level_1/level_2/"
lvl3_dir_marker = "level_1/level_2/level_3/"
self.client.create_object(
container_name,
lvl1_dir_marker,
headers=dir_marker_headers)
self.client.create_object(
container_name,
lvl2_dir_marker,
headers=dir_marker_headers)
self.client.create_object(
container_name,
lvl3_dir_marker,
headers=dir_marker_headers)
"""
create objects
"""
headers = {"Content-Length": str(len(self.default_obj_data)),
"Content-Type": CONTENT_TYPE_TEXT}
"""
level 1 objects
"""
lvl1_obj1 = "{0}{1}".format(lvl1_dir_marker, "lvl1_obj1")
lvl1_obj2 = "{0}{1}".format(lvl1_dir_marker, "lvl1_obj2")
self.client.create_object(
container_name,
lvl1_obj1,
headers=headers,
data=self.default_obj_data)
self.client.create_object(
container_name,
lvl1_obj2,
headers=headers,
data=self.default_obj_data)
"""
level 2 objects
"""
lvl2_obj1 = "{0}{1}".format(lvl2_dir_marker, "lvl2_obj1")
lvl2_obj2 = "{0}{1}".format(lvl2_dir_marker, "lvl2_obj2")
self.client.create_object(
container_name,
lvl2_obj1,
headers=headers,
data=self.default_obj_data)
self.client.create_object(
container_name,
lvl2_obj2,
headers=headers,
data=self.default_obj_data)
"""
level 3 objects
"""
lvl3_obj1 = "{0}{1}".format(lvl3_dir_marker, "lvl3_obj1")
lvl3_obj2 = "{0}{1}".format(lvl3_dir_marker, "lvl3_obj2")
self.client.create_object(
container_name,
lvl3_obj1,
headers=headers,
data=self.default_obj_data)
self.client.create_object(
container_name,
lvl3_obj2,
headers=headers,
data=self.default_obj_data)
"""
list objects
"""
params = {"path": lvl1_dir_marker, "format": "json"}
response = self.client.list_objects(container_name, params=params)
members = self.get_members(["name"], response.content)
expected = 3
received = len(members)
self.assertEqual(
expected,
received,
msg="container list with path: {0} expected: {1} members"
" received: {2}".format(lvl1_dir_marker, expected, received))
self.assertIn(
lvl2_dir_marker,
members,
msg="object name: {0} was not found in response body:"
" {1}".format(lvl2_dir_marker, members))
self.assertIn(
lvl1_obj1,
members,
msg="object name: {0} was not found in response body:"
" {1}".format(lvl1_obj1, members))
self.assertIn(
lvl1_obj2,
members,
msg="object name: {0} was not found in response body:"
" {1}".format(lvl1_obj2, members))
params = {"path": lvl2_dir_marker, "format": "json"}
response = self.client.list_objects(container_name, params=params)
members = self.get_members(["name"], response.content)
expected = 3
received = len(members)
self.assertEqual(
expected,
received,
msg="container list with path: {0} expected: {1} members"
" received: {2}".format(lvl3_dir_marker, expected, received))
self.assertIn(
lvl3_dir_marker,
members,
msg="object name: {0} was not found in response body:"
" {1}".format(lvl3_dir_marker, members))
self.assertIn(
lvl2_obj1,
members,
msg="object name: {0} was not found in response body:"
" {1}".format(lvl2_obj1, members))
self.assertIn(
lvl2_obj2,
members,
msg="object name: {0} was not found in response body:"
" {1}".format(lvl2_obj2, members))
params = {"path": lvl3_dir_marker, "format": "json"}
response = self.client.list_objects(container_name, params=params)
members = self.get_members(["name"], response.content)
expected = 2
received = len(members)
self.assertEqual(
expected,
received,
msg="container list with path: {0} expected: {1} members"
" received: {2}".format(lvl1_dir_marker, expected, received))
self.assertIn(
lvl3_obj1,
members,
msg="object name: {0} was not found in response body:"
" {1}".format(lvl3_obj1, members))
self.assertIn(
lvl3_obj2,
members,
msg="object name: {0} was not found in response body:"
" {1}".format(lvl3_obj2, members))
def test_objects_list_with_path_query_parameter(self):
"""
This is a depricated feature that has little documentation.
The following things need to be done for the path parameter to work.
1. For every 'directory' a 'directory marker' must be added as a
object. The directory marker does not need to contain data, and
thus can have a length of 0.
Example:
If you want a directory 'foo/bar/', you would upload a object
named 'foo/bar/' to your container.
2. You must upload your objects, prefixed with the 'directory' path.
Example:
If you wanted to create an object in 'foo/' and another in
'foo/bar/', you would have to name the objects as follows:
foo/object1.txt
foo/bar/object2.txt
3. Once this has been done, you can use the path query string
parameter to list the objects in the simulated directory structure.
Example:
Using the above examples, setting path to 'foo/' should list
the following:
foo/objet1.txt
foo/bar/
"""
container_name = '{0}_{1}'.format(
self.base_container_name,
randstring.get_random_string())
self.client.create_container(container_name)
self.addCleanup(
self.client.force_delete_containers,
[container_name])
dir_marker = 'path_test/'
headers = {'Content-Length': '0'}
self.client.create_object(
container_name,
dir_marker,
headers=headers)
dir_marker = 'path_test/nested_dir/'
headers = {'Content-Length': '0'}
self.client.create_object(
container_name,
dir_marker,
headers=headers)
object_data = 'Test file data'
content_length = str(len(object_data))
object_name_prefix = 'path_test/nested_dir/'
object_name_postfix = '{0}_{1}'.format(
self.base_object_name,
randstring.get_random_string())
object_name = '{0}{1}'.format(object_name_prefix, object_name_postfix)
headers = {'Content-Length': content_length,
'Content-Type': CONTENT_TYPE_TEXT}
self.client.create_object(
container_name,
object_name,
headers=headers,
data=object_data)
params = {'path': 'path_test/'}
response = self.client.list_objects(container_name, params=params)
method = "simulated directory list"
expected = 200
received = response.status_code
self.assertEqual(
expected,
received,
msg=STATUS_CODE_MSG.format(
method=method,
expected=expected,
received=str(received)))
params = {'path': 'path_test/nested_dir/'}
response = self.client.list_objects(container_name, params=params)
method = "simulated obj in directory list"
expected = 200
received = response.status_code
self.assertEqual(
expected,
received,
msg=STATUS_CODE_MSG.format(
method=method,
expected=expected,
received=str(received)))
def setUpClass(cls):
super(ObjectVersioningTest, cls).setUpClass()
cls.container_name = CONTAINER_NAME
cls.object_name = "{0}_{1}".format(cls.behaviors.VALID_OBJECT_NAME,
randstring.get_random_string())
def test_objects_list_with_path_query_parameter(self):
"""
This is a depricated feature that has little documentation.
The following things need to be done for the path parameter to work.
1. For every 'directory' a 'directory marker' must be added as a
object. The directory marker does not need to contain data, and
thus can have a length of 0.
Example:
If you want a directory 'foo/bar/', you would upload a object
named 'foo/bar/' to your container.
2. You must upload your objects, prefixed with the 'directory' path.
Example:
If you wanted to create an object in 'foo/' and another in
'foo/bar/', you would have to name the objects as follows:
foo/object1.txt
foo/bar/object2.txt
3. Once this has been done, you can use the path query string
parameter to list the objects in the simulated directory structure.
Example:
Using the above examples, setting path to 'foo/' should list
the following:
foo/objet1.txt
foo/bar/
"""
container_name = self.behaviors.generate_unique_container_name(
self.base_container_name)
self.client.create_container(container_name)
self.addCleanup(self.behaviors.force_delete_containers,
[container_name])
dir_marker = 'path_test/'
headers = {'Content-Length': '0'}
self.client.create_object(container_name, dir_marker, headers=headers)
dir_marker = 'path_test/nested_dir/'
headers = {'Content-Length': '0'}
self.client.create_object(container_name, dir_marker, headers=headers)
object_data = 'Test file data'
content_length = str(len(object_data))
object_name_prefix = 'path_test/nested_dir/'
object_name_postfix = 'object_{0}'.format(
randstring.get_random_string())
object_name = '{0}{1}'.format(object_name_prefix, object_name_postfix)
headers = {
'Content-Length': content_length,
'Content-Type': CONTENT_TYPE_TEXT
}
self.client.create_object(container_name,
object_name,
headers=headers,
data=object_data)
params = {'path': 'path_test/'}
response = self.client.list_objects(container_name, params=params)
method = "simulated directory list"
expected = 200
received = response.status_code
self.assertEqual(expected,
received,
msg=STATUS_CODE_MSG.format(method=method,
expected=expected,
received=str(received)))
params = {'path': 'path_test/nested_dir/'}
response = self.client.list_objects(container_name, params=params)
method = "simulated obj in directory list"
expected = 200
received = response.status_code
self.assertEqual(expected,
received,
msg=STATUS_CODE_MSG.format(method=method,
expected=expected,
received=str(received)))
def rand_name(name='test'):
return "{name}{suffix}".format(name=name,
suffix=randomstring.get_random_string())
def rand_name(name='test'):
return "cloudroast-{name}{suffix}".format(
name=name, suffix=randomstring.get_random_string())
