def test_user_exists(self):
execute_mock = mock.Mock()
execute_mock.return_value = Result(status=Status.SUCCESS)
executor = UserExecutor(host=Localhost(),
username=self.username,
password=self.password,
groups=self.groups,
ssh_keys=self.ssh_keys)
executor.execute_executor = execute_mock
result = executor.execute()
execute_mock.assert_has_calls([
mock.call(
UserAddExecutor(username=self.username,
password=self.password,
create_home=self.create_home,
shell='/bin/bash',
groups=self.groups,
**executor.get_base_attributes()))
])
self.assertEqual(
result, Result(status=Status.SUCCESS, message='User is created!'))
self.assertEqual(execute_mock.call_count, 1)
def test_execute_wrong_password(self, client_mock):
executor = self.mock_executor(client_mock, (BytesIO(b'output'),) * 3)
fill_password = Mock()
fill_password.return_value = Result(Status.FAIL, message='Incorrect linux password!')
executor.fill_password = fill_password
result = executor.run_command()
self.assertEqual(result, Result(Status.FAIL, message='Incorrect linux password!'))
def test_all_changed(self):
executor = get_executor()
executor.results = [
Result(Status.CHANGED, message='test1'),
Result(Status.CHANGED, message='test2')
]
self.assertEqual(executor.result_from_executor('test'),
Result(Status.CHANGED, message='test'))
def test_all_success(self):
executor = get_executor()
executor.results = [
Result(Status.SUCCESS, message='test1'),
Result(Status.SUCCESS, message='test2')
]
self.assertEqual(executor.result_from_executor('test'),
Result(Status.SUCCESS, message='test'))
class ExecuteOnHostTest(unittest.TestCase):
"""
Tests if the output paramiko returns is parsed correctly
"""
host = Localhost()
result = Result(Status.SUCCESS)
def test_execute_success(self):
executor = self.mock_executor()
result = executor.execute()
self.assertEqual(result, self.result)
def test_throw_exception_on_fail(self):
self.result = Result(status=Status.FAIL)
executor = self.mock_executor()
with self.assertRaises(SingleExecutorFailedException):
executor.execute(True)
def mock_executor(self, **kwargs):
# Set executor
executor = get_executor(**kwargs)
# Mock run_command() on executor
run_command_mock = Mock()
run_command_mock.return_value = self.result
executor.run_command = run_command_mock
return executor
def setUp(self):
config.hosts = [self.host]
def test_no_linux_password(self, channel):
executor = get_executor(sudo=True)
config.linux_password = ''
host = Host('test.url', 'jessie')
executor.host = host
self.assertEqual(executor.fill_password(channel, channel), Result(Status.FAIL, message='Pass linux password with -p or pass passwordless_user on hosts!'))
def test_get_register(self):
result = Result(Status.CHANGED)
executor = get_executor(register='test')
executor.host = Localhost()
executor.result = result
executor.register_result()
self.assertEqual(config.get_registered(Localhost(), 'test'), result)
def test_host_not_in_config(self):
config.hosts = []
executor = get_executor()
executor.host = self.host
self.assertEqual(
executor.not_in_config_hosts(),
Result(
Status.SKIPPING,
message='Host is not in global config or passed as argument'))
def test_not_in_config(self):
config.hosts = []
host = Host(url='test.com', ssh_user='******')
executor = get_executor()
executor.host = host
self.assertEqual(
executor.run(),
Result(
Status.SKIPPING,
message='Host is not in global config or passed as argument'))
def test_register_result(self):
executor = get_executor(register='test')
result = Result(Status.CHANGED, 'test', ['test'])
host = Localhost()
executor.host = host
executor.result = result
executor.register_result()
self.assertEqual(config.registry[repr(host)]['test'], result)
def test_wrong_password(self, channel):
executor = get_executor(sudo=True)
config.linux_password = '******'
readline = Mock()
readline.return_value = 'Sorry, try again.'
channel.readline = readline
channel.write = Mock()
host = Host('test.url', 'jessie')
executor.host = host
self.assertEqual(executor.fill_password(channel, channel), Result(Status.FAIL, message='Incorrect linux password!'))
def test_without_ssh(self):
execute_mock = mock.Mock()
execute_mock.return_value = Result(status=Status.CHANGED)
executor = UserExecutor(host=Localhost(),
username=self.username,
password=self.password,
groups=self.groups)
executor.execute_executor = execute_mock
executor.execute()
execute_mock.assert_has_calls(
self.user_call(executor) + self.calls_before_ssh_keys(executor) +
self.calls_after_ssh_keys(executor))
def test_run(self):
# Host and the empty mock
host = Localhost()
empty_mock = Mock()
# Mock the result
result = Result(Status.SUCCESS)
result.print_line = empty_mock
# Mock the execute function
execute = Mock()
execute.return_value = result
# Mock the executor
executor = CommandExecutor('ls')
executor.execute = execute
# Mock thread behaviour
join = Mock()
start = Mock()
executor.start = start
executor.join = join
sequence = Sequence(
hosts=[host],
executors=[
executor
]
)
sequence.print_title = empty_mock
sequence.run()
execute.called_with()
join.called_with()
start.called_with()
def result_from_executor(self, message: str):
"""
Gets the result for the executors
Args:
message (str): Success message that will be shown in the terminal
Returns:
Returns a result that is :obj:`Status.CHANGED` or :obj:`Status.SUCCESS`
"""
is_changed = False
for result in self.results:
if result.status == Status.CHANGED and not is_changed:
is_changed = True
return Result(Status.CHANGED if is_changed else Status.SUCCESS,
message=message)
def test_with_everything(self):
execute_mock = mock.Mock()
execute_mock.return_value = Result(status=Status.CHANGED)
executor = UserExecutor(host=Localhost(),
username=self.username,
password=self.password,
groups=self.groups,
ssh_keys=self.ssh_keys)
executor.execute_executor = execute_mock
executor.execute()
execute_mock.assert_has_calls(
self.user_call(executor) + self.calls_before_ssh_keys(executor) + [
mock.call(
CommandExecutor(
command=
f'printf \'{self.ssh_keys}\' | sudo tee /home/{self.username}/.ssh/authorized_keys > /dev/null',
**executor.get_base_attributes()))
] + self.calls_after_ssh_keys(executor))
def run_executors(self):
"""
Runs all the executors in an array on every host
"""
running_threads = []
for executor in self.executors:
if not self.has_tags(executor):
if config.verbose <= 3:
self.print_title(executor)
Result(Status.SKIPPING, message='Skipping based on tags').to_table()
continue
self.print_title(executor)
hosts = executor.hosts or self.hosts
for host in hosts:
executor = deepcopy(executor)
if isinstance(executor, BaseExecutor):
executor.host = host
thread = ThreadExecutor(executor)
thread.start()
running_threads.append(thread)
else:
raise NotBaseExecutorTypeException()
for running_executor in running_threads:
result = running_executor.join()
if result:
result.to_table(running_executor.executor.host)
running_threads = []
def test_run(self):
config.tags = []
host = Localhost()
executor = get_executor()
executor.host = host
not_in_config_hosts = MagicMock(return_value=False)
executor.not_in_config_hosts = not_in_config_hosts
result = Result(status=Status.CHANGED)
execute = MagicMock(return_value=result)
executor.execute = execute
register_result = Mock()
executor.register_result = register_result
executor.run()
self.assertTrue(not_in_config_hosts.called)
self.assertTrue(execute.called)
register_result.assert_called_with()
self.assertEqual(result, executor.result)
def test_throw_exception_on_fail(self):
self.result = Result(status=Status.FAIL)
executor = self.mock_executor()
with self.assertRaises(SingleExecutorFailedException):
executor.execute(True)