openstack/swift
Code Issues Proposed changes

Pep8 the functionalnosetests tests (3 of 12)

Browse Source 
Change-Id: Ia88356d6d36d1c4914f706652aaac5c840a79f13
Signed-off-by: Peter Portante <peter.portante@redhat.com>
This commit is contained in:
Peter Portante 2013-08-31 20:56:39 -04:00
parent 0014f2c828
commit c57f526f58
4 changed files with 226 additions and 135 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
test/functionalnosetests/swift_testing.py
View File

@ -42,8 +42,8 @@ if conf:
if 'auth_prefix' not in conf: if 'auth_prefix' not in conf:
conf['auth_prefix'] = '/' conf['auth_prefix'] = '/'
try: try:
swift_test_auth += \ suffix = '://%(auth_host)s:%(auth_port)s%(auth_prefix)s' % conf
'://%(auth_host)s:%(auth_port)s%(auth_prefix)s' % conf swift_test_auth += suffix
except KeyError: except KeyError:
pass # skip pass # skip
@ -56,8 +56,8 @@ if conf:
swift_test_user[0] = '%(username)s' % conf swift_test_user[0] = '%(username)s' % conf
swift_test_key[0] = conf['password'] swift_test_key[0] = conf['password']
try: try:
swift_test_user[1] = '%s%s' % \ swift_test_user[1] = '%s%s' % (
('%s:' % conf['account2'] if 'account2' in conf else '', '%s:' % conf['account2'] if 'account2' in conf else '',
conf['username2']) conf['username2'])
swift_test_key[1] = conf['password2'] swift_test_key[1] = conf['password2']
except KeyError, err: except KeyError, err:
@ -84,7 +84,8 @@ if conf:
swift_test_key[2] = conf['password3'] swift_test_key[2] = conf['password3']
for _ in range(3): for _ in range(3):
swift_test_perm[_] = swift_test_tenant[_] + ':' + swift_test_user[_] swift_test_perm[_] = swift_test_tenant[_] + ':' \
+ swift_test_user[_]
skip = not all([swift_test_auth, swift_test_user[0], swift_test_key[0]]) skip = not all([swift_test_auth, swift_test_user[0], swift_test_key[0]])
if skip: if skip:
@ -145,7 +146,8 @@ def retry(func, *args, **kwargs):
parsed[use_account], conn[use_account] = \ parsed[use_account], conn[use_account] = \
http_connection(url[use_account]) http_connection(url[use_account])
return func(url[use_account], token[use_account], return func(url[use_account], token[use_account],
parsed[use_account], conn[use_account], *args, **kwargs) parsed[use_account], conn[use_account],
*args, **kwargs)
except (socket.error, HTTPException): except (socket.error, HTTPException):
if attempts > retries: if attempts > retries:
raise raise

15
test/functionalnosetests/test_account.py
View File

@ -29,16 +29,20 @@ class TestAccount(unittest.TestCase):
def test_metadata(self): def test_metadata(self):
if skip: if skip:
raise SkipTest raise SkipTest
def post(url, token, parsed, conn, value): def post(url, token, parsed, conn, value):
conn.request('POST', parsed.path, '', conn.request('POST', parsed.path, '',
{'X-Auth-Token': token, 'X-Account-Meta-Test': value}) {'X-Auth-Token': token, 'X-Account-Meta-Test': value})
return check_response(conn) return check_response(conn)
def head(url, token, parsed, conn): def head(url, token, parsed, conn):
conn.request('HEAD', parsed.path, '', {'X-Auth-Token': token}) conn.request('HEAD', parsed.path, '', {'X-Auth-Token': token})
return check_response(conn) return check_response(conn)
def get(url, token, parsed, conn): def get(url, token, parsed, conn):
conn.request('GET', parsed.path, '', {'X-Auth-Token': token}) conn.request('GET', parsed.path, '', {'X-Auth-Token': token})
return check_response(conn) return check_response(conn)
resp = retry(post, '') resp = retry(post, '')
resp.read() resp.read()
self.assertEquals(resp.status, 204) self.assertEquals(resp.status, 204)
@ -105,13 +109,16 @@ class TestAccount(unittest.TestCase):
def test_multi_metadata(self): def test_multi_metadata(self):
if skip: if skip:
raise SkipTest raise SkipTest
def post(url, token, parsed, conn, name, value): def post(url, token, parsed, conn, name, value):
conn.request('POST', parsed.path, '', conn.request('POST', parsed.path, '',
{'X-Auth-Token': token, name: value}) {'X-Auth-Token': token, name: value})
return check_response(conn) return check_response(conn)
def head(url, token, parsed, conn): def head(url, token, parsed, conn):
conn.request('HEAD', parsed.path, '', {'X-Auth-Token': token}) conn.request('HEAD', parsed.path, '', {'X-Auth-Token': token})
return check_response(conn) return check_response(conn)
resp = retry(post, 'X-Account-Meta-One', '1') resp = retry(post, 'X-Account-Meta-One', '1')
resp.read() resp.read()
self.assertEquals(resp.status, 204) self.assertEquals(resp.status, 204)
@ -131,16 +138,19 @@ class TestAccount(unittest.TestCase):
def test_bad_metadata(self): def test_bad_metadata(self):
if skip: if skip:
raise SkipTest raise SkipTest
def post(url, token, parsed, conn, extra_headers): def post(url, token, parsed, conn, extra_headers):
headers = {'X-Auth-Token': token} headers = {'X-Auth-Token': token}
headers.update(extra_headers) headers.update(extra_headers)
conn.request('POST', parsed.path, '', headers) conn.request('POST', parsed.path, '', headers)
return check_response(conn) return check_response(conn)
resp = retry(post, resp = retry(post,
{'X-Account-Meta-' + ('k' * MAX_META_NAME_LENGTH): 'v'}) {'X-Account-Meta-' + ('k' * MAX_META_NAME_LENGTH): 'v'})
resp.read() resp.read()
self.assertEquals(resp.status, 204) self.assertEquals(resp.status, 204)
resp = retry(post, resp = retry(
post,
{'X-Account-Meta-' + ('k' * (MAX_META_NAME_LENGTH + 1)): 'v'}) {'X-Account-Meta-' + ('k' * (MAX_META_NAME_LENGTH + 1)): 'v'})
resp.read() resp.read()
self.assertEquals(resp.status, 400) self.assertEquals(resp.status, 400)
@ -149,7 +159,8 @@ class TestAccount(unittest.TestCase):
{'X-Account-Meta-Too-Long': 'k' * MAX_META_VALUE_LENGTH}) {'X-Account-Meta-Too-Long': 'k' * MAX_META_VALUE_LENGTH})
resp.read() resp.read()
self.assertEquals(resp.status, 204) self.assertEquals(resp.status, 204)
resp = retry(post, resp = retry(
post,
{'X-Account-Meta-Too-Long': 'k' * (MAX_META_VALUE_LENGTH + 1)}) {'X-Account-Meta-Too-Long': 'k' * (MAX_META_VALUE_LENGTH + 1)})
resp.read() resp.read()
self.assertEquals(resp.status, 400) self.assertEquals(resp.status, 400)

100
test/functionalnosetests/test_container.py
View File

@ -33,10 +33,12 @@ class TestContainer(unittest.TestCase):
if skip: if skip:
raise SkipTest raise SkipTest
self.name = uuid4().hex self.name = uuid4().hex
def put(url, token, parsed, conn): def put(url, token, parsed, conn):
conn.request('PUT', parsed.path + '/' + self.name, '', conn.request('PUT', parsed.path + '/' + self.name, '',
{'X-Auth-Token': token}) {'X-Auth-Token': token})
return check_response(conn) return check_response(conn)
resp = retry(put) resp = retry(put)
resp.read() resp.read()
self.assertEquals(resp.status, 201) self.assertEquals(resp.status, 201)
@ -44,15 +46,18 @@ class TestContainer(unittest.TestCase):
def tearDown(self): def tearDown(self):
if skip: if skip:
raise SkipTest raise SkipTest
def get(url, token, parsed, conn): def get(url, token, parsed, conn):
conn.request('GET', parsed.path + '/' + self.name + '?format=json', conn.request('GET', parsed.path + '/' + self.name + '?format=json',
'', {'X-Auth-Token': token}) '', {'X-Auth-Token': token})
return check_response(conn) return check_response(conn)
def delete(url, token, parsed, conn, obj): def delete(url, token, parsed, conn, obj):
conn.request('DELETE', conn.request('DELETE',
'/'.join([parsed.path, self.name, obj['name']]), '', '/'.join([parsed.path, self.name, obj['name']]), '',
{'X-Auth-Token': token}) {'X-Auth-Token': token})
return check_response(conn) return check_response(conn)
while True: while True:
resp = retry(get) resp = retry(get)
body = resp.read() body = resp.read()
@ -64,10 +69,12 @@ class TestContainer(unittest.TestCase):
resp = retry(delete, obj) resp = retry(delete, obj)
resp.read() resp.read()
self.assertEquals(resp.status, 204) self.assertEquals(resp.status, 204)
def delete(url, token, parsed, conn): def delete(url, token, parsed, conn):
conn.request('DELETE', parsed.path + '/' + self.name, '', conn.request('DELETE', parsed.path + '/' + self.name, '',
{'X-Auth-Token': token}) {'X-Auth-Token': token})
return check_response(conn) return check_response(conn)
resp = retry(delete) resp = retry(delete)
resp.read() resp.read()
self.assertEquals(resp.status, 204) self.assertEquals(resp.status, 204)
@ -75,14 +82,17 @@ class TestContainer(unittest.TestCase):
def test_multi_metadata(self): def test_multi_metadata(self):
if skip: if skip:
raise SkipTest raise SkipTest
def post(url, token, parsed, conn, name, value): def post(url, token, parsed, conn, name, value):
conn.request('POST', parsed.path + '/' + self.name, '', conn.request('POST', parsed.path + '/' + self.name, '',
{'X-Auth-Token': token, name: value}) {'X-Auth-Token': token, name: value})
return check_response(conn) return check_response(conn)
def head(url, token, parsed, conn): def head(url, token, parsed, conn):
conn.request('HEAD', parsed.path + '/' + self.name, '', conn.request('HEAD', parsed.path + '/' + self.name, '',
{'X-Auth-Token': token}) {'X-Auth-Token': token})
return check_response(conn) return check_response(conn)
resp = retry(post, 'X-Container-Meta-One', '1') resp = retry(post, 'X-Container-Meta-One', '1')
resp.read() resp.read()
self.assertEquals(resp.status, 204) self.assertEquals(resp.status, 204)
@ -144,22 +154,28 @@ class TestContainer(unittest.TestCase):
def test_PUT_metadata(self): def test_PUT_metadata(self):
if skip: if skip:
raise SkipTest raise SkipTest
def put(url, token, parsed, conn, name, value): def put(url, token, parsed, conn, name, value):
conn.request('PUT', parsed.path + '/' + name, '', conn.request('PUT', parsed.path + '/' + name, '',
{'X-Auth-Token': token, 'X-Container-Meta-Test': value}) {'X-Auth-Token': token,
'X-Container-Meta-Test': value})
return check_response(conn) return check_response(conn)
def head(url, token, parsed, conn, name): def head(url, token, parsed, conn, name):
conn.request('HEAD', parsed.path + '/' + name, '', conn.request('HEAD', parsed.path + '/' + name, '',
{'X-Auth-Token': token}) {'X-Auth-Token': token})
return check_response(conn) return check_response(conn)
def get(url, token, parsed, conn, name): def get(url, token, parsed, conn, name):
conn.request('GET', parsed.path + '/' + name, '', conn.request('GET', parsed.path + '/' + name, '',
{'X-Auth-Token': token}) {'X-Auth-Token': token})
return check_response(conn) return check_response(conn)
def delete(url, token, parsed, conn, name): def delete(url, token, parsed, conn, name):
conn.request('DELETE', parsed.path + '/' + name, '', conn.request('DELETE', parsed.path + '/' + name, '',
{'X-Auth-Token': token}) {'X-Auth-Token': token})
return check_response(conn) return check_response(conn)
name = uuid4().hex name = uuid4().hex
resp = retry(put, name, 'Value') resp = retry(put, name, 'Value')
resp.read() resp.read()
@ -195,18 +211,23 @@ class TestContainer(unittest.TestCase):
def test_POST_metadata(self): def test_POST_metadata(self):
if skip: if skip:
raise SkipTest raise SkipTest
def post(url, token, parsed, conn, value): def post(url, token, parsed, conn, value):
conn.request('POST', parsed.path + '/' + self.name, '', conn.request('POST', parsed.path + '/' + self.name, '',
{'X-Auth-Token': token, 'X-Container-Meta-Test': value}) {'X-Auth-Token': token,
'X-Container-Meta-Test': value})
return check_response(conn) return check_response(conn)
def head(url, token, parsed, conn): def head(url, token, parsed, conn):
conn.request('HEAD', parsed.path + '/' + self.name, '', conn.request('HEAD', parsed.path + '/' + self.name, '',
{'X-Auth-Token': token}) {'X-Auth-Token': token})
return check_response(conn) return check_response(conn)
def get(url, token, parsed, conn): def get(url, token, parsed, conn):
conn.request('GET', parsed.path + '/' + self.name, '', conn.request('GET', parsed.path + '/' + self.name, '',
{'X-Auth-Token': token}) {'X-Auth-Token': token})
return check_response(conn) return check_response(conn)
resp = retry(head) resp = retry(head)
resp.read() resp.read()
self.assert_(resp.status in (200, 204), resp.status) self.assert_(resp.status in (200, 204), resp.status)
@ -230,17 +251,21 @@ class TestContainer(unittest.TestCase):
def test_PUT_bad_metadata(self): def test_PUT_bad_metadata(self):
if skip: if skip:
raise SkipTest raise SkipTest
def put(url, token, parsed, conn, name, extra_headers): def put(url, token, parsed, conn, name, extra_headers):
headers = {'X-Auth-Token': token} headers = {'X-Auth-Token': token}
headers.update(extra_headers) headers.update(extra_headers)
conn.request('PUT', parsed.path + '/' + name, '', headers) conn.request('PUT', parsed.path + '/' + name, '', headers)
return check_response(conn) return check_response(conn)
def delete(url, token, parsed, conn, name): def delete(url, token, parsed, conn, name):
conn.request('DELETE', parsed.path + '/' + name, '', conn.request('DELETE', parsed.path + '/' + name, '',
{'X-Auth-Token': token}) {'X-Auth-Token': token})
return check_response(conn) return check_response(conn)
name = uuid4().hex name = uuid4().hex
resp = retry(put, name, resp = retry(
put, name,
{'X-Container-Meta-' + ('k' * MAX_META_NAME_LENGTH): 'v'}) {'X-Container-Meta-' + ('k' * MAX_META_NAME_LENGTH): 'v'})
resp.read() resp.read()
self.assertEquals(resp.status, 201) self.assertEquals(resp.status, 201)
@ -248,7 +273,8 @@ class TestContainer(unittest.TestCase):
resp.read() resp.read()
self.assertEquals(resp.status, 204) self.assertEquals(resp.status, 204)
name = uuid4().hex name = uuid4().hex
resp = retry(put, name, resp = retry(
put, name,
{'X-Container-Meta-' + ('k' * (MAX_META_NAME_LENGTH + 1)): 'v'}) {'X-Container-Meta-' + ('k' * (MAX_META_NAME_LENGTH + 1)): 'v'})
resp.read() resp.read()
self.assertEquals(resp.status, 400) self.assertEquals(resp.status, 400)
@ -257,7 +283,8 @@ class TestContainer(unittest.TestCase):
self.assertEquals(resp.status, 404) self.assertEquals(resp.status, 404)
name = uuid4().hex name = uuid4().hex
resp = retry(put, name, resp = retry(
put, name,
{'X-Container-Meta-Too-Long': 'k' * MAX_META_VALUE_LENGTH}) {'X-Container-Meta-Too-Long': 'k' * MAX_META_VALUE_LENGTH})
resp.read() resp.read()
self.assertEquals(resp.status, 201) self.assertEquals(resp.status, 201)
@ -265,7 +292,8 @@ class TestContainer(unittest.TestCase):
resp.read() resp.read()
self.assertEquals(resp.status, 204) self.assertEquals(resp.status, 204)
name = uuid4().hex name = uuid4().hex
resp = retry(put, name, resp = retry(
put, name,
{'X-Container-Meta-Too-Long': 'k' * (MAX_META_VALUE_LENGTH + 1)}) {'X-Container-Meta-Too-Long': 'k' * (MAX_META_VALUE_LENGTH + 1)})
resp.read() resp.read()
self.assertEquals(resp.status, 400) self.assertEquals(resp.status, 400)
@ -325,25 +353,31 @@ class TestContainer(unittest.TestCase):
def test_POST_bad_metadata(self): def test_POST_bad_metadata(self):
if skip: if skip:
raise SkipTest raise SkipTest
def post(url, token, parsed, conn, extra_headers): def post(url, token, parsed, conn, extra_headers):
headers = {'X-Auth-Token': token} headers = {'X-Auth-Token': token}
headers.update(extra_headers) headers.update(extra_headers)
conn.request('POST', parsed.path + '/' + self.name, '', headers) conn.request('POST', parsed.path + '/' + self.name, '', headers)
return check_response(conn) return check_response(conn)
resp = retry(post,
resp = retry(
post,
{'X-Container-Meta-' + ('k' * MAX_META_NAME_LENGTH): 'v'}) {'X-Container-Meta-' + ('k' * MAX_META_NAME_LENGTH): 'v'})
resp.read() resp.read()
self.assertEquals(resp.status, 204) self.assertEquals(resp.status, 204)
resp = retry(post, resp = retry(
post,
{'X-Container-Meta-' + ('k' * (MAX_META_NAME_LENGTH + 1)): 'v'}) {'X-Container-Meta-' + ('k' * (MAX_META_NAME_LENGTH + 1)): 'v'})
resp.read() resp.read()
self.assertEquals(resp.status, 400) self.assertEquals(resp.status, 400)
resp = retry(post, resp = retry(
post,
{'X-Container-Meta-Too-Long': 'k' * MAX_META_VALUE_LENGTH}) {'X-Container-Meta-Too-Long': 'k' * MAX_META_VALUE_LENGTH})
resp.read() resp.read()
self.assertEquals(resp.status, 204) self.assertEquals(resp.status, 204)
resp = retry(post, resp = retry(
post,
{'X-Container-Meta-Too-Long': 'k' * (MAX_META_VALUE_LENGTH + 1)}) {'X-Container-Meta-Too-Long': 'k' * (MAX_META_VALUE_LENGTH + 1)})
resp.read() resp.read()
self.assertEquals(resp.status, 400) self.assertEquals(resp.status, 400)
@ -384,29 +418,35 @@ class TestContainer(unittest.TestCase):
def test_public_container(self): def test_public_container(self):
if skip: if skip:
raise SkipTest raise SkipTest
def get(url, token, parsed, conn): def get(url, token, parsed, conn):
conn.request('GET', parsed.path + '/' + self.name) conn.request('GET', parsed.path + '/' + self.name)
return check_response(conn) return check_response(conn)
try: try:
resp = retry(get) resp = retry(get)
raise Exception('Should not have been able to GET') raise Exception('Should not have been able to GET')
except Exception, err: except Exception, err:
self.assert_(str(err).startswith('No result after '), err) self.assert_(str(err).startswith('No result after '), err)
def post(url, token, parsed, conn): def post(url, token, parsed, conn):
conn.request('POST', parsed.path + '/' + self.name, '', conn.request('POST', parsed.path + '/' + self.name, '',
{'X-Auth-Token': token, {'X-Auth-Token': token,
'X-Container-Read': '.r:*,.rlistings'}) 'X-Container-Read': '.r:*,.rlistings'})
return check_response(conn) return check_response(conn)
resp = retry(post) resp = retry(post)
resp.read() resp.read()
self.assertEquals(resp.status, 204) self.assertEquals(resp.status, 204)
resp = retry(get) resp = retry(get)
resp.read() resp.read()
self.assertEquals(resp.status, 204) self.assertEquals(resp.status, 204)
def post(url, token, parsed, conn): def post(url, token, parsed, conn):
conn.request('POST', parsed.path + '/' + self.name, '', conn.request('POST', parsed.path + '/' + self.name, '',
{'X-Auth-Token': token, 'X-Container-Read': ''}) {'X-Auth-Token': token, 'X-Container-Read': ''})
return check_response(conn) return check_response(conn)
resp = retry(post) resp = retry(post)
resp.read() resp.read()
self.assertEquals(resp.status, 204) self.assertEquals(resp.status, 204)
@ -421,27 +461,34 @@ class TestContainer(unittest.TestCase):
raise SkipTest raise SkipTest
# Obtain the first account's string # Obtain the first account's string
first_account = ['unknown'] first_account = ['unknown']
def get1(url, token, parsed, conn): def get1(url, token, parsed, conn):
first_account[0] = parsed.path first_account[0] = parsed.path
conn.request('HEAD', parsed.path + '/' + self.name, '', conn.request('HEAD', parsed.path + '/' + self.name, '',
{'X-Auth-Token': token}) {'X-Auth-Token': token})
return check_response(conn) return check_response(conn)
resp = retry(get1) resp = retry(get1)
resp.read() resp.read()
# Ensure we can't access the container with the second account # Ensure we can't access the container with the second account
def get2(url, token, parsed, conn): def get2(url, token, parsed, conn):
conn.request('GET', first_account[0] + '/' + self.name, '', conn.request('GET', first_account[0] + '/' + self.name, '',
{'X-Auth-Token': token}) {'X-Auth-Token': token})
return check_response(conn) return check_response(conn)
resp = retry(get2, use_account=2) resp = retry(get2, use_account=2)
resp.read() resp.read()
self.assertEquals(resp.status, 403) self.assertEquals(resp.status, 403)
# Make the container accessible by the second account # Make the container accessible by the second account
def post(url, token, parsed, conn): def post(url, token, parsed, conn):
conn.request('POST', parsed.path + '/' + self.name, '', conn.request('POST', parsed.path + '/' + self.name, '',
{'X-Auth-Token': token, 'X-Container-Read': swift_test_perm[1], {'X-Auth-Token': token,
'X-Container-Read': swift_test_perm[1],
'X-Container-Write': swift_test_perm[1]}) 'X-Container-Write': swift_test_perm[1]})
return check_response(conn) return check_response(conn)
resp = retry(post) resp = retry(post)
resp.read() resp.read()
self.assertEquals(resp.status, 204) self.assertEquals(resp.status, 204)
@ -449,12 +496,14 @@ class TestContainer(unittest.TestCase):
resp = retry(get2, use_account=2) resp = retry(get2, use_account=2)
resp.read() resp.read()
self.assertEquals(resp.status, 204) self.assertEquals(resp.status, 204)
# Make the container private again # Make the container private again
def post(url, token, parsed, conn): def post(url, token, parsed, conn):
conn.request('POST', parsed.path + '/' + self.name, '', conn.request('POST', parsed.path + '/' + self.name, '',
{'X-Auth-Token': token, 'X-Container-Read': '', {'X-Auth-Token': token, 'X-Container-Read': '',
'X-Container-Write': ''}) 'X-Container-Write': ''})
return check_response(conn) return check_response(conn)
resp = retry(post) resp = retry(post)
resp.read() resp.read()
self.assertEquals(resp.status, 204) self.assertEquals(resp.status, 204)
@ -468,27 +517,33 @@ class TestContainer(unittest.TestCase):
raise SkipTest raise SkipTest
# Obtain the first account's string # Obtain the first account's string
first_account = ['unknown'] first_account = ['unknown']
def get1(url, token, parsed, conn): def get1(url, token, parsed, conn):
first_account[0] = parsed.path first_account[0] = parsed.path
conn.request('HEAD', parsed.path + '/' + self.name, '', conn.request('HEAD', parsed.path + '/' + self.name, '',
{'X-Auth-Token': token}) {'X-Auth-Token': token})
return check_response(conn) return check_response(conn)
resp = retry(get1) resp = retry(get1)
resp.read() resp.read()
# Ensure we can't access the container with the second account # Ensure we can't access the container with the second account
def get2(url, token, parsed, conn): def get2(url, token, parsed, conn):
conn.request('GET', first_account[0] + '/' + self.name, '', conn.request('GET', first_account[0] + '/' + self.name, '',
{'X-Auth-Token': token}) {'X-Auth-Token': token})
return check_response(conn) return check_response(conn)
resp = retry(get2, use_account=2) resp = retry(get2, use_account=2)
resp.read() resp.read()
self.assertEquals(resp.status, 403) self.assertEquals(resp.status, 403)
# Make the container completely public # Make the container completely public
def post(url, token, parsed, conn): def post(url, token, parsed, conn):
conn.request('POST', parsed.path + '/' + self.name, '', conn.request('POST', parsed.path + '/' + self.name, '',
{'X-Auth-Token': token, {'X-Auth-Token': token,
'X-Container-Read': '.r:*,.rlistings'}) 'X-Container-Read': '.r:*,.rlistings'})
return check_response(conn) return check_response(conn)
resp = retry(post) resp = retry(post)
resp.read() resp.read()
self.assertEquals(resp.status, 204) self.assertEquals(resp.status, 204)
@ -496,20 +551,24 @@ class TestContainer(unittest.TestCase):
resp = retry(get2, use_account=2) resp = retry(get2, use_account=2)
resp.read() resp.read()
self.assertEquals(resp.status, 204) self.assertEquals(resp.status, 204)
# But we shouldn't be able to write with the second account # But we shouldn't be able to write with the second account
def put2(url, token, parsed, conn): def put2(url, token, parsed, conn):
conn.request('PUT', first_account[0] + '/' + self.name + '/object', conn.request('PUT', first_account[0] + '/' + self.name + '/object',
'test object', {'X-Auth-Token': token}) 'test object', {'X-Auth-Token': token})
return check_response(conn) return check_response(conn)
resp = retry(put2, use_account=2) resp = retry(put2, use_account=2)
resp.read() resp.read()
self.assertEquals(resp.status, 403) self.assertEquals(resp.status, 403)
# Now make the container also writeable by the second account # Now make the container also writeable by the second account
def post(url, token, parsed, conn): def post(url, token, parsed, conn):
conn.request('POST', parsed.path + '/' + self.name, '', conn.request('POST', parsed.path + '/' + self.name, '',
{'X-Auth-Token': token, {'X-Auth-Token': token,
'X-Container-Write': swift_test_perm[1]}) 'X-Container-Write': swift_test_perm[1]})
return check_response(conn) return check_response(conn)
resp = retry(post) resp = retry(post)
resp.read() resp.read()
self.assertEquals(resp.status, 204) self.assertEquals(resp.status, 204)
@ -527,26 +586,33 @@ class TestContainer(unittest.TestCase):
raise SkipTest raise SkipTest
# Obtain the first account's string # Obtain the first account's string
first_account = ['unknown'] first_account = ['unknown']
def get1(url, token, parsed, conn): def get1(url, token, parsed, conn):
first_account[0] = parsed.path first_account[0] = parsed.path
conn.request('HEAD', parsed.path + '/' + self.name, '', conn.request('HEAD', parsed.path + '/' + self.name, '',
{'X-Auth-Token': token}) {'X-Auth-Token': token})
return check_response(conn) return check_response(conn)
resp = retry(get1) resp = retry(get1)
resp.read() resp.read()
# Ensure we can't access the container with the third account # Ensure we can't access the container with the third account
def get3(url, token, parsed, conn): def get3(url, token, parsed, conn):
conn.request('GET', first_account[0] + '/' + self.name, '', conn.request('GET', first_account[0] + '/' + self.name, '',
{'X-Auth-Token': token}) {'X-Auth-Token': token})
return check_response(conn) return check_response(conn)
resp = retry(get3, use_account=3) resp = retry(get3, use_account=3)
resp.read() resp.read()
self.assertEquals(resp.status, 403) self.assertEquals(resp.status, 403)
# Make the container accessible by the third account # Make the container accessible by the third account
def post(url, token, parsed, conn): def post(url, token, parsed, conn):
conn.request('POST', parsed.path + '/' + self.name, '', conn.request('POST', parsed.path + '/' + self.name, '',
{'X-Auth-Token': token, 'X-Container-Read': swift_test_perm[2]}) {'X-Auth-Token': token,
'X-Container-Read': swift_test_perm[2]})
return check_response(conn) return check_response(conn)
resp = retry(post) resp = retry(post)
resp.read() resp.read()
self.assertEquals(resp.status, 204) self.assertEquals(resp.status, 204)
@ -554,20 +620,24 @@ class TestContainer(unittest.TestCase):
resp = retry(get3, use_account=3) resp = retry(get3, use_account=3)
resp.read() resp.read()
self.assertEquals(resp.status, 204) self.assertEquals(resp.status, 204)
# But we shouldn't be able to write with the third account # But we shouldn't be able to write with the third account
def put3(url, token, parsed, conn): def put3(url, token, parsed, conn):
conn.request('PUT', first_account[0] + '/' + self.name + '/object', conn.request('PUT', first_account[0] + '/' + self.name + '/object',
'test object', {'X-Auth-Token': token}) 'test object', {'X-Auth-Token': token})
return check_response(conn) return check_response(conn)
resp = retry(put3, use_account=3) resp = retry(put3, use_account=3)
resp.read() resp.read()
self.assertEquals(resp.status, 403) self.assertEquals(resp.status, 403)
# Now make the container also writeable by the third account # Now make the container also writeable by the third account
def post(url, token, parsed, conn): def post(url, token, parsed, conn):
conn.request('POST', parsed.path + '/' + self.name, '', conn.request('POST', parsed.path + '/' + self.name, '',
{'X-Auth-Token': token, {'X-Auth-Token': token,
'X-Container-Write': swift_test_perm[2]}) 'X-Container-Write': swift_test_perm[2]})
return check_response(conn) return check_response(conn)
resp = retry(post) resp = retry(post)
resp.read() resp.read()
self.assertEquals(resp.status, 204) self.assertEquals(resp.status, 204)
@ -586,9 +656,10 @@ class TestContainer(unittest.TestCase):
def put(url, token, parsed, conn): def put(url, token, parsed, conn):
container_name = 'X' * 2048 container_name = 'X' * 2048
conn.request('PUT', '%s/%s' % (parsed.path, conn.request('PUT', '%s/%s' % (parsed.path, container_name),
container_name), 'there', {'X-Auth-Token': token}) 'there', {'X-Auth-Token': token})
return check_response(conn) return check_response(conn)
resp = retry(put) resp = retry(put)
resp.read() resp.read()
self.assertEquals(resp.status, 400) self.assertEquals(resp.status, 400)
@ -603,6 +674,7 @@ class TestContainer(unittest.TestCase):
conn.request('PUT', '%s/abc%%00def' % parsed.path, '', conn.request('PUT', '%s/abc%%00def' % parsed.path, '',
{'X-Auth-Token': token}) {'X-Auth-Token': token})
return check_response(conn) return check_response(conn)
resp = retry(put) resp = retry(put)
if (web_front_end == 'apache2'): if (web_front_end == 'apache2'):
self.assertEquals(resp.status, 404) self.assertEquals(resp.status, 404)

152
test/functionalnosetests/test_object.py
View File

@ -40,8 +40,9 @@ class TestObject(unittest.TestCase):
self.obj = uuid4().hex self.obj = uuid4().hex
def put(url, token, parsed, conn): def put(url, token, parsed, conn):
conn.request('PUT', '%s/%s/%s' % (parsed.path, self.container, conn.request('PUT', '%s/%s/%s' % (
self.obj), 'test', {'X-Auth-Token': token}) parsed.path, self.container, self.obj), 'test',
{'X-Auth-Token': token})
return check_response(conn) return check_response(conn)
resp = retry(put) resp = retry(put)
resp.read() resp.read()
@ -201,8 +202,8 @@ class TestObject(unittest.TestCase):
# Ensure we can't access the object with the third account # Ensure we can't access the object with the third account
def get(url, token, parsed, conn): def get(url, token, parsed, conn):
conn.request('GET', '%s/%s/%s' % (parsed.path, self.container, conn.request('GET', '%s/%s/%s' % (
self.obj), '', parsed.path, self.container, self.obj), '',
{'X-Auth-Token': token}) {'X-Auth-Token': token})
return check_response(conn) return check_response(conn)
resp = retry(get, use_account=3) resp = retry(get, use_account=3)
@ -213,8 +214,8 @@ class TestObject(unittest.TestCase):
shared_container = uuid4().hex shared_container = uuid4().hex
def put(url, token, parsed, conn): def put(url, token, parsed, conn):
conn.request('PUT', '%s/%s' % (parsed.path, conn.request('PUT', '%s/%s' % (
shared_container), '', parsed.path, shared_container), '',
{'X-Auth-Token': token, {'X-Auth-Token': token,
'X-Container-Read': swift_test_perm[2], 'X-Container-Read': swift_test_perm[2],
'X-Container-Write': swift_test_perm[2]}) 'X-Container-Write': swift_test_perm[2]})
@ -225,13 +226,11 @@ class TestObject(unittest.TestCase):
# verify third account can not copy from private container # verify third account can not copy from private container
def copy(url, token, parsed, conn): def copy(url, token, parsed, conn):
conn.request('PUT', '%s/%s/%s' % (parsed.path, conn.request('PUT', '%s/%s/%s' % (
shared_container, parsed.path, shared_container, 'private_object'), '',
'private_object'), {'X-Auth-Token': token,
'', {'X-Auth-Token': token,
'Content-Length': '0', 'Content-Length': '0',
'X-Copy-From': '%s/%s' % (self.container, 'X-Copy-From': '%s/%s' % (self.container, self.obj)})
self.obj)})
return check_response(conn) return check_response(conn)
resp = retry(copy, use_account=3) resp = retry(copy, use_account=3)
resp.read() resp.read()
@ -239,8 +238,9 @@ class TestObject(unittest.TestCase):
# verify third account can write "obj1" to shared container # verify third account can write "obj1" to shared container
def put(url, token, parsed, conn): def put(url, token, parsed, conn):
conn.request('PUT', '%s/%s/%s' % (parsed.path, shared_container, conn.request('PUT', '%s/%s/%s' % (
'obj1'), 'test', {'X-Auth-Token': token}) parsed.path, shared_container, 'obj1'), 'test',
{'X-Auth-Token': token})
return check_response(conn) return check_response(conn)
resp = retry(put, use_account=3) resp = retry(put, use_account=3)
resp.read() resp.read()
@ -248,12 +248,10 @@ class TestObject(unittest.TestCase):
# verify third account can copy "obj1" to shared container # verify third account can copy "obj1" to shared container
def copy2(url, token, parsed, conn): def copy2(url, token, parsed, conn):
conn.request('COPY', '%s/%s/%s' % (parsed.path, conn.request('COPY', '%s/%s/%s' % (
shared_container, parsed.path, shared_container, 'obj1'), '',
'obj1'), {'X-Auth-Token': token,
'', {'X-Auth-Token': token, 'Destination': '%s/%s' % (shared_container, 'obj1')})
'Destination': '%s/%s' % (shared_container,
'obj1')})
return check_response(conn) return check_response(conn)
resp = retry(copy2, use_account=3) resp = retry(copy2, use_account=3)
resp.read() resp.read()
@ -261,10 +259,9 @@ class TestObject(unittest.TestCase):
# verify third account STILL can not copy from private container # verify third account STILL can not copy from private container
def copy3(url, token, parsed, conn): def copy3(url, token, parsed, conn):
conn.request('COPY', '%s/%s/%s' % (parsed.path, conn.request('COPY', '%s/%s/%s' % (
self.container, parsed.path, self.container, self.obj), '',
self.obj), {'X-Auth-Token': token,
'', {'X-Auth-Token': token,
'Destination': '%s/%s' % (shared_container, 'Destination': '%s/%s' % (shared_container,
'private_object')}) 'private_object')})
return check_response(conn) return check_response(conn)
@ -274,8 +271,9 @@ class TestObject(unittest.TestCase):
# clean up "obj1" # clean up "obj1"
def delete(url, token, parsed, conn): def delete(url, token, parsed, conn):
conn.request('DELETE', '%s/%s/%s' % (parsed.path, shared_container, conn.request('DELETE', '%s/%s/%s' % (
'obj1'), '', {'X-Auth-Token': token}) parsed.path, shared_container, 'obj1'), '',
{'X-Auth-Token': token})
return check_response(conn) return check_response(conn)
resp = retry(delete) resp = retry(delete)
resp.read() resp.read()
@ -301,8 +299,8 @@ class TestObject(unittest.TestCase):
# Upload the first set of segments # Upload the first set of segments
def put(url, token, parsed, conn, objnum): def put(url, token, parsed, conn, objnum):
conn.request('PUT', '%s/%s/segments1/%s' % (parsed.path, conn.request('PUT', '%s/%s/segments1/%s' % (
self.container, str(objnum)), segments1[objnum], parsed.path, self.container, str(objnum)), segments1[objnum],
{'X-Auth-Token': token}) {'X-Auth-Token': token})
return check_response(conn) return check_response(conn)
for objnum in xrange(len(segments1)): for objnum in xrange(len(segments1)):
@ -312,8 +310,9 @@ class TestObject(unittest.TestCase):
# Upload the manifest # Upload the manifest
def put(url, token, parsed, conn): def put(url, token, parsed, conn):
conn.request('PUT', '%s/%s/manifest' % (parsed.path, conn.request('PUT', '%s/%s/manifest' % (
self.container), '', {'X-Auth-Token': token, parsed.path, self.container), '', {
'X-Auth-Token': token,
'X-Object-Manifest': '%s/segments1/' % self.container, 'X-Object-Manifest': '%s/segments1/' % self.container,
'Content-Type': 'text/jibberish', 'Content-Length': '0'}) 'Content-Type': 'text/jibberish', 'Content-Length': '0'})
return check_response(conn) return check_response(conn)
@ -323,8 +322,8 @@ class TestObject(unittest.TestCase):
# Get the manifest (should get all the segments as the body) # Get the manifest (should get all the segments as the body)
def get(url, token, parsed, conn): def get(url, token, parsed, conn):
conn.request('GET', '%s/%s/manifest' % (parsed.path, conn.request('GET', '%s/%s/manifest' % (
self.container), '', {'X-Auth-Token': token}) parsed.path, self.container), '', {'X-Auth-Token': token})
return check_response(conn) return check_response(conn)
resp = retry(get) resp = retry(get)
self.assertEquals(resp.read(), ''.join(segments1)) self.assertEquals(resp.read(), ''.join(segments1))
@ -333,9 +332,9 @@ class TestObject(unittest.TestCase):
# Get with a range at the start of the second segment # Get with a range at the start of the second segment
def get(url, token, parsed, conn): def get(url, token, parsed, conn):
conn.request('GET', '%s/%s/manifest' % (parsed.path, conn.request('GET', '%s/%s/manifest' % (
self.container), '', {'X-Auth-Token': token, 'Range': parsed.path, self.container), '', {
'bytes=3-'}) 'X-Auth-Token': token, 'Range': 'bytes=3-'})
return check_response(conn) return check_response(conn)
resp = retry(get) resp = retry(get)
self.assertEquals(resp.read(), ''.join(segments1[1:])) self.assertEquals(resp.read(), ''.join(segments1[1:]))
@ -343,9 +342,9 @@ class TestObject(unittest.TestCase):
# Get with a range in the middle of the second segment # Get with a range in the middle of the second segment
def get(url, token, parsed, conn): def get(url, token, parsed, conn):
conn.request('GET', '%s/%s/manifest' % (parsed.path, conn.request('GET', '%s/%s/manifest' % (
self.container), '', {'X-Auth-Token': token, 'Range': parsed.path, self.container), '', {
'bytes=5-'}) 'X-Auth-Token': token, 'Range': 'bytes=5-'})
return check_response(conn) return check_response(conn)
resp = retry(get) resp = retry(get)
self.assertEquals(resp.read(), ''.join(segments1)[5:]) self.assertEquals(resp.read(), ''.join(segments1)[5:])
@ -353,9 +352,9 @@ class TestObject(unittest.TestCase):
# Get with a full start and stop range # Get with a full start and stop range
def get(url, token, parsed, conn): def get(url, token, parsed, conn):
conn.request('GET', '%s/%s/manifest' % (parsed.path, conn.request('GET', '%s/%s/manifest' % (
self.container), '', {'X-Auth-Token': token, 'Range': parsed.path, self.container), '', {
'bytes=5-10'}) 'X-Auth-Token': token, 'Range': 'bytes=5-10'})
return check_response(conn) return check_response(conn)
resp = retry(get) resp = retry(get)
self.assertEquals(resp.read(), ''.join(segments1)[5:11]) self.assertEquals(resp.read(), ''.join(segments1)[5:11])
@ -363,8 +362,8 @@ class TestObject(unittest.TestCase):
# Upload the second set of segments # Upload the second set of segments
def put(url, token, parsed, conn, objnum): def put(url, token, parsed, conn, objnum):
conn.request('PUT', '%s/%s/segments2/%s' % (parsed.path, conn.request('PUT', '%s/%s/segments2/%s' % (
self.container, str(objnum)), segments2[objnum], parsed.path, self.container, str(objnum)), segments2[objnum],
{'X-Auth-Token': token}) {'X-Auth-Token': token})
return check_response(conn) return check_response(conn)
for objnum in xrange(len(segments2)): for objnum in xrange(len(segments2)):
@ -374,8 +373,8 @@ class TestObject(unittest.TestCase):
# Get the manifest (should still be the first segments of course) # Get the manifest (should still be the first segments of course)
def get(url, token, parsed, conn): def get(url, token, parsed, conn):
conn.request('GET', '%s/%s/manifest' % (parsed.path, conn.request('GET', '%s/%s/manifest' % (
self.container), '', {'X-Auth-Token': token}) parsed.path, self.container), '', {'X-Auth-Token': token})
return check_response(conn) return check_response(conn)
resp = retry(get) resp = retry(get)
self.assertEquals(resp.read(), ''.join(segments1)) self.assertEquals(resp.read(), ''.join(segments1))
@ -383,8 +382,9 @@ class TestObject(unittest.TestCase):
# Update the manifest # Update the manifest
def put(url, token, parsed, conn): def put(url, token, parsed, conn):
conn.request('PUT', '%s/%s/manifest' % (parsed.path, conn.request('PUT', '%s/%s/manifest' % (
self.container), '', {'X-Auth-Token': token, parsed.path, self.container), '', {
'X-Auth-Token': token,
'X-Object-Manifest': '%s/segments2/' % self.container, 'X-Object-Manifest': '%s/segments2/' % self.container,
'Content-Length': '0'}) 'Content-Length': '0'})
return check_response(conn) return check_response(conn)
@ -394,8 +394,8 @@ class TestObject(unittest.TestCase):
# Get the manifest (should be the second set of segments now) # Get the manifest (should be the second set of segments now)
def get(url, token, parsed, conn): def get(url, token, parsed, conn):
conn.request('GET', '%s/%s/manifest' % (parsed.path, conn.request('GET', '%s/%s/manifest' % (
self.container), '', {'X-Auth-Token': token}) parsed.path, self.container), '', {'X-Auth-Token': token})
return check_response(conn) return check_response(conn)
resp = retry(get) resp = retry(get)
self.assertEquals(resp.read(), ''.join(segments2)) self.assertEquals(resp.read(), ''.join(segments2))
@ -405,8 +405,8 @@ class TestObject(unittest.TestCase):
# Ensure we can't access the manifest with the third account # Ensure we can't access the manifest with the third account
def get(url, token, parsed, conn): def get(url, token, parsed, conn):
conn.request('GET', '%s/%s/manifest' % (parsed.path, conn.request('GET', '%s/%s/manifest' % (
self.container), '', {'X-Auth-Token': token}) parsed.path, self.container), '', {'X-Auth-Token': token})
return check_response(conn) return check_response(conn)
resp = retry(get, use_account=3) resp = retry(get, use_account=3)
resp.read() resp.read()
@ -424,8 +424,8 @@ class TestObject(unittest.TestCase):
# The third account should be able to get the manifest now # The third account should be able to get the manifest now
def get(url, token, parsed, conn): def get(url, token, parsed, conn):
conn.request('GET', '%s/%s/manifest' % (parsed.path, conn.request('GET', '%s/%s/manifest' % (
self.container), '', {'X-Auth-Token': token}) parsed.path, self.container), '', {'X-Auth-Token': token})
return check_response(conn) return check_response(conn)
resp = retry(get, use_account=3) resp = retry(get, use_account=3)
self.assertEquals(resp.read(), ''.join(segments2)) self.assertEquals(resp.read(), ''.join(segments2))
@ -444,8 +444,8 @@ class TestObject(unittest.TestCase):
# Upload the third set of segments in the other container # Upload the third set of segments in the other container
def put(url, token, parsed, conn, objnum): def put(url, token, parsed, conn, objnum):
conn.request('PUT', '%s/%s/segments3/%s' % (parsed.path, conn.request('PUT', '%s/%s/segments3/%s' % (
acontainer, str(objnum)), segments3[objnum], parsed.path, acontainer, str(objnum)), segments3[objnum],
{'X-Auth-Token': token}) {'X-Auth-Token': token})
return check_response(conn) return check_response(conn)
for objnum in xrange(len(segments3)): for objnum in xrange(len(segments3)):
@ -455,8 +455,9 @@ class TestObject(unittest.TestCase):
# Update the manifest # Update the manifest
def put(url, token, parsed, conn): def put(url, token, parsed, conn):
conn.request('PUT', '%s/%s/manifest' % (parsed.path, conn.request('PUT', '%s/%s/manifest' % (
self.container), '', {'X-Auth-Token': token, parsed.path, self.container), '',
{'X-Auth-Token': token,
'X-Object-Manifest': '%s/segments3/' % acontainer, 'X-Object-Manifest': '%s/segments3/' % acontainer,
'Content-Length': '0'}) 'Content-Length': '0'})
return check_response(conn) return check_response(conn)
@ -466,8 +467,8 @@ class TestObject(unittest.TestCase):
# Get the manifest to ensure it's the third set of segments # Get the manifest to ensure it's the third set of segments
def get(url, token, parsed, conn): def get(url, token, parsed, conn):
conn.request('GET', '%s/%s/manifest' % (parsed.path, conn.request('GET', '%s/%s/manifest' % (
self.container), '', {'X-Auth-Token': token}) parsed.path, self.container), '', {'X-Auth-Token': token})
return check_response(conn) return check_response(conn)
resp = retry(get) resp = retry(get)
self.assertEquals(resp.read(), ''.join(segments3)) self.assertEquals(resp.read(), ''.join(segments3))
@ -480,8 +481,8 @@ class TestObject(unittest.TestCase):
# manifest itself is not). # manifest itself is not).
def get(url, token, parsed, conn): def get(url, token, parsed, conn):
conn.request('GET', '%s/%s/manifest' % (parsed.path, conn.request('GET', '%s/%s/manifest' % (
self.container), '', {'X-Auth-Token': token}) parsed.path, self.container), '', {'X-Auth-Token': token})
return check_response(conn) return check_response(conn)
resp = retry(get, use_account=3) resp = retry(get, use_account=3)
resp.read() resp.read()
@ -499,8 +500,8 @@ class TestObject(unittest.TestCase):
# The third account should be able to get the manifest now # The third account should be able to get the manifest now
def get(url, token, parsed, conn): def get(url, token, parsed, conn):
conn.request('GET', '%s/%s/manifest' % (parsed.path, conn.request('GET', '%s/%s/manifest' % (
self.container), '', {'X-Auth-Token': token}) parsed.path, self.container), '', {'X-Auth-Token': token})
return check_response(conn) return check_response(conn)
resp = retry(get, use_account=3) resp = retry(get, use_account=3)
self.assertEquals(resp.read(), ''.join(segments3)) self.assertEquals(resp.read(), ''.join(segments3))
@ -508,7 +509,8 @@ class TestObject(unittest.TestCase):
# Delete the manifest # Delete the manifest
def delete(url, token, parsed, conn, objnum): def delete(url, token, parsed, conn, objnum):
conn.request('DELETE', '%s/%s/manifest' % (parsed.path, conn.request('DELETE', '%s/%s/manifest' % (
parsed.path,
self.container), '', {'X-Auth-Token': token}) self.container), '', {'X-Auth-Token': token})
return check_response(conn) return check_response(conn)
resp = retry(delete, objnum) resp = retry(delete, objnum)
@ -517,8 +519,9 @@ class TestObject(unittest.TestCase):
# Delete the third set of segments # Delete the third set of segments
def delete(url, token, parsed, conn, objnum): def delete(url, token, parsed, conn, objnum):
conn.request('DELETE', '%s/%s/segments3/%s' % (parsed.path, conn.request('DELETE', '%s/%s/segments3/%s' % (
acontainer, str(objnum)), '', {'X-Auth-Token': token}) parsed.path, acontainer, str(objnum)), '',
{'X-Auth-Token': token})
return check_response(conn) return check_response(conn)
for objnum in xrange(len(segments3)): for objnum in xrange(len(segments3)):
resp = retry(delete, objnum) resp = retry(delete, objnum)
@ -527,8 +530,9 @@ class TestObject(unittest.TestCase):
# Delete the second set of segments # Delete the second set of segments
def delete(url, token, parsed, conn, objnum): def delete(url, token, parsed, conn, objnum):
conn.request('DELETE', '%s/%s/segments2/%s' % (parsed.path, conn.request('DELETE', '%s/%s/segments2/%s' % (
self.container, str(objnum)), '', {'X-Auth-Token': token}) parsed.path, self.container, str(objnum)), '',
{'X-Auth-Token': token})
return check_response(conn) return check_response(conn)
for objnum in xrange(len(segments2)): for objnum in xrange(len(segments2)):
resp = retry(delete, objnum) resp = retry(delete, objnum)
@ -537,8 +541,9 @@ class TestObject(unittest.TestCase):
# Delete the first set of segments # Delete the first set of segments
def delete(url, token, parsed, conn, objnum): def delete(url, token, parsed, conn, objnum):
conn.request('DELETE', '%s/%s/segments1/%s' % (parsed.path, conn.request('DELETE', '%s/%s/segments1/%s' % (
self.container, str(objnum)), '', {'X-Auth-Token': token}) parsed.path, self.container, str(objnum)), '',
{'X-Auth-Token': token})
return check_response(conn) return check_response(conn)
for objnum in xrange(len(segments1)): for objnum in xrange(len(segments1)):
resp = retry(delete, objnum) resp = retry(delete, objnum)
@ -559,8 +564,8 @@ class TestObject(unittest.TestCase):
raise SkipTest raise SkipTest
def put(url, token, parsed, conn): def put(url, token, parsed, conn):
conn.request('PUT', '%s/%s/hi' % (parsed.path, conn.request('PUT', '%s/%s/hi' % (parsed.path, self.container),
self.container), 'there', {'X-Auth-Token': token}) 'there', {'X-Auth-Token': token})
return check_response(conn) return check_response(conn)
resp = retry(put) resp = retry(put)
resp.read() resp.read()
@ -581,7 +586,8 @@ class TestObject(unittest.TestCase):
raise SkipTest raise SkipTest
def put(url, token, parsed, conn): def put(url, token, parsed, conn):
conn.request('PUT', '%s/%s/abc%%00def' % (parsed.path, conn.request('PUT', '%s/%s/abc%%00def' % (
parsed.path,
self.container), 'test', {'X-Auth-Token': token}) self.container), 'test', {'X-Auth-Token': token})
return check_response(conn) return check_response(conn)
resp = retry(put) resp = retry(put)