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_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 init_localization(): # pragma: no cover """ Application localization :return: gettext translator method :rtype: method """ try: # Language message file lang_filename = os.path.join( os.path.abspath(os.path.dirname(__file__)), "LC_MESSAGES/%s.mo" % settings.get_config('Alignak-app', 'locale')) logger.info("Opening message file %s for locale %s", lang_filename, settings.get_config('Alignak-app', 'locale')) translation = GNUTranslations(open(lang_filename, "rb")) translation.install() _ = translation.gettext except IOError: logger.warning( "Locale not found. Using default language messages (English)") null_translation = NullTranslations() null_translation.install() _ = null_translation.gettext except Exception as e: # pragma: no cover - should not happen logger.error("Locale not found. Exception: %s", str(e)) null_translation = NullTranslations() null_translation.install() _ = null_translation.gettext return _
def test_actions_buttons_are_updated(self): """Actions Buttons are Updated""" under_test = ActionsQWidget() self.assertIsNone(under_test.item) host_test = Host() host_test.create( 'id_1', { 'ls_acknowledged': False, 'ls_downtimed': False, '_id': 'id_1', 'ls_state': 'DOWN' }, 'name' ) under_test.initialize(host_test) # Actions buttons are True by default self.assertTrue(under_test.acknowledge_btn.isEnabled()) self.assertTrue(under_test.downtime_btn.isEnabled()) self.assertIsNotNone(under_test.item) # Log to backend and fill datamanager app_backend.login( settings.get_config('Alignak', 'username'), settings.get_config('Alignak', 'password') ) data_manager.update_database('host', [host_test]) # Update widget under_test.update_widget() webservice_test = settings.get_config('Alignak', 'webservice') self.assertTrue(webservice_test) if app_backend.ws_client.auth: # WS is set but not available, so buttons are disabled self.assertTrue(under_test.acknowledge_btn.isEnabled()) self.assertTrue(under_test.downtime_btn.isEnabled()) else: # WS is set but not available, so buttons are disabled self.assertFalse(under_test.acknowledge_btn.isEnabled()) self.assertFalse(under_test.downtime_btn.isEnabled()) # remove WS settings.set_config('Alignak', 'webservice', '') under_test.update_widget() # Only downtime button is Enabled, because host is UP self.assertTrue(under_test.acknowledge_btn.isEnabled()) self.assertTrue(under_test.downtime_btn.isEnabled()) # Restore configurations settings.set_config('Alignak', 'webservice', webservice_test) app_backend.connected = False app_backend.user = {}
def test_actions_buttons_are_updated(self): """Actions Buttons are Updated""" under_test = ActionsQWidget() self.assertIsNone(under_test.item) host_test = Host() host_test.create( 'id_1', { 'ls_acknowledged': False, 'ls_downtimed': False, '_id': 'id_1', 'ls_state': 'DOWN' }, 'name') under_test.initialize(host_test) # Actions buttons are True by default self.assertTrue(under_test.acknowledge_btn.isEnabled()) self.assertTrue(under_test.downtime_btn.isEnabled()) self.assertIsNotNone(under_test.item) # Log to backend and fill datamanager app_backend.login(settings.get_config('Alignak', 'username'), settings.get_config('Alignak', 'password')) data_manager.update_database('host', [host_test]) # Update widget under_test.update_widget() webservice_test = settings.get_config('Alignak', 'webservice') self.assertTrue(webservice_test) if app_backend.ws_client.auth: # WS is set but not available, so buttons are disabled self.assertTrue(under_test.acknowledge_btn.isEnabled()) self.assertTrue(under_test.downtime_btn.isEnabled()) else: # WS is set but not available, so buttons are disabled self.assertFalse(under_test.acknowledge_btn.isEnabled()) self.assertFalse(under_test.downtime_btn.isEnabled()) # remove WS settings.set_config('Alignak', 'webservice', '') under_test.update_widget() # Only downtime button is Enabled, because host is UP self.assertTrue(under_test.acknowledge_btn.isEnabled()) self.assertTrue(under_test.downtime_btn.isEnabled()) # Restore configurations settings.set_config('Alignak', 'webservice', webservice_test) app_backend.connected = False app_backend.user = {}
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_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)
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_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_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_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)
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_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 daemon_is_problem(daemon_item): """ Check Daemon Refresh and if daemon is alive. Send a message if needed :param daemon_item: Daemon item :type daemon_item: alignak_app.items.daemon.Daemon :return: if daemon is a problem True, else False :rtype: bool """ is_problem = False actual_freshness = get_diff_since_last_timestamp( daemon_item.data['last_check'], 'minutes') freshness = settings.get_config('Alignak-app', 'daemons_freshness') if int(actual_freshness) > int(freshness): send_event( 'CRITICAL' if 'arbiter' in daemon_item.name else 'WARNING', _('Freshness expired for %s') % daemon_item.name, timer=True) is_problem = True logger.warning('Daemon freshness expired: %s(%dmn)', daemon_item.name, actual_freshness) if not daemon_item.data['alive']: send_event( 'CRITICAL' if 'arbiter' in daemon_item.name else 'WARNING', _('Daemon %s is dead !') % daemon_item.name, timer=True) logger.warning('Daemon %s is dead...', daemon_item.name) is_problem = True return is_problem
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 initialize(self, spy_widget): """ Initialize QWidget and set SpyQWidget :param spy_widget: instance of SpyQWidget to manage spy events :type spy_widget: alignak_app.qobjects.events.spy.SpyQWidget """ problem_layout = QVBoxLayout() problem_layout.setContentsMargins(5, 20, 5, 5) self.setLayout(problem_layout) self.spy_widget = spy_widget self.problems_title.setObjectName('title') problem_layout.addWidget(self.problems_title) problem_layout.addWidget(self.get_search_widget()) problem_layout.addWidget(self.get_btn_widget()) problem_layout.addWidget(self.problems_table) self.update_problems_data() update_problems = int(settings.get_config('Alignak-app', 'update_problems')) * 1000 self.refresh_timer.setInterval(update_problems) self.refresh_timer.start() self.refresh_timer.timeout.connect(self.update_problems_data)
def login(self, token): """ Login to Web Service. Used only to ensure that the user token is identical :param token: user's token of App :type token: str """ self.ws_backend = settings.get_config('Alignak', 'webservice') try: # WS login logger.info("Requesting Web Service authentication with token: %s", token) headers = {'Content-Type': 'application/json'} params = {'username': token, 'password': ''} response = requests.post( '/'.join([self.ws_backend, 'login']), json=params, headers=headers ) resp = response.json() if '_result' in resp: assert token == resp['_result'][0] self.token = token self.auth = requests.auth.HTTPBasicAuth(self.token, '') except (RequestsConnectionError, AssertionError) as exp: msg = 'Connection to Web Service on [%s] has failed' % \ '/'.join([self.ws_backend, 'login']) logger.warning(msg) logger.debug(exp)
def initialize(self, spy_widget): """ Initialize QWidget and set SpyQWidget :param spy_widget: instance of SpyQWidget to manage spy events :type spy_widget: alignak_app.qobjects.events.spy.SpyQWidget """ problem_layout = QVBoxLayout() problem_layout.setContentsMargins(5, 20, 5, 5) self.setLayout(problem_layout) self.spy_widget = spy_widget self.problems_title.setObjectName('title') problem_layout.addWidget(self.problems_title) problem_layout.addWidget(self.get_search_widget()) problem_layout.addWidget(self.get_btn_widget()) problem_layout.addWidget(self.problems_table) self.update_problems_data() update_problems = int( settings.get_config('Alignak-app', 'update_problems')) * 1000 self.refresh_timer.setInterval(update_problems) self.refresh_timer.start() self.refresh_timer.timeout.connect(self.update_problems_data)
def initialize(self): """ Initialize QWidget """ layout = QGridLayout() self.setLayout(layout) # Add Qwidgets layout.addWidget(self.get_host_icon_widget(), 0, 0, 2, 1) layout.addWidget(self.get_last_check_widget(), 0, 1, 1, 1) layout.addWidget(self.get_variables_widget(), 0, 2, 1, 1) layout.addWidget(self.get_notes_output_widget(), 1, 1, 1, 2) layout.addWidget(self.get_actions_widget(), 0, 3, 2, 1) update_host = int(settings.get_config('Alignak-app', 'update_host')) * 1000 self.refresh_timer.setInterval(update_host) self.refresh_timer.start() self.refresh_timer.timeout.connect(self.update_host)
def add_event(self, event_type, msg, timer=False, host=None): """ Add event to events list :param event_type: the type of event: OK, DOWN, ACK, ... :type event_type: str :param msg: message of event :type msg: str :param timer: timer to hide event at end of time :type timer: bool :param host: data of a host to set ``Qt.UserRole`` :type host: None | str """ if not self.event_exist(msg): logger.debug( 'Add Event: msg: %s, timer: %s, host: %s', msg, timer, host ) event = EventItem() event.initialize(event_type, msg, timer=timer, host=host) self.events_list.insertItem(0, event) if timer: event_duration = int( settings.get_config('Alignak-app', 'notification_duration') ) * 1000 QTimer.singleShot( event_duration, lambda: self.remove_timer_event(event) ) else: logger.debug( 'Event with msg: %s already exist.', msg )
def daemon_is_problem(daemon_item): """ Check Daemon Refresh and if daemon is alive. Send a message if needed :param daemon_item: Daemon item :type daemon_item: alignak_app.items.daemon.Daemon :return: if daemon is a problem True, else False :rtype: bool """ is_problem = False actual_freshness = get_diff_since_last_timestamp( daemon_item.data['last_check'], 'minutes' ) freshness = settings.get_config('Alignak-app', 'daemons_freshness') if int(actual_freshness) > int(freshness): send_event( 'CRITICAL' if 'arbiter' in daemon_item.name else 'WARNING', _('Freshness expired for %s') % daemon_item.name, timer=True ) is_problem = True logger.warning('Daemon freshness expired: %s(%dmn)', daemon_item.name, actual_freshness) if not daemon_item.data['alive']: send_event( 'CRITICAL' if 'arbiter' in daemon_item.name else 'WARNING', _('Daemon %s is dead !') % daemon_item.name, timer=True ) logger.warning('Daemon %s is dead...', daemon_item.name) is_problem = True return is_problem
def add_event(self, event_type, msg, timer=False, host=None): """ Add event to events list :param event_type: the type of event: OK, DOWN, ACK, ... :type event_type: str :param msg: message of event :type msg: str :param timer: timer to hide event at end of time :type timer: bool :param host: data of a host to set ``Qt.UserRole`` :type host: None | str """ if not self.event_exist(msg): logger.debug('Add Event: msg: %s, timer: %s, host: %s', msg, timer, host) event = EventItem() event.initialize(event_type, msg, timer=timer, host=host) self.events_list.insertItem(0, event) if timer: event_duration = int( settings.get_config('Alignak-app', 'notification_duration')) * 1000 QTimer.singleShot(event_duration, lambda: self.remove_timer_event(event)) else: logger.debug('Event with msg: %s already exist.', msg)
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() )
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 initialize(self): """ Initialize QMainWindow for App """ logger.info('Display Alignak-App...') app_widget = QWidget() app_widget.setObjectName('dialog') app_layout = QGridLayout() app_layout.setContentsMargins(0, 0, 0, 0) app_widget.setLayout(app_layout) # Logo widget app_layout.addWidget(get_logo_widget(self, 'Alignak-App'), 0, 0, 1, 3) # Panel self.panel_widget.initialize() app_layout.addWidget(self.panel_widget, 1, 0, 1, 1) app_layout.addWidget(get_frame_separator(True), 1, 1, 1, 1) # Dock self.dock.initialize() app_layout.addWidget(self.dock, 1, 2, 1, 1) self.setCentralWidget(app_widget) self.setMinimumSize(1440, 900) center_widget(self) display = settings.get_config('Alignak-app', 'display') if "min" in display: self.show() elif "max" in display: self.showMaximized() else: pass if settings.get_config('Alignak-app', 'problems', boolean=True): self.panel_widget.tab_widget.setCurrentIndex( self.panel_widget.tab_widget.indexOf(self.panel_widget.problems_widget) ) self.panel_widget.problems_widget.line_search.setFocus() else: self.panel_widget.synthesis_widget.line_search.setFocus()
def initialize(self): """ Initialize QMainWindow for App """ logger.info('Display Alignak-App...') app_widget = QWidget() app_widget.setObjectName('dialog') app_layout = QGridLayout() app_layout.setContentsMargins(0, 0, 0, 0) app_widget.setLayout(app_layout) # Logo widget app_layout.addWidget(get_logo_widget(self, 'Alignak-App'), 0, 0, 1, 3) # Panel self.panel_widget.initialize() app_layout.addWidget(self.panel_widget, 1, 0, 1, 1) app_layout.addWidget(get_frame_separator(True), 1, 1, 1, 1) # Dock self.dock.initialize() app_layout.addWidget(self.dock, 1, 2, 1, 1) self.setCentralWidget(app_widget) self.setMinimumSize(1440, 900) center_widget(self) display = settings.get_config('Alignak-app', 'display') if "min" in display: self.show() elif "max" in display: self.showMaximized() else: pass if settings.get_config('Alignak-app', 'problems', boolean=True): self.panel_widget.tab_widget.setCurrentIndex( self.panel_widget.tab_widget.indexOf( self.panel_widget.problems_widget)) self.panel_widget.problems_widget.line_search.setFocus() else: self.panel_widget.synthesis_widget.line_search.setFocus()
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_app_main_window_display_settings(self): """Display AppQMainWindow at Start""" under_test = AppQMainWindow() data_manager.update_database('host', []) data_manager.update_database('service', []) self.assertFalse(under_test.isVisible()) settings.set_config('Alignak-app', 'display', 'min') under_test.initialize() # AppQMainWindow is visible but not maximized self.assertEqual('min', settings.get_config('Alignak-app', 'display')) self.assertTrue(under_test.isVisible()) self.assertFalse(under_test.isMaximized()) under_test.close() settings.set_config('Alignak-app', 'display', 'max') under_test = AppQMainWindow() init_event_widget() under_test.initialize() # AppQMainWindow is visible and Maximized self.assertEqual('max', settings.get_config('Alignak-app', 'display')) self.assertTrue(under_test.isVisible()) self.assertTrue(under_test.isMaximized()) under_test.close() settings.set_config('Alignak-app', 'display', 'no') under_test = AppQMainWindow() init_event_widget() under_test.initialize() # AppQMainWindow is not visible and not maximized self.assertEqual('no', settings.get_config('Alignak-app', 'display')) self.assertFalse(under_test.isVisible()) self.assertFalse(under_test.isMaximized()) under_test.close() # Restore default setting settings.set_config('Alignak-app', 'display', 'min')
def refresh_menus(self): """ Refresh menu if needed """ if settings.get_config('Alignak', 'webui'): self.tray_actions['webui'].setEnabled(True) else: self.tray_actions['webui'].setEnabled(False)
def can_submit_actions(): """ Return if user can trigger actions from App or not, depending if Web Service is set and reachable: * If Web Service: if reachable, make actions are available else they are disabled * If NOT Web Service: App will use backend API :return: if user can trigger actions :rtype: bool """ if not settings.get_config('Alignak', 'webservice') and app_backend.connected: return True if settings.get_config('Alignak', 'webservice') and app_backend.ws_client.auth: return True return False
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)
def initialize(self): """ Intialize Spy QWidget """ layout = QGridLayout() self.setLayout(layout) spy_icon = QLabel() spy_pixmap = QPixmap(settings.get_image('spy')) spy_icon.setPixmap(spy_pixmap) spy_icon.setScaledContents(True) spy_icon.setFixedSize(20, 20) layout.addWidget(spy_icon, 0, 0, 1, 1) layout.setAlignment(spy_icon, Qt.AlignRight) spy_title = QLabel(_('Spy Hosts')) spy_title.setObjectName('title') spy_title.setMinimumHeight(40) layout.addWidget(spy_title, 0, 1, 1, 1) hint_lbl = QLabel('Click to refresh, double-click to stop spying') hint_lbl.setObjectName('subtitle') layout.addWidget(hint_lbl, 1, 0, 1, 1) layout.setAlignment(hint_lbl, Qt.AlignCenter) self.host_services_lbl.setObjectName('subtitle') layout.addWidget(self.host_services_lbl, 1, 1, 1, 1) layout.setAlignment(self.host_services_lbl, Qt.AlignCenter) self.spy_list_widget.setDragDropMode(QAbstractItemView.DragDrop) self.spy_list_widget.setSelectionMode( QAbstractItemView.ExtendedSelection) self.spy_list_widget.doubleClicked.connect(self.remove_event) self.spy_list_widget.setAcceptDrops(True) self.spy_list_widget.setWordWrap(True) self.spy_list_widget.insertItem(0, self.get_hint_item()) self.spy_list_widget.item_dropped.connect( get_events_widget().remove_event) self.spy_list_widget.clicked.connect( lambda: self.manage_host_events(self.spy_list_widget.currentRow())) layout.addWidget(self.spy_list_widget, 2, 0, 1, 1) self.host_list_widget.setObjectName('spy') # self.host_list_widget.setMinimumWidth(500) layout.addWidget(self.host_list_widget, 2, 1, 1, 1) spy_interval = int(settings.get_config('Alignak-app', 'spy_interval')) * 1000 self.spy_timer.setInterval(spy_interval) self.spy_timer.start() self.spy_timer.timeout.connect(self.send_spy_events)
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 set_proxy_settings(self, proxy_password=None): """ Set the proxy settings, with password if given :param proxy_password: the pasword of proxy :type proxy_password: str """ if settings.get_config('Alignak', 'proxy_user'): # Model is: {'http': 'http://*****:*****@proxy:port'} protocol, address, port = settings.get_config('Alignak', 'proxy').split(':') proxy_user = settings.get_config('Alignak', 'proxy_user') address = address.replace('//', '') proxy = { protocol: '%s://%s:%s@%s:%s' % (protocol, proxy_user, proxy_password, address, port) } self.proxies = proxy elif settings.get_config('Alignak', 'proxy'): protocol = settings.get_config('Alignak', 'proxy').split(':')[0] self.proxies = {protocol: settings.get_config('Alignak', 'proxy')} else: self.proxies = {}
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())
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 initialize(self): """ Intialize Spy QWidget """ layout = QGridLayout() self.setLayout(layout) spy_icon = QLabel() spy_pixmap = QPixmap(settings.get_image('spy')) spy_icon.setPixmap(spy_pixmap) spy_icon.setScaledContents(True) spy_icon.setFixedSize(20, 20) layout.addWidget(spy_icon, 0, 0, 1, 1) layout.setAlignment(spy_icon, Qt.AlignRight) spy_title = QLabel(_('Spy Hosts')) spy_title.setObjectName('title') spy_title.setMinimumHeight(40) layout.addWidget(spy_title, 0, 1, 1, 1) hint_lbl = QLabel('Click to refresh, double-click to stop spying') hint_lbl.setObjectName('subtitle') layout.addWidget(hint_lbl, 1, 0, 1, 1) layout.setAlignment(hint_lbl, Qt.AlignCenter) self.host_services_lbl.setObjectName('subtitle') layout.addWidget(self.host_services_lbl, 1, 1, 1, 1) layout.setAlignment(self.host_services_lbl, Qt.AlignCenter) self.spy_list_widget.setDragDropMode(QAbstractItemView.DragDrop) self.spy_list_widget.setSelectionMode(QAbstractItemView.ExtendedSelection) self.spy_list_widget.doubleClicked.connect(self.remove_event) self.spy_list_widget.setAcceptDrops(True) self.spy_list_widget.setWordWrap(True) self.spy_list_widget.insertItem(0, self.get_hint_item()) self.spy_list_widget.item_dropped.connect(get_events_widget().remove_event) self.spy_list_widget.clicked.connect( lambda: self.manage_host_events(self.spy_list_widget.currentRow()) ) layout.addWidget(self.spy_list_widget, 2, 0, 1, 1) self.host_list_widget.setObjectName('spy') # self.host_list_widget.setMinimumWidth(500) layout.addWidget(self.host_list_widget, 2, 1, 1, 1) spy_interval = int(settings.get_config('Alignak-app', 'spy_interval')) * 1000 self.spy_timer.setInterval(spy_interval) self.spy_timer.start() self.spy_timer.timeout.connect(self.send_spy_events)
def test_default_view_is_problems(self): """Display Problems View by Default""" settings.set_config('Alignak-app', 'problems', 'no') under_test = AppQMainWindow() data_manager.update_database('host', []) data_manager.update_database('service', []) init_event_widget() self.assertEqual(-1, under_test.panel_widget.tab_widget.currentIndex()) under_test.initialize() problems_index = under_test.panel_widget.get_tab_order().index('p') self.assertFalse( settings.get_config('Alignak-app', 'problems', boolean=True)) self.assertEqual( problems_index, under_test.panel_widget.tab_widget.indexOf( under_test.panel_widget.problems_widget)) # Make "Problems" as default view settings.set_config('Alignak-app', 'problems', 'yes') under_test = AppQMainWindow() init_event_widget() under_test.initialize() self.assertTrue( settings.get_config('Alignak-app', 'problems', boolean=True)) self.assertEqual( problems_index, under_test.panel_widget.tab_widget.indexOf( under_test.panel_widget.problems_widget)) # Reset settings settings.set_config('Alignak-app', 'problems', 'no')
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_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_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_default_view_is_problems(self): """Display Problems View by Default""" settings.set_config('Alignak-app', 'problems', 'no') under_test = AppQMainWindow() data_manager.update_database('host', []) data_manager.update_database('service', []) init_event_widget() self.assertEqual(-1, under_test.panel_widget.tab_widget.currentIndex()) under_test.initialize() problems_index = under_test.panel_widget.get_tab_order().index('p') self.assertFalse(settings.get_config('Alignak-app', 'problems', boolean=True)) self.assertEqual( problems_index, under_test.panel_widget.tab_widget.indexOf(under_test.panel_widget.problems_widget) ) # Make "Problems" as default view settings.set_config('Alignak-app', 'problems', 'yes') under_test = AppQMainWindow() init_event_widget() under_test.initialize() self.assertTrue(settings.get_config('Alignak-app', 'problems', boolean=True)) self.assertEqual( problems_index, under_test.panel_widget.tab_widget.indexOf(under_test.panel_widget.problems_widget) ) # Reset settings settings.set_config('Alignak-app', 'problems', 'no')
def accept_login(self): """ Accept Login or not if backend is connected """ username = str(self.username_line.text()) password = str(self.password_line.text()) # Set proxy only if in config if not self.proxies and settings.get_config('Alignak', 'proxy'): self.set_proxy_settings() if app_backend.login(username, password, proxies=self.proxies): self.accept() else: self.reject()
def initialize(self): """ Initialize QWidget """ self.setLayout(self.layout) self.layout.setContentsMargins(0, 0, 0, 0) self.get_host_resume_widget() self.get_services_resume_widget() self.update_dashboard() update_dashboard = int(settings.get_config('Alignak-app', 'update_dashboard')) * 1000 self.refresh_timer.setInterval(update_dashboard) self.refresh_timer.start() self.refresh_timer.timeout.connect(self.update_dashboard)
def check_threads(): """ Launch periodically threads """ # Cleaning threads who are finished thread_manager.clean_threads() # Launch or stop threads if app_backend.connected: thread_manager.launch_threads('low') thread_manager.launch_threads('normal') thread_manager.launch_threads('normal') else: logger.debug( 'Can\'t launch Request threads, App is not connected to backend [%s] !', settings.get_config('Alignak', 'backend')) thread_manager.stop_threads()
def initialize(self): """ Initialize QWidget """ layout = QGridLayout() self.setLayout(layout) layout.addWidget(self.get_service_icon_widget(), 0, 0, 1, 1) layout.addWidget(self.get_actions_widget(), 0, 1, 1, 1) layout.addWidget(self.get_last_check_widget(), 1, 0, 1, 2) update_service = int(settings.get_config('Alignak-app', 'update_service')) * 1000 self.refresh_timer.setInterval(update_service) self.refresh_timer.start() self.refresh_timer.timeout.connect(self.periodic_refresh) self.hide()
def initialize(self): """ Initialize QWidget """ layout = QGridLayout() self.setLayout(layout) layout.addWidget(self.get_service_icon_widget(), 0, 0, 1, 1) layout.addWidget(self.get_actions_widget(), 0, 1, 1, 1) layout.addWidget(self.get_last_check_widget(), 1, 0, 1, 2) update_service = int( settings.get_config('Alignak-app', 'update_service')) * 1000 self.refresh_timer.setInterval(update_service) self.refresh_timer.start() self.refresh_timer.timeout.connect(self.periodic_refresh) self.hide()
def get_tab_order(): """ Return tab order defined by user, else default order :return: tab order of App :rtype: list """ default_order = ['p', 'h', 's'] tab_order = settings.get_config('Alignak-app', 'tab_order').split(',') try: assert len(tab_order) == len(default_order) for nb in default_order: assert nb in tab_order except AssertionError: logger.error('Wrong "tab_order" value in config file %s', tab_order) tab_order = default_order return tab_order
def initialize(self): """ Initialize QWidget """ layout = QHBoxLayout() self.setLayout(layout) item_types = ['host', 'service', 'problem'] for item_type in item_types: item_widget = self.get_item_type_widget(item_type, 0, 0) layout.addWidget(item_widget) self.update_labels() update_livestate = int(settings.get_config('Alignak-app', 'update_livestate')) * 1000 self.timer.setInterval(update_livestate) self.timer.start() self.timer.timeout.connect(self.update_labels)
def get_settings_widget(self): """ Return the alignak settings QWidget :return: settings QWidget :rtype: QWidget """ server_widget = QWidget() server_widget.setObjectName('dialog') server_layout = QVBoxLayout(server_widget) # Title title_lbl = QLabel(_('Alignak Backend')) title_lbl.setObjectName('itemtitle') server_layout.addWidget(title_lbl) server_layout.setAlignment(title_lbl, Qt.AlignTop) # Description desc_label = QLabel( _('Here you can define alignak settings. Be sure to enter a valid address.') ) desc_label.setWordWrap(True) server_layout.addWidget(desc_label) # Server URL server_lbl = QLabel(_('Server')) server_layout.addWidget(server_lbl) self.server_url.setText(settings.get_config('Alignak', 'url')) self.server_url.setPlaceholderText(_('alignak backend url...')) self.server_url.setFixedHeight(25) server_layout.addWidget(self.server_url) # Server Port port_lbl = QLabel(_('Port')) server_layout.addWidget(port_lbl) cur_port = settings.get_config('Alignak', 'backend').split(':')[2] self.server_port.setText(cur_port) self.server_port.setPlaceholderText(_('alignak backend port...')) self.server_port.setFixedHeight(25) server_layout.addWidget(self.server_port) # Server Processes (displayed only for Unix platforms) if 'win32' not in sys.platform: process_lbl = QLabel(_('Processes')) server_layout.addWidget(process_lbl) cur_proc = settings.get_config('Alignak', 'processes') self.server_proc.setText(cur_proc) self.server_proc.setPlaceholderText(_('alignak backend processes...')) self.server_proc.setFixedHeight(25) server_layout.addWidget(self.server_proc) # Web Service description server_layout.addStretch(1) webservice_lbl = QLabel(_('Web Service')) webservice_lbl.setObjectName('itemtitle') server_layout.addWidget(webservice_lbl) ws_desc_lbl = QLabel( _('Here you can define your alignak web service url, with port if needed') ) ws_desc_lbl.setWordWrap(True) server_layout.addWidget(ws_desc_lbl) # Web Service URL self.webservice_url.setText(settings.get_config('Alignak', 'webservice')) self.webservice_url.setPlaceholderText(_('alignak webservice url...')) self.webservice_url.setFixedHeight(25) server_layout.addWidget(self.webservice_url) # Valid Button valid_btn = QPushButton(_('Valid')) valid_btn.setObjectName('valid') valid_btn.setMinimumHeight(30) valid_btn.clicked.connect(self.accept) server_layout.addWidget(valid_btn) return server_widget
def initialize(self): """ Initialize QWidget """ self.update_status() layout = QGridLayout() self.setLayout(layout) # Backend state connected_title = QLabel(_('Backend API')) connected_title.setObjectName('subtitle') layout.addWidget(connected_title, 0, 0, 1, 1) self.backend_connected.setFixedSize(16, 16) self.backend_connected.setScaledContents(True) self.backend_connected.setToolTip(_('Status of the backend API connection')) layout.addWidget(self.backend_connected, 0, 1, 1, 1) layout.setAlignment(self.backend_connected, Qt.AlignCenter) # WS state ws_title = QLabel(_('Web Service')) ws_title.setObjectName('subtitle') layout.addWidget(ws_title, 0, 2, 1, 1) self.ws_connected.setFixedSize(16, 16) self.ws_connected.setScaledContents(True) self.ws_connected.setToolTip(_('Status of the Web Service connection')) layout.addWidget(self.ws_connected, 0, 3, 1, 1) layout.setAlignment(self.ws_connected, Qt.AlignCenter) # Daemons state daemons_title = QLabel(_('Alignak')) daemons_title.setObjectName('subtitle') layout.addWidget(daemons_title, 1, 0, 1, 1) self.status_dialog.initialize() self.update_status_btn(self.status_dialog.update_dialog()) self.status_btn.setFixedSize(32, 32) self.status_btn.clicked.connect(self.show_status_dialog) self.status_btn.setToolTip(_('Status of daemons connection')) layout.addWidget(self.status_btn, 1, 1, 1, 1) layout.setAlignment(self.status_btn, Qt.AlignCenter) # User user_lbl = QLabel(_('User')) user_lbl.setObjectName('subtitle') layout.addWidget(user_lbl, 1, 2, 1, 1) self.profile_widget.initialize() self.profile_btn.setIcon(QIcon(settings.get_image('user'))) self.profile_btn.setFixedSize(32, 32) self.profile_btn.clicked.connect(self.show_user_widget) self.profile_btn.setToolTip(_('View current user')) layout.addWidget(self.profile_btn, 1, 3, 1, 1) # Refresh timer update_status = int(settings.get_config('Alignak-app', 'update_status')) * 1000 self.refresh_timer.setInterval(update_status) self.refresh_timer.start() self.refresh_timer.timeout.connect(self.update_status)
def create_logger(): # pragma: no cover """ Create the logger for Alignak-App :return: the RootLogger of App :rtype: logging.RootLogger """ root_logger = getLogger() stdout_handler = None if root_logger.handlers: stdout_handler = root_logger.handlers[0] # Define path and file for "file_handler" if 'ALIGNAKAPP_LOG_DIR' in os.environ: path = os.environ['ALIGNAKAPP_LOG_DIR'] elif 'ALIGNAKAPP_USR_DIR' in os.environ: path = os.environ['ALIGNAKAPP_USR_DIR'] else: path = tempfile.gettempdir() if not os.access(path, os.W_OK): print('Access denied for [%s], App will log in current directory !' % path) path = '.' os.environ['ALIGNAKAPP_LOG_DIR'] = path filename = '%s.log' % settings.get_config('Log', 'filename') if not os.path.isdir(path): # noinspection PyBroadException try: # pragma: no cover - not testable os.makedirs(path) except Exception: print('Can\'t create log file in [%s], App will log in current directory !' % path) path = '.' formatter = Formatter( fmt='[%(asctime)s]-%(name)12s: [%(levelname)s] %(message)s', datefmt='%Y-%m-%d,%H:%M:%S' ) # Create "file_handler" file_handler = TimedRotatingFileHandler( filename=os.path.join(path, filename), when="D", interval=1, backupCount=6 ) file_handler.setLevel(DEBUG) file_handler.setFormatter(formatter) root_logger.addHandler(file_handler) # Remove stdout handler to ensure logs are only in filehandler root_logger.removeHandler(stdout_handler) return root_logger