def testListCallsContextStoreToListFiles(self):
exp_list = [Minifile(file_id="1"),
Minifile(file_id="2")]
self.context_store_mock.list.return_value = exp_list
self.storage.list()
self.context_store_mock.list.assert_called()
def testListReturnsListOfFiles(self):
exp_list = [Minifile(file_id="1"),
Minifile(file_id="2")]
self.context_store_mock.list.return_value = exp_list
act_list = self.storage.list()
self.assertEqual(exp_list, act_list)
def testMifileFromJson(self):
exp_file = Minifile(file_id='1',
file_name='name',
chunk_ids=['1', '2', '3'],
chunk_size=10)
ext_dict = exp_file.to_dict()
self.assertEqual(exp_file, Minifile().from_dict(ext_dict))
def testMinifileToDict(self):
minifile = Minifile(file_id='1',
file_name='name',
chunk_ids=['1', '2', '3'],
chunk_size=10)
d = {
'file_id': minifile.file_id,
'file_name': minifile.file_name,
'chunk_size': minifile.chunk_size,
'chunk_ids': minifile.chunk_ids
}
self.assertEqual(d, minifile.to_dict())
def testLoadCallsObjectStoreForEachChunk(self):
mbf = Minifile(chunk_ids=[1, 2, 3, 4, 5])
self.object_store_mock.load.return_value = KeyValue('id', b'12345')
self.storage._load(mbf)
self.object_store_mock.load.assert_has_calls([call(1), call(2), call(3), call(4), call(5)])
def testDeleteThrowsKeyErrorIfChunkNotFound(self):
metadata = Minifile(chunk_ids=[1])
def delete_raise_io_error(id):
raise KeyError("ObjectStore: Chunk not found id = %s" % id)
self.storage._object_store.delete = delete_raise_io_error
self.assertRaises(KeyError, self.storage._delete, metadata)
def testDeleteCallsContextStoreToLoadFileMetadata(self):
# We disable the internal _load function as we are not interested for this test
def disable_internal_delete(any):
pass
self.storage._delete = disable_internal_delete
exp_file = Minifile(file_id="id")
self.context_store_mock.load.return_value = exp_file
self.storage.delete(exp_file.file_id)
self.context_store_mock.load.assert_has_calls([call(exp_file.file_id)])
def testSaveCallsContextStoreToSaveFileMetadata(self):
# We disable the internal _save function as we are not interested for this test
def disable_internal_save(any):
pass
self.storage._save = disable_internal_save
file = Minifile()
self.storage.save(file)
self.context_store_mock.save.assert_has_calls([call(file)])
def list_files():
headers = {
'cache-control': "no-cache",
}
response = requests.request("GET", based_uri, headers=headers)
# Validating response
assert response.status_code == 200
l = response.json()
return [Minifile().from_dict(s) for s in l]
def testLoadReturnsMinifile(self):
# We disable the internal _load function as we are not interested for this test
def disable_internal_load(any):
pass
self.storage._load = disable_internal_load
exp_file = Minifile(file_id="id", file_name="file")
self.context_store_mock.load.return_value = exp_file
act_file = self.storage.load(exp_file.file_id)
self.assertEqual(exp_file, act_file)
def testDeleteReturnsMinifileOfDeletedFile(self):
# We disable the internal _delete function as we are not interested for this test
def disable_internal_delete(any):
pass
self.storage._delete = disable_internal_delete
exp_file = Minifile(file_id="id")
self.context_store_mock.load.return_value = exp_file
act_file = self.storage.delete(exp_file.file_id)
self.assertEqual(exp_file, act_file)
def upload_file(file_name):
files = {'file': (file_name, open(file_name, 'rb'))}
response = requests.request("POST", based_uri + '/upload', files=files)
# Validating response
assert response.status_code == 200
minifile = Minifile().from_dict(response.json())
assert minifile.file_id
assert minifile.file_name == file_name
return minifile
def delete_file(file_id):
url = based_uri + "/delete/" + file_id
headers = {
'cache-control': "no-cache",
}
response = requests.request("DELETE", url, headers=headers)
assert response.status_code == 200
minifile = Minifile().from_dict(response.json())
return minifile
def testSaveCallsObjectStoreForEachChunk(self):
FileStorage.generate_object_id = lambda x: 'id'
stream = io.BytesIO('12345'.encode())
mbf = Minifile(file_stream=stream, chunk_size=1)
self.storage._save(mbf)
self.object_store_mock.save.assert_has_calls([call(KeyValue('id', b'1')),
call(KeyValue('id', b'2')),
call(KeyValue('id', b'3')),
call(KeyValue('id', b'4')),
call(KeyValue('id', b'5'))])
def testLoadReturnsStream(self):
exp_stream = io.BytesIO('12345'.encode())
chunk_size = 1
mbf = Minifile(chunk_size=chunk_size,
file_stream=exp_stream,
chunk_ids=[1, 2, 3, 4, 5])
# Work around as I cannot manage to make it working with Mock library
def load_return_exp_stream(id):
return KeyValue(id, exp_stream.read(chunk_size))
self.storage._object_store.load = load_return_exp_stream
self.storage._load(mbf)
act_stream = mbf.file_stream
exp_stream.seek(0)
self.assertEqual(act_stream.read(), exp_stream.read())
def testSavesSplitsStreamInTenChunks(self):
file = Minifile(file_stream=io.BytesIO('1234567890'.encode()), chunk_size=1)
self.storage._save(file)
self.assertEqual(len(file.chunk_ids), 10)
def testSaveThrowValueErrorIfChunkSizeLessThanMinChunkSize(self):
self.assertRaises(ValueError, self.storage._save, Minifile(chunk_size=FileStorage.MIN_CHUNK_SIZE - 1))
def testMinifileToDictWhenNoFields(self):
self.assertEqual({}, Minifile().to_dict())
def testSaveThrowValueErrorIfChunkSizeGreaterThanMaxChunkSize(self):
self.assertRaises(ValueError, self.storage._save, Minifile(chunk_size=FileStorage.MAX_CHUNK_SIZE + 1))
def list(self):
return [
Minifile().from_dict(json.loads(obj.value))
for obj in ContextKeyValue.objects().all()
]
def load(self, file_id):
return Minifile().from_dict(
json.loads(ContextKeyValue.get(key=file_id).value))
def testSaveGeneratesNoChunksIfStreamIsEmpty(self):
file = Minifile(file_stream=io.BytesIO(), chunk_size=1)
self.storage._save(file)
self.assertTrue(len(file.chunk_ids) == 0)
def testLoadThrowsValueErrorIsFileMetadataHasNoChunks(self):
mbf = Minifile()
self.assertRaises(ValueError, self.storage._load, mbf)
def list(self):
return [
Minifile().from_dict(json.loads(obj))
for obj in self._memory_db.values()
]
def load(self, file_id):
res = requests.get(self.rest_endpoint + '/%s' % file_id)
if res.status_code is not 200:
raise IOError('Impossible to load the file')
return Minifile().from_dict(res.json())
def testDeleteThrowsValueErrorIfFileMetadataHasNoChunks(self):
mbf = Minifile()
self.assertRaises(ValueError, self.storage._delete, mbf)
def testDeleteCallsObjectStoreDeleteForEachChunkId(self):
mbf = Minifile(chunk_ids=[1, 2, 3])
calls = [call(1), call(2), call(3)]
self.storage._delete(mbf)
self.object_store_mock.delete.assert_has_calls(calls)
def testSaveNoCallsObjectStoreIfStreamIsEmpty(self):
mbf = Minifile(file_stream=io.BytesIO(), chunk_size=1)
self.storage._save(mbf)
self.object_store_mock.assert_not_called()
def list(self):
res = requests.get(self.rest_endpoint)
if res.status_code is not 200:
raise IOError('Impossible to list files')
return [Minifile().from_dict(x) for x in res.json()]
def load(self, file_id):
return Minifile().from_dict(json.loads(self._memory_db[file_id]))
