2012-03-18 22:29:11 +00:00
|
|
|
|
|
|
|
# tests are fairly 'live' (but safe to run)
|
|
|
|
# setup authorized_keys for logged in user such
|
|
|
|
# that the user can log in as themselves before running tests
|
|
|
|
|
|
|
|
import unittest
|
|
|
|
import getpass
|
|
|
|
import ansible.playbook
|
2012-03-18 22:50:25 +00:00
|
|
|
import ansible.utils as utils
|
2012-03-25 23:05:27 +00:00
|
|
|
import ansible.callbacks as ans_callbacks
|
2012-03-18 22:29:11 +00:00
|
|
|
import os
|
|
|
|
import shutil
|
2013-03-09 23:30:18 +00:00
|
|
|
import ansible.constants as C
|
2012-03-18 22:29:11 +00:00
|
|
|
|
2012-03-25 23:05:27 +00:00
|
|
|
EVENTS = []
|
|
|
|
|
2012-03-18 22:29:11 +00:00
|
|
|
class TestCallbacks(object):
|
2012-03-25 23:05:27 +00:00
|
|
|
# using same callbacks class for both runner and playbook
|
2012-03-18 22:29:11 +00:00
|
|
|
|
|
|
|
def __init__(self):
|
2012-03-25 23:05:27 +00:00
|
|
|
pass
|
2012-03-18 22:29:11 +00:00
|
|
|
|
|
|
|
def set_playbook(self, playbook):
|
|
|
|
self.playbook = playbook
|
|
|
|
|
2012-11-19 15:30:30 +00:00
|
|
|
def on_no_hosts_remaining(self):
|
|
|
|
pass
|
|
|
|
|
2012-03-18 22:29:11 +00:00
|
|
|
def on_start(self):
|
2012-03-25 23:05:27 +00:00
|
|
|
EVENTS.append('start')
|
2012-03-18 22:29:11 +00:00
|
|
|
|
2012-08-01 02:26:45 +00:00
|
|
|
def on_skipped(self, host, item=None):
|
2012-03-25 23:05:27 +00:00
|
|
|
EVENTS.append([ 'skipped', [ host ]])
|
2012-03-24 00:51:15 +00:00
|
|
|
|
2012-03-20 02:42:31 +00:00
|
|
|
def on_import_for_host(self, host, filename):
|
2012-03-25 23:05:27 +00:00
|
|
|
EVENTS.append([ 'import', [ host, filename ]])
|
2012-03-20 02:42:31 +00:00
|
|
|
|
2012-03-31 15:45:29 +00:00
|
|
|
def on_error(self, host, msg):
|
2012-04-03 00:08:40 +00:00
|
|
|
EVENTS.append([ 'stderr', [ host, msg ]])
|
2012-03-31 15:45:29 +00:00
|
|
|
|
2012-03-21 01:44:01 +00:00
|
|
|
def on_not_import_for_host(self, host, missing_filename):
|
|
|
|
pass
|
|
|
|
|
2012-03-25 23:05:27 +00:00
|
|
|
def on_notify(self, host, handler):
|
|
|
|
EVENTS.append([ 'notify', [ host, handler ]])
|
|
|
|
|
2012-03-18 22:29:11 +00:00
|
|
|
def on_task_start(self, name, is_conditional):
|
2012-03-25 23:05:27 +00:00
|
|
|
EVENTS.append([ 'task start', [ name, is_conditional ]])
|
2012-03-18 22:29:11 +00:00
|
|
|
|
2012-08-01 19:17:16 +00:00
|
|
|
def on_failed(self, host, results, ignore_errors):
|
|
|
|
EVENTS.append([ 'failed', [ host, results, ignore_errors ]])
|
2012-03-18 22:29:11 +00:00
|
|
|
|
2012-03-24 00:51:15 +00:00
|
|
|
def on_ok(self, host, result):
|
2012-03-18 23:25:56 +00:00
|
|
|
# delete certain info from host_result to make test comparisons easier
|
2012-03-24 00:51:15 +00:00
|
|
|
host_result = result.copy()
|
2012-06-20 01:55:57 +00:00
|
|
|
for k in [ 'ansible_job_id', 'results_file', 'md5sum', 'delta', 'start', 'end' ]:
|
2012-03-18 23:25:56 +00:00
|
|
|
if k in host_result:
|
|
|
|
del host_result[k]
|
2012-03-21 02:29:21 +00:00
|
|
|
for k in host_result.keys():
|
|
|
|
if k.startswith('facter_') or k.startswith('ohai_'):
|
2012-08-07 01:00:21 +00:00
|
|
|
del host_result[k]
|
2012-03-25 23:05:27 +00:00
|
|
|
EVENTS.append([ 'ok', [ host, host_result ]])
|
2012-03-18 22:29:11 +00:00
|
|
|
|
|
|
|
def on_play_start(self, pattern):
|
2012-03-25 23:05:27 +00:00
|
|
|
EVENTS.append([ 'play start', [ pattern ]])
|
2012-03-18 22:29:11 +00:00
|
|
|
|
2012-04-26 18:35:19 +00:00
|
|
|
def on_async_ok(self, host, res, jid):
|
|
|
|
EVENTS.append([ 'async ok', [ host ]])
|
2012-03-18 22:29:11 +00:00
|
|
|
|
2012-04-26 18:35:19 +00:00
|
|
|
def on_async_poll(self, host, res, jid, clock):
|
2012-03-25 23:05:27 +00:00
|
|
|
EVENTS.append([ 'async poll', [ host ]])
|
2012-03-18 22:29:11 +00:00
|
|
|
|
2012-04-26 18:35:19 +00:00
|
|
|
def on_async_failed(self, host, res, jid):
|
|
|
|
EVENTS.append([ 'async failed', [ host ]])
|
|
|
|
|
2012-03-25 23:05:27 +00:00
|
|
|
def on_unreachable(self, host, msg):
|
|
|
|
EVENTS.append([ 'failed/dark', [ host, msg ]])
|
2012-03-18 22:29:11 +00:00
|
|
|
|
2012-07-14 16:24:19 +00:00
|
|
|
def on_setup(self):
|
2012-03-21 01:44:01 +00:00
|
|
|
pass
|
2012-08-07 01:00:21 +00:00
|
|
|
|
2012-04-12 01:05:46 +00:00
|
|
|
def on_no_hosts(self):
|
|
|
|
pass
|
2012-03-18 22:29:11 +00:00
|
|
|
|
2012-04-12 00:16:28 +00:00
|
|
|
class TestPlaybook(unittest.TestCase):
|
2012-03-18 22:29:11 +00:00
|
|
|
|
|
|
|
def setUp(self):
|
|
|
|
self.user = getpass.getuser()
|
|
|
|
self.cwd = os.getcwd()
|
|
|
|
self.test_dir = os.path.join(self.cwd, 'test')
|
|
|
|
self.stage_dir = self._prepare_stage_dir()
|
|
|
|
|
2012-03-18 23:25:56 +00:00
|
|
|
if os.path.exists('/tmp/ansible_test_data_copy.out'):
|
|
|
|
os.unlink('/tmp/ansible_test_data_copy.out')
|
|
|
|
if os.path.exists('/tmp/ansible_test_data_template.out'):
|
|
|
|
os.unlink('/tmp/ansible_test_data_template.out')
|
2013-03-09 23:30:18 +00:00
|
|
|
if os.path.exists('/tmp/ansible_test_messages.out'):
|
|
|
|
os.unlink('/tmp/ansible_test_messages.out')
|
2013-06-03 22:19:11 +00:00
|
|
|
if os.path.exists('/tmp/ansible_test_role_messages.out'):
|
|
|
|
os.unlink('/tmp/ansible_test_role_messages.out')
|
2012-03-18 23:25:56 +00:00
|
|
|
|
2012-03-18 22:29:11 +00:00
|
|
|
def _prepare_stage_dir(self):
|
|
|
|
stage_path = os.path.join(self.test_dir, 'test_data')
|
|
|
|
if os.path.exists(stage_path):
|
|
|
|
shutil.rmtree(stage_path, ignore_errors=False)
|
|
|
|
assert not os.path.exists(stage_path)
|
|
|
|
os.makedirs(stage_path)
|
|
|
|
assert os.path.exists(stage_path)
|
|
|
|
return stage_path
|
|
|
|
|
|
|
|
def _get_test_file(self, filename):
|
|
|
|
# get a file inside the test input directory
|
|
|
|
filename = os.path.join(self.test_dir, filename)
|
|
|
|
assert os.path.exists(filename)
|
|
|
|
return filename
|
2012-08-07 01:00:21 +00:00
|
|
|
|
2012-03-18 22:29:11 +00:00
|
|
|
def _get_stage_file(self, filename):
|
|
|
|
# get a file inside the test output directory
|
|
|
|
filename = os.path.join(self.stage_dir, filename)
|
|
|
|
return filename
|
|
|
|
|
2013-07-18 20:45:18 +00:00
|
|
|
def _run(self, test_playbook, host_list='test/ansible_hosts',
|
|
|
|
extra_vars=None):
|
2012-03-18 22:29:11 +00:00
|
|
|
''' run a module and get the localhost results '''
|
2012-11-04 15:01:58 +00:00
|
|
|
# This ensures tests are independent of eachother
|
2012-11-13 11:09:42 +00:00
|
|
|
global EVENTS
|
2012-11-04 15:01:58 +00:00
|
|
|
ansible.playbook.SETUP_CACHE.clear()
|
|
|
|
EVENTS = []
|
|
|
|
|
2012-03-18 22:29:11 +00:00
|
|
|
self.test_callbacks = TestCallbacks()
|
|
|
|
self.playbook = ansible.playbook.PlayBook(
|
|
|
|
playbook = test_playbook,
|
2012-10-21 18:11:27 +00:00
|
|
|
host_list = host_list,
|
2012-03-18 22:29:11 +00:00
|
|
|
module_path = 'library/',
|
|
|
|
forks = 1,
|
|
|
|
timeout = 5,
|
|
|
|
remote_user = self.user,
|
|
|
|
remote_pass = None,
|
2013-07-18 20:45:18 +00:00
|
|
|
extra_vars = extra_vars,
|
2012-03-25 23:05:27 +00:00
|
|
|
stats = ans_callbacks.AggregateStats(),
|
|
|
|
callbacks = self.test_callbacks,
|
|
|
|
runner_callbacks = self.test_callbacks
|
2012-03-18 22:29:11 +00:00
|
|
|
)
|
2012-04-20 12:09:43 +00:00
|
|
|
result = self.playbook.run()
|
|
|
|
return result
|
2012-03-18 22:29:11 +00:00
|
|
|
|
|
|
|
def test_one(self):
|
2012-11-06 19:57:35 +00:00
|
|
|
pb = 'test/playbook1.yml'
|
2012-03-18 23:25:56 +00:00
|
|
|
actual = self._run(pb)
|
2012-04-12 00:27:17 +00:00
|
|
|
|
2012-08-07 01:00:21 +00:00
|
|
|
expected = {
|
2012-08-28 03:06:39 +00:00
|
|
|
"localhost": {
|
2012-08-07 01:00:21 +00:00
|
|
|
"changed": 9,
|
|
|
|
"failures": 0,
|
|
|
|
"ok": 11,
|
|
|
|
"skipped": 1,
|
2012-04-12 00:27:17 +00:00
|
|
|
"unreachable": 0
|
|
|
|
}
|
|
|
|
}
|
2012-07-15 14:12:49 +00:00
|
|
|
|
|
|
|
assert utils.jsonify(expected, format=True) == utils.jsonify(actual,format=True)
|
2012-03-18 23:25:56 +00:00
|
|
|
|
2012-03-18 23:50:22 +00:00
|
|
|
# make sure the template module took options from the vars section
|
|
|
|
data = file('/tmp/ansible_test_data_template.out').read()
|
|
|
|
assert data.find("ears") != -1, "template success"
|
|
|
|
|
2013-04-05 17:12:46 +00:00
|
|
|
# disabling until we have a nice way of using lookup plugins inside '{{' and '}}'
|
|
|
|
|
|
|
|
#def test_lookups(self):
|
|
|
|
# pb = os.path.join(self.test_dir, 'lookup_plugins.yml')
|
|
|
|
# actual = self._run(pb)
|
|
|
|
#
|
|
|
|
# # if different, this will output to screen
|
|
|
|
# print "**ACTUAL**"
|
|
|
|
# print utils.jsonify(actual, format=True)
|
|
|
|
# expected = {
|
|
|
|
# "localhost": {
|
|
|
|
# "changed": 16,
|
|
|
|
# "failures": 0,
|
|
|
|
# "ok": 21,
|
|
|
|
# "skipped": 1,
|
|
|
|
# "unreachable": 0
|
|
|
|
# }
|
|
|
|
# }
|
|
|
|
# print "**EXPECTED**"
|
|
|
|
# print utils.jsonify(expected, format=True)
|
|
|
|
#
|
|
|
|
# assert utils.jsonify(expected, format=True) == utils.jsonify(actual,format=True)
|
|
|
|
#
|
|
|
|
# print "len(EVENTS) = %d" % len(EVENTS)
|
|
|
|
# assert len(EVENTS) == 74
|
2012-11-04 15:01:58 +00:00
|
|
|
|
2012-11-09 12:09:20 +00:00
|
|
|
def test_includes(self):
|
|
|
|
pb = os.path.join(self.test_dir, 'playbook-includer.yml')
|
|
|
|
actual = self._run(pb)
|
|
|
|
|
|
|
|
# if different, this will output to screen
|
|
|
|
print "**ACTUAL**"
|
|
|
|
print utils.jsonify(actual, format=True)
|
|
|
|
expected = {
|
|
|
|
"localhost": {
|
|
|
|
"changed": 0,
|
|
|
|
"failures": 0,
|
2013-04-10 19:08:18 +00:00
|
|
|
"ok": 6,
|
2012-11-09 12:09:20 +00:00
|
|
|
"skipped": 0,
|
|
|
|
"unreachable": 0
|
2013-03-08 09:08:28 +00:00
|
|
|
}
|
|
|
|
}
|
2012-11-09 12:09:20 +00:00
|
|
|
print "**EXPECTED**"
|
|
|
|
print utils.jsonify(expected, format=True)
|
|
|
|
|
|
|
|
assert utils.jsonify(expected, format=True) == utils.jsonify(actual,format=True)
|
|
|
|
|
2013-07-18 20:45:18 +00:00
|
|
|
def test_templated_includes(self):
|
|
|
|
pb = os.path.join(self.test_dir, 'playbook-templated-includer.yml')
|
|
|
|
actual = self._run(pb, extra_vars={ 'dir': self.test_dir })
|
|
|
|
|
|
|
|
# if different, this will output to screen
|
|
|
|
print "**ACTUAL**"
|
|
|
|
actual_json = utils.jsonify(actual, format=True)
|
|
|
|
print actual_json
|
|
|
|
expected = {
|
|
|
|
"localhost": {
|
|
|
|
"changed": 0,
|
|
|
|
"failures": 0,
|
|
|
|
"ok": 2,
|
|
|
|
"skipped": 0,
|
|
|
|
"unreachable": 0
|
|
|
|
}
|
|
|
|
}
|
|
|
|
expected_json = utils.jsonify(expected, format=True)
|
|
|
|
print "**EXPECTED**"
|
|
|
|
print expected_json
|
|
|
|
|
|
|
|
assert actual_json == expected_json
|
|
|
|
|
Test case and fix for shlex.split unicode bug
When operating on a unicode string in python 2.6, shlex.split returns
a result that does not work with the file constructor.
To reproduce this requires a task include that is templated (this is
because the templated string is a unicode result, whereas a non-
templated string is a non-unicode string)
[will@centos6.3] $ python
Python 2.6.6 (r266:84292, Sep 11 2012, 08:34:23)
[GCC 4.4.6 20120305 (Red Hat 4.4.6-4)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import shlex
>>> shlex.split(u'abc')
['a\x00\x00\x00b\x00\x00\x00c\x00\x00\x00']
[will@fedora17] $ python
Python 2.7.3 (default, Jul 24 2012, 10:05:38)
[GCC 4.7.0 20120507 (Red Hat 4.7.0-5)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import shlex
>>> shlex.split(u'abc')
['abc']
The proposed fix (coercing the include parameters to string before the
shlex.split) may not be ideal but it does fix the bug for my test case.
2013-04-08 04:47:43 +00:00
|
|
|
def test_task_includes(self):
|
|
|
|
pb = os.path.join(self.test_dir, 'task-includer.yml')
|
|
|
|
actual = self._run(pb)
|
|
|
|
|
|
|
|
# if different, this will output to screen
|
|
|
|
print "**ACTUAL**"
|
|
|
|
print utils.jsonify(actual, format=True)
|
|
|
|
expected = {
|
|
|
|
"localhost": {
|
|
|
|
"changed": 0,
|
|
|
|
"failures": 0,
|
|
|
|
"ok": 1,
|
|
|
|
"skipped": 0,
|
|
|
|
"unreachable": 0
|
|
|
|
}
|
|
|
|
}
|
|
|
|
print "**EXPECTED**"
|
|
|
|
print utils.jsonify(expected, format=True)
|
|
|
|
|
|
|
|
assert utils.jsonify(expected, format=True) == utils.jsonify(actual,format=True)
|
|
|
|
|
2013-03-08 09:08:28 +00:00
|
|
|
def test_playbook_vars(self):
|
2012-08-14 03:36:51 +00:00
|
|
|
test_callbacks = TestCallbacks()
|
|
|
|
playbook = ansible.playbook.PlayBook(
|
|
|
|
playbook=os.path.join(self.test_dir, 'test_playbook_vars', 'playbook.yml'),
|
|
|
|
host_list='test/test_playbook_vars/hosts',
|
|
|
|
stats=ans_callbacks.AggregateStats(),
|
|
|
|
callbacks=test_callbacks,
|
|
|
|
runner_callbacks=test_callbacks
|
|
|
|
)
|
|
|
|
playbook.run()
|
|
|
|
|
2012-05-31 20:06:21 +00:00
|
|
|
def test_yaml_hosts_list(self):
|
|
|
|
# Make sure playbooks support hosts: [host1, host2]
|
|
|
|
# TODO: Actually run the play on more than one host
|
|
|
|
test_callbacks = TestCallbacks()
|
|
|
|
playbook = ansible.playbook.PlayBook(
|
|
|
|
playbook=os.path.join(self.test_dir, 'hosts_list.yml'),
|
|
|
|
host_list='test/ansible_hosts',
|
|
|
|
stats=ans_callbacks.AggregateStats(),
|
|
|
|
callbacks=test_callbacks,
|
|
|
|
runner_callbacks=test_callbacks
|
|
|
|
)
|
2012-09-11 22:04:54 +00:00
|
|
|
play = ansible.playbook.Play(playbook, playbook.playbook[0], os.getcwd())
|
2012-05-31 20:06:21 +00:00
|
|
|
assert play.hosts == ';'.join(('host1', 'host2', 'host3'))
|
2012-09-17 20:57:33 +00:00
|
|
|
|
2013-04-08 07:13:23 +00:00
|
|
|
def test_playbook_when(self):
|
|
|
|
test_callbacks = TestCallbacks()
|
|
|
|
playbook = ansible.playbook.PlayBook(
|
|
|
|
playbook=os.path.join(self.test_dir, 'playbook-when.yml'),
|
|
|
|
host_list='test/ansible_hosts',
|
|
|
|
extra_vars={ 'external' : 'xyz', 'identity': 'identity' },
|
|
|
|
stats=ans_callbacks.AggregateStats(),
|
|
|
|
callbacks=test_callbacks,
|
|
|
|
runner_callbacks=test_callbacks
|
|
|
|
)
|
|
|
|
actual = playbook.run()
|
|
|
|
|
|
|
|
# if different, this will output to screen
|
|
|
|
print "**ACTUAL**"
|
|
|
|
print utils.jsonify(actual, format=True)
|
|
|
|
expected = {
|
|
|
|
"localhost": {
|
|
|
|
"changed": 0,
|
|
|
|
"failures": 0,
|
|
|
|
"ok": 3,
|
|
|
|
"skipped": 3,
|
|
|
|
"unreachable": 0
|
|
|
|
}
|
|
|
|
}
|
|
|
|
print "**EXPECTED**"
|
|
|
|
print utils.jsonify(expected, format=True)
|
|
|
|
|
|
|
|
assert utils.jsonify(expected, format=True) == utils.jsonify(actual,format=True)
|
2013-04-17 00:06:06 +00:00
|
|
|
|
2013-03-09 23:30:18 +00:00
|
|
|
def test_playbook_hash_replace(self):
|
|
|
|
# save default hash behavior so we can restore it in the end of the test
|
|
|
|
saved_hash_behavior = C.DEFAULT_HASH_BEHAVIOUR
|
|
|
|
C.DEFAULT_HASH_BEHAVIOUR = "replace"
|
|
|
|
|
|
|
|
test_callbacks = TestCallbacks()
|
|
|
|
playbook = ansible.playbook.PlayBook(
|
|
|
|
playbook=os.path.join(self.test_dir, 'test_hash_behavior', 'playbook.yml'),
|
|
|
|
host_list='test/ansible_hosts',
|
|
|
|
stats=ans_callbacks.AggregateStats(),
|
|
|
|
callbacks=test_callbacks,
|
|
|
|
runner_callbacks=test_callbacks
|
|
|
|
)
|
|
|
|
playbook.run()
|
|
|
|
|
2013-06-03 22:19:11 +00:00
|
|
|
filename = '/tmp/ansible_test_messages.out'
|
|
|
|
expected_lines = [
|
2013-03-09 23:30:18 +00:00
|
|
|
"goodbye: Goodbye World!"
|
|
|
|
]
|
2013-06-03 22:19:11 +00:00
|
|
|
self._compare_file_output(filename, expected_lines)
|
2013-03-09 23:30:18 +00:00
|
|
|
|
2013-06-03 22:19:11 +00:00
|
|
|
filename = '/tmp/ansible_test_role_messages.out'
|
|
|
|
expected_lines = [
|
|
|
|
"inside_a_role: Indeed!"
|
|
|
|
]
|
|
|
|
self._compare_file_output(filename, expected_lines)
|
2013-03-09 23:30:18 +00:00
|
|
|
|
|
|
|
# restore default hash behavior
|
|
|
|
C.DEFAULT_HASH_BEHAVIOUR = saved_hash_behavior
|
|
|
|
|
|
|
|
def test_playbook_hash_merge(self):
|
|
|
|
# save default hash behavior so we can restore it in the end of the test
|
|
|
|
saved_hash_behavior = C.DEFAULT_HASH_BEHAVIOUR
|
|
|
|
C.DEFAULT_HASH_BEHAVIOUR = "merge"
|
|
|
|
|
|
|
|
test_callbacks = TestCallbacks()
|
|
|
|
playbook = ansible.playbook.PlayBook(
|
|
|
|
playbook=os.path.join(self.test_dir, 'test_hash_behavior', 'playbook.yml'),
|
|
|
|
host_list='test/ansible_hosts',
|
|
|
|
stats=ans_callbacks.AggregateStats(),
|
|
|
|
callbacks=test_callbacks,
|
|
|
|
runner_callbacks=test_callbacks
|
|
|
|
)
|
|
|
|
playbook.run()
|
|
|
|
|
2013-06-03 22:19:11 +00:00
|
|
|
filename = '/tmp/ansible_test_messages.out'
|
|
|
|
expected_lines = [
|
|
|
|
"goodbye: Goodbye World!",
|
|
|
|
"hello: Hello World!"
|
|
|
|
]
|
|
|
|
self._compare_file_output(filename, expected_lines)
|
2013-03-09 23:30:18 +00:00
|
|
|
|
2013-06-03 22:19:11 +00:00
|
|
|
filename = '/tmp/ansible_test_role_messages.out'
|
|
|
|
expected_lines = [
|
|
|
|
"goodbye: Goodbye World!",
|
2013-03-09 23:30:18 +00:00
|
|
|
"hello: Hello World!",
|
2013-06-03 22:19:11 +00:00
|
|
|
"inside_a_role: Indeed!"
|
2013-03-09 23:30:18 +00:00
|
|
|
]
|
2013-06-03 22:19:11 +00:00
|
|
|
self._compare_file_output(filename, expected_lines)
|
2013-03-09 23:30:18 +00:00
|
|
|
|
|
|
|
# restore default hash behavior
|
|
|
|
C.DEFAULT_HASH_BEHAVIOUR = saved_hash_behavior
|
2013-06-03 22:19:11 +00:00
|
|
|
|
2013-07-01 00:31:16 +00:00
|
|
|
def test_playbook_ignore_errors(self):
|
|
|
|
test_callbacks = TestCallbacks()
|
|
|
|
playbook = ansible.playbook.PlayBook(
|
|
|
|
playbook=os.path.join(self.test_dir, 'playbook-ignore-errors.yml'),
|
|
|
|
host_list='test/ansible_hosts',
|
|
|
|
stats=ans_callbacks.AggregateStats(),
|
|
|
|
callbacks=test_callbacks,
|
|
|
|
runner_callbacks=test_callbacks
|
|
|
|
)
|
|
|
|
actual = playbook.run()
|
|
|
|
|
|
|
|
# if different, this will output to screen
|
|
|
|
print "**ACTUAL**"
|
|
|
|
print utils.jsonify(actual, format=True)
|
|
|
|
expected = {
|
|
|
|
"localhost": {
|
|
|
|
"changed": 1,
|
|
|
|
"failures": 1,
|
|
|
|
"ok": 1,
|
|
|
|
"skipped": 0,
|
|
|
|
"unreachable": 0
|
|
|
|
}
|
|
|
|
}
|
|
|
|
print "**EXPECTED**"
|
|
|
|
print utils.jsonify(expected, format=True)
|
|
|
|
|
|
|
|
assert utils.jsonify(expected, format=True) == utils.jsonify(actual,format=True)
|
|
|
|
|
2013-07-14 19:07:45 +00:00
|
|
|
def test_playbook_changed_when(self):
|
|
|
|
test_callbacks = TestCallbacks()
|
|
|
|
playbook = ansible.playbook.PlayBook(
|
|
|
|
playbook=os.path.join(self.test_dir, 'playbook-changed_when.yml'),
|
|
|
|
host_list='test/ansible_hosts',
|
|
|
|
stats=ans_callbacks.AggregateStats(),
|
|
|
|
callbacks=test_callbacks,
|
|
|
|
runner_callbacks=test_callbacks
|
|
|
|
)
|
|
|
|
actual = playbook.run()
|
|
|
|
|
|
|
|
# if different, this will output to screen
|
|
|
|
print "**ACTUAL**"
|
|
|
|
print utils.jsonify(actual, format=True)
|
|
|
|
expected = {
|
|
|
|
"localhost": {
|
|
|
|
"changed": 3,
|
|
|
|
"failures": 0,
|
|
|
|
"ok": 6,
|
|
|
|
"skipped": 0,
|
|
|
|
"unreachable": 0
|
|
|
|
}
|
|
|
|
}
|
|
|
|
print "**EXPECTED**"
|
|
|
|
print utils.jsonify(expected, format=True)
|
|
|
|
|
|
|
|
assert utils.jsonify(expected, format=True) == utils.jsonify(actual,format=True)
|
|
|
|
|
2013-06-03 22:19:11 +00:00
|
|
|
def _compare_file_output(self, filename, expected_lines):
|
|
|
|
actual_lines = []
|
|
|
|
with open(filename) as f:
|
|
|
|
actual_lines = [l.strip() for l in f.readlines()]
|
|
|
|
actual_lines = sorted(actual_lines)
|
|
|
|
|
|
|
|
print "**ACTUAL**"
|
|
|
|
print actual_lines
|
|
|
|
|
|
|
|
print "**EXPECTED**"
|
|
|
|
print expected_lines
|
|
|
|
|
|
|
|
assert actual_lines == expected_lines
|