Move GUI tests into tests/ dir and fix conftest related stuff so everything loads what it needs and passes

tests/GuiBaseTest.py

@@ -0,0 +1,275 @@
+import json
+import os
+import requests
+import shutil
+import socket
+import socks
+
+from PyQt5 import QtCore, QtTest
+
+from onionshare import strings
+from onionshare.common import Common
+from onionshare.settings import Settings
+from onionshare.onion import Onion
+from onionshare.web import Web
+from onionshare_gui import Application, OnionShare, OnionShareGui
+from onionshare_gui.mode.share_mode import ShareMode
+from onionshare_gui.mode.receive_mode import ReceiveMode
+
+
+class GuiBaseTest(object):
+    @staticmethod
+    def set_up(test_settings, settings_filename):
+        '''Create GUI with given settings'''
+        # Create our test file
+        testfile = open('/tmp/test.txt', 'w')
+        testfile.write('onionshare')
+        testfile.close()
+
+        common = Common()
+        common.settings = Settings(common)
+        common.define_css()
+        strings.load_strings(common)
+
+        # Get all of the settings in test_settings
+        test_settings['downloads_dir'] = '/tmp/OnionShare'
+        for key, val in common.settings.default_settings.items():
+            if key not in test_settings:
+                test_settings[key] = val
+
+        # Start the Onion
+        testonion = Onion(common)
+        global qtapp
+        qtapp = Application(common)
+        app = OnionShare(common, testonion, True, 0)
+
+        web = Web(common, False, True)
+        open('/tmp/{}.json'.format(settings_filename), 'w').write(json.dumps(test_settings))
+
+        gui = OnionShareGui(common, testonion, qtapp, app, ['/tmp/test.txt'], '/tmp/{}.json'.format(settings_filename), True)
+        return gui
+
+    @staticmethod
+    def tear_down():
+        try:
+            os.remove('/tmp/test.txt')
+            shutil.rmtree('/tmp/OnionShare')
+        except:
+            pass
+
+    
+    def gui_loaded(self):
+        '''Test that the GUI actually is shown'''
+        self.assertTrue(self.gui.show)
+
+    
+    def windowTitle_seen(self):
+        '''Test that the window title is OnionShare'''
+        self.assertEqual(self.gui.windowTitle(), 'OnionShare')
+
+    
+    def settings_button_is_visible(self):
+        '''Test that the settings button is visible'''
+        self.assertTrue(self.gui.settings_button.isVisible())
+
+    
+    def server_status_bar_is_visible(self):
+        '''Test that the status bar is visible'''
+        self.assertTrue(self.gui.status_bar.isVisible())
+
+    
+    def click_mode(self, mode):
+        '''Test that we can switch Mode by clicking the button'''
+        if type(mode) == ReceiveMode:
+            QtTest.QTest.mouseClick(self.gui.receive_mode_button, QtCore.Qt.LeftButton)
+            self.assertTrue(self.gui.mode, self.gui.MODE_RECEIVE)
+        if type(mode) == ShareMode:
+            QtTest.QTest.mouseClick(self.gui.share_mode_button, QtCore.Qt.LeftButton)
+            self.assertTrue(self.gui.mode, self.gui.MODE_SHARE)
+
+    
+    def click_toggle_history(self, mode):
+        '''Test that we can toggle Download or Upload history by clicking the toggle button'''
+        currently_visible = mode.history.isVisible()
+        QtTest.QTest.mouseClick(mode.toggle_history, QtCore.Qt.LeftButton)
+        self.assertEqual(mode.history.isVisible(), not currently_visible)
+
+    
+    def history_indicator(self, mode, public_mode):
+        '''Test that we can make sure the history is toggled off, do an action, and the indiciator works'''
+        # Make sure history is toggled off
+        if mode.history.isVisible():
+            QtTest.QTest.mouseClick(mode.toggle_history, QtCore.Qt.LeftButton)
+            self.assertFalse(mode.history.isVisible())
+
+        # Indicator should not be visible yet
+        self.assertFalse(mode.toggle_history.indicator_label.isVisible())
+
+        if type(mode) == ReceiveMode:
+            # Upload a file
+            files = {'file[]': open('/tmp/test.txt', 'rb')}
+            if not public_mode:
+                path = 'http://127.0.0.1:{}/{}/upload'.format(self.gui.app.port, mode.web.slug)
+            else:
+                path = 'http://127.0.0.1:{}/upload'.format(self.gui.app.port)
+            response = requests.post(path, files=files)
+            QtTest.QTest.qWait(2000)
+
+        if type(mode) == ShareMode:
+            # Download files
+            if public_mode:
+                url = "http://127.0.0.1:{}/download".format(self.gui.app.port)
+            else:
+                url = "http://127.0.0.1:{}/{}/download".format(self.gui.app.port, mode.web.slug)
+            r = requests.get(url)
+            QtTest.QTest.qWait(2000)
+
+        # Indicator should be visible, have a value of "1"
+        self.assertTrue(mode.toggle_history.indicator_label.isVisible())
+        self.assertEqual(mode.toggle_history.indicator_label.text(), "1")
+
+        # Toggle history back on, indicator should be hidden again
+        QtTest.QTest.mouseClick(mode.toggle_history, QtCore.Qt.LeftButton)
+        self.assertFalse(mode.toggle_history.indicator_label.isVisible())
+
+    
+    def history_is_not_visible(self, mode):
+        '''Test that the History section is not visible'''
+        self.assertFalse(mode.history.isVisible())
+
+    
+    def history_is_visible(self, mode):
+        '''Test that the History section is visible'''
+        self.assertTrue(mode.history.isVisible())
+
+    
+    def server_working_on_start_button_pressed(self, mode):
+        '''Test we can start the service'''
+        # Should be in SERVER_WORKING state
+        QtTest.QTest.mouseClick(mode.server_status.server_button, QtCore.Qt.LeftButton)
+        self.assertEqual(mode.server_status.status, 1)
+
+    
+    def server_status_indicator_says_starting(self, mode):
+        '''Test that the Server Status indicator shows we are Starting'''
+        self.assertEquals(mode.server_status_label.text(), strings._('gui_status_indicator_share_working'))
+
+    
+    def settings_button_is_hidden(self):
+        '''Test that the settings button is hidden when the server starts'''
+        self.assertFalse(self.gui.settings_button.isVisible())
+
+    
+    def a_server_is_started(self, mode):
+        '''Test that the server has started'''
+        QtTest.QTest.qWait(2000)
+        # Should now be in SERVER_STARTED state
+        self.assertEqual(mode.server_status.status, 2)
+
+    
+    def a_web_server_is_running(self):
+        '''Test that the web server has started'''
+        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+
+        self.assertEqual(sock.connect_ex(('127.0.0.1',self.gui.app.port)), 0)
+
+    
+    def have_a_slug(self, mode, public_mode):
+        '''Test that we have a valid slug'''
+        if not public_mode:
+            self.assertRegex(mode.server_status.web.slug, r'(\w+)-(\w+)')
+        else:
+            self.assertIsNone(mode.server_status.web.slug, r'(\w+)-(\w+)')
+
+    
+    def url_description_shown(self, mode):
+        '''Test that the URL label is showing'''
+        self.assertTrue(mode.server_status.url_description.isVisible())
+
+    
+    def have_copy_url_button(self, mode):
+        '''Test that the Copy URL button is shown'''
+        self.assertTrue(mode.server_status.copy_url_button.isVisible())
+
+    
+    def server_status_indicator_says_started(self, mode):
+        '''Test that the Server Status indicator shows we are started'''
+        if type(mode) == ReceiveMode:
+            self.assertEquals(mode.server_status_label.text(), strings._('gui_status_indicator_receive_started'))
+        if type(mode) == ShareMode:
+            self.assertEquals(mode.server_status_label.text(), strings._('gui_status_indicator_share_started'))
+
+    
+    def web_page(self, mode, string, public_mode):
+        '''Test that the web page contains a string'''
+        s = socks.socksocket()
+        s.settimeout(60)
+        s.connect(('127.0.0.1', self.gui.app.port))
+
+        if not public_mode:
+            path = '/{}'.format(mode.server_status.web.slug)
+        else:
+            path = '/'
+
+        http_request = 'GET {} HTTP/1.0\r\n'.format(path)
+        http_request += 'Host: 127.0.0.1\r\n'
+        http_request += '\r\n'
+        s.sendall(http_request.encode('utf-8'))
+
+        with open('/tmp/webpage', 'wb') as file_to_write:
+            while True:
+               data = s.recv(1024)
+               if not data:
+                   break
+               file_to_write.write(data)
+            file_to_write.close()
+
+        f = open('/tmp/webpage')
+        self.assertTrue(string in f.read())
+        f.close()
+
+    
+    def history_widgets_present(self, mode):
+        '''Test that the relevant widgets are present in the history view after activity has taken place'''
+        self.assertFalse(mode.history.empty.isVisible())
+        self.assertTrue(mode.history.not_empty.isVisible())
+
+    
+    def counter_incremented(self, mode, count):
+        '''Test that the counter has incremented'''
+        self.assertEquals(mode.history.completed_count, count)
+
+    
+    def server_is_stopped(self, mode, stay_open):
+        '''Test that the server stops when we click Stop'''
+        if type(mode) == ReceiveMode or (type(mode) == ShareMode and stay_open):
+            QtTest.QTest.mouseClick(mode.server_status.server_button, QtCore.Qt.LeftButton)
+        self.assertEquals(mode.server_status.status, 0)
+
+    
+    def web_service_is_stopped(self):
+        '''Test that the web server also stopped'''
+        QtTest.QTest.qWait(2000)
+        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+
+        # We should be closed by now. Fail if not!
+        self.assertNotEqual(sock.connect_ex(('127.0.0.1',self.gui.app.port)), 0)
+
+    
+    def server_status_indicator_says_closed(self, mode, stay_open):
+        '''Test that the Server Status indicator shows we closed'''
+        if type(mode) == ReceiveMode:
+            self.assertEquals(self.gui.receive_mode.server_status_label.text(), strings._('gui_status_indicator_receive_stopped'))
+        if type(mode) == ShareMode:
+            if stay_open:
+                self.assertEquals(self.gui.share_mode.server_status_label.text(), strings._('gui_status_indicator_share_stopped'))
+            else:
+                self.assertEquals(self.gui.share_mode.server_status_label.text(), strings._('closing_automatically'))
+
+    def run_all_common_setup_tests(self):
+        self.gui_loaded()
+        self.windowTitle_seen()
+        self.settings_button_is_visible()
+        self.server_status_bar_is_visible()
+
+