Revision e3268281 snf-pithos-tools/pithos/tools/test.py
| b/snf-pithos-tools/pithos/tools/test.py | ||
|---|---|---|
| 71 | 71 |
#TODO unauthorized request |
| 72 | 72 |
def setUp(self): |
| 73 | 73 |
self.client = Pithos_Client(get_url(), get_auth(), get_user()) |
| 74 |
|
|
| 74 |
|
|
| 75 | 75 |
#keep track of initial containers |
| 76 | 76 |
self.initial_containers = self.client.list_containers() |
| 77 | 77 |
if self.initial_containers == '': |
| 78 | 78 |
self.initial_containers = [] |
| 79 |
|
|
| 79 |
|
|
| 80 | 80 |
self._clean_account() |
| 81 | 81 |
self.invalid_client = Pithos_Client(get_url(), get_auth(), 'invalid') |
| 82 | 82 |
|
| ... | ... | |
| 85 | 85 |
|
| 86 | 86 |
#keep track of initial account meta |
| 87 | 87 |
self.initial_meta = self.client.retrieve_account_metadata(restricted=True) |
| 88 |
|
|
| 88 |
|
|
| 89 | 89 |
self.extended = {
|
| 90 | 90 |
'container':( |
| 91 | 91 |
'name', |
| ... | ... | |
| 123 | 123 |
# if c not in self.initial_containers: |
| 124 | 124 |
self.client.delete_container(c, delimiter='/') |
| 125 | 125 |
self.client.delete_container(c) |
| 126 |
|
|
| 126 |
|
|
| 127 | 127 |
def assert_status(self, status, codes): |
| 128 | 128 |
l = [elem for elem in self.return_codes] |
| 129 | 129 |
if type(codes) == types.ListType: |
| ... | ... | |
| 264 | 264 |
BaseTestCase.setUp(self) |
| 265 | 265 |
self.containers = list(set(self.initial_containers + ['apples', 'bananas', 'kiwis', 'oranges', 'pears'])) |
| 266 | 266 |
self.containers.sort() |
| 267 |
|
|
| 267 |
|
|
| 268 | 268 |
for item in self.containers: |
| 269 | 269 |
self.client.create_container(item) |
| 270 | 270 |
|
| ... | ... | |
| 320 | 320 |
#create some containers |
| 321 | 321 |
self.containers = list(set(self.initial_containers + ['apples', 'bananas', 'kiwis', 'oranges', 'pears'])) |
| 322 | 322 |
self.containers.sort() |
| 323 |
|
|
| 323 |
|
|
| 324 | 324 |
for item in self.containers: |
| 325 | 325 |
self.client.create_container(item) |
| 326 | 326 |
|
| ... | ... | |
| 382 | 382 |
self.assertEqual(len(c), len(self.containers) + 1) |
| 383 | 383 |
except Fault, f: |
| 384 | 384 |
self.failIf(f.status == 304) #fail if not modified |
| 385 |
|
|
| 385 |
|
|
| 386 | 386 |
def test_if_modified_since_invalid_date(self): |
| 387 | 387 |
c = self.client.list_containers(if_modified_since='') |
| 388 | 388 |
self.assertEqual(len(c), len(self.containers)) |
| ... | ... | |
| 427 | 427 |
BaseTestCase.setUp(self) |
| 428 | 428 |
self.containers = list(set(self.initial_containers + ['apples', 'bananas', 'kiwis', 'oranges', 'pears'])) |
| 429 | 429 |
self.containers.sort() |
| 430 |
|
|
| 430 |
|
|
| 431 | 431 |
for item in self.containers: |
| 432 | 432 |
self.client.create_container(item) |
| 433 | 433 |
|
| ... | ... | |
| 546 | 546 |
self.obj.append(self.upload_random_data(self.container[0], o)) |
| 547 | 547 |
for o in o_names[8:]: |
| 548 | 548 |
self.obj.append(self.upload_random_data(self.container[1], o)) |
| 549 |
|
|
| 549 |
|
|
| 550 | 550 |
def test_list_shared(self): |
| 551 | 551 |
self.client.share_object(self.container[0], self.obj[0]['name'], ('*',))
|
| 552 | 552 |
objs = self.client.list_objects(self.container[0], shared=True) |
| 553 | 553 |
self.assertEqual(objs, [self.obj[0]['name']]) |
| 554 |
|
|
| 554 |
|
|
| 555 | 555 |
# create child object |
| 556 | 556 |
self.upload_random_data(self.container[0], strnextling(self.obj[0]['name'])) |
| 557 | 557 |
objs = self.client.list_objects(self.container[0], shared=True) |
| 558 | 558 |
self.assertEqual(objs, [self.obj[0]['name']]) |
| 559 |
|
|
| 559 |
|
|
| 560 | 560 |
# test inheritance |
| 561 | 561 |
self.client.create_folder(self.container[1], 'folder') |
| 562 | 562 |
self.client.share_object(self.container[1], 'folder', ('*',))
|
| 563 | 563 |
self.upload_random_data(self.container[1], 'folder/object') |
| 564 | 564 |
objs = self.client.list_objects(self.container[1], shared=True) |
| 565 | 565 |
self.assertEqual(objs, ['folder', 'folder/object']) |
| 566 |
|
|
| 566 |
|
|
| 567 | 567 |
def test_list_public(self): |
| 568 | 568 |
self.client.publish_object(self.container[0], self.obj[0]['name']) |
| 569 | 569 |
objs = self.client.list_objects(self.container[0], public=True) |
| 570 | 570 |
self.assertEqual(objs, [self.obj[0]['name']]) |
| 571 |
|
|
| 571 |
|
|
| 572 | 572 |
# create child object |
| 573 | 573 |
self.upload_random_data(self.container[0], strnextling(self.obj[0]['name'])) |
| 574 | 574 |
objs = self.client.list_objects(self.container[0], public=True) |
| 575 | 575 |
self.assertEqual(objs, [self.obj[0]['name']]) |
| 576 |
|
|
| 576 |
|
|
| 577 | 577 |
# test inheritance |
| 578 | 578 |
self.client.create_folder(self.container[1], 'folder') |
| 579 | 579 |
self.client.publish_object(self.container[1], 'folder') |
| 580 | 580 |
self.upload_random_data(self.container[1], 'folder/object') |
| 581 | 581 |
objs = self.client.list_objects(self.container[1], public=True) |
| 582 | 582 |
self.assertEqual(objs, ['folder']) |
| 583 |
|
|
| 583 |
|
|
| 584 | 584 |
def test_list_shared_public(self): |
| 585 | 585 |
self.client.share_object(self.container[0], self.obj[0]['name'], ('*',))
|
| 586 | 586 |
self.client.publish_object(self.container[0], self.obj[1]['name']) |
| 587 | 587 |
objs = self.client.list_objects(self.container[0], shared=True, public=True) |
| 588 | 588 |
self.assertEqual(objs, [self.obj[0]['name'], self.obj[1]['name']]) |
| 589 |
|
|
| 589 |
|
|
| 590 | 590 |
# create child object |
| 591 | 591 |
self.upload_random_data(self.container[0], strnextling(self.obj[0]['name'])) |
| 592 | 592 |
self.upload_random_data(self.container[0], strnextling(self.obj[1]['name'])) |
| 593 | 593 |
objs = self.client.list_objects(self.container[0], shared=True, public=True) |
| 594 | 594 |
self.assertEqual(objs, [self.obj[0]['name'], self.obj[1]['name']]) |
| 595 |
|
|
| 595 |
|
|
| 596 | 596 |
# test inheritance |
| 597 | 597 |
self.client.create_folder(self.container[1], 'folder1') |
| 598 | 598 |
self.client.share_object(self.container[1], 'folder1', ('*',))
|
| ... | ... | |
| 602 | 602 |
o = self.upload_random_data(self.container[1], 'folder2/object') |
| 603 | 603 |
objs = self.client.list_objects(self.container[1], shared=True, public=True) |
| 604 | 604 |
self.assertEqual(objs, ['folder1', 'folder1/object', 'folder2']) |
| 605 |
|
|
| 605 |
|
|
| 606 | 606 |
def test_list_objects(self): |
| 607 | 607 |
objects = self.client.list_objects(self.container[0]) |
| 608 | 608 |
l = [elem['name'] for elem in self.obj[:8]] |
| ... | ... | |
| 796 | 796 |
BaseTestCase.setUp(self) |
| 797 | 797 |
self.containers = list(set(self.initial_containers + ['c1', 'c2'])) |
| 798 | 798 |
self.containers.sort() |
| 799 |
|
|
| 799 |
|
|
| 800 | 800 |
def test_create(self): |
| 801 | 801 |
self.client.create_container(self.containers[0]) |
| 802 | 802 |
containers = self.client.list_containers() |
| ... | ... | |
| 846 | 846 |
BaseTestCase.setUp(self) |
| 847 | 847 |
self.containers = list(set(self.initial_containers + ['c1', 'c2'])) |
| 848 | 848 |
self.containers.sort() |
| 849 |
|
|
| 849 |
|
|
| 850 | 850 |
for c in self.containers: |
| 851 | 851 |
self.client.create_container(c) |
| 852 | 852 |
|
| ... | ... | |
| 861 | 861 |
|
| 862 | 862 |
def test_delete_invalid(self): |
| 863 | 863 |
self.assert_raises_fault(404, self.client.delete_container, 'c3') |
| 864 |
|
|
| 864 |
|
|
| 865 | 865 |
def test_delete_contents(self): |
| 866 | 866 |
self.client.create_folder(self.containers[0], 'folder-1') |
| 867 | 867 |
self.upload_random_data(self.containers[1], 'folder-1/%s' % o_names[0]) |
| 868 | 868 |
self.client.create_folder(self.containers[0], 'folder-1/subfolder') |
| 869 | 869 |
self.client.create_folder(self.containers[0], 'folder-2/%s' % o_names[1]) |
| 870 |
|
|
| 870 |
|
|
| 871 | 871 |
objects = self.client.list_objects(self.containers[0]) |
| 872 | 872 |
self.client.delete_container(self.containers[0], delimiter='/') |
| 873 | 873 |
for o in objects: |
| ... | ... | |
| 879 | 879 |
BaseTestCase.setUp(self) |
| 880 | 880 |
self.containers = list(set(self.initial_containers + ['c1', 'c2'])) |
| 881 | 881 |
self.containers.sort() |
| 882 |
|
|
| 882 |
|
|
| 883 | 883 |
#create some containers |
| 884 | 884 |
for c in self.containers: |
| 885 | 885 |
self.client.create_container(c) |
| ... | ... | |
| 911 | 911 |
restricted=True, |
| 912 | 912 |
version=v) |
| 913 | 913 |
(self.assertTrue(k not in v_meta) for k in meta.keys()) |
| 914 |
|
|
| 914 |
|
|
| 915 | 915 |
#update obejct |
| 916 | 916 |
data = get_random_data() |
| 917 | 917 |
self.client.update_object(c, o['name'], StringIO(data)) |
| 918 |
|
|
| 918 |
|
|
| 919 | 919 |
aa = self.client.retrieve_object_versionlist(c, o['name'])['versions'] |
| 920 | 920 |
self.assert_versionlist_structure(aa) |
| 921 | 921 |
self.assertEqual(len(a)+1, len(aa)) |
| ... | ... | |
| 1347 | 1347 |
self.assert_object_exists(self.container, 'large-object') |
| 1348 | 1348 |
self.assertEqual(data, self.client.retrieve_object(self.container, |
| 1349 | 1349 |
'large-object')) |
| 1350 |
|
|
| 1350 |
|
|
| 1351 | 1351 |
r = self.client.retrieve_object_hashmap(self.container,'large-object') |
| 1352 | 1352 |
hashes = r['hashes'] |
| 1353 | 1353 |
block_size = int(r['block_size']) |
| ... | ... | |
| 1355 | 1355 |
l = len(data) |
| 1356 | 1356 |
block_num = l/block_size if l/block_size != 0 else l/block_size + 1 |
| 1357 | 1357 |
self.assertEqual(block_num, len(hashes)) |
| 1358 |
|
|
| 1358 |
|
|
| 1359 | 1359 |
#wrong manifestation |
| 1360 | 1360 |
self.client.create_manifestation(self.container, 'large-object', |
| 1361 | 1361 |
'%s/invalid' % self.container) |
| ... | ... | |
| 1392 | 1392 |
BaseTestCase.setUp(self) |
| 1393 | 1393 |
self.containers = list(set(self.initial_containers + ['c1', 'c2'])) |
| 1394 | 1394 |
self.containers.sort() |
| 1395 |
|
|
| 1395 |
|
|
| 1396 | 1396 |
for c in self.containers: |
| 1397 | 1397 |
self.client.create_container(c) |
| 1398 | 1398 |
self.obj = self.upload_random_data(self.containers[0], o_names[0]) |
| ... | ... | |
| 1455 | 1455 |
self.assert_raises_fault(404, self.client.copy_object, self.containers[1], |
| 1456 | 1456 |
self.obj['name'], self.containers[1], |
| 1457 | 1457 |
'testcopy', meta) |
| 1458 |
|
|
| 1458 |
|
|
| 1459 | 1459 |
def test_copy_dir(self): |
| 1460 | 1460 |
self.client.create_folder(self.containers[0], 'dir') |
| 1461 | 1461 |
self.client.create_folder(self.containers[0], 'dir/subdir') |
| 1462 | 1462 |
self.upload_random_data(self.containers[0], 'dir/object1.jpg', length=1024) |
| 1463 | 1463 |
self.upload_random_data(self.containers[0], 'dir/subdir/object2.pdf', length=2*1024) |
| 1464 | 1464 |
self.client.create_folder(self.containers[0], 'dirs') |
| 1465 |
|
|
| 1465 |
|
|
| 1466 | 1466 |
objects = self.client.list_objects(self.containers[0], prefix='dir') |
| 1467 | 1467 |
self.client.copy_object(self.containers[0], 'dir', self.containers[1], 'dir-backup', delimiter='/') |
| 1468 | 1468 |
for object in objects[:-1]: |
| ... | ... | |
| 1473 | 1473 |
t = ('content-length', 'x-object-hash', 'content-type')
|
| 1474 | 1474 |
(self.assertEqual(meta0[elem], meta1[elem]) for elem in t) |
| 1475 | 1475 |
self.assert_object_not_exists(self.containers[1], objects[-1]) |
| 1476 |
|
|
| 1476 |
|
|
| 1477 | 1477 |
class ObjectMove(BaseTestCase): |
| 1478 | 1478 |
def setUp(self): |
| 1479 | 1479 |
BaseTestCase.setUp(self) |
| 1480 | 1480 |
self.containers = list(set(self.initial_containers + ['c1', 'c2'])) |
| 1481 | 1481 |
self.containers.sort() |
| 1482 |
|
|
| 1482 |
|
|
| 1483 | 1483 |
for c in self.containers: |
| 1484 | 1484 |
self.client.create_container(c) |
| 1485 | 1485 |
self.obj = self.upload_random_data(self.containers[0], o_names[0]) |
| ... | ... | |
| 1511 | 1511 |
|
| 1512 | 1512 |
#assert src object no more exists |
| 1513 | 1513 |
self.assert_object_not_exists(self.containers[0], self.obj['name']) |
| 1514 |
|
|
| 1515 |
|
|
| 1514 |
|
|
| 1515 |
|
|
| 1516 | 1516 |
def test_move_dir(self): |
| 1517 | 1517 |
meta = {}
|
| 1518 | 1518 |
self.client.create_folder(self.containers[0], 'dir') |
| ... | ... | |
| 1525 | 1525 |
meta['dir/subdir/object2.pdf'] = self.client.retrieve_object_metadata(self.containers[0], 'dir/subdir/object2.pdf') |
| 1526 | 1526 |
self.client.create_folder(self.containers[0], 'dirs') |
| 1527 | 1527 |
meta['dirs'] = self.client.retrieve_object_metadata(self.containers[0], 'dirs') |
| 1528 |
|
|
| 1528 |
|
|
| 1529 | 1529 |
objects = self.client.list_objects(self.containers[0], prefix='dir') |
| 1530 | 1530 |
self.client.move_object(self.containers[0], 'dir', self.containers[1], 'dir-backup', delimiter='/') |
| 1531 | 1531 |
for object in objects[:-1]: |
| ... | ... | |
| 1542 | 1542 |
BaseTestCase.setUp(self) |
| 1543 | 1543 |
self.containers = list(set(self.initial_containers + ['c1', 'c2'])) |
| 1544 | 1544 |
self.containers.sort() |
| 1545 |
|
|
| 1545 |
|
|
| 1546 | 1546 |
for c in self.containers: |
| 1547 | 1547 |
self.client.create_container(c) |
| 1548 | 1548 |
self.obj = [] |
| ... | ... | |
| 1576 | 1576 |
self.containers[0], |
| 1577 | 1577 |
self.obj[0]['name'], |
| 1578 | 1578 |
**more) |
| 1579 |
|
|
| 1579 |
|
|
| 1580 | 1580 |
#perform update metadata |
| 1581 | 1581 |
more = {'α': 'β' * 256}
|
| 1582 | 1582 |
status = self.client.update_object_metadata(self.containers[0], |
| ... | ... | |
| 1584 | 1584 |
**more)[0] |
| 1585 | 1585 |
#assert request accepted |
| 1586 | 1586 |
self.assertEqual(status, 202) |
| 1587 |
|
|
| 1587 |
|
|
| 1588 | 1588 |
#assert old metadata are still there |
| 1589 | 1589 |
headers = self.client.retrieve_object_metadata(self.containers[0], |
| 1590 | 1590 |
self.obj[0]['name'], |
| ... | ... | |
| 1593 | 1593 |
for k,v in more.items(): |
| 1594 | 1594 |
self.assertTrue(k in headers.keys()) |
| 1595 | 1595 |
self.assertTrue(headers[k], v) |
| 1596 |
|
|
| 1596 |
|
|
| 1597 | 1597 |
#out of limits |
| 1598 | 1598 |
more = {'α': 'β' * 257}
|
| 1599 | 1599 |
self.assert_raises_fault(400, self.client.update_object_metadata, |
| 1600 | 1600 |
self.containers[0], |
| 1601 | 1601 |
self.obj[0]['name'], |
| 1602 | 1602 |
**more) |
| 1603 |
|
|
| 1603 |
|
|
| 1604 | 1604 |
def test_update_object(self, |
| 1605 | 1605 |
first_byte_pos=0, |
| 1606 | 1606 |
last_byte_pos=499, |
| ... | ... | |
| 1822 | 1822 |
BaseTestCase.setUp(self) |
| 1823 | 1823 |
self.containers = ['c1', 'c2'] |
| 1824 | 1824 |
self.containers.extend(self.initial_containers) |
| 1825 |
|
|
| 1825 |
|
|
| 1826 | 1826 |
for c in self.containers: |
| 1827 | 1827 |
self.client.create_container(c) |
| 1828 | 1828 |
self.obj = self.upload_random_data(self.containers[0], o_names[0]) |
| ... | ... | |
| 1835 | 1835 |
#assert item not found |
| 1836 | 1836 |
self.assert_raises_fault(404, self.client.delete_object, self.containers[1], |
| 1837 | 1837 |
self.obj['name']) |
| 1838 |
|
|
| 1838 |
|
|
| 1839 | 1839 |
def test_delete_dir(self): |
| 1840 | 1840 |
self.client.create_folder(self.containers[0], 'dir') |
| 1841 | 1841 |
self.client.create_folder(self.containers[0], 'dir/subdir') |
| 1842 | 1842 |
self.upload_random_data(self.containers[0], 'dir/object1.jpg', length=1024) |
| 1843 | 1843 |
self.upload_random_data(self.containers[0], 'dir/subdir/object2.pdf', length=2*1024) |
| 1844 | 1844 |
self.client.create_folder(self.containers[0], 'dirs') |
| 1845 |
|
|
| 1845 |
|
|
| 1846 | 1846 |
objects = self.client.list_objects(self.containers[0], prefix='dir') |
| 1847 | 1847 |
self.client.delete_object(self.containers[0], 'dir', delimiter='/') |
| 1848 | 1848 |
for object in objects[:-1]: |
| ... | ... | |
| 1863 | 1863 |
self.o1_sharing = token, account |
| 1864 | 1864 |
self.client.share_object('c1', 'o1', (account,), read=True)
|
| 1865 | 1865 |
break |
| 1866 |
|
|
| 1866 |
|
|
| 1867 | 1867 |
def test_list_other_shared(self): |
| 1868 | 1868 |
self.other = Pithos_Client(get_url(), |
| 1869 | 1869 |
self.o1_sharing[0], |
| ... | ... | |
| 1892 | 1892 |
self.client.share_object(c, 'o1', ['papagian'], read=True) |
| 1893 | 1893 |
if i%2 != 0: |
| 1894 | 1894 |
self.client.publish_object(c, 'o2') |
| 1895 |
|
|
| 1895 |
|
|
| 1896 | 1896 |
def test_shared_public(self): |
| 1897 | 1897 |
diff = lambda l: set(l) - set(self.initial_containers) |
| 1898 |
|
|
| 1898 |
|
|
| 1899 | 1899 |
func, kwargs = self.client.list_containers, {'shared':True}
|
| 1900 | 1900 |
l = func(**kwargs) |
| 1901 | 1901 |
self.assertEqual(set(['c1', 'c2']), diff(l)) |
| 1902 | 1902 |
self.assertEqual(l, [e['name'] for e in func(format='json', **kwargs)]) |
| 1903 |
|
|
| 1903 |
|
|
| 1904 | 1904 |
func, kwargs = self.client.list_containers, {'public':True}
|
| 1905 | 1905 |
l = func(**kwargs) |
| 1906 | 1906 |
self.assertEqual(set(['c1', 'c3']), diff(l)) |
| 1907 | 1907 |
self.assertEqual(l, [e['name'] for e in func(format='json', **kwargs)]) |
| 1908 |
|
|
| 1908 |
|
|
| 1909 | 1909 |
func, kwargs = self.client.list_containers, {'shared':True, 'public':True}
|
| 1910 | 1910 |
l = func(**kwargs) |
| 1911 | 1911 |
self.assertEqual(set(['c1', 'c2', 'c3']), diff(l)) |
| 1912 | 1912 |
self.assertEqual(l, [e['name'] for e in func(format='json', **kwargs)]) |
| 1913 |
|
|
| 1914 |
|
|
| 1913 |
|
|
| 1915 | 1914 |
func, args, kwargs = self.client.list_objects, ['c1'], {'shared':True}
|
| 1916 | 1915 |
l = func(*args, **kwargs) |
| 1917 | 1916 |
self.assertEqual(l, ['o1']) |
| 1918 | 1917 |
self.assertEqual(l, [e['name'] for e in func(*args, format='json', **kwargs)]) |
| 1919 |
|
|
| 1918 |
|
|
| 1920 | 1919 |
func, args, kwargs = self.client.list_objects, ['c1'], {'public':True}
|
| 1921 | 1920 |
l = func(*args, **kwargs) |
| 1922 | 1921 |
self.assertEqual(l, ['o2']) |
| 1923 | 1922 |
self.assertEqual(l, [e['name'] for e in func(*args, format='json', **kwargs)]) |
| 1924 |
|
|
| 1923 |
|
|
| 1925 | 1924 |
func, args, kwargs = self.client.list_objects, ['c1'], {'shared':True, 'public':True}
|
| 1926 | 1925 |
l = func(*args, **kwargs) |
| 1927 | 1926 |
self.assertEqual(l, ['o1', 'o2']) |
| 1928 | 1927 |
self.assertEqual(l, [e['name'] for e in func(*args, format='json', **kwargs)]) |
| 1929 |
|
|
| 1930 |
|
|
| 1928 |
|
|
| 1931 | 1929 |
func, args, kwargs = self.client.list_objects, ['c2'], {'shared':True}
|
| 1932 | 1930 |
l = func(*args, **kwargs) |
| 1933 | 1931 |
self.assertEqual(l, ['o1']) |
| 1934 | 1932 |
self.assertEqual(l, [e['name'] for e in func(*args, format='json', **kwargs)]) |
| 1935 |
|
|
| 1933 |
|
|
| 1936 | 1934 |
func, args, kwargs = self.client.list_objects, ['c2'], {'public':True}
|
| 1937 | 1935 |
l = func(*args, **kwargs) |
| 1938 | 1936 |
self.assertEqual(l, '') |
| 1939 | 1937 |
self.assertEqual([], func(*args, format='json', **kwargs)) |
| 1940 |
|
|
| 1938 |
|
|
| 1941 | 1939 |
func, args, kwargs = self.client.list_objects, ['c2'], {'shared':True, 'public':True}
|
| 1942 | 1940 |
l = func(*args, **kwargs) |
| 1943 | 1941 |
self.assertEqual(l, ['o1']) |
| 1944 | 1942 |
self.assertEqual(l, [e['name'] for e in func(*args, format='json', **kwargs)]) |
| 1945 |
|
|
| 1946 |
|
|
| 1943 |
|
|
| 1947 | 1944 |
func, args, kwargs = self.client.list_objects, ['c3'], {'shared':True}
|
| 1948 | 1945 |
l = func(*args, **kwargs) |
| 1949 | 1946 |
self.assertEqual(l, '') |
| 1950 | 1947 |
self.assertEqual([], func(*args, format='json', **kwargs)) |
| 1951 |
|
|
| 1948 |
|
|
| 1952 | 1949 |
func, args, kwargs = self.client.list_objects, ['c3'], {'public':True}
|
| 1953 | 1950 |
l = func(*args, **kwargs) |
| 1954 | 1951 |
self.assertEqual(l, ['o2']) |
| 1955 | 1952 |
self.assertEqual(l, [e['name'] for e in func(*args, format='json', **kwargs)]) |
| 1956 |
|
|
| 1953 |
|
|
| 1957 | 1954 |
func, args, kwargs = self.client.list_objects, ['c3'], {'shared':True, 'public':True}
|
| 1958 | 1955 |
l = func(*args, **kwargs) |
| 1959 | 1956 |
self.assertEqual(l, ['o2']) |
| 1960 | 1957 |
self.assertEqual(l, [e['name'] for e in func(*args, format='json', **kwargs)]) |
| 1961 |
|
|
| 1962 |
|
|
| 1958 |
|
|
| 1963 | 1959 |
func, args, kwargs = self.client.list_objects, ['c4'], {'shared':True}
|
| 1964 | 1960 |
l = func(*args, **kwargs) |
| 1965 | 1961 |
self.assertEqual(l, '') |
| 1966 | 1962 |
self.assertEqual([], func(*args, format='json', **kwargs)) |
| 1967 |
|
|
| 1963 |
|
|
| 1968 | 1964 |
func, args, kwargs = self.client.list_objects, ['c4'], {'public':True}
|
| 1969 | 1965 |
l = func(*args, **kwargs) |
| 1970 | 1966 |
self.assertEqual(l, '') |
| 1971 | 1967 |
self.assertEqual([], func(*args, format='json', **kwargs)) |
| 1972 |
|
|
| 1968 |
|
|
| 1973 | 1969 |
func, args, kwargs = self.client.list_objects, ['c4'], {'shared':True, 'public':True}
|
| 1974 | 1970 |
l = func(*args, **kwargs) |
| 1975 | 1971 |
self.assertEqual(l, '') |
| ... | ... | |
| 2167 | 2163 |
class TestPermissions(BaseTestCase): |
| 2168 | 2164 |
def setUp(self): |
| 2169 | 2165 |
BaseTestCase.setUp(self) |
| 2170 |
|
|
| 2166 |
|
|
| 2171 | 2167 |
if not OTHER_ACCOUNTS: |
| 2172 | 2168 |
raise Warning('No other accounts avalaible for running this test.')
|
| 2173 |
|
|
| 2169 |
|
|
| 2174 | 2170 |
#create a group |
| 2175 | 2171 |
self.authorized = ['chazapis', 'verigak', 'gtsouk'] |
| 2176 | 2172 |
groups = {'pithosdev':','.join(self.authorized)}
|
Also available in: Unified diff