From ec91e51ace379a1bff4cad3f332ea01086703510 Mon Sep 17 00:00:00 2001 From: Micah Lee Date: Fri, 8 Nov 2019 19:11:30 +0800 Subject: [PATCH] Start refactoring all of the share mode tests to work with tabs --- tests2/gui_base_test.py | 304 +++++++++++++++++----------- tests2/test_gui_share.py | 426 ++++++++++++++++++++------------------- tests2/test_gui_tabs.py | 56 +---- 3 files changed, 406 insertions(+), 380 deletions(-) diff --git a/tests2/gui_base_test.py b/tests2/gui_base_test.py index 2cd9c7b8..acc0b964 100644 --- a/tests2/gui_base_test.py +++ b/tests2/gui_base_test.py @@ -40,6 +40,9 @@ class GuiBaseTest(unittest.TestCase): with open(filename, "w") as file: file.write(secrets.token_hex(10)) cls.tmpfiles.append(filename) + cls.tmpfile_test = os.path.join(cls.tmpdir.name, "test.txt") + with open(cls.tmpfile_test, "w") as file: + file.write("onionshare") @classmethod def tearDownClass(cls): @@ -48,6 +51,64 @@ class GuiBaseTest(unittest.TestCase): # Shared test methods + def verify_new_tab(self, tab): + # Make sure the new tab widget is showing, and no mode has been started + self.assertTrue(tab.new_tab.isVisible()) + self.assertFalse(hasattr(tab, "share_mode")) + self.assertFalse(hasattr(tab, "receive_mode")) + self.assertFalse(hasattr(tab, "website_mode")) + + def new_share_tab(self): + tab = self.gui.tabs.widget(0) + self.verify_new_tab(tab) + + # Share files + tab.share_button.click() + self.assertFalse(tab.new_tab.isVisible()) + self.assertTrue(tab.share_mode.isVisible()) + + return tab + + def new_share_tab_with_files(self): + tab = self.new_share_tab() + + # Add files + for filename in self.tmpfiles: + tab.share_mode.server_status.file_selection.file_list.add_file(filename) + + return tab + + def new_receive_tab(self): + tab = self.gui.tabs.widget(0) + self.verify_new_tab(tab) + + # Receive files + tab.receive_button.click() + self.assertFalse(tab.new_tab.isVisible()) + self.assertTrue(tab.receive_mode.isVisible()) + + return tab + + def new_website_tab(self): + tab = self.gui.tabs.widget(0) + self.verify_new_tab(tab) + + # Publish website + tab.website_button.click() + self.assertFalse(tab.new_tab.isVisible()) + self.assertTrue(tab.website_mode.isVisible()) + + return tab + + def new_website_tab_with_files(self): + tab = self.new_website_tab() + + # Add files + for filename in self.tmpfiles: + tab.website_mode.server_status.file_selection.file_list.add_file(filename) + + return tab + def gui_loaded(self): """Test that the GUI actually is shown""" self.assertTrue(self.gui.show) @@ -56,265 +117,268 @@ class GuiBaseTest(unittest.TestCase): """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 settings_button_is_hidden(self): - """Test that the settings button is hidden when the server starts""" - self.assertFalse(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) - if type(mode) == WebsiteMode: - QtTest.QTest.mouseClick(self.gui.website_mode_button, QtCore.Qt.LeftButton) - self.assertTrue(self.gui.mode, self.gui.MODE_WEBSITE) + def mode_settings_widget_is_visible(self, tab): + """Test that the mode settings are visible""" + self.assertTrue(tab.get_mode().mode_settings_widget.isVisible()) - def click_toggle_history(self, mode): + def mode_settings_widget_is_hidden(self, tab): + """Test that the mode settings are hidden when the server starts""" + self.assertFalse(tab.get_mode().mode_settings_widget.isVisible()) + + def click_toggle_history(self, tab): """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) + currently_visible = tab.get_mode().history.isVisible() + QtTest.QTest.mouseClick(tab.get_mode().toggle_history, QtCore.Qt.LeftButton) + self.assertEqual(tab.get_mode().history.isVisible(), not currently_visible) - def history_indicator(self, mode, public_mode, indicator_count="1"): + def history_indicator(self, tab, indicator_count="1"): """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()) + if tab.get_mode().history.isVisible(): + QtTest.QTest.mouseClick(tab.get_mode().toggle_history, QtCore.Qt.LeftButton) + self.assertFalse(tab.get_mode().history.isVisible()) # Indicator should not be visible yet - self.assertFalse(mode.toggle_history.indicator_label.isVisible()) + self.assertFalse(tab.get_mode().toggle_history.indicator_label.isVisible()) - if type(mode) == ReceiveMode: + if type(tab.get_mode()) == ReceiveMode: # Upload a file - files = {"file[]": open("/tmp/test.txt", "rb")} - url = f"http://127.0.0.1:{self.gui.app.port}/upload" - if public_mode: + files = {"file[]": open(self.tmpfiles[0], "rb")} + url = f"http://127.0.0.1:{tab.app.port}/upload" + if tab.settings.get("general", "public"): requests.post(url, files=files) else: requests.post( url, files=files, - auth=requests.auth.HTTPBasicAuth("onionshare", mode.web.password), + auth=requests.auth.HTTPBasicAuth( + "onionshare", tab.get_mode().web.password + ), ) QtTest.QTest.qWait(2000) - if type(mode) == ShareMode: + if type(tab.get_mode()) == ShareMode: # Download files - url = f"http://127.0.0.1:{self.gui.app.port}/download" - if public_mode: + url = f"http://127.0.0.1:{tab.app.port}/download" + if tab.settings.get("general", "public"): requests.get(url) else: requests.get( url, - auth=requests.auth.HTTPBasicAuth("onionshare", mode.web.password), + auth=requests.auth.HTTPBasicAuth( + "onionshare", tab.get_mode().web.password + ), ) 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(), indicator_count) + self.assertTrue(tab.get_mode().toggle_history.indicator_label.isVisible()) + self.assertEqual( + tab.get_mode().toggle_history.indicator_label.text(), indicator_count + ) # 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()) + QtTest.QTest.mouseClick(tab.get_mode().toggle_history, QtCore.Qt.LeftButton) + self.assertFalse(tab.get_mode().toggle_history.indicator_label.isVisible()) - def history_is_not_visible(self, mode): + def history_is_not_visible(self, tab): """Test that the History section is not visible""" - self.assertFalse(mode.history.isVisible()) + self.assertFalse(tab.get_mode().history.isVisible()) - def history_is_visible(self, mode): + def history_is_visible(self, tab): """Test that the History section is visible""" - self.assertTrue(mode.history.isVisible()) + self.assertTrue(tab.get_mode().history.isVisible()) - def server_working_on_start_button_pressed(self, mode): + def server_working_on_start_button_pressed(self, tab): """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) + QtTest.QTest.mouseClick( + tab.get_mode().server_status.server_button, QtCore.Qt.LeftButton + ) + self.assertEqual(tab.get_mode().server_status.status, 1) - def toggle_indicator_is_reset(self, mode): - self.assertEqual(mode.toggle_history.indicator_count, 0) - self.assertFalse(mode.toggle_history.indicator_label.isVisible()) + def toggle_indicator_is_reset(self, tab): + self.assertEqual(tab.get_mode().toggle_history.indicator_count, 0) + self.assertFalse(tab.get_mode().toggle_history.indicator_label.isVisible()) - def server_status_indicator_says_starting(self, mode): + def server_status_indicator_says_starting(self, tab): """Test that the Server Status indicator shows we are Starting""" self.assertEqual( - mode.server_status_label.text(), + tab.get_mode().server_status_label.text(), strings._("gui_status_indicator_share_working"), ) - def server_status_indicator_says_scheduled(self, mode): + def server_status_indicator_says_scheduled(self, tab): """Test that the Server Status indicator shows we are Scheduled""" self.assertEqual( - mode.server_status_label.text(), + tab.get_mode().server_status_label.text(), strings._("gui_status_indicator_share_scheduled"), ) - def server_is_started(self, mode, startup_time=2000): + def server_is_started(self, tab, startup_time=2000): """Test that the server has started""" QtTest.QTest.qWait(startup_time) # Should now be in SERVER_STARTED state - self.assertEqual(mode.server_status.status, 2) + self.assertEqual(tab.get_mode().server_status.status, 2) - def web_server_is_running(self): + def web_server_is_running(self, tab): """Test that the web server has started""" try: - r = requests.get(f"http://127.0.0.1:{self.gui.app.port}/") + requests.get(f"http://127.0.0.1:{tab.app.port}/") self.assertTrue(True) except requests.exceptions.ConnectionError: self.assertTrue(False) - def have_a_password(self, mode, public_mode): + def have_a_password(self, tab): """Test that we have a valid password""" - if not public_mode: - self.assertRegex(mode.server_status.web.password, r"(\w+)-(\w+)") + if not tab.settings.get("general", "public"): + self.assertRegex(tab.get_mode().server_status.web.password, r"(\w+)-(\w+)") else: - self.assertIsNone(mode.server_status.web.password, r"(\w+)-(\w+)") + self.assertIsNone(tab.get_mode().server_status.web.password, r"(\w+)-(\w+)") - def add_button_visible(self, mode): + def add_button_visible(self, tab): """Test that the add button should be visible""" - self.assertTrue(mode.server_status.file_selection.add_button.isVisible()) + self.assertTrue( + tab.get_mode().server_status.file_selection.add_button.isVisible() + ) - def url_description_shown(self, mode): + def url_description_shown(self, tab): """Test that the URL label is showing""" - self.assertTrue(mode.server_status.url_description.isVisible()) + self.assertTrue(tab.get_mode().server_status.url_description.isVisible()) - def have_copy_url_button(self, mode, public_mode): + def have_copy_url_button(self, tab): """Test that the Copy URL button is shown and that the clipboard is correct""" - self.assertTrue(mode.server_status.copy_url_button.isVisible()) + self.assertTrue(tab.get_mode().server_status.copy_url_button.isVisible()) QtTest.QTest.mouseClick( - mode.server_status.copy_url_button, QtCore.Qt.LeftButton + tab.get_mode().server_status.copy_url_button, QtCore.Qt.LeftButton ) - clipboard = self.gui.qtapp.clipboard() - if public_mode: - self.assertEqual(clipboard.text(), f"http://127.0.0.1:{self.gui.app.port}") + clipboard = tab.common.gui.qtapp.clipboard() + if tab.settings.get("general", "public"): + self.assertEqual(clipboard.text(), f"http://127.0.0.1:{tab.app.port}") else: self.assertEqual( clipboard.text(), - f"http://onionshare:{mode.server_status.web.password}@127.0.0.1:{self.gui.app.port}", + f"http://onionshare:{tab.get_mode().server_status.web.password}@127.0.0.1:{tab.app.port}", ) - def server_status_indicator_says_started(self, mode): + def server_status_indicator_says_started(self, tab): """Test that the Server Status indicator shows we are started""" - if type(mode) == ReceiveMode: + if type(tab.get_mode()) == ReceiveMode: self.assertEqual( - mode.server_status_label.text(), + tab.get_mode().server_status_label.text(), strings._("gui_status_indicator_receive_started"), ) - if type(mode) == ShareMode: + if type(tab.get_mode()) == ShareMode: self.assertEqual( - mode.server_status_label.text(), + tab.get_mode().server_status_label.text(), strings._("gui_status_indicator_share_started"), ) - def web_page(self, mode, string, public_mode): + def web_page(self, tab, string): """Test that the web page contains a string""" - url = f"http://127.0.0.1:{self.gui.app.port}/" - if public_mode: + url = f"http://127.0.0.1:{tab.app.port}/" + if tab.settings.get("general", "public"): r = requests.get(url) else: r = requests.get( - url, auth=requests.auth.HTTPBasicAuth("onionshare", mode.web.password) + url, + auth=requests.auth.HTTPBasicAuth( + "onionshare", tab.get_mode().web.password + ), ) self.assertTrue(string in r.text) - def history_widgets_present(self, mode): + def history_widgets_present(self, tab): """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()) + self.assertFalse(tab.get_mode().history.empty.isVisible()) + self.assertTrue(tab.get_mode().history.not_empty.isVisible()) - def counter_incremented(self, mode, count): + def counter_incremented(self, tab, count): """Test that the counter has incremented""" - self.assertEqual(mode.history.completed_count, count) + self.assertEqual(tab.get_mode().history.completed_count, count) - def server_is_stopped(self, mode, stay_open): + def server_is_stopped(self, tab): """Test that the server stops when we click Stop""" if ( - type(mode) == ReceiveMode - or (type(mode) == ShareMode and stay_open) - or (type(mode) == WebsiteMode) + type(tab.get_mode()) == ReceiveMode + or ( + type(tab.get_mode()) == ShareMode + and not tab.settings.get("share", "autostop_sharing") + ) + or (type(tab.get_mode()) == WebsiteMode) ): QtTest.QTest.mouseClick( - mode.server_status.server_button, QtCore.Qt.LeftButton + tab.get_mode().server_status.server_button, QtCore.Qt.LeftButton ) - self.assertEqual(mode.server_status.status, 0) + self.assertEqual(tab.get_mode().server_status.status, 0) - def web_server_is_stopped(self): + def web_server_is_stopped(self, tab): """Test that the web server also stopped""" QtTest.QTest.qWait(2000) try: - r = requests.get(f"http://127.0.0.1:{self.gui.app.port}/") + r = requests.get(f"http://127.0.0.1:{tab.app.port}/") self.assertTrue(False) except requests.exceptions.ConnectionError: self.assertTrue(True) - def server_status_indicator_says_closed(self, mode, stay_open): + def server_status_indicator_says_closed(self, tab): """Test that the Server Status indicator shows we closed""" - if type(mode) == ReceiveMode: + if type(tab.get_mode()) == ReceiveMode: self.assertEqual( - self.gui.receive_mode.server_status_label.text(), + tab.get_mode().server_status_label.text(), strings._("gui_status_indicator_receive_stopped"), ) - if type(mode) == ShareMode: - if stay_open: + if type(tab.get_mode()) == ShareMode: + if tab.settings.get("share", "autostop_sharing"): self.assertEqual( - self.gui.share_mode.server_status_label.text(), + tab.get_mode().server_status_label.text(), strings._("gui_status_indicator_share_stopped"), ) else: self.assertEqual( - self.gui.share_mode.server_status_label.text(), + tab.get_mode().server_status_label.text(), strings._("closing_automatically"), ) - def clear_all_history_items(self, mode, count): + def clear_all_history_items(self, tab, count): if count == 0: - QtTest.QTest.mouseClick(mode.history.clear_button, QtCore.Qt.LeftButton) - self.assertEquals(len(mode.history.item_list.items.keys()), count) + QtTest.QTest.mouseClick( + tab.get_mode().history.clear_button, QtCore.Qt.LeftButton + ) + self.assertEquals(len(tab.get_mode().history.item_list.items.keys()), count) # Auto-stop timer tests - def set_timeout(self, mode, timeout): + def set_timeout(self, tab, timeout): """Test that the timeout can be set""" timer = QtCore.QDateTime.currentDateTime().addSecs(timeout) - mode.server_status.autostop_timer_widget.setDateTime(timer) - self.assertTrue(mode.server_status.autostop_timer_widget.dateTime(), timer) + tab.get_mode().server_status.autostop_timer_widget.setDateTime(timer) + self.assertTrue( + tab.get_mode().server_status.autostop_timer_widget.dateTime(), timer + ) - def autostop_timer_widget_hidden(self, mode): + def autostop_timer_widget_hidden(self, tab): """Test that the auto-stop timer widget is hidden when share has started""" - self.assertFalse(mode.server_status.autostop_timer_container.isVisible()) + self.assertFalse( + tab.get_mode().server_status.autostop_timer_container.isVisible() + ) - def server_timed_out(self, mode, wait): + def server_timed_out(self, tab, wait): """Test that the server has timed out after the timer ran out""" QtTest.QTest.qWait(wait) # We should have timed out now - self.assertEqual(mode.server_status.status, 0) - - # Hack to close an Alert dialog that would otherwise block tests - def accept_dialog(self): - window = self.gui.qtapp.activeWindow() - if window: - window.close() + self.assertEqual(tab.get_mode().server_status.status, 0) # Grouped tests follow from here def run_all_common_setup_tests(self): self.gui_loaded() self.window_title_seen() - self.settings_button_is_visible() self.server_status_bar_is_visible() diff --git a/tests2/test_gui_share.py b/tests2/test_gui_share.py index e7accb01..09a40cb1 100644 --- a/tests2/test_gui_share.py +++ b/tests2/test_gui_share.py @@ -2,6 +2,7 @@ import pytest import os import requests import tempfile +import zipfile from PyQt5 import QtCore, QtTest @@ -12,110 +13,101 @@ class TestShare(GuiBaseTest): # Shared test methods # Persistence tests - def have_same_password(self, password): + def have_same_password(self, tab, password): """Test that we have the same password""" - self.assertEqual(self.gui.share_mode.server_status.web.password, password) + self.assertEqual(tab.get_mode().server_status.web.password, password) # Share-specific tests - def file_selection_widget_has_files(self, num=2): + def file_selection_widget_has_files(self, tab, num=2): """Test that the number of items in the list is as expected""" self.assertEqual( - self.gui.share_mode.server_status.file_selection.get_num_files(), num + tab.get_mode().server_status.file_selection.get_num_files(), num ) - def deleting_all_files_hides_delete_button(self): + def deleting_all_files_hides_delete_button(self, tab): """Test that clicking on the file item shows the delete button. Test that deleting the only item in the list hides the delete button""" - rect = self.gui.share_mode.server_status.file_selection.file_list.visualItemRect( - self.gui.share_mode.server_status.file_selection.file_list.item(0) + rect = tab.get_mode().server_status.file_selection.file_list.visualItemRect( + tab.get_mode().server_status.file_selection.file_list.item(0) ) QtTest.QTest.mouseClick( - self.gui.share_mode.server_status.file_selection.file_list.viewport(), + tab.get_mode().server_status.file_selection.file_list.viewport(), QtCore.Qt.LeftButton, pos=rect.center(), ) # Delete button should be visible self.assertTrue( - self.gui.share_mode.server_status.file_selection.delete_button.isVisible() + tab.get_mode().server_status.file_selection.delete_button.isVisible() ) # Click delete, delete button should still be visible since we have one more file QtTest.QTest.mouseClick( - self.gui.share_mode.server_status.file_selection.delete_button, + tab.get_mode().server_status.file_selection.delete_button, QtCore.Qt.LeftButton, ) - - rect = self.gui.share_mode.server_status.file_selection.file_list.visualItemRect( - self.gui.share_mode.server_status.file_selection.file_list.item(0) + rect = tab.get_mode().server_status.file_selection.file_list.visualItemRect( + tab.get_mode().server_status.file_selection.file_list.item(0) ) QtTest.QTest.mouseClick( - self.gui.share_mode.server_status.file_selection.file_list.viewport(), + tab.get_mode().server_status.file_selection.file_list.viewport(), QtCore.Qt.LeftButton, pos=rect.center(), ) self.assertTrue( - self.gui.share_mode.server_status.file_selection.delete_button.isVisible() + tab.get_mode().server_status.file_selection.delete_button.isVisible() ) QtTest.QTest.mouseClick( - self.gui.share_mode.server_status.file_selection.delete_button, + tab.get_mode().server_status.file_selection.delete_button, QtCore.Qt.LeftButton, ) # No more files, the delete button should be hidden self.assertFalse( - self.gui.share_mode.server_status.file_selection.delete_button.isVisible() + tab.get_mode().server_status.file_selection.delete_button.isVisible() ) - def add_a_file_and_delete_using_its_delete_widget(self): + def add_a_file_and_delete_using_its_delete_widget(self, tab): """Test that we can also delete a file by clicking on its [X] widget""" - self.gui.share_mode.server_status.file_selection.file_list.add_file( - "/etc/hosts" - ) + tab.get_mode().server_status.file_selection.file_list.add_file(self.tmpfiles[0]) QtTest.QTest.mouseClick( - self.gui.share_mode.server_status.file_selection.file_list.item( - 0 - ).item_button, + tab.get_mode().server_status.file_selection.file_list.item(0).item_button, QtCore.Qt.LeftButton, ) - self.file_selection_widget_has_files(0) + self.file_selection_widget_has_files(tab, 0) - def file_selection_widget_read_files(self): + def file_selection_widget_read_files(self, tab): """Re-add some files to the list so we can share""" - self.gui.share_mode.server_status.file_selection.file_list.add_file( - "/etc/hosts" - ) - self.gui.share_mode.server_status.file_selection.file_list.add_file( - "/tmp/test.txt" - ) - self.file_selection_widget_has_files(2) + tab.get_mode().server_status.file_selection.file_list.add_file(self.tmpfiles[0]) + tab.get_mode().server_status.file_selection.file_list.add_file(self.tmpfiles[1]) + self.file_selection_widget_has_files(tab, 2) - def add_large_file(self): + def add_large_file(self, tab): """Add a large file to the share""" size = 1024 * 1024 * 155 with open("/tmp/large_file", "wb") as fout: fout.write(os.urandom(size)) - self.gui.share_mode.server_status.file_selection.file_list.add_file( + tab.get_mode().server_status.file_selection.file_list.add_file( "/tmp/large_file" ) - def add_delete_buttons_hidden(self): + def add_delete_buttons_hidden(self, tab): """Test that the add and delete buttons are hidden when the server starts""" self.assertFalse( - self.gui.share_mode.server_status.file_selection.add_button.isVisible() + tab.get_mode().server_status.file_selection.add_button.isVisible() ) self.assertFalse( - self.gui.share_mode.server_status.file_selection.delete_button.isVisible() + tab.get_mode().server_status.file_selection.delete_button.isVisible() ) - def download_share(self, public_mode): + def download_share(self, tab): """Test that we can download the share""" - url = f"http://127.0.0.1:{self.gui.app.port}/download" - if public_mode: + url = f"http://127.0.0.1:{tab.app.port}/download" + if tab.settings.get("general", "public"): r = requests.get(url) else: r = requests.get( url, auth=requests.auth.HTTPBasicAuth( - "onionshare", self.gui.share_mode.server_status.web.password + "onionshare", tab.get_mode().server_status.web.password ), ) @@ -127,30 +119,30 @@ class TestShare(GuiBaseTest): QtTest.QTest.qWait(2000) self.assertEqual("onionshare", zip.read("test.txt").decode("utf-8")) - def individual_file_is_viewable_or_not(self, public_mode, stay_open): - """Test whether an individual file is viewable (when in stay_open mode) and that it isn't (when not in stay_open mode)""" - url = f"http://127.0.0.1:{self.gui.app.port}" - download_file_url = f"http://127.0.0.1:{self.gui.app.port}/test.txt" - if public_mode: + def individual_file_is_viewable_or_not(self, tab): + """Test whether an individual file is viewable (when in autostop_sharing is false) and that it isn't (when not in autostop_sharing is true)""" + url = f"http://127.0.0.1:{tab.app.port}" + download_file_url = f"http://127.0.0.1:{tab.app.port}/test.txt" + if tab.settings.get("general", "public"): r = requests.get(url) else: r = requests.get( url, auth=requests.auth.HTTPBasicAuth( - "onionshare", self.gui.share_mode.server_status.web.password + "onionshare", tab.get_mode().server_status.web.password ), ) - if stay_open: + if not tab.settings.get("share", "autostop_sharing"): self.assertTrue('a href="test.txt"' in r.text) - if public_mode: + if tab.settings.get("general", "public"): r = requests.get(download_file_url) else: r = requests.get( download_file_url, auth=requests.auth.HTTPBasicAuth( - "onionshare", self.gui.share_mode.server_status.web.password + "onionshare", tab.get_mode().server_status.web.password ), ) @@ -162,210 +154,228 @@ class TestShare(GuiBaseTest): self.assertEqual("onionshare", f.read()) else: self.assertFalse('a href="/test.txt"' in r.text) - if public_mode: + if tab.settings.get("general", "public"): r = requests.get(download_file_url) else: r = requests.get( download_file_url, auth=requests.auth.HTTPBasicAuth( - "onionshare", self.gui.share_mode.server_status.web.password + "onionshare", tab.get_mode().server_status.web.password ), ) self.assertEqual(r.status_code, 404) - self.download_share(public_mode) + self.download_share(tab) QtTest.QTest.qWait(2000) - def hit_401(self, public_mode): + def hit_401(self, tab): """Test that the server stops after too many 401s, or doesn't when in public_mode""" - url = f"http://127.0.0.1:{self.gui.app.port}/" + url = f"http://127.0.0.1:{tab.app.port}/" for _ in range(20): password_guess = self.gui.common.build_password() - r = requests.get( + requests.get( url, auth=requests.auth.HTTPBasicAuth("onionshare", password_guess) ) # A nasty hack to avoid the Alert dialog that blocks the rest of the test - if not public_mode: + if not tab.settings.get("general", "public"): QtCore.QTimer.singleShot(1000, self.accept_dialog) # In public mode, we should still be running (no rate-limiting) - if public_mode: - self.web_server_is_running() + if tab.settings.get("general", "public"): + self.web_server_is_running(tab) # In non-public mode, we should be shut down (rate-limiting) else: - self.web_server_is_stopped() - - # Grouped tests follow from here - - def run_all_share_mode_setup_tests(self): - """Tests in share mode prior to starting a share""" - self.click_mode(self.gui.share_mode) - self.file_selection_widget_has_files() - self.history_is_not_visible(self.gui.share_mode) - self.click_toggle_history(self.gui.share_mode) - self.history_is_visible(self.gui.share_mode) - self.deleting_all_files_hides_delete_button() - self.add_a_file_and_delete_using_its_delete_widget() - self.file_selection_widget_read_files() - - def run_all_share_mode_started_tests(self, public_mode, startup_time=2000): - """Tests in share mode after starting a share""" - self.server_working_on_start_button_pressed(self.gui.share_mode) - self.server_status_indicator_says_starting(self.gui.share_mode) - self.add_delete_buttons_hidden() - self.settings_button_is_hidden() - self.server_is_started(self.gui.share_mode, startup_time) - self.web_server_is_running() - self.have_a_password(self.gui.share_mode, public_mode) - self.url_description_shown(self.gui.share_mode) - self.have_copy_url_button(self.gui.share_mode, public_mode) - self.server_status_indicator_says_started(self.gui.share_mode) - - def run_all_share_mode_download_tests(self, public_mode, stay_open): - """Tests in share mode after downloading a share""" - self.web_page(self.gui.share_mode, "Total size", public_mode) - self.download_share(public_mode) - self.history_widgets_present(self.gui.share_mode) - self.server_is_stopped(self.gui.share_mode, stay_open) - self.web_server_is_stopped() - self.server_status_indicator_says_closed(self.gui.share_mode, stay_open) - self.add_button_visible(self.gui.share_mode) - self.server_working_on_start_button_pressed(self.gui.share_mode) - self.toggle_indicator_is_reset(self.gui.share_mode) - self.server_is_started(self.gui.share_mode) - self.history_indicator(self.gui.share_mode, public_mode) - - def run_all_share_mode_individual_file_download_tests(self, public_mode, stay_open): - """Tests in share mode after downloading a share""" - self.web_page(self.gui.share_mode, "Total size", public_mode) - self.individual_file_is_viewable_or_not(public_mode, stay_open) - self.history_widgets_present(self.gui.share_mode) - self.server_is_stopped(self.gui.share_mode, stay_open) - self.web_server_is_stopped() - self.server_status_indicator_says_closed(self.gui.share_mode, stay_open) - self.add_button_visible(self.gui.share_mode) - self.server_working_on_start_button_pressed(self.gui.share_mode) - self.server_is_started(self.gui.share_mode) - self.history_indicator(self.gui.share_mode, public_mode) - - def run_all_share_mode_tests(self, public_mode, stay_open): - """End-to-end share tests""" - self.run_all_share_mode_setup_tests() - self.run_all_share_mode_started_tests(public_mode) - self.run_all_share_mode_download_tests(public_mode, stay_open) - - def run_all_clear_all_button_tests(self, public_mode, stay_open): - """Test the Clear All history button""" - self.run_all_share_mode_setup_tests() - self.run_all_share_mode_started_tests(public_mode) - self.individual_file_is_viewable_or_not(public_mode, stay_open) - self.history_widgets_present(self.gui.share_mode) - self.clear_all_history_items(self.gui.share_mode, 0) - self.individual_file_is_viewable_or_not(public_mode, stay_open) - self.clear_all_history_items(self.gui.share_mode, 2) - - def run_all_share_mode_individual_file_tests(self, public_mode, stay_open): - """Tests in share mode when viewing an individual file""" - self.run_all_share_mode_setup_tests() - self.run_all_share_mode_started_tests(public_mode) - self.run_all_share_mode_individual_file_download_tests(public_mode, stay_open) - - def run_all_large_file_tests(self, public_mode, stay_open): - """Same as above but with a larger file""" - self.run_all_share_mode_setup_tests() - self.add_large_file() - self.run_all_share_mode_started_tests(public_mode, startup_time=15000) - self.assertTrue(self.gui.share_mode.filesize_warning.isVisible()) - self.server_is_stopped(self.gui.share_mode, stay_open) - self.web_server_is_stopped() - self.server_status_indicator_says_closed(self.gui.share_mode, stay_open) - - def run_all_share_mode_persistent_tests(self, public_mode, stay_open): - """Same as end-to-end share tests but also test the password is the same on multiple shared""" - self.run_all_share_mode_setup_tests() - self.run_all_share_mode_started_tests(public_mode) - password = self.gui.share_mode.server_status.web.password - self.run_all_share_mode_download_tests(public_mode, stay_open) - self.have_same_password(password) - - def run_all_share_mode_timer_tests(self, public_mode): - """Auto-stop timer tests in share mode""" - self.run_all_share_mode_setup_tests() - self.set_timeout(self.gui.share_mode, 5) - self.run_all_share_mode_started_tests(public_mode) - self.autostop_timer_widget_hidden(self.gui.share_mode) - self.server_timed_out(self.gui.share_mode, 10000) - self.web_server_is_stopped() - - def run_all_share_mode_autostart_timer_tests(self, public_mode): - """Auto-start timer tests in share mode""" - self.run_all_share_mode_setup_tests() - self.set_autostart_timer(self.gui.share_mode, 5) - self.server_working_on_start_button_pressed(self.gui.share_mode) - self.autostart_timer_widget_hidden(self.gui.share_mode) - self.server_status_indicator_says_scheduled(self.gui.share_mode) - self.web_server_is_stopped() - self.scheduled_service_started(self.gui.share_mode, 7000) - self.web_server_is_running() - - def run_all_share_mode_autostop_autostart_mismatch_tests(self, public_mode): - """Auto-stop timer tests in share mode""" - self.run_all_share_mode_setup_tests() - self.set_autostart_timer(self.gui.share_mode, 15) - self.set_timeout(self.gui.share_mode, 5) - QtCore.QTimer.singleShot(4000, self.accept_dialog) - QtTest.QTest.mouseClick( - self.gui.share_mode.server_status.server_button, QtCore.Qt.LeftButton - ) - self.server_is_stopped(self.gui.share_mode, False) - - def run_all_share_mode_unreadable_file_tests(self): - """Attempt to share an unreadable file""" - self.run_all_share_mode_setup_tests() - QtCore.QTimer.singleShot(1000, self.accept_dialog) - self.gui.share_mode.server_status.file_selection.file_list.add_file( - "/tmp/nonexistent.txt" - ) - self.file_selection_widget_has_files(2) + self.web_server_is_stopped(tab) # Auto-start timer tests - def set_autostart_timer(self, mode, timer): + + def set_autostart_timer(self, tab, mode, timer): """Test that the timer can be set""" schedule = QtCore.QDateTime.currentDateTime().addSecs(timer) mode.server_status.autostart_timer_widget.setDateTime(schedule) self.assertTrue(mode.server_status.autostart_timer_widget.dateTime(), schedule) - def autostart_timer_widget_hidden(self, mode): + def autostart_timer_widget_hidden(self, tab, mode): """Test that the auto-start timer widget is hidden when share has started""" self.assertFalse(mode.server_status.autostart_timer_container.isVisible()) - def scheduled_service_started(self, mode, wait): + def scheduled_service_started(self, tab, mode, wait): """Test that the server has timed out after the timer ran out""" QtTest.QTest.qWait(wait) # We should have started now self.assertEqual(mode.server_status.status, 2) - def cancel_the_share(self, mode): + def cancel_the_share(self, tab, mode): """Test that we can cancel a share before it's started up """ - self.server_working_on_start_button_pressed(mode) - self.server_status_indicator_says_scheduled(mode) - self.add_delete_buttons_hidden() - self.settings_button_is_hidden() - self.set_autostart_timer(mode, 10) + self.server_working_on_start_button_pressed(tab) + self.server_status_indicator_says_scheduled(tab) + self.add_delete_buttons_hidden(tab) + self.mode_settings_widget_is_hidden(tab) + self.set_autostart_timer(tab, 10) QtTest.QTest.mousePress(mode.server_status.server_button, QtCore.Qt.LeftButton) QtTest.QTest.qWait(2000) QtTest.QTest.mouseRelease( mode.server_status.server_button, QtCore.Qt.LeftButton ) self.assertEqual(mode.server_status.status, 0) - self.server_is_stopped(mode, False) - self.web_server_is_stopped() + self.server_is_stopped(tab) + self.web_server_is_stopped(tab) + + # Grouped tests follow from here + + def run_all_share_mode_setup_tests(self, tab): + """Tests in share mode prior to starting a share""" + tab.get_mode().server_status.file_selection.file_list.add_file(self.tmpfiles[0]) + tab.get_mode().server_status.file_selection.file_list.add_file(self.tmpfiles[1]) + self.file_selection_widget_has_files(tab, 2) + self.history_is_not_visible(tab) + self.click_toggle_history(tab) + self.history_is_visible(tab) + self.deleting_all_files_hides_delete_button(tab) + self.add_a_file_and_delete_using_its_delete_widget(tab) + self.file_selection_widget_read_files(tab) + + def run_all_share_mode_started_tests(self, tab, startup_time=2000): + """Tests in share mode after starting a share""" + self.server_working_on_start_button_pressed(tab) + self.server_status_indicator_says_starting(tab) + self.add_delete_buttons_hidden(tab) + self.mode_settings_widget_is_hidden(tab) + self.server_is_started(tab, startup_time) + self.web_server_is_running(tab) + self.have_a_password(tab) + self.url_description_shown(tab) + self.have_copy_url_button(tab) + self.server_status_indicator_says_started(tab) + + def run_all_share_mode_download_tests(self, tab): + """Tests in share mode after downloading a share""" + tab.get_mode().server_status.file_selection.file_list.add_file( + self.tmpfile_test + ) + self.web_page(tab, "Total size") + self.download_share(tab) + self.history_widgets_present(tab) + self.server_is_stopped(tab) + self.web_server_is_stopped(tab) + self.server_status_indicator_says_closed(tab) + self.add_button_visible(tab) + self.server_working_on_start_button_pressed(tab) + self.toggle_indicator_is_reset(tab) + self.server_is_started(tab) + self.history_indicator(tab) + + def run_all_share_mode_individual_file_download_tests(self, tab): + """Tests in share mode after downloading a share""" + self.web_page(tab, "Total size") + self.individual_file_is_viewable_or_not(tab) + self.history_widgets_present(tab) + self.server_is_stopped(tab) + self.web_server_is_stopped(tab) + self.server_status_indicator_says_closed(tab) + self.add_button_visible(tab) + self.server_working_on_start_button_pressed(tab) + self.server_is_started(tab) + self.history_indicator(tab) + + def run_all_share_mode_tests(self, tab): + """End-to-end share tests""" + self.run_all_share_mode_setup_tests(tab) + self.run_all_share_mode_started_tests(tab) + self.run_all_share_mode_download_tests(tab) + + def run_all_clear_all_button_tests(self, tab): + """Test the Clear All history button""" + self.run_all_share_mode_setup_tests(tab) + self.run_all_share_mode_started_tests(tab) + self.individual_file_is_viewable_or_not(tab) + self.history_widgets_present(tab) + self.clear_all_history_items(tab, 0) + self.individual_file_is_viewable_or_not(tab) + self.clear_all_history_items(tab, 2) + + def run_all_share_mode_individual_file_tests(self, tab): + """Tests in share mode when viewing an individual file""" + self.run_all_share_mode_setup_tests(tab) + self.run_all_share_mode_started_tests(tab) + self.run_all_share_mode_individual_file_download_tests(tab) + + def run_all_large_file_tests(self, tab): + """Same as above but with a larger file""" + self.run_all_share_mode_setup_tests(tab) + self.add_large_file(tab) + self.run_all_share_mode_started_tests(tab, startup_time=15000) + self.assertTrue(tab.filesize_warning.isVisible()) + self.server_is_stopped(tab) + self.web_server_is_stopped(tab) + self.server_status_indicator_says_closed(tab) + + def run_all_share_mode_persistent_tests(self, tab): + """Same as end-to-end share tests but also test the password is the same on multiple shared""" + self.run_all_share_mode_setup_tests(tab) + self.run_all_share_mode_started_tests(tab) + password = tab.get_mode().server_status.web.password + self.run_all_share_mode_download_tests(tab) + self.have_same_password(tab, password) + + def run_all_share_mode_timer_tests(self, tab): + """Auto-stop timer tests in share mode""" + self.run_all_share_mode_setup_tests(tab) + self.set_timeout(tab, 5) + self.run_all_share_mode_started_tests(tab) + self.autostop_timer_widget_hidden(tab) + self.server_timed_out(tab, 10000) + self.web_server_is_stopped(tab) + + def run_all_share_mode_autostart_timer_tests(self, tab): + """Auto-start timer tests in share mode""" + self.run_all_share_mode_setup_tests(tab) + self.set_autostart_timer(tab, 5) + self.server_working_on_start_button_pressed(tab) + self.autostart_timer_widget_hidden(tab) + self.server_status_indicator_says_scheduled(tab) + self.web_server_is_stopped(tab) + self.scheduled_service_started(tab, 7000) + self.web_server_is_running(tab) + + def run_all_share_mode_autostop_autostart_mismatch_tests(self, tab): + """Auto-stop timer tests in share mode""" + self.run_all_share_mode_setup_tests(tab) + self.set_autostart_timer(tab, 15) + self.set_timeout(tab, 5) + QtCore.QTimer.singleShot(4000, self.accept_dialog) + QtTest.QTest.mouseClick( + tab.get_mode().server_status.server_button, QtCore.Qt.LeftButton + ) + self.server_is_stopped(tab, False) + + def run_all_share_mode_unreadable_file_tests(self, tab): + """Attempt to share an unreadable file""" + self.run_all_share_mode_setup_tests(tab) + QtCore.QTimer.singleShot(1000, self.accept_dialog) + tab.get_mode().server_status.file_selection.file_list.add_file( + "/tmp/nonexistent.txt" + ) + self.file_selection_widget_has_files(tab, 2) # Tests @pytest.mark.gui - def test_common_tests(self): - """Run all common tests""" - self.run_all_common_setup_tests() + def test_tmp(self): + tab = self.new_share_tab() + self.run_all_share_mode_setup_tests(tab) + self.run_all_share_mode_started_tests(tab) + self.run_all_share_mode_download_tests(tab) + self.run_all_share_mode_individual_file_download_tests(tab) + self.run_all_share_mode_tests(tab) + self.run_all_clear_all_button_tests(tab) + self.run_all_share_mode_individual_file_tests(tab) + self.run_all_large_file_tests(tab) + self.run_all_share_mode_persistent_tests(tab) + self.run_all_share_mode_timer_tests(tab) + self.run_all_share_mode_autostart_timer_tests(tab) + self.run_all_share_mode_autostop_autostart_mismatch_tests(tab) + self.run_all_share_mode_unreadable_file_tests(tab) + diff --git a/tests2/test_gui_tabs.py b/tests2/test_gui_tabs.py index eada8176..47a3d75d 100644 --- a/tests2/test_gui_tabs.py +++ b/tests2/test_gui_tabs.py @@ -9,54 +9,6 @@ from .gui_base_test import GuiBaseTest class TestTabs(GuiBaseTest): # Shared test methods - def verify_new_tab(self, tab): - # Make sure the new tab widget is showing, and no mode has been started - self.assertTrue(tab.new_tab.isVisible()) - self.assertFalse(hasattr(tab, "share_mode")) - self.assertFalse(hasattr(tab, "receive_mode")) - self.assertFalse(hasattr(tab, "website_mode")) - - def new_share_tab(self): - tab = self.gui.tabs.widget(0) - self.verify_new_tab(tab) - - # Share files - tab.share_button.click() - self.assertFalse(tab.new_tab.isVisible()) - self.assertTrue(tab.share_mode.isVisible()) - - # Add files - for filename in self.tmpfiles: - tab.share_mode.server_status.file_selection.file_list.add_file(filename) - - return tab - - def new_receive_tab(self): - tab = self.gui.tabs.widget(0) - self.verify_new_tab(tab) - - # Receive files - tab.receive_button.click() - self.assertFalse(tab.new_tab.isVisible()) - self.assertTrue(tab.receive_mode.isVisible()) - - return tab - - def new_website_tab(self): - tab = self.gui.tabs.widget(0) - self.verify_new_tab(tab) - - # Publish website - tab.website_button.click() - self.assertFalse(tab.new_tab.isVisible()) - self.assertTrue(tab.website_mode.isVisible()) - - # Add files - for filename in self.tmpfiles: - tab.website_mode.server_status.file_selection.file_list.add_file(filename) - - return tab - def close_tab_with_active_server(self, tab): # Start the server self.assertEqual( @@ -208,7 +160,7 @@ class TestTabs(GuiBaseTest): @pytest.mark.gui def test_07_close_share_tab_while_server_started_should_warn(self): """Closing a share mode tab when the server is running should throw a warning""" - tab = self.new_share_tab() + tab = self.new_share_tab_with_files() self.close_tab_with_active_server(tab) @pytest.mark.gui @@ -220,13 +172,13 @@ class TestTabs(GuiBaseTest): @pytest.mark.gui def test_09_close_website_tab_while_server_started_should_warn(self): """Closing a website mode tab when the server is running should throw a warning""" - tab = self.new_website_tab() + tab = self.new_website_tab_with_files() self.close_tab_with_active_server(tab) @pytest.mark.gui def test_10_close_persistent_share_tab_shows_warning(self): """Closing a share mode tab that's persistent should show a warning""" - tab = self.new_share_tab() + tab = self.new_share_tab_with_files() self.close_persistent_tab(tab) @pytest.mark.gui @@ -238,7 +190,7 @@ class TestTabs(GuiBaseTest): @pytest.mark.gui def test_12_close_persistent_website_tab_shows_warning(self): """Closing a website mode tab that's persistent should show a warning""" - tab = self.new_website_tab() + tab = self.new_website_tab_with_files() self.close_persistent_tab(tab) @pytest.mark.gui