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())
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
"""
# 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 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 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())
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_())
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())
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())