def reload_configuration(): # pragma: no cover """ Reload configuration """ logger.info('Reload configuration...') settings.init_config() settings.init_css() send_event('INFO', _('Configuration reloaded'), timer=True)
class TestAppQFrame(unittest2.TestCase): """ This file test the AppQFrame class. """ settings.init_config() @classmethod def setUpClass(cls): """Create QApplication""" try: cls.app = QApplication(sys.argv) except: pass def test_get_frame_separator(self): """Get QFrame Separator""" under_test = get_frame_separator() self.assertEqual('hseparator', under_test.objectName()) self.assertEqual(QFrame.HLine, under_test.frameShape()) under_test = get_frame_separator(vertical=True) self.assertEqual('vseparator', under_test.objectName()) self.assertEqual(QFrame.VLine, under_test.frameShape())
class TestWSClient(unittest2.TestCase): """ This file test methods of WSClient class """ # Init config for all methods. settings.init_config() def test_initialize_ws_client(self): """Initialize Web Service""" under_test = WSClient() self.assertFalse(under_test.token) self.assertFalse(under_test.ws_backend) self.assertIsNone(under_test.auth) def test_login_ws_with_wrong_token(self): """Login to WS with Wrong Token""" under_test = WSClient() under_test.login('') self.assertFalse(under_test.token) config_url = settings.get_config('Alignak', 'webservice') self.assertEqual(config_url, under_test.ws_backend) # WS is not auth self.assertIsNone(under_test.auth)
class TestServerQDialog(unittest2.TestCase): """ This file test methods of ServerQDialog class object """ settings.init_config() init_localization() app_backend.login() @classmethod def setUpClass(cls): """Create QApplication""" try: cls.app = QApplication(sys.argv) except: pass def test_initialize_server_dialog(self): """Initialize ServerQDialog""" under_test = ServerQDialog() self.assertIsInstance(under_test.server_proc, QLineEdit) self.assertEqual('', under_test.server_proc.text()) self.assertIsInstance(under_test.server_port, QLineEdit) self.assertEqual('', under_test.server_port.text()) self.assertIsInstance(under_test.server_url, QLineEdit) self.assertEqual('', under_test.server_url.text()) self.assertIsInstance(under_test.webservice_url, QLineEdit) self.assertEqual('', under_test.webservice_url.text()) self.assertIsNone(under_test.offset) self.assertEqual('dialog', under_test.objectName()) under_test.initialize_dialog() # After initialization, # QLineEdit texts must be equal to what is defined in the configuration file self.assertIsInstance(under_test.server_proc, QLineEdit) self.assertEqual(settings.get_config('Alignak', 'processes'), under_test.server_proc.text()) self.assertIsInstance(under_test.server_port, QLineEdit) self.assertEqual( settings.get_config('Alignak', 'backend').split(':')[2], under_test.server_port.text()) self.assertIsInstance(under_test.server_url, QLineEdit) self.assertEqual(settings.get_config('Alignak', 'url'), under_test.server_url.text()) self.assertIsInstance(under_test.webservice_url, QLineEdit) self.assertEqual(settings.get_config('Alignak', 'webservice'), under_test.webservice_url.text())
class TestHostQWidget(unittest2.TestCase): """ This file test methods of AppBackend class """ # Create config for all methods. settings.init_config() @classmethod def setUpClass(cls): """Create QApplication""" try: cls.app = QApplication(sys.argv) except: pass def test_initialize_host_widget(self): """Initialize Host QWidget""" under_test = HostQWidget() self.assertIsNone(under_test.host_item) self.assertIsNone(under_test.service_items) self.assertIsNone(under_test.layout()) self.assertIsNotNone(under_test.history_widget) self.assertIsNotNone(under_test.labels) self.assertIsNotNone(under_test.history_btn) under_test.initialize() self.assertIsNotNone(under_test.layout()) def test_set_data(self): """Set Data Host QWidget""" under_test = HostQWidget() under_test.initialize() self.assertIsNone(under_test.host_item) self.assertIsNone(under_test.service_items) data_manager.database['host'] = [host] under_test.set_data(host) self.assertIsNotNone(under_test.host_item) self.assertIsInstance(under_test.host_item, Host) self.assertIsNotNone(under_test.service_items) for item in under_test.service_items: self.assertIsInstance(item, Service)
# You should have received a copy of the GNU Affero General Public License # along with (AlignakApp). If not, see <http://www.gnu.org/licenses/>. import sys import unittest2 from PyQt5.Qt import QApplication, QWidget, QLabel, QSize from alignak_app.backend.datamanager import data_manager from alignak_app.items.history import History from alignak_app.utils.config import settings from alignak_app.locales.locales import init_localization from alignak_app.qobjects.host.history import HistoryQWidget settings.init_config() init_localization() class TestHistoryQWidget(unittest2.TestCase): """ This file test the HistoryQWidget class. """ history_data_test = [ { '_updated': 'Tue, 19 Sep 2017 13:07:16 GMT', 'service_name': 'Load', 'type': 'ack.processed', 'message': 'Service Load acknowledged by admin, from Alignak-app', },
class TestStatusQDialog(unittest2.TestCase): """ This file test methods of StatusQDialog class object """ settings.init_config() init_localization() daemons_list = [] for i in range(0, 10): daemon = Daemon() daemon.create( '_id%d' % i, { 'name': 'daemon%d' % i, 'alive': True, 'address': '127.0.0.%d' % i, 'port': '700%d' % i, 'reachable': True, 'spare': True, 'passive': True, 'last_check': 100000 }, 'daemon%d' % i ) daemons_list.append(daemon) @classmethod def setUpClass(cls): """Create QApplication""" try: cls.app = QApplication(sys.argv) except: pass def test_initialize_status_qdialog(self): """Initialize StatusQDialog""" under_test = StatusQDialog() self.assertIsNotNone(under_test.daemons_layout) self.assertFalse(under_test.labels) under_test.initialize() def test_set_daemons_labels(self): """Set Daemons QLabels""" under_test = StatusQDialog() labels_test = [ 'alive', 'name', 'reachable', 'spare', 'address', 'passive', 'last_check' ] daemon_test = Daemon() daemon_test.create( '_id1', { 'alive': True }, 'daemon-name' ) under_test.init_daemons_labels([daemon_test]) self.assertTrue('daemon-name' in under_test.labels) for lbl_test in labels_test: self.assertTrue(lbl_test in under_test.labels['daemon-name']) def test_add_daemon_titles_labels(self): """Add Daemon QLabels""" under_test = StatusQDialog() daemon_test = Daemon() daemon_test.create( '_id1', { 'alive': True }, 'daemon-name' ) under_test.init_daemons_labels([daemon_test]) under_test.add_daemon_labels(daemon_test, 2) self.assertEqual(QSize(18, 18), under_test.labels['daemon-name']['alive'].size()) self.assertEqual(QSize(14, 14), under_test.labels['daemon-name']['reachable'].size()) self.assertEqual(QSize(14, 14), under_test.labels['daemon-name']['spare'].size()) self.assertEqual(QSize(14, 14), under_test.labels['daemon-name']['passive'].size()) def test_update_dialog(self): """Update Status QDialog""" # Fill databse with sample daemons data_manager.update_database('alignakdaemon', self.daemons_list) # Init widget under_test = StatusQDialog() # Labels are empty self.assertFalse(under_test.labels) under_test.initialize() under_test.update_dialog() # Labels are filled i = 0 for daemon_labels in under_test.labels: self.assertTrue('daemon%d' % i in under_test.labels) i += 1 for label in under_test.labels[daemon_labels]: self.assertIsInstance(under_test.labels[daemon_labels][label], QLabel) daemon_labels = under_test.labels['daemon0'] self.assertEqual('127.0.0.0:7000', daemon_labels['address'].text()) def test_daemon_is_problem(self): """Daemon Is Problem""" test_time = time.time() daemon_test = Daemon() daemon_test.create( '_id', { 'last_check': test_time, 'alive': True }, 'name' ) under_test = StatusQDialog.daemon_is_problem(daemon_test) # Daemon is NOT a problem self.assertFalse(under_test) # Daemon is NOT alive, so IS a problem daemon_test.data['alive'] = False under_test = StatusQDialog.daemon_is_problem(daemon_test) self.assertTrue(under_test) # Daemon is alive but freshness expired, so IS a problme test_time_plus_15 = test_time + 900 # 900sec == 15 min daemon_test.data['alive'] = True daemon_test.data['last_check'] = test_time_plus_15 under_test = StatusQDialog.daemon_is_problem(daemon_test) self.assertTrue(under_test)
class TestAppBackend(unittest2.TestCase): """ This file test methods of AppBackend class """ # Init config for all methods. settings.init_config() host_id = '59c4e40635d17b8e0c6accae' hostname = 'cogny' def test_log_to_backend(self): """Connection to Alignak-Backend""" under_test = BackendClient() connect = under_test.login(settings.get_config('Alignak', 'username'), settings.get_config('Alignak', 'password')) # Compare config url and app_backend self.assertEquals(under_test.backend.url_endpoint_root, settings.get_config('Alignak', 'backend')) self.assertTrue(under_test.connected) self.assertTrue(under_test.backend.authenticated) self.assertTrue(connect) # Assert on second connection, backend use token ! connect = under_test.login() self.assertTrue(connect) def test_get_endpoint_with_params_and_projection(self): """Backend GET""" backend_test = BackendClient() backend_test.login(settings.get_config('Alignak', 'username'), settings.get_config('Alignak', 'password')) # Get hosts states test_projection = ['name', 'alias'] test_params = {'where': json.dumps({'_is_template': False})} under_test = backend_test.get('host', params=test_params, projection=test_projection) self.assertTrue(under_test) self.assertTrue(under_test['_items']) self.assertTrue('name' in under_test['_items'][0]) self.assertTrue('alias' in under_test['_items'][0]) def test_patch(self): """PATCH User Notes""" under_test = BackendClient() under_test.login(settings.get_config('Alignak', 'username'), settings.get_config('Alignak', 'password')) users = under_test.get('user') user = users['_items'][0] notes = 'Unit Test from Alignak-app' data = {'notes': notes} headers = {'If-Match': user['_etag']} endpoint = '/'.join(['user', user['_id']]) patched = under_test.patch(endpoint, data, headers) self.assertTrue(patched) user_modified = under_test.get('/'.join(['user', user['_id']])) self.assertEqual(user_modified['notes'], notes) back_patched = under_test.patch(endpoint, data={'notes': ''}, headers=headers) self.assertTrue(back_patched) user_modified = under_test.get('/'.join(['user', user['_id']])) self.assertNotEqual(user_modified['notes'], notes) self.assertEqual(user_modified['notes'], '') def test_query_realms_data(self): """Query Realms Data""" under_test = BackendClient() under_test.login(settings.get_config('Alignak', 'username'), settings.get_config('Alignak', 'password')) from alignak_app.backend.datamanager import data_manager under_test.query_realms() self.assertIsNotNone(data_manager.database['realm']) self.assertTrue(data_manager.db_is_ready['realm']) def test_query_period_data(self): """Query TimePeriod Data""" under_test = BackendClient() under_test.login(settings.get_config('Alignak', 'username'), settings.get_config('Alignak', 'password')) from alignak_app.backend.datamanager import data_manager under_test.query_timeperiods() self.assertIsNotNone(data_manager.database['timeperiod']) self.assertTrue(data_manager.db_is_ready['timeperiod']) def test_query_user_data(self): """Query User Data""" under_test = BackendClient() under_test.login(settings.get_config('Alignak', 'username'), settings.get_config('Alignak', 'password')) from alignak_app.backend.datamanager import data_manager under_test.query_user() self.assertIsNotNone(data_manager.database['user']) self.assertTrue(data_manager.db_is_ready['user']) def test_query_hosts_data(self): """Query Host Data""" under_test = BackendClient() under_test.login(settings.get_config('Alignak', 'username'), settings.get_config('Alignak', 'password')) from alignak_app.backend.datamanager import data_manager under_test.query_hosts() self.assertIsNotNone(data_manager.database['host']) self.assertTrue(data_manager.db_is_ready['host']) self.assertTrue(data_manager.db_is_ready['problems']['host']) def test_query_services_data(self): """Query Services Data""" under_test = BackendClient() under_test.login(settings.get_config('Alignak', 'username'), settings.get_config('Alignak', 'password')) from alignak_app.backend.datamanager import data_manager under_test.query_services() self.assertIsNotNone(data_manager.database['service']) self.assertTrue(data_manager.db_is_ready['service']) def test_query_problems(self): """Query Problems Data""" under_test = BackendClient() under_test.login(settings.get_config('Alignak', 'username'), settings.get_config('Alignak', 'password')) from alignak_app.backend.datamanager import data_manager under_test.query_services_problems('WARNING') self.assertIsNotNone(data_manager.database['problems']) self.assertTrue(data_manager.db_is_ready['problems']['WARNING']) under_test.query_services_problems('UNKNOWN') self.assertTrue(data_manager.db_is_ready['problems']['UNKNOWN']) def test_query_daemons_data(self): """Query Daemons Data""" under_test = BackendClient() under_test.login(settings.get_config('Alignak', 'username'), settings.get_config('Alignak', 'password')) from alignak_app.backend.datamanager import data_manager under_test.query_alignakdaemons() self.assertIsNotNone(data_manager.database['alignakdaemon']) self.assertTrue(data_manager.db_is_ready['alignakdaemon']) def test_query_livesynthesis_data(self): """Query Live Synthesis Data""" under_test = BackendClient() under_test.login(settings.get_config('Alignak', 'username'), settings.get_config('Alignak', 'password')) from alignak_app.backend.datamanager import data_manager under_test.query_livesynthesis() self.assertIsNotNone(data_manager.database['livesynthesis']) self.assertTrue(data_manager.db_is_ready['livesynthesis']) def test_query_history_data(self): """Query History Data""" under_test = BackendClient() under_test.login(settings.get_config('Alignak', 'username'), settings.get_config('Alignak', 'password')) from alignak_app.backend.datamanager import data_manager under_test.query_history(self.hostname, self.host_id) self.assertIsNotNone(data_manager.database['history']) old_database = data_manager.database['history'] under_test.query_history() self.assertIsNotNone(data_manager.database['history']) # Assert that old history item has the same properties that the new one self.assertTrue(old_database != data_manager.database['history']) self.assertEqual(old_database[0].name, data_manager.database['history'][0].name) self.assertEqual(old_database[0].item_id, data_manager.database['history'][0].item_id) self.assertEqual(old_database[0].item_id, self.host_id) def test_get_backend_status_icon(self): """Get Backend Status Icon Name""" backend_test = BackendClient() under_test = backend_test.get_backend_status_icon() self.assertEqual('disconnected', under_test) backend_test.login(settings.get_config('Alignak', 'username'), settings.get_config('Alignak', 'password')) under_test = backend_test.get_backend_status_icon() self.assertEqual('connected', under_test)
class TestProxyQDialog(unittest2.TestCase): """ This file test methods of ProxyQDialog class object """ settings.init_config() init_localization() app_backend.login() @classmethod def setUpClass(cls): """Create QApplication""" try: cls.app = QApplication(sys.argv) except: pass def test_initialize_proxy_dialog(self): """Initialize ProxyQDialog""" under_test = ProxyQDialog() self.assertEqual('dialog', under_test.objectName()) self.assertIsNotNone(under_test.proxy_address) self.assertIsInstance(under_test.proxy_address, QLineEdit) self.assertIsNotNone(under_test.proxy_user) self.assertIsInstance(under_test.proxy_user, QLineEdit) self.assertIsNotNone(under_test.proxy_password) self.assertIsInstance(under_test.proxy_password, QLineEdit) self.assertIsNone(under_test.offset) under_test.initialize_dialog() self.assertEqual('dialog', under_test.objectName()) self.assertIsNotNone(under_test.proxy_address) self.assertIsInstance(under_test.proxy_address, QLineEdit) self.assertIsNotNone(under_test.proxy_user) self.assertIsInstance(under_test.proxy_user, QLineEdit) self.assertIsNotNone(under_test.proxy_password) self.assertIsInstance(under_test.proxy_password, QLineEdit) self.assertEqual(QLineEdit.Password, under_test.proxy_password.echoMode()) self.assertIsNone(under_test.offset) def test_get_proxy_widget(self): """Get Proxy QWidget""" under_test = ProxyQDialog() self.assertIsInstance(under_test.get_proxy_widget(), QWidget) def test_accept_proxy(self): """Accept Proxy QDialog""" under_test = ProxyQDialog() under_test.initialize_dialog() timer = QTimer() timer.timeout.connect(under_test.accept_proxy) timer.start(0.5) # When all proxy settings are empties, dialog Accepted self.assertTrue(ProxyQDialog.Accepted == under_test.exec()) # Proxy address is set, dialog Accepted under_test.proxy_address.setText('http://127.0.0.1:8000') timer.start(0.5) self.assertTrue(ProxyQDialog.Accepted == under_test.exec())
class TestAlignakQWidget(unittest2.TestCase): """ This file test methods of AlignakQWidget class object """ settings.init_config() init_localization() app_backend.login() # User data test user = User() user_keys = User.get_request_model('test')['projection'] user_data_test = {} for key in user_keys: if 'host_notifications_enabled' in key or 'service_notifications_enabled' in key: user_data_test[key] = True else: user_data_test[key] = 'test' user.create('_id', user_data_test, 'admin') @classmethod def setUpClass(cls): """Create QApplication""" try: cls.app = QApplication(sys.argv) except: pass def test_initialize_alignak_qwidget(self): """Initialize AlignakQWidget""" under_test = AlignakQWidget() self.assertIsNotNone(under_test.backend_connected) self.assertIsNotNone(under_test.status_btn) self.assertIsNotNone(under_test.status_dialog) self.assertIsNotNone(under_test.profile_btn) self.assertIsNotNone(under_test.profile_widget) self.assertFalse(under_test.refresh_timer.isActive()) self.assertIsInstance(under_test, QWidget) data_manager.update_database('user', self.user) under_test.initialize() self.assertIsNotNone(under_test.backend_connected) self.assertIsNotNone(under_test.status_btn) self.assertFalse(under_test.status_btn.isEnabled()) self.assertIsNotNone(under_test.status_dialog) self.assertIsNotNone(under_test.profile_btn) self.assertIsNotNone(under_test.profile_widget) self.assertTrue(under_test.refresh_timer.isActive()) def test_update_status(self): """Update Alignak QWidget""" under_test = AlignakQWidget() under_test.initialize() self.assertFalse(under_test.status_btn.isEnabled()) daemon_test = Daemon() daemon_test.create( '_id1', { 'alive': True, 'address': '127.0.0.1', 'port': '8888', 'reachable': True, 'spare': True, 'passive': True, 'last_check': 123456789, }, 'arbiter' ) data_manager.update_database('alignakdaemon', [daemon_test]) under_test.update_status() # Status button is enabled when alignakdaemon is filled self.assertTrue(under_test.status_btn.isEnabled())
class TestTrayIcon(unittest2.TestCase): """ This file test the AppTrayIcon class. """ settings.init_config() init_localization() icon = QIcon(settings.get_image('icon')) data_manager.database['user'] = User() data_manager.database['user'].data = {} user_key = [ '_realm', 'is_admin', 'back_role_super_admin', 'alias', 'name', 'notes', 'email', 'can_submit_commands', 'token', 'host_notifications_enabled', 'service_notifications_enabled', 'host_notification_period', 'service_notification_period', 'host_notification_options', 'service_notification_options', ] @classmethod def setUpClass(cls): """Create QApplication""" try: cls.app = QApplication(sys.argv) except: pass def test_tray_icon(self): """Init TrayIcon and QMenu""" under_test = AppTrayIcon(self.icon) self.assertIsInstance(under_test.menu, QMenu) def test_app_action(self): """Add App QAction""" # Init Event QWidget and fill DataManager for AppQMainWindow init_event_widget() data_manager.database['host'] = [] data_manager.database['service'] = [] for key in self.user_key: if key == 'host_notifications_enabled' or key == 'service_notifications_enabled': data_manager.database['user'].data[key] = True else: data_manager.database['user'].data[key] = 'nothing' under_test = AppTrayIcon(self.icon) self.assertFalse(under_test.tray_actions['app'].text()) self.assertFalse(under_test.tray_actions['app'].toolTip()) under_test.add_alignak_menu() self.assertTrue(under_test.tray_actions['app'].text()) self.assertTrue(under_test.tray_actions['app'].toolTip()) def test_reload_action(self): """Add Reload QAction""" under_test = AppTrayIcon(self.icon) self.assertFalse(under_test.tray_actions['reload'].text()) self.assertFalse(under_test.tray_actions['reload'].toolTip()) under_test.add_reload_menu() self.assertTrue(under_test.tray_actions['reload'].text()) self.assertTrue(under_test.tray_actions['reload'].toolTip()) def test_about_action(self): """Add About QAction""" under_test = AppTrayIcon(self.icon) self.assertFalse(under_test.tray_actions['about'].text()) self.assertFalse(under_test.tray_actions['about'].toolTip()) under_test.add_about_menu() self.assertTrue(under_test.tray_actions['about'].text()) self.assertTrue(under_test.tray_actions['about'].toolTip()) def test_quit_action(self): """Add Quit QAction""" under_test = AppTrayIcon(self.icon) self.assertFalse(under_test.tray_actions['exit'].text()) self.assertFalse(under_test.tray_actions['exit'].toolTip()) under_test.add_quit_menu() self.assertTrue(under_test.tray_actions['exit'].text()) self.assertTrue(under_test.tray_actions['exit'].toolTip()) def test_build_menu(self): """Build Menu add QActions""" # Init Event QWidget and fill DataManager for AppQMainWindow init_event_widget() data_manager.database['host'] = [] data_manager.database['service'] = [] for key in self.user_key: if key == 'host_notifications_enabled' or key == 'service_notifications_enabled': data_manager.database['user'].data[key] = True else: data_manager.database['user'].data[key] = 'nothing' under_test = AppTrayIcon(self.icon) # Assert no actions in Menu self.assertFalse(under_test.menu.actions()) self.assertIsNotNone(under_test.app_about) self.assertIsNotNone(under_test.tray_actions) self.assertEqual(under_test.connection_nb, 3) under_test.build_menu() # Assert actions are added in Menu self.assertTrue(under_test.menu.actions()) self.assertIsNotNone(under_test.app_about) self.assertIsNotNone(under_test.tray_actions) self.assertEqual(under_test.connection_nb, 3) def test_check_connection(self): """Tray Icon Check Connection""" under_test = AppTrayIcon(self.icon) from alignak_app.backend.backend import app_backend self.assertEqual(3, under_test.connection_nb) app_backend.connected = False # If App backend is not connected, "connection_nb" decrease under_test.check_connection() self.assertEqual(2, under_test.connection_nb) under_test.check_connection() self.assertEqual(1, under_test.connection_nb) under_test.check_connection() self.assertEqual(0, under_test.connection_nb) # If App still not connected, "connection_nb" is reset to 3 under_test.check_connection() self.assertEqual(3, under_test.connection_nb) # If App backend back to connected, "connection_nb" is reset to 3 under_test.connection_nb = 0 app_backend.connected = True under_test.check_connection() self.assertEqual(3, under_test.connection_nb) # If App backend is connected, "connection_nb stay" at 3 under_test.check_connection() self.assertEqual(3, under_test.connection_nb) def test_refresh_menus(self): """Refresh TrayIcon Menus""" under_test = AppTrayIcon(self.icon) # Webui is True self.assertTrue(under_test.tray_actions['webui'].isEnabled()) old_webui = settings.get_config('Alignak', 'webui') settings.set_config('Alignak', 'webui', '') under_test.refresh_menus() # When refresh menu and WebUI is "False", QAction is not Enabled self.assertFalse(under_test.tray_actions['webui'].isEnabled()) # Change settings does not update QAction settings.set_config('Alignak', 'webui', old_webui) self.assertFalse(under_test.tray_actions['webui'].isEnabled()) under_test.refresh_menus() self.assertTrue(under_test.tray_actions['webui'].isEnabled())
class TestLoginQDialog(unittest2.TestCase): """ This file test the LoginQDialog class. """ settings.init_config() @classmethod def setUpClass(cls): """Create QApplication""" try: cls.app = QApplication(sys.argv) except: pass def test_initialize_login_dialog(self): """Initialize LoginQDialog""" under_test = LoginQDialog() self.assertIsInstance(under_test.username_line, QLineEdit) self.assertIsInstance(under_test.password_line, QLineEdit) self.assertFalse(under_test.proxies) self.assertIsNone(under_test.offset) under_test.create_widget() self.assertFalse(under_test.proxies) self.assertIsNone(under_test.offset) def test_accept_login(self): """QDialog Accept Login""" under_test = LoginQDialog() under_test.create_widget() timer = QTimer() timer.timeout.connect(under_test.accept_login) timer.start(0.5) # If login failed, Rejected self.assertEqual(LoginQDialog.Rejected, under_test.exec()) # Set username and password for login under_test.username_line.setText('admin') under_test.password_line.setText('admin') timer.start(0.5) self.assertEqual(LoginQDialog.Accepted, under_test.exec()) def test_set_proxy_settings(self): """LoginQDialog Set Proxy Settings""" under_test = LoginQDialog() under_test.create_widget() # Set Proxy address self.assertFalse(under_test.proxies) settings.set_config('Alignak', 'proxy', 'http://127.0.0.1:5000') under_test.set_proxy_settings() # Proxy is set in "proxies" QDialog self.assertEqual({'http': 'http://127.0.0.1:5000'}, under_test.proxies) # Set user Proxy settings.set_config('Alignak', 'proxy_user', 'user') # Give password in parameter under_test.set_proxy_settings('password') # Proxy user and password are set in "proxies" QDialog self.assertEqual({'http': 'http://*****:*****@127.0.0.1:5000'}, under_test.proxies) # Back settings for other tests settings.set_config('Alignak', 'proxy', '') settings.set_config('Alignak', 'proxy_user', '') settings.set_config('Alignak', 'proxy_password', '') under_test.set_proxy_settings() # QDialog "proxies" is empty (False) self.assertFalse(under_test.proxies)
class TestAllItems(unittest2.TestCase): """ This file test methods of ItemModel class objects """ settings.init_config() init_localization() app_backend.login() # Host data test host_list = [] for i in range(0, 10): host = Host() host.create( '_id%d' % i, { 'name': 'host%d' % i, 'ls_downtimed': True, 'ls_acknowledged': True, 'ls_state': 'UNKNOWN', '_overall_state_id': 4, 'passive_checks_enabled': False, 'active_checks_enabled': True }, 'host%d' % i) host_list.append(host) # Service data test service_list = [] for i in range(0, 10): service = Service() service.create( '_id%d' % i, { 'name': 'service%d' % i, 'alias': 'Service %d' % i, 'host': '_id%d' % i, 'ls_acknowledged': False, 'ls_downtimed': False, 'ls_state': 'CRITICAL', 'aggregation': 'disk', '_overall_state_id': 4, 'passive_checks_enabled': False, 'active_checks_enabled': True }, 'service%d' % i) service_list.append(service) def test_item_model(self): """Create ItemModel""" under_test = Item() under_test.create('_id', {'ls_state': 'DOWN'}, 'name') self.assertTrue('_id' == under_test.item_id) self.assertTrue('ls_state' in under_test.data) self.assertTrue('DOWN' == under_test.data['ls_state']) self.assertTrue('name' == under_test.name) def test_item_model_get_data(self): """Get Data ItemModel""" under_test = Item() under_test.create('_id', { 'ls_state': 'DOWN', 'ls_acknowledged': True }, 'name') data_test = under_test.data['ls_state'] self.assertTrue('DOWN' == data_test) def test_item_model_update_data(self): """Update Data ItemModel""" under_test = Item() under_test.create('_id', { 'ls_state': 'DOWN', 'ls_acknowledged': True }, 'name') under_test.update_data('ls_acknowledged', False) data_test = under_test.data['ls_acknowledged'] self.assertTrue(data_test is False) def test_get_icon_name(self): """Get Icon Name""" under_test = get_icon_name('host', 'UP', acknowledge=False, downtime=False, monitored=1) self.assertEqual('hosts_up', under_test) under_test = get_icon_name('service', 'WARNING', acknowledge=False, downtime=False, monitored=1) self.assertEqual('services_warning', under_test) under_test = get_icon_name('host', 'DOWN', acknowledge=True, downtime=False, monitored=1) self.assertEqual('acknowledge', under_test) under_test = get_icon_name('service', 'UNREACHABLE', acknowledge=True, downtime=True, monitored=2) self.assertEqual('downtime', under_test) under_test = get_icon_name('host', 'WRONG_STATUS', acknowledge=False, downtime=False, monitored=1) self.assertEqual('error', under_test) under_test = get_icon_name('host', 'UP', acknowledge=False, downtime=False, monitored=False + False) self.assertEqual('hosts_not_monitored', under_test) def test_get_icon_name_from_state(self): """Get Icon Name from State""" under_test = get_icon_name_from_state('host', 'UP') self.assertEqual('hosts_up', under_test) under_test = get_icon_name_from_state('service', 'CRITICAL') self.assertEqual('services_critical', under_test) under_test = get_icon_name_from_state('host', 'ACKNOWLEDGE') self.assertEqual('acknowledge', under_test) under_test = get_icon_name_from_state('service', 'DOWNTIME') self.assertEqual('downtime', under_test) def test_get_real_host_state_icon(self): """Get Real Host State Icon""" # Service data test services_test = [] for i in range(0, 5): service = Service() service.create('_id%d' % i, { 'name': 'service%d' % i, '_overall_state_id': i }, 'service%d' % i) services_test.append(service) service = Service() service.create('other_id2%d' % i, { 'name': 'other_service2%d' % i, '_overall_state_id': i }, 'other_service%d' % i) services_test.append(service) under_test = get_overall_state_icon(services_test, 0) self.assertEqual('all_services_critical', under_test) # Overall state id of 10 does not exist under_test = get_overall_state_icon([], 10) self.assertEqual('all_services_none', under_test) def test_get_request_history_model(self): """Get History Request Model""" under_test = History.get_request_model() self.assertTrue('endpoint' in under_test) self.assertEqual('history', under_test['endpoint']) self.assertTrue('params' in under_test) self.assertTrue('projection' in under_test) def test_get_history_icon_name_from_message(self): """Get History Icon from State""" under_test = History.get_history_icon_name('UNKNOWN', 'downtime') self.assertEqual('downtime', under_test) under_test = History.get_history_icon_name('UP', 'ack') self.assertEqual('acknowledge', under_test) under_test = History.get_history_icon_name('UP', 'event_type') self.assertEqual('hosts_up', under_test) under_test = History.get_history_icon_name('DOWN', 'event_type') self.assertEqual('hosts_down', under_test) under_test = History.get_history_icon_name('UNREACHABLE', 'event_type') self.assertEqual('services_unreachable', under_test) under_test = History.get_history_icon_name('OK', 'event_type') self.assertEqual('services_ok', under_test) under_test = History.get_history_icon_name('WARNING', 'event_type') self.assertEqual('services_warning', under_test) under_test = History.get_history_icon_name('CRITICAL', 'event_type') self.assertEqual('services_critical', under_test) under_test = History.get_history_icon_name('UNKNOWN', 'event_type') self.assertEqual('services_unknown', under_test) under_test = History.get_history_icon_name('error', 'event_type') self.assertEqual('error', under_test) def test_get_request_user_model(self): """Get User Request Model""" under_test = User.get_request_model('') self.assertTrue('endpoint' in under_test) self.assertEqual('user', under_test['endpoint']) self.assertTrue('params' in under_test) self.assertTrue('projection' in under_test) def test_get_user_role(self): """Get User Role""" # User case user_test = User() user_test.create( '_id', { 'is_admin': False, 'can_submit_commands': False, 'back_role_super_admin': False }, 'name') under_test = user_test.get_role() self.assertEqual('user', under_test) # Administrator case user_test = User() user_test.create( '_id', { 'is_admin': True, 'can_submit_commands': False, 'back_role_super_admin': False }, 'name') under_test = user_test.get_role() self.assertEqual('administrator', under_test) # Power case user_test = User() user_test.create( '_id', { 'is_admin': False, 'can_submit_commands': True, 'back_role_super_admin': False }, 'name') under_test = user_test.get_role() self.assertEqual('power', under_test) def test_get_request_host_model(self): """Get Host Request Model""" under_test = Host.get_request_model() self.assertTrue('endpoint' in under_test) self.assertEqual('host', under_test['endpoint']) self.assertTrue('params' in under_test) self.assertTrue('projection' in under_test) def test_get_overall_tooltip(self): """Get Overall Tooltip of Host""" under_test = Host() under_test.create( '_id1', { '_overall_state_id': 1, 'ls_state': 'DOWN', 'ls_downtimed': True, 'ls_acknowledged': False, 'active_checks_enabled': True, 'passive_checks_enabled': False, }, 'hostname') tooltip_test = under_test.get_overall_tooltip([]) self.assertEqual('Hostname is DOWN but downtimed, no services...', tooltip_test) def test_get_request_service_model(self): """Get Service Request Model""" under_test = Service.get_request_model() self.assertTrue('endpoint' in under_test) self.assertEqual('service', under_test['endpoint']) self.assertTrue('params' in under_test) self.assertTrue('projection' in under_test) def test_get_request_daemon_model(self): """Get Daemon Request Model""" under_test = Daemon.get_request_model() self.assertTrue('endpoint' in under_test) self.assertEqual('alignakdaemon', under_test['endpoint']) self.assertTrue('params' in under_test) self.assertTrue('projection' in under_test) def test_get_daemons_names(self): """Get All Daemon Names""" daemon_names = [ 'poller', 'receiver', 'reactionner', 'arbiter', 'scheduler', 'broker' ] self.assertEqual(daemon_names, Daemon.get_daemons_names()) def test_get_request_event_model(self): """Get Event Request Model""" under_test = Event.get_request_model() self.assertTrue('endpoint' in under_test) self.assertEqual('history', under_test['endpoint']) self.assertTrue('params' in under_test) self.assertTrue('projection' in under_test) def test_get_request_livesynthesis_model(self): """Get LiveSynthesis Request Model""" under_test = LiveSynthesis.get_request_model() self.assertTrue('endpoint' in under_test) self.assertEqual('livesynthesis', under_test['endpoint']) self.assertTrue('params' in under_test) self.assertTrue('projection' in under_test) def get_request_realm_model(self): """get Realm Request Model""" under_test = Realm.get_request_model() self.assertTrue('endpoint' in under_test) self.assertEqual('realm', under_test['endpoint']) self.assertTrue('params' in under_test) self.assertTrue('projection' in under_test)
class TestMessageQDialog(unittest2.TestCase): """ This file test methods of MessageQDialog class object """ settings.init_config() init_localization() @classmethod def setUpClass(cls): """Create QApplication""" try: cls.app = QApplication(sys.argv) except: pass def test_initialize_msg_dialog(self): """Initialize MessageQDialog""" under_test = MessageQDialog() self.assertIsNone(under_test.layout()) self.assertEqual('dialog', under_test.objectName()) under_test.initialize( 'widgettitle', 'text', 'title', 'Text to display' ) self.assertIsNotNone(under_test.layout()) self.assertEqual('dialog', under_test.objectName()) def test_get_message_widget(self): """Get Message QWidget""" msg_dialog_test = MessageQDialog() self.assertEqual('dialog', msg_dialog_test.objectName()) under_test = msg_dialog_test.get_message_widget( 'text', 'title', 'Text to display' ) self.assertIsNotNone(under_test.layout()) self.assertEqual('dialog', under_test.objectName()) self.assertIsInstance(under_test, QWidget) def test_initialize_edit_dialog(self): """Initialize EditQDialog""" under_test = EditQDialog() self.assertFalse(under_test.old_text) self.assertIsNotNone(under_test.text_edit) under_test.initialize('title', 'text to edit') self.assertEqual('text to edit', under_test.old_text) self.assertEqual('text to edit', under_test.text_edit.toPlainText()) def test_get_text_widget(self): """Get Text QWidget""" under_test = EditQDialog() under_test.old_text = 'old text' text_widget_test = under_test.get_text_widget() self.assertIsInstance(text_widget_test, QWidget) self.assertEqual('old text', under_test.text_edit.toPlainText()) def test_edit_dialog_accept_text(self): """EditQDialog Accept Text""" under_test = EditQDialog() under_test.initialize('title', 'text to edit') under_test.text_edit.setText('text to edit') timer = QTimer() timer.timeout.connect(under_test.accept_text) timer.start(0.5) # Text is same so refused self.assertEqual(EditQDialog.Rejected, under_test.exec()) under_test.text_edit.setText('text have been edited') timer.start(0.5) # Accepted because text have changed self.assertEqual(EditQDialog.Accepted, under_test.exec()) # Reset text to empty and spaces under_test.old_text = '' under_test.text_edit.setText(' ') timer.start(0.5) # Rejected because there is nothing to change self.assertEqual(EditQDialog.Rejected, under_test.exec()) under_test.old_text = '' under_test.text_edit.setText('New text') timer.start(0.5) # Accepted even if old text is empty self.assertEqual(EditQDialog.Accepted, under_test.exec()) def test_initialize_validator_dialog(self): """Initialize ValidatorQDialog""" under_test = ValidatorQDialog() self.assertTrue(under_test.line_edit) self.assertTrue(under_test.valid_text) self.assertTrue(under_test.validator) self.assertFalse(under_test.old_text) under_test.initialize('title', 'text', '[a-z]') self.assertTrue(under_test.line_edit) self.assertTrue(under_test.valid_text) self.assertTrue(under_test.validator) self.assertTrue(under_test.old_text) def testvalidator_dialog_check_state(self): """Check State ValidatorQDialog""" under_test = ValidatorQDialog() under_test.initialize( 'title', '', r"(^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-]+.+$)" ) self.assertEqual('', under_test.valid_text.text()) self.assertEqual('', under_test.line_edit.text()) self.assertEqual('', under_test.old_text) under_test.check_text() self.assertEqual('Invalid email !', under_test.valid_text.text()) self.assertEqual('', under_test.line_edit.text()) self.assertEqual('', under_test.old_text) under_test.line_edit.setText('*****@*****.**') under_test.check_text() self.assertEqual('Valid email', under_test.valid_text.text()) self.assertEqual('*****@*****.**', under_test.line_edit.text())
def start(self, username=None, password=None): """ Start Alignak-app """ settings.init_config() settings.init_css() init_localization() # Logger global logger # pylint: disable=global-statement logger = create_logger() logger.name = 'alignak_app.app' if settings.get_config('Log', 'debug', boolean=True): logger.setLevel(DEBUG) else: logger.setLevel(INFO) logger.info('\n') logger.info('----- Alignak-App START -----') logger.info('- Running Version : "%s"', __version__) logger.info('- Alignak-App Env :') logger.info('[ALIGNAKAPP_APP_DIR] = %s', os.environ['ALIGNAKAPP_APP_DIR']) logger.info('[ALIGNAKAPP_USR_DIR] = %s', os.environ['ALIGNAKAPP_USR_DIR']) logger.info('[ALIGNAKAPP_LOG_DIR] = %s', os.environ['ALIGNAKAPP_LOG_DIR']) logger.info('- Config File : %s', settings.settings['settings']) logger.info('- Debug Activate : %s', settings.get_config('Log', 'debug', boolean=True)) logger.info('- Alignak Backend : %s', settings.get_config('Alignak', 'backend')) app = QApplication(sys.argv) app.setQuitOnLastWindowClosed(False) # Connection to Backend proxies = None if settings.get_config('Alignak', 'username') and not username and not password: username = settings.get_config('Alignak', 'username') password = settings.get_config('Alignak', 'password') if settings.get_config('Alignak', 'proxy'): try: # Model is: {'protocol': 'http://proxy:port'} proxies = { settings.get_config('Alignak', 'proxy').split(':')[0]: settings.get_config('Alignak', 'proxy') } except ValueError: self.show_login_window() # If Proxy user, display login window to let user enter password if settings.get_config('Alignak', 'proxy_user') and \ not settings.get_config('Alignak', 'proxy_password'): self.show_login_window() # Try login else display login window logger.info('- Proxy settings : %s', proxies) if not app_backend.login(username, password, proxies=proxies): self.show_login_window() # Create Progress Bar app_progress = AppProgressQWidget() app_progress.initialize() center_widget(app_progress) logger.info("Preparing DataManager...") while not data_manager.ready: thread_manager.launch_threads() app_progress.show() for _ in range(0, 100): t = time.time() while time.time() < t + 0.01: status = data_manager.is_ready() app_progress.progress_bar.set_text('%s' % status) app.processEvents() app_progress.close() init_event_widget() requests_interval = int( settings.get_config('Alignak-app', 'requests_interval')) * 1000 self.threadmanager_timer.setInterval(requests_interval) self.threadmanager_timer.start() self.threadmanager_timer.timeout.connect(self.check_threads) self.tray_icon = AppTrayIcon(QIcon(settings.get_image('icon'))) self.tray_icon.build_menu() self.tray_icon.show() sys.exit(app.exec_())
# along with (AlignakApp). If not, see <http://www.gnu.org/licenses/>. import sys import unittest2 from PyQt5.Qt import QApplication, Qt from alignak_app.backend.datamanager import data_manager from alignak_app.items.host import Host from alignak_app.items.service import Service from alignak_app.items.user import User from alignak_app.utils.config import settings from alignak_app.locales.locales import init_localization settings.init_config() init_localization() app = QApplication(sys.argv) user = User() user.create('_id', {'name': 'name'}, 'name') data_manager.database['user'] = user from alignak_app.backend.datamanager import data_manager from alignak_app.qobjects.service.services import ServicesQWidget class TestServicesQWidget(unittest2.TestCase): """ This file test methods of ServicesQWidget class object """
class TestLivestateQWidget(unittest2.TestCase): """ This file test the LivestateQWidget class. """ settings.init_config() init_localization() # Synthesis data test synthesis_data = [ { 'hosts_total': 2, 'hosts_unreachable_hard': 0, '_id': '59c4e40635d17b8e0c6accaf', '_etag': '809a1cf43eaf858de1ef48df38ced9bb5875a3c8', 'services_business_impact': 0, 'hosts_down_hard': 1, 'hosts_in_downtime': 0, 'services_unreachable_soft': 0, 'services_unreachable_hard': 8, 'services_warning_hard': 0, 'hosts_up_hard': 0, 'services_unknown_soft': 0, 'services_acknowledged': 4, 'services_ok_soft': 0, 'hosts_business_impact': 0, 'hosts_acknowledged': 1, '_realm': '59c4e40435d17b8e0c6acc60', '_created': 'Thu, 01 Jan 1970 00:00:00 GMT', 'hosts_unreachable_soft': 0, 'services_in_downtime': 0, '_updated': 'Thu, 01 Jan 1970 00:00:00 GMT', 'services_ok_hard': 1, 'services_total': 14, 'services_critical_soft': 0, 'services_warning_soft': 0, 'hosts_down_soft': 0, 'hosts_up_soft': 0, 'services_critical_hard': 0, 'hosts_flapping': 0, 'services_flapping': 0, 'services_unknown_hard': 1}, { 'hosts_total': 34, 'hosts_unreachable_hard': 0, '_id': '59c4e40635d17b8e0c6accb0', '_etag': '6999aaa6d1b8ebe867f2f6d55c01a7dc71330f73', 'services_business_impact': 0, 'hosts_down_hard': 7, 'hosts_in_downtime': 0, 'services_unreachable_soft': 0, 'services_unreachable_hard': 71, 'services_warning_hard': 3, 'hosts_up_hard': 39, 'services_unknown_soft': 0, 'services_acknowledged': 76, 'services_ok_soft': 0, 'hosts_business_impact': 0, 'hosts_acknowledged': 2, '_realm': '59c4e38535d17b8dcb0bed42', '_created': 'Thu, 01 Jan 1970 00:00:00 GMT', 'hosts_unreachable_soft': 0, 'services_in_downtime': 0, '_updated': 'Fri, 22 Sep 2017 10:20:54 GMT', 'services_ok_hard': 209, 'services_total': 404, 'services_critical_soft': 1, 'services_warning_soft': 0, 'hosts_down_soft': 0, 'hosts_up_soft': 0, 'services_critical_hard': 26, 'hosts_flapping': 0, 'services_flapping': 0, 'services_unknown_hard': 18} ] livesynth_list = [] for data in synthesis_data: livesynth = LiveSynthesis() livesynth.create(data['_id'], data) livesynth_list.append(livesynth) @classmethod def setUpClass(cls): """Create QApplication""" try: cls.app = QApplication(sys.argv) except Exception as e: print(e) pass def test_create_livestate_widget(self): """Inititalize LivestateQWidget""" under_test = LivestateQWidget() self.assertIsInstance(under_test.timer, QTimer) self.assertTrue('host' in under_test.labels) self.assertTrue('problem' in under_test.labels) self.assertTrue('service' in under_test.labels) for label_grp in under_test.labels: self.assertIsNone(under_test.labels[label_grp]) under_test.initialize() for label_grp in under_test.labels: self.assertTrue('problem' in under_test.labels[label_grp]) self.assertTrue('total' in under_test.labels[label_grp]) self.assertTrue('icon' in under_test.labels[label_grp]) def test_update_livestate_labels(self): """Update LivestateQWidget QLabels""" # No problems in datamanager from alignak_app.backend.datamanager import data_manager data_manager.database['livesynthesis'] = [] self.assertFalse(data_manager.database['livesynthesis']) under_test = LivestateQWidget() under_test.initialize() for label_grp in under_test.labels: self.assertEqual('ok', under_test.labels[label_grp]['problem'].objectName()) data_manager.update_database('livesynthesis', self.livesynth_list) under_test.update_labels() # QLabels for 'host' and 'service' should change to 'ko' for label_grp in under_test.labels: self.assertEqual('ko', under_test.labels[label_grp]['problem'].objectName())
class TestPanelQWidget(unittest2.TestCase): """ This file test the PanelQWidget class. """ settings.init_config() # Host data test host_list = [] for i in range(0, 10): host = Host() host.create( '_id%d' % i, { 'name': 'host%d' % i, 'alias': 'Host %d' % i, '_id': '_id%d' % i, 'ls_downtimed': False, 'ls_acknowledged': False, 'ls_state': 'UNREACHABLE', 'ls_output': 'output host %d' % i, 'ls_last_check': '', '_realm': '59c4e38535d17b8dcb0bed42', 'address': '127.0.0.1', 'business_impact': '2', 'notes': 'host notes', 'passive_checks_enabled': False, 'active_checks_enabled': True, '_overall_state_id': 1, 'customs': {} }, 'host%d' % i) host_list.append(host) # Service data test service_list = [] for i in range(0, 10): service = Service() service.create( '_id%d' % i, { 'name': 'service%d' % i, 'alias': 'Service %d' % i, 'host': '_id%d' % i, '_id': '_id%d' % i, 'ls_acknowledged': False, 'ls_downtimed': False, 'ls_state': 'CRITICAL', 'ls_output': 'output host %d' % i, 'aggregation': 'disk', '_overall_state_id': 4, 'passive_checks_enabled': False, 'active_checks_enabled': True, }, 'service%d' % i) service_list.append(service) @classmethod def setUpClass(cls): """Create QApplication""" try: cls.app = QApplication(sys.argv) except: pass def test_create_widget(self): """Inititalize PanelQWidget""" # Add problems data_manager.update_database('host', self.host_list) data_manager.database['problems'] = [] for item in self.host_list: data_manager.database['problems'].append(item) for item in self.service_list: data_manager.database['problems'].append(item) for item in self.host_list: assert 'host' in item.item_type under_test = PanelQWidget() self.assertIsNotNone(under_test.layout) self.assertIsNotNone(under_test.dashboard_widget) self.assertIsNotNone(under_test.synthesis_widget) self.assertIsNotNone(under_test.spy_widget) self.assertFalse(under_test.hostnames_list) under_test.initialize() self.assertIsNotNone(under_test.layout) self.assertIsNotNone(under_test.dashboard_widget) self.assertIsNotNone(under_test.synthesis_widget) self.assertIsNotNone(under_test.spy_widget) self.assertEqual([ 'host0', 'host1', 'host2', 'host3', 'host4', 'host5', 'host6', 'host7', 'host8', 'host9' ], under_test.hostnames_list) def test_spy_host(self): """Panel Add Spy Host""" # init_event_widget() under_test = PanelQWidget() under_test.initialize() # Host is not in hostname_list under_test.synthesis_widget.line_search.setText('no_host') under_test.spy_host() spy_index = under_test.get_tab_order().index('s') self.assertTrue( under_test.synthesis_widget.host_widget.spy_btn.isEnabled()) self.assertEqual('Spy Hosts', under_test.tab_widget.tabText(spy_index)) # Host Id is not added in spied_hosts of SpyQWidget.SpyQListWidget self.assertFalse( '_id0' in under_test.spy_widget.spy_list_widget.spied_hosts) def test_update_panels(self): """Update QTabPanel Problems""" data_manager.database['problems'] = [] data_manager.update_database('host', self.host_list) for item in self.host_list: data_manager.database['problems'].append(item) for item in self.service_list: data_manager.database['problems'].append(item) under_test = PanelQWidget() under_test.initialize() # 20 problems for CRITICAL services and UNREACHABLE hosts problems_index = under_test.get_tab_order().index('p') self.assertEqual('Problems (20)', under_test.tab_widget.tabText(problems_index)) # Remove a service from problems data_manager.database['problems'].remove(self.service_list[0]) under_test.tab_widget.widget(problems_index).update_problems_data() # There are only 9 services in CRITICAL condition self.assertEqual('Problems (19)', under_test.tab_widget.tabText(problems_index)) def test_display_host(self): """Display Host in Panel""" under_test = PanelQWidget() under_test.initialize() self.assertTrue( under_test.synthesis_widget.host_widget.spy_btn.isEnabled()) self.assertEqual( 'Host Synthesis', under_test.tab_widget.tabText( under_test.tab_widget.indexOf(under_test.synthesis_widget))) under_test.display_host() # Host is not spied, so button is enable self.assertTrue( under_test.synthesis_widget.host_widget.spy_btn.isEnabled()) # No customs, so button is not enabled self.assertTrue( under_test.synthesis_widget.host_widget.customs_btn.isEnabled()) # Host and Services Qwidgets are hidden self.assertTrue(under_test.synthesis_widget.host_widget.isHidden()) self.assertTrue(under_test.synthesis_widget.services_widget.isHidden()) # Hint QWidget is shown self.assertFalse(under_test.synthesis_widget.hint_widget.isHidden()) self.assertEqual( 'Host Synthesis', under_test.tab_widget.tabText( under_test.tab_widget.indexOf(under_test.synthesis_widget))) under_test.synthesis_widget.line_search.setText(self.host_list[0].name) under_test.display_host() # Host is not spied, so button is enable self.assertTrue( under_test.synthesis_widget.host_widget.spy_btn.isEnabled()) # No customs, so button is not enabled self.assertFalse( under_test.synthesis_widget.host_widget.customs_btn.isEnabled()) # Host and Services Qwidgets are displayed self.assertFalse(under_test.synthesis_widget.host_widget.isHidden()) self.assertFalse( under_test.synthesis_widget.services_widget.isHidden()) # Hint QWidget is hidden self.assertTrue(under_test.synthesis_widget.hint_widget.isHidden()) self.assertEqual( 'Host "Host 0"', under_test.tab_widget.tabText( under_test.tab_widget.indexOf(under_test.synthesis_widget))) def test_set_host_from_problems(self): """Set Host in Panel from Problems QWidget""" under_test = PanelQWidget() under_test.initialize() self.assertEqual('', under_test.synthesis_widget.line_search.text()) self.assertIsNone( under_test.problems_widget.get_current_user_role_item()) # Make an item as current in problems table under_test.problems_widget.problems_table.update_view( {'problems': [self.host_list[8]]}) index_test = under_test.problems_widget.problems_table.model().index( 0, 0) under_test.problems_widget.problems_table.selectionModel( ).setCurrentIndex(index_test, QItemSelectionModel.SelectCurrent) self.assertIsNotNone( under_test.problems_widget.get_current_user_role_item()) self.assertEqual('', under_test.synthesis_widget.line_search.text()) under_test.set_host_from_problems() # Host is set in line search self.assertEqual('host8', under_test.synthesis_widget.line_search.text())
class TestServiceTreeItem(unittest2.TestCase): """ This file test the ServiceTreeItem class. """ settings.init_config() service = Service() service.create( '_id_1', { '_id': '_id_1', 'name': 'service_1', 'host': '_id_1', 'ls_state': 'CRITICAL', 'ls_acknowledged': False, 'ls_downtimed': False, 'passive_checks_enabled': False, 'active_checks_enabled': True, }, 'service_1') @classmethod def setUpClass(cls): """Create QApplication""" try: cls.app = QApplication(sys.argv) except Exception as e: print(e) pass def test_create_livestate_widget(self): """Inititalize ServiceTreeItem""" under_test = ServiceTreeItem() self.assertFalse(under_test.service_id) self.assertFalse(under_test.service_item) under_test.initialize(self.service) self.assertEqual('_id_1', under_test.service_id) self.assertEqual('service_1', under_test.service_item.name) self.assertEqual(self.service.data, under_test.service_item.data) def test_update_item(self): """Update ServiceTreeItem""" under_test = ServiceTreeItem() under_test.initialize(self.service) self.assertEqual('Service_1', under_test.text(0)) self.assertEqual('service_1', under_test.service_item.name) # Update name of service and add to database self.service.name = 'service_2' self.service.data['name'] = 'service_2' data_manager.update_database('service', [self.service]) # Update ServiceTreeItem under_test.update_item() # Name of ServiceTreeItem should change, and Service() item also self.assertEqual('Service_2', under_test.text(0)) self.assertEqual('service_2', under_test.service_item.name)