Merge branch 'release/v0.2.0'

Conflicts:
	README.txt

9 files changed, 1388 insertions, 0 deletions

diff --git a/src/leap/gui/tests/__init__.py b/src/leap/gui/tests/__init__.py
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/src/leap/gui/tests/__init__.py
diff --git a/src/leap/gui/tests/integration/fake_user_signup.py b/src/leap/gui/tests/integration/fake_user_signup.py
new file mode 100644
index 00000000..78873749
--- /dev/null
+++ b/src/leap/gui/tests/integration/fake_user_signup.py
@@ -0,0 +1,84 @@
+"""
+simple server to test registration and
+authentication
+
+To test:
+
+curl -d login=python_test_user -d password_salt=54321\
+     -d password_verifier=12341234 \
+        http://localhost:8000/users.json
+
+"""
+from BaseHTTPServer import HTTPServer
+from BaseHTTPServer import BaseHTTPRequestHandler
+import cgi
+import json
+import urlparse
+
+HOST = "localhost"
+PORT = 8000
+
+LOGIN_ERROR = """{"errors":{"login":["has already been taken"]}}"""
+
+from leap.base.tests.test_providers import EXPECTED_DEFAULT_CONFIG
+
+
+class request_handler(BaseHTTPRequestHandler):
+    responses = {
+        '/': ['ok\n'],
+        '/users.json': ['ok\n'],
+        '/timeout': ['ok\n'],
+        '/provider.json': ['%s\n' % json.dumps(EXPECTED_DEFAULT_CONFIG)]
+    }
+
+    def do_GET(self):
+        path = urlparse.urlparse(self.path)
+        message = '\n'.join(
+            self.responses.get(
+                path.path, None))
+        self.send_response(200)
+        self.end_headers()
+        self.wfile.write(message)
+
+    def do_POST(self):
+        form = cgi.FieldStorage(
+            fp=self.rfile,
+            headers=self.headers,
+            environ={'REQUEST_METHOD': 'POST',
+                     'CONTENT_TYPE': self.headers['Content-Type'],
+                     })
+        data = dict(
+            (key, form[key].value) for key in form.keys())
+        path = urlparse.urlparse(self.path)
+        message = '\n'.join(
+            self.responses.get(
+                path.path, ''))
+
+        login = data.get('login', None)
+        #password_salt = data.get('password_salt', None)
+        #password_verifier = data.get('password_verifier', None)
+
+        if path.geturl() == "/timeout":
+            print 'timeout'
+            self.send_response(200)
+            self.end_headers()
+            self.wfile.write(message)
+            import time
+            time.sleep(10)
+            return
+
+        ok = True if (login == "python_test_user") else False
+        if ok:
+            self.send_response(200)
+            self.end_headers()
+            self.wfile.write(message)
+
+        else:
+            self.send_response(500)
+            self.end_headers()
+            self.wfile.write(LOGIN_ERROR)
+
+
+if __name__ == "__main__":
+    server = HTTPServer((HOST, PORT), request_handler)
+    server.serve_forever()
diff --git a/src/leap/gui/tests/test_firstrun_login.py b/src/leap/gui/tests/test_firstrun_login.py
new file mode 100644
index 00000000..6c45b8ef
--- /dev/null
+++ b/src/leap/gui/tests/test_firstrun_login.py
@@ -0,0 +1,212 @@
+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
+
+try:
+    from collections import OrderedDict
+except ImportError:
+    # We must be in 2.6
+    from leap.util.dicts import OrderedDict
+
+
+class TestPage(firstrun.login.LogInPage):
+    pass
+
+
+class LogInPageLogicTestCase(qunittest.TestCase):
+
+    # XXX can spy on signal connections
+    __name__ = "register user page logic tests"
+
+    def setUp(self):
+        self.app = QtGui.QApplication(sys.argv)
+        QtGui.qApp = self.app
+        self.page = TestPage(None)
+        self.page.wizard = mock.MagicMock()
+
+    def tearDown(self):
+        QtGui.qApp = None
+        self.app = None
+        self.page = None
+
+    def test__do_checks(self):
+        eq = self.assertEqual
+
+        self.page.userNameLineEdit.setText('testuser@domain')
+        self.page.userPasswordLineEdit.setText('testpassword')
+
+        # fake register process
+        with mock.patch('leap.base.auth.LeapSRPRegister') as mockAuth:
+            mockSignup = mock.MagicMock()
+
+            reqMockup = mock.Mock()
+            # XXX should inject bad json to get error
+            reqMockup.content = '{"errors": null}'
+            mockSignup.register_user.return_value = (True, reqMockup)
+            mockAuth.return_value = mockSignup
+            checks = [x for x in self.page._do_checks()]
+
+            eq(len(checks), 4)
+            labels = [str(x) for (x, y), z in checks]
+            eq(labels, ['head_sentinel',
+                        'Resolving domain name',
+                        'Validating credentials',
+                        'end_sentinel'])
+            progress = [y for (x, y), z in checks]
+            eq(progress, [0, 20, 60, 100])
+
+            # normal run, ie, no exceptions
+
+            checkfuns = [z for (x, y), z in checks]
+            checkusername, resolvedomain, valcreds = checkfuns[:-1]
+
+            self.assertTrue(checkusername())
+            #self.mocknetchecker.check_name_resolution.assert_called_with(
+                #'test_provider1')
+
+            self.assertTrue(resolvedomain())
+            #self.mockpcertchecker.is_https_working.assert_called_with(
+                #"https://test_provider1", verify=True)
+
+            self.assertTrue(valcreds())
+
+        # XXX missing: inject failing exceptions
+        # XXX TODO make it break
+
+
+class RegisterUserPageUITestCase(qunittest.TestCase):
+
+    # XXX can spy on signal connections
+    __name__ = "Register User Page UI tests"
+
+    def setUp(self):
+        self.app = QtGui.QApplication(sys.argv)
+        QtGui.qApp = self.app
+
+        self.pagename = "signup"
+        pages = OrderedDict((
+            (self.pagename, TestPage),
+            ('providersetupvalidation',
+             firstrun.connect.ConnectionPage)))
+        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
+
+    # XXX refactor out
+    def fill_field(self, field, text):
+        """
+        fills a field (line edit) that is passed along
+        :param field: the qLineEdit
+        :param text: the text to be filled
+        :type field: QLineEdit widget
+        :type text: str
+        """
+        keyp = QTest.keyPress
+        field.setFocus(True)
+        for c in text:
+            keyp(field, c)
+        self.assertEqual(field.text(), text)
+
+    def del_field(self, field):
+        """
+        deletes entried text in
+        field line edit
+        :param field: the QLineEdit
+        :type field: QLineEdit widget
+        """
+        keyp = QTest.keyPress
+        for c in range(len(field.text())):
+            keyp(field, Qt.Key_Backspace)
+        self.assertEqual(field.text(), "")
+
+    def test_buttons_disabled_until_textentry(self):
+        # it's a commit button this time
+        nextbutton = self.wizard.button(QtGui.QWizard.CommitButton)
+
+        self.assertFalse(nextbutton.isEnabled())
+
+        f_username = self.page.userNameLineEdit
+        f_password = self.page.userPasswordLineEdit
+
+        self.fill_field(f_username, "testuser")
+        self.fill_field(f_password, "testpassword")
+
+        # commit should be enabled
+        # XXX Need a workaround here
+        # because the isComplete is not being evaluated...
+        # (no event loop running??)
+        #import ipdb;ipdb.set_trace()
+        #self.assertTrue(nextbutton.isEnabled())
+        self.assertTrue(self.page.isComplete())
+
+        self.del_field(f_username)
+        self.del_field(f_password)
+
+        # after rm fields commit button
+        # should be disabled again
+        #self.assertFalse(nextbutton.isEnabled())
+        self.assertFalse(self.page.isComplete())
+
+    def test_validate_page(self):
+        self.assertFalse(self.page.validatePage())
+        # XXX TODO MOAR CASES...
+        # add errors, False
+        # change done, False
+        # not done, do_checks called
+        # click confirm, True
+        # done and do_confirm, True
+
+    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()
+
+    def test_validation_ready(self):
+        f_username = self.page.userNameLineEdit
+        f_password = self.page.userPasswordLineEdit
+
+        self.fill_field(f_username, "testuser")
+        self.fill_field(f_password, "testpassword")
+
+        self.page.done = True
+        self.page.on_checks_validation_ready()
+        self.assertFalse(f_username.isEnabled())
+        self.assertFalse(f_password.isEnabled())
+
+        self.assertEqual(self.page.validationMsg.text(),
+                         "Credentials validated.")
+        self.assertEqual(self.page.do_confirm_next, True)
+
+    def test_regex(self):
+        # XXX enter invalid username with key presses
+        # check text is not updated
+        pass
+
+
+if __name__ == "__main__":
+    unittest.main()
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..18d89010
--- /dev/null
+++ b/src/leap/gui/tests/test_firstrun_providerselect.py
@@ -0,0 +1,203 @@
+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
+
+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 SelectProviderPageLogicTestCase(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()
+
+        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
+        self.app = None
+        self.page = None
+
+    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]
+        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])
+
+        # normal run, ie, no exceptions
+
+        checkfuns = [z for (x, y), z in checks]
+        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
+
+
+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()
diff --git a/src/leap/gui/tests/test_firstrun_register.py b/src/leap/gui/tests/test_firstrun_register.py
new file mode 100644
index 00000000..9d62f808
--- /dev/null
+++ b/src/leap/gui/tests/test_firstrun_register.py
@@ -0,0 +1,244 @@
+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
+
+try:
+    from collections import OrderedDict
+except ImportError:
+    # We must be in 2.6
+    from leap.util.dicts import OrderedDict
+
+
+class TestPage(firstrun.register.RegisterUserPage):
+
+    def field(self, field):
+        if field == "provider_domain":
+            return "testprovider"
+
+
+class RegisterUserPageLogicTestCase(qunittest.TestCase):
+
+    # XXX can spy on signal connections
+    __name__ = "register user page logic tests"
+
+    def setUp(self):
+        self.app = QtGui.QApplication(sys.argv)
+        QtGui.qApp = self.app
+        self.page = TestPage(None)
+        self.page.wizard = mock.MagicMock()
+
+        #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
+        self.app = None
+        self.page = None
+
+    def test__do_checks(self):
+        eq = self.assertEqual
+
+        self.page.userNameLineEdit.setText('testuser')
+        self.page.userPasswordLineEdit.setText('testpassword')
+        self.page.userPassword2LineEdit.setText('testpassword')
+
+        # fake register process
+        with mock.patch('leap.base.auth.LeapSRPRegister') as mockAuth:
+            mockSignup = mock.MagicMock()
+
+            reqMockup = mock.Mock()
+            # XXX should inject bad json to get error
+            reqMockup.content = '{"errors": null}'
+            mockSignup.register_user.return_value = (True, reqMockup)
+            mockAuth.return_value = mockSignup
+            checks = [x for x in self.page._do_checks()]
+
+            eq(len(checks), 3)
+            labels = [str(x) for (x, y), z in checks]
+            eq(labels, ['head_sentinel',
+                        'Registering username',
+                        'end_sentinel'])
+            progress = [y for (x, y), z in checks]
+            eq(progress, [0, 40, 100])
+
+            # normal run, ie, no exceptions
+
+            checkfuns = [z for (x, y), z in checks]
+            passcheck, register = checkfuns[:-1]
+
+            self.assertTrue(passcheck())
+            #self.mocknetchecker.check_name_resolution.assert_called_with(
+                #'test_provider1')
+
+            self.assertTrue(register())
+            #self.mockpcertchecker.is_https_working.assert_called_with(
+                #"https://test_provider1", verify=True)
+
+        # XXX missing: inject failing exceptions
+        # XXX TODO make it break
+
+
+class RegisterUserPageUITestCase(qunittest.TestCase):
+
+    # XXX can spy on signal connections
+    __name__ = "Register User Page UI tests"
+
+    def setUp(self):
+        self.app = QtGui.QApplication(sys.argv)
+        QtGui.qApp = self.app
+
+        self.pagename = "signup"
+        pages = OrderedDict((
+            (self.pagename, TestPage),
+            ('connect',
+             firstrun.connect.ConnectionPage)))
+        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_field(self, field, text):
+        """
+        fills a field (line edit) that is passed along
+        :param field: the qLineEdit
+        :param text: the text to be filled
+        :type field: QLineEdit widget
+        :type text: str
+        """
+        keyp = QTest.keyPress
+        field.setFocus(True)
+        for c in text:
+            keyp(field, c)
+        self.assertEqual(field.text(), text)
+
+    def del_field(self, field):
+        """
+        deletes entried text in
+        field line edit
+        :param field: the QLineEdit
+        :type field: QLineEdit widget
+        """
+        keyp = QTest.keyPress
+        for c in range(len(field.text())):
+            keyp(field, Qt.Key_Backspace)
+        self.assertEqual(field.text(), "")
+
+    def test_buttons_disabled_until_textentry(self):
+        # it's a commit button this time
+        nextbutton = self.wizard.button(QtGui.QWizard.CommitButton)
+
+        self.assertFalse(nextbutton.isEnabled())
+
+        f_username = self.page.userNameLineEdit
+        f_password = self.page.userPasswordLineEdit
+        f_passwor2 = self.page.userPassword2LineEdit
+
+        self.fill_field(f_username, "testuser")
+        self.fill_field(f_password, "testpassword")
+        self.fill_field(f_passwor2, "testpassword")
+
+        # commit should be enabled
+        # XXX Need a workaround here
+        # because the isComplete is not being evaluated...
+        # (no event loop running??)
+        #import ipdb;ipdb.set_trace()
+        #self.assertTrue(nextbutton.isEnabled())
+        self.assertTrue(self.page.isComplete())
+
+        self.del_field(f_username)
+        self.del_field(f_password)
+        self.del_field(f_passwor2)
+
+        # after rm fields commit button
+        # should be disabled again
+        #self.assertFalse(nextbutton.isEnabled())
+        self.assertFalse(self.page.isComplete())
+
+    @unittest.skip
+    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_validate_page(self):
+        self.assertFalse(self.page.validatePage())
+        # XXX TODO MOAR CASES...
+        # add errors, False
+        # change done, False
+        # not done, do_checks called
+        # click confirm, True
+        # done and do_confirm, True
+
+    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()
+
+    def test_validation_ready(self):
+        f_username = self.page.userNameLineEdit
+        f_password = self.page.userPasswordLineEdit
+        f_passwor2 = self.page.userPassword2LineEdit
+
+        self.fill_field(f_username, "testuser")
+        self.fill_field(f_password, "testpassword")
+        self.fill_field(f_passwor2, "testpassword")
+
+        self.page.done = True
+        self.page.on_checks_validation_ready()
+        self.assertFalse(f_username.isEnabled())
+        self.assertFalse(f_password.isEnabled())
+        self.assertFalse(f_passwor2.isEnabled())
+
+        self.assertEqual(self.page.validationMsg.text(),
+                         "Registration succeeded!")
+        self.assertEqual(self.page.do_confirm_next, True)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/src/leap/gui/tests/test_firstrun_wizard.py b/src/leap/gui/tests/test_firstrun_wizard.py
new file mode 100644
index 00000000..395604d3
--- /dev/null
+++ b/src/leap/gui/tests/test_firstrun_wizard.py
@@ -0,0 +1,137 @@
+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 TestWizard(firstrun.wizard.FirstRunWizard):
+    pass
+
+
+PAGES_DICT = dict((
+    ('intro', firstrun.intro.IntroPage),
+    ('providerselection',
+        firstrun.providerselect.SelectProviderPage),
+    ('login', firstrun.login.LogInPage),
+    ('providerinfo', firstrun.providerinfo.ProviderInfoPage),
+    ('providersetupvalidation',
+        firstrun.providersetup.ProviderSetupValidationPage),
+    ('signup', firstrun.register.RegisterUserPage),
+    ('connect',
+        firstrun.connect.ConnectionPage),
+    ('lastpage', firstrun.last.LastPage)
+))
+
+
+mockQSettings = mock.MagicMock()
+mockQSettings().setValue.return_value = True
+
+#PyQt4.QtCore.QSettings = mockQSettings
+
+
+class FirstRunWizardTestCase(qunittest.TestCase):
+
+    # XXX can spy on signal connections
+
+    def setUp(self):
+        self.app = QtGui.QApplication(sys.argv)
+        QtGui.qApp = self.app
+        self.wizard = TestWizard(None)
+
+    def tearDown(self):
+        QtGui.qApp = None
+        self.app = None
+        self.wizard = None
+
+    def test_defaults(self):
+        self.assertEqual(self.wizard.pages_dict, PAGES_DICT)
+
+    @mock.patch('PyQt4.QtCore.QSettings', mockQSettings)
+    def test_accept(self):
+        """
+        test the main accept method
+        that gets called when user has gone
+        thru all the wizard and click on finish button
+        """
+
+        self.wizard.success_cb = mock.Mock()
+        self.wizard.success_cb.return_value = True
+
+        # dummy values; we inject them in the field
+        # mocks (where wizard gets them) and then
+        # we check that they are passed to QSettings.setValue
+        field_returns = ["testuser", "1234", "testprovider", True]
+
+        def field_side_effects(*args):
+            return field_returns.pop(0)
+
+        self.wizard.field = mock.Mock(side_effect=field_side_effects)
+        self.wizard.get_random_str = mock.Mock()
+        RANDOMSTR = "thisisarandomstringTM"
+        self.wizard.get_random_str.return_value = RANDOMSTR
+
+        # mocked settings (see decorator on this method)
+        mqs = PyQt4.QtCore.QSettings
+
+        # go! call accept...
+        self.wizard.accept()
+
+        # did settings().setValue get called with the proper
+        # arguments?
+        call = mock.call
+        calls = [call("FirstRunWizardDone", True),
+                 call("provider_domain", "testprovider"),
+                 call("remember_user_and_pass", True),
+                 call("username", "testuser@testprovider"),
+                 call("testprovider_seed", RANDOMSTR)]
+        mqs().setValue.assert_has_calls(calls, any_order=True)
+
+        # assert success callback is success oh boy
+        self.wizard.success_cb.assert_called_with()
+
+    def test_random_str(self):
+        r = self.wizard.get_random_str(42)
+        self.assertTrue(len(r) == 42)
+
+    def test_page_index(self):
+        """
+        we test both the get_page_index function
+        and the correct ordering of names
+        """
+        # remember it's implemented as an ordered dict
+
+        pagenames = ('intro', 'providerselection', 'login', 'providerinfo',
+                     'providersetupvalidation', 'signup', 'connect',
+                     'lastpage')
+        eq = self.assertEqual
+        w = self.wizard
+        for index, name in enumerate(pagenames):
+            eq(w.get_page_index(name), index)
+
+    def test_validation_errors(self):
+        """
+        tests getters and setters for validation errors
+        """
+        page = "testpage"
+        eq = self.assertEqual
+        w = self.wizard
+        eq(w.get_validation_error(page), None)
+        w.set_validation_error(page, "error")
+        eq(w.get_validation_error(page), "error")
+        w.clean_validation_error(page)
+        eq(w.get_validation_error(page), None)
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/src/leap/gui/tests/test_mainwindow_rc.py b/src/leap/gui/tests/test_mainwindow_rc.py
new file mode 100644
index 00000000..5004b0ac
--- /dev/null
+++ b/src/leap/gui/tests/test_mainwindow_rc.py
@@ -0,0 +1,32 @@
+import unittest
+import hashlib
+
+try:
+    import sip
+    sip.setapi('QVariant', 2)
+except ValueError:
+    pass
+
+from leap.gui import mainwindow_rc
+
+# I have to admit that there's something
+# perverse in testing this.
+# Even though, I still think that it _is_ a good idea
+# to put a check to avoid non-updated resources files.
+
+# so, if you came here because an updated resource
+# did break a test, what you have to do is getting
+# the md5 hash of your qt_resource_data and change it here.
+
+# annoying? yep. try making a script for that :P
+
+
+class MainWindowResourcesTest(unittest.TestCase):
+
+    def test_mainwindow_resources_hash(self):
+        self.assertEqual(
+            hashlib.md5(mainwindow_rc.qt_resource_data).hexdigest(),
+            'ff331dc5ab50df1572b4f5c5a2691ce5')
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/src/leap/gui/tests/test_progress.py b/src/leap/gui/tests/test_progress.py
new file mode 100644
index 00000000..1f9f9e38
--- /dev/null
+++ b/src/leap/gui/tests/test_progress.py
@@ -0,0 +1,449 @@
+from collections import namedtuple
+import sys
+import unittest
+import Queue
+
+import mock
+
+from leap.testing import qunittest
+from leap.testing import pyqt
+
+from PyQt4 import QtGui
+from PyQt4 import QtCore
+from PyQt4.QtTest import QTest
+from PyQt4.QtCore import Qt
+
+from leap.gui import progress
+
+
+class ProgressStepTestCase(unittest.TestCase):
+
+    def test_step_attrs(self):
+        ps = progress.ProgressStep
+        step = ps('test', False, 1)
+        # instance
+        self.assertEqual(step.index, 1)
+        self.assertEqual(step.name, "test")
+        self.assertEqual(step.done, False)
+        step = ps('test2', True, 2)
+        self.assertEqual(step.index, 2)
+        self.assertEqual(step.name, "test2")
+        self.assertEqual(step.done, True)
+
+        # class methods and attrs
+        self.assertEqual(ps.columns(), ('name', 'done'))
+        self.assertEqual(ps.NAME, 0)
+        self.assertEqual(ps.DONE, 1)
+
+
+class ProgressStepContainerTestCase(unittest.TestCase):
+    def setUp(self):
+        self.psc = progress.ProgressStepContainer()
+
+    def addSteps(self, number):
+        Step = progress.ProgressStep
+        for n in range(number):
+            self.psc.addStep(Step("%s" % n, False, n))
+
+    def test_attrs(self):
+        self.assertEqual(self.psc.columns,
+                         ('name', 'done'))
+
+    def test_add_steps(self):
+        Step = progress.ProgressStep
+        self.assertTrue(len(self.psc) == 0)
+        self.psc.addStep(Step('one', False, 0))
+        self.assertTrue(len(self.psc) == 1)
+        self.psc.addStep(Step('two', False, 1))
+        self.assertTrue(len(self.psc) == 2)
+
+    def test_del_all_steps(self):
+        self.assertTrue(len(self.psc) == 0)
+        self.addSteps(5)
+        self.assertTrue(len(self.psc) == 5)
+        self.psc.removeAllSteps()
+        self.assertTrue(len(self.psc) == 0)
+
+    def test_del_step(self):
+        Step = progress.ProgressStep
+        self.addSteps(5)
+        self.assertTrue(len(self.psc) == 5)
+        self.psc.removeStep(self.psc.step(4))
+        self.assertTrue(len(self.psc) == 4)
+        self.psc.removeStep(self.psc.step(4))
+        self.psc.removeStep(Step('none', False, 5))
+        self.psc.removeStep(self.psc.step(4))
+
+    def test_iter(self):
+        self.addSteps(10)
+        self.assertEqual(
+            [x.index for x in self.psc],
+            [x for x in range(10)])
+
+
+class StepsTableWidgetTestCase(unittest.TestCase):
+
+    def setUp(self):
+        self.app = QtGui.QApplication(sys.argv)
+        QtGui.qApp = self.app
+        self.stw = progress.StepsTableWidget()
+
+    def tearDown(self):
+        QtGui.qApp = None
+        self.app = None
+
+    def test_defaults(self):
+        self.assertTrue(isinstance(self.stw, QtGui.QTableWidget))
+        self.assertEqual(self.stw.focusPolicy(), 0)
+
+
+class TestWithStepsClass(QtGui.QWidget, progress.WithStepsMixIn):
+
+    def __init__(self, parent=None):
+        super(TestWithStepsClass, self).__init__(parent=parent)
+        self.setupStepsProcessingQueue()
+        self.statuses = []
+        self.current_page = "testpage"
+
+    def onStepStatusChanged(self, *args):
+        """
+        blank out this gui method
+        that will add status lines
+        """
+        self.statuses.append(args)
+
+
+class WithStepsMixInTestCase(qunittest.TestCase):
+
+    TIMER_WAIT = 2 * progress.WithStepsMixIn.STEPS_TIMER_MS / 1000.0
+
+    # XXX can spy on signal connections
+
+    def setUp(self):
+        self.app = QtGui.QApplication(sys.argv)
+        QtGui.qApp = self.app
+        self.stepy = TestWithStepsClass()
+        #self.connects = []
+        #pyqt.enableSignalDebugging(
+            #connectCall=lambda *args: self.connects.append(args))
+        #self.assertEqual(self.connects, [])
+        #self.stepy.stepscheck_timer.timeout.disconnect(
+            #self.stepy.processStepsQueue)
+
+    def tearDown(self):
+        QtGui.qApp = None
+        self.app = None
+
+    def test_has_queue(self):
+        s = self.stepy
+        self.assertTrue(hasattr(s, 'steps_queue'))
+        self.assertTrue(isinstance(s.steps_queue, Queue.Queue))
+        self.assertTrue(isinstance(s.stepscheck_timer, QtCore.QTimer))
+
+    def test_do_checks_delegation(self):
+        s = self.stepy
+
+        _do_checks = mock.Mock()
+        _do_checks.return_value = (
+            (("test", 0), lambda: None),
+            (("test", 0), lambda: None))
+        s._do_checks = _do_checks
+        s.do_checks()
+        self.waitFor(seconds=self.TIMER_WAIT)
+        _do_checks.assert_called_with()
+        self.assertEqual(len(s.statuses), 2)
+
+        # test that a failed test interrupts the run
+
+        s.statuses = []
+        _do_checks = mock.Mock()
+        _do_checks.return_value = (
+            (("test", 0), lambda: None),
+            (("test", 0), lambda: False),
+            (("test", 0), lambda: None))
+        s._do_checks = _do_checks
+        s.do_checks()
+        self.waitFor(seconds=self.TIMER_WAIT)
+        _do_checks.assert_called_with()
+        self.assertEqual(len(s.statuses), 2)
+
+    def test_process_queue(self):
+        s = self.stepy
+        q = s.steps_queue
+        s.set_failed_icon = mock.MagicMock()
+        with self.assertRaises(AssertionError):
+            q.put('foo')
+            self.waitFor(seconds=self.TIMER_WAIT)
+            s.set_failed_icon.assert_called_with()
+        q.put("failed")
+        self.waitFor(seconds=self.TIMER_WAIT)
+        s.set_failed_icon.assert_called_with()
+
+    def test_on_checks_validation_ready_called(self):
+        s = self.stepy
+        s.on_checks_validation_ready = mock.MagicMock()
+
+        _do_checks = mock.Mock()
+        _do_checks.return_value = (
+            (("test", 0), lambda: None),)
+        s._do_checks = _do_checks
+        s.do_checks()
+
+        self.waitFor(seconds=self.TIMER_WAIT)
+        s.on_checks_validation_ready.assert_called_with()
+
+    def test_fail(self):
+        s = self.stepy
+
+        s.wizard = mock.Mock()
+        wizard = s.wizard.return_value
+        wizard.set_validation_error.return_value = True
+        s.completeChanged = mock.Mock()
+        s.completeChanged.emit.return_value = True
+
+        self.assertFalse(s.fail(err="foo"))
+        self.waitFor(seconds=self.TIMER_WAIT)
+        wizard.set_validation_error.assert_called_with('testpage', 'foo')
+        s.completeChanged.emit.assert_called_with()
+
+        # with no args
+        s.wizard = mock.Mock()
+        wizard = s.wizard.return_value
+        wizard.set_validation_error.return_value = True
+        s.completeChanged = mock.Mock()
+        s.completeChanged.emit.return_value = True
+
+        self.assertFalse(s.fail())
+        self.waitFor(seconds=self.TIMER_WAIT)
+        with self.assertRaises(AssertionError):
+            wizard.set_validation_error.assert_called_with()
+        s.completeChanged.emit.assert_called_with()
+
+    def test_done(self):
+        s = self.stepy
+        s.done = False
+
+        s.completeChanged = mock.Mock()
+        s.completeChanged.emit.return_value = True
+
+        self.assertFalse(s.is_done())
+        s.set_done()
+        self.assertTrue(s.is_done())
+        s.completeChanged.emit.assert_called_with()
+
+        s.completeChanged = mock.Mock()
+        s.completeChanged.emit.return_value = True
+        s.set_undone()
+        self.assertFalse(s.is_done())
+
+    def test_back_and_next(self):
+        s = self.stepy
+        s.wizard = mock.Mock()
+        wizard = s.wizard.return_value
+        wizard.back.return_value = True
+        wizard.next.return_value = True
+        s.go_back()
+        wizard.back.assert_called_with()
+        s.go_next()
+        wizard.next.assert_called_with()
+
+    def test_on_step_statuschanged_slot(self):
+        s = self.stepy
+        s.onStepStatusChanged = progress.WithStepsMixIn.onStepStatusChanged
+        s.add_status_line = mock.Mock()
+        s.set_checked_icon = mock.Mock()
+        s.progress = mock.Mock()
+        s.progress.setValue.return_value = True
+        s.progress.update.return_value = True
+
+        s.onStepStatusChanged(s, "end_sentinel")
+        s.set_checked_icon.assert_called_with()
+
+        s.onStepStatusChanged(s, "foo")
+        s.add_status_line.assert_called_with("foo")
+
+        s.onStepStatusChanged(s, "bar", 42)
+        s.progress.setValue.assert_called_with(42)
+        s.progress.update.assert_called_with()
+
+    def test_steps_and_errors(self):
+        s = self.stepy
+        s.setupSteps()
+        self.assertTrue(isinstance(s.steps, progress.ProgressStepContainer))
+        self.assertEqual(s.errors, {})
+        s.set_error('fooerror', 'barerror')
+        self.assertEqual(s.errors, {'fooerror': 'barerror'})
+        s.set_error('2', 42)
+        self.assertEqual(s.errors, {'fooerror': 'barerror', '2': 42})
+        fe = s.pop_first_error()
+        self.assertEqual(fe, ('fooerror', 'barerror'))
+        self.assertEqual(s.errors, {'2': 42})
+        s.clean_errors()
+        self.assertEqual(s.errors, {})
+
+    def test_launch_chechs_slot(self):
+        s = self.stepy
+        s.do_checks = mock.Mock()
+        s.launch_checks()
+        s.do_checks.assert_called_with()
+
+    def test_clean_wizard_errors(self):
+        s = self.stepy
+        s.wizard = mock.Mock()
+        wizard = s.wizard.return_value
+        wizard.set_validation_error.return_value = True
+        s.clean_wizard_errors(pagename="foopage")
+        wizard.set_validation_error.assert_called_with("foopage", None)
+
+    def test_clear_table(self):
+        s = self.stepy
+        s.stepsTableWidget = mock.Mock()
+        s.stepsTableWidget.clearContents.return_value = True
+        s.clearTable()
+        s.stepsTableWidget.clearContents.assert_called_with()
+
+    def test_populate_steps_table(self):
+        s = self.stepy
+        Step = namedtuple('Step', ['name', 'done'])
+
+        class Steps(object):
+            columns = ("name", "done")
+            _items = (Step('step1', False), Step('step2', False))
+
+            def __len__(self):
+                return 2
+
+            def __iter__(self):
+                for i in self._items:
+                    yield i
+
+        s.steps = Steps()
+
+        s.stepsTableWidget = mock.Mock()
+        s.stepsTableWidget.setItem.return_value = True
+        s.resizeTable = mock.Mock()
+        s.update = mock.Mock()
+        s.populateStepsTable()
+        s.update.assert_called_with()
+        s.resizeTable.assert_called_with()
+
+        # assert stepsTableWidget.setItem called ...
+        # we do not want to get into the actual
+        # <QTableWidgetItem object at 0x92a565c>
+        call_list = s.stepsTableWidget.setItem.call_args_list
+        indexes = [(y, z) for y, z, xx in [x[0] for x in call_list]]
+        self.assertEqual(indexes,
+                         [(0, 0), (0, 1), (1, 0), (1, 1)])
+
+    def test_add_status_line(self):
+        s = self.stepy
+        s.steps = progress.ProgressStepContainer()
+        s.stepsTableWidget = mock.Mock()
+        s.stepsTableWidget.width.return_value = 100
+        s.set_item = mock.Mock()
+        s.set_item_icon = mock.Mock()
+        s.add_status_line("new status")
+        s.set_item_icon.assert_called_with(current=False)
+
+    def test_set_item_icon(self):
+        s = self.stepy
+        s.steps = progress.ProgressStepContainer()
+        s.stepsTableWidget = mock.Mock()
+        s.stepsTableWidget.setCellWidget.return_value = True
+        s.stepsTableWidget.width.return_value = 100
+        #s.set_item = mock.Mock()
+        #s.set_item_icon = mock.Mock()
+        s.add_status_line("new status")
+        s.add_status_line("new 2 status")
+        s.add_status_line("new 3 status")
+        call_list = s.stepsTableWidget.setCellWidget.call_args_list
+        indexes = [(y, z) for y, z, xx in [x[0] for x in call_list]]
+        self.assertEqual(
+            indexes,
+            [(0, 1), (-1, 1), (1, 1), (0, 1), (2, 1), (1, 1)])
+
+
+class TestInlineValidationPage(progress.InlineValidationPage):
+    pass
+
+
+class InlineValidationPageTestCase(unittest.TestCase):
+
+    def setUp(self):
+        self.app = QtGui.QApplication(sys.argv)
+        QtGui.qApp = self.app
+        self.page = TestInlineValidationPage()
+
+    def tearDown(self):
+        QtGui.qApp = None
+        self.app = None
+
+    def test_defaults(self):
+        self.assertFalse(self.page.done)
+        # if setupProcessingQueue was  called
+        self.assertTrue(isinstance(self.page.stepscheck_timer, QtCore.QTimer))
+        self.assertTrue(isinstance(self.page.steps_queue, Queue.Queue))
+
+    def test_validation_frame(self):
+        # test frame creation
+        self.page.stepsTableWidget = progress.StepsTableWidget(
+            parent=self.page)
+        self.page.setupValidationFrame()
+        self.assertTrue(isinstance(self.page.valFrame, QtGui.QFrame))
+
+        # test show steps calls frame.show
+        self.page.valFrame = mock.Mock()
+        self.page.valFrame.show.return_value = True
+        self.page.showStepsFrame()
+        self.page.valFrame.show.assert_called_with()
+
+
+class TestValidationPage(progress.ValidationPage):
+    pass
+
+
+class ValidationPageTestCase(unittest.TestCase):
+
+    def setUp(self):
+        self.app = QtGui.QApplication(sys.argv)
+        QtGui.qApp = self.app
+        self.page = TestValidationPage()
+
+    def tearDown(self):
+        QtGui.qApp = None
+        self.app = None
+
+    def test_defaults(self):
+        self.assertFalse(self.page.done)
+        # if setupProcessingQueue was  called
+        self.assertTrue(isinstance(self.page.timer, QtCore.QTimer))
+        self.assertTrue(isinstance(self.page.stepscheck_timer, QtCore.QTimer))
+        self.assertTrue(isinstance(self.page.steps_queue, Queue.Queue))
+
+    def test_is_complete(self):
+        self.assertFalse(self.page.isComplete())
+        self.page.done = True
+        self.assertTrue(self.page.isComplete())
+        self.page.done = False
+        self.assertFalse(self.page.isComplete())
+
+    def test_show_hide_progress(self):
+        p = self.page
+        p.progress = mock.Mock()
+        p.progress.show.return_code = True
+        p.show_progress()
+        p.progress.show.assert_called_with()
+        p.progress.hide.return_code = True
+        p.hide_progress()
+        p.progress.hide.assert_called_with()
+
+    def test_initialize_page(self):
+        p = self.page
+        p.timer = mock.Mock()
+        p.timer.singleShot.return_code = True
+        p.initializePage()
+        p.timer.singleShot.assert_called_with(0, p.do_checks)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/src/leap/gui/tests/test_threads.py b/src/leap/gui/tests/test_threads.py
new file mode 100644
index 00000000..06c19606
--- /dev/null
+++ b/src/leap/gui/tests/test_threads.py
@@ -0,0 +1,27 @@
+import unittest
+
+import mock
+from leap.gui import threads
+
+
+class FunThreadTestCase(unittest.TestCase):
+
+    def setUp(self):
+        self.fun = mock.MagicMock()
+        self.fun.return_value = "foo"
+        self.t = threads.FunThread(fun=self.fun)
+
+    def test_thread(self):
+        self.t.begin()
+        self.t.wait()
+        self.fun.assert_called()
+        del self.t
+
+    def test_run(self):
+        # this is called by PyQt
+        self.t.run()
+        del self.t
+        self.fun.assert_called()
+
+if __name__ == "__main__":
+    unittest.main()