def test_check_force(self):
# This checks to make sure that the force parameter is run. If
# successful. The delete command will fail as the bucket is empty
# and be caught by the exception.
cmd_params = CommandParameters(self.session, 'rb', {'force': True})
cmd_params.parameters['src'] = 's3://mybucket'
cmd_params.check_force(None)
def test_add_paths(self):
"""
This ensures that the paths are assigned properly in the
class's parameters dictionary.
"""
s3_file = "s3://" + self.bucket + "/" + "text1.txt"
path1 = [s3_file, "s3://some_file"]
path2 = [s3_file]
cmd_params = CommandParameters(self.session, "cp", {})
cmd_params2 = CommandParameters(self.session, "rm", {})
cmd_params.check_region([])
cmd_params2.check_region([])
cmd_params.add_paths(path1)
cmd_params2.add_paths(path2)
ref_params = {
"dir_op": False,
"src": s3_file,
"dest": "s3://some_file",
"region": self.session.get_config()["region"],
"paths_type": "s3s3",
}
self.assertEqual(cmd_params.parameters, ref_params)
ref_params2 = {
"dir_op": False,
"src": s3_file,
"dest": s3_file,
"region": self.session.get_config()["region"],
"paths_type": "s3",
}
self.assertEqual(cmd_params2.parameters, ref_params2)
def test_check_path_type_fail(self):
# This tests the class's ability to determine whether the correct
# path types have been passed for a particular command. It test every
# possible combination that is incorrect for every command.
cmds = {'cp': ['local', 'locallocal', 's3'],
'mv': ['local', 'locallocal', 's3'],
'rm': ['local', 'locallocal', 's3s3', 'locals3', 's3local'],
'ls': ['local', 'locallocal', 's3s3', 'locals3', 's3local'],
'sync': ['local', 'locallocal', 's3'],
'mb': ['local', 'locallocal', 's3s3', 'locals3', 's3local'],
'rb': ['local', 'locallocal', 's3s3', 'locals3', 's3local']}
s3_file = 's3://' + self.bucket + '/' + 'text1.txt'
local_file = self.loc_files[0]
combos = {'s3s3': [s3_file, s3_file],
's3local': [s3_file, local_file],
'locals3': [local_file, s3_file],
's3': [s3_file],
'local': [local_file],
'locallocal': [local_file, local_file]}
for cmd in cmds.keys():
cmd_param = CommandParameters(self.session, cmd, {})
cmd_param.check_region(mock.Mock())
wrong_paths = cmds[cmd]
for path_args in wrong_paths:
with self.assertRaises(TypeError):
cmd_param.check_path_type(combos[path_args])
def test_check_path_type_fail(self):
"""
This tests the class's ability to determine whether the correct
path types have been passed for a particular command. It test every
possible combination that is incorrect for every command.
"""
cmds = {
"cp": ["local", "locallocal", "s3"],
"mv": ["local", "locallocal", "s3"],
"rm": ["local", "locallocal", "s3s3", "locals3", "s3local"],
"ls": ["local", "locallocal", "s3s3", "locals3", "s3local"],
"sync": ["local", "locallocal", "s3"],
"mb": ["local", "locallocal", "s3s3", "locals3", "s3local"],
"rb": ["local", "locallocal", "s3s3", "locals3", "s3local"],
}
s3_file = "s3://" + self.bucket + "/" + "text1.txt"
local_file = self.loc_files[0]
combos = {
"s3s3": [s3_file, s3_file],
"s3local": [s3_file, local_file],
"locals3": [local_file, s3_file],
"s3": [s3_file],
"local": [local_file],
"locallocal": [local_file, local_file],
}
for cmd in cmds.keys():
cmd_param = CommandParameters(self.session, cmd, {})
cmd_param.check_region([])
wrong_paths = cmds[cmd]
for path_args in wrong_paths:
with self.assertRaises(TypeError):
cmd_param.check_path_type(combos[path_args])
def test_check_src_path_fail(self):
"""
This tests to see if all of the checks on the source path works. It
does so by testing if s3 objects and and prefixes do not exist as well
as local files and directories. All of these should throw an
exception.
"""
local_file = self.loc_files[0]
local_dir = self.loc_files[3]
fake_s3_file = 's3://' + self.bucket + '/' + 'text1.tx'
fake_local_file = local_file[:-1]
fake_s3_prefix = 's3://' + self.bucket + '/' + 'fake/'
fake_local_dir = local_dir + os.sep + 'fake' + os.sep
# :var files: a list of tuples where the first element is a single
# element list of file paths. The second element is a boolean
# representing if the operation is a directory operation.
files = [([fake_s3_file], False), ([fake_local_file], False),
([fake_s3_prefix], True), ([local_file], True),
([local_dir], False), ([fake_s3_file+'dag'], False)]
parameters = {}
for filename in files:
parameters['dir_op'] = filename[1]
cmd_parameter = CommandParameters(self.session, 'put', parameters)
cmd_parameter.check_region([])
with self.assertRaises(Exception):
cmd_parameter.check_src_path(filename[0])
def test_check_force(self):
# This checks to make sure that the force parameter is run. If
# successful. The delete command will fail as the bucket is empty
# and be caught by the exception.
cmd_params = CommandParameters(self.session, 'rb', {'force': True})
cmd_params.parameters['src'] = 's3://mybucket'
cmd_params.check_force(None)
def test_check_force(self):
"""
This checks to make sure that the force parameter is run. If
successful. The delete command will fail as the bucket is empty
and be caught by the exception.
"""
cmd_params = CommandParameters(self.session, "rb", {"force": True})
cmd_params.parameters["src"] = "s3://mybucket"
cmd_params.check_force(None, None)
def test_check_path_type_pass(self):
# This tests the class's ability to determine whether the correct
# path types have been passed for a particular command. It test every
# possible combination that is correct for every command.
cmds = {
'cp': ['locals3', 's3s3', 's3local'],
'mv': ['locals3', 's3s3', 's3local'],
'rm': ['s3'],
'mb': ['s3'],
'rb': ['s3'],
'sync': ['locals3', 's3s3', 's3local']
}
s3_file = 's3://' + self.bucket + '/' + 'text1.txt'
local_file = self.loc_files[0]
combos = {
's3s3': [s3_file, s3_file],
's3local': [s3_file, local_file],
'locals3': [local_file, s3_file],
's3': [s3_file],
'local': [local_file],
'locallocal': [local_file, local_file]
}
for cmd in cmds.keys():
cmd_param = CommandParameters(self.session, cmd, {})
cmd_param.add_region(mock.Mock())
correct_paths = cmds[cmd]
for path_args in correct_paths:
cmd_param.check_path_type(combos[path_args])
def test_check_src_path_fail(self):
"""
This tests to see if all of the checks on the source path works. It
does so by testing if s3 objects and and prefixes do not exist as well
as local files and directories. All of these should throw an
exception.
"""
local_file = self.loc_files[0]
local_dir = self.loc_files[3]
fake_s3_file = 's3://' + self.bucket + '/' + 'text1.tx'
fake_local_file = local_file[:-1]
fake_s3_prefix = 's3://' + self.bucket + '/' + 'fake/'
fake_local_dir = local_dir + os.sep + 'fake' + os.sep
# :var files: a list of tuples where the first element is a single
# element list of file paths. The second element is a boolean
# representing if the operation is a directory operation.
files = [([fake_s3_file], False), ([fake_local_file], False),
([fake_s3_prefix], True), ([local_file], True),
([local_dir], False), ([fake_s3_file + 'dag'], False)]
parameters = {}
for filename in files:
parameters['dir_op'] = filename[1]
cmd_parameter = CommandParameters(self.session, 'put', parameters)
cmd_parameter.check_region([])
with self.assertRaises(Exception):
cmd_parameter.check_src_path(filename[0])
def test_check_path_type_fail(self):
"""
This tests the class's ability to determine whether the correct
path types have been passed for a particular command. It test every
possible combination that is incorrect for every command.
"""
cmds = {
'cp': ['local', 'locallocal', 's3'],
'mv': ['local', 'locallocal', 's3'],
'rm': ['local', 'locallocal', 's3s3', 'locals3', 's3local'],
'ls': ['local', 'locallocal', 's3s3', 'locals3', 's3local'],
'sync': ['local', 'locallocal', 's3'],
'mb': ['local', 'locallocal', 's3s3', 'locals3', 's3local'],
'rb': ['local', 'locallocal', 's3s3', 'locals3', 's3local']
}
s3_file = 's3://' + self.bucket + '/' + 'text1.txt'
local_file = self.loc_files[0]
combos = {
's3s3': [s3_file, s3_file],
's3local': [s3_file, local_file],
'locals3': [local_file, s3_file],
's3': [s3_file],
'local': [local_file],
'locallocal': [local_file, local_file]
}
for cmd in cmds.keys():
cmd_param = CommandParameters(self.session, cmd, {})
cmd_param.check_region([])
wrong_paths = cmds[cmd]
for path_args in wrong_paths:
with self.assertRaises(TypeError):
cmd_param.check_path_type(combos[path_args])
def test_check_src_path_pass(self):
# This tests to see if all of the checks on the source path works. It
# does so by testing if s3 objects and and prefixes exist as well as
# local files and directories. All of these should not throw an
# exception.
s3_file = 's3://' + self.bucket + '/' + 'text1.txt'
local_file = self.loc_files[0]
s3_prefix = 's3://' + self.bucket
local_dir = self.loc_files[3]
# :var files: a list of tuples where the first element is a single
# element list of file paths. The second element is a boolean
# representing if the operation is a directory operation.
files = [([s3_file], False), ([local_file], False),
([s3_prefix], True), ([local_dir], True)]
parameters = {}
for filename in files:
parameters['dir_op'] = filename[1]
cmd_parameter = CommandParameters(self.session, 'put', parameters)
cmd_parameter.check_region(mock.Mock())
cmd_parameter.check_src_path(filename[0])
def test_region(self):
# This tests the ability to specify the region and throw an error
# if a region is never specified whether if it is an environment
# variable, config file, or parsed global.
cmd_params = CommandParameters(self.session, 'mb', {})
parser = argparse.ArgumentParser()
parser.add_argument('--region', nargs=1)
parser.add_argument('--test', action='store_true')
parsed_args = parser.parse_args(['--region', 'eu-west-1'])
cmd_params.check_region(parsed_args)
self.assertEqual(cmd_params.parameters['region'][0], 'eu-west-1')
cmd_params2 = CommandParameters(self.mock, 'mb', {})
parsed_args2 = parser.parse_args(['--test'])
with self.assertRaises(Exception):
cmd_params2.check_region(parsed_args2)
def test_add_paths(self):
"""
This ensures that the paths are assigned properly in the
class's parameters dictionary.
"""
s3_file = 's3://' + self.bucket + '/' + 'text1.txt'
path1 = [s3_file, 's3://some_file']
path2 = [s3_file]
cmd_params = CommandParameters(self.session, 'cp', {})
cmd_params2 = CommandParameters(self.session, 'rm', {})
cmd_params.check_region([])
cmd_params2.check_region([])
cmd_params.add_paths(path1)
cmd_params2.add_paths(path2)
ref_params = {'dir_op': False, 'src': s3_file,
'dest': 's3://some_file',
'region': self.session.get_config()['region'],
'paths_type': 's3s3'}
self.assertEqual(cmd_params.parameters, ref_params)
ref_params2 = {'dir_op': False, 'src': s3_file, 'dest': s3_file,
'region': self.session.get_config()['region'],
'paths_type': 's3'}
self.assertEqual(cmd_params2.parameters, ref_params2)
def test_region(self):
# This tests the ability to specify the region and throw an error
# if a region is never specified whether if it is an environment
# variable, config file, or parsed global.
cmd_params = CommandParameters(self.session, 'mb', {})
parser = argparse.ArgumentParser()
parser.add_argument('--region', nargs=1)
parser.add_argument('--test', action='store_true')
parsed_args = parser.parse_args(['--region', 'eu-west-1'])
cmd_params.check_region(parsed_args)
self.assertEqual(cmd_params.parameters['region'][0], 'eu-west-1')
cmd_params2 = CommandParameters(self.mock, 'mb', {})
parsed_args2 = parser.parse_args(['--test'])
with self.assertRaises(Exception):
cmd_params2.check_region(parsed_args2)
def test_region(self):
"""
This tests the ability to specify the region and throw an error
if a region is never specified whether if it is an environment
variable, config file, or parsed global.
"""
cmd_params = CommandParameters(self.session, "mb", {})
parser = argparse.ArgumentParser()
parser.add_argument("--region", nargs=1)
parser.add_argument("--test", action="store_true")
parsed_args = parser.parse_args(["--region", "eu-west-1"])
cmd_params.check_region(parsed_args)
self.assertEqual(cmd_params.parameters["region"][0], "eu-west-1")
cmd_params2 = CommandParameters(self.mock, "mb", {})
parsed_args2 = parser.parse_args(["--test"])
with self.assertRaises(Exception):
cmd_params2.check_region(parsed_args2)
def test_check_src_path_pass(self):
# This tests to see if all of the checks on the source path works. It
# does so by testing if s3 objects and and prefixes exist as well as
# local files and directories. All of these should not throw an
# exception.
s3_file = 's3://' + self.bucket + '/' + 'text1.txt'
local_file = self.loc_files[0]
s3_prefix = 's3://' + self.bucket
local_dir = self.loc_files[3]
# :var files: a list of tuples where the first element is a single
# element list of file paths. The second element is a boolean
# representing if the operation is a directory operation.
files = [([s3_file], False), ([local_file], False),
([s3_prefix], True), ([local_dir], True)]
parameters = {}
for filename in files:
parameters['dir_op'] = filename[1]
cmd_parameter = CommandParameters(self.session, 'put', parameters)
cmd_parameter.add_region(mock.Mock())
cmd_parameter.check_src_path(filename[0])
def test_add_paths(self):
"""
This ensures that the paths are assigned properly in the
class's parameters dictionary.
"""
s3_file = 's3://' + self.bucket + '/' + 'text1.txt'
path1 = [s3_file, 's3://some_file']
path2 = [s3_file]
cmd_params = CommandParameters(self.session, 'cp', {})
cmd_params2 = CommandParameters(self.session, 'rm', {})
cmd_params.check_region([])
cmd_params2.check_region([])
cmd_params.add_paths(path1)
cmd_params2.add_paths(path2)
ref_params = {
'dir_op': False,
'src': s3_file,
'dest': 's3://some_file',
'region': self.session.get_config()['region'],
'paths_type': 's3s3'
}
self.assertEqual(cmd_params.parameters, ref_params)
ref_params2 = {
'dir_op': False,
'src': s3_file,
'dest': s3_file,
'region': self.session.get_config()['region'],
'paths_type': 's3'
}
self.assertEqual(cmd_params2.parameters, ref_params2)
