class PluginsToModelControllerIntegration(unittest.TestCase):
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 tearDown(self):
self.workspace_manager.removeWorkspace('temp_workspace')
def test_nmap_scan_saves_host(self):
output_file = open(os.path.join(os.getcwd(), 'test_cases/data/nmap_plugin_with_api.xml'))
output = output_file.read()
self._plugin_controller.processCommandInput("nmap localhost")
self._plugin_controller.onCommandFinished("nmap localhost", output)
self.model_controller.processAllPendingActions()
self.assertEquals(len(self.model_controller.getAllHosts()), 1,
"Not all hosts added to model")
host = self.model_controller.getAllHosts()[0]
self.assertEquals(len(host.getAllInterfaces()), 1,
"Not all interfaces added to model")
interface = host.getAllInterfaces()[0]
self.assertEquals(len(interface.getAllServices()), 3,
"Not all services added to model")
services = interface.getAllServices()
self.assertTrue(all( [ s.getStatus() == 'open' for s in services]),
"Port status not saved correctly")
def test_nessus_scan_saves_host(self):
output_file = open(os.path.join(os.getcwd(), 'test_cases/data/nessus_plugin_with_api.nessus'))
output = output_file.read()
self._plugin_controller.processCommandInput("./nessus report")
self._plugin_controller.onCommandFinished("./nessus report", output)
self.model_controller.processAllPendingActions()
self.assertEquals(len(self.model_controller.getAllHosts()), 7,
"Not all hosts added to model")
def testRemoveWorkspace(self):
dbManager = mock()
mappersManager = mock()
dbConnector = mock()
mappers = mock()
changesController = mock()
workspace = Workspace('test_workspace', 'a desc')
when(dbManager).removeDb('test_workspace').thenReturn(True)
when(dbManager).getAllDbNames().thenReturn(['test_workspace'])
workspace_manager = WorkspaceManager(dbManager, mappersManager, changesController, mock())
remove_ret = workspace_manager.removeWorkspace('test_workspace')
verify(dbManager).removeDb('test_workspace')
self.assertTrue(remove_ret, 'bbdd not removed')
def testRemoveWorkspace(self):
dbManager = mock()
mappersManager = mock()
dbConnector = mock()
mappers = mock()
changesController = mock()
workspace = Workspace('test_workspace', 'a desc')
when(dbManager).removeDb('test_workspace').thenReturn(True)
when(dbManager).getAllDbNames().thenReturn(['test_workspace'])
workspace_manager = WorkspaceManager(dbManager, mappersManager,
changesController, mock())
remove_ret = workspace_manager.removeWorkspace('test_workspace')
verify(dbManager).removeDb('test_workspace')
self.assertTrue(remove_ret, 'bbdd not removed')
class PluginsToModelControllerIntegration(unittest.TestCase):
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 tearDown(self):
self.workspace_manager.removeWorkspace('temp_workspace')
def test_nmap_scan_saves_host(self):
output_file = open(
os.path.join(os.getcwd(),
'test_cases/data/nmap_plugin_with_api.xml'))
output = output_file.read()
self._plugin_controller.processCommandInput("nmap localhost")
self._plugin_controller.onCommandFinished("nmap localhost", output)
self.model_controller.processAllPendingActions()
self.assertEquals(len(self.model_controller.getAllHosts()), 1,
"Not all hosts added to model")
host = self.model_controller.getAllHosts()[0]
self.assertEquals(len(host.getAllInterfaces()), 1,
"Not all interfaces added to model")
interface = host.getAllInterfaces()[0]
self.assertEquals(len(interface.getAllServices()), 3,
"Not all services added to model")
services = interface.getAllServices()
self.assertTrue(all([s.getStatus() == 'open' for s in services]),
"Port status not saved correctly")
def test_nessus_scan_saves_host(self):
output_file = open(
os.path.join(os.getcwd(),
'test_cases/data/nessus_plugin_with_api.nessus'))
output = output_file.read()
self._plugin_controller.processCommandInput("./nessus report")
self._plugin_controller.onCommandFinished("./nessus report", output)
self.model_controller.processAllPendingActions()
self.assertEquals(len(self.model_controller.getAllHosts()), 7,
"Not all hosts added to model")
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')
