def setUp(self):
self.region = 'us-east-1'
self.config_file = 'config-file'
self.installer = 'install'
self.bucket = 'aws-codedeploy-{0}'.format(self.region)
self.key = 'latest/{0}'.format(self.installer)
self.agent_installer = 's3://{0}/{1}'.format(self.bucket, self.key)
self.system_patcher = mock.patch('platform.system')
self.system = self.system_patcher.start()
self.system.return_value = 'Linux'
self.linux_distribution_patcher = mock.patch(
'awscli.compat.linux_distribution')
self.linux_distribution = self.linux_distribution_patcher.start()
self.linux_distribution.return_value = ('Ubuntu', '', '')
self.urlopen_patcher = mock.patch(
'awscli.customizations.codedeploy.utils.urlopen')
self.urlopen = self.urlopen_patcher.start()
self.urlopen.side_effect = timeout('Not EC2 instance')
self.geteuid_patcher = mock.patch('os.geteuid', create=True)
self.geteuid = self.geteuid_patcher.start()
self.geteuid.return_value = 0
self.isfile_patcher = mock.patch('os.path.isfile')
self.isfile = self.isfile_patcher.start()
self.isfile.return_value = False
self.makedirs_patcher = mock.patch('os.makedirs')
self.makedirs = self.makedirs_patcher.start()
self.copyfile_patcher = mock.patch('shutil.copyfile')
self.copyfile = self.copyfile_patcher.start()
self.open_patcher = mock.patch(
'awscli.customizations.codedeploy.systems.open',
mock.mock_open(),
create=True)
self.open = self.open_patcher.start()
self.args = Namespace()
self.args.override_config = False
self.args.config_file = self.config_file
self.args.agent_installer = None
self.globals = Namespace()
self.globals.region = self.region
self.body = 'install-script'
self.reader = mock.MagicMock()
self.reader.read.return_value = self.body
self.s3 = mock.MagicMock()
self.s3.get_object.return_value = {'Body': self.reader}
self.session = mock.MagicMock()
self.session.create_client.return_value = self.s3
self.install = Install(self.session)
def setUp(self):
self.path = '/AWS/CodeDeploy/'
self.instance_name = 'instance-name'
self.tags = [{'Key': 'k1', 'Value': 'v1'}]
self.iam_user_arn = 'arn:aws:iam::012345678912:user/instance-name'
self.access_key_id = 'ACCESSKEYID'
self.secret_access_key = 'SECRETACCESSKEY'
self.region = 'us-east-1'
self.policy_name = 'codedeploy-agent'
self.policy_document = (
'{\n'
' "Version": "2012-10-17",\n'
' "Statement": [ {\n'
' "Action": [ "s3:Get*", "s3:List*" ],\n'
' "Effect": "Allow",\n'
' "Resource": "*"\n'
' } ]\n'
'}')
self.config_file = 'codedeploy.onpremises.yml'
self.endpoint_url = 'https://codedeploy.aws.amazon.com'
self.args = Namespace()
self.args.instance_name = self.instance_name
self.args.tags = None
self.args.iam_user_arn = None
self.globals = Namespace()
self.globals.region = self.region
self.globals.endpoint_url = self.endpoint_url
self.globals.verify_ssl = False
self.open_patcher = mock.patch(
'awscli.customizations.codedeploy.register.open',
mock.mock_open(),
create=True)
self.open = self.open_patcher.start()
self.codedeploy = mock.MagicMock()
self.iam = mock.MagicMock()
self.iam.create_user.return_value = {
'User': {
'Arn': self.iam_user_arn
}
}
self.iam.create_access_key.return_value = {
'AccessKey': {
'AccessKeyId': self.access_key_id,
'SecretAccessKey': self.secret_access_key
}
}
self.session = mock.MagicMock()
self.session.create_client.side_effect = [self.codedeploy, self.iam]
self.register = Register(self.session)
def setUp(self):
self.popen_patcher = mock.patch('subprocess.Popen')
self.popen = self.popen_patcher.start()
self.check_call_patcher = mock.patch('subprocess.check_call')
self.check_call = self.check_call_patcher.start()
self.open_patcher = mock.patch(
'awscli.customizations.codedeploy.systems.open',
mock.mock_open(),
create=True)
self.open = self.open_patcher.start()
self.environ_patcher = mock.patch('os.environ')
self.environ = self.environ_patcher.start()
self.environ.copy.return_value = dict()
self.config_dir = '/etc/codedeploy-agent/conf'
self.config_file = 'codedeploy.onpremises.yml'
self.config_path = '{0}/{1}'.format(self.config_dir, self.config_file)
self.installer = 'install'
self.bucket = 'bucket'
self.key = 'key'
self.region = 'us-east-1'
self.access_key_id = 'ACCESSKEYID'
self.secret_access_key = 'SECRETACCESSKEY'
self.session_token = 'SESSION_TOKEN'
self.credentials = mock.MagicMock()
self.credentials.access_key = self.access_key_id
self.credentials.secret_key = self.secret_access_key
self.credentials.token = self.session_token
self.environment = dict({
'AWS_REGION': self.region,
'AWS_ACCESS_KEY_ID': self.access_key_id,
'AWS_SECRET_ACCESS_KEY': self.secret_access_key,
'AWS_SESSION_TOKEN': self.session_token
})
self.body = 'install-script'
self.reader = mock.MagicMock()
self.reader.read.return_value = self.body
self.s3 = mock.MagicMock()
self.s3.get_object.return_value = {'Body': self.reader}
self.session = mock.MagicMock()
self.session.create_client.return_value = self.s3
self.session.get_credentials.return_value = self.credentials
self.params = Namespace()
self.params.session = self.session
self.params.region = self.region
self.params.bucket = self.bucket
self.params.key = self.key
def test_command_invoked(self, mock_yaml_parse):
"""
Tests that deploy method is invoked when command is run
"""
fake_parameter_overrides = []
fake_tags_dict = {"tagkey1": "tagvalue1"}
fake_tags = [{"Key": "tagkey1", "Value": "tagvalue1"}]
fake_parameters = "some return value"
template_str = "some template"
with tempfile.NamedTemporaryFile() as handle:
file_path = handle.name
open_mock = mock.mock_open()
# Patch the file open method to return template string
with mock.patch("awscli.customizations.cloudformation.deploy.open",
open_mock(read_data=template_str)) as open_mock:
fake_template = get_example_template()
mock_yaml_parse.return_value = fake_template
self.deploy_command.deploy = mock.MagicMock()
self.deploy_command.deploy.return_value = 0
self.deploy_command.parse_key_value_arg = mock.Mock()
self.deploy_command.parse_key_value_arg.side_effect = [
fake_parameter_overrides, fake_tags_dict
]
self.deploy_command.merge_parameters = mock.MagicMock(
return_value=fake_parameters)
self.parsed_args.template_file = file_path
result = self.deploy_command._run_main(
self.parsed_args, parsed_globals=self.parsed_globals)
self.assertEqual(0, result)
open_mock.assert_called_once_with(file_path, "r")
self.deploy_command.deploy.assert_called_once_with(
mock.ANY, 'some_stack_name', mock.ANY, fake_parameters,
None, not self.parsed_args.no_execute_changeset, None, [],
None, fake_tags, True, True)
self.deploy_command.parse_key_value_arg.assert_has_calls([
mock.call(self.parsed_args.parameter_overrides,
"parameter-overrides"),
mock.call(self.parsed_args.tags, "tags")
])
self.deploy_command.merge_parameters.assert_called_once_with(
fake_template, fake_parameter_overrides)
self.assertEqual(1, mock_yaml_parse.call_count)
def test_s3_upload_required_but_missing_bucket(self, mock_getsize,
mock_yaml_parse,
mock_isfile):
"""
Tests that large templates are detected prior to deployment
"""
template_str = get_example_template()
mock_getsize.return_value = 51201
mock_isfile.return_value = True
mock_yaml_parse.return_value = template_str
open_mock = mock.mock_open()
with mock.patch("awscli.customizations.cloudformation.deploy.open",
open_mock(read_data=template_str)) as open_mock:
with self.assertRaises(exceptions.DeployBucketRequiredError):
result = self.deploy_command._run_main(
self.parsed_args, parsed_globals=self.parsed_globals)
def setUp(self):
self.popen_patcher = mock.patch('subprocess.Popen')
self.popen = self.popen_patcher.start()
self.check_call_patcher = mock.patch('subprocess.check_call')
self.check_call = self.check_call_patcher.start()
self.open_patcher = mock.patch(
'awscli.customizations.codedeploy.systems.open',
mock.mock_open(),
create=True)
self.open = self.open_patcher.start()
self.config_dir = r'C:\ProgramData\Amazon\CodeDeploy'
self.config_file = 'conf.onpremises.yml'
self.config_path = r'{0}\{1}'.format(self.config_dir, self.config_file)
self.installer = 'codedeploy-agent.msi'
self.bucket = 'bucket'
self.key = 'key'
self.region = 'us-east-1'
self.body = 'install-script'
self.reader = mock.MagicMock()
self.reader.read.return_value = self.body
self.s3 = mock.MagicMock()
self.s3.get_object.return_value = {'Body': self.reader}
self.session = mock.MagicMock()
self.session.create_client.return_value = self.s3
self.params = Namespace()
self.params.session = self.session
self.params.region = self.region
self.params.bucket = self.bucket
self.params.key = self.key
self.windows = Windows(self.params)
def test_s3_uploader_is_configured_properly(self, s3UploaderMock,
deploy_method_mock,
mock_getsize, mock_yaml_parse,
mock_isfile):
"""
Tests that large templates are detected prior to deployment
"""
bucket_name = "mybucket"
template_str = get_example_template()
mock_getsize.return_value = 1024
mock_isfile.return_value = True
mock_yaml_parse.return_value = template_str
open_mock = mock.mock_open()
with mock.patch("awscli.customizations.cloudformation.deploy.open",
open_mock(read_data=template_str)) as open_mock:
self.parsed_args.s3_bucket = bucket_name
s3UploaderObject = mock.Mock()
s3UploaderMock.return_value = s3UploaderObject
result = self.deploy_command._run_main(
self.parsed_args, parsed_globals=self.parsed_globals)
self.deploy_command.deploy.assert_called_once_with(
mock.ANY, self.parsed_args.stack_name, mock.ANY, mock.ANY,
None, not self.parsed_args.no_execute_changeset, None, [],
s3UploaderObject, [{
"Key": "tagkey1",
"Value": "tagvalue1"
}], True, True)
s3UploaderMock.assert_called_once_with(
mock.ANY, bucket_name, self.parsed_args.s3_prefix,
self.parsed_args.kms_key_id, self.parsed_args.force_upload)