def test_target_status_pass(self):
"""
This tests to ensure a target's status is being set properly
based on it's session statuses.
"""
session1 = Database.create_session(None, 0)
target = Database.get_target(session1.target_name)
self.assertEqual(target.status, SESSION_STATUSES.get('inactive'))
missing_timer = 2401 + SESSION_CHECK_THRESHOLD
session2 = Database.create_session(target.name,
time.time() - missing_timer, 1800,
600)
self.assertEqual(target.status, SESSION_STATUSES.get('missing'))
session3 = Database.create_session(target.name)
self.assertEqual(target.status, SESSION_STATUSES.get('active'))
session3.timestamp = 0
session3.save()
self.assertEqual(target.status, SESSION_STATUSES.get('missing'))
session2.timestamp = 0
session2.save()
self.assertEqual(target.status, SESSION_STATUSES.get('inactive'))
def test_status(self):
"""
Ensure that the proper status is set for a group action
based on it's included actions.
"""
# After creation, status should be queued
group_action = Database.create_group_action()
self.assertEqual(group_action.get_status(),
GROUP_ACTION_STATUSES.get('queued', 'queued'))
# Send to a session, status should be in progress
session = Database.create_session()
group_action.actions[0].assign_to(session.session_id)
self.assertEqual(
group_action.get_status(),
GROUP_ACTION_STATUSES.get('in progress', 'in progress'))
# Submit a response to all actions, status should be success
for action in group_action.actions:
action.assign_to(session.session_id)
response = Database.create_response()
action.submit_response(response)
self.assertEqual(group_action.get_status(),
GROUP_ACTION_STATUSES.get('success', 'success'))
# Create a new group action, make all actions stale. Status should be stale
group_action = Database.create_group_action()
for action in group_action.actions:
action.queue_time = 0
action.save()
self.assertEqual(group_action.get_status(),
GROUP_ACTION_STATUSES.get('stale', 'stale'))
# Have a session check in, status should update to in progress
group_action.actions[0].assign_to(session.session_id)
self.assertEqual(
group_action.get_status(),
GROUP_ACTION_STATUSES.get('in progress', 'in progress'))
# Submit a response, status should be mixed success
response = Database.create_response()
group_action.actions[0].submit_response(response)
self.assertEqual(
group_action.get_status(),
GROUP_ACTION_STATUSES.get('mixed success', 'mixed success'))
# Set all actions to failed. Status should be failed.
group_action = Database.create_group_action()
session = Database.create_session(None, 0)
for action in group_action.actions:
action.assign_to(session.session_id)
self.assertEqual(group_action.get_status(),
GROUP_ACTION_STATUSES.get('failed', 'failed'))
# Create a new group action, and cancel it. Status should be cancelled
group_action = Database.create_group_action()
group_action.cancel()
self.assertEqual(group_action.get_status(),
GROUP_ACTION_STATUSES.get('cancelled', 'cancelled'))
def test_target_rename_association(self):
"""
Tests the RenameTarget API function, check to make sure Sessions, Targets, and Groups.
"""
target = Database.create_target()
target_name = target.name
session_id = Database.create_session(target_name).session_id
orig_group = Database.create_group('some_group')
orig_group.whitelist_member(target.name)
action_id = Database.create_action(target_name).action_id
data = APIClient.rename_target(self.client, target_name, 'TEST')
self.assertEqual(data['error'], False)
target = Database.get_target('TEST')
self.assertIsNotNone(target)
with self.assertRaises(DoesNotExist):
Database.get_target(target_name)
self.assertEqual(target.name, 'TEST')
session = Database.get_session(session_id)
self.assertEqual(session.target_name, 'TEST')
action = Database.get_action(action_id)
self.assertEqual(action.target_name, 'TEST')
group = Database.get_group(orig_group.name)
self.assertIn(target.name, group.member_names)
def test_status_pass(self):
"""
This tests to ensure the session's status is being set properly.
"""
session1 = Database.create_session('TEST1', time.time())
self.assertEqual(session1.status, SESSION_STATUSES.get('active'))
missing_timer = 2401 + SESSION_CHECK_THRESHOLD
session2 = Database.create_session('TEST2',
time.time() - missing_timer, 1800,
600)
self.assertEqual(session2.status, SESSION_STATUSES.get('missing'))
missing_timer *= SESSION_CHECK_MODIFIER
session3 = Database.create_session('TEST3',
time.time() - missing_timer, 1800,
600)
self.assertEqual(session3.status, SESSION_STATUSES.get('inactive'))
def test_create_pass(self):
"""
This test will attempt to create a session model object.
"""
timestamp = time.time()
session = Database.create_session('TEST', timestamp)
self.assertEqual(session.target_name, 'TEST')
self.assertEqual(session.timestamp, timestamp)
self.assertIsNotNone(session.history)
self.assertIsNotNone(session.servers)
self.assertIsNotNone(session.interval)
self.assertIsNotNone(session.interval_delta)
def test_migrate_target(self):
"""
Tests the MigrateTarget API function.
"""
old_target = Database.create_target()
old_sessions = [
Database.create_session(old_target.name),
Database.create_session(old_target.name),
Database.create_session(old_target.name),
Database.create_session(old_target.name),
Database.create_session(old_target.name),
]
new_target = Database.create_target(None, None, {'updated': True})
new_sessions = [
Database.create_session(new_target.name),
Database.create_session(new_target.name),
Database.create_session(new_target.name),
Database.create_session(new_target.name),
Database.create_session(new_target.name),
]
data = APIClient.migrate_target(self.client, old_target.name,
new_target.name)
self.assertEqual(data['error'], False)
# Ensure new_target has old name, and still has facts
target = Database.get_target(old_target.name)
self.assertIsNotNone(target)
self.assertEqual(target.facts['updated'], True)
# Ensure new target name is gone
with self.assertRaises(DoesNotExist):
Database.get_target(new_target.name)
# Ensure all sessions exist on new_target
self.assertListEqual(
sorted([
session.session_id for session in old_sessions + new_sessions
]), sorted([session.session_id for session in target.sessions]))
def test_find_pass(self):
"""
This test creates a session and attempts to find it,
it's target, and it's history document.
"""
session1 = Database.create_session()
session2 = Database.get_session(session1.session_id)
self.assertEqual(session1, session2)
self.assertIsNotNone(Database.get_target(session2.target_name))
self.assertIsNotNone(session1.history)
self.assertIsNotNone(session2.history)
def test_status_pass(self):
"""
This test will attempt to see if the action is assigned
the correct statuses based on it's session.
"""
action1 = Database.create_action()
self.assertIsNone(action1.session_id)
self.assertEqual(action1.status, ACTION_STATUSES.get('queued'))
action1.cancelled = True
self.assertEqual(action1.status, ACTION_STATUSES.get('cancelled'))
action1.cancelled = False
action1.queue_time = time.time() - (ACTION_STALE_THRESHOLD+1)
action1.save()
self.assertEqual(action1.status, ACTION_STATUSES.get('stale'))
session1 = Database.create_session()
action1.assign_to(session1.session_id)
self.assertEqual(action1.status, ACTION_STATUSES.get('sent'))
Database.missing_session(session1)
self.assertEqual(action1.status, ACTION_STATUSES.get('failing'))
session1.timestamp = 0
session1.save()
self.assertEqual(action1.status, ACTION_STATUSES.get('failed'))
session1.timestamp = time.time()
session1.save()
response = Database.create_response(None, None, True)
action1.submit_response(response)
self.assertEqual(action1.status, ACTION_STATUSES.get('error'))
response.error = False
action1.submit_response(response)
self.assertEqual(action1.status, ACTION_STATUSES.get('complete'))
