def test_contains_success(self):
server_ref = isolate_storage.ServerRef('http://example.com', '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 range(3)],
}
missing = [
files[0],
files[1],
files[2],
]
self._requests = [self.mock_contains_request(server_ref, request, response)]
storage = isolate_storage.IsolateServer(server_ref)
result = storage.contains(files)
self.assertEqual(set(missing), set(result.keys()))
for i, (_item, push_state) in enumerate(result.items()):
self.assertEqual(
push_state.upload_url, '_ah/api/isolateservice/v1/store_inline')
self.assertEqual(push_state.finalize_url, None)
def test_contains_format_failure(self):
server_ref = isolate_storage.ServerRef('http://example.com', 'default')
self.expected_requests(
[self.mock_contains_request(server_ref, {'items': []}, None)])
storage = isolate_storage.IsolateServer(server_ref)
with self.assertRaises(isolated_format.MappingError):
storage.contains([])
def test_fetch_offset_bad_header(self):
server_ref = isolate_storage.ServerRef('http://example.com', 'default')
data = ''.join(str(x) for x in range(1000))
item = isolateserver_fake.hash_content(data)
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.expected_requests([
self.mock_fetch_request(server_ref, item, offset=offset),
self.mock_gs_request(
server_ref, item, data, offset=offset,
request_headers={'Range': 'bytes=%d-' % offset},
response_headers={'Content-Range': content_range_header}),
])
storage = isolate_storage.IsolateServer(server_ref)
with self.assertRaises(IOError):
_ = ''.join(storage.fetch(item, 0, offset))
def test_push_failure_upload(self):
server_ref = isolate_storage.ServerRef('http://example.com', 'default')
data = ''.join(str(x) for x in range(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_ref, contains_request, contains_response),
self.mock_upload_request(
server_ref,
base64.b64encode(data),
contains_response['items'][0]['upload_ticket'],
),
]
self.expected_requests(requests)
storage = isolate_storage.IsolateServer(server_ref)
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_server_capabilities_success(self):
server = 'http://example.com'
namespace = 'default'
self.expected_requests([self.mock_server_details_request(server)])
storage = isolate_storage.IsolateServer(server, namespace)
caps = storage._server_capabilities
self.assertEqual({'server_version': 'such a good version'}, caps)
def test_push_success(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'],
{'ok': True},
),
]
self.expected_requests(requests)
storage = isolate_storage.IsolateServer(server, namespace)
missing = storage.contains([item])
self.assertEqual([item], missing.keys())
push_state = missing[item]
storage.push(item, push_state, [data])
self.assertTrue(push_state.uploaded)
self.assertTrue(push_state.finalized)
def test_fetch_failure(self):
server_ref = isolate_storage.ServerRef('http://example.com', 'default')
item = isolateserver_fake.hash_content('something')
self.expected_requests(
[self.mock_fetch_request(server_ref, item)[:-1] + (None,)])
storage = isolate_storage.IsolateServer(server_ref)
with self.assertRaises(IOError):
_ = ''.join(storage.fetch(item, 0, 0))
def test_fetch_success(self):
server_ref = isolate_storage.ServerRef('http://example.com', 'default')
data = ''.join(str(x) for x in range(1000))
item = isolateserver_fake.hash_content(data)
self.expected_requests([self.mock_fetch_request(server_ref, item, data)])
storage = isolate_storage.IsolateServer(server_ref)
fetched = ''.join(storage.fetch(item, 0, 0))
self.assertEqual(data, fetched)
def test_contains_format_failure(self):
server = 'http://example.com'
namespace = 'default'
self.expected_requests([self.mock_contains_request(
server, namespace, {'items': []}, None)])
storage = isolate_storage.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 = isolate_storage.IsolateServer(server, namespace)
with self.assertRaises(IOError):
_ = ''.join(storage.fetch(item, 0, 0))
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 = isolate_storage.IsolateServer(server, namespace)
fetched = ''.join(storage.fetch(item, 0, 0))
self.assertEqual(data, fetched)
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 + '/FAKE_GCS/whatevs/1234',
'upload_ticket': 'ticket!'
}]
}
requests = [
self.mock_contains_request(server, namespace, contains_request,
contains_response),
(
server + '/FAKE_GCS/whatevs/1234',
{
'data': data,
'content_type': 'application/octet-stream',
'method': 'PUT',
'headers': {
'Cache-Control': 'public, max-age=31536000'
},
},
'',
None,
),
(
server + '/_ah/api/isolateservice/v1/finalize_gs_upload',
{
'data': {
'upload_ticket': 'ticket!'
}
},
None,
),
]
self.expected_requests(requests)
storage = isolate_storage.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_fetch_offset_success(self):
server_ref = isolate_storage.ServerRef('http://example.com', 'default')
data = ''.join(str(x) for x in range(1000))
item = isolateserver_fake.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_ref, item, data, offset=offset)])
storage = isolate_storage.IsolateServer(server_ref)
fetched = ''.join(storage.fetch(item, 0, offset))
self.assertEqual(data[offset:], fetched)
