def test_process_include_results(mock_iterator, mock_variable_manager):
hostname = "testhost1"
hostname2 = "testhost2"
parent_task_ds = {'debug': 'msg=foo'}
parent_task = Task.load(parent_task_ds)
parent_task._play = None
task_ds = {'include': 'include_test.yml'}
loaded_task = TaskInclude.load(task_ds, task_include=parent_task)
return_data = {'include': 'include_test.yml'}
# The task in the TaskResult has to be a TaskInclude so it has a .static attr
result1 = task_result.TaskResult(host=hostname,
task=loaded_task,
return_data=return_data)
result2 = task_result.TaskResult(host=hostname2,
task=loaded_task,
return_data=return_data)
results = [result1, result2]
fake_loader = DictDataLoader({'include_test.yml': ""})
res = IncludedFile.process_include_results(results, mock_iterator,
fake_loader,
mock_variable_manager)
assert isinstance(res, list)
assert len(res) == 1
assert res[0]._filename == os.path.join(os.getcwd(), 'include_test.yml')
assert res[0]._hosts == ['testhost1', 'testhost2']
assert res[0]._args == {}
def test_process_include_simulate_free_block_role_tasks(
mock_iterator, mock_variable_manager):
"""Test loading the same role returns different included files
In the case of free, we may end up with included files from roles that
have the same parent but are different tasks. Previously the comparison
for equality did not check if the tasks were the same and only checked
that the parents were the same. This lead to some tasks being run
incorrectly and some tasks being silient dropped."""
fake_loader = DictDataLoader({
'include_test.yml':
"",
'/etc/ansible/roles/foo_role/tasks/task1.yml':
"""
- debug: msg=task1
""",
'/etc/ansible/roles/foo_role/tasks/task2.yml':
"""
- debug: msg=task2
""",
})
hostname = "testhost1"
hostname2 = "testhost2"
role1_ds = {
'name': 'task1 include',
'include_role': {
'name': 'foo_role',
'tasks_from': 'task1.yml'
}
}
role2_ds = {
'name': 'task2 include',
'include_role': {
'name': 'foo_role',
'tasks_from': 'task2.yml'
}
}
parent_task_ds = {'block': [role1_ds, role2_ds]}
parent_block = Block.load(parent_task_ds, loader=fake_loader)
parent_block._play = None
include_role1_ds = {
'include_args': {
'name': 'foo_role',
'tasks_from': 'task1.yml'
}
}
include_role2_ds = {
'include_args': {
'name': 'foo_role',
'tasks_from': 'task2.yml'
}
}
include_role1 = IncludeRole.load(role1_ds,
block=parent_block,
loader=fake_loader)
include_role2 = IncludeRole.load(role2_ds,
block=parent_block,
loader=fake_loader)
result1 = task_result.TaskResult(host=hostname,
task=include_role1,
return_data=include_role1_ds)
result2 = task_result.TaskResult(host=hostname2,
task=include_role2,
return_data=include_role2_ds)
results = [result1, result2]
res = IncludedFile.process_include_results(results, mock_iterator,
fake_loader,
mock_variable_manager)
assert isinstance(res, list)
# we should get two different includes
assert len(res) == 2
assert res[0]._filename == 'foo_role'
assert res[1]._filename == 'foo_role'
# with different tasks
assert res[0]._task != res[1]._task
assert res[0]._hosts == ['testhost1']
assert res[1]._hosts == ['testhost2']
assert res[0]._args == {}
assert res[1]._args == {}
assert res[0]._vars == {}
assert res[1]._vars == {}
def test_process_include_results(self):
hostname = "testhost1"
hostname2 = "testhost2"
parent_task_ds = {'debug': 'msg=foo'}
parent_task = Task()
parent_task.load(parent_task_ds)
task_ds = {'include': 'include_test.yml'}
task_include = TaskInclude()
loaded_task = task_include.load(task_ds, task_include=parent_task)
child_task_ds = {'include': 'other_include_test.yml'}
child_task_include = TaskInclude()
loaded_child_task = child_task_include.load(child_task_ds,
task_include=loaded_task)
return_data = {'include': 'include_test.yml'}
# The task in the TaskResult has to be a TaskInclude so it has a .static attr
result1 = task_result.TaskResult(host=hostname,
task=loaded_task,
return_data=return_data)
return_data = {'include': 'other_include_test.yml'}
result2 = task_result.TaskResult(host=hostname2,
task=loaded_child_task,
return_data=return_data)
results = [result1, result2]
fake_loader = DictDataLoader({
'include_test.yml': "",
'other_include_test.yml': ""
})
mock_tqm = MagicMock(name='MockTaskQueueManager')
mock_play = MagicMock(name='MockPlay')
mock_iterator = MagicMock(name='MockIterator')
mock_iterator._play = mock_play
mock_inventory = MagicMock(name='MockInventory')
mock_inventory._hosts_cache = dict()
def _get_host(host_name):
return None
mock_inventory.get_host.side_effect = _get_host
# TODO: can we use a real VariableManager?
mock_variable_manager = MagicMock(name='MockVariableManager')
mock_variable_manager.get_vars.return_value = dict()
res = IncludedFile.process_include_results(results, mock_tqm,
mock_iterator,
mock_inventory, fake_loader,
mock_variable_manager)
self.assertIsInstance(res, list)
self.assertEquals(res[0]._filename,
os.path.join(os.getcwd(), 'include_test.yml'))
self.assertEquals(res[1]._filename,
os.path.join(os.getcwd(), 'other_include_test.yml'))
self.assertEquals(res[0]._hosts, ['testhost1'])
self.assertEquals(res[1]._hosts, ['testhost2'])
self.assertEquals(res[0]._args, {})
self.assertEquals(res[1]._args, {})
