def _init_new_scenario(command_args):
"""
Initialize a new scenario:
>>> molecule init scenario --scenario-name default --role-name foo
"""
scenario_name = command_args['scenario_name']
role_name = os.getcwd().split(os.sep)[-1]
role_directory = os.path.abspath(os.path.join(os.getcwd(), os.pardir))
LOG.info('Initializing new scenario {}...'.format(scenario_name))
molecule_directory = config.molecule_directory(
os.path.join(role_directory, role_name))
scenario_directory = os.path.join(molecule_directory, scenario_name)
scenario_base_directory = os.path.dirname(scenario_directory)
if os.path.isdir(scenario_directory):
msg = ('The directory molecule/{} exists. '
'Cannot create new scenario.').format(scenario_name)
util.sysexit_with_message(msg)
scenario_base_directory = os.path.join(role_directory, role_name)
templates = [
'scenario/driver/{driver_name}'.format(**command_args),
'scenario/verifier/{verifier_name}'.format(**command_args)
]
for template in templates:
_process_templates(template, command_args, scenario_base_directory)
role_directory = os.path.join(role_directory, role_name)
msg = 'Initialized scenario in {} successfully.'.format(scenario_directory)
LOG.success(msg)
def test_command_init_scenario_goss(temp_dir):
molecule_directory = config.molecule_directory(temp_dir.strpath)
scenario_directory = os.path.join(molecule_directory, 'test-scenario')
cmd = sh.molecule.bake('init', 'scenario', '--scenario-name',
'test-scenario', '--role-name', 'test-init',
'--verifier-name', 'goss')
pytest.helpers.run_command(cmd)
assert os.path.isdir(scenario_directory)
def test_os_walk(temp_dir):
scenarios = ['scenario1', 'scenario2', 'scenario3']
molecule_directory = config.molecule_directory(temp_dir.strpath)
for scenario in scenarios:
scenario_directory = os.path.join(molecule_directory, scenario)
molecule_file = config.molecule_file(scenario_directory)
os.makedirs(scenario_directory)
open(molecule_file, 'a').close()
result = [f for f in util.os_walk(molecule_directory, 'molecule.yml')]
assert 3 == len(result)
def execute(self):
"""
Execute the actions necessary to perform a `molecule init scenario` and \
returns None.
:return: None
"""
scenario_name = self._command_args["scenario_name"]
role_name = os.getcwd().split(os.sep)[-1]
role_directory = util.abs_path(os.path.join(os.getcwd(), os.pardir))
msg = "Initializing new scenario {}...".format(scenario_name)
LOG.info(msg)
molecule_directory = config.molecule_directory(
os.path.join(role_directory, role_name)
)
scenario_directory = os.path.join(molecule_directory, scenario_name)
if os.path.isdir(scenario_directory):
msg = (
"The directory molecule/{} exists. " "Cannot create new scenario."
).format(scenario_name)
util.sysexit_with_message(msg)
driver_template = api.drivers()[
self._command_args["driver_name"]
].template_dir()
if "driver_template" in self._command_args:
self._validate_template_dir(self._command_args["driver_template"])
cli_driver_template = "{driver_template}/{driver_name}".format(
**self._command_args
)
if os.path.isdir(cli_driver_template):
driver_template = cli_driver_template
else:
LOG.warning(
"Driver not found in custom template directory({}), "
"using the default template instead".format(cli_driver_template)
)
scenario_base_directory = os.path.join(role_directory, role_name)
templates = [
driver_template,
api.verifiers()[self._command_args["verifier_name"]].template_dir(),
]
self._process_templates("molecule", self._command_args, role_directory)
for template in templates:
self._process_templates(
template, self._command_args, scenario_base_directory
)
role_directory = os.path.join(role_directory, role_name)
msg = "Initialized scenario in {} successfully.".format(scenario_directory)
LOG.success(msg)
def execute(self):
"""
Execute the actions necessary to perform a `molecule init scenario` and
returns None.
:return: None
"""
scenario_name = self._command_args['scenario_name']
role_name = os.getcwd().split(os.sep)[-1]
role_directory = util.abs_path(os.path.join(os.getcwd(), os.pardir))
msg = 'Initializing new scenario {}...'.format(scenario_name)
LOG.info(msg)
molecule_directory = config.molecule_directory(
os.path.join(role_directory, role_name)
)
scenario_directory = os.path.join(molecule_directory, scenario_name)
if os.path.isdir(scenario_directory):
msg = (
'The directory molecule/{} exists. ' 'Cannot create new scenario.'
).format(scenario_name)
util.sysexit_with_message(msg)
driver_template = 'scenario/driver/{driver_name}'.format(**self._command_args)
if 'driver_template' in self._command_args:
self._validate_template_dir(self._command_args['driver_template'])
cli_driver_template = '{driver_template}/{driver_name}'.format(
**self._command_args
)
if os.path.isdir(cli_driver_template):
driver_template = cli_driver_template
else:
LOG.warn(
"Driver not found in custom template directory({}), "
"using the default template instead".format(cli_driver_template)
)
scenario_base_directory = os.path.join(role_directory, role_name)
templates = [
driver_template,
'scenario/verifier/{verifier_name}'.format(**self._command_args),
]
for template in templates:
self._process_templates(
template, self._command_args, scenario_base_directory
)
self._process_templates('molecule', self._command_args, role_directory)
role_directory = os.path.join(role_directory, role_name)
msg = 'Initialized scenario in {} successfully.'.format(scenario_directory)
LOG.success(msg)
def test_get_data_loads_existing_state_file(temp_dir, molecule_data):
molecule_directory = config.molecule_directory(temp_dir.strpath)
scenario_directory = os.path.join(molecule_directory, 'default')
molecule_file = config.molecule_file(scenario_directory)
ephemeral_directory = config.molecule_ephemeral_directory(
scenario_directory)
state_file = os.path.join(ephemeral_directory, 'state.yml')
os.makedirs(ephemeral_directory)
data = {'converged': False, 'created': True, 'driver': None}
util.write_file(state_file, util.safe_dump(data))
pytest.helpers.write_molecule_file(molecule_file, molecule_data)
c = config.Config(molecule_file)
s = state.State(c)
assert not s.converged
assert s.created
assert not s.driver
def __init__(self, old_molecule_file, driver_name):
self._old_molecule_file = old_molecule_file
if not os.path.isfile(old_molecule_file):
msg = 'Unable to find {}. Exiting.'.format(old_molecule_file)
util.sysexit_with_message(msg)
self._m = migrate.Migrate(old_molecule_file)
self._old_role_dir = os.path.join(os.path.dirname(old_molecule_file))
self._old_dot_molecule_dir = scenario.ephemeral_directory(
self._old_role_dir)
self._old_test_dir = os.path.join(self._old_role_dir, 'tests')
self._old_playbook = os.path.join(self._old_role_dir, 'playbook.yml')
self._molecule_dir = config.molecule_directory(self._old_role_dir)
self._scenario_dir = os.path.join(self._molecule_dir, 'default')
self._test_dir = os.path.join(self._scenario_dir, 'tests')
self._molecule_file = config.molecule_file(self._scenario_dir)
self._role_name = os.path.basename(os.path.normpath(
self._old_role_dir))
def __init__(self, old_molecule_file, driver_name):
self._old_molecule_file = old_molecule_file
if not os.path.isfile(old_molecule_file):
msg = 'Unable to find {}. Exiting.'.format(old_molecule_file)
util.sysexit_with_message(msg)
self._m = migrate.Migrate(old_molecule_file)
self._old_role_dir = os.path.join(os.path.dirname(old_molecule_file))
self._old_dot_molecule_dir = scenario.ephemeral_directory(
self._old_role_dir)
self._old_test_dir = os.path.join(self._old_role_dir, 'tests')
self._old_playbook = os.path.join(self._old_role_dir, 'playbook.yml')
self._molecule_dir = config.molecule_directory(self._old_role_dir)
self._scenario_dir = os.path.join(self._molecule_dir, 'default')
self._test_dir = os.path.join(self._scenario_dir, 'tests')
self._molecule_file = config.molecule_file(self._scenario_dir)
self._role_name = os.path.basename(
os.path.normpath(self._old_role_dir))
def execute(self):
"""
Execute the actions necessary to perform a `molecule init scenario` and
returns None.
:return: None
"""
scenario_name = self._command_args['scenario_name']
role_name = os.getcwd().split(os.sep)[-1]
role_directory = util.abs_path(os.path.join(os.getcwd(), os.pardir))
msg = 'Initializing new scenario {}...'.format(scenario_name)
LOG.info(msg)
molecule_directory = config.molecule_directory(
os.path.join(role_directory, role_name)
)
scenario_directory = os.path.join(molecule_directory, scenario_name)
scenario_base_directory = os.path.dirname(scenario_directory)
if os.path.isdir(scenario_directory):
msg = (
'The directory molecule/{} exists. ' 'Cannot create new scenario.'
).format(scenario_name)
util.sysexit_with_message(msg)
scenario_base_directory = os.path.join(role_directory, role_name)
templates = [
'scenario/driver/{driver_name}'.format(**self._command_args),
'scenario/verifier/{verifier_name}'.format(**self._command_args),
]
for template in templates:
self._process_templates(
template, self._command_args, scenario_base_directory
)
self._process_templates('molecule', self._command_args, role_directory)
role_directory = os.path.join(role_directory, role_name)
msg = 'Initialized scenario in {} successfully.'.format(scenario_directory)
LOG.success(msg)
def execute(self):
"""
Execute the actions necessary to perform a `molecule init scenario` and
returns None.
:return: None
"""
scenario_name = self._command_args['scenario_name']
role_name = os.getcwd().split(os.sep)[-1]
role_directory = util.abs_path(os.path.join(os.getcwd(), os.pardir))
msg = 'Initializing new scenario {}...'.format(scenario_name)
LOG.info(msg)
molecule_directory = config.molecule_directory(
os.path.join(role_directory, role_name))
scenario_directory = os.path.join(molecule_directory, scenario_name)
scenario_base_directory = os.path.dirname(scenario_directory)
if os.path.isdir(scenario_directory):
msg = ('The directory molecule/{} exists. '
'Cannot create new scenario.').format(scenario_name)
util.sysexit_with_message(msg)
scenario_base_directory = os.path.join(role_directory, role_name)
templates = [
'scenario/driver/{driver_name}'.format(**self._command_args),
'scenario/verifier/{verifier_name}'.format(**self._command_args),
]
for template in templates:
self._process_templates(template, self._command_args,
scenario_base_directory)
self._process_templates('molecule', self._command_args,
scenario_base_directory)
role_directory = os.path.join(role_directory, role_name)
msg = 'Initialized scenario in {} successfully.'.format(
scenario_directory)
LOG.success(msg)
def init_scenario(temp_dir, driver_name):
# Create role
role_directory = os.path.join(temp_dir.strpath, 'test-init')
cmd = sh.molecule.bake('init', 'role', {
'driver-name': driver_name,
'role-name': 'test-init'
})
run_command(cmd)
os.chdir(role_directory)
# Create scenario
molecule_directory = config.molecule_directory(role_directory)
scenario_directory = os.path.join(molecule_directory, 'test-scenario')
options = {'scenario_name': 'test-scenario', 'role_name': 'test-init'}
cmd = sh.molecule.bake('init', 'scenario', **options)
run_command(cmd)
assert os.path.isdir(scenario_directory)
options = {'scenario_name': 'test-scenario'}
cmd = sh.molecule.bake('test', **options)
run_command(cmd)
def molecule_directory():
return config.molecule_directory(molecule_project_directory())
def test_molecule_directory():
assert '/foo/bar/molecule' == config.molecule_directory('/foo/bar')
def test_molecule_directory():
assert "/foo/bar/molecule" == config.molecule_directory("/foo/bar")
def test_molecule_directory():
assert '/foo/bar/molecule' == config.molecule_directory('/foo/bar')
def molecule_directory(temp_dir):
return config.molecule_directory(temp_dir.strpath)
