def test_get_by_name(self):
"""
Test the get_by_name function.
"""
Database.create_group('some group')
Database.create_group('other group')
group = Group.get_by_name('some group')
self.assertEqual(group.name, 'some group')
with self.assertRaises(DoesNotExist):
Group.get_by_name('not group')
def test_add_member(self):
"""
Test the GetGroup API function.
"""
Database.create_group('TEST GROUP')
target = Database.create_target()
data = APIClient.add_group_member(self.client, 'TEST GROUP',
target.name)
self.assertEqual(data['error'], False)
group = Database.get_group('TEST GROUP')
self.assertListEqual(group.whitelist_members, [target.name])
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_list(self):
"""
Populates the database with sample groups, and calls the list API
function to ensure that all are returned.
"""
groups = [
Database.create_group(),
Database.create_group(),
Database.create_group(),
Database.create_group(),
Database.create_group(),
]
data = APIClient.list_groups(self.client)
self.assertEqual(data['error'], False)
self.assertEqual(sorted(list(data['groups'].keys())),
sorted([group.name for group in groups]))
def test_create(self):
"""
Attempt to create a GroupAction document
"""
targets = [
Database.create_target().name,
Database.create_target().name,
Database.create_target().name,
Database.create_target().name,
Database.create_target().name,
]
Database.create_group('test_group', targets)
group_action = Database.create_group_action('test_group', 'exec echo hi')
self.assertEqual(group_action.cancelled, False)
self.assertEqual(group_action.action_string, 'exec echo hi')
for action in group_action.actions:
self.assertEqual(action.action_string, 'exec echo hi')
self.assertIn(action.target_name, targets)
def test_whitelist_member(self):
"""
Test the whitelist_member function.
"""
group = Database.create_group('SOME GROUP')
target = Database.create_target()
group.whitelist_member(target.name)
group = Database.get_group('SOME GROUP')
self.assertListEqual([target.name], group.whitelist_members)
def test_target_groups(self):
"""
Test the get_target_groups function.
"""
target = Database.create_target()
group1 = Database.create_group('group1')
group2 = Database.create_group('group2')
Database.create_group('group3')
group1.whitelist_member(target.name)
group2.whitelist_member(target.name)
group_names = [
group.name for group in Group.get_target_groups(target.name)
]
self.assertIn('group1', group_names)
self.assertIn('group2', group_names)
self.assertNotIn('group3', group_names)
def test_get(self):
"""
Test the GetGroup API function.
"""
targets = [
Database.create_target(),
Database.create_target(),
Database.create_target(),
]
Database.create_group('TEST GROUP',
[target.name for target in targets])
data = APIClient.get_group(self.client, 'TEST GROUP')
self.assertEqual(data['error'], False)
self.assertEqual(data['group']['name'], 'TEST GROUP')
self.assertListEqual(sorted(data['group']['whitelist_members']),
sorted([target.name for target in targets]))
def test_delete(self):
"""
Test the DeleteGroup function.
"""
group = Database.create_group()
data = APIClient.delete_group(self.client, group.name)
self.assertEqual(data['error'], False)
with self.assertRaises(DoesNotExist):
Database.get_group(group.name)
def test_remove_member(self):
"""
Test the RemoveGroupMember function.
"""
targets = [
Database.create_target().name,
Database.create_target().name,
Database.create_target().name,
]
Database.create_group('REMOVE GROUP', targets)
data = APIClient.remove_group_member(self.client, 'REMOVE GROUP',
targets[0])
self.assertEqual(data['error'], False)
group = Database.get_group('REMOVE GROUP')
self.assertListEqual(sorted(targets[1:]), sorted(group.member_names))
def test_blacklist_member(self):
"""
Test the BlacklistGroupMember function.
"""
targets = [
Database.create_target().name,
Database.create_target().name,
Database.create_target().name,
]
Database.create_group('BLACKLIST GROUP', targets)
data = APIClient.blacklist_group_member(self.client, 'BLACKLIST GROUP',
targets[0])
self.assertEqual(data['error'], False)
group = Database.get_group('BLACKLIST GROUP')
self.assertListEqual(sorted(targets[1:]), sorted(group.member_names))
self.assertListEqual([targets[0]], group.blacklist_members)
def test_remove_member(self):
"""
Test the remove_member function.
"""
target1 = Database.create_target()
target2 = Database.create_target()
group = Database.create_group('test_group')
group.whitelist_member(target1.name)
group.whitelist_member(target2.name)
group.remove_member(target2.name)
self.assertNotIn(target2.name, group.members)
def test_members(self):
"""
Test the members function.
"""
target1 = Database.create_target()
target2 = Database.create_target()
target3 = Database.create_target()
group = Database.create_group('test_group')
group.whitelist_member(target1.name)
group.whitelist_member(target2.name)
member_names = group.members
self.assertIn(target1.name, member_names)
self.assertIn(target2.name, member_names)
self.assertNotIn(target3.name, member_names)
def test_create(self):
"""
This test will pass if the group action is created and content matches.
"""
targets = [
Database.create_target().name,
Database.create_target().name,
Database.create_target().name,
Database.create_target().name,
]
group = Database.create_group('TEST', targets)
data = APIClient.create_group_action(self.client, group.name,
'exec echo hello | wall')
self.assertEqual(data['error'], False)
group_action = Database.get_group_action(data['group_action_id'])
self.assertIsNotNone(group_action)
self.assertEqual(group_action.action_string, 'exec echo hello | wall')
for action in group_action.actions:
self.assertEqual(action.action_string, 'exec echo hello | wall')
def test_group_rules(self):
"""
Test if group Automember rules are functioning as expected.
"""
group = Database.create_group()
targets = [
Database.create_target(None, None, {'include': 'yes'}),
Database.create_target(None, None, {'something': {
'cool': True
}}),
Database.create_target(
None, None, {
'interfaces': [{
'name': 'eth0',
'ip_addrs': ['192.168.1.1', '127.0.0.1']
}]
}),
Database.create_target(None, None, {
'include': 'sureyessure',
'something': {
'cool': False
}
}),
]
group.membership_rules = [
Database.create_group_rule(attribute='facts.include',
regex='.*yes.*'),
Database.create_group_rule(attribute='facts.something.cool',
regex='True'),
Database.create_group_rule(attribute='facts.interfaces',
regex='.*192.168.1.*'),
]
group.save()
for target in targets:
self.assertIn(target.name, group.members)
def test_create(self):
"""
Test to ensure a group can be properly created.
"""
group = Database.create_group('TEST GROUP')
self.assertEqual(group.name, 'TEST GROUP')
