def test_vagrant_create(molecule_file):
c = create.Create([], [])
try:
c.execute()
except SystemExit as f:
assert f.code == 0
def test_execute_creates_instances_with_platform_all(
patched_driver_up, patched_create_templates, patched_remove_inventory,
patched_create_inventory, molecule_instance):
command_args = {'platform': 'all'}
c = create.Create({}, command_args, molecule_instance)
c.execute()
patched_driver_up.assert_called_once_with(no_provision=True)
assert molecule_instance.state.multiple_platforms
def test_execute_does_not_raise_on_exit(
patched_driver_up, patched_create_templates, patched_remove_inventory,
patched_create_inventory, patched_logger_error,
patched_write_instances_state, molecule_instance):
patched_driver_up.side_effect = subprocess.CalledProcessError(1, None,
None)
c = create.Create({}, {}, molecule_instance)
result = c.execute(exit=False)
assert (1, '') == result
def test_execute_skips_when_instances_already_created(
patched_logger_warn, command_patched_ansible_create, config_instance):
config_instance.state.change_state('created', True)
c = create.Create(config_instance)
c.execute()
msg = 'Skipping, instances already created.'
patched_logger_warn.assert_called_once_with(msg)
assert not command_patched_ansible_create.called
def test_execute_skips_when_delegated_driver(_patched_create_setup,
patched_logger_warn,
command_patched_ansible_create,
config_instance):
c = create.Create(config_instance)
c.execute()
msg = 'Skipping, instances are delegated.'
patched_logger_warn.assert_called_once_with(msg)
assert not command_patched_ansible_create.called
def test_execute_skips_when_manual_driver(
patched_create_setup, molecule_driver_delegated_section_data,
patched_logger_warn, patched_ansible_create, config_instance):
config_instance.merge_dicts(config_instance.config,
molecule_driver_delegated_section_data)
c = create.Create(config_instance)
c.execute()
msg = 'Skipping, instances are delegated.'
patched_logger_warn.assert_called_once_with(msg)
assert not patched_ansible_create.called
def test_execute_raises_on_exit(
patched_driver_up, patched_create_templates, patched_remove_inventory,
patched_create_inventory, patched_logger_error,
patched_write_instances_state, molecule_instance):
patched_driver_up.side_effect = subprocess.CalledProcessError(1, None,
None)
c = create.Create({}, {}, molecule_instance)
with pytest.raises(SystemExit):
c.execute()
msg = "ERROR: Command 'None' returned non-zero exit status 1"
patched_logger_error.assert_called_with(msg)
assert not patched_create_inventory.called
assert not patched_write_instances_state.called
def test_execute_creates_instances(
patched_driver_up, patched_create_templates, patched_remove_inventory,
patched_create_inventory, patched_print_info, molecule_instance):
c = create.Create({}, {}, molecule_instance)
result = c.execute()
patched_remove_inventory.assert_called_once
patched_create_templates.assert_called_once
msg = 'Creating instances ...'
patched_print_info.assert_called_once_with(msg)
assert molecule_instance.state.created
patched_driver_up.assert_called_once_with(no_provision=True)
(None, None) == result
def test_execute(mocker, patched_logger_info, patched_ansible_create,
config_instance):
c = create.Create(config_instance)
c.execute()
x = [
mocker.call("Scenario: 'default'"),
mocker.call("Action: 'create'"),
]
assert x == patched_logger_info.mock_calls
assert 'docker' == config_instance.state.driver
patched_ansible_create.assert_called_once_with()
assert config_instance.state.created
def test_execute(mocker, patched_create_setup, patched_logger_info,
patched_ansible_setup, config_instance):
c = create.Create(config_instance)
c.execute()
x = [
mocker.call('Scenario: [default]'),
mocker.call('Provisioner: [ansible]'),
mocker.call('Driver: [docker]'),
mocker.call('Playbook: [create.yml]')
]
assert x == patched_logger_info.mock_calls
assert 'docker' == config_instance.state.driver
patched_ansible_setup.assert_called_once_with()
assert config_instance.state.created
def test_execute(
mocker,
patched_logger_info,
command_patched_ansible_create,
patched_config_validate,
config_instance,
):
c = create.Create(config_instance)
c.execute()
x = [mocker.call("Scenario: 'default'"), mocker.call("Action: 'create'")]
assert x == patched_logger_info.mock_calls
assert "delegated" == config_instance.state.driver
command_patched_ansible_create.assert_called_once_with()
assert config_instance.state.created
def test_execute(
mocker,
patched_logger_info,
command_patched_ansible_create,
patched_config_validate,
config_instance,
):
c = create.Create(config_instance)
c.execute()
assert len(patched_logger_info.mock_calls) == 1
name, args, kwargs = patched_logger_info.mock_calls[0]
assert "default" in args
assert "converge" in args
assert "delegated" == config_instance.state.driver
command_patched_ansible_create.assert_called_once_with()
assert config_instance.state.created
def execute(self,
idempotent=False,
create_instances=True,
create_inventory=True,
exit=True,
hide_errors=True):
"""
Execute the actions necessary to perform a `molecule converge` and
return a tuple.
:param idempotent: An optional flag to perform the converge again, and
parse the output for idempotence.
:param create_inventory: An optional flag to toggle inventory creation.
:param create_instances: An optional flag to toggle instance creation.
:return: Return a tuple of (`exit status`, `command output`), otherwise
sys.exit on command failure.
"""
if self.molecule.state.created:
create_instances = False
if self.molecule.state.converged:
create_inventory = False
if self.molecule.state.multiple_platforms:
self.command_args['platform'] = 'all'
else:
if ((self.command_args.get('platform') == 'all')
and self.molecule.state.created):
create_instances = True
create_inventory = True
if create_instances and not idempotent:
c = create.Create(self.command_args, self.args, self.molecule)
c.execute()
if create_inventory:
self.molecule.create_inventory_file()
# Install role dependencies only during `molecule converge`
if not idempotent and 'requirements_file' in \
self.molecule.config.config['ansible'] and not \
self.molecule.state.installed_deps:
galaxy = ansible_galaxy.AnsibleGalaxy(self.molecule.config.config)
galaxy.install()
self.molecule.state.change_state('installed_deps', True)
ansible = ansible_playbook.AnsiblePlaybook(
self.molecule.config.config['ansible'],
self.molecule.driver.ansible_connection_params)
# Target tags passed in via CLI
if self.command_args.get('tags'):
ansible.add_cli_arg('tags', self.command_args.get('tags'))
if idempotent:
# Don't log stdout/err
ansible.remove_cli_arg('_out')
ansible.remove_cli_arg('_err')
# Disable color for regexp
ansible.add_env_arg('ANSIBLE_NOCOLOR', 'true')
ansible.add_env_arg('ANSIBLE_FORCE_COLOR', 'false')
ansible.bake()
if self.args.get('debug'):
ansible_env = {
k: v
for (k, v) in ansible.env.items() if 'ANSIBLE' in k
}
other_env = {
k: v
for (k, v) in ansible.env.items() if 'ANSIBLE' not in k
}
util.print_debug(
'OTHER ENVIRONMENT',
yaml.dump(other_env, default_flow_style=False, indent=2))
util.print_debug(
'ANSIBLE ENVIRONMENT',
yaml.dump(ansible_env, default_flow_style=False, indent=2))
util.print_debug('ANSIBLE PLAYBOOK', str(ansible._ansible))
util.print_info('Starting Ansible Run ...')
status, output = ansible.execute(hide_errors=hide_errors)
if status is not None:
if exit:
util.sysexit(status)
return status, None
if not self.molecule.state.converged:
self.molecule.state.change_state('converged', True)
return None, output
def execute(self,
idempotent=False,
create_instances=True,
create_inventory=True,
exit=True,
hide_errors=True):
"""
Execute the actions necessary to perform a `molecule converge` and
return a tuple.
:param idempotent: An optional flag to perform the converge again, and
parse the output for idempotence.
:param create_inventory: An optional flag to toggle inventory creation.
:param create_instances: An optional flag to toggle instance creation.
:return: Return a tuple of (`exit status`, `command output`), otherwise
sys.exit on command failure.
"""
debug = self.args.get('debug')
if self.molecule.state.created:
create_instances = False
if self.molecule.state.converged:
create_inventory = False
if self.molecule.state.multiple_platforms:
self.command_args['platform'] = 'all'
else:
if ((self.command_args.get('platform') == 'all')
and self.molecule.state.created):
create_instances = True
create_inventory = True
if create_instances and not idempotent:
c = create.Create(self.args, self.command_args, self.molecule)
c.execute()
if create_inventory:
self.molecule.create_inventory_file()
d = dependency.Dependency(self.args, self.command_args, self.molecule)
d.execute()
ansible = ansible_playbook.AnsiblePlaybook(
self.molecule.config.config['ansible'],
self.molecule.driver.ansible_connection_params,
raw_ansible_args=self.command_args.get('ansible_args'),
debug=debug)
if idempotent:
# Don't log stdout/err
ansible.remove_cli_arg('_out')
ansible.remove_cli_arg('_err')
# Idempotence task regexp cannot handle diff
ansible.remove_cli_arg('diff')
# Disable color for regexp
ansible.add_env_arg('ANSIBLE_NOCOLOR', 'true')
ansible.add_env_arg('ANSIBLE_FORCE_COLOR', 'false')
if debug:
ansible_env = {
k: v
for (k, v) in ansible.env.items() if 'ANSIBLE' in k
}
util.print_debug(
'ANSIBLE ENVIRONMENT',
yaml.dump(ansible_env, default_flow_style=False, indent=2))
util.print_info('Starting Ansible Run ...')
status, output = ansible.execute(hide_errors=hide_errors)
if status is not None:
if exit:
util.sysexit(status)
return status, None
if not self.molecule.state.converged:
self.molecule.state.change_state('converged', True)
return None, output
