Revision 95e0d8ee pithos/tools/pithos-test
| b/pithos/tools/pithos-test | ||
|---|---|---|
| 1374 | 1374 |
self.obj = self.upload_random_data(self.containers[0], o_names[0]) |
| 1375 | 1375 |
|
| 1376 | 1376 |
def test_move(self): |
| 1377 |
meta = self.client.retrieve_object_metadata(self.containers[0], |
|
| 1378 |
self.obj['name']) |
|
| 1379 |
self.assertTrue('x-object-uuid' in meta)
|
|
| 1380 |
uuid = meta['x-object-uuid'] |
|
| 1381 |
|
|
| 1377 | 1382 |
#perform move |
| 1378 | 1383 |
meta = {'test':'testcopy'}
|
| 1379 | 1384 |
src_path = '/'.join(('/', self.containers[0], self.obj['name']))
|
| ... | ... | |
| 1386 | 1391 |
|
| 1387 | 1392 |
#assert updated metadata |
| 1388 | 1393 |
meta = self.client.retrieve_object_metadata(self.containers[0], |
| 1389 |
'testcopy', |
|
| 1390 |
restricted=True) |
|
| 1391 |
self.assertTrue('test' in meta.keys())
|
|
| 1392 |
self.assertTrue(meta['test'], 'testcopy') |
|
| 1394 |
'testcopy') |
|
| 1395 |
self.assertTrue('x-object-meta-test' in meta.keys())
|
|
| 1396 |
self.assertTrue(meta['x-object-meta-test'], 'testcopy') |
|
| 1397 |
|
|
| 1398 |
#assert same uuid |
|
| 1399 |
self.assertTrue(meta['x-object-uuid'], uuid) |
|
| 1393 | 1400 |
|
| 1394 | 1401 |
#assert src object no more exists |
| 1395 | 1402 |
self.assert_object_not_exists(self.containers[0], self.obj['name']) |
| ... | ... | |
| 1405 | 1412 |
self.obj.append(self.upload_random_data(self.containers[0], o_names[i])) |
| 1406 | 1413 |
|
| 1407 | 1414 |
def test_update_meta(self): |
| 1408 |
#perform update metadata |
|
| 1409 |
more = {'foo':'foo', 'bar':'bar'}
|
|
| 1410 |
status = self.client.update_object_metadata(self.containers[0], |
|
| 1411 |
self.obj[0]['name'], |
|
| 1412 |
**more)[0] |
|
| 1413 |
#assert request accepted |
|
| 1414 |
self.assertEqual(status, 202) |
|
| 1415 |
|
|
| 1416 |
#assert old metadata are still there |
|
| 1417 |
headers = self.client.retrieve_object_metadata(self.containers[0], |
|
| 1418 |
self.obj[0]['name'], |
|
| 1419 |
restricted=True) |
|
| 1420 |
#assert new metadata have been updated |
|
| 1421 |
for k,v in more.items(): |
|
| 1422 |
self.assertTrue(k in headers.keys()) |
|
| 1423 |
self.assertTrue(headers[k], v) |
|
| 1415 |
with AssertUUidInvariant(self.client.retrieve_object_metadata, |
|
| 1416 |
self.containers[0], |
|
| 1417 |
self.obj[0]['name']): |
|
| 1418 |
#perform update metadata |
|
| 1419 |
more = {'foo':'foo', 'bar':'bar'}
|
|
| 1420 |
status = self.client.update_object_metadata(self.containers[0], |
|
| 1421 |
self.obj[0]['name'], |
|
| 1422 |
**more)[0] |
|
| 1423 |
#assert request accepted |
|
| 1424 |
self.assertEqual(status, 202) |
|
| 1425 |
|
|
| 1426 |
#assert old metadata are still there |
|
| 1427 |
headers = self.client.retrieve_object_metadata(self.containers[0], |
|
| 1428 |
self.obj[0]['name'], |
|
| 1429 |
restricted=True) |
|
| 1430 |
#assert new metadata have been updated |
|
| 1431 |
for k,v in more.items(): |
|
| 1432 |
self.assertTrue(k in headers.keys()) |
|
| 1433 |
self.assertTrue(headers[k], v) |
|
| 1424 | 1434 |
|
| 1425 | 1435 |
def test_update_object(self, |
| 1426 | 1436 |
first_byte_pos=0, |
| 1427 | 1437 |
last_byte_pos=499, |
| 1428 | 1438 |
instance_length = True, |
| 1429 | 1439 |
content_length = 500): |
| 1430 |
l = len(self.obj[0]['data']) |
|
| 1431 |
range = 'bytes %d-%d/%s' %(first_byte_pos, |
|
| 1432 |
last_byte_pos, |
|
| 1433 |
l if instance_length else '*') |
|
| 1434 |
partial = last_byte_pos - first_byte_pos + 1 |
|
| 1435 |
length = first_byte_pos + partial |
|
| 1436 |
data = get_random_data(partial) |
|
| 1437 |
args = {'content_type':'application/octet-stream',
|
|
| 1438 |
'content_range':'%s' %range} |
|
| 1439 |
if content_length: |
|
| 1440 |
args['content_length'] = content_length |
|
| 1441 |
|
|
| 1442 |
status = self.client.update_object(self.containers[0], self.obj[0]['name'], |
|
| 1443 |
StringIO(data), **args)[0] |
|
| 1444 |
|
|
| 1445 |
if partial < 0 or (instance_length and l <= last_byte_pos): |
|
| 1446 |
self.assertEqual(status, 202) |
|
| 1447 |
else: |
|
| 1448 |
self.assertEqual(status, 204) |
|
| 1449 |
#check modified object |
|
| 1450 |
content = self.client.retrieve_object(self.containers[0], |
|
| 1451 |
self.obj[0]['name']) |
|
| 1452 |
self.assertEqual(content[:first_byte_pos], self.obj[0]['data'][:first_byte_pos]) |
|
| 1453 |
self.assertEqual(content[first_byte_pos:last_byte_pos+1], data) |
|
| 1454 |
self.assertEqual(content[last_byte_pos+1:], self.obj[0]['data'][last_byte_pos+1:]) |
|
| 1440 |
with AssertUUidInvariant(self.client.retrieve_object_metadata, |
|
| 1441 |
self.containers[0], |
|
| 1442 |
self.obj[0]['name']): |
|
| 1443 |
l = len(self.obj[0]['data']) |
|
| 1444 |
range = 'bytes %d-%d/%s' %(first_byte_pos, |
|
| 1445 |
last_byte_pos, |
|
| 1446 |
l if instance_length else '*') |
|
| 1447 |
partial = last_byte_pos - first_byte_pos + 1 |
|
| 1448 |
length = first_byte_pos + partial |
|
| 1449 |
data = get_random_data(partial) |
|
| 1450 |
args = {'content_type':'application/octet-stream',
|
|
| 1451 |
'content_range':'%s' %range} |
|
| 1452 |
if content_length: |
|
| 1453 |
args['content_length'] = content_length |
|
| 1454 |
|
|
| 1455 |
status = self.client.update_object(self.containers[0], self.obj[0]['name'], |
|
| 1456 |
StringIO(data), **args)[0] |
|
| 1457 |
|
|
| 1458 |
if partial < 0 or (instance_length and l <= last_byte_pos): |
|
| 1459 |
self.assertEqual(status, 202) |
|
| 1460 |
else: |
|
| 1461 |
self.assertEqual(status, 204) |
|
| 1462 |
#check modified object |
|
| 1463 |
content = self.client.retrieve_object(self.containers[0], |
|
| 1464 |
self.obj[0]['name']) |
|
| 1465 |
self.assertEqual(content[:first_byte_pos], self.obj[0]['data'][:first_byte_pos]) |
|
| 1466 |
self.assertEqual(content[first_byte_pos:last_byte_pos+1], data) |
|
| 1467 |
self.assertEqual(content[last_byte_pos+1:], self.obj[0]['data'][last_byte_pos+1:]) |
|
| 1455 | 1468 |
|
| 1456 | 1469 |
def test_update_object_lt_blocksize(self): |
| 1457 | 1470 |
self.test_update_object(10, 20, content_length=None) |
| ... | ... | |
| 1998 | 2011 |
data = public_client.get(url)[2] |
| 1999 | 2012 |
self.assertEqual(o_data, data) |
| 2000 | 2013 |
|
| 2014 |
class AssertUUidInvariant(object): |
|
| 2015 |
def __init__(self, callable, *args, **kwargs): |
|
| 2016 |
self.callable = callable |
|
| 2017 |
self.args = args |
|
| 2018 |
self.kwargs = kwargs |
|
| 2019 |
|
|
| 2020 |
def __enter__(self): |
|
| 2021 |
self.map = self.callable(*self.args, **self.kwargs) |
|
| 2022 |
assert('x-object-uuid' in self.map)
|
|
| 2023 |
self.uuid = self.map['x-object-uuid'] |
|
| 2024 |
return self.map |
|
| 2025 |
|
|
| 2026 |
def __exit__(self, type, value, tb): |
|
| 2027 |
map = self.callable(*self.args, **self.kwargs) |
|
| 2028 |
assert('x-object-uuid' in self.map)
|
|
| 2029 |
uuid = map['x-object-uuid'] |
|
| 2030 |
assert(uuid == self.uuid) |
|
| 2031 |
|
|
| 2001 | 2032 |
class AssertMappingInvariant(object): |
| 2002 | 2033 |
def __init__(self, callable, *args, **kwargs): |
| 2003 | 2034 |
self.callable = callable |
| ... | ... | |
| 2010 | 2041 |
|
| 2011 | 2042 |
def __exit__(self, type, value, tb): |
| 2012 | 2043 |
map = self.callable(*self.args, **self.kwargs) |
| 2013 |
for k in self.map.keys():
|
|
| 2014 |
if is_date(self.map[k]):
|
|
| 2044 |
for k, v in self.map.items():
|
|
| 2045 |
if is_date(v):
|
|
| 2015 | 2046 |
continue |
| 2016 |
assert map[k] == self.map[k] |
|
| 2017 |
|
|
| 2047 |
print '#', k, v, map[k] |
|
| 2048 |
assert(k in map) |
|
| 2049 |
assert v == map[k] |
|
| 2050 |
|
|
| 2018 | 2051 |
class AssertContentInvariant(object): |
| 2019 | 2052 |
def __init__(self, callable, *args, **kwargs): |
| 2020 | 2053 |
self.callable = callable |
Also available in: Unified diff