class MapperManagerTestSuite(unittest.TestCase):
def setUp(self):
self.mapper_manager = MapperManager()
def tearDown(self):
pass
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 test_find_obj_by_id(self, many_test_data, session, monkeypatch):
obj_class = many_test_data['class']
test_data = many_test_data
persisted_obj = test_data['factory'].create()
session.add(persisted_obj)
session.commit()
mapper_manager = MapperManager()
mapper_manager.createMappers(persisted_obj.workspace.name)
def mock_unsafe_io_with_server(host, test_data, server_io_function,
server_expected_response, server_url,
**payload):
mocked_response = test_data['mocked_response']
assert '{0}/ws/{1}/{2}/{3}/'.format(_create_server_api_url(),
persisted_obj.workspace.name,
test_data['api_end_point'],
persisted_obj.id) == server_url
return MockResponse(mocked_response, 200)
monkeypatch.setattr(
persistence.server.server, '_unsafe_io_with_server',
partial(mock_unsafe_io_with_server, persisted_obj, test_data))
found_obj = mapper_manager.find(obj_class.class_signature,
persisted_obj.id)
serialized_obj = test_data['get_properties_function'](found_obj)
if obj_class not in [Command]:
metadata = serialized_obj.pop('metadata')
assert serialized_obj == test_data['serialized_expected_results']
def setUp(self):
self.db_name = self.new_random_workspace_name()
self.fsmanager = FileSystemManager()
self.connector = self.fsmanager.createDb(self.db_name)
self.mapper_manager = MapperManager()
self.mapper_manager.createMappers(self.connector)
def setUp(self):
self.db_name = self.new_random_workspace_name()
self.couchdbmanager = CouchDbManager(CONF.getCouchURI())
self.connector = self.couchdbmanager.createDb(self.db_name)
self.mapper_manager = MapperManager()
self.mapper_manager.createMappers(self.connector)
def test_find(get, url_endpoint, test_data, session):
if 'api_result' in test_data:
get.return_value = test_data['api_result']
mappers_manager = MapperManager()
pending_actions = Queue()
controller = ModelController(mappers_manager, pending_actions)
workspace = WorkspaceFactory.create()
mappers_manager.createMappers(workspace.name)
obj = test_data['factory'].create(workspace=workspace)
session.add(obj)
session.commit()
result = controller.find(test_data['class_signature'], obj.id)
assert get.called
print(get.mock_calls[0][1][0])
assert get.mock_calls[0][1][0].endswith(
'/_api/v2/ws/{0}/{1}/{2}/'.format(workspace.name, url_endpoint, obj.id))
def test_find(get, url_endpoint, test_data, session):
if 'api_result' in test_data:
get.return_value = test_data['api_result']
mappers_manager = MapperManager()
pending_actions = Queue()
controller = ModelController(mappers_manager, pending_actions)
workspace = WorkspaceFactory.create()
mappers_manager.createMappers(workspace.name)
obj = test_data['factory'].create(workspace=workspace)
session.add(obj)
session.commit()
result = controller.find(test_data['class_signature'], obj.id)
assert get.called
print(get.mock_calls[0][1][0])
assert get.mock_calls[0][1][0].endswith('/_api/v2/ws/{0}/{1}/{2}/'.format(
workspace.name, url_endpoint, obj.id))
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 __init__(self):
super(RawReportProcessor, self).__init__()
from faraday import setupPlugins
setupPlugins()
self.pending_actions = Queue()
try:
plugin_manager = PluginManager(
os.path.join(CONF.getConfigPath(), "plugins"))
except AttributeError:
get_logger().warning(
"Upload reports in WEB-UI not configurated, run Faraday client and try again..."
)
self._stop = True
return
mappers_manager = MapperManager()
self.model_controller = ModelController(mappers_manager,
self.pending_actions)
self.model_controller.start()
self.end_event = Event()
plugin_controller = PluginController('PluginController',
plugin_manager, mappers_manager,
self.pending_actions,
self.end_event)
self.processor = ReportProcessor(plugin_controller, None)
self._stop = False
def __init__(self, args):
self._original_excepthook = sys.excepthook
self._configuration = CONF
self._security_manager = SecurityManager()
self._mappers_manager = MapperManager()
self._changes_controller = ChangeController()
self._db_manager = DbManager()
self._model_controller = ModelController(self._security_manager,
self._mappers_manager)
self._plugin_manager = PluginManager(
os.path.join(CONF.getConfigPath(), "plugins"),
self._mappers_manager)
self._reports_manager = ReportManager(
10, self._plugin_manager.createController("ReportManager"))
self._workspace_manager = WorkspaceManager(self._db_manager,
self._mappers_manager,
self._changes_controller,
self._reports_manager)
self.gui_app = UiFactory.create(self._model_controller,
self._plugin_manager,
self._workspace_manager, args.gui)
self.gui_app.setSplashImage(
os.path.join(CONF.getImagePath(), "splash2.png"))
def setUp(self):
"""
Generic test to verify that the object exists and can be
instantiated without problems.
"""
self.dbManager = mock()
self.changesController = mock()
self.reportManager = mock()
self.dbManager = DbManager()
self.mappersManager = MapperManager()
self.model_controller = controller.ModelController(
mock(), self.mappersManager)
self.workspace_manager = WorkspaceManager(self.dbManager,
self.mappersManager,
self.changesController,
self.reportManager)
self.workspace_manager.createWorkspace('temp_workspace', 'desc',
DBTYPE.FS)
self.workspace_manager.openWorkspace('temp_workspace')
self._plugin_controller = PluginControllerForApi(
"test", {
"nmap": nmap_plugin.NmapPlugin(),
"nessus": nessus_plugin.NessusPlugin()
}, mock())
api.setUpAPIs(self.model_controller, self.workspace_manager)
def __init__(self, args):
self._original_excepthook = sys.excepthook
self.args = args
self._mappers_manager = MapperManager()
self._model_controller = ModelController(self._mappers_manager)
self._plugin_manager = PluginManager(
os.path.join(CONF.getConfigPath(), "plugins"))
self._workspace_manager = WorkspaceManager(self._mappers_manager)
# Create a PluginController and send this to UI selected.
self._plugin_controller = PluginController('PluginController',
self._plugin_manager,
self._mappers_manager)
if self.args.cli:
self.app = CliApp(self._workspace_manager, self._plugin_controller)
CONF.setMergeStrategy("new")
else:
self.app = UiFactory.create(self._model_controller,
self._plugin_manager,
self._workspace_manager,
self._plugin_controller, self.args.gui)
self.timer = TimerClass()
self.timer.start()
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 setUp(self):
self.db_name = self.new_random_workspace_name()
self.couchdbmanager = CouchDbManager(CONF.getCouchURI())
self.connector = self.couchdbmanager.createDb(self.db_name)
self.mapper_manager = MapperManager()
self.mapper_manager.createMappers(self.connector)
def setUp(self):
self.db_name = self.new_random_workspace_name()
self.fsmanager = FileSystemManager()
self.connector = self.fsmanager.createDb(self.db_name)
self.mapper_manager = MapperManager()
self.mapper_manager.createMappers(self.connector)
def test_end_pluging_multiple_times():
mappers_manager = MapperManager()
pending_actions = Queue()
controller = ModelController(mappers_manager, pending_actions)
controller._pluginEnd('test', None)
controller._pluginEnd('test', None)
assert controller.active_plugins_count == 0
assert controller.processing is False
def __init__(self, args):
self._original_excepthook = sys.excepthook
self.args = args
logger = getLogger(self)
if args.creds_file:
try:
with open(args.creds_file, 'r') as fp:
creds = json.loads(fp.read())
username = creds.get('username')
password = creds.get('password')
session_cookie = login_user(CONF.getServerURI(), username,
password)
if session_cookie:
logger.info('Login successful')
CONF.setDBUser(username)
CONF.setDBSessionCookies(session_cookie)
else:
logger.error('Login failed')
except (IOError, ValueError):
logger.error("Credentials file couldn't be loaded")
self._mappers_manager = MapperManager()
pending_actions = Queue()
self._model_controller = ModelController(self._mappers_manager,
pending_actions)
self._plugin_manager = PluginManager(
os.path.join(CONF.getConfigPath(), "plugins"),
pending_actions=pending_actions,
)
self._workspace_manager = WorkspaceManager(self._mappers_manager)
# Create a PluginController and send this to UI selected.
self._plugin_controller = PluginController('PluginController',
self._plugin_manager,
self._mappers_manager,
pending_actions)
if self.args.cli:
self.app = CliApp(self._workspace_manager, self._plugin_controller)
if self.args.keep_old:
CONF.setMergeStrategy("old")
else:
CONF.setMergeStrategy("new")
else:
self.app = UiFactory.create(self._model_controller,
self._plugin_manager,
self._workspace_manager,
self._plugin_controller, self.args.gui)
self.timer = TimerClass()
self.timer.start()
def test_only_start_plugin():
mappers_manager = MapperManager()
pending_actions = Queue()
controller = ModelController(mappers_manager, pending_actions)
controller._pluginStart('test', None)
assert controller.active_plugins_count == 1
assert controller.processing
controller._pluginStart('test', None)
assert controller.active_plugins_count == 2
def test_update_without_command(self, many_test_data, monkeypatch, session):
obj_class = many_test_data['class']
workspace = WorkspaceFactory.create(name='test')
mapper_manager = MapperManager()
mapper_manager.createMappers(workspace.name)
test_data = many_test_data
relational_model = test_data['factory'].create()
session.add(relational_model)
session.commit()
raw_data = test_data['data']
if test_data['parent']:
parent = test_data['parent']['parent_factory'].create()
session.add(parent)
session.commit()
test_data['data']['parent'] = parent.id
test_data['data']['parent_type'] = test_data['parent']['parent_type']
if obj_class not in [Note, Command]:
test_data['expected_payload']['parent'] = parent.id
if obj_class in [Vuln, Credential]:
test_data['expected_payload']['parent_type'] = test_data['parent']['parent_type']
def mock_server_put(test_data, put_url, update=False, expected_response=201, **params):
assert put_url == '{0}/ws/test/{1}/{2}/'.format(_create_server_api_url(), test_data['api_end_point'], test_data['id'])
assert expected_response == 200
assert update == False
if obj_class not in [Command]:
metadata = params.pop('metadata')
assert metadata['owner'] == test_data['expected_payload']['owner']
params.pop('command_id', None)
test_data['expected_payload'].pop('command_id', None)
assert params == test_data['expected_payload']
return {
'id': 1,
'ok': True,
'rev': ''
}
raw_data['id'] = relational_model.id
test_data['id'] = relational_model.id
monkeypatch.setattr(persistence.server.server, '_put', partial(mock_server_put, test_data))
obj = obj_class(raw_data, workspace.name)
mapper_manager.update(obj)
def test_update_with_command(self, many_test_data, monkeypatch, session):
obj_class = many_test_data['class']
if obj_class in [Command]:
return
workspace = WorkspaceFactory.create(name='test')
command = CommandFactory.create(workspace=workspace)
session.add(command)
session.commit()
mapper_manager = MapperManager()
mapper_manager.createMappers(workspace.name)
test_data = many_test_data
raw_data = test_data['data']
if test_data['parent']:
parent = test_data['parent']['parent_factory'].create()
session.add(parent)
session.commit()
test_data['data']['parent'] = parent.id
test_data['data']['parent_type'] = test_data['parent']['parent_type']
test_data['expected_payload']['parent'] = parent.id
if obj_class in [Vuln, Credential]:
test_data['expected_payload']['parent_type'] = test_data['parent']['parent_type']
relational_model = test_data['factory'].create()
session.add(relational_model)
session.commit()
def mock_server_put(put_url, update=False, expected_response=201, **params):
assert put_url == '{0}/ws/test/{1}/{2}/?command_id={3}'.format(
_create_server_api_url(),
test_data['api_end_point'],
test_data['id'],
params['command_id'])
assert expected_response == 200
assert update == False
return {
'id': 1,
'ok': True,
'rev': ''
}
raw_data['id'] = relational_model.id
test_data['id'] = relational_model.id
monkeypatch.setattr(persistence.server.server, '_put', mock_server_put)
obj = obj_class(raw_data, workspace.name)
mapper_manager.update(obj, command.id)
def import_external_reports(workspace_name=None, disable_polling=False):
plugins_path = os.path.join(CONF.getConfigPath(), "plugins")
plugin_manager = PluginManager(plugins_path)
mappers_manager = MapperManager()
if workspace_name:
query = Workspace.query.filter_by(name=workspace_name)
else:
query = Workspace.query
process_workspaces(mappers_manager, plugin_manager, query, disable_polling)
def test_controller_stop_when_is_not_processing():
mappers_manager = MapperManager()
pending_actions = Queue()
controller = ModelController(mappers_manager, pending_actions)
assert controller.processing is False
assert controller._stop is False
controller.start()
assert controller.isAlive()
controller.stop()
assert controller._stop is True
controller.join()
assert controller.isAlive() is False
def test_save_with_command(self, many_test_data, monkeypatch, session):
obj_class = many_test_data['class']
if obj_class == Command:
return
workspace = WorkspaceFactory.create(name='test')
command = CommandFactory.create(workspace=workspace)
session.commit()
mapper_manager = MapperManager()
mapper_manager.createMappers(workspace.name)
test_data = many_test_data
raw_data = test_data['data']
if test_data['parent']:
parent = test_data['parent']['parent_factory'].create()
session.commit()
test_data['data']['parent'] = parent.id
test_data['data']['parent_type'] = test_data['parent']['parent_type']
if obj_class not in [Note]:
test_data['expected_payload']['parent'] = parent.id
if obj_class in [Vuln, Credential]:
test_data['expected_payload']['parent_type'] = test_data['parent']['parent_type']
def mock_server_post(test_data, post_url, update=False, expected_response=201, **params):
assert post_url == '{0}/ws/test/{1}/?command_id={2}'.format(_create_server_api_url(), test_data['api_end_point'], params['command_id'])
assert expected_response == 201
assert update == False
metadata = params.pop('metadata')
assert metadata['owner'] == test_data['expected_payload']['owner']
params.pop('command_id')
test_data['expected_payload'].pop('command_id')
assert params == test_data['expected_payload']
return {
'id': 1,
'ok': True,
'rev': ''
}
monkeypatch.setattr(persistence.server.server, '_post', partial(mock_server_post, test_data))
obj = obj_class(raw_data, workspace.name)
mapper_manager.save(obj, command.id)
def setUp(self):
self._security_manager = mock(SecurityManager())
self._mappers_manager = mock(MapperManager())
self._plugin_manager = mock(PluginManager)
self._model_controller = ModelController(self._security_manager,
self._mappers_manager)
restapi.startAPIs(self._plugin_manager, self._model_controller,
self._mappers_manager)
#TODO: load conf from file
self.client = ModelRestApiClient("127.0.0.1", 9977)
def test_load_not_loaded_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)
#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.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 setUp(self):
self.couch_uri = CONF.getCouchURI()
# self.cdm = CouchdbManager(uri=self.couch_uri)
wpath = os.path.expanduser("~/.faraday/persistence/" )
# self.fsm = FSManager(wpath)
self.dbManager = DbManager()
self.mappersManager = MapperManager()
self.changesController = ChangeController(self.mappersManager)
self.wm = WorkspaceManager(self.dbManager, self.mappersManager,
self.changesController)
self._fs_workspaces = []
self._couchdb_workspaces = []
def test_find_obj_by_id(self, obj_class, many_test_data, session, monkeypatch):
for test_data in many_test_data:
persisted_obj = test_data['factory'].create()
session.add(persisted_obj)
session.commit()
mapper_manager = MapperManager()
mapper_manager.createMappers(persisted_obj.workspace.name)
def mock_unsafe_io_with_server(host, test_data, server_io_function, server_expected_response, server_url, **payload):
mocked_response = test_data['mocked_response']
assert '{0}/ws/{1}/{2}/{3}/'.format(
_create_server_api_url(),
persisted_obj.workspace.name,
test_data['api_end_point'],
persisted_obj.id) == server_url
return MockResponse(mocked_response, 200)
monkeypatch.setattr(persistence.server.server, '_unsafe_io_with_server', partial(mock_unsafe_io_with_server, persisted_obj, test_data))
found_obj = mapper_manager.find(obj_class.class_signature, persisted_obj.id)
serialized_obj = test_data['get_properties_function'](found_obj)
if obj_class not in [Command]:
metadata = serialized_obj.pop('metadata')
assert serialized_obj == test_data['serialized_expected_results']
def test_controller_plugin_start_action_updates_internal_state():
mappers_manager = MapperManager()
pending_actions = Queue()
controller = ModelController(mappers_manager, pending_actions)
controller.start()
controller.add_action((Modelactions.PLUGINSTART, "test", None))
time.sleep(1)
assert controller.active_plugins_count == 1
assert controller.processing
controller.add_action((Modelactions.PLUGINEND, "test", None))
time.sleep(1)
assert controller.active_plugins_count == 0
assert controller.processing is False
controller.stop()
controller.join()
assert controller.isAlive() is False
def test_update_without_command(self, many_test_data, monkeypatch,
session):
obj_class = many_test_data['class']
workspace = WorkspaceFactory.create(name='test')
mapper_manager = MapperManager()
mapper_manager.createMappers(workspace.name)
test_data = many_test_data
relational_model = test_data['factory'].create()
session.add(relational_model)
session.commit()
raw_data = test_data['data']
if test_data['parent']:
parent = test_data['parent']['parent_factory'].create()
session.add(parent)
session.commit()
test_data['data']['parent'] = parent.id
test_data['data']['parent_type'] = test_data['parent'][
'parent_type']
if obj_class not in [Note, Command]:
test_data['expected_payload']['parent'] = parent.id
if obj_class in [Vuln, Credential]:
test_data['expected_payload']['parent_type'] = test_data[
'parent']['parent_type']
def mock_server_put(test_data,
put_url,
update=False,
expected_response=201,
**params):
assert put_url == '{0}/ws/test/{1}/{2}/'.format(
_create_server_api_url(), test_data['api_end_point'],
test_data['id'])
assert expected_response == 200
assert update == False
if obj_class not in [Command]:
metadata = params.pop('metadata')
assert metadata['owner'] == test_data['expected_payload'][
'owner']
params.pop('command_id', None)
test_data['expected_payload'].pop('command_id', None)
assert params == test_data['expected_payload']
return {'id': 1, 'ok': True, 'rev': ''}
raw_data['id'] = relational_model.id
test_data['id'] = relational_model.id
monkeypatch.setattr(persistence.server.server, '_put',
partial(mock_server_put, test_data))
obj = obj_class(raw_data, workspace.name)
mapper_manager.update(obj)
def test_load_not_loaded_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)
#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.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_save_with_command(self, many_test_data, monkeypatch, session):
obj_class = many_test_data['class']
if obj_class == Command:
return
workspace = WorkspaceFactory.create(name='test')
command = CommandFactory.create(workspace=workspace)
session.commit()
mapper_manager = MapperManager()
mapper_manager.createMappers(workspace.name)
test_data = many_test_data
raw_data = test_data['data']
if test_data['parent']:
parent = test_data['parent']['parent_factory'].create()
session.commit()
test_data['data']['parent'] = parent.id
test_data['data']['parent_type'] = test_data['parent'][
'parent_type']
if obj_class not in [Note]:
test_data['expected_payload']['parent'] = parent.id
if obj_class in [Vuln, Credential]:
test_data['expected_payload']['parent_type'] = test_data[
'parent']['parent_type']
def mock_server_post(test_data,
post_url,
update=False,
expected_response=201,
**params):
assert post_url == '{0}/ws/test/{1}/?command_id={2}'.format(
_create_server_api_url(), test_data['api_end_point'],
params['command_id'])
assert expected_response == 201
assert update == False
metadata = params.pop('metadata')
assert metadata['owner'] == test_data['expected_payload']['owner']
params.pop('command_id')
test_data['expected_payload'].pop('command_id')
assert params == test_data['expected_payload']
return {'id': 1, 'ok': True, 'rev': ''}
monkeypatch.setattr(persistence.server.server, '_post',
partial(mock_server_post, test_data))
obj = obj_class(raw_data, workspace.name)
mapper_manager.save(obj, command.id)
def test_controller_cant_be_stopped_when_is_processing():
"""
If someone tells the controller to stop and it is processing then it
will stop when the processing finishes
"""
mappers_manager = MapperManager()
pending_actions = Queue()
controller = ModelController(mappers_manager, pending_actions)
assert controller.processing is False
assert controller._stop is False
controller.start()
controller.processing = True
controller.active_plugins_count = 1
assert controller.isAlive()
controller.stop()
assert controller._stop
assert controller.processing
controller.join(timeout=2)
assert controller.isAlive()
controller.processing = False
controller.join()
assert controller.isAlive() is False
def test_update_with_command(self, many_test_data, monkeypatch, session):
obj_class = many_test_data['class']
if obj_class in [Command]:
return
workspace = WorkspaceFactory.create(name='test')
command = CommandFactory.create(workspace=workspace)
session.add(command)
session.commit()
mapper_manager = MapperManager()
mapper_manager.createMappers(workspace.name)
test_data = many_test_data
raw_data = test_data['data']
if test_data['parent']:
parent = test_data['parent']['parent_factory'].create()
session.add(parent)
session.commit()
test_data['data']['parent'] = parent.id
test_data['data']['parent_type'] = test_data['parent'][
'parent_type']
test_data['expected_payload']['parent'] = parent.id
if obj_class in [Vuln, Credential]:
test_data['expected_payload']['parent_type'] = test_data[
'parent']['parent_type']
relational_model = test_data['factory'].create()
session.add(relational_model)
session.commit()
def mock_server_put(put_url,
update=False,
expected_response=201,
**params):
assert put_url == '{0}/ws/test/{1}/{2}/?command_id={3}'.format(
_create_server_api_url(), test_data['api_end_point'],
test_data['id'], params['command_id'])
assert expected_response == 200
assert update == False
return {'id': 1, 'ok': True, 'rev': ''}
raw_data['id'] = relational_model.id
test_data['id'] = relational_model.id
monkeypatch.setattr(persistence.server.server, '_put', mock_server_put)
obj = obj_class(raw_data, workspace.name)
mapper_manager.update(obj, command.id)
def test_save_without_command(self, obj_class, many_test_data, monkeypatch, session):
"""
This test verifies that the request made to the api are the expected ones
"""
workspace = WorkspaceFactory.create(name='test')
session.commit()
mapper_manager = MapperManager()
mapper_manager.createMappers(workspace.name)
for test_data in many_test_data:
raw_data = test_data['data']
if test_data['parent']:
parent = test_data['parent']['parent_factory'].create()
session.commit()
test_data['data']['parent'] = parent.id
test_data['data']['parent_type'] = test_data['parent']['parent_type']
if obj_class not in [Note, Command]:
test_data['expected_payload']['parent'] = parent.id
if obj_class in [Vuln, Credential]:
test_data['expected_payload']['parent_type'] = test_data['parent']['parent_type']
def mock_server_post(test_data, post_url, update=False, expected_response=201, **params):
assert post_url == '{0}/ws/test/{1}/'.format(
_create_server_api_url(), test_data['api_end_point'])
assert expected_response == 201
assert update == False
if obj_class not in [Command]:
metadata = params.pop('metadata')
assert metadata['owner'] == test_data['expected_payload']['owner']
assert params == test_data['expected_payload']
return {
'id': 1,
'ok': True,
'rev': ''
}
monkeypatch.setattr(persistence.server.server, '_post', partial(mock_server_post, test_data))
obj = obj_class(raw_data, workspace.name)
mapper_manager.save(obj)
class CompositeMapperTestSuite(unittest.TestCase):
def setUp(self):
self.mapper_manager = MapperManager()
self.mapper_manager.createMappers(NullPersistenceManager())
def tearDown(self):
pass
def create_host(self):
host = Host(name="pepito", os="linux")
host.setDescription("Some description")
host.setOwned(True)
return host
def create_interface(self):
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)
return iface
def test_find_composite_host(self):
'''
We are going to create a host, then save it.
Next we create an interface and then add it
to the host, and finally save it.
'''
# add host
host = self.create_host()
self.mapper_manager.save(host)
# add inteface
interface = self.create_interface()
host.addChild(interface)
self.mapper_manager.save(interface)
h = self.mapper_manager.find(host.getID())
self.assertEquals(
h.getAllInterfaces(), host.getAllInterfaces(),
"Interfaces from original host should be equals to retrieved host's interfaces"
)
def test_load_composite_one_host_one_interface(self):
'''
We are going to create a host, then save it.
Next we create an interface and then add it
to the host, and finally save it.
'''
doc_host = {
"type": "Host",
"_id": "1234",
"name": "pepito",
"owned": False,
"parent": None,
"owner": None,
"description": "some description",
"metadata": None,
"os": "linux",
"default_gateway": None
}
doc_interface = {
"type": "Interface",
"_id": "5678",
"name": "192.168.10.168",
"owned": False,
"parent": "1234",
"owner": None,
"description": "some description",
"metadata": None,
"mac": "01:02:03:04:05:06",
"network_segment": None,
"hostnames": ["www.test.com"],
"ipv4": {
"address": "192.168.10.168",
"mask": "255.255.255.0",
"gateway": "192.168.10.1",
"DNS": "192.168.10.1"
},
"ipv6": {},
"ports": {
"opened": 2,
"closed": 3,
"filtered": 4,
}
}
pmanager = mock(NullPersistenceManager)
when(pmanager).getDocument("1234").thenReturn(doc_host)
when(pmanager).getDocument("5678").thenReturn(doc_interface)
when(pmanager).getChildren(any(str)).thenReturn([])
when(pmanager).getChildren("1234").thenReturn([{
'_id': "5678",
'type': "Interface"
}])
self.mapper_manager.createMappers(pmanager)
host = self.mapper_manager.find("1234")
self.assertNotEquals(host, None, "Existent host shouldn't be None")
self.assertEquals(len(host.getAllInterfaces()), 1,
"Host should have one interface")
iface = self.mapper_manager.find("5678")
self.assertNotEquals(iface, None,
"Existent interface shouldn't be None")
self.assertEquals(
host.getInterface("5678"), iface,
"Interface inside host should be equals to retrieved interface")
self.assertEquals(iface.getParent(), host,
"Host should be the interface's parent")
def test_load_composite_one_host_two_interfaces(self):
doc_host = {
"type": "Host",
"_id": "1234",
"name": "pepito",
"owned": False,
"parent": None,
"owner": None,
"description": "some description",
"metadata": None,
"os": "linux",
"default_gateway": None
}
doc_interface1 = {
"type": "Interface",
"_id": "5678",
"name": "192.168.10.168",
"owned": False,
"parent": "1234",
"owner": None,
"description": "some description",
"metadata": None,
"mac": "01:02:03:04:05:06",
"network_segment": None,
"hostnames": ["www.test.com"],
"ipv4": {
"address": "192.168.10.168",
"mask": "255.255.255.0",
"gateway": "192.168.10.1",
"DNS": "192.168.10.1"
},
"ipv6": {},
"ports": {
"opened": 2,
"closed": 3,
"filtered": 4,
}
}
doc_interface2 = {
"type": "Interface",
"_id": "6789",
"name": "192.168.10.168",
"owned": False,
"parent": "1234",
"owner": None,
"description": "some description",
"metadata": None,
"mac": "01:02:03:04:05:06",
"network_segment": None,
"hostnames": ["www.test.com"],
"ipv4": {
"address": "192.168.10.168",
"mask": "255.255.255.0",
"gateway": "192.168.10.1",
"DNS": "192.168.10.1"
},
"ipv6": {},
"ports": {
"opened": 2,
"closed": 3,
"filtered": 4,
}
}
pmanager = mock(NullPersistenceManager)
when(pmanager).getDocument("1234").thenReturn(doc_host)
when(pmanager).getDocument("5678").thenReturn(doc_interface1)
when(pmanager).getDocument("6789").thenReturn(doc_interface2)
when(pmanager).getChildren(any(str)).thenReturn([])
when(pmanager).getChildren("1234").thenReturn([{
'_id': "5678",
'type': "Interface"
}, {
'_id': "6789",
'type': "Interface"
}])
self.mapper_manager.createMappers(pmanager)
host = self.mapper_manager.find("1234")
self.assertNotEquals(host, None, "Existent host shouldn't be None")
self.assertEquals(len(host.getAllInterfaces()), 2,
"Host should have two interface")
iface1 = self.mapper_manager.find("5678")
self.assertNotEquals(iface1, None,
"Existent interface1 shouldn't be None")
self.assertEquals(
host.getInterface("5678"), iface1,
"Interface1 inside host should be equals to retrieved interface1")
self.assertEquals(iface1.getParent(), host,
"Host should be the interface1's parent")
iface2 = self.mapper_manager.find("6789")
self.assertNotEquals(iface2, None,
"Existent interface2 shouldn't be None")
self.assertEquals(
host.getInterface("6789"), iface2,
"Interface2 inside host should be equals to retrieved interface2")
self.assertEquals(iface2.getParent(), host,
"Host should be the interface2's parent")
def test_load_composite_one_host_one_interface_two_services(self):
doc_host = {
"type": "Host",
"_id": "1234",
"name": "pepito",
"owned": False,
"parent": None,
"owner": None,
"description": "some description",
"metadata": None,
"os": "linux",
"default_gateway": None
}
doc_interface = {
"type": "Interface",
"_id": "5678",
"name": "192.168.10.168",
"owned": False,
"parent": "1234",
"owner": None,
"description": "some description",
"metadata": None,
"mac": "01:02:03:04:05:06",
"network_segment": None,
"hostnames": ["www.test.com"],
"ipv4": {
"address": "192.168.10.168",
"mask": "255.255.255.0",
"gateway": "192.168.10.1",
"DNS": "192.168.10.1"
},
"ipv6": {},
"ports": {
"opened": 2,
"closed": 3,
"filtered": 4,
}
}
doc_service1 = {
"type": "Service",
"_id": "abcd",
"name": "http",
"owned": False,
"parent": "5678",
"owner": None,
"description": "some description",
"metadata": None,
"protocol": "tcp",
"status": "open",
"ports": [80],
"version": "Apache 2.4"
}
doc_service2 = {
"type": "Service",
"_id": "efgh",
"name": "ssh",
"owned": False,
"parent": "5678",
"owner": None,
"description": "some description",
"metadata": None,
"protocol": "tcp",
"status": "open",
"ports": [22],
"version": "OpenSSH"
}
pmanager = mock(NullPersistenceManager)
when(pmanager).getDocument("1234").thenReturn(doc_host)
when(pmanager).getDocument("5678").thenReturn(doc_interface)
when(pmanager).getDocument("abcd").thenReturn(doc_service1)
when(pmanager).getDocument("efgh").thenReturn(doc_service2)
when(pmanager).getChildren(any(str)).thenReturn([])
when(pmanager).getChildren("1234").thenReturn([{
'_id': "5678",
'type': "Interface"
}])
when(pmanager).getChildren("5678").thenReturn([{
'_id': "abcd",
'type': "Service"
}, {
'_id': "efgh",
'type': "Service"
}])
self.mapper_manager.createMappers(pmanager)
iface = self.mapper_manager.find("5678")
self.assertNotEquals(iface, None,
"Existent interface shouldn't be None")
# Lets make sure that the host was created
host = iface.getParent()
self.assertEquals(host.getID(), "1234",
"Interface's parent id should be 1234")
self.assertEquals(
host, self.mapper_manager.find("1234"),
"Interface1's parent should be equals to the host retrieved")
self.assertEquals(len(iface.getAllServices()), 2,
"Interface should have two services")
services_ids = [srv.getID() for srv in iface.getAllServices()]
self.assertIn(
"abcd", services_ids,
"Service 'abcd' should be one of the interface's services")
self.assertIn(
"efgh", services_ids,
"Service 'efgh' should be one of the interface's services")
def test_load_composite_one_host_one_note_one_vuln_one_credential(self):
doc_host = {
"type": "Host",
"_id": "1234",
"name": "pepito",
"owned": False,
"parent": None,
"owner": None,
"description": "some description",
"metadata": None,
"os": "linux",
"default_gateway": None
}
doc_note = {
"type": "Note",
"_id": "note1",
"name": "Note1",
"owned": False,
"parent": "1234",
"owner": None,
"description": "some description",
"metadata": None,
"text": "this is a note"
}
doc_vuln = {
"type": "Vulnerability",
"_id": "vuln1",
"name": "Vuln1",
"owned": False,
"parent": "1234",
"owner": None,
"description": "some description",
"metadata": None,
"desc": "this is a vuln",
"severity": "high",
"refs": ["cve1", "cve2"]
}
doc_cred = {
"type": "Cred",
"_id": "cred1",
"name": "Vuln1",
"owned": False,
"parent": "1234",
"owner": None,
"description": "some description",
"metadata": None,
"username": "******",
"password": "******"
}
pmanager = mock(NullPersistenceManager)
when(pmanager).getDocument("1234").thenReturn(doc_host)
when(pmanager).getDocument("note1").thenReturn(doc_note)
when(pmanager).getDocument("vuln1").thenReturn(doc_vuln)
when(pmanager).getDocument("cred1").thenReturn(doc_cred)
when(pmanager).getChildren(any(str)).thenReturn([])
when(pmanager).getChildren("1234").thenReturn([{
'_id': "note1",
'type': "Note"
}, {
'_id': "vuln1",
'type': "Vulnerability"
}, {
'_id': "cred1",
'type': "Cred"
}])
self.mapper_manager.createMappers(pmanager)
host = self.mapper_manager.find("1234")
self.assertNotEquals(host, None, "Existent host shouldn't be None")
self.assertEquals(len(host.getNotes()), 1, "Host should have one note")
self.assertEquals(len(host.getVulns()), 1, "Host should have one vuln")
self.assertEquals(len(host.getCreds()), 1, "Host should have one cred")
def test_delete_interface_from_composite_one_host_one_interface_two_services(
self):
doc_host = {
"type": "Host",
"_id": "1234",
"name": "pepito",
"owned": False,
"parent": None,
"owner": None,
"description": "some description",
"metadata": None,
"os": "linux",
"default_gateway": None
}
doc_interface = {
"type": "Interface",
"_id": "5678",
"name": "192.168.10.168",
"owned": False,
"parent": "1234",
"owner": None,
"description": "some description",
"metadata": None,
"mac": "01:02:03:04:05:06",
"network_segment": None,
"hostnames": ["www.test.com"],
"ipv4": {
"address": "192.168.10.168",
"mask": "255.255.255.0",
"gateway": "192.168.10.1",
"DNS": "192.168.10.1"
},
"ipv6": {},
"ports": {
"opened": 2,
"closed": 3,
"filtered": 4,
}
}
doc_service1 = {
"type": "Service",
"_id": "abcd",
"name": "http",
"owned": False,
"parent": "5678",
"owner": None,
"description": "some description",
"metadata": None,
"protocol": "tcp",
"status": "open",
"ports": [80],
"version": "Apache 2.4"
}
doc_service2 = {
"type": "Service",
"_id": "efgh",
"name": "ssh",
"owned": False,
"parent": "5678",
"owner": None,
"description": "some description",
"metadata": None,
"protocol": "tcp",
"status": "open",
"ports": [22],
"version": "OpenSSH"
}
self.pmanager = mock(NullPersistenceManager)
when(self.pmanager).getDocument("1234").thenReturn(doc_host)
when(self.pmanager).getDocument("5678").thenReturn(doc_interface)
when(self.pmanager).getDocument("abcd").thenReturn(doc_service1)
when(self.pmanager).getDocument("efgh").thenReturn(doc_service2)
when(self.pmanager).getChildren(any(str)).thenReturn([])
when(self.pmanager).getChildren("1234").thenReturn([{
'_id': "5678",
'type': "Interface"
}])
when(self.pmanager).getChildren("5678").thenReturn([{
'_id': "abcd",
'type': "Service"
}, {
'_id': "efgh",
'type': "Service"
}])
self.mapper_manager.createMappers(self.pmanager)
# load the host first
host = self.mapper_manager.find("1234")
#then remove the interface
iface_id = host.getInterface("5678").getID()
host.deleteChild(iface_id)
def fake_remove(id):
when(self.pmanager).getDocument(id).thenReturn(None)
when(self.pmanager).remove("5678").thenReturn(fake_remove("5678"))
when(self.pmanager).remove("abcd").thenReturn(fake_remove("abcd"))
when(self.pmanager).remove("efgh").thenReturn(fake_remove("efgh"))
self.mapper_manager.remove(iface_id)
# now we make sure that we have removed the interface
# and the services
self.assertEquals(len(host.getAllInterfaces()), 0,
"Host should have no interfaces")
self.assertEquals(self.mapper_manager.find("5678"), None,
"Service abcd shouldn't exist anymore")
self.assertEquals(self.mapper_manager.find("abcd"), None,
"Service abcd shouldn't exist anymore")
self.assertEquals(self.mapper_manager.find("efgh"), None,
"Service efgh shouldn't exist anymore")
def test_load_composite_one_workspace_two_hosts(self):
doc_ws = {
"type": "Workspace",
"_id": "test_ws",
"name": "test_ws",
"description": "some description",
"customer": "Infobyte",
"sdate": None,
"fdate": None
}
doc_host1 = {
"type": "Host",
"_id": "1234",
"name": "pepito",
"owned": False,
"parent": "test_ws",
"owner": None,
"description": "some description",
"metadata": None,
"os": "linux",
"default_gateway": None
}
doc_host2 = {
"type": "Host",
"_id": "5678",
"name": "coquito",
"owned": False,
"parent": "test_ws",
"owner": None,
"description": "some description",
"metadata": None,
"os": "windows",
"default_gateway": None
}
pmanager = NullPersistenceManager()
when(pmanager).getDocument("test_ws").thenReturn(doc_ws)
when(pmanager).getDocument("1234").thenReturn(doc_host1)
when(pmanager).getDocument("5678").thenReturn(doc_host2)
when(pmanager).getDocsByFilter(any, any).thenReturn([])
when(pmanager).getDocsByFilter(any(str), None).thenReturn([])
when(pmanager).getDocsByFilter(None, None).thenReturn([])
when(pmanager).getDocsByFilter("test_ws", None).thenReturn([{
'_id':
"1234",
'type':
"Host"
}, {
'_id':
"5678",
'type':
"Host"
}])
#when(pmanager).getDocsByFilter(None, "Host").thenReturn([])
self.mapper_manager.createMappers(pmanager)
ws = self.mapper_manager.find("test_ws")
self.assertNotEquals(ws, None, "Existent Workspace shouldn't be None")
self.assertEquals(len(ws.getHosts()), 2,
"Workspace should have two hosts")
hosts_ids = [host.getID() for host in ws.getHosts()]
self.assertIn("1234", hosts_ids,
"Host '1234' should be one of the workspace's hosts")
self.assertIn("5678", hosts_ids,
"Host '5678' should be one of the workspace's hosts")
def setUp(self):
self.mapper_manager = MapperManager()
def setUp(self):
self.mapper_manager = MapperManager()
self.mapper_manager.createMappers(NullPersistenceManager())
self.wmapper = self.mapper_manager.getMapper(Workspace.__name__)
class WorkspaceMapperTestSuite(unittest.TestCase):
def setUp(self):
self.mapper_manager = MapperManager()
self.mapper_manager.createMappers(NullPersistenceManager())
self.wmapper = self.mapper_manager.getMapper(Workspace.__name__)
def tearDown(self):
pass
def test_workspace_serialization(self):
workspace = Workspace(name="workspace_test")
workspace.setDescription("Some description")
workspace.setCustomer("Infobyte")
wserialized = self.wmapper.serialize(workspace)
# if serialization fails, returns None
self.assertNotEqual(wserialized, None,
"Serialized workspace shouldn't be None")
# we check the host attributes
self.assertEquals(wserialized.get("_id"), workspace.getID(),
"Serialized ID is not the same as workspace ID")
self.assertEquals(wserialized.get("name"), workspace.getName(),
"Serialized name is not the same as workspace name")
self.assertEquals(
wserialized.get("description"), workspace.getDescription(),
"Serialized description is not the same as workspace description")
self.assertEquals(
wserialized.get("customer"), workspace.getCustomer(),
"Serialized customer is not the same as workspace customer")
def test_workspace_creation(self):
workspace = Workspace(name="workspace_test")
self.wmapper.save(workspace)
w = self.wmapper.find(workspace.getID())
self.assertEquals(
w, workspace,
"Workspace retrieved should be the same as persisted")
self.assertEquals(
w.getID(), workspace.getID(),
"Workspace retrieved's Id should be the same as persisted's Id")
def test_load_nonexistent_workspace(self):
self.assertEquals(self.wmapper.load("Nonexistent"), None,
"Nonexistent workspace should return None")
def test_find_not_loaded_workspace(self):
# we need to mock the persistence manager first,
# so we can return a simulated doc
doc = {
"type": "Workspace",
"_id": "workspace_test",
"name": "workspace_test",
"description": "some description",
"customer": "Infobyte",
"sdate": time(),
"fdate": time()
}
when(self.wmapper.pmanager).getDocument("workspace_test").thenReturn(
doc)
workspace = self.wmapper.find("workspace_test")
self.assertNotEquals(workspace, None,
"Existent workspace shouldn't return None")
self.assertEquals(workspace.getName(), "workspace_test",
"Workspace name should be workspace_test")
self.assertEquals(workspace.getCustomer(), "Infobyte",
"Host os should be Infobyte")
def test_workspace_create_and_delete(self):
workspace = Workspace(name="workspace_test")
self.wmapper.save(workspace)
w_id = workspace.getID()
self.assertNotEquals(self.wmapper.load(w_id), None,
"Workspace should be saved")
self.wmapper.delete(w_id)
self.assertEquals(self.wmapper.find(w_id), None,
"Workspace shouldn't exist anymore")
def setUp(self):
self.mapper_manager = MapperManager()
self.mapper_manager.createMappers(NullPersistenceManager())
def setUp(self):
self.mapper_manager = MapperManager()
self.mapper_manager.createMappers(NullPersistenceManager())
self.imapper = self.mapper_manager.getMapper(Interface.__name__)
def setUp(self):
self.mapper_manager = MapperManager()
self.mapper_manager.createMappers(NullPersistenceManager())
self.mapper = self.mapper_manager.getMapper(CommandRunInformation.__name__)
class MapperWithCouchDbManagerInegrationTest(unittest.TestCase):
def setUp(self):
self.db_name = self.new_random_workspace_name()
self.couchdbmanager = CouchDbManager(CONF.getCouchURI())
self.connector = self.couchdbmanager.createDb(self.db_name)
self.mapper_manager = MapperManager()
self.mapper_manager.createMappers(self.connector)
def new_random_workspace_name(self):
return ("aworkspace" +
"".join(random.sample([chr(i)
for i in range(65, 90)], 10))).lower()
def tearDown(self):
self.couchdbmanager.deleteDb(self.db_name)
time.sleep(3)
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 test_load_nonexistent_host_using_manager_find(self):
self.assertEquals(self.connector.getDocument("1234"), None,
"Nonexistent host should return None document")
self.assertEquals(self.mapper_manager.find("1234"), None,
"Nonexistent host should return None object")
def test_load_nonexistent_host_using_mapper_find(self):
self.assertEquals(self.connector.getDocument("1234"), None,
"Nonexistent host should return None document")
self.assertEquals(
self.mapper_manager.getMapper(Host.__name__).find("1234"), None,
"Nonexistent host should return None object")
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_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 test_load_not_loaded_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)
#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.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 setUp(self):
self.mapper_manager = MapperManager()
self.mapper_manager.createMappers(NullPersistenceManager())
class MapperWithCouchDbManagerInegrationTest(unittest.TestCase):
def setUp(self):
self.db_name = self.new_random_workspace_name()
self.couchdbmanager = CouchDbManager(CONF.getCouchURI())
self.connector = self.couchdbmanager.createDb(self.db_name)
self.mapper_manager = MapperManager()
self.mapper_manager.createMappers(self.connector)
def new_random_workspace_name(self):
return ("aworkspace" + "".join(random.sample(
[chr(i) for i in range(65, 90)], 10))).lower()
def tearDown(self):
self.couchdbmanager.deleteDb(self.db_name)
time.sleep(3)
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 test_load_nonexistent_host_using_manager_find(self):
self.assertEquals(
self.connector.getDocument("1234"),
None,
"Nonexistent host should return None document")
self.assertEquals(
self.mapper_manager.find("1234"),
None,
"Nonexistent host should return None object")
def test_load_nonexistent_host_using_mapper_find(self):
self.assertEquals(
self.connector.getDocument("1234"),
None,
"Nonexistent host should return None document")
self.assertEquals(
self.mapper_manager.getMapper(Host.__name__).find("1234"),
None,
"Nonexistent host should return None object")
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_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 test_load_not_loaded_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)
#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.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")
class HostMapperTestSuite(unittest.TestCase):
def setUp(self):
self.mapper_manager = MapperManager()
self.mapper_manager.createMappers(NullPersistenceManager())
self.hmapper = self.mapper_manager.getMapper(Host.__name__)
def tearDown(self):
pass
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):
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_load_nonexistent_host(self):
self.assertEquals(
self.hmapper.load("1234"),
None,
"Nonexistent host should return None")
def test_find_not_loaded_host(self):
# we need to mock the persistence manager first,
# so we can return a simulated doc
doc = {
"type": "Host",
"_id": "1234",
"name": "pepito",
"owned": False,
"parent": None,
"owner": None,
"description": "some description",
"metadata": None,
"os": "linux",
"default_gateway": None
}
when(self.hmapper.pmanager).getDocument("1234").thenReturn(doc)
host = self.hmapper.find("1234")
self.assertNotEquals(
host,
None,
"Existent host shouldn't return None")
self.assertEquals(
host.getName(),
"pepito",
"Host name should be pepito")
self.assertEquals(
host.getOS(),
"linux",
"Host os should be linux")
def test_load_rubbish_host_doc(self):
# we need to mock the persistence manager first,
# so we can return an erroneous simulated doc
doc = {
"type": "RUBBISH",
"_id": "1234",
"name": "pepito",
"owned": False,
"parent": None,
"owner": None,
"description": "some description",
"metadata": None,
"os": "linux",
"default_gateway": None
}
pmanager = mock(NullPersistenceManager)
when(pmanager).getDocument(any(str)).thenReturn(doc)
self.hmapper.setPersistenceManager(pmanager)
host = self.hmapper.find("1234")
self.assertEquals(
host,
None,
"Doc is malformed so we should get None")
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")
class InterfaceMapperTestSuite(unittest.TestCase):
def setUp(self):
self.mapper_manager = MapperManager()
self.mapper_manager.createMappers(NullPersistenceManager())
self.imapper = self.mapper_manager.getMapper(Interface.__name__)
def tearDown(self):
pass
def test_interface_serialization(self):
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)
iserialized = self.imapper.serialize(iface)
# if serialization fails, returns None
self.assertNotEqual(
iserialized,
None,
"Serialized interface shouldn't be None")
# we check the interface attributes
self.assertEquals(
iserialized.get("_id"),
iface.getID(),
"Serialized ID is not the same as Interface ID")
self.assertEquals(
iserialized.get("name"),
iface.getName(),
"Serialized name is not the same as Interface name")
self.assertEquals(
iserialized.get("mac"),
iface.getMAC(),
"Serialized MAC is not the same as Interface MAC")
self.assertEquals(
iserialized.get("network_segment"),
iface.getNetworkSegment(),
"Serialized Network Segment is not the same as Interface Network Segment")
self.assertEquals(
iserialized.get("description"),
iface.getDescription(),
"Serialized description is not the same as Interface description")
self.assertEquals(
iserialized.get("owned"),
iface.isOwned(),
"Serialized owned flag is not the same as Interface owned flag")
def test_interface_creation(self):
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)
self.imapper.save(iface)
i = self.imapper.find(iface.getID())
self.assertEquals(
i,
iface,
"Interface retrieved should be the same as persisted")
self.assertEquals(
i.getID(),
iface.getID(),
"Interface retrieved's Id should be the same as persisted's Id")
def test_load_nonexistent_interface(self):
self.assertEquals(
self.imapper.load("1234"),
None,
"Nonexistent interface should return None")
def test_find_not_loaded_interface(self):
# we need to mock the persistence manager first,
# so we can return a simulated doc
doc = {
"type": "Interface",
"_id": "1234",
"name": "192.168.10.168",
"owned": False,
"parent": None,
"owner": None,
"description": "some description",
"metadata": None,
"mac": "01:02:03:04:05:06",
"network_segment": None,
"hostnames": ["www.test.com"],
"ipv4": {
"address": "192.168.10.168",
"mask": "255.255.255.0",
"gateway": "192.168.10.1",
"DNS": "192.168.10.1"
},
"ipv6": {},
"ports": {
"opened": 2,
"closed": 3,
"filtered": 4,
}
}
when(self.imapper.pmanager).getDocument("1234").thenReturn(doc)
iface = self.imapper.find("1234")
self.assertNotEquals(
iface,
None,
"Existent interface shouldn't return None")
self.assertEquals(
iface.getName(),
"192.168.10.168",
"Inteface name should be 192.168.10.168")
self.assertEquals(
iface.getMAC(),
"01:02:03:04:05:06",
"Interface MAC should be 01:02:03:04:05:06")
def test_interface_create_and_delete(self):
iface = Interface(name="192.168.10.168", mac="01:02:03:04:05:06")
self.imapper.save(iface)
i_id = iface.getID()
self.assertNotEquals(
self.imapper.load(i_id),
None,
"Inteface should be saved")
self.imapper.delete(i_id)
self.assertEquals(
self.imapper.find(i_id),
None,
"Inteface shouldn't exist anymore")
def setUp(self):
self.mapper_manager = MapperManager()
def setUp(self):
self.mapper_manager = MapperManager()
self.mapper_manager.createMappers(NullPersistenceManager())
self.wmapper = self.mapper_manager.getMapper(Workspace.__name__)
def setUp(self):
self.mapper_manager = MapperManager()
self.mapper_manager.createMappers(NullPersistenceManager())
self.smapper = self.mapper_manager.getMapper(Service.__name__)
class WorkspaceMapperTestSuite(unittest.TestCase):
def setUp(self):
self.mapper_manager = MapperManager()
self.mapper_manager.createMappers(NullPersistenceManager())
self.wmapper = self.mapper_manager.getMapper(Workspace.__name__)
def tearDown(self):
pass
def test_workspace_serialization(self):
workspace = Workspace(name="workspace_test")
workspace.setDescription("Some description")
workspace.setCustomer("Infobyte")
wserialized = self.wmapper.serialize(workspace)
# if serialization fails, returns None
self.assertNotEqual(
wserialized,
None,
"Serialized workspace shouldn't be None")
# we check the host attributes
self.assertEquals(
wserialized.get("_id"),
workspace.getID(),
"Serialized ID is not the same as workspace ID")
self.assertEquals(
wserialized.get("name"),
workspace.getName(),
"Serialized name is not the same as workspace name")
self.assertEquals(
wserialized.get("description"),
workspace.getDescription(),
"Serialized description is not the same as workspace description")
self.assertEquals(
wserialized.get("customer"),
workspace.getCustomer(),
"Serialized customer is not the same as workspace customer")
def test_workspace_creation(self):
workspace = Workspace(name="workspace_test")
self.wmapper.save(workspace)
w = self.wmapper.find(workspace.getID())
self.assertEquals(
w,
workspace,
"Workspace retrieved should be the same as persisted")
self.assertEquals(
w.getID(),
workspace.getID(),
"Workspace retrieved's Id should be the same as persisted's Id")
def test_load_nonexistent_workspace(self):
self.assertEquals(
self.wmapper.load("Nonexistent"),
None,
"Nonexistent workspace should return None")
def test_find_not_loaded_workspace(self):
# we need to mock the persistence manager first,
# so we can return a simulated doc
doc = {
"type": "Workspace",
"_id": "workspace_test",
"name": "workspace_test",
"description": "some description",
"customer": "Infobyte",
"sdate": time(),
"fdate": time()
}
when(self.wmapper.pmanager).getDocument("workspace_test").thenReturn(doc)
workspace = self.wmapper.find("workspace_test")
self.assertNotEquals(
workspace,
None,
"Existent workspace shouldn't return None")
self.assertEquals(
workspace.getName(),
"workspace_test",
"Workspace name should be workspace_test")
self.assertEquals(
workspace.getCustomer(),
"Infobyte",
"Host os should be Infobyte")
def test_workspace_create_and_delete(self):
workspace = Workspace(name="workspace_test")
self.wmapper.save(workspace)
w_id = workspace.getID()
self.assertNotEquals(
self.wmapper.load(w_id),
None,
"Workspace should be saved")
self.wmapper.delete(w_id)
self.assertEquals(
self.wmapper.find(w_id),
None,
"Workspace shouldn't exist anymore")
class ModelObjectMapperTestSuite(unittest.TestCase):
def setUp(self):
Mappers[ModelObject.class_signature] = ModelObjectMapper
self.mapper_manager = MapperManager()
self.mapper_manager.createMappers(NullPersistenceManager())
self.mapper = self.mapper_manager.getMapper(ModelObject.__name__)
def tearDown(self):
pass
def test_metadata_deserialization(self):
import time
modelobject = ModelObject()
modelobject.updateID = lambda *args : 'ModelObjectID'
# {'create_time': 1417205460.253131,
# 'creator': 'ninja_owner',
# 'owner': 'ninja_owner',
# 'update_time': 1417205460.253132,
# 'update_user': '******'}
modelobjectserialized = {'name': '',
'parent': None,
'owner': '',
'_id': None,
'type': 'ModelObject',
'metadata': {'update_time': 1417207650.761777,
'update_user': '',
'update_action': 0,
'creator': '',
'create_time': 1417207650.761777,
'update_controller_action': 'No model controller call',
'owner': ''},
'owned': False,
'description': ''}
modelobject2 = self.mapper.unserialize(modelobject, modelobjectserialized)
metadata = modelobject2._metadata
metadataserialized = modelobjectserialized['metadata']
# if serialization fails, returns None
self.assertNotEqual(
modelobjectserialized,
None,
"Serialized ModelObejct shouldn't be None")
# we check the cmd attributes
self.assertEquals(
modelobjectserialized.get("_id"),
modelobject.getID(),
"Serialized ID is not the same as metadata ID")
import ipdb; ipdb.set_trace()
self.assertEquals(
metadataserialized.get("owner"),
metadata.__getattribute__("owner"),
"Serialized owner is not the same as metadata owner")
self.assertEquals(
metadataserialized.get("creator"),
metadata.__getattribute__("creator"),
"Serialized owner is not the same as metadata creator")
self.assertTrue(
isinstance(metadataserialized.get("create_time"), float),
"Serialized create_time is not int")
self.assertTrue(
isinstance(metadataserialized.get("update_time"), float),
"Serialized update_time is not int")
def test_metadata_serialization(self):
import time
modelobject = ModelObject()
modelobject.updateID = lambda *args : 'ModelObjectID'
metadata = Metadata('')
# {'create_time': 1417205460.253131,
# 'creator': 'ninja_owner',
# 'owner': 'ninja_owner',
# 'update_time': 1417205460.253132,
# 'update_user': '******'}
modelobjectserialized = self.mapper.serialize(modelobject)
metadataserialized = modelobjectserialized['metadata']
# if serialization fails, returns None
self.assertNotEqual(
modelobjectserialized,
None,
"Serialized ModelObejct shouldn't be None")
# we check the cmd attributes
self.assertEquals(
modelobjectserialized.get("_id"),
modelobject.getID(),
"Serialized ID is not the same as metadata ID")
self.assertEquals(
metadataserialized.get("creator"),
metadata.__getattribute__("creator"),
"Serialized owner is not the same as metadata creator")
self.assertEquals(
metadataserialized.get("owner"),
metadata.__getattribute__("owner"),
"Serialized owner is not the same as metadata owner")
self.assertTrue(
isinstance(metadataserialized.get("create_time"), float),
"Serialized create_time is not int")
self.assertTrue(
isinstance(metadataserialized.get("update_time"), float),
"Serialized update_time is not int")
class CommandRunInformationMapperTestSuite(unittest.TestCase):
def setUp(self):
self.mapper_manager = MapperManager()
self.mapper_manager.createMappers(NullPersistenceManager())
self.mapper = self.mapper_manager.getMapper(CommandRunInformation.__name__)
def tearDown(self):
pass
def test_cmd_serialization(self):
import time
cmd = CommandRunInformation(**{
'workspace': 'fakews',
'itime': time.time(),
'command': "ping",
'params': "127.0.0.1"})
cmdserialized = self.mapper.serialize(cmd)
# if serialization fails, returns None
self.assertNotEqual(
cmdserialized,
None,
"Serialized cmd shouldn't be None")
# we check the cmd attributes
self.assertEquals(
cmdserialized.get("_id"),
cmd.getID(),
"Serialized ID is not the same as cmd ID")
self.assertEquals(
cmdserialized.get("command"),
cmd.__getattribute__("command"),
"Serialized name is not the same as cmd command")
self.assertEquals(
cmdserialized.get("params"),
cmd.__getattribute__("params"),
"Serialized name is not the same as cmd params")
def test_cmd_creation(self):
import time
cmd = CommandRunInformation(**{
'workspace': 'fakews',
'itime': time.time(),
'command': "ping",
'params': "127.0.0.1"})
self.mapper.save(cmd)
c = self.mapper.find(cmd.getID())
self.assertEquals(
c,
cmd,
"Cmd retrieved should be the same as persisted")
self.assertEquals(
c.getID(),
cmd.getID(),
"Cmd retrieved's Id should be the same as persisted's Id")
def test_load_nonexistent_cmd(self):
self.assertEquals(
self.mapper.load("1234"),
None,
"Nonexistent cmd should return None")
def test_find_not_loaded_cmd(self):
# we need to mock the persistence manager first,
# so we can return a simulated doc
doc = {
"_id": "1234",
"itime": 1409856507.891718,
"command": "ping",
"workspace": "fakews",
"duration": 0.6570961475372314,
"params": "127.0.0.1",
"type": "CommandRunInformation",
}
when(self.mapper.pmanager).getDocument("1234").thenReturn(doc)
cmd = self.mapper.find("1234")
self.assertNotEquals(
cmd,
None,
"Existent cmd shouldn't return None")
self.assertEquals(
cmd.__getattribute__("command"),
"ping",
"Cmd command should be ping")
def test_cmd_create_and_delete(self):
import time
cmd = CommandRunInformation(**{
'workspace': 'fakews',
'itime': time.time(),
'command': "ping",
'params': "127.0.0.1"})
self.mapper.save(cmd)
cmd_id = cmd.getID()
self.assertNotEquals(
self.mapper.load(cmd_id),
None,
"Command should be saved")
self.mapper.delete(cmd_id)
self.assertEquals(
self.mapper.find(cmd_id),
None,
"Command shouldn't exist anymore")
def setUp(self):
self.mapper_manager = MapperManager()
self.mapper_manager.createMappers(NullPersistenceManager())
self.mapper = self.mapper_manager.getMapper(
CommandRunInformation.__name__)
def setUp(self):
Mappers[ModelObject.class_signature] = ModelObjectMapper
self.mapper_manager = MapperManager()
self.mapper_manager.createMappers(NullPersistenceManager())
self.mapper = self.mapper_manager.getMapper(ModelObject.__name__)
class TestWorkspacesManagement(unittest.TestCase):
def setUp(self):
self.couch_uri = CONF.getCouchURI()
# self.cdm = CouchdbManager(uri=self.couch_uri)
wpath = os.path.expanduser("~/.faraday/persistence/" )
# self.fsm = FSManager(wpath)
self.dbManager = DbManager()
self.mappersManager = MapperManager()
self.changesController = ChangeController(self.mappersManager)
self.wm = WorkspaceManager(self.dbManager, self.mappersManager,
self.changesController)
self._fs_workspaces = []
self._couchdb_workspaces = []
def tearDown(self):
self.cleanCouchDatabases()
self.cleanFSWorkspaces()
# pass
def new_random_workspace_name(self):
return ("aworkspace" + "".join(random.sample(
[chr(i) for i in range(65, 90)], 10))).lower()
def cleanFSWorkspaces(self):
import shutil
basepath = os.path.expanduser("~/.faraday/persistence/")
for d in self._fs_workspaces:
wpath = os.path.join(basepath, d)
if os.path.isdir(wpath):
shutil.rmtree(wpath)
def cleanCouchDatabases(self):
try:
for wname in self._couchdb_workspaces:
self.cdm.removeWorkspace(wname)
except Exception as e:
print e
def test_create_fs_workspace(self):
"""
Verifies the creation of a filesystem workspace
"""
wname = self.new_random_workspace_name()
self._fs_workspaces.append(wname)
self.wm.createWorkspace(wname, 'desc', DBTYPE.FS)
wpath = os.path.expanduser("~/.faraday/persistence/%s" % wname)
self.assertTrue(os.path.exists(wpath))
def test_create_couch_workspace(self):
"""
Verifies the creation of a couch workspace
"""
wname = self.new_random_workspace_name()
self._couchdb_workspaces.append(wname)
self.wm.createWorkspace(wname, 'a desc', DBTYPE.COUCHDB)
res_connector = self.dbManager.getConnector(wname)
self.assertTrue(res_connector)
self.assertEquals(res_connector.getType(), DBTYPE.COUCHDB)
self.assertTrue(self.mappersManager.find(wname), "Workspace document not found")
wpath = os.path.expanduser("~/.faraday/persistence/%s" % wname)
self.assertFalse(os.path.exists(wpath))
# self.assertEquals(WorkspaceOnCouch.__name__, self.wm.getWorkspaceType(wname))
def test_delete_couch_workspace(self):
"""
Verifies the deletion of a couch workspace
"""
wname = self.new_random_workspace_name()
self.wm.createWorkspace(wname, 'a desc', DBTYPE.COUCHDB)
self.assertTrue(self.mappersManager.find(wname), "Workspace document not found")
#Delete workspace
self.wm.removeWorkspace(wname)
self.assertIsNone(self.mappersManager.find(wname))
self.assertFalse(self.dbManager.connectorExists(wname))
def test_delete_fs_workspace(self):
"""
Verifies the deletion of a filesystem workspace
"""
wname = self.new_random_workspace_name()
self.wm.createWorkspace(wname, 'desc', DBTYPE.FS)
wpath = os.path.expanduser("~/.faraday/persistence/%s" % wname)
self.assertTrue(os.path.exists(wpath))
#Delete workspace
self.wm.removeWorkspace(wname)
self.assertFalse(os.path.exists(wpath))
def test_list_workspaces(self):
""" Lists FS workspaces and Couch workspaces """
# First create workspaces manually
wnamefs = self.new_random_workspace_name()
wnamecouch = self.new_random_workspace_name()
# FS
self.wm.createWorkspace(wnamefs, 'a desc', DBTYPE.FS)
# Couch
self.wm.createWorkspace(wnamecouch, 'a desc', DBTYPE.COUCHDB)
self.assertIn(wnamefs, self.wm.getWorkspacesNames(), 'FS Workspace not loaded')
self.assertIn(wnamecouch, self.wm.getWorkspacesNames(), 'Couch Workspace not loaded')
self.assertEquals(self.wm.getWorkspaceType(wnamecouch), 'CouchDB', 'Workspace type bad defined' )
self.assertEquals(self.wm.getWorkspaceType(wnamefs), 'FS', 'Workspace type bad defined')
def test_get_workspace(self):
""" Create a workspace, now ask for it """
# When
wname = self.new_random_workspace_name()
workspace = self.wm.createWorkspace(wname, 'a desc', DBTYPE.FS)
added_workspace = self.wm.openWorkspace(wname)
# Then
self.assertIsNotNone(workspace, 'Workspace added should not be none')
self.assertEquals(workspace, added_workspace, 'Workspace created and added diffier')
def _test_get_existent_couch_workspace(self): # Deprecate
""" Create a workspace in the backend, now ask for it """
# When
wname = self.new_random_workspace_name()
workspace = self.cdm.addWorkspace(wname)
added_workspace = self.wm.getWorkspace(wname)
# Then
self.assertIsNotNone(added_workspace, 'Workspace added should not be none')
def _test_get_existent_fs_workspace(self): # Deprecate
""" Create a workspace in the backend, now ask for it """
# When
wname = self.new_random_workspace_name()
workspace = self.fsm.addWorkspace(wname)
self.wm.loadWorkspaces()
added_workspace = self.wm.getWorkspace(wname)
# Then
self.assertIsNotNone(added_workspace, 'Workspace added should not be none')
def test_get_non_existent_workspace(self):
""" Retrieve a non existent workspace """
added_workspace = self.wm.openWorkspace('inventado')
# Then
self.assertIsNone(added_workspace, 'Workspace added should not be none')
def test_set_active_workspace(self):
''' create a workspace through the backend, then set it as active '''
wname = self.new_random_workspace_name()
workspace = self.wm.createWorkspace(wname, 'desc', DBTYPE.FS)
# when
self.wm.setActiveWorkspace(workspace)
self.assertEquals(workspace, self.wm.getActiveWorkspace(),
'Active workspace diffiers with expected workspace')
self.assertTrue(self.wm.isActive(workspace.name),
'Workspace is active flag not set')
def test_remove_fs_workspace(self):
# First
wname = self.new_random_workspace_name()
added_workspace = self.wm.createWorkspace(wname, 'desc', DBTYPE.FS)
# When
self.wm.removeWorkspace(wname)
# Then
self.assertNotIn(wname, self.wm.getWorkspacesNames())
wpath = os.path.expanduser("~/.faraday/persistence/%s" % wname)
self.assertFalse(os.path.exists(wpath))
def test_remove_couch_workspace(self):
# First
wname = self.new_random_workspace_name()
added_workspace = self.wm.createWorkspace(wname, 'desc', DBTYPE.COUCHDB)
# When
self.wm.removeWorkspace(wname)
# Then
self.assertNotIn(wname, self.wm.getWorkspacesNames())
def test_remove_non_existent_workspace(self):
# When
self.wm.removeWorkspace('invented')
class CompositeMapperTestSuite(unittest.TestCase):
def setUp(self):
self.mapper_manager = MapperManager()
self.mapper_manager.createMappers(NullPersistenceManager())
def tearDown(self):
pass
def create_host(self):
host = Host(name="pepito", os="linux")
host.setDescription("Some description")
host.setOwned(True)
return host
def create_interface(self):
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)
return iface
def test_find_composite_host(self):
'''
We are going to create a host, then save it.
Next we create an interface and then add it
to the host, and finally save it.
'''
# add host
host = self.create_host()
self.mapper_manager.save(host)
# add inteface
interface = self.create_interface()
host.addChild(interface)
self.mapper_manager.save(interface)
h = self.mapper_manager.find(host.getID())
self.assertEquals(
h.getAllInterfaces(),
host.getAllInterfaces(),
"Interfaces from original host should be equals to retrieved host's interfaces")
def test_load_composite_one_host_one_interface(self):
'''
We are going to create a host, then save it.
Next we create an interface and then add it
to the host, and finally save it.
'''
doc_host = {
"type": "Host",
"_id": "1234",
"name": "pepito",
"owned": False,
"parent": None,
"owner": None,
"description": "some description",
"metadata": None,
"os": "linux",
"default_gateway": None
}
doc_interface = {
"type": "Interface",
"_id": "5678",
"name": "192.168.10.168",
"owned": False,
"parent": "1234",
"owner": None,
"description": "some description",
"metadata": None,
"mac": "01:02:03:04:05:06",
"network_segment": None,
"hostnames": ["www.test.com"],
"ipv4": {
"address": "192.168.10.168",
"mask": "255.255.255.0",
"gateway": "192.168.10.1",
"DNS": "192.168.10.1"
},
"ipv6": {},
"ports": {
"opened": 2,
"closed": 3,
"filtered": 4,
}
}
pmanager = mock(NullPersistenceManager)
when(pmanager).getDocument("1234").thenReturn(doc_host)
when(pmanager).getDocument("5678").thenReturn(doc_interface)
when(pmanager).getChildren(any(str)).thenReturn([])
when(pmanager).getChildren("1234").thenReturn([{'_id': "5678", 'type': "Interface"}])
self.mapper_manager.createMappers(pmanager)
host = self.mapper_manager.find("1234")
self.assertNotEquals(
host,
None,
"Existent host shouldn't be None")
self.assertEquals(
len(host.getAllInterfaces()),
1,
"Host should have one interface")
iface = self.mapper_manager.find("5678")
self.assertNotEquals(
iface,
None,
"Existent interface shouldn't be None")
self.assertEquals(
host.getInterface("5678"),
iface,
"Interface inside host should be equals to retrieved interface")
self.assertEquals(
iface.getParent(),
host,
"Host should be the interface's parent")
def test_load_composite_one_host_two_interfaces(self):
doc_host = {
"type": "Host",
"_id": "1234",
"name": "pepito",
"owned": False,
"parent": None,
"owner": None,
"description": "some description",
"metadata": None,
"os": "linux",
"default_gateway": None
}
doc_interface1 = {
"type": "Interface",
"_id": "5678",
"name": "192.168.10.168",
"owned": False,
"parent": "1234",
"owner": None,
"description": "some description",
"metadata": None,
"mac": "01:02:03:04:05:06",
"network_segment": None,
"hostnames": ["www.test.com"],
"ipv4": {
"address": "192.168.10.168",
"mask": "255.255.255.0",
"gateway": "192.168.10.1",
"DNS": "192.168.10.1"
},
"ipv6": {},
"ports": {
"opened": 2,
"closed": 3,
"filtered": 4,
}
}
doc_interface2 = {
"type": "Interface",
"_id": "6789",
"name": "192.168.10.168",
"owned": False,
"parent": "1234",
"owner": None,
"description": "some description",
"metadata": None,
"mac": "01:02:03:04:05:06",
"network_segment": None,
"hostnames": ["www.test.com"],
"ipv4": {
"address": "192.168.10.168",
"mask": "255.255.255.0",
"gateway": "192.168.10.1",
"DNS": "192.168.10.1"
},
"ipv6": {},
"ports": {
"opened": 2,
"closed": 3,
"filtered": 4,
}
}
pmanager = mock(NullPersistenceManager)
when(pmanager).getDocument("1234").thenReturn(doc_host)
when(pmanager).getDocument("5678").thenReturn(doc_interface1)
when(pmanager).getDocument("6789").thenReturn(doc_interface2)
when(pmanager).getChildren(any(str)).thenReturn([])
when(pmanager).getChildren("1234").thenReturn([{'_id': "5678", 'type': "Interface"}, {'_id': "6789", 'type': "Interface"}])
self.mapper_manager.createMappers(pmanager)
host = self.mapper_manager.find("1234")
self.assertNotEquals(
host,
None,
"Existent host shouldn't be None")
self.assertEquals(
len(host.getAllInterfaces()),
2,
"Host should have two interface")
iface1 = self.mapper_manager.find("5678")
self.assertNotEquals(
iface1,
None,
"Existent interface1 shouldn't be None")
self.assertEquals(
host.getInterface("5678"),
iface1,
"Interface1 inside host should be equals to retrieved interface1")
self.assertEquals(
iface1.getParent(),
host,
"Host should be the interface1's parent")
iface2 = self.mapper_manager.find("6789")
self.assertNotEquals(
iface2,
None,
"Existent interface2 shouldn't be None")
self.assertEquals(
host.getInterface("6789"),
iface2,
"Interface2 inside host should be equals to retrieved interface2")
self.assertEquals(
iface2.getParent(),
host,
"Host should be the interface2's parent")
def test_load_composite_one_host_one_interface_two_services(self):
doc_host = {
"type": "Host",
"_id": "1234",
"name": "pepito",
"owned": False,
"parent": None,
"owner": None,
"description": "some description",
"metadata": None,
"os": "linux",
"default_gateway": None
}
doc_interface = {
"type": "Interface",
"_id": "5678",
"name": "192.168.10.168",
"owned": False,
"parent": "1234",
"owner": None,
"description": "some description",
"metadata": None,
"mac": "01:02:03:04:05:06",
"network_segment": None,
"hostnames": ["www.test.com"],
"ipv4": {
"address": "192.168.10.168",
"mask": "255.255.255.0",
"gateway": "192.168.10.1",
"DNS": "192.168.10.1"
},
"ipv6": {},
"ports": {
"opened": 2,
"closed": 3,
"filtered": 4,
}
}
doc_service1 = {
"type": "Service",
"_id": "abcd",
"name": "http",
"owned": False,
"parent": "5678",
"owner": None,
"description": "some description",
"metadata": None,
"protocol": "tcp",
"status": "open",
"ports": [80],
"version": "Apache 2.4"
}
doc_service2 = {
"type": "Service",
"_id": "efgh",
"name": "ssh",
"owned": False,
"parent": "5678",
"owner": None,
"description": "some description",
"metadata": None,
"protocol": "tcp",
"status": "open",
"ports": [22],
"version": "OpenSSH"
}
pmanager = mock(NullPersistenceManager)
when(pmanager).getDocument("1234").thenReturn(doc_host)
when(pmanager).getDocument("5678").thenReturn(doc_interface)
when(pmanager).getDocument("abcd").thenReturn(doc_service1)
when(pmanager).getDocument("efgh").thenReturn(doc_service2)
when(pmanager).getChildren(any(str)).thenReturn([])
when(pmanager).getChildren("1234").thenReturn([{'_id': "5678", 'type': "Interface"}])
when(pmanager).getChildren("5678").thenReturn([{'_id': "abcd", 'type': "Service"}, {'_id': "efgh", 'type': "Service"}])
self.mapper_manager.createMappers(pmanager)
iface = self.mapper_manager.find("5678")
self.assertNotEquals(
iface,
None,
"Existent interface shouldn't be None")
# Lets make sure that the host was created
host = iface.getParent()
self.assertEquals(
host.getID(),
"1234",
"Interface's parent id should be 1234")
self.assertEquals(
host,
self.mapper_manager.find("1234"),
"Interface1's parent should be equals to the host retrieved")
self.assertEquals(
len(iface.getAllServices()),
2,
"Interface should have two services")
services_ids = [srv.getID() for srv in iface.getAllServices()]
self.assertIn(
"abcd",
services_ids,
"Service 'abcd' should be one of the interface's services")
self.assertIn(
"efgh",
services_ids,
"Service 'efgh' should be one of the interface's services")
def test_load_composite_one_host_one_note_one_vuln_one_credential(self):
doc_host = {
"type": "Host",
"_id": "1234",
"name": "pepito",
"owned": False,
"parent": None,
"owner": None,
"description": "some description",
"metadata": None,
"os": "linux",
"default_gateway": None
}
doc_note = {
"type": "Note",
"_id": "note1",
"name": "Note1",
"owned": False,
"parent": "1234",
"owner": None,
"description": "some description",
"metadata": None,
"text": "this is a note"
}
doc_vuln = {
"type": "Vulnerability",
"_id": "vuln1",
"name": "Vuln1",
"owned": False,
"parent": "1234",
"owner": None,
"description": "some description",
"metadata": None,
"desc": "this is a vuln",
"severity": "high",
"refs": ["cve1", "cve2"]
}
doc_cred = {
"type": "Cred",
"_id": "cred1",
"name": "Vuln1",
"owned": False,
"parent": "1234",
"owner": None,
"description": "some description",
"metadata": None,
"username": "******",
"password": "******"
}
pmanager = mock(NullPersistenceManager)
when(pmanager).getDocument("1234").thenReturn(doc_host)
when(pmanager).getDocument("note1").thenReturn(doc_note)
when(pmanager).getDocument("vuln1").thenReturn(doc_vuln)
when(pmanager).getDocument("cred1").thenReturn(doc_cred)
when(pmanager).getChildren(any(str)).thenReturn([])
when(pmanager).getChildren("1234").thenReturn(
[{'_id': "note1", 'type': "Note"},
{'_id': "vuln1", 'type': "Vulnerability"},
{'_id': "cred1", 'type': "Cred"}])
self.mapper_manager.createMappers(pmanager)
host = self.mapper_manager.find("1234")
self.assertNotEquals(
host,
None,
"Existent host shouldn't be None")
self.assertEquals(
len(host.getNotes()),
1,
"Host should have one note")
self.assertEquals(
len(host.getVulns()),
1,
"Host should have one vuln")
self.assertEquals(
len(host.getCreds()),
1,
"Host should have one cred")
def test_delete_interface_from_composite_one_host_one_interface_two_services(self):
doc_host = {
"type": "Host",
"_id": "1234",
"name": "pepito",
"owned": False,
"parent": None,
"owner": None,
"description": "some description",
"metadata": None,
"os": "linux",
"default_gateway": None
}
doc_interface = {
"type": "Interface",
"_id": "5678",
"name": "192.168.10.168",
"owned": False,
"parent": "1234",
"owner": None,
"description": "some description",
"metadata": None,
"mac": "01:02:03:04:05:06",
"network_segment": None,
"hostnames": ["www.test.com"],
"ipv4": {
"address": "192.168.10.168",
"mask": "255.255.255.0",
"gateway": "192.168.10.1",
"DNS": "192.168.10.1"
},
"ipv6": {},
"ports": {
"opened": 2,
"closed": 3,
"filtered": 4,
}
}
doc_service1 = {
"type": "Service",
"_id": "abcd",
"name": "http",
"owned": False,
"parent": "5678",
"owner": None,
"description": "some description",
"metadata": None,
"protocol": "tcp",
"status": "open",
"ports": [80],
"version": "Apache 2.4"
}
doc_service2 = {
"type": "Service",
"_id": "efgh",
"name": "ssh",
"owned": False,
"parent": "5678",
"owner": None,
"description": "some description",
"metadata": None,
"protocol": "tcp",
"status": "open",
"ports": [22],
"version": "OpenSSH"
}
self.pmanager = mock(NullPersistenceManager)
when(self.pmanager).getDocument("1234").thenReturn(doc_host)
when(self.pmanager).getDocument("5678").thenReturn(doc_interface)
when(self.pmanager).getDocument("abcd").thenReturn(doc_service1)
when(self.pmanager).getDocument("efgh").thenReturn(doc_service2)
when(self.pmanager).getChildren(any(str)).thenReturn([])
when(self.pmanager).getChildren("1234").thenReturn([{'_id': "5678", 'type': "Interface"}])
when(self.pmanager).getChildren("5678").thenReturn([{'_id': "abcd", 'type': "Service"}, {'_id': "efgh", 'type': "Service"}])
self.mapper_manager.createMappers(self.pmanager)
# load the host first
host = self.mapper_manager.find("1234")
#then remove the interface
iface_id = host.getInterface("5678").getID()
host.deleteChild(iface_id)
def fake_remove(id):
when(self.pmanager).getDocument(id).thenReturn(None)
when(self.pmanager).remove("5678").thenReturn(fake_remove("5678"))
when(self.pmanager).remove("abcd").thenReturn(fake_remove("abcd"))
when(self.pmanager).remove("efgh").thenReturn(fake_remove("efgh"))
self.mapper_manager.remove(iface_id)
# now we make sure that we have removed the interface
# and the services
self.assertEquals(
len(host.getAllInterfaces()),
0,
"Host should have no interfaces")
self.assertEquals(
self.mapper_manager.find("5678"),
None,
"Service abcd shouldn't exist anymore")
self.assertEquals(
self.mapper_manager.find("abcd"),
None,
"Service abcd shouldn't exist anymore")
self.assertEquals(
self.mapper_manager.find("efgh"),
None,
"Service efgh shouldn't exist anymore")
def test_load_composite_one_workspace_two_hosts(self):
doc_ws = {
"type": "Workspace",
"_id": "test_ws",
"name": "test_ws",
"description": "some description",
"customer": "Infobyte",
"sdate": None,
"fdate": None
}
doc_host1 = {
"type": "Host",
"_id": "1234",
"name": "pepito",
"owned": False,
"parent": "test_ws",
"owner": None,
"description": "some description",
"metadata": None,
"os": "linux",
"default_gateway": None
}
doc_host2 = {
"type": "Host",
"_id": "5678",
"name": "coquito",
"owned": False,
"parent": "test_ws",
"owner": None,
"description": "some description",
"metadata": None,
"os": "windows",
"default_gateway": None
}
pmanager = NullPersistenceManager()
when(pmanager).getDocument("test_ws").thenReturn(doc_ws)
when(pmanager).getDocument("1234").thenReturn(doc_host1)
when(pmanager).getDocument("5678").thenReturn(doc_host2)
when(pmanager).getDocsByFilter(any, any).thenReturn([])
when(pmanager).getDocsByFilter(any(str), None).thenReturn([])
when(pmanager).getDocsByFilter(None, None).thenReturn([])
when(pmanager).getDocsByFilter("test_ws", None).thenReturn(
[{'_id': "1234", 'type': "Host"},
{'_id': "5678", 'type': "Host"}])
#when(pmanager).getDocsByFilter(None, "Host").thenReturn([])
self.mapper_manager.createMappers(pmanager)
ws = self.mapper_manager.find("test_ws")
self.assertNotEquals(
ws,
None,
"Existent Workspace shouldn't be None")
self.assertEquals(
len(ws.getHosts()),
2,
"Workspace should have two hosts")
hosts_ids = [host.getID() for host in ws.getHosts()]
self.assertIn(
"1234",
hosts_ids,
"Host '1234' should be one of the workspace's hosts")
self.assertIn(
"5678",
hosts_ids,
"Host '5678' should be one of the workspace's hosts")
class ServiceMapperTestSuite(unittest.TestCase):
def setUp(self):
self.mapper_manager = MapperManager()
self.mapper_manager.createMappers(NullPersistenceManager())
self.smapper = self.mapper_manager.getMapper(Service.__name__)
def tearDown(self):
pass
def test_service_serialization(self):
srv = Service(name="http")
srv.setDescription("Some description")
srv.setOwned(True)
srv.setProtocol("tcp")
srv.setPorts(80)
srv.setStatus("open")
srv.setVersion("Apache 2.4")
sserialized = self.smapper.serialize(srv)
# if serialization fails, returns None
self.assertNotEqual(
sserialized,
None,
"Serialized service shouldn't be None")
# we check the service attributes
self.assertEquals(
sserialized.get("_id"),
srv.getID(),
"Serialized ID is not the same as Service ID")
self.assertEquals(
sserialized.get("name"),
srv.getName(),
"Serialized name is not the same as Service name")
self.assertEquals(
sserialized.get("protocol"),
srv.getProtocol(),
"Serialized protocol is not the same as Service protocol")
self.assertEquals(
sserialized.get("status"),
srv.getStatus(),
"Serialized status is not the same as Service status")
self.assertEquals(
sserialized.get("ports"),
srv.getPorts(),
"Serialized ports is not the same as Service ports")
self.assertEquals(
sserialized.get("description"),
srv.getDescription(),
"Serialized description is not the same as Interface description")
self.assertEquals(
sserialized.get("owned"),
srv.isOwned(),
"Serialized owned flag is not the same as Interface owned flag")
def test_service_creation(self):
srv = Service(name="http")
srv.setDescription("Some description")
srv.setOwned(True)
srv.setProtocol("tcp")
srv.setPorts(80)
srv.setStatus("open")
srv.setVersion("Apache 2.4")
self.smapper.save(srv)
s = self.smapper.find(srv.getID())
self.assertEquals(
s,
srv,
"Service retrieved should be the same as persisted")
self.assertEquals(
s.getID(),
srv.getID(),
"Service retrieved's Id should be the same as persisted's Id")
def test_load_nonexistent_service(self):
self.assertEquals(
self.smapper.load("1234"),
None,
"Nonexistent service should return None")
def test_find_not_loaded_service(self):
# we need to mock the persistence manager first,
# so we can return a simulated doc
doc = {
"type": "Service",
"_id": "1234",
"name": "http",
"owned": False,
"parent": None,
"owner": None,
"description": "some description",
"metadata": None,
"protocol": "tcp",
"status": "open",
"ports": [80],
"version": "Apache 2.4"
}
when(self.smapper.pmanager).getDocument("1234").thenReturn(doc)
srv = self.smapper.find("1234")
self.assertNotEquals(
srv,
None,
"Existent service shouldn't return None")
self.assertEquals(
srv.getName(),
"http",
"Service name should be http")
self.assertEquals(
srv.getProtocol(),
"tcp",
"Service protocol should be tcp")
def test_service_create_and_delete(self):
srv = Service(name="http")
self.smapper.save(srv)
s_id = srv.getID()
self.assertNotEquals(
self.smapper.load(s_id),
None,
"Service should be saved")
self.smapper.delete(s_id)
self.assertEquals(
self.smapper.find(s_id),
None,
"Service shouldn't exist anymore")
