diff options
author | Micah Lee <micah@micahflee.com> | 2019-10-13 14:35:40 -0400 |
---|---|---|
committer | GitHub <noreply@github.com> | 2019-10-13 14:35:40 -0400 |
commit | 896659c6963c14c4e047cff7f3d421977060ed23 (patch) | |
tree | 660468dd7478fb001ced211a4a33ae28a1b5f9a4 /tests | |
parent | bbf6c02da645fcd4fc50db18dd341178ad4fa2e6 (diff) | |
parent | 7d24bf9ffcd1e21e087431c21bfc658803a61ab6 (diff) | |
download | onionshare-2.2.tar.gz onionshare-2.2.zip |
Merge pull request #1048 from micahflee/developv2.2
Version 2.2
Diffstat (limited to 'tests')
56 files changed, 1494 insertions, 867 deletions
diff --git a/tests/GuiBaseTest.py b/tests/GuiBaseTest.py index d3fc9945..6d6340d1 100644 --- a/tests/GuiBaseTest.py +++ b/tests/GuiBaseTest.py @@ -2,8 +2,7 @@ import json import os import requests import shutil -import socket -import socks +import base64 from PyQt5 import QtCore, QtTest @@ -15,22 +14,23 @@ 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 +from onionshare_gui.mode.website_mode import WebsiteMode class GuiBaseTest(object): @staticmethod def set_up(test_settings): - '''Create GUI with given settings''' + """Create GUI with given settings""" # Create our test file - testfile = open('/tmp/test.txt', 'w') - testfile.write('onionshare') + testfile = open("/tmp/test.txt", "w") + testfile.write("onionshare") testfile.close() # Create a test dir and files - if not os.path.exists('/tmp/testdir'): - testdir = os.mkdir('/tmp/testdir') - testfile = open('/tmp/testdir/test', 'w') - testfile.write('onionshare') + if not os.path.exists("/tmp/testdir"): + testdir = os.mkdir("/tmp/testdir") + testfile = open("/tmp/testdir/test", "w") + testfile.write("onionshare") testfile.close() common = Common() @@ -39,7 +39,7 @@ class GuiBaseTest(object): strings.load_strings(common) # Get all of the settings in test_settings - test_settings['data_dir'] = '/tmp/OnionShare' + test_settings["data_dir"] = "/tmp/OnionShare" for key, val in common.settings.default_settings.items(): if key not in test_settings: test_settings[key] = val @@ -51,70 +51,73 @@ class GuiBaseTest(object): app = OnionShare(common, testonion, True, 0) web = Web(common, False, True) - open('/tmp/settings.json', 'w').write(json.dumps(test_settings)) - - gui = OnionShareGui(common, testonion, qtapp, app, ['/tmp/test.txt', '/tmp/testdir'], '/tmp/settings.json', True) + open("/tmp/settings.json", "w").write(json.dumps(test_settings)) + + gui = OnionShareGui( + common, + testonion, + qtapp, + app, + ["/tmp/test.txt", "/tmp/testdir"], + "/tmp/settings.json", + True, + ) return gui @staticmethod def tear_down(): - '''Clean up after tests''' + """Clean up after tests""" try: - os.remove('/tmp/test.txt') - os.remove('/tmp/settings.json') - os.remove('/tmp/large_file') - os.remove('/tmp/download.zip') - os.remove('/tmp/webpage') - shutil.rmtree('/tmp/testdir') - shutil.rmtree('/tmp/OnionShare') + os.remove("/tmp/test.txt") + os.remove("/tmp/settings.json") + os.remove("/tmp/large_file") + os.remove("/tmp/download.zip") + os.remove("/tmp/webpage") + shutil.rmtree("/tmp/testdir") + shutil.rmtree("/tmp/OnionShare") except: pass - def gui_loaded(self): - '''Test that the GUI actually is shown''' + """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') - + """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''' + """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''' + """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''' + """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''' + """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 click_toggle_history(self, mode): - '''Test that we can toggle Download or Upload history by clicking the toggle button''' + """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''' + def history_indicator(self, mode, public_mode, 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) @@ -125,208 +128,236 @@ class GuiBaseTest(object): 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) + files = {"file[]": open("/tmp/test.txt", "rb")} + url = "http://127.0.0.1:{}/upload".format(self.gui.app.port) + if public_mode: + r = requests.post(url, files=files) else: - path = 'http://127.0.0.1:{}/upload'.format(self.gui.app.port) - response = requests.post(path, files=files) + r = requests.post( + url, + files=files, + auth=requests.auth.HTTPBasicAuth("onionshare", mode.web.password), + ) QtTest.QTest.qWait(2000) if type(mode) == ShareMode: # Download files + url = "http://127.0.0.1:{}/download".format(self.gui.app.port) if public_mode: - url = "http://127.0.0.1:{}/download".format(self.gui.app.port) + r = requests.get(url) else: - url = "http://127.0.0.1:{}/{}/download".format(self.gui.app.port, mode.web.slug) - r = requests.get(url) + r = requests.get( + url, + auth=requests.auth.HTTPBasicAuth("onionshare", 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(), "1") + self.assertEqual(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()) - def history_is_not_visible(self, mode): - '''Test that the History section is not visible''' + """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''' + """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''' + """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 toggle_indicator_is_reset(self, mode): + self.assertEqual(mode.toggle_history.indicator_count, 0) + self.assertFalse(mode.toggle_history.indicator_label.isVisible()) def server_status_indicator_says_starting(self, mode): - '''Test that the Server Status indicator shows we are Starting''' - self.assertEqual(mode.server_status_label.text(), strings._('gui_status_indicator_share_working')) + """Test that the Server Status indicator shows we are Starting""" + self.assertEqual( + mode.server_status_label.text(), + strings._("gui_status_indicator_share_working"), + ) def server_status_indicator_says_scheduled(self, mode): - '''Test that the Server Status indicator shows we are Scheduled''' - self.assertEqual(mode.server_status_label.text(), strings._('gui_status_indicator_share_scheduled')) + """Test that the Server Status indicator shows we are Scheduled""" + self.assertEqual( + mode.server_status_label.text(), + strings._("gui_status_indicator_share_scheduled"), + ) def server_is_started(self, mode, startup_time=2000): - '''Test that the server has started''' + """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) - def 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) - + """Test that the web server has started""" + try: + r = requests.get("http://127.0.0.1:{}/".format(self.gui.app.port)) + self.assertTrue(True) + except requests.exceptions.ConnectionError: + self.assertTrue(False) - def have_a_slug(self, mode, public_mode): - '''Test that we have a valid slug''' + def have_a_password(self, mode, public_mode): + """Test that we have a valid password""" if not public_mode: - self.assertRegex(mode.server_status.web.slug, r'(\w+)-(\w+)') + self.assertRegex(mode.server_status.web.password, r"(\w+)-(\w+)") else: - self.assertIsNone(mode.server_status.web.slug, r'(\w+)-(\w+)') + self.assertIsNone(mode.server_status.web.password, r"(\w+)-(\w+)") + def add_button_visible(self, mode): + """Test that the add button should be visible""" + self.assertTrue(mode.server_status.file_selection.add_button.isVisible()) def url_description_shown(self, mode): - '''Test that the URL label is showing''' + """Test that the URL label is showing""" self.assertTrue(mode.server_status.url_description.isVisible()) - def have_copy_url_button(self, mode, public_mode): - '''Test that the Copy URL button is shown and that the clipboard is correct''' + """Test that the Copy URL button is shown and that the clipboard is correct""" self.assertTrue(mode.server_status.copy_url_button.isVisible()) - QtTest.QTest.mouseClick(mode.server_status.copy_url_button, QtCore.Qt.LeftButton) + QtTest.QTest.mouseClick( + mode.server_status.copy_url_button, QtCore.Qt.LeftButton + ) clipboard = self.gui.qtapp.clipboard() if public_mode: - self.assertEqual(clipboard.text(), 'http://127.0.0.1:{}'.format(self.gui.app.port)) + self.assertEqual( + clipboard.text(), "http://127.0.0.1:{}".format(self.gui.app.port) + ) else: - self.assertEqual(clipboard.text(), 'http://127.0.0.1:{}/{}'.format(self.gui.app.port, mode.server_status.web.slug)) - + self.assertEqual( + clipboard.text(), + "http://onionshare:{}@127.0.0.1:{}".format( + mode.server_status.web.password, self.gui.app.port + ), + ) def server_status_indicator_says_started(self, mode): - '''Test that the Server Status indicator shows we are started''' + """Test that the Server Status indicator shows we are started""" if type(mode) == ReceiveMode: - self.assertEqual(mode.server_status_label.text(), strings._('gui_status_indicator_receive_started')) + self.assertEqual( + mode.server_status_label.text(), + strings._("gui_status_indicator_receive_started"), + ) if type(mode) == ShareMode: - self.assertEqual(mode.server_status_label.text(), strings._('gui_status_indicator_share_started')) - + self.assertEqual( + 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)) + """Test that the web page contains a string""" - if not public_mode: - path = '/{}'.format(mode.server_status.web.slug) + url = "http://127.0.0.1:{}/".format(self.gui.app.port) + if public_mode: + r = requests.get(url) 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() + r = requests.get( + url, auth=requests.auth.HTTPBasicAuth("onionshare", mode.web.password) + ) + self.assertTrue(string in r.text) def history_widgets_present(self, mode): - '''Test that the relevant widgets are present in the history view after activity has taken place''' + """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''' + """Test that the counter has incremented""" self.assertEqual(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) + """Test that the server stops when we click Stop""" + if ( + type(mode) == ReceiveMode + or (type(mode) == ShareMode and stay_open) + or (type(mode) == WebsiteMode) + ): + QtTest.QTest.mouseClick( + mode.server_status.server_button, QtCore.Qt.LeftButton + ) self.assertEqual(mode.server_status.status, 0) - def web_server_is_stopped(self): - '''Test that the web server also stopped''' + """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) + try: + r = requests.get("http://127.0.0.1:{}/".format(self.gui.app.port)) + self.assertTrue(False) + except requests.exceptions.ConnectionError: + self.assertTrue(True) def server_status_indicator_says_closed(self, mode, stay_open): - '''Test that the Server Status indicator shows we closed''' + """Test that the Server Status indicator shows we closed""" if type(mode) == ReceiveMode: - self.assertEqual(self.gui.receive_mode.server_status_label.text(), strings._('gui_status_indicator_receive_stopped')) + self.assertEqual( + self.gui.receive_mode.server_status_label.text(), + strings._("gui_status_indicator_receive_stopped"), + ) if type(mode) == ShareMode: if stay_open: - self.assertEqual(self.gui.share_mode.server_status_label.text(), strings._('gui_status_indicator_share_stopped')) + self.assertEqual( + self.gui.share_mode.server_status_label.text(), + strings._("gui_status_indicator_share_stopped"), + ) else: - self.assertEqual(self.gui.share_mode.server_status_label.text(), strings._('closing_automatically')) + self.assertEqual( + self.gui.share_mode.server_status_label.text(), + strings._("closing_automatically"), + ) + def clear_all_history_items(self, mode, count): + if count == 0: + QtTest.QTest.mouseClick(mode.history.clear_button, QtCore.Qt.LeftButton) + self.assertEquals(len(mode.history.item_list.items.keys()), count) # Auto-stop timer tests def set_timeout(self, mode, timeout): - '''Test that the timeout can be set''' + """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) def autostop_timer_widget_hidden(self, mode): - '''Test that the auto-stop timer widget is hidden when share has started''' + """Test that the auto-stop timer widget is hidden when share has started""" self.assertFalse(mode.server_status.autostop_timer_container.isVisible()) - def server_timed_out(self, mode, wait): - '''Test that the server has timed out after the timer ran out''' + """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) # Auto-start timer tests def set_autostart_timer(self, mode, timer): - '''Test that the timer can be set''' + """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): - '''Test that the auto-start timer widget is hidden when share has started''' + """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): - '''Test that the server has timed out after the timer ran out''' + """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): - '''Test that we can cancel a share before it's started up ''' + """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() @@ -334,7 +365,9 @@ class GuiBaseTest(object): self.set_autostart_timer(mode, 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) + 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() diff --git a/tests/GuiReceiveTest.py b/tests/GuiReceiveTest.py index 40c3de95..34db1a94 100644 --- a/tests/GuiReceiveTest.py +++ b/tests/GuiReceiveTest.py @@ -4,21 +4,48 @@ from datetime import datetime, timedelta from PyQt5 import QtCore, QtTest from .GuiBaseTest import GuiBaseTest + class GuiReceiveTest(GuiBaseTest): - def upload_file(self, public_mode, file_to_upload, expected_basename, identical_files_at_once=False): - '''Test that we can upload the file''' - files = {'file[]': open(file_to_upload, 'rb')} - if not public_mode: - path = 'http://127.0.0.1:{}/{}/upload'.format(self.gui.app.port, self.gui.receive_mode.web.slug) + def upload_file( + self, + public_mode, + file_to_upload, + expected_basename, + identical_files_at_once=False, + ): + """Test that we can upload the file""" + + # Wait 2 seconds to make sure the filename, based on timestamp, isn't accidentally reused + QtTest.QTest.qWait(2000) + + files = {"file[]": open(file_to_upload, "rb")} + url = "http://127.0.0.1:{}/upload".format(self.gui.app.port) + if public_mode: + r = requests.post(url, files=files) + if identical_files_at_once: + # Send a duplicate upload to test for collisions + r = requests.post(url, files=files) else: - path = 'http://127.0.0.1:{}/upload'.format(self.gui.app.port) - response = requests.post(path, files=files) - if identical_files_at_once: - # Send a duplicate upload to test for collisions - response = requests.post(path, files=files) + r = requests.post( + url, + files=files, + auth=requests.auth.HTTPBasicAuth( + "onionshare", self.gui.receive_mode.web.password + ), + ) + if identical_files_at_once: + # Send a duplicate upload to test for collisions + r = requests.post( + url, + files=files, + auth=requests.auth.HTTPBasicAuth( + "onionshare", self.gui.receive_mode.web.password + ), + ) + QtTest.QTest.qWait(2000) - # Make sure the file is within the last 10 seconds worth of filenames + # Make sure the file is within the last 10 seconds worth of fileames exists = False now = datetime.now() for i in range(10): @@ -27,7 +54,9 @@ class GuiReceiveTest(GuiBaseTest): time_dir = now.strftime("%H.%M.%S-1") else: time_dir = now.strftime("%H.%M.%S") - receive_mode_dir = os.path.join(self.gui.common.settings.get('data_dir'), date_dir, time_dir) + receive_mode_dir = os.path.join( + self.gui.common.settings.get("data_dir"), date_dir, time_dir + ) expected_filename = os.path.join(receive_mode_dir, expected_basename) if os.path.exists(expected_filename): exists = True @@ -37,53 +66,37 @@ class GuiReceiveTest(GuiBaseTest): self.assertTrue(exists) def upload_file_should_fail(self, public_mode): - '''Test that we can't upload the file when permissions are wrong, and expected content is shown''' - files = {'file[]': open('/tmp/test.txt', 'rb')} - if not public_mode: - path = 'http://127.0.0.1:{}/{}/upload'.format(self.gui.app.port, self.gui.receive_mode.web.slug) + """Test that we can't upload the file when permissions are wrong, and expected content is shown""" + files = {"file[]": open("/tmp/test.txt", "rb")} + url = "http://127.0.0.1:{}/upload".format(self.gui.app.port) + if public_mode: + r = requests.post(url, files=files) else: - path = 'http://127.0.0.1:{}/upload'.format(self.gui.app.port) - response = requests.post(path, files=files) + r = requests.post( + url, + files=files, + auth=requests.auth.HTTPBasicAuth( + "onionshare", self.gui.receive_mode.web.password + ), + ) QtCore.QTimer.singleShot(1000, self.accept_dialog) - self.assertTrue('Error uploading, please inform the OnionShare user' in response.text) + self.assertTrue("Error uploading, please inform the OnionShare user" in r.text) def upload_dir_permissions(self, mode=0o755): - '''Manipulate the permissions on the upload dir in between tests''' - os.chmod('/tmp/OnionShare', mode) - - def try_public_paths_in_non_public_mode(self): - response = requests.post('http://127.0.0.1:{}/upload'.format(self.gui.app.port)) - self.assertEqual(response.status_code, 404) - response = requests.get('http://127.0.0.1:{}/close'.format(self.gui.app.port)) - self.assertEqual(response.status_code, 404) + """Manipulate the permissions on the upload dir in between tests""" + os.chmod("/tmp/OnionShare", mode) - def uploading_zero_files_shouldnt_change_ui(self, mode, public_mode): - '''If you submit the receive mode form without selecting any files, the UI shouldn't get updated''' - if not public_mode: - path = 'http://127.0.0.1:{}/{}/upload'.format(self.gui.app.port, self.gui.receive_mode.web.slug) - else: - path = 'http://127.0.0.1:{}/upload'.format(self.gui.app.port) - - # What were the counts before submitting the form? - before_in_progress_count = mode.history.in_progress_count - before_completed_count = mode.history.completed_count - before_number_of_history_items = len(mode.history.item_list.items) - - # Click submit without including any files a few times - response = requests.post(path, files={}) - response = requests.post(path, files={}) - response = requests.post(path, files={}) - - # The counts shouldn't change - self.assertEqual(mode.history.in_progress_count, before_in_progress_count) - self.assertEqual(mode.history.completed_count, before_completed_count) - self.assertEqual(len(mode.history.item_list.items), before_number_of_history_items) + def try_without_auth_in_non_public_mode(self): + r = requests.post("http://127.0.0.1:{}/upload".format(self.gui.app.port)) + self.assertEqual(r.status_code, 401) + r = requests.get("http://127.0.0.1:{}/close".format(self.gui.app.port)) + self.assertEqual(r.status_code, 401) # 'Grouped' tests follow from here def run_all_receive_mode_setup_tests(self, public_mode): - '''Set up a share in Receive mode and start it''' + """Set up a share in Receive mode and start it""" self.click_mode(self.gui.receive_mode) self.history_is_not_visible(self.gui.receive_mode) self.click_toggle_history(self.gui.receive_mode) @@ -93,40 +106,43 @@ class GuiReceiveTest(GuiBaseTest): self.settings_button_is_hidden() self.server_is_started(self.gui.receive_mode) self.web_server_is_running() - self.have_a_slug(self.gui.receive_mode, public_mode) + self.have_a_password(self.gui.receive_mode, public_mode) self.url_description_shown(self.gui.receive_mode) self.have_copy_url_button(self.gui.receive_mode, public_mode) self.server_status_indicator_says_started(self.gui.receive_mode) - self.web_page(self.gui.receive_mode, 'Select the files you want to send, then click', public_mode) - - def run_all_receive_mode_tests(self, public_mode, receive_allow_receiver_shutdown): - '''Upload files in receive mode and stop the share''' + self.web_page( + self.gui.receive_mode, + "Select the files you want to send, then click", + public_mode, + ) + + def run_all_receive_mode_tests(self, public_mode): + """Upload files in receive mode and stop the share""" self.run_all_receive_mode_setup_tests(public_mode) if not public_mode: - self.try_public_paths_in_non_public_mode() - self.upload_file(public_mode, '/tmp/test.txt', 'test.txt') + self.try_without_auth_in_non_public_mode() + self.upload_file(public_mode, "/tmp/test.txt", "test.txt") self.history_widgets_present(self.gui.receive_mode) self.counter_incremented(self.gui.receive_mode, 1) - self.upload_file(public_mode, '/tmp/test.txt', 'test.txt') + self.upload_file(public_mode, "/tmp/test.txt", "test.txt") self.counter_incremented(self.gui.receive_mode, 2) - self.upload_file(public_mode, '/tmp/testdir/test', 'test') + self.upload_file(public_mode, "/tmp/testdir/test", "test") self.counter_incremented(self.gui.receive_mode, 3) - self.upload_file(public_mode, '/tmp/testdir/test', 'test') + self.upload_file(public_mode, "/tmp/testdir/test", "test") self.counter_incremented(self.gui.receive_mode, 4) # Test uploading the same file twice at the same time, and make sure no collisions - self.upload_file(public_mode, '/tmp/test.txt', 'test.txt', True) + self.upload_file(public_mode, "/tmp/test.txt", "test.txt", True) self.counter_incremented(self.gui.receive_mode, 6) - self.uploading_zero_files_shouldnt_change_ui(self.gui.receive_mode, public_mode) - self.history_indicator(self.gui.receive_mode, public_mode) + self.history_indicator(self.gui.receive_mode, public_mode, "2") self.server_is_stopped(self.gui.receive_mode, False) self.web_server_is_stopped() self.server_status_indicator_says_closed(self.gui.receive_mode, False) self.server_working_on_start_button_pressed(self.gui.receive_mode) self.server_is_started(self.gui.receive_mode) - self.history_indicator(self.gui.receive_mode, public_mode) + self.history_indicator(self.gui.receive_mode, public_mode, "2") - def run_all_receive_mode_unwritable_dir_tests(self, public_mode, receive_allow_receiver_shutdown): - '''Attempt to upload (unwritable) files in receive mode and stop the share''' + def run_all_receive_mode_unwritable_dir_tests(self, public_mode): + """Attempt to upload (unwritable) files in receive mode and stop the share""" self.run_all_receive_mode_setup_tests(public_mode) self.upload_dir_permissions(0o400) self.upload_file_should_fail(public_mode) @@ -142,3 +158,12 @@ class GuiReceiveTest(GuiBaseTest): self.autostop_timer_widget_hidden(self.gui.receive_mode) self.server_timed_out(self.gui.receive_mode, 15000) self.web_server_is_stopped() + + def run_all_clear_all_button_tests(self, public_mode): + """Test the Clear All history button""" + self.run_all_receive_mode_setup_tests(public_mode) + self.upload_file(public_mode, "/tmp/test.txt", "test.txt") + self.history_widgets_present(self.gui.receive_mode) + self.clear_all_history_items(self.gui.receive_mode, 0) + self.upload_file(public_mode, "/tmp/test.txt", "test.txt") + self.clear_all_history_items(self.gui.receive_mode, 2) diff --git a/tests/GuiShareTest.py b/tests/GuiShareTest.py index 29661712..630d0562 100644 --- a/tests/GuiShareTest.py +++ b/tests/GuiShareTest.py @@ -2,103 +2,186 @@ import os import requests import socks import zipfile +import tempfile from PyQt5 import QtCore, QtTest from .GuiBaseTest import GuiBaseTest + class GuiShareTest(GuiBaseTest): # Persistence tests - def have_same_slug(self, slug): - '''Test that we have the same slug''' - self.assertEqual(self.gui.share_mode.server_status.web.slug, slug) + def have_same_password(self, password): + """Test that we have the same password""" + self.assertEqual(self.gui.share_mode.server_status.web.password, password) # Share-specific tests def file_selection_widget_has_files(self, 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) + """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 + ) - def deleting_all_files_hides_delete_button(self): - '''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)) - QtTest.QTest.mouseClick(self.gui.share_mode.server_status.file_selection.file_list.viewport(), QtCore.Qt.LeftButton, pos=rect.center()) + """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) + ) + QtTest.QTest.mouseClick( + self.gui.share_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()) + self.assertTrue( + self.gui.share_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, 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)) - QtTest.QTest.mouseClick(self.gui.share_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()) - QtTest.QTest.mouseClick(self.gui.share_mode.server_status.file_selection.delete_button, QtCore.Qt.LeftButton) + QtTest.QTest.mouseClick( + self.gui.share_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) + ) + QtTest.QTest.mouseClick( + self.gui.share_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() + ) + QtTest.QTest.mouseClick( + self.gui.share_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()) + self.assertFalse( + self.gui.share_mode.server_status.file_selection.delete_button.isVisible() + ) - def add_a_file_and_delete_using_its_delete_widget(self): - '''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') - QtTest.QTest.mouseClick(self.gui.share_mode.server_status.file_selection.file_list.item(0).item_button, QtCore.Qt.LeftButton) + """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" + ) + QtTest.QTest.mouseClick( + self.gui.share_mode.server_status.file_selection.file_list.item( + 0 + ).item_button, + QtCore.Qt.LeftButton, + ) self.file_selection_widget_has_files(0) - - def file_selection_widget_readd_files(self): - '''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') + def file_selection_widget_read_files(self): + """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) - def add_large_file(self): - '''Add a large file to the share''' - size = 1024*1024*155 - with open('/tmp/large_file', 'wb') as fout: + """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('/tmp/large_file') - + self.gui.share_mode.server_status.file_selection.file_list.add_file( + "/tmp/large_file" + ) def add_delete_buttons_hidden(self): - '''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()) - self.assertFalse(self.gui.share_mode.server_status.file_selection.delete_button.isVisible()) + """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() + ) + self.assertFalse( + self.gui.share_mode.server_status.file_selection.delete_button.isVisible() + ) - def download_share(self, public_mode): - '''Test that we can download the share''' - s = socks.socksocket() - s.settimeout(60) - s.connect(('127.0.0.1', self.gui.app.port)) + """Test that we can download the share""" + url = "http://127.0.0.1:{}/download".format(self.gui.app.port) + if public_mode: + r = requests.get(url) + else: + r = requests.get( + url, + auth=requests.auth.HTTPBasicAuth( + "onionshare", self.gui.share_mode.server_status.web.password + ), + ) + + tmp_file = tempfile.NamedTemporaryFile() + with open(tmp_file.name, "wb") as f: + f.write(r.content) + + zip = zipfile.ZipFile(tmp_file.name) + 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 = "http://127.0.0.1:{}".format(self.gui.app.port) + download_file_url = "http://127.0.0.1:{}/test.txt".format(self.gui.app.port) if public_mode: - path = '/download' + r = requests.get(url) else: - path = '{}/download'.format(self.gui.share_mode.web.slug) - - 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/download.zip', 'wb') as file_to_write: - while True: - data = s.recv(1024) - if not data: - break - file_to_write.write(data) - file_to_write.close() - - zip = zipfile.ZipFile('/tmp/download.zip') + r = requests.get( + url, + auth=requests.auth.HTTPBasicAuth( + "onionshare", self.gui.share_mode.server_status.web.password + ), + ) + + if stay_open: + self.assertTrue('a href="test.txt"' in r.text) + + if public_mode: + 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 + ), + ) + + tmp_file = tempfile.NamedTemporaryFile() + with open(tmp_file.name, "wb") as f: + f.write(r.content) + + with open(tmp_file.name, "r") as f: + self.assertEqual("onionshare", f.read()) + else: + self.assertFalse('a href="/test.txt"' in r.text) + if public_mode: + 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 + ), + ) + self.assertEqual(r.status_code, 404) + self.download_share(public_mode) + QtTest.QTest.qWait(2000) - self.assertEqual('onionshare', zip.read('test.txt').decode('utf-8')) - def hit_404(self, public_mode): - '''Test that the server stops after too many 404s, or doesn't when in public_mode''' - bogus_path = '/gimme' - url = "http://127.0.0.1:{}/{}".format(self.gui.app.port, bogus_path) + def hit_401(self, public_mode): + """Test that the server stops after too many 401s, or doesn't when in public_mode""" + url = "http://127.0.0.1:{}/".format(self.gui.app.port) for _ in range(20): - r = requests.get(url) + password_guess = self.gui.common.build_password() + r = 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: @@ -111,12 +194,6 @@ class GuiShareTest(GuiBaseTest): else: self.web_server_is_stopped() - - def add_button_visible(self): - '''Test that the add button should be visible''' - self.assertTrue(self.gui.share_mode.server_status.file_selection.add_button.isVisible()) - - # 'Grouped' tests follow from here def run_all_share_mode_setup_tests(self): @@ -128,9 +205,8 @@ class GuiShareTest(GuiBaseTest): 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_readd_files() + 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) @@ -139,32 +215,59 @@ class GuiShareTest(GuiBaseTest): self.settings_button_is_hidden() self.server_is_started(self.gui.share_mode, startup_time) self.web_server_is_running() - self.have_a_slug(self.gui.share_mode, public_mode) + 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.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.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""" @@ -176,15 +279,13 @@ class GuiShareTest(GuiBaseTest): 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 slug is the same on multiple shared""" + """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) - slug = self.gui.share_mode.server_status.web.slug + password = self.gui.share_mode.server_status.web.password self.run_all_share_mode_download_tests(public_mode, stay_open) - self.have_same_slug(slug) - + self.have_same_password(password) def run_all_share_mode_timer_tests(self, public_mode): """Auto-stop timer tests in share mode""" @@ -212,12 +313,16 @@ class GuiShareTest(GuiBaseTest): 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) + 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''' + """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.gui.share_mode.server_status.file_selection.file_list.add_file( + "/tmp/nonexistent.txt" + ) self.file_selection_widget_has_files(2) diff --git a/tests/GuiWebsiteTest.py b/tests/GuiWebsiteTest.py new file mode 100644 index 00000000..f6b67112 --- /dev/null +++ b/tests/GuiWebsiteTest.py @@ -0,0 +1,136 @@ +import json +import os +import requests +import socks +import zipfile +import tempfile +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 .GuiShareTest import GuiShareTest + + +class GuiWebsiteTest(GuiShareTest): + @staticmethod + def set_up(test_settings): + """Create GUI with given settings""" + # Create our test file + testfile = open("/tmp/index.html", "w") + testfile.write( + "<html><body><p>This is a test website hosted by OnionShare</p></body></html>" + ) + 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["data_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/settings.json", "w").write(json.dumps(test_settings)) + + gui = OnionShareGui( + common, + testonion, + qtapp, + app, + ["/tmp/index.html"], + "/tmp/settings.json", + True, + ) + return gui + + @staticmethod + def tear_down(): + """Clean up after tests""" + try: + os.remove("/tmp/index.html") + os.remove("/tmp/settings.json") + except: + pass + + def view_website(self, public_mode): + """Test that we can download the share""" + url = "http://127.0.0.1:{}/".format(self.gui.app.port) + if public_mode: + r = requests.get(url) + else: + r = requests.get( + url, + auth=requests.auth.HTTPBasicAuth( + "onionshare", self.gui.website_mode.server_status.web.password + ), + ) + + QtTest.QTest.qWait(2000) + self.assertTrue("This is a test website hosted by OnionShare" in r.text) + + def check_csp_header(self, public_mode, csp_header_disabled): + """Test that the CSP header is present when enabled or vice versa""" + url = "http://127.0.0.1:{}/".format(self.gui.app.port) + if public_mode: + r = requests.get(url) + else: + r = requests.get( + url, + auth=requests.auth.HTTPBasicAuth( + "onionshare", self.gui.website_mode.server_status.web.password + ), + ) + + QtTest.QTest.qWait(2000) + if csp_header_disabled: + self.assertFalse("Content-Security-Policy" in r.headers) + else: + self.assertTrue("Content-Security-Policy" in r.headers) + + def run_all_website_mode_setup_tests(self): + """Tests in website mode prior to starting a share""" + self.click_mode(self.gui.website_mode) + self.file_selection_widget_has_files(1) + self.history_is_not_visible(self.gui.website_mode) + self.click_toggle_history(self.gui.website_mode) + self.history_is_visible(self.gui.website_mode) + + def run_all_website_mode_started_tests(self, public_mode, startup_time=2000): + """Tests in website mode after starting a share""" + self.server_working_on_start_button_pressed(self.gui.website_mode) + self.server_status_indicator_says_starting(self.gui.website_mode) + self.add_delete_buttons_hidden() + self.settings_button_is_hidden() + self.server_is_started(self.gui.website_mode, startup_time) + self.web_server_is_running() + self.have_a_password(self.gui.website_mode, public_mode) + self.url_description_shown(self.gui.website_mode) + self.have_copy_url_button(self.gui.website_mode, public_mode) + self.server_status_indicator_says_started(self.gui.website_mode) + + def run_all_website_mode_download_tests(self, public_mode): + """Tests in website mode after viewing the site""" + self.run_all_website_mode_setup_tests() + self.run_all_website_mode_started_tests(public_mode, startup_time=2000) + self.view_website(public_mode) + self.check_csp_header( + public_mode, self.gui.common.settings.get("csp_header_disabled") + ) + self.history_widgets_present(self.gui.website_mode) + self.server_is_stopped(self.gui.website_mode, False) + self.web_server_is_stopped() + self.server_status_indicator_says_closed(self.gui.website_mode, False) + self.add_button_visible(self.gui.website_mode) diff --git a/tests/SettingsGuiBaseTest.py b/tests/SettingsGuiBaseTest.py index 35bdd9c6..1aa6da25 100644 --- a/tests/SettingsGuiBaseTest.py +++ b/tests/SettingsGuiBaseTest.py @@ -23,17 +23,17 @@ class OnionStub(object): class SettingsGuiBaseTest(object): @staticmethod def set_up(): - '''Create the GUI''' + """Create the GUI""" # Default settings for the settings GUI tests test_settings = { - "no_bridges": False, - "tor_bridges_use_custom_bridges": "Bridge 1.2.3.4:56 EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\nBridge 5.6.7.8:910 EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\nBridge 11.12.13.14:1516 EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n", + "no_bridges": False, + "tor_bridges_use_custom_bridges": "Bridge 1.2.3.4:56 EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\nBridge 5.6.7.8:910 EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\nBridge 11.12.13.14:1516 EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n", } # Create our test file - testfile = open('/tmp/test.txt', 'w') - testfile.write('onionshare') + testfile = open("/tmp/test.txt", "w") + testfile.write("onionshare") testfile.close() common = Common() @@ -51,22 +51,22 @@ class SettingsGuiBaseTest(object): if key not in test_settings: test_settings[key] = val - open('/tmp/settings.json', 'w').write(json.dumps(test_settings)) + open("/tmp/settings.json", "w").write(json.dumps(test_settings)) - gui = SettingsDialog(common, testonion, qtapp, '/tmp/settings.json', True) + gui = SettingsDialog(common, testonion, qtapp, "/tmp/settings.json", True) return gui @staticmethod def tear_down(): - '''Clean up after tests''' - os.remove('/tmp/settings.json') + """Clean up after tests""" + os.remove("/tmp/settings.json") def run_settings_gui_tests(self): self.gui.show() # Window is shown self.assertTrue(self.gui.isVisible()) - self.assertEqual(self.gui.windowTitle(), strings._('gui_settings_window_title')) + self.assertEqual(self.gui.windowTitle(), strings._("gui_settings_window_title")) # Check for updates button is hidden self.assertFalse(self.gui.check_for_updates_button.isVisible()) @@ -74,13 +74,21 @@ class SettingsGuiBaseTest(object): # public mode is off self.assertFalse(self.gui.public_mode_checkbox.isChecked()) # enable public mode - QtTest.QTest.mouseClick(self.gui.public_mode_checkbox, QtCore.Qt.LeftButton, pos=QtCore.QPoint(2,self.gui.public_mode_checkbox.height()/2)) + QtTest.QTest.mouseClick( + self.gui.public_mode_checkbox, + QtCore.Qt.LeftButton, + pos=QtCore.QPoint(2, self.gui.public_mode_checkbox.height() / 2), + ) self.assertTrue(self.gui.public_mode_checkbox.isChecked()) # autostop timer is off self.assertFalse(self.gui.autostop_timer_checkbox.isChecked()) # enable autostop timer - QtTest.QTest.mouseClick(self.gui.autostop_timer_checkbox, QtCore.Qt.LeftButton, pos=QtCore.QPoint(2,self.gui.autostop_timer_checkbox.height()/2)) + QtTest.QTest.mouseClick( + self.gui.autostop_timer_checkbox, + QtCore.Qt.LeftButton, + pos=QtCore.QPoint(2, self.gui.autostop_timer_checkbox.height() / 2), + ) self.assertTrue(self.gui.autostop_timer_checkbox.isChecked()) # legacy mode checkbox and related widgets @@ -96,32 +104,70 @@ class SettingsGuiBaseTest(object): self.assertFalse(self.gui.hidservauth_copy_button.isVisible()) # enable legacy mode - QtTest.QTest.mouseClick(self.gui.use_legacy_v2_onions_checkbox, QtCore.Qt.LeftButton, pos=QtCore.QPoint(2,self.gui.use_legacy_v2_onions_checkbox.height()/2)) + QtTest.QTest.mouseClick( + self.gui.use_legacy_v2_onions_checkbox, + QtCore.Qt.LeftButton, + pos=QtCore.QPoint( + 2, self.gui.use_legacy_v2_onions_checkbox.height() / 2 + ), + ) self.assertTrue(self.gui.use_legacy_v2_onions_checkbox.isChecked()) self.assertTrue(self.gui.save_private_key_checkbox.isVisible()) self.assertTrue(self.gui.use_stealth_widget.isVisible()) # enable persistent mode - QtTest.QTest.mouseClick(self.gui.save_private_key_checkbox, QtCore.Qt.LeftButton, pos=QtCore.QPoint(2,self.gui.save_private_key_checkbox.height()/2)) + QtTest.QTest.mouseClick( + self.gui.save_private_key_checkbox, + QtCore.Qt.LeftButton, + pos=QtCore.QPoint( + 2, self.gui.save_private_key_checkbox.height() / 2 + ), + ) self.assertTrue(self.gui.save_private_key_checkbox.isChecked()) # enable stealth mode - QtTest.QTest.mouseClick(self.gui.stealth_checkbox, QtCore.Qt.LeftButton, pos=QtCore.QPoint(2,self.gui.stealth_checkbox.height()/2)) + QtTest.QTest.mouseClick( + self.gui.stealth_checkbox, + QtCore.Qt.LeftButton, + pos=QtCore.QPoint(2, self.gui.stealth_checkbox.height() / 2), + ) self.assertTrue(self.gui.stealth_checkbox.isChecked()) # now that stealth is enabled, we can't turn off legacy mode self.assertFalse(self.gui.use_legacy_v2_onions_checkbox.isEnabled()) # disable stealth, persistence - QtTest.QTest.mouseClick(self.gui.save_private_key_checkbox, QtCore.Qt.LeftButton, pos=QtCore.QPoint(2,self.gui.save_private_key_checkbox.height()/2)) - QtTest.QTest.mouseClick(self.gui.stealth_checkbox, QtCore.Qt.LeftButton, pos=QtCore.QPoint(2,self.gui.stealth_checkbox.height()/2)) + QtTest.QTest.mouseClick( + self.gui.save_private_key_checkbox, + QtCore.Qt.LeftButton, + pos=QtCore.QPoint( + 2, self.gui.save_private_key_checkbox.height() / 2 + ), + ) + QtTest.QTest.mouseClick( + self.gui.stealth_checkbox, + QtCore.Qt.LeftButton, + pos=QtCore.QPoint(2, self.gui.stealth_checkbox.height() / 2), + ) # legacy mode checkbox is enabled again self.assertTrue(self.gui.use_legacy_v2_onions_checkbox.isEnabled()) # uncheck legacy mode - QtTest.QTest.mouseClick(self.gui.use_legacy_v2_onions_checkbox, QtCore.Qt.LeftButton, pos=QtCore.QPoint(2,self.gui.use_legacy_v2_onions_checkbox.height()/2)) + QtTest.QTest.mouseClick( + self.gui.use_legacy_v2_onions_checkbox, + QtCore.Qt.LeftButton, + pos=QtCore.QPoint( + 2, self.gui.use_legacy_v2_onions_checkbox.height() / 2 + ), + ) # legacy options hidden again self.assertTrue(self.gui.save_private_key_widget.isVisible()) self.assertFalse(self.gui.use_stealth_widget.isVisible()) # re-enable legacy mode - QtTest.QTest.mouseClick(self.gui.use_legacy_v2_onions_checkbox, QtCore.Qt.LeftButton, pos=QtCore.QPoint(2,self.gui.use_legacy_v2_onions_checkbox.height()/2)) + QtTest.QTest.mouseClick( + self.gui.use_legacy_v2_onions_checkbox, + QtCore.Qt.LeftButton, + pos=QtCore.QPoint( + 2, self.gui.use_legacy_v2_onions_checkbox.height() / 2 + ), + ) else: # legacy mode setting is hidden @@ -131,8 +177,16 @@ class SettingsGuiBaseTest(object): self.assertTrue(self.gui.use_stealth_widget.isVisible()) # enable them all again so that we can see the setting stick in settings.json - QtTest.QTest.mouseClick(self.gui.save_private_key_checkbox, QtCore.Qt.LeftButton, pos=QtCore.QPoint(2,self.gui.save_private_key_checkbox.height()/2)) - QtTest.QTest.mouseClick(self.gui.stealth_checkbox, QtCore.Qt.LeftButton, pos=QtCore.QPoint(2,self.gui.stealth_checkbox.height()/2)) + QtTest.QTest.mouseClick( + self.gui.save_private_key_checkbox, + QtCore.Qt.LeftButton, + pos=QtCore.QPoint(2, self.gui.save_private_key_checkbox.height() / 2), + ) + QtTest.QTest.mouseClick( + self.gui.stealth_checkbox, + QtCore.Qt.LeftButton, + pos=QtCore.QPoint(2, self.gui.stealth_checkbox.height() / 2), + ) else: # None of the onion settings should appear self.assertFalse(self.gui.use_legacy_v2_onions_checkbox.isVisible()) @@ -144,12 +198,17 @@ class SettingsGuiBaseTest(object): # stay open toggled off, on self.assertTrue(self.gui.close_after_first_download_checkbox.isChecked()) - QtTest.QTest.mouseClick(self.gui.close_after_first_download_checkbox, QtCore.Qt.LeftButton, pos=QtCore.QPoint(2,self.gui.close_after_first_download_checkbox.height()/2)) + QtTest.QTest.mouseClick( + self.gui.close_after_first_download_checkbox, + QtCore.Qt.LeftButton, + pos=QtCore.QPoint( + 2, self.gui.close_after_first_download_checkbox.height() / 2 + ), + ) self.assertFalse(self.gui.close_after_first_download_checkbox.isChecked()) # receive mode - self.gui.data_dir_lineedit.setText('/tmp/OnionShareSettingsTest') - + self.gui.data_dir_lineedit.setText("/tmp/OnionShareSettingsTest") # bundled mode is enabled self.assertTrue(self.gui.connection_type_bundled_radio.isEnabled()) @@ -161,7 +220,11 @@ class SettingsGuiBaseTest(object): self.assertTrue(self.gui.tor_bridges_use_custom_radio.isChecked()) # switch to obfs4 - QtTest.QTest.mouseClick(self.gui.tor_bridges_use_obfs4_radio, QtCore.Qt.LeftButton, pos=QtCore.QPoint(2,self.gui.tor_bridges_use_obfs4_radio.height()/2)) + QtTest.QTest.mouseClick( + self.gui.tor_bridges_use_obfs4_radio, + QtCore.Qt.LeftButton, + pos=QtCore.QPoint(2, self.gui.tor_bridges_use_obfs4_radio.height() / 2), + ) self.assertTrue(self.gui.tor_bridges_use_obfs4_radio.isChecked()) # custom bridges are hidden @@ -175,7 +238,11 @@ class SettingsGuiBaseTest(object): self.assertFalse(self.gui.connection_type_socket_file_radio.isChecked()) # enable automatic mode - QtTest.QTest.mouseClick(self.gui.connection_type_automatic_radio, QtCore.Qt.LeftButton, pos=QtCore.QPoint(2,self.gui.connection_type_automatic_radio.height()/2)) + QtTest.QTest.mouseClick( + self.gui.connection_type_automatic_radio, + QtCore.Qt.LeftButton, + pos=QtCore.QPoint(2, self.gui.connection_type_automatic_radio.height() / 2), + ) self.assertTrue(self.gui.connection_type_automatic_radio.isChecked()) # bundled is off self.assertFalse(self.gui.connection_type_bundled_radio.isChecked()) @@ -187,7 +254,13 @@ class SettingsGuiBaseTest(object): self.assertFalse(self.gui.authenticate_password_radio.isVisible()) # enable control port mode - QtTest.QTest.mouseClick(self.gui.connection_type_control_port_radio, QtCore.Qt.LeftButton, pos=QtCore.QPoint(2,self.gui.connection_type_control_port_radio.height()/2)) + QtTest.QTest.mouseClick( + self.gui.connection_type_control_port_radio, + QtCore.Qt.LeftButton, + pos=QtCore.QPoint( + 2, self.gui.connection_type_control_port_radio.height() / 2 + ), + ) self.assertTrue(self.gui.connection_type_control_port_radio.isChecked()) # automatic is off self.assertFalse(self.gui.connection_type_automatic_radio.isChecked()) @@ -196,7 +269,13 @@ class SettingsGuiBaseTest(object): self.assertTrue(self.gui.authenticate_password_radio.isVisible()) # enable socket mode - QtTest.QTest.mouseClick(self.gui.connection_type_socket_file_radio, QtCore.Qt.LeftButton, pos=QtCore.QPoint(2,self.gui.connection_type_socket_file_radio.height()/2)) + QtTest.QTest.mouseClick( + self.gui.connection_type_socket_file_radio, + QtCore.Qt.LeftButton, + pos=QtCore.QPoint( + 2, self.gui.connection_type_socket_file_radio.height() / 2 + ), + ) self.assertTrue(self.gui.connection_type_socket_file_radio.isChecked()) # control port is off self.assertFalse(self.gui.connection_type_control_port_radio.isChecked()) @@ -205,20 +284,30 @@ class SettingsGuiBaseTest(object): self.assertTrue(self.gui.authenticate_password_radio.isVisible()) # re-enable bundled mode - QtTest.QTest.mouseClick(self.gui.connection_type_bundled_radio, QtCore.Qt.LeftButton, pos=QtCore.QPoint(2,self.gui.connection_type_bundled_radio.height()/2)) + QtTest.QTest.mouseClick( + self.gui.connection_type_bundled_radio, + QtCore.Qt.LeftButton, + pos=QtCore.QPoint(2, self.gui.connection_type_bundled_radio.height() / 2), + ) # go back to custom bridges - QtTest.QTest.mouseClick(self.gui.tor_bridges_use_custom_radio, QtCore.Qt.LeftButton, pos=QtCore.QPoint(2,self.gui.tor_bridges_use_custom_radio.height()/2)) + QtTest.QTest.mouseClick( + self.gui.tor_bridges_use_custom_radio, + QtCore.Qt.LeftButton, + pos=QtCore.QPoint(2, self.gui.tor_bridges_use_custom_radio.height() / 2), + ) self.assertTrue(self.gui.tor_bridges_use_custom_radio.isChecked()) self.assertTrue(self.gui.tor_bridges_use_custom_textbox.isVisible()) self.assertFalse(self.gui.tor_bridges_use_obfs4_radio.isChecked()) - self.gui.tor_bridges_use_custom_textbox.setPlainText('94.242.249.2:83 E25A95F1DADB739F0A83EB0223A37C02FD519306\n148.251.90.59:7510 019F727CA6DCA6CA5C90B55E477B7D87981E75BC\n93.80.47.217:41727 A6A0D497D98097FCFE91D639548EE9E34C15CDD3') + self.gui.tor_bridges_use_custom_textbox.setPlainText( + "94.242.249.2:83 E25A95F1DADB739F0A83EB0223A37C02FD519306\n148.251.90.59:7510 019F727CA6DCA6CA5C90B55E477B7D87981E75BC\n93.80.47.217:41727 A6A0D497D98097FCFE91D639548EE9E34C15CDD3" + ) # Test that the Settings Dialog can save the settings and close itself QtTest.QTest.mouseClick(self.gui.save_button, QtCore.Qt.LeftButton) self.assertFalse(self.gui.isVisible()) # Test our settings are reflected in the settings json - with open('/tmp/settings.json') as f: + with open("/tmp/settings.json") as f: data = json.load(f) self.assertTrue(data["public_mode"]) @@ -238,4 +327,7 @@ class SettingsGuiBaseTest(object): self.assertFalse(data["close_after_first_download"]) self.assertEqual(data["connection_type"], "bundled") self.assertFalse(data["tor_bridges_use_obfs4"]) - self.assertEqual(data["tor_bridges_use_custom_bridges"], "Bridge 94.242.249.2:83 E25A95F1DADB739F0A83EB0223A37C02FD519306\nBridge 148.251.90.59:7510 019F727CA6DCA6CA5C90B55E477B7D87981E75BC\nBridge 93.80.47.217:41727 A6A0D497D98097FCFE91D639548EE9E34C15CDD3\n") + self.assertEqual( + data["tor_bridges_use_custom_bridges"], + "Bridge 94.242.249.2:83 E25A95F1DADB739F0A83EB0223A37C02FD519306\nBridge 148.251.90.59:7510 019F727CA6DCA6CA5C90B55E477B7D87981E75BC\nBridge 93.80.47.217:41727 A6A0D497D98097FCFE91D639548EE9E34C15CDD3\n", + ) diff --git a/tests/TorGuiBaseTest.py b/tests/TorGuiBaseTest.py index 8bd963bd..434a525d 100644 --- a/tests/TorGuiBaseTest.py +++ b/tests/TorGuiBaseTest.py @@ -16,20 +16,21 @@ from onionshare_gui.mode.receive_mode import ReceiveMode from .GuiBaseTest import GuiBaseTest + class TorGuiBaseTest(GuiBaseTest): @staticmethod def set_up(test_settings): - '''Create GUI with given settings''' + """Create GUI with given settings""" # Create our test file - testfile = open('/tmp/test.txt', 'w') - testfile.write('onionshare') + testfile = open("/tmp/test.txt", "w") + testfile.write("onionshare") testfile.close() # Create a test dir and files - if not os.path.exists('/tmp/testdir'): - testdir = os.mkdir('/tmp/testdir') - testfile = open('/tmp/testdir/test.txt', 'w') - testfile.write('onionshare') + if not os.path.exists("/tmp/testdir"): + testdir = os.mkdir("/tmp/testdir") + testfile = open("/tmp/testdir/test.txt", "w") + testfile.write("onionshare") testfile.close() common = Common() @@ -38,8 +39,8 @@ class TorGuiBaseTest(GuiBaseTest): strings.load_strings(common) # Get all of the settings in test_settings - test_settings['connection_type'] = 'automatic' - test_settings['data_dir'] = '/tmp/OnionShare' + test_settings["connection_type"] = "automatic" + test_settings["data_dir"] = "/tmp/OnionShare" for key, val in common.settings.default_settings.items(): if key not in test_settings: test_settings[key] = val @@ -51,13 +52,21 @@ class TorGuiBaseTest(GuiBaseTest): app = OnionShare(common, testonion, False, 0) web = Web(common, False, False) - open('/tmp/settings.json', 'w').write(json.dumps(test_settings)) - - gui = OnionShareGui(common, testonion, qtapp, app, ['/tmp/test.txt', '/tmp/testdir'], '/tmp/settings.json', False) + open("/tmp/settings.json", "w").write(json.dumps(test_settings)) + + gui = OnionShareGui( + common, + testonion, + qtapp, + app, + ["/tmp/test.txt", "/tmp/testdir"], + "/tmp/settings.json", + False, + ) return gui 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''' + """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) @@ -70,15 +79,17 @@ class TorGuiBaseTest(GuiBaseTest): (socks_address, socks_port) = self.gui.app.onion.get_tor_socks_port() session = requests.session() session.proxies = {} - session.proxies['http'] = 'socks5h://{}:{}'.format(socks_address, socks_port) + session.proxies["http"] = "socks5h://{}:{}".format(socks_address, socks_port) if type(mode) == ReceiveMode: # Upload a file - files = {'file[]': open('/tmp/test.txt', 'rb')} + files = {"file[]": open("/tmp/test.txt", "rb")} if not public_mode: - path = 'http://{}/{}/upload'.format(self.gui.app.onion_host, mode.web.slug) + path = "http://{}/{}/upload".format( + self.gui.app.onion_host, mode.web.password + ) else: - path = 'http://{}/upload'.format(self.gui.app.onion_host) + path = "http://{}/upload".format(self.gui.app.onion_host) response = session.post(path, files=files) QtTest.QTest.qWait(4000) @@ -87,7 +98,9 @@ class TorGuiBaseTest(GuiBaseTest): if public_mode: path = "http://{}/download".format(self.gui.app.onion_host) else: - path = "http://{}/{}/download".format(self.gui.app.onion_host, mode.web.slug) + path = "http://{}/{}/download".format( + self.gui.app.onion_host, mode.web.password + ) response = session.get(path) QtTest.QTest.qWait(4000) @@ -100,61 +113,72 @@ class TorGuiBaseTest(GuiBaseTest): self.assertFalse(mode.toggle_history.indicator_label.isVisible()) def have_an_onion_service(self): - '''Test that we have a valid Onion URL''' - self.assertRegex(self.gui.app.onion_host, r'[a-z2-7].onion') + """Test that we have a valid Onion URL""" + self.assertRegex(self.gui.app.onion_host, r"[a-z2-7].onion") def web_page(self, mode, string, public_mode): - '''Test that the web page contains a string''' + """Test that the web page contains a string""" (socks_address, socks_port) = self.gui.app.onion.get_tor_socks_port() socks.set_default_proxy(socks.SOCKS5, socks_address, socks_port) s = socks.socksocket() s.settimeout(60) s.connect((self.gui.app.onion_host, 80)) if not public_mode: - path = '/{}'.format(mode.server_status.web.slug) + path = "/{}".format(mode.server_status.web.password) else: - path = '/' - http_request = 'GET {} HTTP/1.0\r\n'.format(path) - http_request += 'Host: {}\r\n'.format(self.gui.app.onion_host) - http_request += '\r\n' - s.sendall(http_request.encode('utf-8')) - with open('/tmp/webpage', 'wb') as file_to_write: + path = "/" + http_request = "GET {} HTTP/1.0\r\n".format(path) + http_request += "Host: {}\r\n".format(self.gui.app.onion_host) + 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) + data = s.recv(1024) + if not data: + break + file_to_write.write(data) file_to_write.close() - f = open('/tmp/webpage') + f = open("/tmp/webpage") self.assertTrue(string in f.read()) f.close() def have_copy_url_button(self, mode, public_mode): - '''Test that the Copy URL button is shown and that the clipboard is correct''' + """Test that the Copy URL button is shown and that the clipboard is correct""" self.assertTrue(mode.server_status.copy_url_button.isVisible()) - QtTest.QTest.mouseClick(mode.server_status.copy_url_button, QtCore.Qt.LeftButton) + QtTest.QTest.mouseClick( + mode.server_status.copy_url_button, QtCore.Qt.LeftButton + ) clipboard = self.gui.qtapp.clipboard() if public_mode: - self.assertEqual(clipboard.text(), 'http://{}'.format(self.gui.app.onion_host)) + self.assertEqual( + clipboard.text(), "http://{}".format(self.gui.app.onion_host) + ) else: - self.assertEqual(clipboard.text(), 'http://{}/{}'.format(self.gui.app.onion_host, mode.server_status.web.slug)) - + self.assertEqual( + clipboard.text(), + "http://{}/{}".format( + self.gui.app.onion_host, mode.server_status.web.password + ), + ) # Stealth tests def copy_have_hidserv_auth_button(self, mode): - '''Test that the Copy HidservAuth button is shown''' + """Test that the Copy HidservAuth button is shown""" self.assertTrue(mode.server_status.copy_hidservauth_button.isVisible()) def hidserv_auth_string(self): - '''Test the validity of the HidservAuth string''' - self.assertRegex(self.gui.app.auth_string, r'HidServAuth {} [a-zA-Z1-9]'.format(self.gui.app.onion_host)) - - + """Test the validity of the HidservAuth string""" + self.assertRegex( + self.gui.app.auth_string, + r"HidServAuth {} [a-zA-Z1-9]".format(self.gui.app.onion_host), + ) # Miscellaneous tests def tor_killed_statusbar_message_shown(self, mode): - '''Test that the status bar message shows Tor was disconnected''' + """Test that the status bar message shows Tor was disconnected""" self.gui.app.onion.c = None QtTest.QTest.qWait(1000) - self.assertTrue(mode.status_bar.currentMessage(), strings._('gui_tor_connection_lost')) + self.assertTrue( + mode.status_bar.currentMessage(), strings._("gui_tor_connection_lost") + ) diff --git a/tests/TorGuiReceiveTest.py b/tests/TorGuiReceiveTest.py index a21dd4fc..18a00643 100644 --- a/tests/TorGuiReceiveTest.py +++ b/tests/TorGuiReceiveTest.py @@ -3,28 +3,29 @@ import requests from PyQt5 import QtTest from .TorGuiBaseTest import TorGuiBaseTest -class TorGuiReceiveTest(TorGuiBaseTest): +class TorGuiReceiveTest(TorGuiBaseTest): def upload_file(self, public_mode, file_to_upload, expected_file): - '''Test that we can upload the file''' + """Test that we can upload the file""" (socks_address, socks_port) = self.gui.app.onion.get_tor_socks_port() session = requests.session() session.proxies = {} - session.proxies['http'] = 'socks5h://{}:{}'.format(socks_address, socks_port) - files = {'file[]': open(file_to_upload, 'rb')} + session.proxies["http"] = "socks5h://{}:{}".format(socks_address, socks_port) + files = {"file[]": open(file_to_upload, "rb")} if not public_mode: - path = 'http://{}/{}/upload'.format(self.gui.app.onion_host, self.gui.receive_mode.web.slug) + path = "http://{}/{}/upload".format( + self.gui.app.onion_host, self.gui.receive_mode.web.password + ) else: - path = 'http://{}/upload'.format(self.gui.app.onion_host) + path = "http://{}/upload".format(self.gui.app.onion_host) response = session.post(path, files=files) QtTest.QTest.qWait(4000) self.assertTrue(os.path.isfile(expected_file)) - # 'Grouped' tests follow from here def run_all_receive_mode_tests(self, public_mode, receive_allow_receiver_shutdown): - '''Run a full suite of tests in Receive mode''' + """Run a full suite of tests in Receive mode""" self.click_mode(self.gui.receive_mode) self.history_is_not_visible(self.gui.receive_mode) self.click_toggle_history(self.gui.receive_mode) @@ -35,19 +36,23 @@ class TorGuiReceiveTest(TorGuiBaseTest): self.server_is_started(self.gui.receive_mode, startup_time=45000) self.web_server_is_running() self.have_an_onion_service() - self.have_a_slug(self.gui.receive_mode, public_mode) + self.have_a_password(self.gui.receive_mode, public_mode) self.url_description_shown(self.gui.receive_mode) self.have_copy_url_button(self.gui.receive_mode, public_mode) self.server_status_indicator_says_started(self.gui.receive_mode) - self.web_page(self.gui.receive_mode, 'Select the files you want to send, then click', public_mode) - self.upload_file(public_mode, '/tmp/test.txt', '/tmp/OnionShare/test.txt') + self.web_page( + self.gui.receive_mode, + "Select the files you want to send, then click", + public_mode, + ) + self.upload_file(public_mode, "/tmp/test.txt", "/tmp/OnionShare/test.txt") self.history_widgets_present(self.gui.receive_mode) self.counter_incremented(self.gui.receive_mode, 1) - self.upload_file(public_mode, '/tmp/test.txt', '/tmp/OnionShare/test-2.txt') + self.upload_file(public_mode, "/tmp/test.txt", "/tmp/OnionShare/test-2.txt") self.counter_incremented(self.gui.receive_mode, 2) - self.upload_file(public_mode, '/tmp/testdir/test', '/tmp/OnionShare/test') + self.upload_file(public_mode, "/tmp/testdir/test", "/tmp/OnionShare/test") self.counter_incremented(self.gui.receive_mode, 3) - self.upload_file(public_mode, '/tmp/testdir/test', '/tmp/OnionShare/test-2') + self.upload_file(public_mode, "/tmp/testdir/test", "/tmp/OnionShare/test-2") self.counter_incremented(self.gui.receive_mode, 4) self.history_indicator(self.gui.receive_mode, public_mode) self.server_is_stopped(self.gui.receive_mode, False) @@ -56,4 +61,3 @@ class TorGuiReceiveTest(TorGuiBaseTest): self.server_working_on_start_button_pressed(self.gui.receive_mode) self.server_is_started(self.gui.receive_mode, startup_time=45000) self.history_indicator(self.gui.receive_mode, public_mode) - diff --git a/tests/TorGuiShareTest.py b/tests/TorGuiShareTest.py index 36efacd1..e86a6927 100644 --- a/tests/TorGuiShareTest.py +++ b/tests/TorGuiShareTest.py @@ -4,48 +4,50 @@ from PyQt5 import QtTest from .TorGuiBaseTest import TorGuiBaseTest from .GuiShareTest import GuiShareTest + class TorGuiShareTest(TorGuiBaseTest, GuiShareTest): def download_share(self, public_mode): - '''Test downloading a share''' + """Test downloading a share""" # Set up connecting to the onion (socks_address, socks_port) = self.gui.app.onion.get_tor_socks_port() session = requests.session() session.proxies = {} - session.proxies['http'] = 'socks5h://{}:{}'.format(socks_address, socks_port) + session.proxies["http"] = "socks5h://{}:{}".format(socks_address, socks_port) # Download files if public_mode: path = "http://{}/download".format(self.gui.app.onion_host) else: - path = "http://{}/{}/download".format(self.gui.app.onion_host, self.gui.share_mode.web.slug) + path = "http://{}/{}/download".format( + self.gui.app.onion_host, self.gui.share_mode.web.password + ) response = session.get(path, stream=True) QtTest.QTest.qWait(4000) if response.status_code == 200: - with open('/tmp/download.zip', 'wb') as file_to_write: + with open("/tmp/download.zip", "wb") as file_to_write: for chunk in response.iter_content(chunk_size=128): file_to_write.write(chunk) file_to_write.close() - zip = zipfile.ZipFile('/tmp/download.zip') + zip = zipfile.ZipFile("/tmp/download.zip") QtTest.QTest.qWait(4000) - self.assertEqual('onionshare', zip.read('test.txt').decode('utf-8')) - + self.assertEqual("onionshare", zip.read("test.txt").decode("utf-8")) # Persistence tests def have_same_onion(self, onion): - '''Test that we have the same onion''' + """Test that we have the same onion""" self.assertEqual(self.gui.app.onion_host, onion) # legacy v2 onion test def have_v2_onion(self): - '''Test that the onion is a v2 style onion''' - self.assertRegex(self.gui.app.onion_host, r'[a-z2-7].onion') + """Test that the onion is a v2 style onion""" + self.assertRegex(self.gui.app.onion_host, r"[a-z2-7].onion") self.assertEqual(len(self.gui.app.onion_host), 22) # 'Grouped' tests follow from here def run_all_share_mode_started_tests(self, public_mode): - '''Tests in share mode after starting a share''' + """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() @@ -53,37 +55,34 @@ class TorGuiShareTest(TorGuiBaseTest, GuiShareTest): self.server_is_started(self.gui.share_mode, startup_time=45000) self.web_server_is_running() self.have_an_onion_service() - self.have_a_slug(self.gui.share_mode, public_mode) + 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.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.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, startup_time=45000) self.history_indicator(self.gui.share_mode, public_mode) - def run_all_share_mode_persistent_tests(self, public_mode, stay_open): - """Same as end-to-end share tests but also test the slug is the same on multiple shared""" + """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) - slug = self.gui.share_mode.server_status.web.slug + password = self.gui.share_mode.server_status.web.password onion = self.gui.app.onion_host self.run_all_share_mode_download_tests(public_mode, stay_open) self.have_same_onion(onion) - self.have_same_slug(slug) + 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() @@ -92,4 +91,3 @@ class TorGuiShareTest(TorGuiBaseTest, GuiShareTest): self.autostop_timer_widget_hidden(self.gui.share_mode) self.server_timed_out(self.gui.share_mode, 125000) self.web_server_is_stopped() - diff --git a/tests/conftest.py b/tests/conftest.py index 7aca2b2c..ac81d14d 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -1,4 +1,5 @@ import sys + # Force tests to look for resources in the source code tree sys.onionshare_dev_mode = True @@ -10,6 +11,7 @@ import pytest from onionshare import common, web, settings, strings + def pytest_addoption(parser): parser.addoption( "--rungui", action="store_true", default=False, help="run GUI tests" @@ -27,7 +29,7 @@ def pytest_collection_modifyitems(config, items): if "tor" in item.keywords: item.add_marker(skip_tor) - if not config.getoption('--rungui'): + if not config.getoption("--rungui"): # --rungui given in cli: do not skip GUI tests skip_gui = pytest.mark.skip(reason="need --rungui option to run") for item in items: @@ -43,8 +45,8 @@ def temp_dir_1024(): tmp_dir = tempfile.mkdtemp() tmp_file, tmp_file_path = tempfile.mkstemp(dir=tmp_dir) - with open(tmp_file, 'wb') as f: - f.write(b'*' * 1024) + with open(tmp_file, "wb") as f: + f.write(b"*" * 1024) return tmp_dir @@ -58,8 +60,8 @@ def temp_dir_1024_delete(): with tempfile.TemporaryDirectory() as tmp_dir: tmp_file, tmp_file_path = tempfile.mkstemp(dir=tmp_dir) - with open(tmp_file, 'wb') as f: - f.write(b'*' * 1024) + with open(tmp_file, "wb") as f: + f.write(b"*" * 1024) yield tmp_dir @@ -68,7 +70,7 @@ def temp_file_1024(): """ Create a temporary file of a particular size (1024 bytes). """ with tempfile.NamedTemporaryFile(delete=False) as tmp_file: - tmp_file.write(b'*' * 1024) + tmp_file.write(b"*" * 1024) return tmp_file.name @@ -81,18 +83,18 @@ def temp_file_1024_delete(): """ with tempfile.NamedTemporaryFile() as tmp_file: - tmp_file.write(b'*' * 1024) + tmp_file.write(b"*" * 1024) tmp_file.flush() yield tmp_file.name # pytest > 2.9 only needs @pytest.fixture -@pytest.yield_fixture(scope='session') +@pytest.yield_fixture(scope="session") def custom_zw(): zw = web.share_mode.ZipWriter( common.Common(), zip_filename=common.Common.random_string(4, 6), - processed_size_callback=lambda _: 'custom_callback' + processed_size_callback=lambda _: "custom_callback", ) yield zw zw.close() @@ -100,7 +102,7 @@ def custom_zw(): # pytest > 2.9 only needs @pytest.fixture -@pytest.yield_fixture(scope='session') +@pytest.yield_fixture(scope="session") def default_zw(): zw = web.share_mode.ZipWriter(common.Common()) yield zw @@ -111,76 +113,77 @@ def default_zw(): @pytest.fixture def locale_en(monkeypatch): - monkeypatch.setattr('locale.getdefaultlocale', lambda: ('en_US', 'UTF-8')) + monkeypatch.setattr("locale.getdefaultlocale", lambda: ("en_US", "UTF-8")) @pytest.fixture def locale_fr(monkeypatch): - monkeypatch.setattr('locale.getdefaultlocale', lambda: ('fr_FR', 'UTF-8')) + monkeypatch.setattr("locale.getdefaultlocale", lambda: ("fr_FR", "UTF-8")) @pytest.fixture def locale_invalid(monkeypatch): - monkeypatch.setattr('locale.getdefaultlocale', lambda: ('xx_XX', 'UTF-8')) + monkeypatch.setattr("locale.getdefaultlocale", lambda: ("xx_XX", "UTF-8")) @pytest.fixture def locale_ru(monkeypatch): - monkeypatch.setattr('locale.getdefaultlocale', lambda: ('ru_RU', 'UTF-8')) + monkeypatch.setattr("locale.getdefaultlocale", lambda: ("ru_RU", "UTF-8")) @pytest.fixture def platform_darwin(monkeypatch): - monkeypatch.setattr('platform.system', lambda: 'Darwin') + monkeypatch.setattr("platform.system", lambda: "Darwin") @pytest.fixture # (scope="session") def platform_linux(monkeypatch): - monkeypatch.setattr('platform.system', lambda: 'Linux') + monkeypatch.setattr("platform.system", lambda: "Linux") @pytest.fixture def platform_windows(monkeypatch): - monkeypatch.setattr('platform.system', lambda: 'Windows') + monkeypatch.setattr("platform.system", lambda: "Windows") @pytest.fixture def sys_argv_sys_prefix(monkeypatch): - monkeypatch.setattr('sys.argv', [sys.prefix]) + monkeypatch.setattr("sys.argv", [sys.prefix]) @pytest.fixture def sys_frozen(monkeypatch): - monkeypatch.setattr('sys.frozen', True, raising=False) + monkeypatch.setattr("sys.frozen", True, raising=False) @pytest.fixture def sys_meipass(monkeypatch): - monkeypatch.setattr( - 'sys._MEIPASS', os.path.expanduser('~'), raising=False) + monkeypatch.setattr("sys._MEIPASS", os.path.expanduser("~"), raising=False) @pytest.fixture # (scope="session") def sys_onionshare_dev_mode(monkeypatch): - monkeypatch.setattr('sys.onionshare_dev_mode', True, raising=False) + monkeypatch.setattr("sys.onionshare_dev_mode", True, raising=False) @pytest.fixture def time_time_100(monkeypatch): - monkeypatch.setattr('time.time', lambda: 100) + monkeypatch.setattr("time.time", lambda: 100) @pytest.fixture def time_strftime(monkeypatch): - monkeypatch.setattr('time.strftime', lambda _: 'Jun 06 2013 11:05:00') + monkeypatch.setattr("time.strftime", lambda _: "Jun 06 2013 11:05:00") + @pytest.fixture def common_obj(): return common.Common() + @pytest.fixture def settings_obj(sys_onionshare_dev_mode, platform_linux): _common = common.Common() - _common.version = 'DUMMY_VERSION_1.2.3' + _common.version = "DUMMY_VERSION_1.2.3" strings.load_strings(_common) return settings.Settings(_common) diff --git a/tests/local_onionshare_404_public_mode_skips_ratelimit_test.py b/tests/local_onionshare_401_public_mode_skips_ratelimit_test.py index 4fad5532..388a424b 100644 --- a/tests/local_onionshare_404_public_mode_skips_ratelimit_test.py +++ b/tests/local_onionshare_401_public_mode_skips_ratelimit_test.py @@ -4,13 +4,11 @@ import unittest from .GuiShareTest import GuiShareTest -class Local404PublicModeRateLimitTest(unittest.TestCase, GuiShareTest): + +class Local401PublicModeRateLimitTest(unittest.TestCase, GuiShareTest): @classmethod def setUpClass(cls): - test_settings = { - "close_after_first_download": False, - "public_mode": True - } + test_settings = {"close_after_first_download": False, "public_mode": True} cls.gui = GuiShareTest.set_up(test_settings) @classmethod @@ -18,11 +16,12 @@ class Local404PublicModeRateLimitTest(unittest.TestCase, GuiShareTest): GuiShareTest.tear_down() @pytest.mark.gui - @pytest.mark.skipif(pytest.__version__ < '2.9', reason="requires newer pytest") + @pytest.mark.skipif(pytest.__version__ < "2.9", reason="requires newer pytest") def test_gui(self): self.run_all_common_setup_tests() self.run_all_share_mode_tests(True, True) - self.hit_404(True) + self.hit_401(True) + if __name__ == "__main__": unittest.main() diff --git a/tests/local_onionshare_404_triggers_ratelimit_test.py b/tests/local_onionshare_401_triggers_ratelimit_test.py index 49be0f5b..cdeb34db 100644 --- a/tests/local_onionshare_404_triggers_ratelimit_test.py +++ b/tests/local_onionshare_401_triggers_ratelimit_test.py @@ -4,12 +4,11 @@ import unittest from .GuiShareTest import GuiShareTest -class Local404RateLimitTest(unittest.TestCase, GuiShareTest): + +class Local401RateLimitTest(unittest.TestCase, GuiShareTest): @classmethod def setUpClass(cls): - test_settings = { - "close_after_first_download": False - } + test_settings = {"close_after_first_download": False} cls.gui = GuiShareTest.set_up(test_settings) @classmethod @@ -17,11 +16,12 @@ class Local404RateLimitTest(unittest.TestCase, GuiShareTest): GuiShareTest.tear_down() @pytest.mark.gui - @pytest.mark.skipif(pytest.__version__ < '2.9', reason="requires newer pytest") + @pytest.mark.skipif(pytest.__version__ < "2.9", reason="requires newer pytest") def test_gui(self): self.run_all_common_setup_tests() self.run_all_share_mode_tests(False, True) - self.hit_404(False) + self.hit_401(False) + if __name__ == "__main__": unittest.main() diff --git a/tests/local_onionshare_quitting_during_share_prompts_warning_test.py b/tests/local_onionshare_quitting_during_share_prompts_warning_test.py index e43c88ba..9a38e24a 100644 --- a/tests/local_onionshare_quitting_during_share_prompts_warning_test.py +++ b/tests/local_onionshare_quitting_during_share_prompts_warning_test.py @@ -5,12 +5,11 @@ from PyQt5 import QtCore, QtTest from .GuiShareTest import GuiShareTest + class LocalQuittingDuringSharePromptsWarningTest(unittest.TestCase, GuiShareTest): @classmethod def setUpClass(cls): - test_settings = { - "close_after_first_download": False - } + test_settings = {"close_after_first_download": False} cls.gui = GuiShareTest.set_up(test_settings) @classmethod @@ -18,7 +17,7 @@ class LocalQuittingDuringSharePromptsWarningTest(unittest.TestCase, GuiShareTest GuiShareTest.tear_down() @pytest.mark.gui - @pytest.mark.skipif(pytest.__version__ < '2.9', reason="requires newer pytest") + @pytest.mark.skipif(pytest.__version__ < "2.9", reason="requires newer pytest") def test_gui(self): self.run_all_common_setup_tests() self.run_all_share_mode_tests(False, True) @@ -30,5 +29,6 @@ class LocalQuittingDuringSharePromptsWarningTest(unittest.TestCase, GuiShareTest self.server_is_started(self.gui.share_mode, 0) self.web_server_is_running() + if __name__ == "__main__": unittest.main() diff --git a/tests/local_onionshare_receive_mode_clear_all_button_test.py b/tests/local_onionshare_receive_mode_clear_all_button_test.py new file mode 100644 index 00000000..d69c3e59 --- /dev/null +++ b/tests/local_onionshare_receive_mode_clear_all_button_test.py @@ -0,0 +1,26 @@ +#!/usr/bin/env python3 +import pytest +import unittest + +from .GuiReceiveTest import GuiReceiveTest + + +class LocalReceiveModeClearAllButtonTest(unittest.TestCase, GuiReceiveTest): + @classmethod + def setUpClass(cls): + test_settings = {} + cls.gui = GuiReceiveTest.set_up(test_settings) + + @classmethod + def tearDownClass(cls): + GuiReceiveTest.tear_down() + + @pytest.mark.gui + @pytest.mark.skipif(pytest.__version__ < "2.9", reason="requires newer pytest") + def test_gui(self): + self.run_all_common_setup_tests() + self.run_all_clear_all_button_tests(False) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/local_onionshare_receive_mode_timer_test.py b/tests/local_onionshare_receive_mode_timer_test.py index 4cde86c1..f958a132 100644 --- a/tests/local_onionshare_receive_mode_timer_test.py +++ b/tests/local_onionshare_receive_mode_timer_test.py @@ -4,13 +4,11 @@ import unittest from .GuiReceiveTest import GuiReceiveTest + class LocalReceiveModeTimerTest(unittest.TestCase, GuiReceiveTest): @classmethod def setUpClass(cls): - test_settings = { - "public_mode": False, - "autostop_timer": True, - } + test_settings = {"public_mode": False, "autostop_timer": True} cls.gui = GuiReceiveTest.set_up(test_settings) @classmethod @@ -18,10 +16,11 @@ class LocalReceiveModeTimerTest(unittest.TestCase, GuiReceiveTest): GuiReceiveTest.tear_down() @pytest.mark.gui - @pytest.mark.skipif(pytest.__version__ < '2.9', reason="requires newer pytest") + @pytest.mark.skipif(pytest.__version__ < "2.9", reason="requires newer pytest") def test_gui(self): self.run_all_common_setup_tests() self.run_all_receive_mode_timer_tests(False) + if __name__ == "__main__": unittest.main() diff --git a/tests/local_onionshare_receive_mode_upload_non_writable_dir_test.py b/tests/local_onionshare_receive_mode_upload_non_writable_dir_test.py index 5737bae3..f1451ba0 100644 --- a/tests/local_onionshare_receive_mode_upload_non_writable_dir_test.py +++ b/tests/local_onionshare_receive_mode_upload_non_writable_dir_test.py @@ -4,12 +4,11 @@ import unittest from .GuiReceiveTest import GuiReceiveTest + class LocalReceiveModeUnwritableTest(unittest.TestCase, GuiReceiveTest): @classmethod def setUpClass(cls): - test_settings = { - "receive_allow_receiver_shutdown": True - } + test_settings = {"receive_allow_receiver_shutdown": True} cls.gui = GuiReceiveTest.set_up(test_settings) @classmethod @@ -17,10 +16,11 @@ class LocalReceiveModeUnwritableTest(unittest.TestCase, GuiReceiveTest): GuiReceiveTest.tear_down() @pytest.mark.gui - @pytest.mark.skipif(pytest.__version__ < '2.9', reason="requires newer pytest") + @pytest.mark.skipif(pytest.__version__ < "2.9", reason="requires newer pytest") def test_gui(self): self.run_all_common_setup_tests() - self.run_all_receive_mode_unwritable_dir_tests(False, True) + self.run_all_receive_mode_unwritable_dir_tests(False) + if __name__ == "__main__": unittest.main() diff --git a/tests/local_onionshare_receive_mode_upload_public_mode_non_writable_dir_test.py b/tests/local_onionshare_receive_mode_upload_public_mode_non_writable_dir_test.py index e6024352..6f0997f2 100644 --- a/tests/local_onionshare_receive_mode_upload_public_mode_non_writable_dir_test.py +++ b/tests/local_onionshare_receive_mode_upload_public_mode_non_writable_dir_test.py @@ -4,13 +4,11 @@ import unittest from .GuiReceiveTest import GuiReceiveTest + class LocalReceivePublicModeUnwritableTest(unittest.TestCase, GuiReceiveTest): @classmethod def setUpClass(cls): - test_settings = { - "public_mode": True, - "receive_allow_receiver_shutdown": True - } + test_settings = {"public_mode": True, "receive_allow_receiver_shutdown": True} cls.gui = GuiReceiveTest.set_up(test_settings) @classmethod @@ -18,10 +16,11 @@ class LocalReceivePublicModeUnwritableTest(unittest.TestCase, GuiReceiveTest): GuiReceiveTest.tear_down() @pytest.mark.gui - @pytest.mark.skipif(pytest.__version__ < '2.9', reason="requires newer pytest") + @pytest.mark.skipif(pytest.__version__ < "2.9", reason="requires newer pytest") def test_gui(self): self.run_all_common_setup_tests() - self.run_all_receive_mode_unwritable_dir_tests(True, True) + self.run_all_receive_mode_unwritable_dir_tests(True) + if __name__ == "__main__": unittest.main() diff --git a/tests/local_onionshare_receive_mode_upload_public_mode_test.py b/tests/local_onionshare_receive_mode_upload_public_mode_test.py index 885ae4fe..818bd593 100644 --- a/tests/local_onionshare_receive_mode_upload_public_mode_test.py +++ b/tests/local_onionshare_receive_mode_upload_public_mode_test.py @@ -4,13 +4,11 @@ import unittest from .GuiReceiveTest import GuiReceiveTest + class LocalReceiveModePublicModeTest(unittest.TestCase, GuiReceiveTest): @classmethod def setUpClass(cls): - test_settings = { - "public_mode": True, - "receive_allow_receiver_shutdown": True - } + test_settings = {"public_mode": True, "receive_allow_receiver_shutdown": True} cls.gui = GuiReceiveTest.set_up(test_settings) @classmethod @@ -18,10 +16,11 @@ class LocalReceiveModePublicModeTest(unittest.TestCase, GuiReceiveTest): GuiReceiveTest.tear_down() @pytest.mark.gui - @pytest.mark.skipif(pytest.__version__ < '2.9', reason="requires newer pytest") + @pytest.mark.skipif(pytest.__version__ < "2.9", reason="requires newer pytest") def test_gui(self): self.run_all_common_setup_tests() - self.run_all_receive_mode_tests(True, True) + self.run_all_receive_mode_tests(True) + if __name__ == "__main__": unittest.main() diff --git a/tests/local_onionshare_receive_mode_upload_test.py b/tests/local_onionshare_receive_mode_upload_test.py index 3d23730c..38888655 100644 --- a/tests/local_onionshare_receive_mode_upload_test.py +++ b/tests/local_onionshare_receive_mode_upload_test.py @@ -4,12 +4,11 @@ import unittest from .GuiReceiveTest import GuiReceiveTest + class LocalReceiveModeTest(unittest.TestCase, GuiReceiveTest): @classmethod def setUpClass(cls): - test_settings = { - "receive_allow_receiver_shutdown": True - } + test_settings = {"receive_allow_receiver_shutdown": True} cls.gui = GuiReceiveTest.set_up(test_settings) @classmethod @@ -17,10 +16,11 @@ class LocalReceiveModeTest(unittest.TestCase, GuiReceiveTest): GuiReceiveTest.tear_down() @pytest.mark.gui - @pytest.mark.skipif(pytest.__version__ < '2.9', reason="requires newer pytest") + @pytest.mark.skipif(pytest.__version__ < "2.9", reason="requires newer pytest") def test_gui(self): self.run_all_common_setup_tests() - self.run_all_receive_mode_tests(False, True) + self.run_all_receive_mode_tests(False) + if __name__ == "__main__": unittest.main() diff --git a/tests/local_onionshare_settings_dialog_legacy_tor_test.py b/tests/local_onionshare_settings_dialog_legacy_tor_test.py index 54653c1b..72d33241 100644 --- a/tests/local_onionshare_settings_dialog_legacy_tor_test.py +++ b/tests/local_onionshare_settings_dialog_legacy_tor_test.py @@ -16,7 +16,7 @@ class SettingsGuiTest(unittest.TestCase, SettingsGuiBaseTest): SettingsGuiBaseTest.tear_down() @pytest.mark.gui - @pytest.mark.skipif(pytest.__version__ < '2.9', reason="requires newer pytest") + @pytest.mark.skipif(pytest.__version__ < "2.9", reason="requires newer pytest") def test_gui_legacy_tor(self): self.gui.onion = OnionStub(True, False) self.gui.reload_settings() diff --git a/tests/local_onionshare_settings_dialog_no_tor_test.py b/tests/local_onionshare_settings_dialog_no_tor_test.py index 06e3cc9e..b8c06243 100644 --- a/tests/local_onionshare_settings_dialog_no_tor_test.py +++ b/tests/local_onionshare_settings_dialog_no_tor_test.py @@ -16,7 +16,7 @@ class SettingsGuiTest(unittest.TestCase, SettingsGuiBaseTest): SettingsGuiBaseTest.tear_down() @pytest.mark.gui - @pytest.mark.skipif(pytest.__version__ < '2.9', reason="requires newer pytest") + @pytest.mark.skipif(pytest.__version__ < "2.9", reason="requires newer pytest") def test_gui_no_tor(self): self.gui.onion = OnionStub(False, False) self.gui.reload_settings() diff --git a/tests/local_onionshare_settings_dialog_v3_tor_test.py b/tests/local_onionshare_settings_dialog_v3_tor_test.py index 88a0438e..d5abeabc 100644 --- a/tests/local_onionshare_settings_dialog_v3_tor_test.py +++ b/tests/local_onionshare_settings_dialog_v3_tor_test.py @@ -16,7 +16,7 @@ class SettingsGuiTest(unittest.TestCase, SettingsGuiBaseTest): SettingsGuiBaseTest.tear_down() @pytest.mark.gui - @pytest.mark.skipif(pytest.__version__ < '2.9', reason="requires newer pytest") + @pytest.mark.skipif(pytest.__version__ < "2.9", reason="requires newer pytest") def test_gui_v3_tor(self): self.gui.onion = OnionStub(True, True) self.gui.reload_settings() diff --git a/tests/local_onionshare_share_mode_autostart_and_autostop_timer_mismatch_test.py b/tests/local_onionshare_share_mode_autostart_and_autostop_timer_mismatch_test.py index 0bb3bfa3..2a25bef1 100644 --- a/tests/local_onionshare_share_mode_autostart_and_autostop_timer_mismatch_test.py +++ b/tests/local_onionshare_share_mode_autostart_and_autostop_timer_mismatch_test.py @@ -4,6 +4,7 @@ import unittest from .GuiShareTest import GuiShareTest + class LocalShareModeAutoStartTimerTest(unittest.TestCase, GuiShareTest): @classmethod def setUpClass(cls): @@ -19,10 +20,11 @@ class LocalShareModeAutoStartTimerTest(unittest.TestCase, GuiShareTest): GuiShareTest.tear_down() @pytest.mark.gui - @pytest.mark.skipif(pytest.__version__ < '2.9', reason="requires newer pytest") + @pytest.mark.skipif(pytest.__version__ < "2.9", reason="requires newer pytest") def test_gui(self): self.run_all_common_setup_tests() self.run_all_share_mode_autostop_autostart_mismatch_tests(False) + if __name__ == "__main__": unittest.main() diff --git a/tests/local_onionshare_share_mode_autostart_timer_test.py b/tests/local_onionshare_share_mode_autostart_timer_test.py index 4fd5f649..776cff4f 100644 --- a/tests/local_onionshare_share_mode_autostart_timer_test.py +++ b/tests/local_onionshare_share_mode_autostart_timer_test.py @@ -4,13 +4,11 @@ import unittest from .GuiShareTest import GuiShareTest + class LocalShareModeAutoStartTimerTest(unittest.TestCase, GuiShareTest): @classmethod def setUpClass(cls): - test_settings = { - "public_mode": False, - "autostart_timer": True, - } + test_settings = {"public_mode": False, "autostart_timer": True} cls.gui = GuiShareTest.set_up(test_settings) @classmethod @@ -18,10 +16,11 @@ class LocalShareModeAutoStartTimerTest(unittest.TestCase, GuiShareTest): GuiShareTest.tear_down() @pytest.mark.gui - @pytest.mark.skipif(pytest.__version__ < '2.9', reason="requires newer pytest") + @pytest.mark.skipif(pytest.__version__ < "2.9", reason="requires newer pytest") def test_gui(self): self.run_all_common_setup_tests() self.run_all_share_mode_autostart_timer_tests(False) + if __name__ == "__main__": unittest.main() diff --git a/tests/local_onionshare_share_mode_autostart_timer_too_short_test.py b/tests/local_onionshare_share_mode_autostart_timer_too_short_test.py index d8e82aed..1c2040df 100644 --- a/tests/local_onionshare_share_mode_autostart_timer_too_short_test.py +++ b/tests/local_onionshare_share_mode_autostart_timer_too_short_test.py @@ -5,13 +5,11 @@ from PyQt5 import QtCore, QtTest from .GuiShareTest import GuiShareTest + class LocalShareModeAutoStartTimerTooShortTest(unittest.TestCase, GuiShareTest): @classmethod def setUpClass(cls): - test_settings = { - "public_mode": False, - "autostart_timer": True, - } + test_settings = {"public_mode": False, "autostart_timer": True} cls.gui = GuiShareTest.set_up(test_settings) @classmethod @@ -19,7 +17,7 @@ class LocalShareModeAutoStartTimerTooShortTest(unittest.TestCase, GuiShareTest): GuiShareTest.tear_down() @pytest.mark.gui - @pytest.mark.skipif(pytest.__version__ < '2.9', reason="requires newer pytest") + @pytest.mark.skipif(pytest.__version__ < "2.9", reason="requires newer pytest") def test_gui(self): self.run_all_common_setup_tests() self.run_all_share_mode_setup_tests() @@ -27,8 +25,11 @@ class LocalShareModeAutoStartTimerTooShortTest(unittest.TestCase, GuiShareTest): self.set_autostart_timer(self.gui.share_mode, 2) QtTest.QTest.qWait(3000) QtCore.QTimer.singleShot(4000, self.accept_dialog) - QtTest.QTest.mouseClick(self.gui.share_mode.server_status.server_button, QtCore.Qt.LeftButton) + QtTest.QTest.mouseClick( + self.gui.share_mode.server_status.server_button, QtCore.Qt.LeftButton + ) self.assertEqual(self.gui.share_mode.server_status.status, 0) + if __name__ == "__main__": unittest.main() diff --git a/tests/local_onionshare_share_mode_cancel_share_test.py b/tests/local_onionshare_share_mode_cancel_share_test.py index 5b526999..d6ee051b 100644 --- a/tests/local_onionshare_share_mode_cancel_share_test.py +++ b/tests/local_onionshare_share_mode_cancel_share_test.py @@ -4,12 +4,11 @@ import unittest from .GuiShareTest import GuiShareTest + class LocalShareModeCancelTest(unittest.TestCase, GuiShareTest): @classmethod def setUpClass(cls): - test_settings = { - "autostart_timer": True, - } + test_settings = {"autostart_timer": True} cls.gui = GuiShareTest.set_up(test_settings) @classmethod @@ -17,11 +16,12 @@ class LocalShareModeCancelTest(unittest.TestCase, GuiShareTest): GuiShareTest.tear_down() @pytest.mark.gui - @pytest.mark.skipif(pytest.__version__ < '2.9', reason="requires newer pytest") + @pytest.mark.skipif(pytest.__version__ < "2.9", reason="requires newer pytest") def test_gui(self): self.run_all_common_setup_tests() self.run_all_share_mode_setup_tests() self.cancel_the_share(self.gui.share_mode) + if __name__ == "__main__": unittest.main() diff --git a/tests/local_onionshare_share_mode_clear_all_button_test.py b/tests/local_onionshare_share_mode_clear_all_button_test.py new file mode 100644 index 00000000..1c11fe81 --- /dev/null +++ b/tests/local_onionshare_share_mode_clear_all_button_test.py @@ -0,0 +1,26 @@ +#!/usr/bin/env python3 +import pytest +import unittest + +from .GuiShareTest import GuiShareTest + + +class LocalShareModeClearAllButtonTest(unittest.TestCase, GuiShareTest): + @classmethod + def setUpClass(cls): + test_settings = {"close_after_first_download": False} + cls.gui = GuiShareTest.set_up(test_settings) + + @classmethod + def tearDownClass(cls): + GuiShareTest.tear_down() + + @pytest.mark.gui + @pytest.mark.skipif(pytest.__version__ < "2.9", reason="requires newer pytest") + def test_gui(self): + self.run_all_common_setup_tests() + self.run_all_clear_all_button_tests(False, True) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/local_onionshare_share_mode_download_public_mode_test.py b/tests/local_onionshare_share_mode_download_public_mode_test.py index b7ff336c..6661eae7 100644 --- a/tests/local_onionshare_share_mode_download_public_mode_test.py +++ b/tests/local_onionshare_share_mode_download_public_mode_test.py @@ -4,12 +4,11 @@ import unittest from .GuiShareTest import GuiShareTest + class LocalShareModePublicModeTest(unittest.TestCase, GuiShareTest): @classmethod def setUpClass(cls): - test_settings = { - "public_mode": True, - } + test_settings = {"public_mode": True} cls.gui = GuiShareTest.set_up(test_settings) @classmethod @@ -17,10 +16,11 @@ class LocalShareModePublicModeTest(unittest.TestCase, GuiShareTest): GuiShareTest.tear_down() @pytest.mark.gui - @pytest.mark.skipif(pytest.__version__ < '2.9', reason="requires newer pytest") + @pytest.mark.skipif(pytest.__version__ < "2.9", reason="requires newer pytest") def test_gui(self): self.run_all_common_setup_tests() self.run_all_share_mode_tests(True, False) + if __name__ == "__main__": unittest.main() diff --git a/tests/local_onionshare_share_mode_download_stay_open_test.py b/tests/local_onionshare_share_mode_download_stay_open_test.py index 50d82326..04213865 100644 --- a/tests/local_onionshare_share_mode_download_stay_open_test.py +++ b/tests/local_onionshare_share_mode_download_stay_open_test.py @@ -4,12 +4,11 @@ import unittest from .GuiShareTest import GuiShareTest + class LocalShareModeStayOpenTest(unittest.TestCase, GuiShareTest): @classmethod def setUpClass(cls): - test_settings = { - "close_after_first_download": False, - } + test_settings = {"close_after_first_download": False} cls.gui = GuiShareTest.set_up(test_settings) @classmethod @@ -17,10 +16,11 @@ class LocalShareModeStayOpenTest(unittest.TestCase, GuiShareTest): GuiShareTest.tear_down() @pytest.mark.gui - @pytest.mark.skipif(pytest.__version__ < '2.9', reason="requires newer pytest") + @pytest.mark.skipif(pytest.__version__ < "2.9", reason="requires newer pytest") def test_gui(self): self.run_all_common_setup_tests() self.run_all_share_mode_tests(False, True) + if __name__ == "__main__": unittest.main() diff --git a/tests/local_onionshare_share_mode_download_test.py b/tests/local_onionshare_share_mode_download_test.py index 387d63c1..1c0b69e9 100644 --- a/tests/local_onionshare_share_mode_download_test.py +++ b/tests/local_onionshare_share_mode_download_test.py @@ -4,11 +4,11 @@ import unittest from .GuiShareTest import GuiShareTest + class LocalShareModeTest(unittest.TestCase, GuiShareTest): @classmethod def setUpClass(cls): - test_settings = { - } + test_settings = {} cls.gui = GuiShareTest.set_up(test_settings) @classmethod @@ -16,10 +16,11 @@ class LocalShareModeTest(unittest.TestCase, GuiShareTest): GuiShareTest.tear_down() @pytest.mark.gui - @pytest.mark.skipif(pytest.__version__ < '2.9', reason="requires newer pytest") + @pytest.mark.skipif(pytest.__version__ < "2.9", reason="requires newer pytest") def test_gui(self): self.run_all_common_setup_tests() self.run_all_share_mode_tests(False, False) + if __name__ == "__main__": unittest.main() diff --git a/tests/local_onionshare_share_mode_individual_file_view_stay_open_test.py b/tests/local_onionshare_share_mode_individual_file_view_stay_open_test.py new file mode 100644 index 00000000..18b3283a --- /dev/null +++ b/tests/local_onionshare_share_mode_individual_file_view_stay_open_test.py @@ -0,0 +1,26 @@ +#!/usr/bin/env python3 +import pytest +import unittest + +from .GuiShareTest import GuiShareTest + + +class LocalShareModeIndividualFileViewStayOpenTest(unittest.TestCase, GuiShareTest): + @classmethod + def setUpClass(cls): + test_settings = {"close_after_first_download": False} + cls.gui = GuiShareTest.set_up(test_settings) + + @classmethod + def tearDownClass(cls): + GuiShareTest.tear_down() + + @pytest.mark.gui + @pytest.mark.skipif(pytest.__version__ < "2.9", reason="requires newer pytest") + def test_gui(self): + self.run_all_common_setup_tests() + self.run_all_share_mode_individual_file_tests(False, True) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/local_onionshare_share_mode_individual_file_view_test.py b/tests/local_onionshare_share_mode_individual_file_view_test.py new file mode 100644 index 00000000..d41b2010 --- /dev/null +++ b/tests/local_onionshare_share_mode_individual_file_view_test.py @@ -0,0 +1,26 @@ +#!/usr/bin/env python3 +import pytest +import unittest + +from .GuiShareTest import GuiShareTest + + +class LocalShareModeIndividualFileViewTest(unittest.TestCase, GuiShareTest): + @classmethod + def setUpClass(cls): + test_settings = {"close_after_first_download": True} + cls.gui = GuiShareTest.set_up(test_settings) + + @classmethod + def tearDownClass(cls): + GuiShareTest.tear_down() + + @pytest.mark.gui + @pytest.mark.skipif(pytest.__version__ < "2.9", reason="requires newer pytest") + def test_gui(self): + self.run_all_common_setup_tests() + self.run_all_share_mode_individual_file_tests(False, False) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/local_onionshare_share_mode_large_download_test.py b/tests/local_onionshare_share_mode_large_download_test.py index 5717a2d8..a0458d03 100644 --- a/tests/local_onionshare_share_mode_large_download_test.py +++ b/tests/local_onionshare_share_mode_large_download_test.py @@ -4,11 +4,11 @@ import unittest from .GuiShareTest import GuiShareTest + class LocalShareModeLargeDownloadTest(unittest.TestCase, GuiShareTest): @classmethod def setUpClass(cls): - test_settings = { - } + test_settings = {} cls.gui = GuiShareTest.set_up(test_settings) @classmethod @@ -16,10 +16,11 @@ class LocalShareModeLargeDownloadTest(unittest.TestCase, GuiShareTest): GuiShareTest.tear_down() @pytest.mark.gui - @pytest.mark.skipif(pytest.__version__ < '2.9', reason="requires newer pytest") + @pytest.mark.skipif(pytest.__version__ < "2.9", reason="requires newer pytest") def test_gui(self): self.run_all_common_setup_tests() self.run_all_large_file_tests(False, True) + if __name__ == "__main__": unittest.main() diff --git a/tests/local_onionshare_share_mode_slug_persistent_test.py b/tests/local_onionshare_share_mode_password_persistent_test.py index 58e1cfeb..067815f7 100644 --- a/tests/local_onionshare_share_mode_slug_persistent_test.py +++ b/tests/local_onionshare_share_mode_password_persistent_test.py @@ -4,12 +4,13 @@ import unittest from .GuiShareTest import GuiShareTest -class LocalShareModePersistentSlugTest(unittest.TestCase, GuiShareTest): + +class LocalShareModePersistentPasswordTest(unittest.TestCase, GuiShareTest): @classmethod def setUpClass(cls): test_settings = { "public_mode": False, - "slug": "", + "password": "", "save_private_key": True, "close_after_first_download": False, } @@ -20,10 +21,11 @@ class LocalShareModePersistentSlugTest(unittest.TestCase, GuiShareTest): GuiShareTest.tear_down() @pytest.mark.gui - @pytest.mark.skipif(pytest.__version__ < '2.9', reason="requires newer pytest") + @pytest.mark.skipif(pytest.__version__ < "2.9", reason="requires newer pytest") def test_gui(self): self.run_all_common_setup_tests() self.run_all_share_mode_persistent_tests(False, True) + if __name__ == "__main__": unittest.main() diff --git a/tests/local_onionshare_share_mode_timer_test.py b/tests/local_onionshare_share_mode_timer_test.py index 0526be08..da200f97 100644 --- a/tests/local_onionshare_share_mode_timer_test.py +++ b/tests/local_onionshare_share_mode_timer_test.py @@ -4,13 +4,11 @@ import unittest from .GuiShareTest import GuiShareTest + class LocalShareModeTimerTest(unittest.TestCase, GuiShareTest): @classmethod def setUpClass(cls): - test_settings = { - "public_mode": False, - "autostop_timer": True, - } + test_settings = {"public_mode": False, "autostop_timer": True} cls.gui = GuiShareTest.set_up(test_settings) @classmethod @@ -18,10 +16,11 @@ class LocalShareModeTimerTest(unittest.TestCase, GuiShareTest): GuiShareTest.tear_down() @pytest.mark.gui - @pytest.mark.skipif(pytest.__version__ < '2.9', reason="requires newer pytest") + @pytest.mark.skipif(pytest.__version__ < "2.9", reason="requires newer pytest") def test_gui(self): self.run_all_common_setup_tests() self.run_all_share_mode_timer_tests(False) + if __name__ == "__main__": unittest.main() diff --git a/tests/local_onionshare_share_mode_timer_too_short_test.py b/tests/local_onionshare_share_mode_timer_too_short_test.py index 09b82af3..63c2fdc2 100644 --- a/tests/local_onionshare_share_mode_timer_too_short_test.py +++ b/tests/local_onionshare_share_mode_timer_too_short_test.py @@ -5,13 +5,11 @@ from PyQt5 import QtCore, QtTest from .GuiShareTest import GuiShareTest + class LocalShareModeTimerTooShortTest(unittest.TestCase, GuiShareTest): @classmethod def setUpClass(cls): - test_settings = { - "public_mode": False, - "autostop_timer": True, - } + test_settings = {"public_mode": False, "autostop_timer": True} cls.gui = GuiShareTest.set_up(test_settings) @classmethod @@ -19,7 +17,7 @@ class LocalShareModeTimerTooShortTest(unittest.TestCase, GuiShareTest): GuiShareTest.tear_down() @pytest.mark.gui - @pytest.mark.skipif(pytest.__version__ < '2.9', reason="requires newer pytest") + @pytest.mark.skipif(pytest.__version__ < "2.9", reason="requires newer pytest") def test_gui(self): self.run_all_common_setup_tests() self.run_all_share_mode_setup_tests() @@ -27,8 +25,11 @@ class LocalShareModeTimerTooShortTest(unittest.TestCase, GuiShareTest): self.set_timeout(self.gui.share_mode, 2) QtTest.QTest.qWait(3000) QtCore.QTimer.singleShot(4000, self.accept_dialog) - QtTest.QTest.mouseClick(self.gui.share_mode.server_status.server_button, QtCore.Qt.LeftButton) + QtTest.QTest.mouseClick( + self.gui.share_mode.server_status.server_button, QtCore.Qt.LeftButton + ) self.assertEqual(self.gui.share_mode.server_status.status, 0) + if __name__ == "__main__": unittest.main() diff --git a/tests/local_onionshare_share_mode_unreadable_file_test.py b/tests/local_onionshare_share_mode_unreadable_file_test.py index 8b5dd4e7..80f0fdb8 100644 --- a/tests/local_onionshare_share_mode_unreadable_file_test.py +++ b/tests/local_onionshare_share_mode_unreadable_file_test.py @@ -4,11 +4,11 @@ import unittest from .GuiShareTest import GuiShareTest + class LocalShareModeUnReadableFileTest(unittest.TestCase, GuiShareTest): @classmethod def setUpClass(cls): - test_settings = { - } + test_settings = {} cls.gui = GuiShareTest.set_up(test_settings) @classmethod @@ -16,10 +16,11 @@ class LocalShareModeUnReadableFileTest(unittest.TestCase, GuiShareTest): GuiShareTest.tear_down() @pytest.mark.gui - @pytest.mark.skipif(pytest.__version__ < '2.9', reason="requires newer pytest") + @pytest.mark.skipif(pytest.__version__ < "2.9", reason="requires newer pytest") def test_gui(self): self.run_all_common_setup_tests() self.run_all_share_mode_unreadable_file_tests() + if __name__ == "__main__": unittest.main() diff --git a/tests/local_onionshare_website_mode_csp_enabled_test.py b/tests/local_onionshare_website_mode_csp_enabled_test.py new file mode 100644 index 00000000..f9fdb983 --- /dev/null +++ b/tests/local_onionshare_website_mode_csp_enabled_test.py @@ -0,0 +1,26 @@ +#!/usr/bin/env python3 +import pytest +import unittest + +from .GuiWebsiteTest import GuiWebsiteTest + + +class LocalWebsiteModeCSPEnabledTest(unittest.TestCase, GuiWebsiteTest): + @classmethod + def setUpClass(cls): + test_settings = {"csp_header_disabled": False} + cls.gui = GuiWebsiteTest.set_up(test_settings) + + @classmethod + def tearDownClass(cls): + GuiWebsiteTest.tear_down() + + @pytest.mark.gui + @pytest.mark.skipif(pytest.__version__ < "2.9", reason="requires newer pytest") + def test_gui(self): + # self.run_all_common_setup_tests() + self.run_all_website_mode_download_tests(False) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/local_onionshare_website_mode_test.py b/tests/local_onionshare_website_mode_test.py new file mode 100644 index 00000000..ba00e780 --- /dev/null +++ b/tests/local_onionshare_website_mode_test.py @@ -0,0 +1,26 @@ +#!/usr/bin/env python3 +import pytest +import unittest + +from .GuiWebsiteTest import GuiWebsiteTest + + +class LocalWebsiteModeTest(unittest.TestCase, GuiWebsiteTest): + @classmethod + def setUpClass(cls): + test_settings = {"csp_header_disabled": True} + cls.gui = GuiWebsiteTest.set_up(test_settings) + + @classmethod + def tearDownClass(cls): + GuiWebsiteTest.tear_down() + + @pytest.mark.gui + @pytest.mark.skipif(pytest.__version__ < "2.9", reason="requires newer pytest") + def test_gui(self): + # self.run_all_common_setup_tests() + self.run_all_website_mode_download_tests(False) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/onionshare_790_cancel_on_second_share_test.py b/tests/onionshare_790_cancel_on_second_share_test.py index f970b8af..7a87c690 100644 --- a/tests/onionshare_790_cancel_on_second_share_test.py +++ b/tests/onionshare_790_cancel_on_second_share_test.py @@ -8,9 +8,7 @@ from .TorGuiShareTest import TorGuiShareTest class ShareModeCancelSecondShareTest(unittest.TestCase, TorGuiShareTest): @classmethod def setUpClass(cls): - test_settings = { - "close_after_first_download": True - } + test_settings = {"close_after_first_download": True} cls.gui = TorGuiShareTest.set_up(test_settings) @classmethod @@ -19,7 +17,7 @@ class ShareModeCancelSecondShareTest(unittest.TestCase, TorGuiShareTest): @pytest.mark.gui @pytest.mark.tor - @pytest.mark.skipif(pytest.__version__ < '2.9', reason="requires newer pytest") + @pytest.mark.skipif(pytest.__version__ < "2.9", reason="requires newer pytest") def test_gui(self): self.run_all_common_setup_tests() self.run_all_share_mode_tests(False, False) @@ -27,5 +25,6 @@ class ShareModeCancelSecondShareTest(unittest.TestCase, TorGuiShareTest): self.server_is_stopped(self.gui.share_mode, False) self.web_server_is_stopped() + if __name__ == "__main__": unittest.main() diff --git a/tests/onionshare_receive_mode_upload_public_mode_test.py b/tests/onionshare_receive_mode_upload_public_mode_test.py index c2611ad5..31b1a8f6 100644 --- a/tests/onionshare_receive_mode_upload_public_mode_test.py +++ b/tests/onionshare_receive_mode_upload_public_mode_test.py @@ -4,13 +4,11 @@ import unittest from .TorGuiReceiveTest import TorGuiReceiveTest + class ReceiveModeTest(unittest.TestCase, TorGuiReceiveTest): @classmethod def setUpClass(cls): - test_settings = { - "public_mode": True, - "receive_allow_receiver_shutdown": True - } + test_settings = {"public_mode": True, "receive_allow_receiver_shutdown": True} cls.gui = TorGuiReceiveTest.set_up(test_settings) @classmethod @@ -19,10 +17,11 @@ class ReceiveModeTest(unittest.TestCase, TorGuiReceiveTest): @pytest.mark.gui @pytest.mark.tor - @pytest.mark.skipif(pytest.__version__ < '2.9', reason="requires newer pytest") + @pytest.mark.skipif(pytest.__version__ < "2.9", reason="requires newer pytest") def test_gui(self): self.run_all_common_setup_tests() self.run_all_receive_mode_tests(True, True) + if __name__ == "__main__": unittest.main() diff --git a/tests/onionshare_receive_mode_upload_test.py b/tests/onionshare_receive_mode_upload_test.py index a1935562..ca695843 100644 --- a/tests/onionshare_receive_mode_upload_test.py +++ b/tests/onionshare_receive_mode_upload_test.py @@ -4,12 +4,11 @@ import unittest from .TorGuiReceiveTest import TorGuiReceiveTest + class ReceiveModeTest(unittest.TestCase, TorGuiReceiveTest): @classmethod def setUpClass(cls): - test_settings = { - "receive_allow_receiver_shutdown": True - } + test_settings = {"receive_allow_receiver_shutdown": True} cls.gui = TorGuiReceiveTest.set_up(test_settings) @classmethod @@ -18,10 +17,11 @@ class ReceiveModeTest(unittest.TestCase, TorGuiReceiveTest): @pytest.mark.gui @pytest.mark.tor - @pytest.mark.skipif(pytest.__version__ < '2.9', reason="requires newer pytest") + @pytest.mark.skipif(pytest.__version__ < "2.9", reason="requires newer pytest") def test_gui(self): self.run_all_common_setup_tests() self.run_all_receive_mode_tests(False, True) + if __name__ == "__main__": unittest.main() diff --git a/tests/onionshare_share_mode_cancel_share_test.py b/tests/onionshare_share_mode_cancel_share_test.py index 2a248bae..0483fbe1 100644 --- a/tests/onionshare_share_mode_cancel_share_test.py +++ b/tests/onionshare_share_mode_cancel_share_test.py @@ -4,12 +4,11 @@ import unittest from .TorGuiShareTest import TorGuiShareTest + class ShareModeCancelTest(unittest.TestCase, TorGuiShareTest): @classmethod def setUpClass(cls): - test_settings = { - "autostart_timer": True, - } + test_settings = {"autostart_timer": True} cls.gui = TorGuiShareTest.set_up(test_settings) @classmethod @@ -18,11 +17,12 @@ class ShareModeCancelTest(unittest.TestCase, TorGuiShareTest): @pytest.mark.gui @pytest.mark.tor - @pytest.mark.skipif(pytest.__version__ < '2.9', reason="requires newer pytest") + @pytest.mark.skipif(pytest.__version__ < "2.9", reason="requires newer pytest") def test_gui(self): self.run_all_common_setup_tests() self.run_all_share_mode_setup_tests() self.cancel_the_share(self.gui.share_mode) + if __name__ == "__main__": unittest.main() diff --git a/tests/onionshare_share_mode_download_public_mode_test.py b/tests/onionshare_share_mode_download_public_mode_test.py index 93c23978..72554f8b 100644 --- a/tests/onionshare_share_mode_download_public_mode_test.py +++ b/tests/onionshare_share_mode_download_public_mode_test.py @@ -4,12 +4,11 @@ import unittest from .TorGuiShareTest import TorGuiShareTest + class ShareModePublicModeTest(unittest.TestCase, TorGuiShareTest): @classmethod def setUpClass(cls): - test_settings = { - "public_mode": True, - } + test_settings = {"public_mode": True} cls.gui = TorGuiShareTest.set_up(test_settings) @classmethod @@ -18,10 +17,11 @@ class ShareModePublicModeTest(unittest.TestCase, TorGuiShareTest): @pytest.mark.gui @pytest.mark.tor - @pytest.mark.skipif(pytest.__version__ < '2.9', reason="requires newer pytest") + @pytest.mark.skipif(pytest.__version__ < "2.9", reason="requires newer pytest") def test_gui(self): self.run_all_common_setup_tests() self.run_all_share_mode_tests(True, False) + if __name__ == "__main__": unittest.main() diff --git a/tests/onionshare_share_mode_download_stay_open_test.py b/tests/onionshare_share_mode_download_stay_open_test.py index 3fcebc63..923eebf3 100644 --- a/tests/onionshare_share_mode_download_stay_open_test.py +++ b/tests/onionshare_share_mode_download_stay_open_test.py @@ -4,12 +4,11 @@ import unittest from .TorGuiShareTest import TorGuiShareTest + class ShareModeStayOpenTest(unittest.TestCase, TorGuiShareTest): @classmethod def setUpClass(cls): - test_settings = { - "close_after_first_download": False, - } + test_settings = {"close_after_first_download": False} cls.gui = TorGuiShareTest.set_up(test_settings) @classmethod @@ -18,10 +17,11 @@ class ShareModeStayOpenTest(unittest.TestCase, TorGuiShareTest): @pytest.mark.gui @pytest.mark.tor - @pytest.mark.skipif(pytest.__version__ < '2.9', reason="requires newer pytest") + @pytest.mark.skipif(pytest.__version__ < "2.9", reason="requires newer pytest") def test_gui(self): self.run_all_common_setup_tests() self.run_all_share_mode_tests(False, True) + if __name__ == "__main__": unittest.main() diff --git a/tests/onionshare_share_mode_download_test.py b/tests/onionshare_share_mode_download_test.py index 65f68df6..2bebd098 100644 --- a/tests/onionshare_share_mode_download_test.py +++ b/tests/onionshare_share_mode_download_test.py @@ -4,11 +4,11 @@ import unittest from .TorGuiShareTest import TorGuiShareTest + class ShareModeTest(unittest.TestCase, TorGuiShareTest): @classmethod def setUpClass(cls): - test_settings = { - } + test_settings = {} cls.gui = TorGuiShareTest.set_up(test_settings) @classmethod @@ -17,10 +17,11 @@ class ShareModeTest(unittest.TestCase, TorGuiShareTest): @pytest.mark.gui @pytest.mark.tor - @pytest.mark.skipif(pytest.__version__ < '2.9', reason="requires newer pytest") + @pytest.mark.skipif(pytest.__version__ < "2.9", reason="requires newer pytest") def test_gui(self): self.run_all_common_setup_tests() self.run_all_share_mode_tests(False, False) + if __name__ == "__main__": unittest.main() diff --git a/tests/onionshare_share_mode_persistent_test.py b/tests/onionshare_share_mode_persistent_test.py index d0fb5b22..c5d44733 100644 --- a/tests/onionshare_share_mode_persistent_test.py +++ b/tests/onionshare_share_mode_persistent_test.py @@ -4,13 +4,14 @@ import unittest from .TorGuiShareTest import TorGuiShareTest -class ShareModePersistentSlugTest(unittest.TestCase, TorGuiShareTest): + +class ShareModePersistentPasswordTest(unittest.TestCase, TorGuiShareTest): @classmethod def setUpClass(cls): test_settings = { "use_legacy_v2_onions": True, "public_mode": False, - "slug": "", + "password": "", "save_private_key": True, "close_after_first_download": False, } @@ -22,10 +23,11 @@ class ShareModePersistentSlugTest(unittest.TestCase, TorGuiShareTest): @pytest.mark.gui @pytest.mark.tor - @pytest.mark.skipif(pytest.__version__ < '2.9', reason="requires newer pytest") + @pytest.mark.skipif(pytest.__version__ < "2.9", reason="requires newer pytest") def test_gui(self): self.run_all_common_setup_tests() self.run_all_share_mode_persistent_tests(False, True) + if __name__ == "__main__": unittest.main() diff --git a/tests/onionshare_share_mode_stealth_test.py b/tests/onionshare_share_mode_stealth_test.py index ded0b7a8..3ee743d5 100644 --- a/tests/onionshare_share_mode_stealth_test.py +++ b/tests/onionshare_share_mode_stealth_test.py @@ -4,13 +4,11 @@ import unittest from .TorGuiShareTest import TorGuiShareTest + class ShareModeStealthTest(unittest.TestCase, TorGuiShareTest): @classmethod def setUpClass(cls): - test_settings = { - "use_legacy_v2_onions": True, - "use_stealth": True, - } + test_settings = {"use_legacy_v2_onions": True, "use_stealth": True} cls.gui = TorGuiShareTest.set_up(test_settings) @classmethod @@ -19,7 +17,7 @@ class ShareModeStealthTest(unittest.TestCase, TorGuiShareTest): @pytest.mark.gui @pytest.mark.tor - @pytest.mark.skipif(pytest.__version__ < '2.9', reason="requires newer pytest") + @pytest.mark.skipif(pytest.__version__ < "2.9", reason="requires newer pytest") def test_gui(self): self.run_all_common_setup_tests() self.run_all_share_mode_setup_tests() @@ -27,5 +25,6 @@ class ShareModeStealthTest(unittest.TestCase, TorGuiShareTest): self.hidserv_auth_string() self.copy_have_hidserv_auth_button(self.gui.share_mode) + if __name__ == "__main__": unittest.main() diff --git a/tests/onionshare_share_mode_timer_test.py b/tests/onionshare_share_mode_timer_test.py index 1ae2b0fa..78a70bbf 100644 --- a/tests/onionshare_share_mode_timer_test.py +++ b/tests/onionshare_share_mode_timer_test.py @@ -4,13 +4,11 @@ import unittest from .TorGuiShareTest import TorGuiShareTest + class ShareModeTimerTest(unittest.TestCase, TorGuiShareTest): @classmethod def setUpClass(cls): - test_settings = { - "public_mode": False, - "autostop_timer": True, - } + test_settings = {"public_mode": False, "autostop_timer": True} cls.gui = TorGuiShareTest.set_up(test_settings) @classmethod @@ -19,10 +17,11 @@ class ShareModeTimerTest(unittest.TestCase, TorGuiShareTest): @pytest.mark.gui @pytest.mark.tor - @pytest.mark.skipif(pytest.__version__ < '2.9', reason="requires newer pytest") + @pytest.mark.skipif(pytest.__version__ < "2.9", reason="requires newer pytest") def test_gui(self): self.run_all_common_setup_tests() self.run_all_share_mode_timer_tests(False) + if __name__ == "__main__": unittest.main() diff --git a/tests/onionshare_share_mode_tor_connection_killed_test.py b/tests/onionshare_share_mode_tor_connection_killed_test.py index 7362a170..4702ab3e 100644 --- a/tests/onionshare_share_mode_tor_connection_killed_test.py +++ b/tests/onionshare_share_mode_tor_connection_killed_test.py @@ -4,16 +4,16 @@ import unittest from .TorGuiShareTest import TorGuiShareTest + class ShareModeTorConnectionKilledTest(unittest.TestCase, TorGuiShareTest): @classmethod def setUpClass(cls): - test_settings = { - } + test_settings = {} cls.gui = TorGuiShareTest.set_up(test_settings) @pytest.mark.gui @pytest.mark.tor - @pytest.mark.skipif(pytest.__version__ < '2.9', reason="requires newer pytest") + @pytest.mark.skipif(pytest.__version__ < "2.9", reason="requires newer pytest") def test_gui(self): self.run_all_common_setup_tests() self.run_all_share_mode_setup_tests() diff --git a/tests/onionshare_share_mode_v2_onion_test.py b/tests/onionshare_share_mode_v2_onion_test.py index 29c97491..152457ba 100644 --- a/tests/onionshare_share_mode_v2_onion_test.py +++ b/tests/onionshare_share_mode_v2_onion_test.py @@ -4,12 +4,11 @@ import unittest from .TorGuiShareTest import TorGuiShareTest + class ShareModeV2OnionTest(unittest.TestCase, TorGuiShareTest): @classmethod def setUpClass(cls): - test_settings = { - "use_legacy_v2_onions": True, - } + test_settings = {"use_legacy_v2_onions": True} cls.gui = TorGuiShareTest.set_up(test_settings) @classmethod @@ -18,11 +17,12 @@ class ShareModeV2OnionTest(unittest.TestCase, TorGuiShareTest): @pytest.mark.gui @pytest.mark.tor - @pytest.mark.skipif(pytest.__version__ < '2.9', reason="requires newer pytest") + @pytest.mark.skipif(pytest.__version__ < "2.9", reason="requires newer pytest") def test_gui(self): self.run_all_common_setup_tests() self.run_all_share_mode_tests(False, False) self.have_v2_onion() + if __name__ == "__main__": unittest.main() diff --git a/tests/test_helpers.py b/tests/test_helpers.py index 321afbb7..387fbf4a 100644 --- a/tests/test_helpers.py +++ b/tests/test_helpers.py @@ -20,7 +20,7 @@ import tempfile import os -class MockSubprocess(): +class MockSubprocess: def __init__(self): self.last_call = None diff --git a/tests/test_onionshare.py b/tests/test_onionshare.py index f141fed7..64b16b1f 100644 --- a/tests/test_onionshare.py +++ b/tests/test_onionshare.py @@ -27,14 +27,14 @@ from onionshare.common import Common class MyOnion: def __init__(self, stealth=False): - self.auth_string = 'TestHidServAuth' - self.private_key = '' + self.auth_string = "TestHidServAuth" + self.private_key = "" self.stealth = stealth self.scheduled_key = None @staticmethod def start_onion_service(self, await_publication=True, save_scheduled_key=False): - return 'test_service_id.onion' + return "test_service_id.onion" @pytest.fixture @@ -65,18 +65,17 @@ class TestOnionShare: onionshare_obj.set_stealth(False) onionshare_obj.start_onion_service() assert 17600 <= onionshare_obj.port <= 17650 - assert onionshare_obj.onion_host == 'test_service_id.onion' + assert onionshare_obj.onion_host == "test_service_id.onion" def test_start_onion_service_stealth(self, onionshare_obj): onionshare_obj.set_stealth(True) onionshare_obj.start_onion_service() - assert onionshare_obj.auth_string == 'TestHidServAuth' + assert onionshare_obj.auth_string == "TestHidServAuth" def test_start_onion_service_local_only(self, onionshare_obj): onionshare_obj.local_only = True onionshare_obj.start_onion_service() - assert onionshare_obj.onion_host == '127.0.0.1:{}'.format( - onionshare_obj.port) + assert onionshare_obj.onion_host == "127.0.0.1:{}".format(onionshare_obj.port) def test_cleanup(self, onionshare_obj, temp_dir_1024, temp_file_1024): onionshare_obj.cleanup_filenames = [temp_dir_1024, temp_file_1024] diff --git a/tests/test_onionshare_common.py b/tests/test_onionshare_common.py index f975dce7..1f230295 100644 --- a/tests/test_onionshare_common.py +++ b/tests/test_onionshare_common.py @@ -29,39 +29,42 @@ import zipfile import pytest -LOG_MSG_REGEX = re.compile(r""" +LOG_MSG_REGEX = re.compile( + r""" ^\[Jun\ 06\ 2013\ 11:05:00\] \ TestModule\.<function\ TestLog\.test_output\.<locals>\.dummy_func - \ at\ 0x[a-f0-9]+>(:\ TEST_MSG)?$""", re.VERBOSE) -SLUG_REGEX = re.compile(r'^([a-z]+)(-[a-z]+)?-([a-z]+)(-[a-z]+)?$') + \ at\ 0x[a-f0-9]+>(:\ TEST_MSG)?$""", + re.VERBOSE, +) +PASSWORD_REGEX = re.compile(r"^([a-z]+)(-[a-z]+)?-([a-z]+)(-[a-z]+)?$") # TODO: Improve the Common tests to test it all as a single class -class TestBuildSlug: - @pytest.mark.parametrize('test_input,expected', ( - # VALID, two lowercase words, separated by a hyphen - ('syrup-enzyme', True), - ('caution-friday', True), - - # VALID, two lowercase words, with one hyphenated compound word - ('drop-down-thimble', True), - ('unmixed-yo-yo', True), - - # VALID, two lowercase hyphenated compound words, separated by hyphen - ('yo-yo-drop-down', True), - ('felt-tip-t-shirt', True), - ('hello-world', True), - - # INVALID - ('Upper-Case', False), - ('digits-123', False), - ('too-many-hyphens-', False), - ('symbols-!@#$%', False) - )) - def test_build_slug_regex(self, test_input, expected): - """ Test that `SLUG_REGEX` accounts for the following patterns +class TestBuildPassword: + @pytest.mark.parametrize( + "test_input,expected", + ( + # VALID, two lowercase words, separated by a hyphen + ("syrup-enzyme", True), + ("caution-friday", True), + # VALID, two lowercase words, with one hyphenated compound word + ("drop-down-thimble", True), + ("unmixed-yo-yo", True), + # VALID, two lowercase hyphenated compound words, separated by hyphen + ("yo-yo-drop-down", True), + ("felt-tip-t-shirt", True), + ("hello-world", True), + # INVALID + ("Upper-Case", False), + ("digits-123", False), + ("too-many-hyphens-", False), + ("symbols-!@#$%", False), + ), + ) + def test_build_password_regex(self, test_input, expected): + """ Test that `PASSWORD_REGEX` accounts for the following patterns There are a few hyphenated words in `wordlist.txt`: * drop-down @@ -69,17 +72,17 @@ class TestBuildSlug: * t-shirt * yo-yo - These words cause a few extra potential slug patterns: + These words cause a few extra potential password patterns: * word-word * hyphenated-word-word * word-hyphenated-word * hyphenated-word-hyphenated-word """ - assert bool(SLUG_REGEX.match(test_input)) == expected + assert bool(PASSWORD_REGEX.match(test_input)) == expected - def test_build_slug_unique(self, common_obj, sys_onionshare_dev_mode): - assert common_obj.build_slug() != common_obj.build_slug() + def test_build_password_unique(self, common_obj, sys_onionshare_dev_mode): + assert common_obj.build_password() != common_obj.build_password() class TestDirSize: @@ -92,79 +95,87 @@ class TestDirSize: class TestEstimatedTimeRemaining: - @pytest.mark.parametrize('test_input,expected', ( - ((2, 676, 12), '8h14m16s'), - ((14, 1049, 30), '1h26m15s'), - ((21, 450, 1), '33m42s'), - ((31, 1115, 80), '11m39s'), - ((336, 989, 32), '2m12s'), - ((603, 949, 38), '36s'), - ((971, 1009, 83), '1s') - )) + @pytest.mark.parametrize( + "test_input,expected", + ( + ((2, 676, 12), "8h14m16s"), + ((14, 1049, 30), "1h26m15s"), + ((21, 450, 1), "33m42s"), + ((31, 1115, 80), "11m39s"), + ((336, 989, 32), "2m12s"), + ((603, 949, 38), "36s"), + ((971, 1009, 83), "1s"), + ), + ) def test_estimated_time_remaining( - self, common_obj, test_input, expected, time_time_100): + self, common_obj, test_input, expected, time_time_100 + ): assert common_obj.estimated_time_remaining(*test_input) == expected - @pytest.mark.parametrize('test_input', ( - (10, 20, 100), # if `time_elapsed == 0` - (0, 37, 99) # if `download_rate == 0` - )) + @pytest.mark.parametrize( + "test_input", + ( + (10, 20, 100), # if `time_elapsed == 0` + (0, 37, 99), # if `download_rate == 0` + ), + ) def test_raises_zero_division_error(self, common_obj, test_input, time_time_100): with pytest.raises(ZeroDivisionError): common_obj.estimated_time_remaining(*test_input) class TestFormatSeconds: - @pytest.mark.parametrize('test_input,expected', ( - (0, '0s'), - (26, '26s'), - (60, '1m'), - (947.35, '15m47s'), - (1847, '30m47s'), - (2193.94, '36m34s'), - (3600, '1h'), - (13426.83, '3h43m47s'), - (16293, '4h31m33s'), - (18392.14, '5h6m32s'), - (86400, '1d'), - (129674, '1d12h1m14s'), - (56404.12, '15h40m4s') - )) + @pytest.mark.parametrize( + "test_input,expected", + ( + (0, "0s"), + (26, "26s"), + (60, "1m"), + (947.35, "15m47s"), + (1847, "30m47s"), + (2193.94, "36m34s"), + (3600, "1h"), + (13426.83, "3h43m47s"), + (16293, "4h31m33s"), + (18392.14, "5h6m32s"), + (86400, "1d"), + (129674, "1d12h1m14s"), + (56404.12, "15h40m4s"), + ), + ) def test_format_seconds(self, common_obj, test_input, expected): assert common_obj.format_seconds(test_input) == expected # TODO: test negative numbers? - @pytest.mark.parametrize('test_input', ( - 'string', lambda: None, [], {}, set() - )) + @pytest.mark.parametrize("test_input", ("string", lambda: None, [], {}, set())) def test_invalid_input_types(self, common_obj, test_input): with pytest.raises(TypeError): common_obj.format_seconds(test_input) class TestGetAvailablePort: - @pytest.mark.parametrize('port_min,port_max', ( - (random.randint(1024, 1500), - random.randint(1800, 2048)) for _ in range(50) - )) + @pytest.mark.parametrize( + "port_min,port_max", + ((random.randint(1024, 1500), random.randint(1800, 2048)) for _ in range(50)), + ) def test_returns_an_open_port(self, common_obj, port_min, port_max): """ get_available_port() should return an open port within the range """ port = common_obj.get_available_port(port_min, port_max) assert port_min <= port <= port_max with socket.socket() as tmpsock: - tmpsock.bind(('127.0.0.1', port)) + tmpsock.bind(("127.0.0.1", port)) class TestGetPlatform: def test_darwin(self, platform_darwin, common_obj): - assert common_obj.platform == 'Darwin' + assert common_obj.platform == "Darwin" def test_linux(self, platform_linux, common_obj): - assert common_obj.platform == 'Linux' + assert common_obj.platform == "Linux" def test_windows(self, platform_windows, common_obj): - assert common_obj.platform == 'Windows' + assert common_obj.platform == "Windows" # TODO: double-check these tests @@ -173,94 +184,114 @@ class TestGetResourcePath: prefix = os.path.join( os.path.dirname( os.path.dirname( - os.path.abspath( - inspect.getfile( - inspect.currentframe())))), 'share') - assert ( - common_obj.get_resource_path(os.path.join(prefix, 'test_filename')) == - os.path.join(prefix, 'test_filename')) + os.path.abspath(inspect.getfile(inspect.currentframe())) + ) + ), + "share", + ) + assert common_obj.get_resource_path( + os.path.join(prefix, "test_filename") + ) == os.path.join(prefix, "test_filename") def test_linux(self, common_obj, platform_linux, sys_argv_sys_prefix): - prefix = os.path.join(sys.prefix, 'share/onionshare') - assert ( - common_obj.get_resource_path(os.path.join(prefix, 'test_filename')) == - os.path.join(prefix, 'test_filename')) + prefix = os.path.join(sys.prefix, "share/onionshare") + assert common_obj.get_resource_path( + os.path.join(prefix, "test_filename") + ) == os.path.join(prefix, "test_filename") def test_frozen_darwin(self, common_obj, platform_darwin, sys_frozen, sys_meipass): - prefix = os.path.join(sys._MEIPASS, 'share') - assert ( - common_obj.get_resource_path(os.path.join(prefix, 'test_filename')) == - os.path.join(prefix, 'test_filename')) + prefix = os.path.join(sys._MEIPASS, "share") + assert common_obj.get_resource_path( + os.path.join(prefix, "test_filename") + ) == os.path.join(prefix, "test_filename") class TestGetTorPaths: # @pytest.mark.skipif(sys.platform != 'Darwin', reason='requires MacOS') ? - def test_get_tor_paths_darwin(self, platform_darwin, common_obj, sys_frozen, sys_meipass): + def test_get_tor_paths_darwin( + self, platform_darwin, common_obj, sys_frozen, sys_meipass + ): base_path = os.path.dirname( - os.path.dirname( - os.path.dirname( - common_obj.get_resource_path('')))) - tor_path = os.path.join( - base_path, 'Resources', 'Tor', 'tor') - tor_geo_ip_file_path = os.path.join( - base_path, 'Resources', 'Tor', 'geoip') - tor_geo_ipv6_file_path = os.path.join( - base_path, 'Resources', 'Tor', 'geoip6') - obfs4proxy_file_path = os.path.join( - base_path, 'Resources', 'Tor', 'obfs4proxy') - assert (common_obj.get_tor_paths() == - (tor_path, tor_geo_ip_file_path, tor_geo_ipv6_file_path, obfs4proxy_file_path)) + os.path.dirname(os.path.dirname(common_obj.get_resource_path(""))) + ) + tor_path = os.path.join(base_path, "Resources", "Tor", "tor") + tor_geo_ip_file_path = os.path.join(base_path, "Resources", "Tor", "geoip") + tor_geo_ipv6_file_path = os.path.join(base_path, "Resources", "Tor", "geoip6") + obfs4proxy_file_path = os.path.join(base_path, "Resources", "Tor", "obfs4proxy") + assert common_obj.get_tor_paths() == ( + tor_path, + tor_geo_ip_file_path, + tor_geo_ipv6_file_path, + obfs4proxy_file_path, + ) # @pytest.mark.skipif(sys.platform != 'Linux', reason='requires Linux') ? def test_get_tor_paths_linux(self, platform_linux, common_obj): - assert (common_obj.get_tor_paths() == - ('/usr/bin/tor', '/usr/share/tor/geoip', '/usr/share/tor/geoip6', '/usr/bin/obfs4proxy')) + assert common_obj.get_tor_paths() == ( + "/usr/bin/tor", + "/usr/share/tor/geoip", + "/usr/share/tor/geoip6", + "/usr/bin/obfs4proxy", + ) # @pytest.mark.skipif(sys.platform != 'Windows', reason='requires Windows') ? def test_get_tor_paths_windows(self, platform_windows, common_obj, sys_frozen): base_path = os.path.join( - os.path.dirname( - os.path.dirname( - common_obj.get_resource_path(''))), 'tor') - tor_path = os.path.join( - os.path.join(base_path, 'Tor'), 'tor.exe') + os.path.dirname(os.path.dirname(common_obj.get_resource_path(""))), "tor" + ) + tor_path = os.path.join(os.path.join(base_path, "Tor"), "tor.exe") obfs4proxy_file_path = os.path.join( - os.path.join(base_path, 'Tor'), 'obfs4proxy.exe') + os.path.join(base_path, "Tor"), "obfs4proxy.exe" + ) tor_geo_ip_file_path = os.path.join( - os.path.join( - os.path.join(base_path, 'Data'), 'Tor'), 'geoip') + os.path.join(os.path.join(base_path, "Data"), "Tor"), "geoip" + ) tor_geo_ipv6_file_path = os.path.join( - os.path.join( - os.path.join(base_path, 'Data'), 'Tor'), 'geoip6') - assert (common_obj.get_tor_paths() == - (tor_path, tor_geo_ip_file_path, tor_geo_ipv6_file_path, obfs4proxy_file_path)) + os.path.join(os.path.join(base_path, "Data"), "Tor"), "geoip6" + ) + assert common_obj.get_tor_paths() == ( + tor_path, + tor_geo_ip_file_path, + tor_geo_ipv6_file_path, + obfs4proxy_file_path, + ) class TestHumanReadableFilesize: - @pytest.mark.parametrize('test_input,expected', ( - (1024 ** 0, '1.0 B'), - (1024 ** 1, '1.0 KiB'), - (1024 ** 2, '1.0 MiB'), - (1024 ** 3, '1.0 GiB'), - (1024 ** 4, '1.0 TiB'), - (1024 ** 5, '1.0 PiB'), - (1024 ** 6, '1.0 EiB'), - (1024 ** 7, '1.0 ZiB'), - (1024 ** 8, '1.0 YiB') - )) + @pytest.mark.parametrize( + "test_input,expected", + ( + (1024 ** 0, "1.0 B"), + (1024 ** 1, "1.0 KiB"), + (1024 ** 2, "1.0 MiB"), + (1024 ** 3, "1.0 GiB"), + (1024 ** 4, "1.0 TiB"), + (1024 ** 5, "1.0 PiB"), + (1024 ** 6, "1.0 EiB"), + (1024 ** 7, "1.0 ZiB"), + (1024 ** 8, "1.0 YiB"), + ), + ) def test_human_readable_filesize(self, common_obj, test_input, expected): assert common_obj.human_readable_filesize(test_input) == expected class TestLog: - @pytest.mark.parametrize('test_input', ( - ('[Jun 06 2013 11:05:00]' - ' TestModule.<function TestLog.test_output.<locals>.dummy_func' - ' at 0xdeadbeef>'), - ('[Jun 06 2013 11:05:00]' - ' TestModule.<function TestLog.test_output.<locals>.dummy_func' - ' at 0xdeadbeef>: TEST_MSG') - )) + @pytest.mark.parametrize( + "test_input", + ( + ( + "[Jun 06 2013 11:05:00]" + " TestModule.<function TestLog.test_output.<locals>.dummy_func" + " at 0xdeadbeef>" + ), + ( + "[Jun 06 2013 11:05:00]" + " TestModule.<function TestLog.test_output.<locals>.dummy_func" + " at 0xdeadbeef>: TEST_MSG" + ), + ), + ) def test_log_msg_regex(self, test_input): assert bool(LOG_MSG_REGEX.match(test_input)) @@ -272,10 +303,10 @@ class TestLog: # From: https://stackoverflow.com/questions/1218933 with io.StringIO() as buf, contextlib.redirect_stdout(buf): - common_obj.log('TestModule', dummy_func) - common_obj.log('TestModule', dummy_func, 'TEST_MSG') + common_obj.log("TestModule", dummy_func) + common_obj.log("TestModule", dummy_func, "TEST_MSG") output = buf.getvalue() - line_one, line_two, _ = output.split('\n') + line_one, line_two, _ = output.split("\n") assert LOG_MSG_REGEX.match(line_one) assert LOG_MSG_REGEX.match(line_two) diff --git a/tests/test_onionshare_settings.py b/tests/test_onionshare_settings.py index bcc2f7cb..0bce2f94 100644 --- a/tests/test_onionshare_settings.py +++ b/tests/test_onionshare_settings.py @@ -28,85 +28,86 @@ from onionshare import common, settings, strings @pytest.fixture def os_path_expanduser(monkeypatch): - monkeypatch.setattr('os.path.expanduser', lambda path: path) + monkeypatch.setattr("os.path.expanduser", lambda path: path) @pytest.fixture def settings_obj(sys_onionshare_dev_mode, platform_linux): _common = common.Common() - _common.version = 'DUMMY_VERSION_1.2.3' + _common.version = "DUMMY_VERSION_1.2.3" return settings.Settings(_common) class TestSettings: def test_init(self, settings_obj): expected_settings = { - 'version': 'DUMMY_VERSION_1.2.3', - 'connection_type': 'bundled', - 'control_port_address': '127.0.0.1', - 'control_port_port': 9051, - 'socks_address': '127.0.0.1', - 'socks_port': 9050, - 'socket_file_path': '/var/run/tor/control', - 'auth_type': 'no_auth', - 'auth_password': '', - 'close_after_first_download': True, - 'autostop_timer': False, - 'autostart_timer': False, - 'use_stealth': False, - 'use_autoupdate': True, - 'autoupdate_timestamp': None, - 'no_bridges': True, - 'tor_bridges_use_obfs4': False, - 'tor_bridges_use_meek_lite_azure': False, - 'tor_bridges_use_custom_bridges': '', - 'use_legacy_v2_onions': False, - 'save_private_key': False, - 'private_key': '', - 'slug': '', - 'hidservauth_string': '', - 'data_dir': os.path.expanduser('~/OnionShare'), - 'public_mode': False + "version": "DUMMY_VERSION_1.2.3", + "connection_type": "bundled", + "control_port_address": "127.0.0.1", + "control_port_port": 9051, + "socks_address": "127.0.0.1", + "socks_port": 9050, + "socket_file_path": "/var/run/tor/control", + "auth_type": "no_auth", + "auth_password": "", + "close_after_first_download": True, + "autostop_timer": False, + "autostart_timer": False, + "use_stealth": False, + "use_autoupdate": True, + "autoupdate_timestamp": None, + "no_bridges": True, + "tor_bridges_use_obfs4": False, + "tor_bridges_use_meek_lite_azure": False, + "tor_bridges_use_custom_bridges": "", + "use_legacy_v2_onions": False, + "save_private_key": False, + "private_key": "", + "password": "", + "hidservauth_string": "", + "data_dir": os.path.expanduser("~/OnionShare"), + "public_mode": False, + "csp_header_disabled": False, } for key in settings_obj._settings: # Skip locale, it will not always default to the same thing - if key != 'locale': + if key != "locale": assert settings_obj._settings[key] == settings_obj.default_settings[key] assert settings_obj._settings[key] == expected_settings[key] def test_fill_in_defaults(self, settings_obj): - del settings_obj._settings['version'] + del settings_obj._settings["version"] settings_obj.fill_in_defaults() - assert settings_obj._settings['version'] == 'DUMMY_VERSION_1.2.3' + assert settings_obj._settings["version"] == "DUMMY_VERSION_1.2.3" def test_load(self, settings_obj): custom_settings = { - 'version': 'CUSTOM_VERSION', - 'socks_port': 9999, - 'use_stealth': True + "version": "CUSTOM_VERSION", + "socks_port": 9999, + "use_stealth": True, } tmp_file, tmp_file_path = tempfile.mkstemp() - with open(tmp_file, 'w') as f: + with open(tmp_file, "w") as f: json.dump(custom_settings, f) settings_obj.filename = tmp_file_path settings_obj.load() - assert settings_obj._settings['version'] == 'CUSTOM_VERSION' - assert settings_obj._settings['socks_port'] == 9999 - assert settings_obj._settings['use_stealth'] is True + assert settings_obj._settings["version"] == "CUSTOM_VERSION" + assert settings_obj._settings["socks_port"] == 9999 + assert settings_obj._settings["use_stealth"] is True os.remove(tmp_file_path) assert os.path.exists(tmp_file_path) is False def test_save(self, monkeypatch, settings_obj): - monkeypatch.setattr(strings, '_', lambda _: '') + monkeypatch.setattr(strings, "_", lambda _: "") - settings_filename = 'default_settings.json' + settings_filename = "default_settings.json" tmp_dir = tempfile.gettempdir() settings_path = os.path.join(tmp_dir, settings_filename) settings_obj.filename = settings_path settings_obj.save() - with open(settings_path, 'r') as f: + with open(settings_path, "r") as f: settings = json.load(f) assert settings_obj._settings == settings @@ -115,69 +116,64 @@ class TestSettings: assert os.path.exists(settings_path) is False def test_get(self, settings_obj): - assert settings_obj.get('version') == 'DUMMY_VERSION_1.2.3' - assert settings_obj.get('connection_type') == 'bundled' - assert settings_obj.get('control_port_address') == '127.0.0.1' - assert settings_obj.get('control_port_port') == 9051 - assert settings_obj.get('socks_address') == '127.0.0.1' - assert settings_obj.get('socks_port') == 9050 - assert settings_obj.get('socket_file_path') == '/var/run/tor/control' - assert settings_obj.get('auth_type') == 'no_auth' - assert settings_obj.get('auth_password') == '' - assert settings_obj.get('close_after_first_download') is True - assert settings_obj.get('use_stealth') is False - assert settings_obj.get('use_autoupdate') is True - assert settings_obj.get('autoupdate_timestamp') is None - assert settings_obj.get('autoupdate_timestamp') is None - assert settings_obj.get('no_bridges') is True - assert settings_obj.get('tor_bridges_use_obfs4') is False - assert settings_obj.get('tor_bridges_use_meek_lite_azure') is False - assert settings_obj.get('tor_bridges_use_custom_bridges') == '' - + assert settings_obj.get("version") == "DUMMY_VERSION_1.2.3" + assert settings_obj.get("connection_type") == "bundled" + assert settings_obj.get("control_port_address") == "127.0.0.1" + assert settings_obj.get("control_port_port") == 9051 + assert settings_obj.get("socks_address") == "127.0.0.1" + assert settings_obj.get("socks_port") == 9050 + assert settings_obj.get("socket_file_path") == "/var/run/tor/control" + assert settings_obj.get("auth_type") == "no_auth" + assert settings_obj.get("auth_password") == "" + assert settings_obj.get("close_after_first_download") is True + assert settings_obj.get("use_stealth") is False + assert settings_obj.get("use_autoupdate") is True + assert settings_obj.get("autoupdate_timestamp") is None + assert settings_obj.get("autoupdate_timestamp") is None + assert settings_obj.get("no_bridges") is True + assert settings_obj.get("tor_bridges_use_obfs4") is False + assert settings_obj.get("tor_bridges_use_meek_lite_azure") is False + assert settings_obj.get("tor_bridges_use_custom_bridges") == "" def test_set_version(self, settings_obj): - settings_obj.set('version', 'CUSTOM_VERSION') - assert settings_obj._settings['version'] == 'CUSTOM_VERSION' + settings_obj.set("version", "CUSTOM_VERSION") + assert settings_obj._settings["version"] == "CUSTOM_VERSION" def test_set_control_port_port(self, settings_obj): - settings_obj.set('control_port_port', 999) - assert settings_obj._settings['control_port_port'] == 999 + settings_obj.set("control_port_port", 999) + assert settings_obj._settings["control_port_port"] == 999 - settings_obj.set('control_port_port', 'NON_INTEGER') - assert settings_obj._settings['control_port_port'] == 9051 + settings_obj.set("control_port_port", "NON_INTEGER") + assert settings_obj._settings["control_port_port"] == 9051 def test_set_socks_port(self, settings_obj): - settings_obj.set('socks_port', 888) - assert settings_obj._settings['socks_port'] == 888 + settings_obj.set("socks_port", 888) + assert settings_obj._settings["socks_port"] == 888 - settings_obj.set('socks_port', 'NON_INTEGER') - assert settings_obj._settings['socks_port'] == 9050 + settings_obj.set("socks_port", "NON_INTEGER") + assert settings_obj._settings["socks_port"] == 9050 - def test_filename_darwin( - self, - monkeypatch, - os_path_expanduser, - platform_darwin): + def test_filename_darwin(self, monkeypatch, os_path_expanduser, platform_darwin): obj = settings.Settings(common.Common()) - assert (obj.filename == - '~/Library/Application Support/OnionShare/onionshare.json') - - def test_filename_linux( - self, - monkeypatch, - os_path_expanduser, - platform_linux): + assert ( + obj.filename == "~/Library/Application Support/OnionShare/onionshare.json" + ) + + def test_filename_linux(self, monkeypatch, os_path_expanduser, platform_linux): obj = settings.Settings(common.Common()) - assert obj.filename == '~/.config/onionshare/onionshare.json' + assert obj.filename == "~/.config/onionshare/onionshare.json" - def test_filename_windows( - self, - monkeypatch, - platform_windows): - monkeypatch.setenv('APPDATA', 'C:') + def test_filename_windows(self, monkeypatch, platform_windows): + monkeypatch.setenv("APPDATA", "C:") obj = settings.Settings(common.Common()) - assert obj.filename.replace('/', '\\') == 'C:\\OnionShare\\onionshare.json' + assert obj.filename.replace("/", "\\") == "C:\\OnionShare\\onionshare.json" def test_set_custom_bridge(self, settings_obj): - settings_obj.set('tor_bridges_use_custom_bridges', 'Bridge 45.3.20.65:9050 21300AD88890A49C429A6CB9959CFD44490A8F6E') - assert settings_obj._settings['tor_bridges_use_custom_bridges'] == 'Bridge 45.3.20.65:9050 21300AD88890A49C429A6CB9959CFD44490A8F6E' + settings_obj.set( + "tor_bridges_use_custom_bridges", + "Bridge 45.3.20.65:9050 21300AD88890A49C429A6CB9959CFD44490A8F6E", + ) + assert ( + settings_obj._settings["tor_bridges_use_custom_bridges"] + == "Bridge 45.3.20.65:9050 21300AD88890A49C429A6CB9959CFD44490A8F6E" + ) diff --git a/tests/test_onionshare_strings.py b/tests/test_onionshare_strings.py index 3ac22a11..7ad65191 100644 --- a/tests/test_onionshare_strings.py +++ b/tests/test_onionshare_strings.py @@ -32,31 +32,34 @@ from onionshare.settings import Settings # return path # common.get_resource_path = get_resource_path + def test_underscore_is_function(): assert callable(strings._) and isinstance(strings._, types.FunctionType) class TestLoadStrings: def test_load_strings_defaults_to_english( - self, common_obj, locale_en, sys_onionshare_dev_mode): + self, common_obj, locale_en, sys_onionshare_dev_mode + ): """ load_strings() loads English by default """ common_obj.settings = Settings(common_obj) strings.load_strings(common_obj) - assert strings._('preparing_files') == "Compressing files." - + assert strings._("preparing_files") == "Compressing files." def test_load_strings_loads_other_languages( - self, common_obj, locale_fr, sys_onionshare_dev_mode): + self, common_obj, locale_fr, sys_onionshare_dev_mode + ): """ load_strings() loads other languages in different locales """ common_obj.settings = Settings(common_obj) - common_obj.settings.set('locale', 'fr') + common_obj.settings.set("locale", "fr") strings.load_strings(common_obj) - assert strings._('preparing_files') == "Compression des fichiers." + assert strings._("preparing_files") == "Compression des fichiers." def test_load_invalid_locale( - self, common_obj, locale_invalid, sys_onionshare_dev_mode): + self, common_obj, locale_invalid, sys_onionshare_dev_mode + ): """ load_strings() raises a KeyError for an invalid locale """ with pytest.raises(KeyError): common_obj.settings = Settings(common_obj) - common_obj.settings.set('locale', 'XX') + common_obj.settings.set("locale", "XX") strings.load_strings(common_obj) diff --git a/tests/test_onionshare_web.py b/tests/test_onionshare_web.py index 0c29859b..b971b31a 100644 --- a/tests/test_onionshare_web.py +++ b/tests/test_onionshare_web.py @@ -27,16 +27,18 @@ import socket import sys import zipfile import tempfile +import base64 import pytest +from werkzeug.datastructures import Headers from onionshare.common import Common from onionshare import strings from onionshare.web import Web from onionshare.settings import Settings -DEFAULT_ZW_FILENAME_REGEX = re.compile(r'^onionshare_[a-z2-7]{6}.zip$') -RANDOM_STR_REGEX = re.compile(r'^[a-z2-7]+$') +DEFAULT_ZW_FILENAME_REGEX = re.compile(r"^onionshare_[a-z2-7]{6}.zip$") +RANDOM_STR_REGEX = re.compile(r"^[a-z2-7]+$") def web_obj(common_obj, mode, num_files=0): @@ -44,19 +46,19 @@ def web_obj(common_obj, mode, num_files=0): common_obj.settings = Settings(common_obj) strings.load_strings(common_obj) web = Web(common_obj, False, mode) - web.generate_slug() + web.generate_password() web.stay_open = True web.running = True web.app.testing = True # Share mode - if mode == 'share': + if mode == "share": # Add files files = [] for i in range(num_files): with tempfile.NamedTemporaryFile(delete=False) as tmp_file: - tmp_file.write(b'*' * 1024) + tmp_file.write(b"*" * 1024) files.append(tmp_file.name) web.share_mode.set_file_info(files) # Receive mode @@ -68,114 +70,130 @@ def web_obj(common_obj, mode, num_files=0): class TestWeb: def test_share_mode(self, common_obj): - web = web_obj(common_obj, 'share', 3) - assert web.mode is 'share' + web = web_obj(common_obj, "share", 3) + assert web.mode is "share" with web.app.test_client() as c: - # Load 404 pages - res = c.get('/') + # Load / without auth + res = c.get("/") res.get_data() - assert res.status_code == 404 + assert res.status_code == 401 - res = c.get('/invalidslug'.format(web.slug)) + # Load / with invalid auth + res = c.get("/", headers=self._make_auth_headers("invalid")) res.get_data() - assert res.status_code == 404 + assert res.status_code == 401 - # Load download page - res = c.get('/{}'.format(web.slug)) + # Load / with valid auth + res = c.get("/", headers=self._make_auth_headers(web.password)) res.get_data() assert res.status_code == 200 # Download - res = c.get('/{}/download'.format(web.slug)) + res = c.get("/download", headers=self._make_auth_headers(web.password)) res.get_data() assert res.status_code == 200 - assert res.mimetype == 'application/zip' + assert res.mimetype == "application/zip" def test_share_mode_close_after_first_download_on(self, common_obj, temp_file_1024): - web = web_obj(common_obj, 'share', 3) + web = web_obj(common_obj, "share", 3) web.stay_open = False assert web.running == True with web.app.test_client() as c: # Download the first time - res = c.get('/{}/download'.format(web.slug)) + res = c.get("/download", headers=self._make_auth_headers(web.password)) res.get_data() assert res.status_code == 200 - assert res.mimetype == 'application/zip' + assert res.mimetype == "application/zip" assert web.running == False - def test_share_mode_close_after_first_download_off(self, common_obj, temp_file_1024): - web = web_obj(common_obj, 'share', 3) + def test_share_mode_close_after_first_download_off( + self, common_obj, temp_file_1024 + ): + web = web_obj(common_obj, "share", 3) web.stay_open = True assert web.running == True with web.app.test_client() as c: # Download the first time - res = c.get('/{}/download'.format(web.slug)) + res = c.get("/download", headers=self._make_auth_headers(web.password)) res.get_data() assert res.status_code == 200 - assert res.mimetype == 'application/zip' + assert res.mimetype == "application/zip" assert web.running == True def test_receive_mode(self, common_obj): - web = web_obj(common_obj, 'receive') - assert web.mode is 'receive' + web = web_obj(common_obj, "receive") + assert web.mode is "receive" with web.app.test_client() as c: - # Load 404 pages - res = c.get('/') + # Load / without auth + res = c.get("/") res.get_data() - assert res.status_code == 404 + assert res.status_code == 401 - res = c.get('/invalidslug'.format(web.slug)) + # Load / with invalid auth + res = c.get("/", headers=self._make_auth_headers("invalid")) res.get_data() - assert res.status_code == 404 + assert res.status_code == 401 - # Load upload page - res = c.get('/{}'.format(web.slug)) + # Load / with valid auth + res = c.get("/", headers=self._make_auth_headers(web.password)) res.get_data() assert res.status_code == 200 def test_public_mode_on(self, common_obj): - web = web_obj(common_obj, 'receive') - common_obj.settings.set('public_mode', True) + web = web_obj(common_obj, "receive") + common_obj.settings.set("public_mode", True) with web.app.test_client() as c: - # Upload page should be accessible from / - res = c.get('/') + # Loading / should work without auth + res = c.get("/") data1 = res.get_data() assert res.status_code == 200 - # /[slug] should be a 404 - res = c.get('/{}'.format(web.slug)) - data2 = res.get_data() - assert res.status_code == 404 - def test_public_mode_off(self, common_obj): - web = web_obj(common_obj, 'receive') - common_obj.settings.set('public_mode', False) + web = web_obj(common_obj, "receive") + common_obj.settings.set("public_mode", False) with web.app.test_client() as c: - # / should be a 404 - res = c.get('/') - data1 = res.get_data() - assert res.status_code == 404 + # Load / without auth + res = c.get("/") + res.get_data() + assert res.status_code == 401 + + # But static resources should work without auth + res = c.get("{}/css/style.css".format(web.static_url_path)) + res.get_data() + assert res.status_code == 200 - # Upload page should be accessible from /[slug] - res = c.get('/{}'.format(web.slug)) - data2 = res.get_data() + # Load / with valid auth + res = c.get("/", headers=self._make_auth_headers(web.password)) + res.get_data() assert res.status_code == 200 + def _make_auth_headers(self, password): + auth = base64.b64encode(b"onionshare:" + password.encode()).decode() + h = Headers() + h.add("Authorization", "Basic " + auth) + return h + class TestZipWriterDefault: - @pytest.mark.parametrize('test_input', ( - 'onionshare_{}.zip'.format(''.join( - random.choice('abcdefghijklmnopqrstuvwxyz234567') for _ in range(6) - )) for _ in range(50) - )) + @pytest.mark.parametrize( + "test_input", + ( + "onionshare_{}.zip".format( + "".join( + random.choice("abcdefghijklmnopqrstuvwxyz234567") for _ in range(6) + ) + ) + for _ in range(50) + ), + ) def test_default_zw_filename_regex(self, test_input): assert bool(DEFAULT_ZW_FILENAME_REGEX.match(test_input)) @@ -190,15 +208,14 @@ class TestZipWriterDefault: assert default_zw.z._allowZip64 is True def test_zipfile_mode(self, default_zw): - assert default_zw.z.mode == 'w' + assert default_zw.z.mode == "w" def test_callback(self, default_zw): assert default_zw.processed_size_callback(None) is None def test_add_file(self, default_zw, temp_file_1024_delete): default_zw.add_file(temp_file_1024_delete) - zipfile_info = default_zw.z.getinfo( - os.path.basename(temp_file_1024_delete)) + zipfile_info = default_zw.z.getinfo(os.path.basename(temp_file_1024_delete)) assert zipfile_info.compress_type == zipfile.ZIP_DEFLATED assert zipfile_info.file_size == 1024 @@ -210,12 +227,15 @@ class TestZipWriterDefault: class TestZipWriterCustom: - @pytest.mark.parametrize('test_input', ( - Common.random_string( - random.randint(2, 50), - random.choice((None, random.randint(2, 50))) - ) for _ in range(50) - )) + @pytest.mark.parametrize( + "test_input", + ( + Common.random_string( + random.randint(2, 50), random.choice((None, random.randint(2, 50))) + ) + for _ in range(50) + ), + ) def test_random_string_regex(self, test_input): assert bool(RANDOM_STR_REGEX.match(test_input)) @@ -223,4 +243,4 @@ class TestZipWriterCustom: assert bool(RANDOM_STR_REGEX.match(custom_zw.zip_filename)) def test_custom_callback(self, custom_zw): - assert custom_zw.processed_size_callback(None) == 'custom_callback' + assert custom_zw.processed_size_callback(None) == "custom_callback" |