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())