def test_server_capabilities_network_failure(self):
self.mock(isolateserver.net, 'url_open',
lambda *_args, **_kwargs: None)
with self.assertRaises(isolateserver.MappingError):
storage = isolateserver.IsolateServer('http://example.com',
'default')
_ = storage._server_capabilities
def test_push_failure_finalize(self):
server = 'http://example.com'
namespace = 'default'
token = 'fake token'
data = ''.join(str(x) for x in xrange(1000))
item = FakeItem(data)
push_urls = (server + '/push_here', server + '/call_this')
contains_request = [{'h': item.digest, 's': item.size, 'i': 0}]
contains_response = [push_urls]
self._requests = [
self.mock_handshake_request(server, token),
self.mock_contains_request(server, namespace, token,
contains_request, contains_response),
(push_urls[0], {
'data': data,
'content_type': 'application/octet-stream',
'method': 'PUT',
}, ''),
(push_urls[1], {
'data': '',
'content_type': 'application/json',
'method': 'POST',
}, None),
]
storage = isolateserver.IsolateServer(server, namespace)
missing = storage.contains([item])
self.assertEqual([item], missing)
with self.assertRaises(IOError):
storage.push(item, [data])
self.assertTrue(item.push_state.uploaded)
self.assertFalse(item.push_state.finalized)
def test_push_failure_upload(self):
server = 'http://example.com'
namespace = 'default'
data = ''.join(str(x) for x in xrange(1000))
item = FakeItem(data)
contains_request = {'items': [
{'digest': item.digest, 'size': item.size, 'is_isolated': 0}]}
contains_response = {'items': [{'index': 0, 'upload_ticket': 'ticket!'}]}
requests = [
self.mock_contains_request(
server, namespace, contains_request, contains_response),
self.mock_upload_request(
server,
base64.b64encode(data),
contains_response['items'][0]['upload_ticket'],
),
]
self.expected_requests(requests)
storage = isolateserver.IsolateServer(server, namespace)
missing = storage.contains([item])
self.assertEqual([item], missing.keys())
push_state = missing[item]
with self.assertRaises(IOError):
storage.push(item, push_state, [data])
self.assertFalse(push_state.uploaded)
self.assertFalse(push_state.finalized)
def test_fetch_offset_bad_header(self):
server = 'http://example.com'
namespace = 'default'
data = ''.join(str(x) for x in xrange(1000))
item = ALGO(data).hexdigest()
offset = 200
size = len(data)
bad_content_range_headers = [
# Missing header.
None,
'',
# Bad format.
'not bytes %d-%d/%d' % (offset, size - 1, size),
'bytes %d-%d' % (offset, size - 1),
# Bad offset.
'bytes %d-%d/%d' % (offset - 1, size - 1, size),
# Incomplete chunk.
'bytes %d-%d/%d' % (offset, offset + 10, size),
]
for content_range_header in bad_content_range_headers:
self._requests = [
self.mock_fetch_request(
server,
namespace,
item,
data[offset:],
request_headers={'Range': 'bytes=%d-' % offset},
response_headers={'Content-Range': content_range_header}),
]
storage = isolateserver.IsolateServer(server, namespace)
with self.assertRaises(IOError):
_ = ''.join(storage.fetch(item, offset))
def test_fetch_offset_success(self):
server = 'http://example.com'
namespace = 'default'
data = ''.join(str(x) for x in xrange(1000))
item = ALGO(data).hexdigest()
offset = 200
size = len(data)
good_content_range_headers = [
'bytes %d-%d/%d' % (offset, size - 1, size),
'bytes %d-%d/*' % (offset, size - 1),
]
for content_range_header in good_content_range_headers:
self._requests = [
self.mock_fetch_request(
server,
namespace,
item,
data[offset:],
request_headers={'Range': 'bytes=%d-' % offset},
response_headers={'Content-Range': content_range_header}),
]
storage = isolateserver.IsolateServer(server, namespace)
fetched = ''.join(storage.fetch(item, offset))
self.assertEqual(data[offset:], fetched)
def test_contains_success(self):
server = 'http://example.com'
namespace = 'default'
files = [
FakeItem('1', high_priority=True),
FakeItem('2' * 100),
FakeItem('3' * 200),
]
request = {'items': [
{'digest': f.digest, 'is_isolated': not i, 'size': f.size}
for i, f in enumerate(files)]}
response = {
'items': [
{'index': str(i), 'upload_ticket': 'ticket_%d' % i}
for i in xrange(3)],
}
missing = [
files[0],
files[1],
files[2],
]
self._requests = [
self.mock_contains_request(server, namespace, request, response),
]
storage = isolateserver.IsolateServer(server, namespace)
result = storage.contains(files)
self.assertEqual(set(missing), set(result.keys()))
for i, (_item, push_state) in enumerate(result.iteritems()):
self.assertEqual(
push_state.upload_url, '_ah/api/isolateservice/v1/store_inline')
self.assertEqual(push_state.finalize_url, None)
def test_server_capabilities_success(self):
server = 'http://example.com'
namespace = 'default'
self.expected_requests([self.mock_server_details_request(server)])
storage = isolateserver.IsolateServer(server, namespace)
caps = storage._server_capabilities
self.assertEqual({'server_version': 'such a good version'}, caps)
def test_contains_format_failure(self):
server = 'http://example.com'
namespace = 'default'
self.expected_requests([self.mock_contains_request(
server, namespace, {'items': []}, None)])
storage = isolateserver.IsolateServer(server, namespace)
with self.assertRaises(isolated_format.MappingError):
storage.contains([])
def test_fetch_failure(self):
server = 'http://example.com'
namespace = 'default'
item = isolateserver_mock.hash_content('something')
self.expected_requests(
[self.mock_fetch_request(server, namespace, item)[:-1] + (None, )])
storage = isolateserver.IsolateServer(server, namespace)
with self.assertRaises(IOError):
_ = ''.join(storage.fetch(item))
def test_fetch_failure(self):
server = 'http://example.com'
namespace = 'default'
item = ALGO('something').hexdigest()
self._requests = [
self.mock_fetch_request(server, namespace, item, None),
]
storage = isolateserver.IsolateServer(server, namespace)
with self.assertRaises(IOError):
_ = ''.join(storage.fetch(item))
def test_server_capabilities_respects_error(self):
server = 'http://example.com'
namespace = 'default'
error = 'Im sorry, Dave. Im afraid I cant do that.'
self._requests = [self.mock_handshake_request(server, error=error)]
storage = isolateserver.IsolateServer(server, namespace)
with self.assertRaises(isolateserver.MappingError) as context:
_ = storage._server_capabilities
# Server error message should be reported to user.
self.assertIn(error, str(context.exception))
def test_fetch_success(self):
server = 'http://example.com'
namespace = 'default'
data = ''.join(str(x) for x in xrange(1000))
item = isolateserver_mock.hash_content(data)
self.expected_requests(
[self.mock_fetch_request(server, namespace, item, data)])
storage = isolateserver.IsolateServer(server, namespace)
fetched = ''.join(storage.fetch(item))
self.assertEqual(data, fetched)
def test_server_capabilities_success(self):
server = 'http://example.com'
namespace = 'default'
access_token = 'fake token'
self._requests = [
self.mock_handshake_request(server, access_token),
]
storage = isolateserver.IsolateServer(server, namespace)
caps = storage._server_capabilities
self.assertEqual(access_token, caps['access_token'])
def test_server_capabilities_format_failure(self):
server = 'http://example.com'
namespace = 'default'
handshake_req = self.mock_handshake_request(server)
self._requests = [
(handshake_req[0], handshake_req[1], 'Im a bad response'),
]
storage = isolateserver.IsolateServer(server, namespace)
with self.assertRaises(isolateserver.MappingError):
_ = storage._server_capabilities
def test_contains_format_failure(self):
server = 'http://example.com'
namespace = 'default'
token = 'fake token'
self._requests = [
self.mock_handshake_request(server, token),
self.mock_contains_request(server, namespace, token, [], [1, 2, 3])
]
storage = isolateserver.IsolateServer(server, namespace)
with self.assertRaises(isolateserver.MappingError):
storage.contains([])
def test_fetch_success(self):
server = 'http://example.com'
namespace = 'default'
data = ''.join(str(x) for x in xrange(1000))
item = ALGO(data).hexdigest()
self._requests = [
self.mock_fetch_request(server, namespace, item, data),
]
storage = isolateserver.IsolateServer(server, namespace)
fetched = ''.join(storage.fetch(item))
self.assertEqual(data, fetched)
def test_contains_network_failure(self):
server = 'http://example.com'
namespace = 'default'
token = 'fake token'
req = self.mock_contains_request(server, namespace, token, [], [])
self._requests = [
self.mock_handshake_request(server, token),
(req[0], req[1], None),
]
storage = isolateserver.IsolateServer(server, namespace)
with self.assertRaises(isolateserver.MappingError):
storage.contains([])
def test_push_failure_finalize(self):
server = 'http://example.com'
namespace = 'default'
data = ''.join(str(x) for x in xrange(1000))
item = FakeItem(data)
contains_request = {
'items': [{
'digest': item.digest,
'size': item.size,
'is_isolated': 0
}]
}
contains_response = {
'items': [{
'index': 0,
'gs_upload_url': server + '/content-gs/whatevs/1234',
'upload_ticket': 'ticket!'
}]
}
requests = [
self.mock_contains_request(server, namespace, contains_request,
contains_response),
(
server + '/content-gs/whatevs/1234',
{
'data': data,
'content_type': 'application/octet-stream',
'method': 'PUT',
},
'',
None,
),
(
server + '/_ah/api/isolateservice/v1/finalize_gs_upload',
{
'data': {
'upload_ticket': 'ticket!'
}
},
None,
),
]
self.expected_requests(requests)
storage = isolateserver.IsolateServer(server, namespace)
missing = storage.contains([item])
self.assertEqual([item], missing.keys())
push_state = missing[item]
with self.assertRaises(IOError):
storage.push(item, push_state, [data])
self.assertTrue(push_state.uploaded)
self.assertFalse(push_state.finalized)
def test_contains_success(self):
server = 'http://example.com'
namespace = 'default'
token = 'fake token'
files = [
FakeItem('1', is_isolated=True),
FakeItem('2' * 100),
FakeItem('3' * 200),
]
request = [
{
'h': files[0].digest,
's': files[0].size,
'i': 1
},
{
'h': files[1].digest,
's': files[1].size,
'i': 0
},
{
'h': files[2].digest,
's': files[2].size,
'i': 0
},
]
response = [
None,
['http://example/upload_here_1', None],
['http://example/upload_here_2', 'http://example/call_this'],
]
missing = [
files[1],
files[2],
]
self._requests = [
self.mock_handshake_request(server, token),
self.mock_contains_request(server, namespace, token, request,
response),
]
storage = isolateserver.IsolateServer(server, namespace)
result = storage.contains(files)
self.assertEqual(missing, result)
self.assertEqual([x for x in response if x],
[[i.push_state.upload_url, i.push_state.finalize_url]
for i in missing])
def test_fetch_offset_success(self):
server = 'http://example.com'
namespace = 'default'
data = ''.join(str(x) for x in xrange(1000))
item = isolateserver_mock.hash_content(data)
offset = 200
size = len(data)
good_content_range_headers = [
'bytes %d-%d/%d' % (offset, size - 1, size),
'bytes %d-%d/*' % (offset, size - 1),
]
for _content_range_header in good_content_range_headers:
self.expected_requests([self.mock_fetch_request(
server, namespace, item, data, offset=offset)])
storage = isolateserver.IsolateServer(server, namespace)
fetched = ''.join(storage.fetch(item, offset))
self.assertEqual(data[offset:], fetched)
