Python s3.CommandParameters类代码示例

 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_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_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_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_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_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)