def query_user(self): """ Launch request on "user" endpoint. Only for current App user. """ request_model = User.get_request_model(self.backend.token) request = self.get( request_model['endpoint'], request_model['params'], request_model['projection'] ) if request: if request['_items']: user = User() user.create( request['_items'][0]['_id'], request['_items'][0], request['_items'][0]['name'] ) data_manager.update_database('user', user) if 'OK' in request['_status']: data_manager.db_is_ready[request_model['endpoint']] = True
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 query_timeperiods(self): """ Launch a request on ``timeperiod`` endpoint """ request_model = Period.get_request_model() request = self.get( request_model['endpoint'], request_model['params'], request_model['projection'] ) if request: periods_list = [] for backend_item in request['_items']: period = Period() period.create( backend_item['_id'], backend_item, backend_item['name'], ) periods_list.append(period) if periods_list: data_manager.update_database('timeperiod', periods_list) if 'OK' in request['_status']: data_manager.db_is_ready[request_model['endpoint']] = True
def query_notifications(self): # pragma: no cover, notifications can be empty """ Launch request on "history" endpoint. Only for 'type': 'monitoring.notification' and for current App user """ request_model = Event.get_request_model() request = self.get( request_model['endpoint'], request_model['params'], request_model['projection'], all_items=False ) if request: notifications = [] for backend_item in request['_items']: message_split = backend_item['message'].split(';') user = message_split[0].split(':')[1].strip() if 'imported_admin' in user: user = '******' if user == data_manager.database['user'].name: notification = Event() notification.create( backend_item['_id'], backend_item, ) notifications.append(notification) if notifications: data_manager.update_database('notifications', notifications)
def test_set_filter_items(self): """Set Filter Services Items""" under_test = ServicesQWidget() data_manager.update_database('host', self.host_list) data_manager.update_database('service', self.service_list) under_test.initialize() services = data_manager.get_host_services(self.host_list[2].item_id) under_test.update_widget(services) self.assertEqual(0, under_test.services_list_widget.count()) under_test.set_filter_items('OK') # Host has only one service OK self.assertEqual(1, under_test.services_list_widget.count()) under_test.services_list_widget.clear() under_test.set_filter_items('UNKNOWN') under_test.services_list_widget.setCurrentItem(under_test.services_list_widget.item(0)) # Host has no service UNKNOWN, so item have hint text self.assertEqual(1, under_test.services_list_widget.count()) self.assertEqual( 'No such services to display...', under_test.services_list_widget.currentItem().data(Qt.DisplayRole) )
def query_timeperiods(self): """ Launch a request on ``timeperiod`` endpoint """ request_model = Period.get_request_model() request = self.get(request_model['endpoint'], request_model['params'], request_model['projection']) if request: periods_list = [] for backend_item in request['_items']: period = Period() period.create( backend_item['_id'], backend_item, backend_item['name'], ) periods_list.append(period) if periods_list: data_manager.update_database('timeperiod', periods_list) if 'OK' in request['_status']: data_manager.db_is_ready[request_model['endpoint']] = True
def query_realms(self): """ Launch a request on ``realm`` endpoint """ request_model = Realm.get_request_model() request = self.get( request_model['endpoint'], request_model['params'], request_model['projection'] ) if request: realms_list = [] for backend_item in request['_items']: realm = Realm() realm.create( backend_item['_id'], backend_item, backend_item['name'], ) realms_list.append(realm) if realms_list: data_manager.update_database('realm', realms_list) if 'OK' in request['_status']: data_manager.db_is_ready[request_model['endpoint']] = True
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 query_realms(self): """ Launch a request on ``realm`` endpoint """ request_model = Realm.get_request_model() request = self.get(request_model['endpoint'], request_model['params'], request_model['projection']) if request: realms_list = [] for backend_item in request['_items']: realm = Realm() realm.create( backend_item['_id'], backend_item, backend_item['name'], ) realms_list.append(realm) if realms_list: data_manager.update_database('realm', realms_list) if 'OK' in request['_status']: data_manager.db_is_ready[request_model['endpoint']] = True
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())
def test_add_spy_host(self): """Add Spy Host from Problems QWidget""" data_manager.update_database('host', []) data_manager.update_database('service', []) under_test = ProblemsQWidget() spy_widget_test = SpyQWidget() spy_widget_test.initialize() under_test.initialize(spy_widget_test) # Update view with problems under_test.problems_table.update_view({'problems': [self.host_list[8]]}) # Make this QStandardItem as current index index_test = under_test.problems_table.model().index(0, 0) under_test.problems_table.selectionModel().setCurrentIndex( index_test, QItemSelectionModel.SelectCurrent ) self.assertFalse(under_test.spy_widget.spy_list_widget.spied_hosts) under_test.add_spied_host() # Assert host has been spied self.assertTrue(under_test.spy_widget.spy_list_widget.spied_hosts) # "_id8" is inside "spied_hosts" self.assertTrue( self.host_list[8].item_id in under_test.spy_widget.spy_list_widget.spied_hosts )
def query_livesynthesis(self): """ Launch request on "livesynthesis" endpoint """ request_model = LiveSynthesis.get_request_model() request = self.get( request_model['endpoint'], request_model['params'], request_model['projection'], all_items=True ) if request: livesynthesis = [] for backend_item in request['_items']: synthesis = LiveSynthesis() synthesis.create( backend_item['_id'], backend_item, ) livesynthesis.append(synthesis) if livesynthesis: data_manager.update_database('livesynthesis', livesynthesis) if 'OK' in request['_status']: data_manager.db_is_ready[request_model['endpoint']] = True
def query_alignakdaemons(self): """ Launch request on "alignakdaemon" endpoint """ request_model = Daemon.get_request_model() request = self.get( request_model['endpoint'], request_model['params'], request_model['projection'], all_items=True ) if request: daemons_list = [] for backend_item in request['_items']: daemon = Daemon() daemon.create( backend_item['_id'], backend_item, backend_item['name'], ) daemons_list.append(daemon) if daemons_list: data_manager.update_database('alignakdaemon', daemons_list) if 'OK' in request['_status']: data_manager.db_is_ready[request_model['endpoint']] = True
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_update_widget(self): """Update Services QWidget""" under_test = ServicesQWidget() data_manager.update_database('host', self.host_list) data_manager.update_database('service', self.service_list) under_test.initialize() self.assertIsNone(under_test.services) services = data_manager.get_host_services(self.host_list[2].item_id) under_test.update_widget(services) self.assertIsNotNone(under_test.services)
def test_initialize_app_main_window(self): """Initialize AppQMainWindow""" under_test = AppQMainWindow() self.assertTrue(under_test.panel_widget) self.assertTrue(under_test.dock) self.assertIsNone(under_test.offset) data_manager.update_database('host', []) data_manager.update_database('service', []) init_event_widget() under_test.initialize() self.assertTrue(under_test.panel_widget) self.assertTrue(under_test.dock) self.assertIsNone(under_test.offset)
def query_services(self, host_id=None): """ Launch request for "service" endpoint. If ``host_id`` is given, only services related to host are added / updated :param host_id: "_id" of host :type host_id: str """ request_model = Service.get_request_model(host_id) request = self.get( request_model['endpoint'], request_model['params'], request_model['projection'], all_items=True ) if request: services_list = [] for backend_item in request['_items']: service = Service() service.create( backend_item['_id'], backend_item, backend_item['name'], ) # Add / update only services of host "if host_id" if host_id: if not data_manager.get_item('service', service.item_id): logger.debug('Add item data in database[service]') data_manager.database['service'].append(service) else: data_manager.update_item_data('service', service.item_id, service.data) # If not item ID, update all database if services_list and not host_id: data_manager.update_database('service', services_list) if host_id: host = data_manager.get_item('host', '_id', host_id) if host: logger.info('Update database[service] for %s', host.name) if 'OK' in request['_status']: data_manager.db_is_ready[request_model['endpoint']] = True
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 test_send_datamanager_events(self): """Send Data Manager Events""" under_test = EventsQWidget() under_test.initialize() self.assertEqual(1, under_test.events_list.count()) under_test.send_datamanager_events() # No events in datamanager self.assertEqual(1, under_test.events_list.count()) # Fill datamanager with events event = Event() event.create( '_id1', { 'event_type': 'OK', 'message': 'HOST;host_one;UP;imported_admin;output of host one', 'host': '_id1', '_updated': 'Thu, 22 Mar 2018 12:30:41 GMT' }, '_id1' ) event_2 = Event() event_2.create( '_id2', { 'event_type': 'OK', 'message': 'HOST;host_two;DOWN;imported_admin;output of host two', 'host': '_id1', '_updated': 'Thu, 22 Mar 2018 12:30:41 GMT' }, '_id2' ) data_manager.update_database('notifications', [event, event_2]) under_test.send_datamanager_events() # Events are sent self.assertEqual(3, under_test.events_list.count())
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)
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)
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())
def query_hosts(self): """ Launch request on "host" endpoint, add hosts in problems if needed """ request_model = Host.get_request_model() request = self.get( request_model['endpoint'], request_model['params'], request_model['projection'], all_items=True ) if request: hosts_list = [] for backend_item in request['_items']: host = Host() host.create( backend_item['_id'], backend_item, backend_item['name'], ) hosts_list.append(host) # If host is a problem, add / update it if data_manager.is_problem('host', backend_item): if data_manager.get_item('problems', host.item_id): data_manager.update_item_data('problems', host.item_id, host.data) else: data_manager.database['problems'].append(host) data_manager.db_is_ready['problems']['host'] = True if hosts_list: data_manager.update_database('host', hosts_list) if 'OK' in request['_status']: data_manager.db_is_ready[request_model['endpoint']] = True
def query_user(self): """ Launch request on "user" endpoint. Only for current App user. """ request_model = User.get_request_model(self.backend.token) request = self.get(request_model['endpoint'], request_model['params'], request_model['projection']) if request: if request['_items']: user = User() user.create(request['_items'][0]['_id'], request['_items'][0], request['_items'][0]['name']) data_manager.update_database('user', user) if 'OK' in request['_status']: data_manager.db_is_ready[request_model['endpoint']] = True
def test_update_widget(self): """Update ServiceData QWidget""" under_test = ServiceDataQWidget() under_test.initialize() old_labels = {} # Store QLabel.text() = '' for label in under_test.labels: old_labels[label] = under_test.labels[label] data_manager.database['user'].data['can_submit_commands'] = True data_manager.update_database('service', self.service_list) under_test.update_widget(self.service_list[0]) new_labels = under_test.labels # Assert labels have been filled by update for label in old_labels: self.assertNotEqual(new_labels[label].text(), old_labels[label])
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_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_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 query_history(self, hostname=None, host_id=None): """ Launch request on "history" endpoint but only for hosts in "data_manager" :param hostname: name of host we want history :type hostname: str :param host_id: id of host for history :type host_id: str """ request_model = History.get_request_model() if hostname and host_id: request_model['params']['where'] = json.dumps({ 'host': host_id}) request_model['params']['max_results'] = 25 request = self.get( request_model['endpoint'], request_model['params'], request_model['projection'], all_items=False ) if request: logger.debug('Add / Update history for %s (%s)', hostname, host_id) if data_manager.get_item('history', host_id): data_manager.update_item_data('history', host_id, request['_items']) else: host_history = History() host_history.create( host_id, request['_items'], hostname, ) data_manager.database['history'].append(host_history) else: # pragma: no cover, too long to test history_list = [] for history in data_manager.database['history']: request_model['params']['where'] = json.dumps({ 'host': history.item_id}) request_model['params']['max_results'] = 25 request = self.get( request_model['endpoint'], request_model['params'], request_model['projection'], all_items=False ) if request: host_history = History() host_history.create( history.item_id, request['_items'], history.name, ) history_list.append(host_history) if history_list: data_manager.update_database('history', history_list)