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)
