def test_provisioner_init(self):
"""
Test Provisioner.__init__
"""
# Check that the correct default provisioning log is created
mock_open_file = mock_open()
with patch('infrastructure_provisioning.open', mock_open_file, create=True):
ip.Provisioner(self.config)
mock_open_file.assert_called_with(ip.PROVISION_LOG_PATH, "w")
# Check when TERRAFORM is an environment variable
provisioner = ip.Provisioner(self.config, provisioning_file=self.provision_log_path)
self.assertEqual(provisioner.cluster, 'single')
self.assertFalse(provisioner.reuse_cluster)
self.assertEqual(provisioner.dsi_dir, self.dsi_path)
self.assertFalse(provisioner.existing)
self.assertEqual(provisioner.parallelism, '-parallelism=20')
self.assertEqual(provisioner.terraform, 'test/path/terraform')
# Check when TERRAFORM is not environment variable
os_environ_missing_terraform = self.os_environ.copy()
del os_environ_missing_terraform['TERRAFORM']
os_environ_missing_terraform['PATH'] = "/foo:/bar"
self.mock_environ.__getitem__.side_effect = os_environ_missing_terraform.__getitem__
self.mock_environ.__contains__.side_effect = os_environ_missing_terraform.__contains__
with self.assertRaises(common.utils.TerraformNotFound):
provisioner_missing_terraform = ip.Provisioner(
self.config, provisioning_file=self.provision_log_path)
self.assertEqual(provisioner_missing_terraform.cluster, 'single')
self.assertFalse(provisioner_missing_terraform.reuse_cluster)
self.assertEqual(provisioner_missing_terraform.dsi_dir, self.dsi_path)
self.assertFalse(provisioner_missing_terraform.existing)
self.assertEqual(provisioner_missing_terraform.parallelism, '-parallelism=20')
self.assertEqual(provisioner_missing_terraform.terraform, './terraform')
self.reset_mock_objects()
def test_setup_evg_dir(self, mock_isdir, mock_listdir, mock_shutil):
"""
Test Provisioner.setup_evg_dir
"""
evg_data_dir = self.config['infrastructure_provisioning']['evergreen']['data_dir']
# Test when evergreen data directories do not exist
with patch('infrastructure_provisioning.os.makedirs') as mock_makedirs:
mock_isdir.return_value = False
provisioner = ip.Provisioner(self.config, provisioning_file=self.provision_log_path)
provisioner.bin_dir = 'test/bin'
provisioner.setup_evg_dir()
mock_makedirs.assert_called_with(evg_data_dir + 'terraform')
copytree_calls = [call('modules', evg_data_dir + 'terraform/modules')]
mock_shutil.copytree.assert_has_calls(copytree_calls)
copy_calls = [
call('test/path/terraform', evg_data_dir + 'terraform/terraform'),
call(provisioner.bin_dir + '/infrastructure_teardown.py',
evg_data_dir + 'terraform/infrastructure_teardown.py')
]
mock_shutil.copy.assert_has_calls(copy_calls)
listdir_calls = [call(evg_data_dir), call(os.path.join(evg_data_dir, 'terraform'))]
# any_order is set to True because when running nosetests, listdir has extra
# __str__() calls due to logging
mock_listdir.assert_has_calls(listdir_calls, any_order=True)
# Test when evergreen data directories do exist
with patch('infrastructure_provisioning.os.makedirs') as mock_makedirs:
mock_isdir.return_value = True
provisioner = ip.Provisioner(self.config, provisioning_file=self.provision_log_path)
provisioner.bin_dir = 'test/bin'
provisioner.setup_evg_dir()
self.assertFalse(mock_makedirs.called)
self.reset_mock_objects()
def test_check_existing_state(self, mock_rmtree, mock_isdir, mock_check_call, mock_copyfile):
"""
Test Provisioner.existing_state. First case finds a saved state, second doesn't
"""
config = copy.deepcopy(self.config)
config['infrastructure_provisioning']['tfvars']['cluster_name'] = 'replica'
evg_data_dir = config['infrastructure_provisioning']['evergreen']['data_dir']
mock_isdir.side_effect = lambda evg_dir: evg_dir == evg_data_dir
# Run check_existing_state when existing state exists
with patch('infrastructure_provisioning.os.path.isfile') as mock_isfile:
mock_isfile.return_value = True
provisioner = ip.Provisioner(config, provisioning_file=self.provision_log_path)
mock_teardown_old_cluster = MagicMock(name="teardown_old_cluster")
self.assertEqual(provisioner.evg_data_dir, evg_data_dir)
provisioner.check_existing_state()
isfile_calls = [
call(evg_data_dir + 'terraform/terraform.tfstate'),
call(evg_data_dir + 'terraform/provisioned.replica')
]
mock_isfile.assert_has_calls(isfile_calls)
copyfile_calls = [
call(FIXTURE_FILES.fixture_file_path('terraform/terraform.tfstate'),
'terraform.tfstate'),
call(FIXTURE_FILES.fixture_file_path('terraform/cluster.json'), 'cluster.json')
]
mock_copyfile.assert_has_calls(copyfile_calls)
mock_check_call.assert_not_called()
mock_rmtree.assert_not_called()
self.assertTrue(provisioner.existing)
mock_teardown_old_cluster.assert_not_called()
with patch('infrastructure_provisioning.os.path.isfile') as mock_isfile:
with patch('infrastructure_provisioning.check_version') as mock_check_version:
mock_check_version.return_value = False
mock_isfile.return_value = True
provisioner = ip.Provisioner(config, provisioning_file=self.provision_log_path)
mock_teardown_old_cluster = MagicMock(name="teardown_old_cluster")
provisioner.teardown_old_cluster = mock_teardown_old_cluster
self.assertEqual(provisioner.evg_data_dir, evg_data_dir)
provisioner.check_existing_state()
mock_teardown_old_cluster.assert_called_once()
self.assertFalse(provisioner.existing)
mock_check_version.assert_called_once_with(
FIXTURE_FILES.fixture_file_path('terraform/provisioned.replica'))
# Run check_existing_state when no existing state exists
with patch('infrastructure_provisioning.os.path.isfile') as mock_isfile:
mock_isfile.return_value = False
provisioner = ip.Provisioner(config, provisioning_file=self.provision_log_path)
provisioner.check_existing_state()
isfile_calls = [call(evg_data_dir + 'terraform/terraform.tfstate')]
mock_isfile.assert_has_calls(isfile_calls)
mock_check_call.assert_not_called()
mock_rmtree.assert_not_called()
self.assertFalse(provisioner.existing)
self.reset_mock_objects()
def test_check_existing_state_initialsync(self, mock_remove, mock_isdir, mock_check_call,
mock_shutil):
"""
Test Provisioner.existing_state, initialsync-logkeeper should force destroy existing
"""
config = copy.deepcopy(self.config)
config['infrastructure_provisioning']['tfvars']['cluster_name'] = 'initialsync-logkeeper'
evg_data_dir = config['infrastructure_provisioning']['evergreen']['data_dir']
mock_isdir.side_effect = lambda evg_dir: evg_dir == evg_data_dir
# Run check_existing_state when existing state exists
with patch('infrastructure_provisioning.os.path.isfile') as mock_isfile:
expected_command = ['python', evg_data_dir + 'terraform/infrastructure_teardown.py']
# mock_check_call.side_effect = partial(self.check_subprocess_call, expected_command)
mock_isfile.return_value = True
provisioner = ip.Provisioner(config, provisioning_file=self.provision_log_path)
self.assertEqual(provisioner.evg_data_dir, evg_data_dir)
provisioner.check_existing_state()
mock_check_call.assert_called_with(expected_command, env=ANY, stdout=ANY, stderr=ANY)
mock_shutil.rmtree.assert_called_with(evg_data_dir)
isfile_calls = [
call(FIXTURE_FILES.fixture_file_path('terraform/infrastructure_teardown.py')),
call('cluster.json'),
call('terraform.tfstate'),
call(FIXTURE_FILES.fixture_file_path('terraform/terraform.tfstate')),
call(FIXTURE_FILES.fixture_file_path('terraform/provisioned.initialsync-logkeeper'))
]
mock_isfile.assert_has_calls(isfile_calls)
remove_calls = [call('cluster.json'), call('terraform.tfstate')]
mock_remove.assert_has_calls(remove_calls)
self.assertTrue(provisioner.existing)
# Run check_existing_state when no existing state exists
with patch('infrastructure_provisioning.os.path.isfile') as mock_isfile:
expected_command = [
FIXTURE_FILES.fixture_file_path('terraform/infrastructure_teardown.sh')
]
mock_check_call.side_effect = partial(self.check_subprocess_call, expected_command)
mock_isfile.return_value = False
provisioner = ip.Provisioner(config, provisioning_file=self.provision_log_path)
provisioner.check_existing_state()
mock_shutil.rmtree.assert_called_with(evg_data_dir)
isfile_calls = [call(evg_data_dir + 'terraform/terraform.tfstate')]
mock_isfile.assert_has_calls(isfile_calls)
remove_calls = [call('cluster.json'), call('terraform.tfstate')]
mock_remove.assert_has_calls(remove_calls)
self.assertFalse(provisioner.existing)
self.reset_mock_objects()
def test_build_hosts_file(self):
expected = [
'10.2.1.1\tmd md0 mongod0 mongod0.dsitest.dev',
'10.2.1.2\tmd1 mongod1 mongod1.dsitest.dev',
'10.2.1.3\tmd2 mongod2 mongod2.dsitest.dev',
'10.2.1.4\tmd3 mongod3 mongod3.dsitest.dev',
'10.2.1.5\tmd4 mongod4 mongod4.dsitest.dev',
'10.2.1.6\tmd5 mongod5 mongod5.dsitest.dev',
'10.2.1.7\tmd6 mongod6 mongod6.dsitest.dev',
'10.2.1.8\tmd7 mongod7 mongod7.dsitest.dev',
'10.2.1.9\tmd8 mongod8 mongod8.dsitest.dev',
'10.2.1.100\tms ms0 mongos0 mongos0.dsitest.dev',
'10.2.1.101\tms1 mongos1 mongos1.dsitest.dev',
'10.2.1.102\tms2 mongos2 mongos2.dsitest.dev',
'10.2.1.51\tcs cs0 configsvr0 configsvr0.dsitest.dev',
'10.2.1.52\tcs1 configsvr1 configsvr1.dsitest.dev',
'10.2.1.53\tcs2 configsvr2 configsvr2.dsitest.dev',
'10.2.1.10\twc wc0 workload_client0 workload_client0.dsitest.dev'
]
config_files = os.path.dirname(os.path.abspath(__file__)) + '/../../docs/config-specs/'
with test_config.in_dir(config_files):
real_config_dict = ConfigDict('infrastructure_provisioning')
real_config_dict.load()
real_config_dict.save = MagicMock(name='save')
provisioner = ip.Provisioner(real_config_dict,
provisioning_file=self.provision_log_path)
hosts_contents = provisioner._build_hosts_file()
self.assertEqual(expected, hosts_contents)
def test_print_terraform_errors(self, log_output):
"""
Test infrastructure_provisioning.print_terraform_errors()
"""
# pylint: disable=line-too-long
provisioner = ip.Provisioner(self.config, provisioning_file=self.provision_log_path)
provisioner.tf_log_path = FIXTURE_FILES.fixture_file_path('terraform.log.short')
provisioner.print_terraform_errors()
log_output.check(
('infrastructure_provisioning', 'INFO',
'[info ] Using terraform binary: [infrastructure_provisioning] '
'path=test/path/terraform'),
('infrastructure_provisioning', 'INFO',
'[info ] Redirecting terraform output to file '
'[infrastructure_provisioning] '
'path={}'.format(FIXTURE_FILES.fixture_file_path('terraform.stdout.log'))),
('infrastructure_provisioning', 'ERROR',
'[error ] 2018-03-05T15:45:36.018+0200 [DEBUG] '
'plugin.terraform-provider-aws_v1.6.0_x4: '
'<Response><Errors><Error><Code>InsufficientInstanceCapacity</Code><Message>Insufficient '
'capacity.</Message></Error></Errors><RequestID>bd5b4071-755d-440e-8381-aa09bad52d69</RequestID></Response> '
'[infrastructure_provisioning] '),
('infrastructure_provisioning', 'ERROR',
'[error ] 2018-03-05T15:45:36.914+0200 [DEBUG] '
'plugin.terraform-provider-aws_v1.6.0_x4: '
'<Response><Errors><Error><Code>RequestLimitExceeded</Code><Message>Request '
'limit '
'exceeded.</Message></Error></Errors><RequestID>6280e71d-9be4-442c-8ddf-00265efeafe6</RequestID></Response> '
'[infrastructure_provisioning] '),
('infrastructure_provisioning', 'ERROR',
'[error ] 2018-03-05T15:48:36.336+0200 [DEBUG] '
'plugin.terraform-provider-aws_v1.6.0_x4: '
'<Response><Errors><Error><Code>InvalidRouteTableID.NotFound</Code><Message>The '
"routeTable ID 'rtb-509f1528' does not "
'exist</Message></Error></Errors><RequestID>54256eb4-d706-4084-86dc-b7f581006f9f</RequestID></Response> '
'[infrastructure_provisioning] '),
('infrastructure_provisioning', 'ERROR',
'[error ] 2018-03-05T15:48:47.258+0200 [DEBUG] '
'plugin.terraform-provider-aws_v1.6.0_x4: '
'<Response><Errors><Error><Code>DependencyViolation</Code><Message>Network '
'vpc-a9ed8bd0 has some mapped public address(es). Please unmap those public '
'address(es) before detaching the '
'gateway.</Message></Error></Errors><RequestID>cd102bc6-d598-4bae-80f5-25e62103f9a4</RequestID></Response> '
'[infrastructure_provisioning] '),
('infrastructure_provisioning', 'ERROR',
'[error ] 2018-03-05T15:49:29.084+0200 [DEBUG] '
'plugin.terraform-provider-aws_v1.6.0_x4: '
'<Response><Errors><Error><Code>InvalidPlacementGroup.Unknown</Code><Message>The '
"Placement Group 'shard-8665ea69-9e76-483a-937b-af68d41d54dd' is "
'unknown.</Message></Error></Errors><RequestID>4264aef8-ae91-40f0-bc16-d914a8dc2cf8</RequestID></Response> '
'[infrastructure_provisioning] '),
('infrastructure_provisioning', 'ERROR',
'[error ] For more info, see: [infrastructure_provisioning] '
'path={}'.format(FIXTURE_FILES.fixture_file_path('terraform.log.short'))),
('infrastructure_provisioning', 'ERROR',
'[error ] [infrastructure_provisioning] '),
('infrastructure_provisioning', 'ERROR',
'[error ] For more info, see: [infrastructure_provisioning] '
'path={}'.format(FIXTURE_FILES.fixture_file_path('terraform.stdout.log'))))
def test_userexpand(self, mock_copyfile, mock_getcwd, mock_chdir, mock_remove, mock_check_call):
"""
Test Provisioner.save_terraform_state with ~/.ssh/user_ssh_key.pem
"""
config = copy.deepcopy(self.config)
config['infrastructure_provisioning']['tfvars']['ssh_key_file'] = '~/.ssh/user_aws_key.pem'
provisioned_files = ['provisioned.single', 'provisioned.shard']
evg_data_dir = config['infrastructure_provisioning']['evergreen']['data_dir']
terraform_dir = os.path.join(evg_data_dir, 'terraform')
with patch('infrastructure_provisioning.glob.glob') as mock_glob:
mock_open_file = mock_open()
with patch('infrastructure_provisioning.open', mock_open_file, create=True):
mock_glob.return_value = provisioned_files
mock_getcwd.return_value = 'fake/path'
provisioner = ip.Provisioner(config, provisioning_file=self.provision_log_path)
provisioner.production = True
provisioner.save_terraform_state()
files_to_copy = ['terraform.tfstate', 'cluster.tf', 'security.tf', 'cluster.json']
copyfile_calls = [
call(file_to_copy, os.path.join(terraform_dir, file_to_copy))
for file_to_copy in files_to_copy
]
mock_copyfile.assert_has_calls(copyfile_calls)
self.reset_mock_objects()
def test_save_terraform_state(self, mock_copyfile, mock_getcwd, mock_chdir, mock_remove,
mock_check_call):
"""
Test Provisioner.save_terraform_state
"""
provisioned_files = ['provisioned.single', 'provisioned.shard']
evg_data_dir = self.config['infrastructure_provisioning']['evergreen']['data_dir']
terraform_dir = os.path.join(evg_data_dir, 'terraform')
with patch('infrastructure_provisioning.glob.glob') as mock_glob:
mock_open_file = mock_open()
with patch('infrastructure_provisioning.open', mock_open_file, create=True):
mock_glob.return_value = provisioned_files
mock_getcwd.return_value = 'fake/path'
provisioner = ip.Provisioner(self.config, provisioning_file=self.provision_log_path)
provisioner.production = True
provisioner.save_terraform_state()
files_to_copy = [
'terraform.tfstate', 'cluster.tf', 'security.tf', 'cluster.json',
'aws_ssh_key.pem'
]
copyfile_calls = [
call(file_to_copy, os.path.join(terraform_dir, file_to_copy))
for file_to_copy in files_to_copy
]
mock_copyfile.assert_has_calls(copyfile_calls)
chdir_calls = [call(terraform_dir), call(mock_getcwd.return_value)]
mock_chdir.assert_has_calls(chdir_calls)
mock_check_call.assert_called_with(['./terraform', 'init', '-upgrade'],
stdout=provisioner.stdout,
stderr=provisioner.stderr)
remove_calls = [call('provisioned.single'), call('provisioned.shard')]
mock_remove.assert_has_calls(remove_calls)
mock_open_file.assert_called_with('provisioned.single', 'w')
self.reset_mock_objects()
def test_setup_terraform_tf(self):
"""
Test setup_terraform_tf creates the correct directories and files
"""
# Create temporary directory and get correct paths
directory = 'temp_test'
if os.path.exists(directory):
shutil.rmtree(directory)
os.mkdir(directory)
cluster_path = os.path.join(self.dsi_path, 'clusters', 'default')
remote_scripts_path = os.path.join(self.dsi_path, 'clusters', 'remote-scripts')
remote_scripts_target = os.path.join(directory, 'remote-scripts')
modules_path = os.path.join(self.dsi_path, 'clusters', 'modules')
modules_target = os.path.join(directory, 'modules')
# Check files copied correctly
with patch('infrastructure_provisioning.os.getcwd', return_value='temp_test'):
provisioner = ip.Provisioner(self.config, provisioning_file=self.provision_log_path)
provisioner.setup_terraform_tf()
for filename in glob.glob(os.path.join(cluster_path, '*')):
self.assertTrue(os.path.exists(os.path.join(directory, filename.split('/')[-1])))
for filename in glob.glob(os.path.join(remote_scripts_path, '*')):
self.assertTrue(os.path.exists(os.path.join(remote_scripts_target, \
filename.split('/')[-1])))
for filename in glob.glob(os.path.join(modules_path, '*')):
self.assertTrue(os.path.exists(os.path.join(modules_target, filename.split('/')[-1])))
# Remove temporary directory
shutil.rmtree(directory)
def test_setup_security_tf(self):
"""
Testing setup_security_tf creates security.tf file
"""
key_name = self.config['infrastructure_provisioning']['tfvars']['ssh_key_name']
key_file = self.config['infrastructure_provisioning']['tfvars']['ssh_key_file']
master_tf_str = ('provider "aws" {{ '
'access_key = "test_aws_access_key" '
'secret_key = "test_aws_secret_key" '
'region = var.region'
'version = "test_aws_version" }}'
'variable "key_name" {{ '
'default = "{}"}}'
'variable "key_file" {{ '
'default = "{}"}}').format(key_name, key_file)
master_tf_str = master_tf_str.replace('\n', '').replace(' ', '')
provisioner = ip.Provisioner(self.config, provisioning_file=self.provision_log_path)
provisioner.aws_access_key = 'test_aws_access_key'
provisioner.aws_secret_key = 'test_aws_secret_key'
# Creating 'security.tf' file in current dir to test, reading to string
provisioner.setup_security_tf()
test_tf_str = ''
with open('security.tf', 'r') as test_tf_file:
test_tf_str = test_tf_file.read().replace('\n', '').replace(' ', '')
self.assertEqual(test_tf_str, master_tf_str)
# Removing created file
os.remove('security.tf')
def test_setup_cluster(self, mock_subprocess, mock_save_output, mock_terraform_configuration,
mock_terraform_output_parser, mock_save_terraform_state,
mock_setup_evg_dir, mock_setup_security_tf, mock_setup_terraform_tf,
mock_pre_post_commands):
"""
Test Provisioner.setup_cluster
"""
mock_save_output.return_value = "mock terraform output"
# NOTE: This tests the majority of the functionality of the infrastructure_provisioning.py
# mock.mock_open is needed to effectively mock out the open() function in python
mock_open_file = mock_open()
with patch('infrastructure_provisioning.open', mock_open_file, create=True):
provisioner = ip.Provisioner(self.config, provisioning_file=self.provision_log_path)
provisioner.cluster = 'initialsync-logkeeper'
provisioner.reuse_cluster = True
provisioner.hostnames_method = None
provisioner.setup_cluster()
mock_setup_security_tf.assert_called()
mock_setup_terraform_tf.assert_called()
mock_terraform_configuration.return_value.to_json.assert_called_with(
file_name='cluster.json')
# __enter__ and __exit__ are checked to see if the files were opened
# as context managers.
open_file_calls = [call('infrastructure_provisioning.out.yml', 'r'), call().read()]
mock_open_file.assert_has_calls(open_file_calls, any_order=True)
# If the cluster is initialsync-logkeeper, then terraform should be run twice
terraform = self.os_environ['TERRAFORM']
check_call_calls = [
call([terraform, 'init', '-upgrade'],
stdout=provisioner.stdout,
stderr=provisioner.stderr),
call([
terraform, 'apply', '-var-file=cluster.json', provisioner.parallelism,
'-auto-approve', '-var=mongod_ebs_instance_count=0',
'-var=workload_instance_count=0'
],
stdout=provisioner.stdout,
stderr=provisioner.stderr),
call([
terraform, 'apply', '-var-file=cluster.json', provisioner.parallelism,
'-auto-approve'
],
stdout=provisioner.stdout,
stderr=provisioner.stderr),
call([terraform, 'refresh', '-var-file=cluster.json'],
stdout=provisioner.stdout,
stderr=provisioner.stderr),
call([terraform, 'plan', '-detailed-exitcode', '-var-file=cluster.json'],
stdout=provisioner.stdout,
stderr=provisioner.stderr)
]
mock_subprocess.check_call.assert_has_calls(check_call_calls)
mock_save_output.assert_called_with([terraform, 'output'])
self.assertTrue(mock_terraform_output_parser.return_value.write_output_files.called)
self.assertTrue(mock_setup_evg_dir.called)
self.assertTrue(mock_save_terraform_state.called)
mock_pre_post_commands.assert_called()
self.reset_mock_objects()
def test_setup_hostnames(self, mock_exec_command, mock_create_file, mock_ssh):
_ = mock_ssh
config_files = os.path.dirname(os.path.abspath(__file__)) + '/../../docs/config-specs/'
with test_config.in_dir(config_files):
real_config_dict = ConfigDict('infrastructure_provisioning')
real_config_dict.load()
real_config_dict.save = MagicMock(name='save')
provisioner = ip.Provisioner(real_config_dict,
provisioning_file=self.provision_log_path)
provisioner.setup_hostnames()
out = provisioner.config['infrastructure_provisioning']['out']
self.assertEqual(out['mongod'][0]['private_hostname'], 'mongod0.dsitest.dev')
self.assertEqual(out['configsvr'][2]['private_hostname'], 'configsvr2.dsitest.dev')
self.assertEqual(mock_create_file.call_count, 16)
self.assertEqual(mock_exec_command.call_count, 16)
def test_check_existing_state_teardown_fails(self, mock_remove, mock_isdir, mock_check_call,
mock_shutil):
"""
Test Provisioner.existing_state when teardown fails. The code should catch the exception,
and continue execution.
"""
config = copy.deepcopy(self.config)
config['infrastructure_provisioning']['tfvars']['cluster_name'] = 'single'
evg_data_dir = config['infrastructure_provisioning']['evergreen']['data_dir']
mock_isdir.side_effect = lambda evg_dir: evg_dir == evg_data_dir
with patch('infrastructure_provisioning.os.path.isfile') as mock_isfile:
mock_check_call.side_effect = CalledProcessError(1, ['cmd'])
mock_isfile.return_value = True
provisioner = ip.Provisioner(config, provisioning_file=self.provision_log_path)
self.assertEqual(provisioner.evg_data_dir, evg_data_dir)
with LogCapture(level=logging.ERROR) as error:
provisioner.check_existing_state()
error.check((
'infrastructure_provisioning',
'ERROR',
"[error ] Teardown of existing resources failed. Catching exception and continuing. [infrastructure_provisioning] \nCommand '['cmd']' returned non-zero exit status 1." # pylint: disable=line-too-long
))
mock_shutil.rmtree.assert_called_with(evg_data_dir)
isfile_calls = [
call(FIXTURE_FILES.fixture_file_path('terraform/terraform.tfstate')),
call(FIXTURE_FILES.fixture_file_path('terraform/provisioned.single')),
call(FIXTURE_FILES.fixture_file_path('terraform/infrastructure_teardown.py')),
call('cluster.json'),
call('terraform.tfstate')
]
# This call to check_existing_state should follow the same path as the working case,
# through the sub_process.check_call. As such, it should have the same isfile calls as
# that case.
mock_isfile.assert_has_calls(isfile_calls)
remove_calls = [call('cluster.json'), call('terraform.tfstate')]
mock_remove.assert_has_calls(remove_calls)
self.assertFalse(provisioner.existing)
self.reset_mock_objects()
def test_setup_cluster_failure(self, mock_subprocess, mock_terraform_configuration,
mock_terraform_output_parser, mock_save_terraform_state,
mock_rmtree, mock_setup_terraform_tf):
"""
Test Provisioner.setup_cluster when an error happens. Ensure that the cluster is torn
down.
"""
# NOTE: This tests the majority of the functionality of the infrastructure_provisioning.py
mock_open_file = mock_open()
with patch('infrastructure_provisioning.open', mock_open_file, create=True):
with patch('infrastructure_provisioning.destroy_resources') as mock_destroy:
provisioner = ip.Provisioner(self.config, provisioning_file=self.provision_log_path)
provisioner.reuse_cluster = True
mock_subprocess.check_call.side_effect = [1, CalledProcessError(1, ['cmd']), 1]
with self.assertRaises(CalledProcessError):
provisioner.setup_cluster()
mock_setup_terraform_tf.assert_called()
mock_destroy.assert_called()
mock_rmtree.assert_called()
self.assertFalse(mock_terraform_output_parser.return_value.write_output_files.called)
self.assertFalse(mock_save_terraform_state.called)
mock_terraform_configuration.return_value.to_json.assert_called_with(
file_name='cluster.json')
self.reset_mock_objects()