Remove everything to start from scratch

9 files changed, 0 insertions, 1388 deletions

diff --git a/src/leap/gui/tests/__init__.py b/src/leap/gui/tests/__init__.py
deleted file mode 100644
index e69de29b..00000000
--- a/src/leap/gui/tests/__init__.py
+++ /dev/null
diff --git a/src/leap/gui/tests/integration/fake_user_signup.py b/src/leap/gui/tests/integration/fake_user_signup.py
deleted file mode 100644
index 78873749..00000000
--- a/src/leap/gui/tests/integration/fake_user_signup.py
+++ /dev/null
@@ -1,84 +0,0 @@
-"""
-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
deleted file mode 100644
index 6c45b8ef..00000000
--- a/src/leap/gui/tests/test_firstrun_login.py
+++ /dev/null
@@ -1,212 +0,0 @@
-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
deleted file mode 100644
index 18d89010..00000000
--- a/src/leap/gui/tests/test_firstrun_providerselect.py
+++ /dev/null
@@ -1,203 +0,0 @@
-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
deleted file mode 100644
index 9d62f808..00000000
--- a/src/leap/gui/tests/test_firstrun_register.py
+++ /dev/null
@@ -1,244 +0,0 @@
-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
deleted file mode 100644
index 395604d3..00000000
--- a/src/leap/gui/tests/test_firstrun_wizard.py
+++ /dev/null
@@ -1,137 +0,0 @@
-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
deleted file mode 100644
index 9f5172f7..00000000
--- a/src/leap/gui/tests/test_mainwindow_rc.py
+++ /dev/null
@@ -1,32 +0,0 @@
-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(),
-            'e04cb467985ba38b9eb91e7689f9458f')
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/src/leap/gui/tests/test_progress.py b/src/leap/gui/tests/test_progress.py
deleted file mode 100644
index 1f9f9e38..00000000
--- a/src/leap/gui/tests/test_progress.py
+++ /dev/null
@@ -1,449 +0,0 @@
-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
deleted file mode 100644
index 06c19606..00000000
--- a/src/leap/gui/tests/test_threads.py
+++ /dev/null
@@ -1,27 +0,0 @@
-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()