From cb4c40c21cf19e8b61a7747067e4b9729209d4b0 Mon Sep 17 00:00:00 2001 From: kali Date: Thu, 6 Dec 2012 01:29:53 +0900 Subject: providerselect tests --- src/leap/gui/tests/test_firstrun_providerselect.py | 61 ++++++++++++++++++++++ 1 file changed, 61 insertions(+) create mode 100644 src/leap/gui/tests/test_firstrun_providerselect.py (limited to 'src/leap/gui/tests/test_firstrun_providerselect.py') diff --git a/src/leap/gui/tests/test_firstrun_providerselect.py b/src/leap/gui/tests/test_firstrun_providerselect.py new file mode 100644 index 00000000..be7cc9c1 --- /dev/null +++ b/src/leap/gui/tests/test_firstrun_providerselect.py @@ -0,0 +1,61 @@ +import sys +import unittest + +import mock + +from leap.testing import qunittest +from leap.testing import pyqt + +from PyQt4 import QtGui +#from PyQt4 import QtCore +import PyQt4.QtCore # some weirdness with mock module + +from PyQt4.QtTest import QTest +#from PyQt4.QtCore import Qt + +from leap.gui import firstrun + + +class TestPage(firstrun.providerselect.SelectProviderPage): + pass + + +class SelectProviderPageTestCase(qunittest.TestCase): + + # XXX can spy on signal connections + + def setUp(self): + self.app = QtGui.QApplication(sys.argv) + QtGui.qApp = self.app + self.page = TestPage(None) + self.page.wizard = mock.MagicMock() + self.page.wizard().netchecker.return_value = True + + def tearDown(self): + QtGui.qApp = None + self.app = None + self.page = None + + def test__do_checks(self): + eq = self.assertEqual + checks = [x for x in self.page._do_checks()] + eq(len(checks), 5) + labels = [str(x) for (x, y), z in checks] + eq(labels, ['head_sentinel', 'checking domain name', + 'checking https connection', + 'fetching provider info', 'end_sentinel']) + progress = [y for (x, y), z in checks] + eq(progress, [0, 20, 40, 80, 100]) + + # XXX now: execute the functions + # with proper mocks (for checkers and so on) + # and try to cover all the exceptions + checkfuns = [z for (x, y), z in checks] + #import ipdb;ipdb.set_trace() + + def test_next_button_is_disabled(self): + pass + + +if __name__ == "__main__": + unittest.main() -- cgit v1.2.3 From f40bfa7b674418f9903e826d20ad943efcc47807 Mon Sep 17 00:00:00 2001 From: kali Date: Fri, 7 Dec 2012 02:16:25 +0900 Subject: register tests --- src/leap/gui/tests/test_firstrun_providerselect.py | 162 +++++++++++++++++++-- 1 file changed, 151 insertions(+), 11 deletions(-) (limited to 'src/leap/gui/tests/test_firstrun_providerselect.py') diff --git a/src/leap/gui/tests/test_firstrun_providerselect.py b/src/leap/gui/tests/test_firstrun_providerselect.py index be7cc9c1..976c68cd 100644 --- a/src/leap/gui/tests/test_firstrun_providerselect.py +++ b/src/leap/gui/tests/test_firstrun_providerselect.py @@ -4,23 +4,29 @@ import unittest import mock from leap.testing import qunittest -from leap.testing import pyqt +#from leap.testing import pyqt from PyQt4 import QtGui #from PyQt4 import QtCore -import PyQt4.QtCore # some weirdness with mock module +#import PyQt4.QtCore # some weirdness with mock module from PyQt4.QtTest import QTest -#from PyQt4.QtCore import Qt +from PyQt4.QtCore import Qt from leap.gui import firstrun +try: + from collections import OrderedDict +except ImportError: + # We must be in 2.6 + from leap.util.dicts import OrderedDict + class TestPage(firstrun.providerselect.SelectProviderPage): pass -class SelectProviderPageTestCase(qunittest.TestCase): +class SelectProviderPageLogicTestCase(qunittest.TestCase): # XXX can spy on signal connections @@ -29,7 +35,18 @@ class SelectProviderPageTestCase(qunittest.TestCase): QtGui.qApp = self.app self.page = TestPage(None) self.page.wizard = mock.MagicMock() - self.page.wizard().netchecker.return_value = True + + mocknetchecker = mock.Mock() + self.page.wizard().netchecker.return_value = mocknetchecker + self.mocknetchecker = mocknetchecker + + mockpcertchecker = mock.Mock() + self.page.wizard().providercertchecker.return_value = mockpcertchecker + self.mockpcertchecker = mockpcertchecker + + mockeipconfchecker = mock.Mock() + self.page.wizard().eipconfigchecker.return_value = mockeipconfchecker + self.mockeipconfchecker = mockeipconfchecker def tearDown(self): QtGui.qApp = None @@ -38,6 +55,9 @@ class SelectProviderPageTestCase(qunittest.TestCase): def test__do_checks(self): eq = self.assertEqual + + self.page.providerNameEdit.setText('test_provider1') + checks = [x for x in self.page._do_checks()] eq(len(checks), 5) labels = [str(x) for (x, y), z in checks] @@ -47,15 +67,135 @@ class SelectProviderPageTestCase(qunittest.TestCase): progress = [y for (x, y), z in checks] eq(progress, [0, 20, 40, 80, 100]) - # XXX now: execute the functions - # with proper mocks (for checkers and so on) - # and try to cover all the exceptions + # normal run, ie, no exceptions + checkfuns = [z for (x, y), z in checks] - #import ipdb;ipdb.set_trace() + namecheck, httpscheck, fetchinfo = checkfuns[1:-1] + + self.assertTrue(namecheck()) + self.mocknetchecker.check_name_resolution.assert_called_with( + 'test_provider1') + + self.assertTrue(httpscheck()) + self.mockpcertchecker.is_https_working.assert_called_with( + "https://test_provider1", verify=True) + + self.assertTrue(fetchinfo()) + self.mockeipconfchecker.fetch_definition.assert_called_with( + domain="test_provider1") + + # XXX missing: inject failing exceptions + # XXX TODO make it break + - def test_next_button_is_disabled(self): - pass +class SelectProviderPageUITestCase(qunittest.TestCase): + # XXX can spy on signal connections + __name__ = "Select Provider Page UI tests" + + def setUp(self): + self.app = QtGui.QApplication(sys.argv) + QtGui.qApp = self.app + + self.pagename = "providerselection" + pages = OrderedDict(( + (self.pagename, TestPage), + ('providerinfo', + firstrun.providerinfo.ProviderInfoPage))) + self.wizard = firstrun.wizard.FirstRunWizard(None, pages_dict=pages) + self.page = self.wizard.page(self.wizard.get_page_index(self.pagename)) + + self.page.do_checks = mock.Mock() + + # wizard would do this for us + self.page.initializePage() + + def tearDown(self): + QtGui.qApp = None + self.app = None + self.wizard = None + + def fill_provider(self): + """ + fills provider line edit + """ + keyp = QTest.keyPress + pedit = self.page.providerNameEdit + pedit.setFocus(True) + for c in "testprovider": + keyp(pedit, c) + self.assertEqual(pedit.text(), "testprovider") + + def del_provider(self): + """ + deletes entried provider in + line edit + """ + keyp = QTest.keyPress + pedit = self.page.providerNameEdit + for c in range(len("testprovider")): + keyp(pedit, Qt.Key_Backspace) + self.assertEqual(pedit.text(), "") + + def test_buttons_disabled_until_textentry(self): + nextbutton = self.wizard.button(QtGui.QWizard.NextButton) + checkbutton = self.page.providerCheckButton + + self.assertFalse(nextbutton.isEnabled()) + self.assertFalse(checkbutton.isEnabled()) + + self.fill_provider() + # checkbutton should be enabled + self.assertTrue(checkbutton.isEnabled()) + self.assertFalse(nextbutton.isEnabled()) + + self.del_provider() + # after rm provider checkbutton disabled again + self.assertFalse(checkbutton.isEnabled()) + self.assertFalse(nextbutton.isEnabled()) + + def test_check_button_triggers_tests(self): + checkbutton = self.page.providerCheckButton + self.assertFalse(checkbutton.isEnabled()) + self.assertFalse(self.page.do_checks.called) + + self.fill_provider() + + self.assertTrue(checkbutton.isEnabled()) + mclick = QTest.mouseClick + # click! + mclick(checkbutton, Qt.LeftButton) + self.waitFor(seconds=0.1) + self.assertTrue(self.page.do_checks.called) + + # XXX + # can play with different side_effects for do_checks mock... + # so we can see what happens with errors and so on + + def test_page_completed_after_checks(self): + nextbutton = self.wizard.button(QtGui.QWizard.NextButton) + self.assertFalse(nextbutton.isEnabled()) + + self.assertFalse(self.page.isComplete()) + self.fill_provider() + # simulate checks done + self.page.done = True + self.page.on_checks_validation_ready() + self.assertTrue(self.page.isComplete()) + # cannot test for nexbutton enabled + # cause it's the the wizard loop + # that would do that I think + + def test_validate_page(self): + self.assertTrue(self.page.validatePage()) + + def test_next_id(self): + self.assertEqual(self.page.nextId(), 1) + + def test_paint_event(self): + self.page.populateErrors = mock.Mock() + self.page.paintEvent(None) + self.page.populateErrors.assert_called_with() if __name__ == "__main__": unittest.main() -- cgit v1.2.3 From 9cdc193c587631986e579c1ba37a8b982be01238 Mon Sep 17 00:00:00 2001 From: kali Date: Thu, 24 Jan 2013 18:47:41 +0900 Subject: all tests green again plus: * added soledad test requirements * removed soledad from run_tests run (+1K tests failing) * added option to run All tests to run_tests script * pep8 cleanup --- src/leap/gui/tests/test_firstrun_providerselect.py | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) (limited to 'src/leap/gui/tests/test_firstrun_providerselect.py') diff --git a/src/leap/gui/tests/test_firstrun_providerselect.py b/src/leap/gui/tests/test_firstrun_providerselect.py index 976c68cd..18d89010 100644 --- a/src/leap/gui/tests/test_firstrun_providerselect.py +++ b/src/leap/gui/tests/test_firstrun_providerselect.py @@ -61,9 +61,11 @@ class SelectProviderPageLogicTestCase(qunittest.TestCase): checks = [x for x in self.page._do_checks()] eq(len(checks), 5) labels = [str(x) for (x, y), z in checks] - eq(labels, ['head_sentinel', 'checking domain name', - 'checking https connection', - 'fetching provider info', 'end_sentinel']) + eq(labels, ['head_sentinel', + 'Checking if it is a valid provider', + 'Checking for a secure connection', + 'Getting info from the provider', + 'end_sentinel']) progress = [y for (x, y), z in checks] eq(progress, [0, 20, 40, 80, 100]) -- cgit v1.2.3