def test_all_files__files_available__lists_files(self):
""" Tests that all_files calls both files() and more_files() and yields File objects. """
bucket = Bucket(self.mock_api, {})
names = (
'f1',
'f2',
'f3',
)
f1 = File(self.mock_api, bucket, {'fileName': names[0]})
f2 = File(self.mock_api, bucket, {'fileName': names[1]})
f3 = File(self.mock_api, bucket, {'fileName': names[2]})
bucket.files = MagicMock()
bucket.more_files = MagicMock()
bucket.files.return_value = [f1]
bucket.more_files.return_value = [[f2], [f3]]
args = (
'prefix',
'delimiter',
0,
'start_name',
)
index = 0
for index, bucket_file in enumerate(bucket.all_files(*args)):
self.assertTrue(isinstance(bucket_file, File))
self.assertIs(bucket_file._api, self.mock_api)
self.assertEqual(bucket_file.name, names[index])
bucket.files.assert_called_with(*args)
bucket.more_files.assert_called()
self.assertEqual(index, len(names) - 1)
def test_folder__folder_with_delimiter__lists_files(self):
""" Tests that the prefix is used as-is if it is suffixed with the delimiter. """
bucket = Bucket(self.mock_api, {})
bucket.files = MagicMock()
delimiter = 'delimiter'
prefix = 'prefix' + delimiter
max_files = 0
bucket.folder(prefix, delimiter, max_files)
bucket.files.assert_called_with(prefix, delimiter, max_files)
def test_file__retrieve_by_id_success__retrieves_file(self):
""" Tests retrieving a file by its name. """
file_info = Responses.get_file_info.value.dict
self.mock_api.get_file_info.return_value = file_info
bucket = Bucket(self.mock_api, {})
file_ = bucket.file(file_id=file_info['fileId'])
self.assertTrue(isinstance(file_, File))
self.assertIs(file_.bucket, bucket)
self.assertIs(file_._api, self.mock_api)
self.assertEqual(file_.name, file_info['fileName'])
def test_folder__folder_without_delimiter__appends_delimiter_and_lists_files(
self):
""" Tests that the prefix is appended with the delimiter if it lacks it. """
bucket = Bucket(self.mock_api, {})
bucket.files = MagicMock()
prefix = 'prefix'
delimiter = 'delimiter'
max_files = 0
bucket.folder(prefix, delimiter, max_files)
bucket.files.assert_called_with(prefix + delimiter, delimiter,
max_files)
def test_files__lists_bucket_files(self):
""" Tests the bucket can list its files . """
self.mock_api.list_files.return_value = Responses.list_files.value.dict
bucket = Bucket(self.mock_api, {'bucketId': 'bucket_id'})
args = ('prefix', '/', 'start_name', 50)
files = bucket.files(*args)
self.mock_api.list_files.assert_called_with(*args, bucket.id)
for file_ in files:
self.assertTrue(isinstance(file_, File))
self.assertIs(file_.bucket, bucket)
self.assertIs(file_._api, self.mock_api)
def test_upload_iter__upload_success(self):
bucket_id = 'bucket_id'
bucket = Bucket(self.mock_api, {'bucketId': bucket_id})
file_info = Responses.get_file_info.json
iter_data = [
({}, 1, 2),
({}, 2, 2),
(file_info, 0, 2),
]
self.mock_api.upload.return_value = iter(iter_data)
args = (Path(), 'upload', True, 0)
for iteration, expected in zip(bucket.upload_iter(*args), iter_data):
self.assertEqual(iteration, expected)
self.mock_api.upload.assert_called_with(*args, bucket.id)
def test_file__retrieve_by_name_success__retrieves_file(self):
""" Tests retrieving a file by its id. """
bucket = Bucket(self.mock_api, {})
file_name = 'file_name'
file_data = [File(self.mock_api, bucket, {'fileName': file_name})]
bucket.files = MagicMock()
bucket.files.return_value = file_data
file_ = bucket.file(file_name=file_name)
bucket.files.assert_called_with(start_name=file_name, max_files=1)
self.assertTrue(isinstance(file_, File))
self.assertIs(file_.bucket, bucket)
self.assertIs(file_._api,
self.mock_api) # pylint: disable = protected-access
self.assertEqual(file_.name, file_name)
def test_more_files__no_available_params__breaks(self):
""" Tests that the method breaks if the paratemers for the next request are empty. """
bucket = Bucket(self.mock_api, {})
bucket._next_files = False
bucket._next_params = (1, 2, 3)
self.assertEqual([], list(bucket.more_files()))
bucket._next_files = True
bucket._next_params = False
self.assertEqual([], list(bucket.more_files()))
def test_init__bucket_initialized(self):
""" Tests object attributes are being correctly initialized. """
bucket_info = Responses.list_buckets.value.dict['buckets'][0]
bucket = Bucket(self.mock_api, bucket_info)
self.assertIs(bucket._api, self.mock_api)
self.assertEqual(bucket.id, bucket_info['bucketId'])
self.assertEqual(bucket.name, bucket_info['bucketName'])
self.assertEqual(bucket.type, BucketType(bucket_info['bucketType']))
def test_upload__upload_success(self):
""" Tests uploading a file to the bucket. """
bucket_id = 'bucket_id'
bucket = Bucket(self.mock_api, {'bucketId': bucket_id})
file_info = Responses.get_file_info.json
self.mock_api.upload.return_value = iter([
({}, 1, 2),
({}, 2, 2),
(file_info, 0, 2),
])
args = (Path(), 'upload', True, 0)
file = bucket.upload(*args)
self.assertIsInstance(file, File)
self.assertEqual(file.api, self.mock_api)
self.assertEqual(file.bucket, bucket)
self.assertEqual(file.id, file_info['fileId'])
self.assertEqual(file.name, file_info['fileName'])
self.mock_api.upload.assert_called_with(*args, bucket.id)
def test_str(self):
""" Tests that the __str__ and __repr__ methods. """
name = 'bucket_name'
bucket_id = 'bucket_id'
bucket = Bucket(self.mock_api, {
'bucketName': name,
'bucketId': bucket_id
})
self.assertEqual(str(bucket), name)
self.assertTrue(Bucket.__name__ in repr(bucket))
self.assertTrue(name in repr(bucket))
self.assertTrue(bucket_id in repr(bucket))
def test_more_files__no_more_files__breaks(self):
""" Tests that the method breaks if the request returns empty results. """
bucket = Bucket(self.mock_api, {})
bucket.files = MagicMock()
bucket.files.return_value = []
bucket._next_files = True
bucket._next_params = (1, 2, 3)
self.assertEqual([], list(bucket.more_files()))
bucket.files.assert_called_with(*bucket._next_params,
bucket._next_files)
def test_more_files__files_available__yields_files(self):
""" Tests that more files are listed if available. """
bucket = Bucket(self.mock_api, {})
bucket.files = MagicMock()
names = ('f1', 'f2')
bucket.files.side_effect = [
[File(self.mock_api, bucket, {'fileName': names[0]})],
[File(self.mock_api, bucket, {'fileName': names[1]})],
]
bucket._next_files = True
bucket._next_params = (1, 2, 3)
more_files_generator = bucket.more_files()
for name in names:
files = next(more_files_generator)
self.assertTrue(isinstance(files, list))
self.assertTrue(isinstance(files[0], File))
self.assertEqual(files[0].name, name)
self.assertRaises(RuntimeError, next, more_files_generator)
def test_delete__delete_success(self):
""" Tests deleting the bucket. """
bucket_id = 'bucket_id'
bucket = Bucket(self.mock_api, {'bucketId': bucket_id})
bucket.delete()
self.mock_api.delete_bucket.assert_called_with(bucket.id)
def test_file__retrieve_by_name_failure__raises_file_error(self):
""" Tests failure when retrieving a file by its id. """
bucket = Bucket(self.mock_api, {})
bucket.files = MagicMock()
bucket.files.return_value = []
self.assertRaises(FileError, bucket.file, file_name='file_name')
def test_file__retrieve_by_id_failure__raises_file_error(self):
""" Tests failure when retrieving a file by its name. """
self.mock_api.get_file_info.side_effect = ResponseError
bucket = Bucket(self.mock_api, {})
self.assertRaises(FileError, bucket.file, 'file_id')
