commit a7fbfadee6e11c270a37e93c4d67363bbbcd6629 Author: Illia Volochii illia.volochii@gmail.com Date: Thu May 21 23:25:38 2020 +0300

Make `test.runner.Runner.get_tor_controller` synchronous --- test/integ/connection/authentication.py | 9 +- test/integ/control/controller.py | 245 +++++++++++++------------------- test/integ/manual.py | 6 +- test/runner.py | 2 +- 4 files changed, 106 insertions(+), 156 deletions(-)

diff --git a/test/integ/connection/authentication.py b/test/integ/connection/authentication.py index 3eaae8d9..3709c275 100644 --- a/test/integ/connection/authentication.py +++ b/test/integ/connection/authentication.py @@ -121,7 +121,7 @@ class TestAuthenticate(unittest.TestCase):

runner = test.runner.get_runner()

- with await runner.get_tor_controller(False) as controller: + with runner.get_tor_controller(False) as controller: asyncio.run_coroutine_threadsafe( stem.connection.authenticate(controller._wrapped_instance, test.runner.CONTROL_PASSWORD, runner.get_chroot()), controller._thread_for_wrapped_class.loop, @@ -276,8 +276,7 @@ class TestAuthenticate(unittest.TestCase): await self._check_auth(auth_type, auth_value)

@test.require.controller - @async_test - async def test_wrong_password_with_controller(self): + def test_wrong_password_with_controller(self): """ We ran into a race condition where providing the wrong password to the Controller caused inconsistent responses. Checking for that... @@ -291,9 +290,9 @@ class TestAuthenticate(unittest.TestCase): self.skipTest('(requires only password auth)')

for i in range(10): - with await runner.get_tor_controller(False) as controller: + with runner.get_tor_controller(False) as controller: with self.assertRaises(stem.connection.IncorrectPassword): - await controller.authenticate('wrong_password') + controller.authenticate('wrong_password')

@test.require.controller @async_test diff --git a/test/integ/control/controller.py b/test/integ/control/controller.py index b1772f34..7853d407 100644 --- a/test/integ/control/controller.py +++ b/test/integ/control/controller.py @@ -38,14 +38,13 @@ TEST_ROUTER_STATUS_ENTRY = None class TestController(unittest.TestCase): @test.require.only_run_once @test.require.controller - @async_test - async def test_missing_capabilities(self): + def test_missing_capabilities(self): """ Check to see if tor supports any events, signals, or features that we don't. """

- with await test.runner.get_runner().get_tor_controller() as controller: + with test.runner.get_runner().get_tor_controller() as controller: for event in controller.get_info('events/names').split(): if event not in EventType: test.register_new_capability('Event', event) @@ -89,7 +88,7 @@ class TestController(unittest.TestCase): Checks that a notificiation listener is... well, notified of SIGHUPs. """

- with await test.runner.get_runner().get_tor_controller() as controller: + with test.runner.get_runner().get_tor_controller() as controller: received_events = []

def status_listener(my_controller, state, timestamp): @@ -120,8 +119,7 @@ class TestController(unittest.TestCase): controller.reset_conf('__OwningControllerProcess')

@test.require.controller - @async_test - async def test_event_handling(self): + def test_event_handling(self): """ Add a couple listeners for various events and make sure that they receive them. Then remove the listeners. @@ -140,7 +138,7 @@ class TestController(unittest.TestCase):

runner = test.runner.get_runner()

- with await runner.get_tor_controller() as controller: + with runner.get_tor_controller() as controller: controller.add_event_listener(listener1, EventType.CONF_CHANGED) controller.add_event_listener(listener2, EventType.CONF_CHANGED, EventType.DEBUG)

@@ -179,8 +177,7 @@ class TestController(unittest.TestCase): controller.reset_conf('NodeFamily')

@test.require.controller - @async_test - async def test_reattaching_listeners(self): + def test_reattaching_listeners(self): """ Checks that event listeners are re-attached when a controller disconnects then reconnects to tor. @@ -195,7 +192,7 @@ class TestController(unittest.TestCase):

runner = test.runner.get_runner()

- with await runner.get_tor_controller() as controller: + with runner.get_tor_controller() as controller: controller.add_event_listener(listener, EventType.CONF_CHANGED)

# trigger an event @@ -221,15 +218,14 @@ class TestController(unittest.TestCase): controller.reset_conf('NodeFamily')

@test.require.controller - @async_test - async def test_getinfo(self): + def test_getinfo(self): """ Exercises GETINFO with valid and invalid queries. """

runner = test.runner.get_runner()

- with await runner.get_tor_controller() as controller: + with runner.get_tor_controller() as controller: # successful single query

torrc_path = runner.get_torrc_path() @@ -260,13 +256,12 @@ class TestController(unittest.TestCase): self.assertEqual({}, controller.get_info([], {}))

@test.require.controller - @async_test - async def test_getinfo_freshrelaydescs(self): + def test_getinfo_freshrelaydescs(self): """ Exercises 'GETINFO status/fresh-relay-descs'. """

- with await test.runner.get_runner().get_tor_controller() as controller: + with test.runner.get_runner().get_tor_controller() as controller: response = controller.get_info('status/fresh-relay-descs') div = response.find('\nextra-info ') nickname = controller.get_conf('Nickname') @@ -284,13 +279,12 @@ class TestController(unittest.TestCase):

@test.require.controller @test.require.online - @async_test - async def test_getinfo_dir_status(self): + def test_getinfo_dir_status(self): """ Exercise 'GETINFO dir/status-vote/*'. """

- with await test.runner.get_runner().get_tor_controller() as controller: + with test.runner.get_runner().get_tor_controller() as controller: consensus = controller.get_info('dir/status-vote/current/consensus') self.assertTrue('moria1' in consensus, 'moria1 not found in the consensus')

@@ -299,26 +293,24 @@ class TestController(unittest.TestCase): self.assertTrue('moria1' in microdescs, 'moria1 not found in the microdescriptor consensus')

@test.require.controller - @async_test - async def test_get_version(self): + def test_get_version(self): """ Test that the convenient method get_version() works. """

- with await test.runner.get_runner().get_tor_controller() as controller: + with test.runner.get_runner().get_tor_controller() as controller: version = controller.get_version() self.assertTrue(isinstance(version, stem.version.Version)) self.assertEqual(version, test.tor_version())

@test.require.controller - @async_test - async def test_get_exit_policy(self): + def test_get_exit_policy(self): """ Sanity test for get_exit_policy(). Our 'ExitRelay 0' torrc entry causes us to have a simple reject-all policy. """

- with await test.runner.get_runner().get_tor_controller() as controller: + with test.runner.get_runner().get_tor_controller() as controller: self.assertEqual(ExitPolicy('reject *:*'), controller.get_exit_policy())

@test.require.controller @@ -330,20 +322,19 @@ class TestController(unittest.TestCase):

runner = test.runner.get_runner()

- with await runner.get_tor_controller(False) as controller: + with runner.get_tor_controller(False) as controller: controller.authenticate(test.runner.CONTROL_PASSWORD) await test.runner.exercise_controller(self, controller)

@test.require.controller - @async_test - async def test_protocolinfo(self): + def test_protocolinfo(self): """ Test that the convenient method protocolinfo() works. """

runner = test.runner.get_runner()

- with await runner.get_tor_controller(False) as controller: + with runner.get_tor_controller(False) as controller: protocolinfo = controller.get_protocolinfo() self.assertTrue(isinstance(protocolinfo, stem.response.protocolinfo.ProtocolInfoResponse))

@@ -364,15 +355,14 @@ class TestController(unittest.TestCase): self.assertEqual(tuple(auth_methods), protocolinfo.auth_methods)

@test.require.controller - @async_test - async def test_getconf(self): + def test_getconf(self): """ Exercises GETCONF with valid and invalid queries. """

runner = test.runner.get_runner()

- with await runner.get_tor_controller() as controller: + with runner.get_tor_controller() as controller: control_socket = controller.get_socket()

if isinstance(control_socket, stem.socket.ControlPort): @@ -428,15 +418,14 @@ class TestController(unittest.TestCase): self.assertEqual({}, controller.get_conf_map([], 'la-di-dah'))

@test.require.controller - @async_test - async def test_is_set(self): + def test_is_set(self): """ Exercises our is_set() method. """

runner = test.runner.get_runner()

- with await runner.get_tor_controller() as controller: + with runner.get_tor_controller() as controller: custom_options = controller._execute_async_method('_get_custom_options') self.assertTrue('ControlPort' in custom_options or 'ControlSocket' in custom_options) self.assertEqual('1', custom_options['DownloadExtraInfo']) @@ -456,8 +445,7 @@ class TestController(unittest.TestCase): self.assertFalse(controller.is_set('ConnLimit'))

@test.require.controller - @async_test - async def test_hidden_services_conf(self): + def test_hidden_services_conf(self): """ Exercises the hidden service family of methods (get_hidden_service_conf, set_hidden_service_conf, create_hidden_service, and remove_hidden_service). @@ -471,7 +459,7 @@ class TestController(unittest.TestCase): service3_path = os.path.join(test_dir, 'test_hidden_service3') service4_path = os.path.join(test_dir, 'test_hidden_service4')

- with await runner.get_tor_controller() as controller: + with runner.get_tor_controller() as controller: try: # initially we shouldn't be running any hidden services

@@ -565,35 +553,32 @@ class TestController(unittest.TestCase): pass

@test.require.controller - @async_test - async def test_without_ephemeral_hidden_services(self): + def test_without_ephemeral_hidden_services(self): """ Exercises ephemeral hidden service methods when none are present. """

- with await test.runner.get_runner().get_tor_controller() as controller: + with test.runner.get_runner().get_tor_controller() as controller: self.assertEqual([], controller.list_ephemeral_hidden_services()) self.assertEqual([], controller.list_ephemeral_hidden_services(detached = True)) self.assertEqual(False, controller.remove_ephemeral_hidden_service('gfzprpioee3hoppz'))

@test.require.controller - @async_test - async def test_with_invalid_ephemeral_hidden_service_port(self): - with await test.runner.get_runner().get_tor_controller() as controller: + def test_with_invalid_ephemeral_hidden_service_port(self): + with test.runner.get_runner().get_tor_controller() as controller: for ports in (4567890, [4567, 4567890], {4567: '-:4567'}): exc_msg = "ADD_ONION response didn't have an OK status: Invalid VIRTPORT/TARGET" self.assertRaisesWith(stem.ProtocolError, exc_msg, controller.create_ephemeral_hidden_service, ports)

@test.require.controller - @async_test - async def test_ephemeral_hidden_services_v2(self): + def test_ephemeral_hidden_services_v2(self): """ Exercises creating v2 ephemeral hidden services. """

runner = test.runner.get_runner()

- with await runner.get_tor_controller() as controller: + with runner.get_tor_controller() as controller: response = controller.create_ephemeral_hidden_service(4567, key_content = 'RSA1024') self.assertEqual([response.service_id], controller.list_ephemeral_hidden_services()) self.assertTrue(response.private_key is not None) @@ -625,20 +610,19 @@ class TestController(unittest.TestCase):

# other controllers shouldn't be able to see these hidden services

- with await runner.get_tor_controller() as second_controller: + with runner.get_tor_controller() as second_controller: self.assertEqual(2, len(controller.list_ephemeral_hidden_services())) self.assertEqual(0, len(second_controller.list_ephemeral_hidden_services()))

@test.require.controller - @async_test - async def test_ephemeral_hidden_services_v3(self): + def test_ephemeral_hidden_services_v3(self): """ Exercises creating v3 ephemeral hidden services. """

runner = test.runner.get_runner()

- with await runner.get_tor_controller() as controller: + with runner.get_tor_controller() as controller: response = controller.create_ephemeral_hidden_service(4567, key_content = 'ED25519-V3') self.assertEqual([response.service_id], controller.list_ephemeral_hidden_services()) self.assertTrue(response.private_key is not None) @@ -670,20 +654,19 @@ class TestController(unittest.TestCase):

# other controllers shouldn't be able to see these hidden services

- with await runner.get_tor_controller() as second_controller: + with runner.get_tor_controller() as second_controller: self.assertEqual(2, len(controller.list_ephemeral_hidden_services())) self.assertEqual(0, len(second_controller.list_ephemeral_hidden_services()))

@test.require.controller - @async_test - async def test_with_ephemeral_hidden_services_basic_auth(self): + def test_with_ephemeral_hidden_services_basic_auth(self): """ Exercises creating ephemeral hidden services that uses basic authentication. """

runner = test.runner.get_runner()

- with await runner.get_tor_controller() as controller: + with runner.get_tor_controller() as controller: response = controller.create_ephemeral_hidden_service(4567, key_content = 'RSA1024', basic_auth = {'alice': 'nKwfvVPmTNr2k2pG0pzV4g', 'bob': None}) self.assertEqual([response.service_id], controller.list_ephemeral_hidden_services()) self.assertTrue(response.private_key is not None) @@ -695,8 +678,7 @@ class TestController(unittest.TestCase): self.assertEqual([], controller.list_ephemeral_hidden_services())

@test.require.controller - @async_test - async def test_with_ephemeral_hidden_services_basic_auth_no_credentials(self): + def test_with_ephemeral_hidden_services_basic_auth_no_credentials(self): """ Exercises creating ephemeral hidden services when attempting to use basic auth but not including any credentials. @@ -704,13 +686,12 @@ class TestController(unittest.TestCase):

runner = test.runner.get_runner()

- with await runner.get_tor_controller() as controller: + with runner.get_tor_controller() as controller: exc_msg = "ADD_ONION response didn't have an OK status: No auth clients specified" self.assertRaisesWith(stem.ProtocolError, exc_msg, controller.create_ephemeral_hidden_service, 4567, basic_auth = {})

@test.require.controller - @async_test - async def test_with_detached_ephemeral_hidden_services(self): + def test_with_detached_ephemeral_hidden_services(self): """ Exercises creating detached ephemeral hidden services and methods when they're present. @@ -718,7 +699,7 @@ class TestController(unittest.TestCase):

runner = test.runner.get_runner()

- with await runner.get_tor_controller() as controller: + with runner.get_tor_controller() as controller: response = controller.create_ephemeral_hidden_service(4567, detached = True) self.assertEqual([], controller.list_ephemeral_hidden_services()) self.assertEqual([response.service_id], controller.list_ephemeral_hidden_services(detached = True)) @@ -732,7 +713,7 @@ class TestController(unittest.TestCase):

# other controllers should be able to see this service, and drop it

- with await runner.get_tor_controller() as second_controller: + with runner.get_tor_controller() as second_controller: self.assertEqual([response.service_id], second_controller.list_ephemeral_hidden_services(detached = True)) self.assertEqual(True, second_controller.remove_ephemeral_hidden_service(response.service_id)) self.assertEqual([], controller.list_ephemeral_hidden_services(detached = True)) @@ -745,8 +726,7 @@ class TestController(unittest.TestCase): controller.remove_ephemeral_hidden_service(response.service_id)

@test.require.controller - @async_test - async def test_rejecting_unanonymous_hidden_services_creation(self): + def test_rejecting_unanonymous_hidden_services_creation(self): """ Attempt to create a non-anonymous hidden service despite not setting HiddenServiceSingleHopMode and HiddenServiceNonAnonymousMode. @@ -754,12 +734,11 @@ class TestController(unittest.TestCase):

runner = test.runner.get_runner()

- with await runner.get_tor_controller() as controller: + with runner.get_tor_controller() as controller: self.assertEqual('Tor is in anonymous hidden service mode', str(controller.msg('ADD_ONION NEW:BEST Flags=NonAnonymous Port=4567')))

@test.require.controller - @async_test - async def test_set_conf(self): + def test_set_conf(self): """ Exercises set_conf(), reset_conf(), and set_options() methods with valid and invalid requests. @@ -769,7 +748,7 @@ class TestController(unittest.TestCase):

with tempfile.TemporaryDirectory() as tmpdir:

- with await runner.get_tor_controller() as controller: + with runner.get_tor_controller() as controller: try: # successfully set a single option connlimit = int(controller.get_conf('ConnLimit')) @@ -832,14 +811,13 @@ class TestController(unittest.TestCase): ), reset = True)

@test.require.controller - @async_test - async def test_set_conf_for_usebridges(self): + def test_set_conf_for_usebridges(self): """ Ensure we can set UseBridges=1 and also set a Bridge. This is a tor regression check (:trac:`31945`). """

- with await test.runner.get_runner().get_tor_controller() as controller: + with test.runner.get_runner().get_tor_controller() as controller: orport = controller.get_conf('ORPort')

try: @@ -856,26 +834,24 @@ class TestController(unittest.TestCase): ), reset = True)

@test.require.controller - @async_test - async def test_set_conf_when_immutable(self): + def test_set_conf_when_immutable(self): """ Issue a SETCONF for tor options that cannot be changed while running. """

- with await test.runner.get_runner().get_tor_controller() as controller: + with test.runner.get_runner().get_tor_controller() as controller: self.assertRaisesWith(stem.InvalidArguments, "DisableAllSwap cannot be changed while tor's running", controller.set_conf, 'DisableAllSwap', '1') self.assertRaisesWith(stem.InvalidArguments, "DisableAllSwap, User cannot be changed while tor's running", controller.set_options, {'User': 'atagar', 'DisableAllSwap': '1'})

@test.require.controller - @async_test - async def test_loadconf(self): + def test_loadconf(self): """ Exercises Controller.load_conf with valid and invalid requests. """

runner = test.runner.get_runner()

- with await runner.get_tor_controller() as controller: + with runner.get_tor_controller() as controller: oldconf = runner.get_torrc_contents()

try: @@ -905,13 +881,12 @@ class TestController(unittest.TestCase): controller.reset_conf('__OwningControllerProcess')

@test.require.controller - @async_test - async def test_saveconf(self): + def test_saveconf(self): runner = test.runner.get_runner()

# only testing for success, since we need to run out of disk space to test # for failure - with await runner.get_tor_controller() as controller: + with runner.get_tor_controller() as controller: oldconf = runner.get_torrc_contents()

try: @@ -926,15 +901,14 @@ class TestController(unittest.TestCase): controller.reset_conf('__OwningControllerProcess')

@test.require.controller - @async_test - async def test_get_ports(self): + def test_get_ports(self): """ Test Controller.get_ports against a running tor instance. """

runner = test.runner.get_runner()

- with await runner.get_tor_controller() as controller: + with runner.get_tor_controller() as controller: self.assertEqual([test.runner.ORPORT], controller.get_ports(Listener.OR)) self.assertEqual([], controller.get_ports(Listener.DIR)) self.assertEqual([test.runner.SOCKS_PORT], controller.get_ports(Listener.SOCKS)) @@ -948,15 +922,14 @@ class TestController(unittest.TestCase): self.assertEqual([], controller.get_ports(Listener.CONTROL))

@test.require.controller - @async_test - async def test_get_listeners(self): + def test_get_listeners(self): """ Test Controller.get_listeners against a running tor instance. """

runner = test.runner.get_runner()

- with await runner.get_tor_controller() as controller: + with runner.get_tor_controller() as controller: self.assertEqual([('0.0.0.0', test.runner.ORPORT)], controller.get_listeners(Listener.OR)) self.assertEqual([], controller.get_listeners(Listener.DIR)) self.assertEqual([('127.0.0.1', test.runner.SOCKS_PORT)], controller.get_listeners(Listener.SOCKS)) @@ -972,15 +945,14 @@ class TestController(unittest.TestCase): @test.require.controller @test.require.online @test.require.version(stem.version.Version('0.1.2.2-alpha')) - @async_test - async def test_enable_feature(self): + def test_enable_feature(self): """ Test Controller.enable_feature with valid and invalid inputs. """

runner = test.runner.get_runner()

- with await runner.get_tor_controller() as controller: + with runner.get_tor_controller() as controller: self.assertTrue(controller.is_feature_enabled('VERBOSE_NAMES')) self.assertRaises(stem.InvalidArguments, controller.enable_feature, ['NOT', 'A', 'FEATURE'])

@@ -992,13 +964,12 @@ class TestController(unittest.TestCase): self.fail()

@test.require.controller - @async_test - async def test_signal(self): + def test_signal(self): """ Test controller.signal with valid and invalid signals. """

- with await test.runner.get_runner().get_tor_controller() as controller: + with test.runner.get_runner().get_tor_controller() as controller: # valid signal controller.signal('CLEARDNSCACHE')

@@ -1006,13 +977,12 @@ class TestController(unittest.TestCase): self.assertRaises(stem.InvalidArguments, controller.signal, 'FOOBAR')

@test.require.controller - @async_test - async def test_newnym_availability(self): + def test_newnym_availability(self): """ Test the is_newnym_available and get_newnym_wait methods. """

- with await test.runner.get_runner().get_tor_controller() as controller: + with test.runner.get_runner().get_tor_controller() as controller: self.assertEqual(True, controller.is_newnym_available()) self.assertEqual(0.0, controller.get_newnym_wait())

@@ -1023,9 +993,8 @@ class TestController(unittest.TestCase):

@test.require.controller @test.require.online - @async_test - async def test_extendcircuit(self): - with await test.runner.get_runner().get_tor_controller() as controller: + def test_extendcircuit(self): + with test.runner.get_runner().get_tor_controller() as controller: circuit_id = controller.extend_circuit('0')

# check if our circuit was created @@ -1039,15 +1008,14 @@ class TestController(unittest.TestCase):

@test.require.controller @test.require.online - @async_test - async def test_repurpose_circuit(self): + def test_repurpose_circuit(self): """ Tests Controller.repurpose_circuit with valid and invalid input. """

runner = test.runner.get_runner()

- with await runner.get_tor_controller() as controller: + with runner.get_tor_controller() as controller: circ_id = controller.new_circuit() controller.repurpose_circuit(circ_id, 'CONTROLLER') circuit = controller.get_circuit(circ_id) @@ -1062,15 +1030,14 @@ class TestController(unittest.TestCase):

@test.require.controller @test.require.online - @async_test - async def test_close_circuit(self): + def test_close_circuit(self): """ Tests Controller.close_circuit with valid and invalid input. """

runner = test.runner.get_runner()

- with await runner.get_tor_controller() as controller: + with runner.get_tor_controller() as controller: circuit_id = controller.new_circuit() controller.close_circuit(circuit_id) circuit_output = controller.get_info('circuit-status') @@ -1089,8 +1056,7 @@ class TestController(unittest.TestCase):

@test.require.controller @test.require.online - @async_test - async def test_get_streams(self): + def test_get_streams(self): """ Tests Controller.get_streams(). """ @@ -1099,7 +1065,7 @@ class TestController(unittest.TestCase): port = 443

runner = test.runner.get_runner() - with await runner.get_tor_controller() as controller: + with runner.get_tor_controller() as controller: # we only need one proxy port, so take the first socks_listener = controller.get_listeners(Listener.SOCKS)[0]

@@ -1115,15 +1081,14 @@ class TestController(unittest.TestCase):

@test.require.controller @test.require.online - @async_test - async def test_close_stream(self): + def test_close_stream(self): """ Tests Controller.close_stream with valid and invalid input. """

runner = test.runner.get_runner()

- with await runner.get_tor_controller() as controller: + with runner.get_tor_controller() as controller: # use the first socks listener

socks_listener = controller.get_listeners(Listener.SOCKS)[0] @@ -1155,12 +1120,11 @@ class TestController(unittest.TestCase):

@test.require.controller @test.require.online - @async_test - async def test_mapaddress(self): + def test_mapaddress(self): self.skipTest('(https://trac.torproject.org/projects/tor/ticket/25611)') runner = test.runner.get_runner()

- with await runner.get_tor_controller() as controller: + with runner.get_tor_controller() as controller: controller.map_address({'1.2.1.2': 'ifconfig.me'})

s = None @@ -1194,11 +1158,10 @@ class TestController(unittest.TestCase): self.assertTrue(stem.util.connection.is_valid_ipv4_address(stem.util.str_tools._to_unicode(ip_addr)), "'%s' isn't an address" % ip_addr)

@test.require.controller - @async_test - async def test_mapaddress_offline(self): + def test_mapaddress_offline(self): runner = test.runner.get_runner()

- with await runner.get_tor_controller() as controller: + with runner.get_tor_controller() as controller: # try mapping one element, ensuring results are as expected

map1 = {'1.2.1.2': 'ifconfig.me'} @@ -1274,13 +1237,12 @@ class TestController(unittest.TestCase):

@test.require.controller @test.require.online - @async_test - async def test_get_microdescriptor(self): + def test_get_microdescriptor(self): """ Basic checks for get_microdescriptor(). """

- with await test.runner.get_runner().get_tor_controller() as controller: + with test.runner.get_runner().get_tor_controller() as controller: # we should balk at invalid content self.assertRaises(ValueError, controller.get_microdescriptor, '') self.assertRaises(ValueError, controller.get_microdescriptor, 5) @@ -1299,8 +1261,7 @@ class TestController(unittest.TestCase):

@test.require.controller @test.require.online - @async_test - async def test_get_microdescriptors(self): + def test_get_microdescriptors(self): """ Fetches a few descriptors via the get_microdescriptors() method. """ @@ -1310,7 +1271,7 @@ class TestController(unittest.TestCase): if not os.path.exists(runner.get_test_dir('cached-microdescs')): self.skipTest('(no cached microdescriptors)')

- with await runner.get_tor_controller() as controller: + with runner.get_tor_controller() as controller: count = 0

for desc in controller.get_microdescriptors(): @@ -1322,15 +1283,14 @@ class TestController(unittest.TestCase):

@test.require.controller @test.require.online - @async_test - async def test_get_server_descriptor(self): + def test_get_server_descriptor(self): """ Basic checks for get_server_descriptor(). """

runner = test.runner.get_runner()

- with await runner.get_tor_controller() as controller: + with runner.get_tor_controller() as controller: # we should balk at invalid content self.assertRaises(ValueError, controller.get_server_descriptor, '') self.assertRaises(ValueError, controller.get_server_descriptor, 5) @@ -1349,15 +1309,14 @@ class TestController(unittest.TestCase):

@test.require.controller @test.require.online - @async_test - async def test_get_server_descriptors(self): + def test_get_server_descriptors(self): """ Fetches a few descriptors via the get_server_descriptors() method. """

runner = test.runner.get_runner()

- with await runner.get_tor_controller() as controller: + with runner.get_tor_controller() as controller: count = 0

for desc in controller.get_server_descriptors(): @@ -1375,13 +1334,12 @@ class TestController(unittest.TestCase):

@test.require.controller @test.require.online - @async_test - async def test_get_network_status(self): + def test_get_network_status(self): """ Basic checks for get_network_status(). """

- with await test.runner.get_runner().get_tor_controller() as controller: + with test.runner.get_runner().get_tor_controller() as controller: # we should balk at invalid content self.assertRaises(ValueError, controller.get_network_status, '') self.assertRaises(ValueError, controller.get_network_status, 5) @@ -1400,15 +1358,14 @@ class TestController(unittest.TestCase):

@test.require.controller @test.require.online - @async_test - async def test_get_network_statuses(self): + def test_get_network_statuses(self): """ Fetches a few descriptors via the get_network_statuses() method. """

runner = test.runner.get_runner()

- with await runner.get_tor_controller() as controller: + with runner.get_tor_controller() as controller: count = 0

for desc in controller.get_network_statuses(): @@ -1424,15 +1381,14 @@ class TestController(unittest.TestCase):

@test.require.controller @test.require.online - @async_test - async def test_get_hidden_service_descriptor(self): + def test_get_hidden_service_descriptor(self): """ Fetches a few descriptors via the get_hidden_service_descriptor() method. """

runner = test.runner.get_runner()

- with await runner.get_tor_controller() as controller: + with runner.get_tor_controller() as controller: # fetch the descriptor for DuckDuckGo

desc = controller.get_hidden_service_descriptor('3g2upl4pq6kufc4m.onion') @@ -1450,8 +1406,7 @@ class TestController(unittest.TestCase):

@test.require.controller @test.require.online - @async_test - async def test_attachstream(self): + def test_attachstream(self): host = socket.gethostbyname('www.torproject.org') port = 80

@@ -1461,7 +1416,7 @@ class TestController(unittest.TestCase): if stream.status == 'NEW' and circuit_id: controller.attach_stream(stream.id, circuit_id)

- with await test.runner.get_runner().get_tor_controller() as controller: + with test.runner.get_runner().get_tor_controller() as controller: # try 10 times to build a circuit we can connect through for i in range(10): controller.add_event_listener(handle_streamcreated, stem.control.EventType.STREAM) @@ -1491,26 +1446,24 @@ class TestController(unittest.TestCase):

@test.require.controller @test.require.online - @async_test - async def test_get_circuits(self): + def test_get_circuits(self): """ Fetches circuits via the get_circuits() method. """

- with await test.runner.get_runner().get_tor_controller() as controller: + with test.runner.get_runner().get_tor_controller() as controller: new_circ = controller.new_circuit() circuits = controller.get_circuits() self.assertTrue(new_circ in [circ.id for circ in circuits])

@test.require.controller - @async_test - async def test_transition_to_relay(self): + def test_transition_to_relay(self): """ Transitions Tor to turn into a relay, then back to a client. This helps to catch transition issues such as the one cited in :trac:`14901`. """

- with await test.runner.get_runner().get_tor_controller() as controller: + with test.runner.get_runner().get_tor_controller() as controller: try: controller.reset_conf('OrPort', 'DisableNetwork') self.assertEqual(None, controller.get_conf('OrPort')) diff --git a/test/integ/manual.py b/test/integ/manual.py index d285c758..3e721ac6 100644 --- a/test/integ/manual.py +++ b/test/integ/manual.py @@ -14,7 +14,6 @@ import test import test.runner

from stem.manual import Category -from stem.util.test_tools import async_test

EXPECTED_CATEGORIES = set([ 'NAME', @@ -217,15 +216,14 @@ class TestManual(unittest.TestCase): self.assertEqual(['tor - The second-generation onion router'], categories['NAME']) self.assertEqual(['tor [OPTION value]...'], categories['SYNOPSIS'])

- @async_test - async def test_has_all_tor_config_options(self): + def test_has_all_tor_config_options(self): """ Check that all the configuration options tor supports are in the man page. """

self.requires_downloaded_manual()

- with await test.runner.get_runner().get_tor_controller() as controller: + with test.runner.get_runner().get_tor_controller() as controller: config_options_in_tor = set([line.split()[0] for line in controller.get_info('config/names').splitlines() if line.split()[1] != 'Virtual'])

# options starting with an underscore are hidden by convention diff --git a/test/runner.py b/test/runner.py index 189a2d7b..4f237552 100644 --- a/test/runner.py +++ b/test/runner.py @@ -477,7 +477,7 @@ class Runner(object): def _authenticate_controller(self, controller): controller.authenticate(password=CONTROL_PASSWORD, chroot_path=self.get_chroot())

- async def get_tor_controller(self, authenticate = True): + def get_tor_controller(self, authenticate = True): """ Provides a controller connected to our tor test instance.