CoCalc -- test_config.py

GitHub Repository: aws/aws-cli
Path: blob/develop/tests/unit/customizations/emr/test_config.py
¹⁵⁶⁹ views
1
from awscli.testutils import mock
2
from awscli.customizations.emr.createcluster import CreateCluster
3
from awscli.customizations.emr.exceptions import InvalidBooleanConfigError
4
from awscli.customizations.emr.ssh import Get
5
from awscli.customizations.emr.ssh import Put
6
from awscli.customizations.emr.ssh import SSH
7
from awscli.customizations.emr.ssh import Socks
8
from awscli.testutils import BaseAWSHelpOutputTest
9
from tests.unit.customizations.emr import EMRBaseAWSCommandParamsTest as \
10
    BaseAWSCommandParamsTest
11

12

13
INSTANCE_GROUPS_ARG = (
14
    'InstanceGroupType=MASTER,Name=MASTER,'
15
    'InstanceCount=1,InstanceType=m1.large ')
16

17
CREATE_CLUSTER_CMD = (
18
    "emr create-cluster --ami-version 3.1.0 --instance-groups %s" %
19
    INSTANCE_GROUPS_ARG)
20

21
DEFAULT_CONFIGS = {
22
    'service_role': 'my_default_emr_role',
23
    'instance_profile': 'my_default_ec2_role',
24
    'log_uri': 's3://my_default_logs',
25
    'enable_debugging': 'True',
26
    'key_name': 'my_default_key',
27
    'key_pair_file': '/home/my_default_key_pair.pem'
28
}
29

30
DEBUG_FALSE_CONFIGS = {
31
    'enable_debugging': 'False'
32
}
33

34
BAD_BOOLEAN_VALUE_CONFIGS = {
35
    'enable_debugging': 'False1'
36
}
37

38
BAD_CONFIGS = {
39
    'service_role1': 'my_default_emr_role',
40
    'instance_profiile': 'my_default_ec2_role',
41
    'log_uri_': 's3://my_default_logs',
42
    'enable_debugging*': 'True',
43
    'keyname': 'my_default_key',
44
    'key_pairrr_file': '/home/my_default_key_pair.pem'
45
}
46

47
TEST_CLUSTER_ID = "j-227H3PFKLBOBP"
48
TEST_SRC_PATH = "/home/my_src"
49

50
SSH_CMD = ('emr ssh --cluster-id %s' % TEST_CLUSTER_ID)
51
SOCKS_CMD = ('emr socks --cluster-id %s' % TEST_CLUSTER_ID)
52
GET_CMD = ('emr get --cluster-id %s --src %s' % (TEST_CLUSTER_ID,
53
                                                 TEST_SRC_PATH))
54
PUT_CMD = ('emr put --cluster-id %s --src %s' % (TEST_CLUSTER_ID,
55
                                                 TEST_SRC_PATH))
56

57
CREATE_DEFAULT_ROLES_CMD = 'emr create-default-roles'
58

59

60
class TestCreateCluster(BaseAWSCommandParamsTest):
61

62
    @mock.patch.object(CreateCluster, '_run_main_command')
63
    def test_with_configs(self, mock_run_main_command):
64
        self.set_configs(DEFAULT_CONFIGS)
65
        self._run_cmd_w_mock(mock_run_main_command, CREATE_CLUSTER_CMD)
66
        parsed_args = mock_run_main_command.call_args[0][0]
67
        self._assert_args_for_default_configs(parsed_args)
68

69
    @mock.patch.object(CreateCluster, '_run_main_command')
70
    def test_with_configs_and_other_ec2_attributes(self,
71
                                                   mock_run_main_command):
72
        self.set_configs(DEFAULT_CONFIGS)
73
        cmd = CREATE_CLUSTER_CMD \
74
            + ' --ec2-attributes AvailabilityZone=us-east-1e'
75
        self._run_cmd_w_mock(mock_run_main_command, cmd)
76
        parsed_args = mock_run_main_command.call_args[0][0]
77
        self._assert_args_for_default_configs(parsed_args)
78

79
    @mock.patch.object(CreateCluster, '_run_main_command')
80
    def test_enable_debugging_false(self, mock_run_main_command):
81
        self.set_configs(DEBUG_FALSE_CONFIGS)
82
        self._run_cmd_w_mock(mock_run_main_command, CREATE_CLUSTER_CMD)
83
        parsed_args = mock_run_main_command.call_args[0][0]
84
        self._assert_enable_debugging(parsed_args, False)
85

86
    @mock.patch.object(CreateCluster, '_run_main_command')
87
    def test_with_bad_configs(self, mock_run_main_command):
88
        self.set_configs(BAD_CONFIGS)
89
        self._run_cmd_w_mock(mock_run_main_command, CREATE_CLUSTER_CMD)
90
        parsed_args = mock_run_main_command.call_args[0][0]
91
        self.assertFalse(getattr(parsed_args, 'service_role', None))
92
        self.assertFalse(getattr(parsed_args, 'log_uri', None))
93
        self.assertFalse(parsed_args.enable_debugging)
94
        self.assertFalse(parsed_args.no_enable_debugging)
95
        self.assertFalse(getattr(parsed_args, 'ec2-attributes', None))
96

97
    def test_with_bad_boolean_value(self):
98
        self.set_configs(BAD_BOOLEAN_VALUE_CONFIGS)
99
        cmd = CREATE_CLUSTER_CMD
100
        expect_error_msg = ("\n%s\n" % InvalidBooleanConfigError.fmt.format(
101
            config_value='False1', config_key='enable_debugging',
102
            profile_var_name='default'))
103
        result = self.run_cmd(cmd, 255)
104
        self.assertEqual(expect_error_msg, result[1])
105

106
    @mock.patch.object(CreateCluster, '_run_main_command')
107
    def test_ignore_role_configs_when_use_default_roles(self,
108
                                                        mock_run_main_command):
109
        self.set_configs(DEFAULT_CONFIGS)
110
        cmd = CREATE_CLUSTER_CMD + '--use-default-roles'
111
        self._run_cmd_w_mock(mock_run_main_command, cmd)
112
        parsed_args = mock_run_main_command.call_args[0][0]
113
        self._assert_enable_debugging(parsed_args, True)
114
        self._assert_log_uri(parsed_args, 's3://my_default_logs')
115
        self._assert_ec2_attributes(parsed_args, 'my_default_key')
116

117
    @mock.patch.object(CreateCluster, '_run_main_command')
118
    def test_with_configs_and_overriding_options(self, mock_run_main_command):
119
        self.set_configs(DEFAULT_CONFIGS)
120
        cmd = CREATE_CLUSTER_CMD + \
121
            ' --service-role my_emr_role --log-uri s3://my_logs' \
122
            ' --ec2-attributes KeyName=my_key,' \
123
            'InstanceProfile=my_ec2_role --no-enable-debugging'
124
        self._run_cmd_w_mock(mock_run_main_command, cmd)
125
        parsed_args = mock_run_main_command.call_args[0][0]
126
        self._assert_enable_debugging(parsed_args, False)
127
        self._assert_log_uri(parsed_args, 's3://my_logs')
128
        self._assert_service_role(parsed_args, 'my_emr_role')
129
        self._assert_ec2_attributes(parsed_args, 'my_key', 'my_ec2_role')
130

131
    @mock.patch.object(CreateCluster, '_run_main_command')
132
    def test_with_configs_and_overriding_ec2_attributes(self,
133
                                                        mock_run_main_command):
134
        self.set_configs(DEFAULT_CONFIGS)
135
        cmd = CREATE_CLUSTER_CMD \
136
            + ' --ec2-attributes AvailabilityZone=us-east-1e,'\
137
            'KeyName=my_key'
138
        self._run_cmd_w_mock(mock_run_main_command, cmd)
139
        parsed_args = mock_run_main_command.call_args[0][0]
140
        self._assert_enable_debugging(parsed_args, True)
141
        self._assert_log_uri(parsed_args, 's3://my_default_logs')
142
        self._assert_service_role(parsed_args, 'my_default_emr_role')
143
        self._assert_ec2_attributes(
144
            parsed_args, 'my_key', 'my_default_ec2_role')
145

146
    def _run_cmd_w_mock(self, mock_run_main_command, cmd, return_value=0):
147
        mock_run_main_command.return_value = return_value
148
        self.run_cmd(cmd, return_value)
149

150
    def _assert_args_for_default_configs(self, parsed_args):
151
        self._assert_enable_debugging(parsed_args, True)
152
        self._assert_log_uri(parsed_args, 's3://my_default_logs')
153
        self._assert_service_role(parsed_args, 'my_default_emr_role')
154
        self._assert_ec2_attributes(
155
            parsed_args, 'my_default_key', 'my_default_ec2_role')
156

157
    def _assert_enable_debugging(self, parsed_args, value):
158
        if value:
159
            self.assertTrue(parsed_args.enable_debugging)
160
            self.assertFalse(parsed_args.no_enable_debugging)
161
        else:
162
            self.assertFalse(parsed_args.enable_debugging)
163
            self.assertTrue(parsed_args.no_enable_debugging)
164

165
    def _assert_ec2_attributes(self, parsed_args, key_name=None,
166
                               instance_profile=None):
167
        if key_name:
168
            self.assertEqual(
169
                parsed_args.ec2_attributes['KeyName'], key_name)
170
        if instance_profile:
171
            self.assertEqual(
172
                parsed_args.ec2_attributes['InstanceProfile'],
173
                instance_profile)
174

175
    def _assert_log_uri(self, parsed_args, value):
176
        self.assertEqual(parsed_args.log_uri, value)
177

178
    def _assert_service_role(self, parsed_args, value):
179
        self.assertEqual(parsed_args.service_role, value)
180

181

182
class TestSSHBasedCommands(BaseAWSCommandParamsTest):
183

184
    @mock.patch.object(SSH, '_run_main_command')
185
    def test_ssh_with_configs(self, mock_run_main_command):
186
        self._test_cmd_with_configs(mock_run_main_command, SSH_CMD)
187

188
    @mock.patch.object(Socks, '_run_main_command')
189
    def test_socks_with_configs(self, mock_run_main_command):
190
        self._test_cmd_with_configs(mock_run_main_command, SOCKS_CMD)
191

192
    @mock.patch.object(Get, '_run_main_command')
193
    def test_get_with_configs(self, mock_run_main_command):
194
        self._test_cmd_with_configs(mock_run_main_command, GET_CMD)
195

196
    @mock.patch.object(Put, '_run_main_command')
197
    def test_put_with_configs(self, mock_run_main_command):
198
        self._test_cmd_with_configs(mock_run_main_command, PUT_CMD)
199

200
    @mock.patch.object(SSH, '_run_main_command')
201
    def test_ssh_with_configs_and_overriding_key(self, mock_run_main_command):
202
        cmd = SSH_CMD + " --key-pair-file /home/my_key_pair.pem"
203
        self._test_cmd_with_configs(mock_run_main_command, cmd,
204
                                    '/home/my_key_pair.pem')
205

206
    def _test_cmd_with_configs(self, mock_run_main_command, cmd,
207
                               key_pair_file_to_assert=''
208
                               '/home/my_default_key_pair.pem'):
209
        self.set_configs(DEFAULT_CONFIGS)
210
        mock_run_main_command.return_value = 0
211
        self.run_cmd(cmd, 0)
212
        call_args = mock_run_main_command.call_args
213
        self.assertEqual(
214
            call_args[0][0].key_pair_file, key_pair_file_to_assert)
215

216

217
class TestHelpOutput(BaseAWSHelpOutputTest):
218

219
    def test_not_override_required_options(self):
220
        scoped_config = self.session.get_scoped_config()
221
        scoped_config['emr'] = DEFAULT_CONFIGS
222
        self.driver.main(['emr', 'ssh', 'help'])
223
        self.assert_contains('--key-pair-file <value>')
224
        self.assert_not_contains('[--key-pair-file <value>]')
225

226

227
class TestCreateDefaultRoles(BaseAWSCommandParamsTest):
228

229
    def test_roles_updated_if_not_present(self):
230
        self.run_cmd(CREATE_DEFAULT_ROLES_CMD, expected_rc=0)
231

232
        call_args_list = self.mock_update_config.call_args_list
233

234
        keys = [x[0][0] for x in call_args_list]
235
        self.assertTrue('instance_profile' in keys)
236
        self.assertTrue('service_role' in keys)
237

238
    def test_roles_not_updated_if_present(self):
239
        self.set_configs(DEFAULT_CONFIGS)
240
        self.run_cmd(CREATE_DEFAULT_ROLES_CMD, expected_rc=0)
241

242
        call_args_list = self.mock_update_config.call_args_list
243

244
        self.assertFalse(call_args_list)
245

246
if __name__ == "__main__":
247
    unittest.main()
248

249
Product

Resources

Company
