def test_host_creation(self):
name = "pepito"
os = "Windows"
host_id = self.client.createHost(name, os)
host = Host(name, os)
self.assertEquals(host.getID(), host_id, "ids should be the same")
def test_host_create_and_delete(self):
host = Host(name="coquito")
self.mapper_manager.save(host)
h_id = host.getID()
self.assertNotEquals(
self.mapper_manager.find(h_id),
None,
"Host should be in the mapper")
self.assertNotEquals(
self.connector.getDocument(h_id),
None,
"Host should be in the db")
self.mapper_manager.remove(h_id)
self.assertEquals(
self.mapper_manager.find(h_id),
None,
"Host shouldn't exist anymore in the mapper")
self.assertEquals(
self.connector.getDocument(h_id),
None,
"Host shouldn't exist anymore in the db")
def test_composite_host(self):
# add host
host = Host(name="pepito", os="linux")
host.setDescription("Some description")
host.setOwned(True)
self.mapper_manager.save(host)
# add inteface
iface = Interface(name="192.168.10.168", mac="01:02:03:04:05:06")
iface.setDescription("Some description")
iface.setOwned(True)
iface.addHostname("www.test.com")
iface.setIPv4({
"address": "192.168.10.168",
"mask": "255.255.255.0",
"gateway": "192.168.10.1",
"DNS": "192.168.10.1"
})
iface.setPortsOpened(2)
iface.setPortsClosed(3)
iface.setPortsFiltered(4)
host.addChild(iface)
self.mapper_manager.save(iface)
h = self.mapper_manager.find(host.getID())
self.assertEquals(
len(h.getAllInterfaces()), len(host.getAllInterfaces()),
"Interfaces from original host should be equals to retrieved host's interfaces"
)
i = self.mapper_manager.find(h.getAllInterfaces()[0].getID())
self.assertEquals(
i.getID(), iface.getID(),
"Interface's id' from original host should be equals to retrieved host's interface's id"
)
def testAddInterfaceToHost(self):
host = Host('coco')
inter = Interface('cuca')
host.addChild(inter)
self.assertIn(inter, host.childs.values(), 'Interface not in childs')
self.assertIn(inter, host.getAllInterfaces(), 'Interface not accessible')
def test_host_serialization(self):
host = Host(name="pepito", os="linux")
host.setDescription("Some description")
host.setOwned(True)
hserialized = self.hmapper.serialize(host)
# if serialization fails, returns None
self.assertNotEqual(
hserialized,
None,
"Serialized host shouldn't be None")
# we check the host attributes
self.assertEquals(
hserialized.get("_id"),
host.getID(),
"Serialized ID is not the same as Host ID")
self.assertEquals(
hserialized.get("name"),
host.getName(),
"Serialized name is not the same as Host name")
self.assertEquals(
hserialized.get("os"),
host.getOS(),
"Serialized OS is not the same as Host OS")
self.assertEquals(
hserialized.get("description"),
host.getDescription(),
"Serialized description is not the same as Host description")
self.assertEquals(
hserialized.get("owned"),
host.isOwned(),
"Serialized owned flag is not the same as Host owned flag")
def test_host_creation(self):
name = "pepito"
os = "Windows"
host_id = self.client.createHost(name, os)
host = Host(name, os)
self.assertEquals(host.getID(), host_id, "ids should be the same")
def test_interface_creation(self):
name = "pepito"
os = "Windows"
host = Host(name, os)
when(self._model_controller).find(host.getID()).thenReturn(host)
name = ""
mac = "00:00:00:00:00:00"
ipv4_address = "0.0.0.0"
ipv4_mask = "0.0.0.0"
ipv4_gateway = "0.0.0.0"
ipv4_dns = []
ipv6_address = "0000:0000:0000:0000:0000:0000:0000:0000"
ipv6_prefix = "00"
ipv6_gateway = "0000:0000:0000:0000:0000:0000:0000:0000"
ipv6_dns = []
network_segment = ""
hostname_resolution = []
interface_id = self.client.createInterface(
name, mac, ipv4_address, ipv4_mask, ipv4_gateway, ipv4_dns,
ipv6_address, ipv6_prefix, ipv6_gateway, ipv6_dns, network_segment,
hostname_resolution, host.getID())
interface = Interface(
name, mac, ipv4_address, ipv4_mask, ipv4_gateway, ipv4_dns,
ipv6_address, ipv6_prefix, ipv6_gateway, ipv6_dns, network_segment,
hostname_resolution, parent_id=host.getID())
self.assertNotEquals(
interface_id, None, "interface created shouldn't be None")
self.assertEquals(
interface.getID(), interface_id, "ids should be the same")
def test_service_creation(self):
name = "pepito"
os = "Windows"
host = Host(name, os)
name = ""
mac = "00:00:00:00:00:00"
ipv4_address = "0.0.0.0"
ipv4_mask = "0.0.0.0"
ipv4_gateway = "0.0.0.0"
ipv4_dns = []
ipv6_address = "0000:0000:0000:0000:0000:0000:0000:0000"
ipv6_prefix = "00"
ipv6_gateway = "0000:0000:0000:0000:0000:0000:0000:0000"
ipv6_dns = []
network_segment = ""
hostname_resolution = []
interface = Interface(name,
mac,
ipv4_address,
ipv4_mask,
ipv4_gateway,
ipv4_dns,
ipv6_address,
ipv6_prefix,
ipv6_gateway,
ipv6_dns,
network_segment,
hostname_resolution,
parent_id=host.getID())
when(self._model_controller).find(
interface.getID()).thenReturn(interface)
name = "srv"
protocol = "tcp"
ports = []
status = "running"
version = "unknown"
description = ""
service_id = self.client.createService(name, protocol, ports, status,
version, description,
interface.getID())
service = Service(name,
protocol,
ports,
status,
version,
description,
parent_id=interface.getID())
self.assertNotEquals(service_id, None,
"service created shouldn't be None")
self.assertEquals(service.getID(), service_id,
"ids should be the same")
def testDelVulnFromHostASYNC(self):
host = Host('coco')
vuln = ModelObjectVuln("int_mock0")
host.addChild(vuln)
self.genericDelTest(host,
vuln,
controller.ModelController.delVulnFromHostASYNC,
process_pending=True)
def testDelNoteFromHostSYNC(self):
host = Host('coco')
note = ModelObjectNote("int_mock0")
host.addChild(note)
self.genericDelTest(host,
note,
controller.ModelController.delNoteFromHostASYNC,
process_pending=True)
def testAddInterfaceToHost(self):
host = Host('coco')
inter = Interface('cuca')
host.addChild(inter)
self.assertIn(inter, host.childs.values(), 'Interface not in childs')
self.assertIn(inter, host.getAllInterfaces(),
'Interface not accessible')
def test_host_creation(self):
host = Host(name="pepito", os="linux")
self.hmapper.save(host)
h = self.hmapper.find(host.getID())
self.assertEquals(h, host,
"Host retrieved should be the same as persisted")
self.assertEquals(
h.getID(), host.getID(),
"Host retrieved's Id should be the same as persisted's Id")
def test_composite_host(self):
# add host
host = Host(name="pepito", os="linux")
host.setDescription("Some description")
host.setOwned(True)
self.mapper_manager.save(host)
# add inteface
iface = Interface(name="192.168.10.168", mac="01:02:03:04:05:06")
iface.setDescription("Some description")
iface.setOwned(True)
iface.addHostname("www.test.com")
iface.setIPv4({
"address": "192.168.10.168",
"mask": "255.255.255.0",
"gateway": "192.168.10.1",
"DNS": "192.168.10.1"
})
iface.setPortsOpened(2)
iface.setPortsClosed(3)
iface.setPortsFiltered(4)
host.addChild(iface)
self.mapper_manager.save(iface)
h = self.mapper_manager.find(host.getID())
self.assertEquals(
len(h.getAllInterfaces()),
len(host.getAllInterfaces()),
"Interfaces from original host should be equals to retrieved host's interfaces")
i = self.mapper_manager.find(h.getAllInterfaces()[0].getID())
self.assertEquals(
i.getID(),
iface.getID(),
"Interface's id' from original host should be equals to retrieved host's interface's id")
def test_diff_between_different_hosts(self):
"""
This test case creates a host and the compares it
with another different host using the ModelObjectDiff class
"""
h1 = Host(name='host1', os='Windows')
h2 = Host(name='host1', os='Linux')
diff = ModelObjectDiff(h1, h2)
self.assertTrue(diff.existDiff())
def testHostSetInterfaces(self):
host = Host('coco')
interfaces = {}
for i in range(50, 60):
inter = Interface('cuca%s' % i, ipv4_address="192.168.0.%d" % i)
interfaces[inter.getID()] = inter
host.setInterfaces(interfaces)
self.assertEquals(len(host.getChildsByType(Interface.__name__)), 10, "not all interfaces added")
for s in interfaces.values():
self.assertIn(s, host.getChildsByType(Interface.__name__), "what happened with interfaces?")
def test_host_creation(self):
host = Host(name="pepito", os="linux")
self.hmapper.save(host)
h = self.hmapper.find(host.getID())
self.assertEquals(
h,
host,
"Host retrieved should be the same as persisted")
self.assertEquals(
h.getID(),
host.getID(),
"Host retrieved's Id should be the same as persisted's Id")
def testDeleteHostObjectDispatchRemoveSYNC(self):
host = Host("coquito")
mappersManager = self.createMapperMock()
objectMapper = mock()
when(mappersManager).getMapper(host.getID()).thenReturn(objectMapper)
when(objectMapper).delObject(host.getID()).thenReturn(True)
model_controller = controller.ModelController(mock(), mappersManager)
model_controller.delHostSYNC(host)
verify(mappersManager).getMapper(host.getID())
verify(objectMapper).delObject(host.getID())
def test_host_create_and_delete(self):
host = Host(name="pepito", os="linux")
self.hmapper.save(host)
h_id = host.getID()
self.assertNotEquals(self.hmapper.load(h_id), None,
"Host should be saved")
self.hmapper.delete(h_id)
self.assertEquals(self.hmapper.find(h_id), None,
"Host shouldn't exist anymore")
def testDeleteHostObjectDispatchRemoveASYNC(self):
host = Host("coquito")
mappersManager = self.createMapperMock()
objectMapper = mock()
when(mappersManager).find(host.getID()).thenReturn(host)
when(mappersManager).remove(host.getID()).thenReturn(True)
model_controller = controller.ModelController(mock(), mappersManager)
model_controller.delHostASYNC(host.getID())
model_controller.processAllPendingActions()
verify(mappersManager).remove(host.getID())
def testAddInterfaceGetsMapperDispatchSaveSYNC(self):
host = Host('coco')
interface = Interface("int_mock0")
mappersManager = self.createMapperMock()
objectMapper = mock()
when(mappersManager).getMapper(interface).thenReturn(objectMapper)
when(objectMapper).saveObject(interface).thenReturn(True)
model_controller = controller.ModelController(mock(), mappersManager)
model_controller.addInterfaceSYNC(host.getID(), interface)
verify(mappersManager).getMapper(interface)
verify(objectMapper).saveObject(interface)
def testHostWithMultipleChildTypes(self):
host = Host('coco')
inter = Interface('cuca')
vuln = ModelObjectVuln('vuln')
host.addChild(inter)
host.addChild(vuln)
self.assertEquals(len(host.getVulns()), 1, "Vulns added is not 1")
self.assertIn(vuln, host.getVulns(), "Vuln not accessible")
self.assertEquals(len(host.getAllInterfaces()), 1,
"Interfaces added is not 1")
def testAddInterfaceGetsMapperDispatchSaveSYNC(self):
host = Host('coco')
interface = Interface("int_mock0")
mappersManager = self.createMapperMock()
objectMapper = mock()
when(mappersManager).getMapper(
interface.class_signature).thenReturn(objectMapper)
when(objectMapper).save(interface).thenReturn(True)
model_controller = controller.ModelController(mock(), mappersManager)
model_controller.addInterfaceSYNC(host.getID(), interface)
verify(mappersManager).getMapper(interface.class_signature)
verify(objectMapper).save(interface)
def testAddVulnToHostGetsMapperDispatchSaveSYNC(self):
host = Host("pepito")
vuln = ModelObjectVuln("a_vuln")
mappersManager = self.createMapperMock()
objectMapper = mock()
when(mappersManager).getMapper(vuln).thenReturn(objectMapper)
when(objectMapper).saveObject(vuln).thenReturn(True)
model_controller = controller.ModelController(mock(), mappersManager)
model_controller.addVulnToHostSYNC(host.getID(), vuln)
verify(mappersManager).getMapper(vuln)
verify(objectMapper).saveObject(vuln)
def testAddNoteToModelObjectSYNC(self):
host = Host("pepito")
note = ModelObjectNote("a_note")
mappersManager = self.createMapperMock()
objectMapper = mock()
when(mappersManager).getMapper(note).thenReturn(objectMapper)
when(objectMapper).saveObject(note).thenReturn(True)
model_controller = controller.ModelController(mock(), mappersManager)
model_controller.addNoteSYNC(host.getID(), note)
verify(mappersManager).getMapper(note)
verify(objectMapper).saveObject(note)
def test_host_saving(self):
host = Host(name="pepito", os="linux")
host.setDescription("Some description")
host.setOwned(True)
self.mapper_manager.save(host)
self.assertNotEquals(self.connector.getDocument(host.getID()), None,
"Document shouldn't be None")
self.assertEquals(
self.connector.getDocument(host.getID()).get("name"),
host.getName(), "Document should have the same host name")
def testAddVulnToHostGetsMapperDispatchSaveSYNC(self):
host = Host("pepito")
vuln = ModelObjectVuln("a_vuln")
mappersManager = self.createMapperMock()
objectMapper = mock()
when(mappersManager).getMapper(
vuln.class_signature).thenReturn(objectMapper)
when(objectMapper).save(vuln).thenReturn(True)
model_controller = controller.ModelController(mock(), mappersManager)
model_controller.addVulnToHostSYNC(host.getID(), vuln)
verify(mappersManager).getMapper(vuln.class_signature)
verify(objectMapper).save(vuln)
def testAddInterfaceGetsMapperDispatchSaveASYNC(self):
host = Host('coco')
interface = Interface("int_mock0")
mappersManager = self.createMapperMock()
objectMapper = mock()
when(mappersManager).getMapper(interface.class_signature).thenReturn(objectMapper)
when(objectMapper).save(interface).thenReturn(True)
model_controller = controller.ModelController(mock(), mappersManager)
model_controller.addInterfaceASYNC(host.getID(), interface)
model_controller.processAllPendingActions()
verify(mappersManager).getMapper(interface.class_signature)
verify(objectMapper).save(interface)
def testDeleteModelObjectRemovesChildFromParentASYNC(self):
host = Host('coco')
interface = Interface("int_mock0")
self.genericDelTest(host,
interface,
controller.ModelController.delInterfaceASYNC,
process_pending=True)
def testAddVulnToHostGetsMapperDispatchSaveASYNC(self):
host = Host("pepito")
vuln = ModelObjectVuln("a_vuln")
mappersManager = self.createMapperMock()
objectMapper = mock()
when(mappersManager).getMapper(vuln.class_signature).thenReturn(objectMapper)
when(objectMapper).save(vuln).thenReturn(True)
model_controller = controller.ModelController(mock(), mappersManager)
model_controller.addVulnToHostASYNC(host.getID(), vuln)
model_controller.processAllPendingActions()
verify(mappersManager).getMapper(vuln.class_signature)
verify(objectMapper).save(vuln)
def testAddNoteToModelObjectSYNC(self):
host = Host("pepito")
note = ModelObjectNote("a_note")
mappersManager = self.createMapperMock()
objectMapper = mock()
when(mappersManager).getMapper(
note.class_signature).thenReturn(objectMapper)
when(objectMapper).save(note).thenReturn(True)
model_controller = controller.ModelController(mock(), mappersManager)
model_controller.addNoteSYNC(host.getID(), note)
verify(mappersManager).getMapper(note.class_signature)
verify(objectMapper).save(note)
def test_host_create_and_delete(self):
host = Host(name="pepito", os="linux")
self.hmapper.save(host)
h_id = host.getID()
self.assertNotEquals(
self.hmapper.load(h_id),
None,
"Host should be saved")
self.hmapper.delete(h_id)
self.assertEquals(
self.hmapper.find(h_id),
None,
"Host shouldn't exist anymore")
def testAddNoteToHostGetsMapperDispatchSaveASYNC(self):
host = Host("pepito")
note = ModelObjectNote("a_note")
mappersManager = self.createMapperMock()
objectMapper = mock()
when(mappersManager).getMapper(note).thenReturn(objectMapper)
when(objectMapper).saveObject(note).thenReturn(True)
model_controller = controller.ModelController(mock(), mappersManager)
model_controller.addNoteToHostASYNC(host.getID(), note)
model_controller.processAllPendingActions()
verify(mappersManager).getMapper(note)
verify(objectMapper).saveObject(note)
def testGetHost(self):
host = Host("coquito")
mappersManager = self.createMapperMock()
objectMapper = mock()
when(mappersManager).getMapper(host.__class__.__name__).thenReturn(objectMapper)
when(objectMapper).find(host.getName()).thenReturn(host)
model_controller = controller.ModelController(mock(), mappersManager)
host_obt = model_controller.getHost('coquito')
verify(objectMapper).find(host.getName())
verify(mappersManager).getMapper(host.__class__.__name__)
self.assertEqual(host, host_obt)
def test_interface_creation(self):
name = "pepito"
os = "Windows"
host = Host(name, os)
when(self._model_controller).find(host.getID()).thenReturn(host)
name = ""
mac = "00:00:00:00:00:00"
ipv4_address = "0.0.0.0"
ipv4_mask = "0.0.0.0"
ipv4_gateway = "0.0.0.0"
ipv4_dns = []
ipv6_address = "0000:0000:0000:0000:0000:0000:0000:0000"
ipv6_prefix = "00"
ipv6_gateway = "0000:0000:0000:0000:0000:0000:0000:0000"
ipv6_dns = []
network_segment = ""
hostname_resolution = []
interface_id = self.client.createInterface(name, mac, ipv4_address,
ipv4_mask, ipv4_gateway,
ipv4_dns, ipv6_address,
ipv6_prefix, ipv6_gateway,
ipv6_dns, network_segment,
hostname_resolution,
host.getID())
interface = Interface(name,
mac,
ipv4_address,
ipv4_mask,
ipv4_gateway,
ipv4_dns,
ipv6_address,
ipv6_prefix,
ipv6_gateway,
ipv6_dns,
network_segment,
hostname_resolution,
parent_id=host.getID())
self.assertNotEquals(interface_id, None,
"interface created shouldn't be None")
self.assertEquals(interface.getID(), interface_id,
"ids should be the same")
def load(self):
self._model_controller.setSavingModel(True)
hosts = {}
def find_leaf(path, sub_graph=hosts):
for i in path:
if len(path) > 1:
return find_leaf(path[1:], sub_graph['subs'][i])
else:
return sub_graph
try:
t = time.time()
model.api.devlog("load start: %s" % str(t))
docs = [
i["doc"]
for i in self.cdm.workspaceDocumentsIterator(self.name)
]
model.api.devlog("time to get docs: %s" % str(time.time() - t))
t = time.time()
for d in docs:
id_path = d['_id'].split('.')
if d['type'] == "Host":
hosts[d['_id']] = d
subs = hosts.get('subs', {})
subs[d['_id']] = d
hosts['subs'] = subs
continue
leaf = {}
try:
leaf = find_leaf(id_path)
except Exception as e:
model.api.devlog('Object parent not found, skipping: %s' %
'.'.join(id_path))
continue
subs = leaf.get('subs', {})
subs[d['obj_id']] = d
leaf['subs'] = subs
key = "%s" % d['type']
key = key.lower()
sub = leaf.get(key, {})
sub[d['obj_id']] = d
leaf[key] = sub
model.api.devlog("time to reconstruct: %s" % str(time.time() - t))
t = time.time()
self.container.clear()
for k, v in hosts.items():
if k is not "subs":
h = Host(name=None, dic=v)
self.container[k] = h
model.api.devlog("time to fill container: %s" %
str(time.time() - t))
t = time.time()
except Exception, e:
model.api.devlog("Exception during load: %s" % e)
def testAddNoteToHostGetsMapperDispatchSaveASYNC(self):
host = Host("pepito")
note = ModelObjectNote("a_note")
mappersManager = self.createMapperMock()
objectMapper = mock()
when(mappersManager).getMapper(
note.class_signature).thenReturn(objectMapper)
when(objectMapper).save(note).thenReturn(True)
model_controller = controller.ModelController(mock(), mappersManager)
model_controller.addNoteToHostASYNC(host.getID(), note)
model_controller.processAllPendingActions()
verify(mappersManager).getMapper(note.class_signature)
verify(objectMapper).save(note)
def testGetHost(self):
host = Host("coquito")
mappersManager = self.createMapperMock()
objectMapper = mock()
when(mappersManager).getMapper(
host.__class__.__name__).thenReturn(objectMapper)
when(objectMapper).find(host.getName()).thenReturn(host)
model_controller = controller.ModelController(mock(), mappersManager)
host_obt = model_controller.getHost('coquito')
verify(objectMapper).find(host.getName())
verify(mappersManager).getMapper(host.__class__.__name__)
self.assertEqual(host, host_obt)
def testHostWithMultipleChildTypes(self):
host = Host('coco')
inter = Interface('cuca')
vuln = ModelObjectVuln('vuln')
host.addChild(inter)
host.addChild(vuln)
self.assertEquals(len(host.getVulns()), 1, "Vulns added is not 1")
self.assertIn(vuln, host.getVulns(), "Vuln not accessible")
self.assertEquals(len(host.getAllInterfaces()), 1, "Interfaces added is not 1")
def test_service_creation(self):
name = "pepito"
os = "Windows"
host = Host(name, os)
name = ""
mac = "00:00:00:00:00:00"
ipv4_address = "0.0.0.0"
ipv4_mask = "0.0.0.0"
ipv4_gateway = "0.0.0.0"
ipv4_dns = []
ipv6_address = "0000:0000:0000:0000:0000:0000:0000:0000"
ipv6_prefix = "00"
ipv6_gateway = "0000:0000:0000:0000:0000:0000:0000:0000"
ipv6_dns = []
network_segment = ""
hostname_resolution = []
interface = Interface(
name, mac, ipv4_address, ipv4_mask, ipv4_gateway, ipv4_dns,
ipv6_address, ipv6_prefix, ipv6_gateway, ipv6_dns, network_segment,
hostname_resolution, parent_id=host.getID())
when(self._model_controller).find(
interface.getID()).thenReturn(interface)
name = "srv"
protocol = "tcp"
ports = []
status = "running"
version = "unknown"
description = ""
service_id = self.client.createService(
name, protocol, ports, status, version, description,
interface.getID())
service = Service(name, protocol, ports, status, version, description,
parent_id=interface.getID())
self.assertNotEquals(
service_id, None, "service created shouldn't be None")
self.assertEquals(
service.getID(), service_id, "ids should be the same")
def test_host_create_and_delete(self):
host = Host(name="coquito")
self.mapper_manager.save(host)
h_id = host.getID()
self.assertNotEquals(self.mapper_manager.find(h_id), None,
"Host should be in the mapper")
self.assertNotEquals(self.connector.getDocument(h_id), None,
"Host should be in the db")
self.mapper_manager.remove(h_id)
self.assertEquals(self.mapper_manager.find(h_id), None,
"Host shouldn't exist anymore in the mapper")
self.assertEquals(self.connector.getDocument(h_id), None,
"Host shouldn't exist anymore in the db")
def testAddObjectSavesChildInParent(self):
host = Host('coco')
interface = Interface("int_mock0")
mappersManager = self.createMapperMock()
objectMapper = mock()
when(mappersManager).getMapper(interface).thenReturn(objectMapper)
when(objectMapper).saveObject(interface).thenReturn(True)
when(mappersManager).find(host.getID()).thenReturn(host)
model_controller = controller.ModelController(mock(), mappersManager)
model_controller.addInterfaceSYNC(host.getID(), interface)
verify(mappersManager).getMapper(interface)
verify(objectMapper).saveObject(interface)
self.assertEquals(interface, host.findChild(interface.getID()),
"Orphan child, what happen papi?")
def testAddSavesObjectNameInTrie(self):
host = Host('coco')
mappersManager = self.createMapperMock()
objectMapper = mock()
triemock = mock()
when(mappersManager).getMapper(host).thenReturn(objectMapper)
when(objectMapper).saveObject(host).thenReturn(True)
when(triemock).addWord(host.getName()).thenReturn(True)
model_controller = controller.ModelController(mock(), mappersManager)
model_controller.treeWordsTries = triemock
model_controller.addHostSYNC(host)
verify(mappersManager).getMapper(host)
verify(objectMapper).saveObject(host)
verify(triemock).addWord(host.getName())
def testEditHostSyncGetsMapperDispatchedSYNC(self):
host = Host("coquito")
mappersManager = self.createMapperMock()
dataMapper = mock()
objectMapper = mock()
triemock = mock()
when(mappersManager).getMapper(host.class_signature).thenReturn(dataMapper)
when(dataMapper).save(host).thenReturn(True)
model_controller = controller.ModelController(mock(), mappersManager)
model_controller.editHostSYNC(host, 'new_name', 'new_desc', 'new_os', True)
verify(dataMapper).save(host)
self.assertEquals(host.getName(), 'new_name', "Name not updated")
self.assertEquals(host.getDescription(), 'new_desc', "Description not updated")
self.assertEquals(host.getOS(), 'new_os', "OS not updated")
self.assertEquals(host.isOwned(), True, "Owned status not updated")
def testAddObjectSavesChildInParent(self):
host = Host('coco')
interface = Interface("int_mock0")
mappersManager = self.createMapperMock()
objectMapper = mock()
when(mappersManager).getMapper(
interface.class_signature).thenReturn(objectMapper)
when(objectMapper).save(interface).thenReturn(True)
when(mappersManager).find(host.getID()).thenReturn(host)
model_controller = controller.ModelController(mock(), mappersManager)
model_controller.addInterfaceSYNC(host.getID(), interface)
verify(mappersManager).getMapper(interface.class_signature)
verify(objectMapper).save(interface)
self.assertEquals(interface, host.findChild(interface.getID()),
"Orphan child, what happen papi?")
def testAddSavesObjectNameInTrie(self):
host = Host('coco')
mappersManager = self.createMapperMock()
objectMapper = mock()
triemock = mock()
when(mappersManager).getMapper(
host.class_signature).thenReturn(objectMapper)
when(objectMapper).save(host).thenReturn(True)
when(triemock).addWord(host.getName()).thenReturn(True)
model_controller = controller.ModelController(mock(), mappersManager)
model_controller.treeWordsTries = triemock
model_controller.addHostSYNC(host)
verify(mappersManager).getMapper(host.class_signature)
verify(objectMapper).save(host)
verify(triemock).addWord(host.getName())
def test_find_not_loaded_host(self):
host = Host(name="pepito", os="linux")
host.setDescription("Some description")
host.setOwned(True)
self.mapper_manager.save(host)
#create a set of mappers, so we have a clean map
self.mapper_manager = MapperManager()
self.mapper_manager.createMappers(self.connector)
h = self.mapper_manager.find(host.getID())
self.assertNotEquals(
h,
None,
"Existent host shouldn't return None")
self.assertEquals(
h.getName(),
"pepito",
"Host name should be pepito")
self.assertEquals(
h.getOS(),
"linux",
"Host os should be linux")
def test_host_saving(self):
host = Host(name="pepito", os="linux")
host.setDescription("Some description")
host.setOwned(True)
self.mapper_manager.save(host)
self.assertNotEquals(
self.connector.getDocument(host.getID()),
None,
"Document shouldn't be None")
self.assertEquals(
self.connector.getDocument(host.getID()).get("name"),
host.getName(),
"Document should have the same host name")
def testDeleteHostObjectDispatchRemoveSYNC(self):
host = Host("coquito")
mappersManager = self.createMapperMock()
objectMapper = mock()
when(mappersManager).find(host.getID()).thenReturn(host)
when(mappersManager).remove(host.getID()).thenReturn(True)
model_controller = controller.ModelController(mock(), mappersManager)
model_controller.delHostSYNC(host.getID())
verify(mappersManager).remove(host.getID())
verify(mappersManager).find(host.getID())
def testGetAllHosts(self):
hosts = [Host("coquito%i" % i) for i in range(10)]
mappersManager = self.createMapperMock()
objectMapper = mock()
when(mappersManager).getMapper(Host.__name__).thenReturn(objectMapper)
when(objectMapper).getAll().thenReturn(hosts)
model_controller = controller.ModelController(mock(), mappersManager)
hosts_obt = model_controller.getAllHosts()
verify(objectMapper).getAll()
verify(mappersManager).getMapper(Host.__name__)
self.assertListEqual(hosts, hosts_obt)
def testAddHostGetsMapperDispatchSaveSYNC(self):
host = Host('coco')
mappersManager = self.createMapperMock()
objectMapper = mock()
when(mappersManager).getMapper(
host.class_signature).thenReturn(objectMapper)
when(objectMapper).save(host).thenReturn(True)
model_controller = controller.ModelController(mock(), mappersManager)
model_controller.addHostSYNC(host)
verify(mappersManager).getMapper(host.class_signature)
verify(objectMapper).save(host)
def test_create_and_retrieve_host(self):
self.mapper_manager.createMappers(NullPersistenceManager())
host = Host(name="pepito", os="linux")
host.setDescription("Some description")
host.setOwned(True)
self.mapper_manager.save(host)
h = self.mapper_manager.find(host.getID())
self.assertNotEquals(h, None, "Host retrieved shouldn't be None")
self.assertEquals(host, h,
"Host created should be the same as host retrieved")
def testAddCredGetsMapperDispatchSaveSYNC(self):
host = Host("pepito")
cred = ModelObjectCred("usr", "pass")
mappersManager = self.createMapperMock()
objectMapper = mock()
when(mappersManager).getMapper(
cred.class_signature).thenReturn(objectMapper)
when(objectMapper).save(cred).thenReturn(True)
model_controller = controller.ModelController(mock(), mappersManager)
model_controller.addCredSYNC(cred.getID(), cred)
verify(mappersManager).getMapper(cred.class_signature)
verify(objectMapper).save(cred)
def testDelRemovesObjectFromTrie(self):
host = Host("coquito")
mappersManager = self.createMapperMock()
objectMapper = mock()
triemock = mock()
when(mappersManager).getMapper(host.getID()).thenReturn(objectMapper)
when(objectMapper).delObject(host.getID()).thenReturn(True)
when(mappersManager).find(host.getID()).thenReturn(host)
when(triemock).addWord(host.getName()).thenReturn(True)
model_controller = controller.ModelController(mock(), mappersManager)
model_controller.treeWordsTries = triemock
model_controller.delHostSYNC(host)
verify(mappersManager).getMapper(host.getID())
verify(objectMapper).delObject(host.getID())
verify(triemock).removeWord(host.getName())
def test(self):
"""
DELETE THIS BEFORE RELEASE
used for internal testing (not correct way but we need to use it like
this for now)
"""
global test_count
test_count += 1
model.api.showPopup("Creating test host %d" % test_count)
from utils.error_report import exception_handler
def raiser():
sys.excepthook = exception_handler
time.sleep(3)
raise Exception("Exception from a secondary thread...")
from model.hosts import Host
from model.hosts import Interface
from model.hosts import Service
from model.hosts import HostApplication
self._main_app.getLogger().log("testing..")
self._main_app.getLogger().log("creating test host %d" % test_count)
host = Host("TestHost-%d" % test_count, "Windows 2003")
service = Service("TestService-%d" % test_count, "TCP", [80, 8080],
"running")
interface = Interface("eth%d" % test_count,
mac="00:00:00:00:00:00",
ipv4_address="10.1.1.%d" % test_count,
ipv4_mask="255.255.0.0",
ipv4_gateway="10.1.1.%d" % (test_count + 1),
hostname_resolution="TestHost-%d" % test_count)
app = HostApplication("AppTest-%d" % test_count, "running", "1.0 beta")
host.addInterface(interface)
host.addService(service)
host.addApplication(app)
interface.addService(service)
app.addService(service)
service.addInterface(interface)
self._model_controller.addHostASYNC(host)
def test(self):
"""
DELETE THIS BEFORE RELEASE
used for internal testing (not correct way but we need to use it like
this for now)
"""
global test_count
test_count += 1
model.api.showPopup("Creating test host %d" % test_count)
from utils.error_report import exception_handler
def raiser():
sys.excepthook = exception_handler
time.sleep(3)
raise Exception("Exception from a secondary thread...")
from model.hosts import Host
from model.hosts import Interface
from model.hosts import Service
from model.hosts import HostApplication
self._main_app.getLogger().log("testing..")
self._main_app.getLogger().log("creating test host %d" % test_count)
host = Host("TestHost-%d" % test_count, "Windows 2003")
service = Service( "TestService-%d" % test_count, "TCP", [80,8080], "running")
interface = Interface("eth%d" % test_count, mac = "00:00:00:00:00:00",
ipv4_address = "10.1.1.%d" % test_count, ipv4_mask = "255.255.0.0",
ipv4_gateway = "10.1.1.%d" % (test_count+1),
hostname_resolution = "TestHost-%d" % test_count)
app = HostApplication( "AppTest-%d" % test_count, "running", "1.0 beta")
host.addInterface(interface)
host.addService(service)
host.addApplication(app)
interface.addService(service)
app.addService(service)
service.addInterface(interface)
self._model_controller.addHostASYNC(host)
def test_find_not_loaded_host(self):
host = Host(name="pepito", os="linux")
host.setDescription("Some description")
host.setOwned(True)
self.mapper_manager.save(host)
#create a set of mappers, so we have a clean map
self.mapper_manager = MapperManager()
self.mapper_manager.createMappers(self.connector)
h = self.mapper_manager.find(host.getID())
self.assertNotEquals(h, None, "Existent host shouldn't return None")
self.assertEquals(h.getName(), "pepito", "Host name should be pepito")
self.assertEquals(h.getOS(), "linux", "Host os should be linux")
def testHostSetInterfaces(self):
host = Host('coco')
interfaces = {}
for i in range(50, 60):
inter = Interface('cuca%s' % i, ipv4_address="192.168.0.%d" % i)
interfaces[inter.getID()] = inter
host.setInterfaces(interfaces)
self.assertEquals(len(host.getChildsByType(Interface.__name__)), 10,
"not all interfaces added")
for s in interfaces.values():
self.assertIn(s, host.getChildsByType(Interface.__name__),
"what happened with interfaces?")
def test_create_and_retrieve_host(self):
self.mapper_manager.createMappers(NullPersistenceManager())
host = Host(name="pepito", os="linux")
host.setDescription("Some description")
host.setOwned(True)
self.mapper_manager.save(host)
h = self.mapper_manager.find(host.getID())
self.assertNotEquals(
h,
None,
"Host retrieved shouldn't be None")
self.assertEquals(
host,
h,
"Host created should be the same as host retrieved")
def testDelNoteFromHostSYNC(self):
host = Host('coco')
note = ModelObjectNote("int_mock0")
host.addChild(note.getID(), note)
self.genericDelTest(host, note,
controller.ModelController.delNoteFromHostASYNC, process_pending=True)
def testDelNoteFromModelObjectSYNC(self):
host = Host('coco')
note = ModelObjectNote("int_mock0")
host.addChild(note.getID(), note)
self.genericDelTest(host, note,
controller.ModelController.delNoteSYNC)
