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