phantom/onionshare
1
0
Fork 0
mirror of https://github.com/onionshare/onionshare.git synced 2025-01-26 11:13:00 -03:00
Code Issues Projects Releases Packages Wiki Activity Actions

Start fixing the GUI tests. Also, refactor CommonTests to pass in a Mode object instead of the string "share" or "receive"

Browse source
This commit is contained in:
Micah Lee 2018-10-07 18:49:09 -07:00
parent 38e62d8528
commit 1b1ade63da
No known key found for this signature in database
GPG key ID: 403C2657CD994F73
2 changed files with 69 additions and 151 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

182
tests_gui_local/commontests.py
View file

@ -6,6 +6,9 @@ import zipfile
from PyQt5 import QtCore, QtTest from PyQt5 import QtCore, QtTest
from onionshare import strings from onionshare import strings
from onionshare_gui.mode.receive_mode import ReceiveMode
from onionshare_gui.mode.share_mode import ShareMode
class CommonTests(object): class CommonTests(object):
def test_gui_loaded(self): def test_gui_loaded(self):
@ -24,71 +27,42 @@ class CommonTests(object):
'''Test that the status bar is visible''' '''Test that the status bar is visible'''
self.assertTrue(self.gui.status_bar.isVisible()) self.assertTrue(self.gui.status_bar.isVisible())
def test_info_widget_shows_less(self, mode):
'''Test that minimum information (no label) is displayed in the info bar'''
if mode == 'share':
self.assertFalse(self.gui.share_mode.info.label.text() == "")
if mode == 'receive':
# There's no minimal display in receive mode
self.assertTrue(False)
def test_click_mode(self, mode): def test_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 mode == 'receive': if type(mode) == ReceiveMode:
QtTest.QTest.mouseClick(self.gui.receive_mode_button, QtCore.Qt.LeftButton) QtTest.QTest.mouseClick(self.gui.receive_mode_button, QtCore.Qt.LeftButton)
self.assertTrue(self.gui.mode, self.gui.MODE_RECEIVE) self.assertTrue(self.gui.mode, self.gui.MODE_RECEIVE)
if mode == 'share': if type(mode) == ShareMode:
QtTest.QTest.mouseClick(self.gui.share_mode_button, QtCore.Qt.LeftButton) QtTest.QTest.mouseClick(self.gui.share_mode_button, QtCore.Qt.LeftButton)
self.assertTrue(self.gui.mode, self.gui.MODE_SHARE) self.assertTrue(self.gui.mode, self.gui.MODE_SHARE)
def test_click_toggle_history(self, mode): def test_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'''
if mode == 'receive': currently_visible = mode.history.isVisible()
currently_visible = self.gui.receive_mode.uploads.isVisible() QtTest.QTest.mouseClick(mode.toggle_history, QtCore.Qt.LeftButton)
QtTest.QTest.mouseClick(self.gui.receive_mode.info.toggle_button, QtCore.Qt.LeftButton) self.assertEqual(mode.history.isVisible(), not currently_visible)
self.assertEqual(self.gui.receive_mode.uploads.isVisible(), not currently_visible)
if mode == 'share':
currently_visible = self.gui.receive_mode.uploads.isVisible()
QtTest.QTest.mouseClick(self.gui.share_mode.info.toggle_button, QtCore.Qt.LeftButton)
self.assertEqual(self.gui.share_mode.downloads.isVisible(), not currently_visible)
def test_history_indicator(self, mode, public_mode): def test_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'''
if mode == 'receive': # Make sure history is toggled off
# Make sure history is toggled off if mode.history.isVisible():
if self.gui.receive_mode.uploads.isVisible(): QtTest.QTest.mouseClick(mode.toggle_history, QtCore.Qt.LeftButton)
QtTest.QTest.mouseClick(self.gui.receive_mode.info.toggle_button, QtCore.Qt.LeftButton) self.assertFalse(mode.history.isVisible())
self.assertFalse(self.gui.receive_mode.uploads.isVisible())
# Indicator should not be visible yet # Indicator should not be visible yet
self.assertFalse(self.gui.receive_mode.info.indicator_label.isVisible()) self.assertFalse(mode.toggle_history.indicator_label.isVisible())
if type(mode) == ReceiveMode:
# Upload a file # Upload a file
files = {'file[]': open('/tmp/test.txt', 'rb')} files = {'file[]': open('/tmp/test.txt', 'rb')}
if not public_mode: if not public_mode:
path = 'http://127.0.0.1:{}/{}/upload'.format(self.gui.app.port, self.gui.receive_mode.web.slug) path = 'http://127.0.0.1:{}/{}/upload'.format(self.gui.app.port, mode.web.slug)
else: else:
path = 'http://127.0.0.1:{}/upload'.format(self.gui.app.port) path = 'http://127.0.0.1:{}/upload'.format(self.gui.app.port)
response = requests.post(path, files=files) response = requests.post(path, files=files)
QtTest.QTest.qWait(2000) QtTest.QTest.qWait(2000)
# Indicator should be visible, have a value of "1" if type(mode) == ShareMode:
self.assertTrue(self.gui.receive_mode.info.indicator_label.isVisible())
self.assertEqual(self.gui.receive_mode.info.indicator_label.text(), "1")
# Toggle history back on, indicator should be hidden again
QtTest.QTest.mouseClick(self.gui.receive_mode.info.toggle_button, QtCore.Qt.LeftButton)
self.assertFalse(self.gui.receive_mode.info.indicator_label.isVisible())
if mode == 'share':
# Make sure history is toggled off
if self.gui.share_mode.downloads.isVisible():
QtTest.QTest.mouseClick(self.gui.share_mode.info.toggle_button, QtCore.Qt.LeftButton)
self.assertFalse(self.gui.share_mode.downloads.isVisible())
# Indicator should not be visible yet
self.assertFalse(self.gui.share_mode.info.indicator_label.isVisible())
# Download files # Download files
if public_mode: if public_mode:
url = "http://127.0.0.1:{}/download".format(self.gui.app.port) url = "http://127.0.0.1:{}/download".format(self.gui.app.port)
@ -97,44 +71,31 @@ class CommonTests(object):
r = requests.get(url) r = requests.get(url)
QtTest.QTest.qWait(2000) QtTest.QTest.qWait(2000)
# Indicator should be visible, have a value of "1" # Indicator should be visible, have a value of "1"
self.assertTrue(self.gui.share_mode.info.indicator_label.isVisible()) self.assertTrue(mode.toggle_history.indicator_label.isVisible())
self.assertEqual(self.gui.share_mode.info.indicator_label.text(), "1") self.assertEqual(mode.toggle_history.indicator_label.text(), "1")
# Toggle history back on, indicator should be hidden again # Toggle history back on, indicator should be hidden again
QtTest.QTest.mouseClick(self.gui.share_mode.info.toggle_button, QtCore.Qt.LeftButton) QtTest.QTest.mouseClick(mode.toggle_history, QtCore.Qt.LeftButton)
self.assertFalse(self.gui.share_mode.info.indicator_label.isVisible()) self.assertFalse(mode.toggle_history.indicator_label.isVisible())
def test_history_is_not_visible(self, mode): def test_history_is_not_visible(self, mode):
'''Test that the History section is not visible''' '''Test that the History section is not visible'''
if mode == 'receive': self.assertFalse(mode.history.isVisible())
self.assertFalse(self.gui.receive_mode.uploads.isVisible())
if mode == 'share':
self.assertFalse(self.gui.share_mode.downloads.isVisible())
def test_history_is_visible(self, mode): def test_history_is_visible(self, mode):
'''Test that the History section is visible''' '''Test that the History section is visible'''
if mode == 'receive': self.assertTrue(mode.history.isVisible())
self.assertTrue(self.gui.receive_mode.uploads.isVisible())
if mode == 'share':
self.assertTrue(self.gui.share_mode.downloads.isVisible())
def test_server_working_on_start_button_pressed(self, mode): def test_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 # Should be in SERVER_WORKING state
if mode == 'receive': QtTest.QTest.mouseClick(mode.server_status.server_button, QtCore.Qt.LeftButton)
QtTest.QTest.mouseClick(self.gui.receive_mode.server_status.server_button, QtCore.Qt.LeftButton) self.assertEqual(mode.server_status.status, 1)
self.assertEqual(self.gui.receive_mode.server_status.status, 1)
if mode == 'share':
QtTest.QTest.mouseClick(self.gui.share_mode.server_status.server_button, QtCore.Qt.LeftButton)
self.assertEqual(self.gui.share_mode.server_status.status, 1)
def test_server_status_indicator_says_starting(self, mode): def test_server_status_indicator_says_starting(self, mode):
'''Test that the Server Status indicator shows we are Starting''' '''Test that the Server Status indicator shows we are Starting'''
if mode == 'receive': self.assertEquals(mode.server_status_label.text(), strings._('gui_status_indicator_share_working', True))
self.assertEquals(self.gui.receive_mode.server_status_label.text(), strings._('gui_status_indicator_share_working', True))
if mode == 'share':
self.assertEquals(self.gui.share_mode.server_status_label.text(), strings._('gui_status_indicator_share_working', True))
def test_settings_button_is_hidden(self): def test_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'''
@ -144,10 +105,7 @@ class CommonTests(object):
'''Test that the server has started''' '''Test that the server has started'''
QtTest.QTest.qWait(2000) QtTest.QTest.qWait(2000)
# Should now be in SERVER_STARTED state # Should now be in SERVER_STARTED state
if mode == 'receive': self.assertEqual(mode.server_status.status, 2)
self.assertEqual(self.gui.receive_mode.server_status.status, 2)
if mode == 'share':
self.assertEqual(self.gui.share_mode.server_status.status, 2)
def test_a_web_server_is_running(self): def test_a_web_server_is_running(self):
'''Test that the web server has started''' '''Test that the web server has started'''
@ -157,38 +115,26 @@ class CommonTests(object):
def test_have_a_slug(self, mode, public_mode): def test_have_a_slug(self, mode, public_mode):
'''Test that we have a valid slug''' '''Test that we have a valid slug'''
if mode == 'receive': if not public_mode:
if not public_mode: self.assertRegex(mode.server_status.web.slug, r'(\w+)-(\w+)')
self.assertRegex(self.gui.receive_mode.server_status.web.slug, r'(\w+)-(\w+)') else:
else: self.assertIsNone(mode.server_status.web.slug, r'(\w+)-(\w+)')
self.assertIsNone(self.gui.receive_mode.server_status.web.slug, r'(\w+)-(\w+)')
if mode == 'share':
if not public_mode:
self.assertRegex(self.gui.share_mode.server_status.web.slug, r'(\w+)-(\w+)')
else:
self.assertIsNone(self.gui.share_mode.server_status.web.slug, r'(\w+)-(\w+)')
def test_url_description_shown(self, mode): def test_url_description_shown(self, mode):
'''Test that the URL label is showing''' '''Test that the URL label is showing'''
if mode == 'receive': self.assertTrue(mode.server_status.url_description.isVisible())
self.assertTrue(self.gui.receive_mode.server_status.url_description.isVisible())
if mode == 'share':
self.assertTrue(self.gui.share_mode.server_status.url_description.isVisible())
def test_have_copy_url_button(self, mode): def test_have_copy_url_button(self, mode):
'''Test that the Copy URL button is shown''' '''Test that the Copy URL button is shown'''
if mode == 'receive': self.assertTrue(mode.server_status.copy_url_button.isVisible())
self.assertTrue(self.gui.receive_mode.server_status.copy_url_button.isVisible())
if mode == 'share':
self.assertTrue(self.gui.share_mode.server_status.copy_url_button.isVisible())
def test_server_status_indicator_says_started(self, mode): def test_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 mode == 'receive': if type(mode) == ReceiveMode:
self.assertEquals(self.gui.receive_mode.server_status_label.text(), strings._('gui_status_indicator_receive_started', True)) self.assertEquals(mode.server_status_label.text(), strings._('gui_status_indicator_receive_started', True))
if mode == 'share': if type(mode) == ShareMode:
self.assertEquals(self.gui.receive_mode.server_status_label.text(), strings._('gui_status_indicator_share_started', True)) self.assertEquals(mode.server_status_label.text(), strings._('gui_status_indicator_share_started', True))
def test_web_page(self, mode, string, public_mode): def test_web_page(self, mode, string, public_mode):
'''Test that the web page contains a string''' '''Test that the web page contains a string'''
@ -197,10 +143,7 @@ class CommonTests(object):
s.connect(('127.0.0.1', self.gui.app.port)) s.connect(('127.0.0.1', self.gui.app.port))
if not public_mode: if not public_mode:
if mode == 'receive': path = '/{}'.format(mode.server_status.web.slug)
path = '/{}'.format(self.gui.receive_mode.server_status.web.slug)
if mode == 'share':
path = '/{}'.format(self.gui.share_mode.server_status.web.slug)
else: else:
path = '/' path = '/'
@ -223,29 +166,18 @@ class CommonTests(object):
def test_history_widgets_present(self, mode): def test_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'''
if mode == 'receive': self.assertFalse(mode.history.empty.isVisible())
self.assertFalse(self.gui.receive_mode.uploads.empty.isVisible()) self.assertTrue(mode.history.not_empty.isVisible())
self.assertTrue(self.gui.receive_mode.uploads.not_empty.isVisible())
if mode == 'share':
self.assertFalse(self.gui.share_mode.downloads.empty.isVisible())
self.assertTrue(self.gui.share_mode.downloads.not_empty.isVisible())
def test_counter_incremented(self, mode, count): def test_counter_incremented(self, mode, count):
'''Test that the counter has incremented''' '''Test that the counter has incremented'''
if mode == 'receive': self.assertEquals(mode.uploads_completed, count)
self.assertEquals(self.gui.receive_mode.uploads_completed, count)
if mode == 'share':
self.assertEquals(self.gui.share_mode.downloads_completed, count)
def test_server_is_stopped(self, mode, stay_open): def test_server_is_stopped(self, mode, stay_open):
'''Test that the server stops when we click Stop''' '''Test that the server stops when we click Stop'''
if mode == 'receive': if type(mode) == ReceiveMode or (type(mode) == ShareMode and stay_open):
QtTest.QTest.mouseClick(self.gui.receive_mode.server_status.server_button, QtCore.Qt.LeftButton) QtTest.QTest.mouseClick(mode.server_status.server_button, QtCore.Qt.LeftButton)
self.assertEquals(self.gui.receive_mode.server_status.status, 0) self.assertEquals(mode.server_status.status, 0)
if mode == 'share':
if stay_open:
QtTest.QTest.mouseClick(self.gui.share_mode.server_status.server_button, QtCore.Qt.LeftButton)
self.assertEquals(self.gui.share_mode.server_status.status, 0)
def test_web_service_is_stopped(self): def test_web_service_is_stopped(self):
'''Test that the web server also stopped''' '''Test that the web server also stopped'''
@ -257,9 +189,9 @@ class CommonTests(object):
def test_server_status_indicator_says_closed(self, mode, stay_open): def test_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 mode == 'receive': if type(mode) == ReceiveMode:
self.assertEquals(self.gui.receive_mode.server_status_label.text(), strings._('gui_status_indicator_receive_stopped', True)) self.assertEquals(self.gui.receive_mode.server_status_label.text(), strings._('gui_status_indicator_receive_stopped', True))
if mode == 'share': if type(mode) == ShareMode:
if stay_open: if stay_open:
self.assertEquals(self.gui.share_mode.server_status_label.text(), strings._('gui_status_indicator_share_stopped', True)) self.assertEquals(self.gui.share_mode.server_status_label.text(), strings._('gui_status_indicator_share_stopped', True))
else: else:
@ -269,28 +201,18 @@ class CommonTests(object):
def test_set_timeout(self, mode, timeout): def test_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) timer = QtCore.QDateTime.currentDateTime().addSecs(timeout)
if mode == 'receive': mode.server_status.shutdown_timeout.setDateTime(timer)
self.gui.receive_mode.server_status.shutdown_timeout.setDateTime(timer) self.assertTrue(mode.server_status.shutdown_timeout.dateTime(), timer)
self.assertTrue(self.gui.receive_mode.server_status.shutdown_timeout.dateTime(), timer)
if mode == 'share':
self.gui.share_mode.server_status.shutdown_timeout.setDateTime(timer)
self.assertTrue(self.gui.share_mode.server_status.shutdown_timeout.dateTime(), timer)
def test_timeout_widget_hidden(self, mode): def test_timeout_widget_hidden(self, mode):
'''Test that the timeout widget is hidden when share has started''' '''Test that the timeout widget is hidden when share has started'''
if mode == 'receive': self.assertFalse(mode.server_status.shutdown_timeout_container.isVisible())
self.assertFalse(self.gui.receive_mode.server_status.shutdown_timeout_container.isVisible())
if mode == 'share':
self.assertFalse(self.gui.share_mode.server_status.shutdown_timeout_container.isVisible())
def test_server_timed_out(self, mode, wait): def test_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) QtTest.QTest.qWait(wait)
# We should have timed out now # We should have timed out now
if mode == 'receive': self.assertEqual(mode.server_status.status, 0)
self.assertEqual(self.gui.receive_mode.server_status.status, 0)
if mode == 'share':
self.assertEqual(self.gui.share_mode.server_status.status, 0)
# Receive-specific tests # Receive-specific tests
def test_upload_file(self, public_mode, expected_file): def test_upload_file(self, public_mode, expected_file):

38
tests_gui_local/onionshare_share_mode_download_test_public_mode.py
View file

@ -96,21 +96,17 @@ class OnionShareGuiTest(unittest.TestCase):
def test_file_selection_widget_has_a_file(self): def test_file_selection_widget_has_a_file(self):
CommonTests.test_file_selection_widget_has_a_file(self) CommonTests.test_file_selection_widget_has_a_file(self)
@pytest.mark.run(order=6)
def test_info_widget_shows_less(self):
CommonTests.test_info_widget_shows_less(self, 'share')
@pytest.mark.run(order=7) @pytest.mark.run(order=7)
def test_history_is_not_visible(self): def test_history_is_not_visible(self):
CommonTests.test_history_is_not_visible(self, 'share') CommonTests.test_history_is_not_visible(self, self.gui.share_mode)
@pytest.mark.run(order=8) @pytest.mark.run(order=8)
def test_click_toggle_history(self): def test_click_toggle_history(self):
CommonTests.test_click_toggle_history(self, 'share') CommonTests.test_click_toggle_history(self, self.gui.share_mode)
@pytest.mark.run(order=9) @pytest.mark.run(order=9)
def test_history_is_visible(self): def test_history_is_visible(self):
CommonTests.test_history_is_visible(self, 'share') CommonTests.test_history_is_visible(self, self.gui.share_mode)
@pytest.mark.run(order=10) @pytest.mark.run(order=10)
def test_deleting_only_file_hides_delete_button(self): def test_deleting_only_file_hides_delete_button(self):
@ -126,11 +122,11 @@ class OnionShareGuiTest(unittest.TestCase):
@pytest.mark.run(order=13) @pytest.mark.run(order=13)
def test_server_working_on_start_button_pressed(self): def test_server_working_on_start_button_pressed(self):
CommonTests.test_server_working_on_start_button_pressed(self, 'share') CommonTests.test_server_working_on_start_button_pressed(self, self.gui.share_mode)
@pytest.mark.run(order=14) @pytest.mark.run(order=14)
def test_server_status_indicator_says_starting(self): def test_server_status_indicator_says_starting(self):
CommonTests.test_server_status_indicator_says_starting(self, 'share') CommonTests.test_server_status_indicator_says_starting(self, self.gui.share_mode)
@pytest.mark.run(order=15) @pytest.mark.run(order=15)
def test_add_delete_buttons_hidden(self): def test_add_delete_buttons_hidden(self):
@ -142,7 +138,7 @@ class OnionShareGuiTest(unittest.TestCase):
@pytest.mark.run(order=17) @pytest.mark.run(order=17)
def test_a_server_is_started(self): def test_a_server_is_started(self):
CommonTests.test_a_server_is_started(self, 'share') CommonTests.test_a_server_is_started(self, self.gui.share_mode)
@pytest.mark.run(order=18) @pytest.mark.run(order=18)
def test_a_web_server_is_running(self): def test_a_web_server_is_running(self):
@ -150,23 +146,23 @@ class OnionShareGuiTest(unittest.TestCase):
@pytest.mark.run(order=19) @pytest.mark.run(order=19)
def test_have_a_slug(self): def test_have_a_slug(self):
CommonTests.test_have_a_slug(self, 'share', True) CommonTests.test_have_a_slug(self, self.gui.share_mode, True)
@pytest.mark.run(order=20) @pytest.mark.run(order=20)
def test_url_description_shown(self): def test_url_description_shown(self):
CommonTests.test_url_description_shown(self, 'share') CommonTests.test_url_description_shown(self, self.gui.share_mode)
@pytest.mark.run(order=21) @pytest.mark.run(order=21)
def test_have_copy_url_button(self): def test_have_copy_url_button(self):
CommonTests.test_have_copy_url_button(self, 'share') CommonTests.test_have_copy_url_button(self, self.gui.share_mode)
@pytest.mark.run(order=22) @pytest.mark.run(order=22)
def test_server_status_indicator_says_started(self): def test_server_status_indicator_says_started(self):
CommonTests.test_server_status_indicator_says_started(self, 'share') CommonTests.test_server_status_indicator_says_started(self, self.gui.share_mode)
@pytest.mark.run(order=23) @pytest.mark.run(order=23)
def test_web_page(self): def test_web_page(self):
CommonTests.test_web_page(self, 'share', 'Total size', True) CommonTests.test_web_page(self, self.gui.share_mode, 'Total size', True)
@pytest.mark.run(order=24) @pytest.mark.run(order=24)
def test_download_share(self): def test_download_share(self):
@ -174,11 +170,11 @@ class OnionShareGuiTest(unittest.TestCase):
@pytest.mark.run(order=25) @pytest.mark.run(order=25)
def test_history_widgets_present(self): def test_history_widgets_present(self):
CommonTests.test_history_widgets_present(self, 'share') CommonTests.test_history_widgets_present(self, self.gui.share_mode)
@pytest.mark.run(order=26) @pytest.mark.run(order=26)
def test_server_is_stopped(self): def test_server_is_stopped(self):
CommonTests.test_server_is_stopped(self, 'share', False) CommonTests.test_server_is_stopped(self, self.gui.share_mode, False)
@pytest.mark.run(order=27) @pytest.mark.run(order=27)
def test_web_service_is_stopped(self): def test_web_service_is_stopped(self):
@ -186,7 +182,7 @@ class OnionShareGuiTest(unittest.TestCase):
@pytest.mark.run(order=28) @pytest.mark.run(order=28)
def test_server_status_indicator_says_closed(self): def test_server_status_indicator_says_closed(self):
CommonTests.test_server_status_indicator_says_closed(self, 'share', False) CommonTests.test_server_status_indicator_says_closed(self, self.gui.share_mode, False)
@pytest.mark.run(order=29) @pytest.mark.run(order=29)
def test_add_button_visible(self): def test_add_button_visible(self):
@ -194,9 +190,9 @@ class OnionShareGuiTest(unittest.TestCase):
@pytest.mark.run(order=30) @pytest.mark.run(order=30)
def test_history_indicator(self): def test_history_indicator(self):
CommonTests.test_server_working_on_start_button_pressed(self, 'share') CommonTests.test_server_working_on_start_button_pressed(self, self.gui.share_mode)
CommonTests.test_a_server_is_started(self, 'share') CommonTests.test_a_server_is_started(self, self.gui.share_mode)
CommonTests.test_history_indicator(self, 'share', True) CommonTests.test_history_indicator(self, self.gui.share_mode, True)
if __name__ == "__main__": if __name__ == "__main__":