def test_generate_junit_for_playbook(self):
""" Roughly ensures the expected xml is generated properly """
tdir = self.generate_dir
# Record two separate playbooks
ctx = ansible_run()
ansible_run()
cmd = ara.cli.generate.GenerateJunit(None, None)
parser = cmd.get_parser('test')
junit_file = "{tdir}/junit-playbook.xml".format(tdir=tdir)
playbook = ctx['playbook'].id
args = parser.parse_args([junit_file, '--playbook', playbook])
cmd.take_action(args)
# Test that we effectively have two playbooks
playbooks = m.Playbook.query.all()
all_tasks = m.Task.query.all()
tasks = (m.Task.query
.filter(m.Task.playbook_id == ctx['playbook'].id).all())
self.assertEqual(len(playbooks), 2)
self.assertNotEqual(len(all_tasks), len(tasks))
self.assertTrue(os.path.exists(junit_file))
tree = etree.parse(junit_file)
self.assertEqual(tree.getroot().tag, "testsuites")
self.assertEqual(tree.getroot()[0].tag, "testsuite")
self.assertEqual(tree.getroot()[0][0].tag, "testcase")
self.assertEqual(int(tree.getroot().get('tests')), len(tasks))
def test_fast_count(self):
ansible_run()
query = m.Task.query
normal_count = query.count()
fast_count = u.fast_count(query)
self.assertEqual(normal_count, fast_count)
def test_stats_show_non_existing(self):
ansible_run()
cmd = ara.cli.stats.StatsShow(None, None)
parser = cmd.get_parser('test')
args = parser.parse_args(['foo'])
with self.assertRaises(RuntimeError):
cmd.take_action(args)
def test_task_list_non_existing_playbook(self):
ansible_run()
cmd = ara.cli.task.TaskList(None, None)
parser = cmd.get_parser('test')
args = parser.parse_args(['--playbook', 'foo'])
res = cmd.take_action(args)
self.assertEqual(res[1], [])
def test_result_list_non_existing_task(self):
ansible_run()
cmd = ara.cli.result.ResultList(None, None)
parser = cmd.get_parser('test')
args = parser.parse_args(['--task', 'foo'])
res = cmd.take_action(args)
self.assertEqual(res[1], [])
def test_data_list_for_non_existing_playbook(self):
ansible_run(ara_record=True)
cmd = ara.cli.data.DataList(None, None)
parser = cmd.get_parser('test')
args = parser.parse_args(['--playbook', 'foo'])
res = cmd.take_action(args)
self.assertEqual(res[1], [])
def test_playbook_list_incomplete_with_no_incomplete(self):
ansible_run()
cmd = ara.cli.playbook.PlaybookList(None, None)
parser = cmd.get_parser('test')
args = parser.parse_args(['--incomplete'])
res = cmd.take_action(args)
self.assertEqual(res[1], [])
def test_result_show_long_non_existing(self):
ansible_run()
cmd = ara.cli.result.ResultShow(None, None)
parser = cmd.get_parser('test')
args = parser.parse_args(['foo', '--long'])
with self.assertRaises(RuntimeError):
cmd.take_action(args)
def test_host_fact_non_existing_host(self):
ansible_run()
cmd = ara.cli.host.HostFacts(None, None)
parser = cmd.get_parser('test')
args = parser.parse_args('foo')
with self.assertRaises(RuntimeError):
cmd.take_action(args)
def test_data_show_for_non_existing_data(self):
ansible_run(ara_record=True)
cmd = ara.cli.data.DataShow(None, None)
parser = cmd.get_parser('test')
args = parser.parse_args(['foo'])
with self.assertRaises(RuntimeError):
cmd.take_action(args)
def test_generate_html_no_destination(self):
""" Ensures generating without a destination fails """
ansible_run()
cmd = ara.cli.generate.GenerateHtml(None, None)
parser = cmd.get_parser('test')
with self.assertRaises(SystemExit):
args = parser.parse_args([])
cmd.take_action(args)
def test_playbook_delete(self):
# Run two playbook runs
ctx = ansible_run(ara_record=True)
ansible_run(gather_facts=False)
# Assert that we have two playbooks and that we have valid data for
# the first playbook
playbooks = m.Playbook.query.all()
self.assertTrue(len(playbooks) == 2)
d = m.Data.query.filter(m.Data.playbook_id.in_([ctx['playbook'].id]))
self.assertNotEqual(d.count(), 0)
f = m.File.query.filter(m.File.playbook_id.in_([ctx['playbook'].id]))
self.assertNotEqual(f.count(), 0)
p = m.Play.query.filter(m.Play.playbook_id.in_([ctx['playbook'].id]))
self.assertNotEqual(p.count(), 0)
t = m.Task.query.filter(m.Task.playbook_id.in_([ctx['playbook'].id]))
self.assertNotEqual(t.count(), 0)
tr = m.TaskResult.query.count() # compared later
h = m.Host.query.filter(m.Host.playbook_id.in_([ctx['playbook'].id]))
self.assertNotEqual(h.count(), 0)
hf = m.HostFacts.query
self.assertNotEqual(hf.count(), 0)
s = m.Stats.query.filter(m.Stats.playbook_id.in_([ctx['playbook'].id]))
self.assertNotEqual(s.count(), 0)
# Delete the first playbook
cmd = ara.cli.playbook.PlaybookDelete(None, None)
parser = cmd.get_parser('test')
args = parser.parse_args([ctx['playbook'].id])
cmd.take_action(args)
# Assert that we only have one playbook left and that records have been
# deleted
playbooks = m.Playbook.query.all()
self.assertTrue(len(playbooks) == 1)
d = m.Data.query.filter(m.Data.playbook_id.in_([ctx['playbook'].id]))
self.assertEqual(d.count(), 0)
f = m.File.query.filter(m.File.playbook_id.in_([ctx['playbook'].id]))
self.assertEqual(f.count(), 0)
p = m.Play.query.filter(m.Play.playbook_id.in_([ctx['playbook'].id]))
self.assertEqual(p.count(), 0)
t = m.Task.query.filter(m.Task.playbook_id.in_([ctx['playbook'].id]))
self.assertEqual(t.count(), 0)
new_tr = m.TaskResult.query.count() # compare before and after
self.assertNotEqual(tr, new_tr)
h = m.Host.query.filter(m.Host.playbook_id.in_([ctx['playbook'].id]))
self.assertEqual(h.count(), 0)
hf = m.HostFacts.query
self.assertEqual(hf.count(), 0)
s = m.Stats.query.filter(m.Stats.playbook_id.in_([ctx['playbook'].id]))
self.assertEqual(s.count(), 0)
def test_reports_with_pagination(self):
ansible_run()
ansible_run()
self.app.config['ARA_PLAYBOOK_PER_PAGE'] = 1
res = self.client.get('/reports/')
self.assertEqual(res.status_code, 200)
res = self.client.get('/reports/list/1.html')
self.assertEqual(res.status_code, 200)
res = self.client.get('/reports/list/2.html')
self.assertEqual(res.status_code, 200)
def test_data_show_by_id(self):
ctx = ansible_run(ara_record=True)
cmd = ara.cli.data.DataShow(None, None)
parser = cmd.get_parser('test')
args = parser.parse_args([ctx['data'].id])
res = cmd.take_action(args)
self.assertEqual(res[1][0], ctx['data'].id)
def test_result_list_task(self):
ctx = ansible_run()
cmd = ara.cli.result.ResultList(None, None)
parser = cmd.get_parser('test')
args = parser.parse_args(['--task', ctx['task'].id])
res = cmd.take_action(args)
self.assertEqual(res[1][0][0], ctx['result'].id)
def test_playbook_show(self):
ctx = ansible_run()
cmd = ara.cli.playbook.PlaybookShow(None, None)
parser = cmd.get_parser('test')
args = parser.parse_args([ctx['playbook'].id])
res = cmd.take_action(args)
self.assertEqual(res[1][0], ctx['playbook'].id)
def test_play_list_all(self):
ctx = ansible_run()
cmd = ara.cli.play.PlayList(None, None)
parser = cmd.get_parser('test')
args = parser.parse_args(['--all'])
res = cmd.take_action(args)
self.assertEqual(res[1][0][0], ctx['play'].id)
def test_host_fact_existing_host_non_existing_facts(self):
ctx = ansible_run(gather_facts=False)
cmd = ara.cli.host.HostFacts(None, None)
parser = cmd.get_parser('test')
args = parser.parse_args([ctx['host'].id])
with self.assertRaises(RuntimeError):
cmd.take_action(args)
def test_host_show_by_id(self):
ctx = ansible_run()
cmd = ara.cli.host.HostShow(None, None)
parser = cmd.get_parser('test')
args = parser.parse_args([ctx['host'].id])
res = cmd.take_action(args)
self.assertEqual(res[1][0], ctx['host'].id)
def test_host_list(self):
ctx = ansible_run()
cmd = ara.cli.host.HostList(None, None)
parser = cmd.get_parser('test')
args = parser.parse_args(['-a'])
res = cmd.take_action(args)
self.assertEqual(res[1][0][0], ctx['host'].id)
def test_playbook_list_incomplete(self):
ctx = ansible_run(complete=False)
cmd = ara.cli.playbook.PlaybookList(None, None)
parser = cmd.get_parser('test')
args = parser.parse_args(['--incomplete'])
res = cmd.take_action(args)
self.assertEqual(res[1][0][0], ctx['playbook'].id)
def test_stats_show(self):
ctx = ansible_run()
cmd = ara.cli.stats.StatsShow(None, None)
parser = cmd.get_parser('test')
args = parser.parse_args([ctx['stats'].id])
res = cmd.take_action(args)
self.assertEqual(res[1][0], ctx['stats'].id)
def test_data_list_for_playbook(self):
ctx = ansible_run(ara_record=True)
cmd = ara.cli.data.DataList(None, None)
parser = cmd.get_parser('test')
args = parser.parse_args(['--playbook', ctx['playbook'].id])
res = cmd.take_action(args)
self.assertEqual(res[1][0][0], ctx['data'].id)
def test_task_list_playbook(self):
ctx = ansible_run()
cmd = ara.cli.task.TaskList(None, None)
parser = cmd.get_parser('test')
args = parser.parse_args(['--playbook', ctx['playbook'].id])
res = cmd.take_action(args)
self.assertEqual(res[1][0][0], ctx['task'].id)
def test_host_show_by_name(self):
ctx = ansible_run()
cmd = ara.cli.host.HostShow(None, None)
parser = cmd.get_parser('test')
args = parser.parse_args(
['-b', ctx['host'].playbook.id, ctx['host'].name])
res = cmd.take_action(args)
self.assertEqual(res[1][0], ctx['host'].id)
def test_host_fact_by_id(self):
ctx = ansible_run()
cmd = ara.cli.host.HostFacts(None, None)
parser = cmd.get_parser('test')
args = parser.parse_args([ctx['host'].id])
res = cmd.take_action(args)
facts = json.loads(ctx['facts'].values)
self.assertEqual(res, zip(*sorted(six.iteritems(facts))))
def test_result_show_long(self):
ctx = ansible_run()
cmd = ara.cli.result.ResultShow(None, None)
parser = cmd.get_parser('test')
args = parser.parse_args([ctx['result'].id, '--long'])
res = cmd.take_action(args)
self.assertEqual(res[1][0], ctx['result'].id)
self.assertEqual(res[1][-1], json.dumps(ctx['result'].result))
def test_data_show_by_key(self):
ctx = ansible_run(ara_record=True)
cmd = ara.cli.data.DataShow(None, None)
parser = cmd.get_parser('test')
args = parser.parse_args(
['-b', ctx['data'].playbook.id, ctx['data'].key])
res = cmd.take_action(args)
self.assertEqual(res[1][0], ctx['data'].id)
def test_result_show_long(self):
ctx = ansible_run()
cmd = ara.cli.result.ResultShow(None, None)
parser = cmd.get_parser('test')
args = parser.parse_args([ctx['result'].id, '--long'])
res = cmd.take_action(args)
self.assertEqual(res[1][0], ctx['result'].id)
self.assertEqual(res[1][-1], jsonutils.dumps(ctx['result'].result))
def test_generate_html_for_playbook(self):
""" Roughly ensures the expected files are generated properly """
dir = self.generate_dir
# Record two separate playbooks
ctx = ansible_run()
ansible_run()
cmd = ara.cli.generate.GenerateHtml(None, None)
parser = cmd.get_parser('test')
args = parser.parse_args([dir, '--playbook', ctx['playbook'].id])
cmd.take_action(args)
file_id = ctx['task'].file_id
host_id = ctx['host'].id
result_id = ctx['result'].id
paths = [
os.path.join(dir, 'index.html'),
os.path.join(dir, 'static'),
os.path.join(dir, 'file/index.html'),
os.path.join(dir, 'file/{0}'.format(file_id)),
os.path.join(dir, 'host/index.html'),
os.path.join(dir, 'host/{0}'.format(host_id)),
os.path.join(dir, 'reports/index.html'),
os.path.join(dir, 'playbook/index.html'),
os.path.join(dir, 'result/index.html'),
os.path.join(dir, 'result/{0}'.format(result_id))
]
for path in paths:
self.assertTrue(os.path.exists(path))
# Test that we effectively have two playbooks
playbooks = m.Playbook.query.all()
self.assertTrue(len(playbooks) == 2)
# Retrieve the other playbook and validate that we haven't generated
# files for it
playbook_two = (m.Playbook.query
.filter(m.Playbook.id != ctx['playbook'].id).one())
path = os.path.join(dir, 'playbook/{0}'.format(playbook_two.id))
self.assertFalse(os.path.exists(path))
def test_get_summary_stats_failed(self):
ctx = ansible_run(failed=True)
playbook = ctx['playbook'].id
res = u.get_summary_stats([ctx['playbook']], 'playbook_id')
self.assertEqual(1, res[playbook]['ok'])
self.assertEqual(1, res[playbook]['changed'])
self.assertEqual(1, res[playbook]['failed'])
self.assertEqual(1, res[playbook]['skipped'])
self.assertEqual(0, res[playbook]['unreachable'])
self.assertEqual('failed', res[playbook]['status'])
def test_get_summary_stats_failed(self):
ctx = ansible_run(failed=True)
playbook = ctx['playbook'].id
res = u.get_summary_stats([ctx['playbook']], 'playbook_id')
self.assertEqual(1, res[playbook]['ok'])
self.assertEqual(1, res[playbook]['changed'])
self.assertEqual(1, res[playbook]['failed'])
self.assertEqual(1, res[playbook]['skipped'])
self.assertEqual(0, res[playbook]['unreachable'])
self.assertEqual('failed', res[playbook]['status'])
def test_get_summary_stats_incomplete(self):
ctx = ansible_run(complete=False)
playbook = ctx['playbook'].id
res = u.get_summary_stats([ctx['playbook']], 'playbook_id')
self.assertEqual(0, res[playbook]['ok'])
self.assertEqual(0, res[playbook]['changed'])
self.assertEqual(0, res[playbook]['failed'])
self.assertEqual(0, res[playbook]['skipped'])
self.assertEqual(0, res[playbook]['unreachable'])
self.assertEqual('incomplete', res[playbook]['status'])
def test_get_summary_stats_incomplete(self):
ctx = ansible_run(complete=False)
playbook = ctx['playbook'].id
res = u.get_summary_stats([ctx['playbook']], 'playbook_id')
self.assertEqual(0, res[playbook]['ok'])
self.assertEqual(0, res[playbook]['changed'])
self.assertEqual(0, res[playbook]['failed'])
self.assertEqual(0, res[playbook]['skipped'])
self.assertEqual(0, res[playbook]['unreachable'])
self.assertEqual('incomplete', res[playbook]['status'])
def test_host_fact_by_id(self):
ctx = ansible_run()
cmd = ara.cli.host.HostFacts(None, None)
parser = cmd.get_parser('test')
args = parser.parse_args([ctx['host'].id])
res = cmd.take_action(args)
facts = jsonutils.loads(ctx['facts'].values)
expected = six.moves.zip(*sorted(six.iteritems(facts)))
self.assertSequenceEqual(list(res), list(expected))
def test_host_fact_by_id(self):
ctx = ansible_run()
cmd = ara.cli.host.HostFacts(None, None)
parser = cmd.get_parser('test')
args = parser.parse_args([ctx['host'].id])
res = cmd.take_action(args)
facts = jsonutils.loads(ctx['facts'].values)
expected = six.moves.zip(*sorted(six.iteritems(facts)))
self.assertSequenceEqual(list(res), list(expected))
def test_generate_html(self):
""" Roughly ensures the expected files are generated properly """
dir = self.generate_dir
ansible_run()
shell = ara.shell.AraCli()
shell.prepare_to_run_command(ara.cli.generate.GenerateHtml)
cmd = ara.cli.generate.GenerateHtml(shell, None)
parser = cmd.get_parser('test')
args = parser.parse_args([dir])
cmd.take_action(args)
paths = [
os.path.join(dir, 'index.html'),
os.path.join(dir, 'static'),
os.path.join(dir, 'file/index.html'),
os.path.join(dir, 'host/index.html'),
os.path.join(dir, 'reports/index.html'),
os.path.join(dir, 'result/index.html'),
]
for path in paths:
self.assertTrue(os.path.exists(path))
def test_generate_html(self):
""" Roughly ensures the expected files are generated properly """
dir = self.generate_dir
ansible_run()
shell = ara.shell.AraCli()
shell.prepare_to_run_command(ara.cli.generate.GenerateHtml)
cmd = ara.cli.generate.GenerateHtml(shell, None)
parser = cmd.get_parser('test')
args = parser.parse_args([dir])
cmd.take_action(args)
paths = [
os.path.join(dir, 'index.html'),
os.path.join(dir, 'static'),
os.path.join(dir, 'file/index.html'),
os.path.join(dir, 'host/index.html'),
os.path.join(dir, 'reports/index.html'),
os.path.join(dir, 'result/index.html'),
]
for path in paths:
self.assertTrue(os.path.exists(path))
def test_playbook_treeview(self):
ctx = ansible_run()
treeview = jsonutils.loads(u.playbook_treeview(ctx['playbook'].id))
# ansible_run provides two fake files:
# /some/path/main.yml and /playbook.yml
for f in treeview:
if f['text'] == 'some':
self.assertEqual(f['text'], 'some')
child = f['nodes'][0]
self.assertEqual(child['text'], 'path')
child = child['nodes'][0]
self.assertEqual(child['text'], 'main.yml')
self.assertEqual(child['dataAttr']['load'],
ctx['task_file'].id)
else:
self.assertEqual(f['text'], 'playbook.yml')
self.assertEqual(f['dataAttr']['load'], ctx['pb_file'].id)
def test_playbook_treeview(self):
ctx = ansible_run()
treeview = jsonutils.loads(u.playbook_treeview(ctx['playbook'].id))
# ansible_run provides two fake files:
# /some/path/main.yml and /playbook.yml
for f in treeview:
if f['text'] == 'some':
self.assertEqual(f['text'], 'some')
child = f['nodes'][0]
self.assertEqual(child['text'], 'path')
child = child['nodes'][0]
self.assertEqual(child['text'], 'main.yml')
self.assertEqual(child['dataAttr']['load'],
ctx['task_file'].id + '/')
else:
self.assertEqual(f['text'], 'playbook.yml')
self.assertEqual(
f['dataAttr']['load'], ctx['pb_file'].id + '/'
)
def test_generate_junit(self):
""" Roughly ensures the expected xml is generated properly """
tdir = self.generate_dir
ctx = ansible_run()
cmd = ara.cli.generate.GenerateJunit(None, None)
parser = cmd.get_parser('test')
junit_file = '{tdir}/junit.xml'.format(tdir=tdir)
args = parser.parse_args([junit_file])
cmd.take_action(args)
self.assertTrue(os.path.exists(junit_file))
tasks = m.Task.query.all()
tree = etree.parse(junit_file)
self.assertEqual(tree.getroot().tag, "testsuites")
self.assertEqual(tree.getroot()[0].tag, "testsuite")
self.assertEqual(tree.getroot()[0][0].tag, "testcase")
self.assertEqual(int(tree.getroot().get('tests')), len(tasks))
self.assertEqual(int(tree.getroot().get('failures')),
ctx['stats'].failed)
def test_reports_with_override(self):
ctx = ansible_run()
self.app.config['ARA_PLAYBOOK_OVERRIDE'] = [ctx['playbook'].id]
res = self.client.get('/reports/')
self.assertEqual(res.status_code, 200)
def test_reports_with_bad_override(self):
ansible_run()
self.app.config['ARA_PLAYBOOK_OVERRIDE'] = ['uuuu-iiii-dddd-0000']
res = self.client.get('/reports/')
self.assertEqual(res.status_code, 302)
def test_reports(self):
ansible_run()
res = self.client.get('/reports/')
self.assertEqual(res.status_code, 200)
def test_reports_with_incomplete(self):
ansible_run(complete=False)
res = self.client.get('/reports/')
self.assertEqual(res.status_code, 200)
def test_show_host_exists_facts_missing(self):
ctx = ansible_run(gather_facts=False)
res = self.client.get('/host/{}/'.format(ctx['host'].id))
self.assertEqual(res.status_code, 404)
def test_home_with_data(self):
ansible_run()
res = self.client.get('/')
self.assertEqual(res.status_code, 200)
def test_show_playbook_incomplete(self):
ctx = ansible_run(complete=False)
res = self.client.get('/playbook/{}/'.format(
ctx['playbook'].id))
self.assertEqual(res.status_code, 200)
def test_generate_subunit(self):
""" Roughly ensures the expected subunit is generated properly """
tdir = self.generate_dir
ansible_run()
cmd = ara.cli.generate.GenerateSubunit(None, None)
parser = cmd.get_parser('test')
subunit_file = os.path.join(tdir, 'test.subunit')
subunit_dir = os.path.join(tdir, 'subunit_dir')
args = parser.parse_args([subunit_file])
cmd.take_action(args)
self.assertTrue(os.path.exists(subunit_file))
# Dump the subunit binary stream to some files we can read and assert
with open(subunit_file, 'r') as f:
to_disk(['-d', subunit_dir], stdin=f)
# Get *.json files, load them and test them
data = []
testfiles = glob("%s/%s" % (subunit_dir, '*/*.json'))
for testfile in testfiles:
with open(testfile, 'rb') as f:
data.append(jsonutils.load(f))
keys = ['status', 'tags', 'stop', 'start', 'details', 'id']
for result in data:
# Test that we have the expected keys, no more, no less
for key in keys:
self.assertTrue(key in result.keys())
for key in result.keys():
self.assertTrue(key in keys)
# Get non-json files, load them and test them
data = []
testfiles = [fn for fn in glob("%s/%s" % (subunit_dir, '*/*'))
if not os.path.basename(fn).endswith('json')]
for testfile in testfiles:
with open(testfile, 'rb') as f:
data.append(jsonutils.load(f))
keys = ['host', 'playbook_id', 'playbook_path', 'play_name',
'task_action', 'task_action_lineno', 'task_id', 'task_name',
'task_path']
for result in data:
# Test that we have the expected keys, no more, no less
for key in keys:
self.assertTrue(key in result.keys())
for key in result.keys():
self.assertTrue(key in keys)
# Test that we have matching data for playbook records
playbook = m.Playbook.query.get(result['playbook_id'])
self.assertEqual(playbook.id, result['playbook_id'])
self.assertEqual(playbook.path, result['playbook_path'])
# Test that we have matchin gdata for task records
task = m.Task.query.get(result['task_id'])
self.assertEqual(task.id, result['task_id'])
self.assertEqual(task.action, result['task_action'])
self.assertEqual(task.file.path, result['task_path'])
self.assertEqual(task.lineno, result['task_action_lineno'])
self.assertEqual(task.name, result['task_name'])
def test_list_playbook(self):
ansible_run()
res = self.client.get('/playbook/')
self.assertEqual(res.status_code, 200)
def test_list_playbook_incomplete(self):
ansible_run(complete=False)
res = self.client.get('/playbook/')
self.assertEqual(res.status_code, 200)
def test_show_file(self):
ctx = ansible_run()
res = self.client.get('/file/{0}/'.format(ctx['pb_file'].id))
self.assertEqual(res.status_code, 200)
def test_show_result_missing(self):
ansible_run()
res = self.client.get('/result/foo/')
self.assertEqual(res.status_code, 404)
def test_show_result_index(self):
ansible_run()
res = self.client.get('/result/')
self.assertEqual(res.status_code, 200)
def test_report_ajax_no_plays(self):
ansible_run()
res = self.client.get('/reports/ajax/plays/uuid.txt')
self.assertEqual(res.status_code, 404)
def test_show_playbook_results_host_status(self):
ctx = ansible_run()
res = self.client.get('/playbook/{}/host/{}/ok/'.format(
ctx['playbook'].id,
ctx['host'].name))
self.assertEqual(res.status_code, 200)
def test_report_ajax_records(self):
ctx = ansible_run(ara_record=True)
pbid = ctx['playbook'].id
res = self.client.get('/reports/ajax/records/{0}.txt'.format(pbid))
self.assertEqual(res.status_code, 200)
def test_show_playbook_results_task(self):
ctx = ansible_run()
res = self.client.get('/playbook/{}/task/{}/'.format(
ctx['playbook'].id,
ctx['task'].id))
self.assertEqual(res.status_code, 200)
def test_show_result_incomplete(self):
ctx = ansible_run(complete=False)
res = self.client.get('/result/{}/'.format(ctx['result'].id))
self.assertEqual(res.status_code, 200)
def test_show_host(self):
ctx = ansible_run()
res = self.client.get('/host/{}/'.format(ctx['host'].id))
self.assertEqual(res.status_code, 200)
