Exemple #1
0
class TestControl(unittest.TestCase):
  def setUp(self):
    socket = stem.socket.ControlSocket()

    with patch('stem.control.Controller.add_event_listener', Mock()):
      self.controller = Controller(socket)

  def test_event_description(self):
    self.assertEqual("Logging at the debug runlevel. This is low level, high volume information about tor's internals that generally isn't useful to users.", stem.control.event_description('DEBUG'))
    self.assertEqual('Event emitted every second with the bytes sent and received by tor.', stem.control.event_description('BW'))
    self.assertEqual('Event emitted every second with the bytes sent and received by tor.', stem.control.event_description('bw'))

  def test_event_description_includes_all_events(self):
    self.assertEqual(None, stem.control.event_description('NO_SUCH_EVENT'))

    for event in stem.control.EventType:
      self.assertTrue(stem.control.event_description(event) is not None)

  @patch('stem.control.Controller.msg')
  def test_get_info(self, msg_mock):
    msg_mock.return_value = ControlMessage.from_str('250-hello=hi right back!\r\n250 OK\r\n', 'GETINFO')
    self.assertEqual('hi right back!', self.controller.get_info('hello'))

  @patch('stem.control.Controller.msg')
  def test_get_info_address_caching(self, msg_mock):
    test_start = time.time()
    msg_mock.return_value = ControlMessage.from_str('551 Address unknown\r\n')

    self.assertEqual(0, self.controller._address_cached_at)
    self.assertEqual(None, self.controller._last_address_exc)
    self.assertRaisesRegexp(stem.ProtocolError, 'Address unknown', self.controller.get_info, 'address')
    self.assertTrue(test_start <= self.controller._address_cached_at <= time.time())
    self.assertEqual("GETINFO response didn't have an OK status:\nAddress unknown", str(self.controller._last_address_exc))
    self.assertEqual(1, msg_mock.call_count)

    # now that we have a cached failure we should provide that back

    self.assertRaisesRegexp(stem.ProtocolError, 'Address unknown', self.controller.get_info, 'address')
    self.assertEqual(1, msg_mock.call_count)

    # pretend it's a minute later and try again, now with an address

    msg_mock.return_value = ControlMessage.from_str('250-address=17.2.89.80\r\n250 OK\r\n', 'GETINFO')
    self.assertRaisesRegexp(stem.ProtocolError, 'Address unknown', self.controller.get_info, 'address')
    self.controller._address_cached_at -= 60
    self.assertEqual('17.2.89.80', self.controller.get_info('address'))

  @patch('stem.control.Controller.msg')
  @patch('stem.control.Controller.get_conf')
  def test_get_info_without_fingerprint(self, get_conf_mock, msg_mock):
    msg_mock.return_value = ControlMessage.from_str('551 Not running in server mode\r\n')
    get_conf_mock.return_value = None

    self.assertEqual(None, self.controller._last_fingerprint_exc)
    self.assertRaisesRegexp(stem.ProtocolError, 'Not running in server mode', self.controller.get_info, 'fingerprint')
    self.assertEqual("GETINFO response didn't have an OK status:\nNot running in server mode", str(self.controller._last_fingerprint_exc))
    self.assertEqual(1, msg_mock.call_count)

    # now that we have a cached failure we should provide that back

    self.assertRaisesRegexp(stem.ProtocolError, 'Not running in server mode', self.controller.get_info, 'fingerprint')
    self.assertEqual(1, msg_mock.call_count)

    # ... but if we become a relay we'll call it again

    get_conf_mock.return_value = '443'
    self.assertRaisesRegexp(stem.ProtocolError, 'Not running in server mode', self.controller.get_info, 'fingerprint')
    self.assertEqual(2, msg_mock.call_count)

  @patch('stem.control.Controller.get_info')
  def test_get_version(self, get_info_mock):
    """
    Exercises the get_version() method.
    """

    try:
      # Use one version for first check.
      version_2_1 = '0.2.1.32'
      version_2_1_object = stem.version.Version(version_2_1)
      get_info_mock.return_value = version_2_1

      # Return a version with a cold cache.
      self.assertEqual(version_2_1_object, self.controller.get_version())

      # Use a different version for second check.
      version_2_2 = '0.2.2.39'
      version_2_2_object = stem.version.Version(version_2_2)
      get_info_mock.return_value = version_2_2

      # Return a version with a hot cache, so it will be the old version.
      self.assertEqual(version_2_1_object, self.controller.get_version())

      # Turn off caching.
      self.controller._is_caching_enabled = False
      # Return a version without caching, so it will be the new version.
      self.assertEqual(version_2_2_object, self.controller.get_version())

      # Spec says the getinfo response may optionally be prefixed by 'Tor '. In
      # practice it doesn't but we should accept that.
      get_info_mock.return_value = 'Tor 0.2.1.32'
      self.assertEqual(version_2_1_object, self.controller.get_version())

      # Raise an exception in the get_info() call.
      get_info_mock.side_effect = InvalidArguments

      # Get a default value when the call fails.
      self.assertEqual(
        'default returned',
        self.controller.get_version(default = 'default returned')
      )

      # No default value, accept the error.
      self.assertRaises(InvalidArguments, self.controller.get_version)

      # Give a bad version.  The stem.version.Version ValueError should bubble up.
      version_A_42 = '0.A.42.spam'
      get_info_mock.return_value = version_A_42
      get_info_mock.side_effect = None
      self.assertRaises(ValueError, self.controller.get_version)
    finally:
      # Turn caching back on before we leave.
      self.controller._is_caching_enabled = True

  @patch('stem.control.Controller.get_info')
  @patch('stem.control.Controller.get_conf')
  def test_get_exit_policy(self, get_conf_mock, get_info_mock):
    """
    Exercises the get_exit_policy() method.
    """

    get_conf_mock.side_effect = lambda param, **kwargs: {
      'ExitPolicyRejectPrivate': '1',
      'ExitPolicy': ['accept *:80,   accept *:443', 'accept 43.5.5.5,reject *:22'],
    }[param]

    get_info_mock.side_effect = lambda param, default = None: {
      'address': '123.45.67.89',
      'exit-policy/default': 'reject *:25,reject *:119,reject *:135-139,reject *:445,reject *:563,reject *:1214,reject *:4661-4666,reject *:6346-6429,reject *:6699,reject *:6881-6999,accept *:*',
    }[param]

    expected = ExitPolicy(
      'reject 0.0.0.0/8:*',  # private entries
      'reject 169.254.0.0/16:*',
      'reject 127.0.0.0/8:*',
      'reject 192.168.0.0/16:*',
      'reject 10.0.0.0/8:*',
      'reject 172.16.0.0/12:*',
      'reject 123.45.67.89:*',  # relay's public address
      'accept *:80',  # finally we get to our ExitPolicy
      'accept *:443',
      'accept 43.5.5.5:*',
      'reject *:22',
      'reject *:25',  # default policy
      'reject *:119',
      'reject *:135-139',
      'reject *:445',
      'reject *:563',
      'reject *:1214',
      'reject *:4661-4666',
      'reject *:6346-6429',
      'reject *:6699',
      'reject *:6881-6999',
      'accept *:*',
    )

    self.assertEqual(expected, self.controller.get_exit_policy())

  @patch('stem.control.Controller.get_info')
  @patch('stem.control.Controller.get_conf')
  def test_get_ports(self, get_conf_mock, get_info_mock):
    """
    Exercises the get_ports() and get_listeners() methods.
    """

    # Exercise as an old version of tor that doesn't support the 'GETINFO
    # net/listeners/*' options.

    get_info_mock.side_effect = InvalidArguments

    get_conf_mock.side_effect = lambda param, **kwargs: {
      'ControlPort': '9050',
      'ControlListenAddress': ['127.0.0.1'],
    }[param]

    self.assertEqual([('127.0.0.1', 9050)], self.controller.get_listeners(Listener.CONTROL))
    self.assertEqual([9050], self.controller.get_ports(Listener.CONTROL))
    self.controller.clear_cache()

    # non-local addresss

    get_conf_mock.side_effect = lambda param, **kwargs: {
      'ControlPort': '9050',
      'ControlListenAddress': ['27.4.4.1'],
    }[param]

    self.assertEqual([('27.4.4.1', 9050)], self.controller.get_listeners(Listener.CONTROL))
    self.assertEqual([], self.controller.get_ports(Listener.CONTROL))
    self.controller.clear_cache()

    # exercise via the GETINFO option

    get_info_mock.side_effect = None
    get_info_mock.return_value = '"127.0.0.1:1112" "127.0.0.1:1114"'

    self.assertEqual(
      [('127.0.0.1', 1112), ('127.0.0.1', 1114)],
      self.controller.get_listeners(Listener.CONTROL)
    )

    self.assertEqual([1112, 1114], self.controller.get_ports(Listener.CONTROL))
    self.controller.clear_cache()

    # with all localhost addresses, including a couple that aren't

    get_info_mock.side_effect = None
    get_info_mock.return_value = '"27.4.4.1:1113" "127.0.0.5:1114" "0.0.0.0:1115" "[::]:1116" "[::1]:1117" "[10::]:1118"'

    self.assertEqual([1114, 1115, 1116, 1117], self.controller.get_ports(Listener.OR))
    self.controller.clear_cache()

    # IPv6 address

    get_info_mock.return_value = '"0.0.0.0:9001" "[fe80:0000:0000:0000:0202:b3ff:fe1e:8329]:9001"'

    self.assertEqual(
      [('0.0.0.0', 9001), ('fe80:0000:0000:0000:0202:b3ff:fe1e:8329', 9001)],
      self.controller.get_listeners(Listener.CONTROL)
    )

    # unix socket file

    self.controller.clear_cache()
    get_info_mock.return_value = '"unix:/tmp/tor/socket"'

    self.assertEqual([], self.controller.get_listeners(Listener.CONTROL))
    self.assertEqual([], self.controller.get_ports(Listener.CONTROL))

  @patch('stem.control.Controller.get_info')
  @patch('stem.control.Controller.get_conf')
  def test_get_socks_listeners_old(self, get_conf_mock, get_info_mock):
    """
    Exercises the get_socks_listeners() method as though talking to an old tor
    instance.
    """

    # An old tor raises stem.InvalidArguments for get_info about socks, but
    # get_socks_listeners should work anyway.

    get_info_mock.side_effect = InvalidArguments

    get_conf_mock.side_effect = lambda param, **kwargs: {
      'SocksPort': '9050',
      'SocksListenAddress': ['127.0.0.1'],
    }[param]

    self.assertEqual([('127.0.0.1', 9050)], self.controller.get_socks_listeners())
    self.controller.clear_cache()

    # Again, an old tor, but SocksListenAddress overrides the port number.

    get_conf_mock.side_effect = lambda param, **kwargs: {
      'SocksPort': '9050',
      'SocksListenAddress': ['127.0.0.1:1112'],
    }[param]

    self.assertEqual([('127.0.0.1', 1112)], self.controller.get_socks_listeners())
    self.controller.clear_cache()

    # Again, an old tor, but multiple listeners

    get_conf_mock.side_effect = lambda param, **kwargs: {
      'SocksPort': '9050',
      'SocksListenAddress': ['127.0.0.1:1112', '127.0.0.1:1114'],
    }[param]

    self.assertEqual([('127.0.0.1', 1112), ('127.0.0.1', 1114)], self.controller.get_socks_listeners())
    self.controller.clear_cache()

    # Again, an old tor, but no SOCKS listeners

    get_conf_mock.side_effect = lambda param, **kwargs: {
      'SocksPort': '0',
      'SocksListenAddress': [],
    }[param]

    self.assertEqual([], self.controller.get_socks_listeners())
    self.controller.clear_cache()

    # Where tor provides invalid ports or addresses

    get_conf_mock.side_effect = lambda param, **kwargs: {
      'SocksPort': 'blarg',
      'SocksListenAddress': ['127.0.0.1'],
    }[param]

    self.assertRaises(stem.ProtocolError, self.controller.get_socks_listeners)

    get_conf_mock.side_effect = lambda param, **kwargs: {
      'SocksPort': '0',
      'SocksListenAddress': ['127.0.0.1:abc'],
    }[param]

    self.assertRaises(stem.ProtocolError, self.controller.get_socks_listeners)

    get_conf_mock.side_effect = lambda param, **kwargs: {
      'SocksPort': '40',
      'SocksListenAddress': ['500.0.0.1'],
    }[param]

    self.assertRaises(stem.ProtocolError, self.controller.get_socks_listeners)

  @patch('stem.control.Controller.get_info')
  def test_get_socks_listeners_new(self, get_info_mock):
    """
    Exercises the get_socks_listeners() method as if talking to a newer tor
    instance.
    """

    # multiple SOCKS listeners

    get_info_mock.return_value = '"127.0.0.1:1112" "127.0.0.1:1114"'

    self.assertEqual(
      [('127.0.0.1', 1112), ('127.0.0.1', 1114)],
      self.controller.get_socks_listeners()
    )

    # no SOCKS listeners

    self.controller.clear_cache()
    get_info_mock.return_value = ''
    self.assertEqual([], self.controller.get_socks_listeners())

    # check where GETINFO provides malformed content

    invalid_responses = (
      '"127.0.0.1"',         # address only
      '"1112"',              # port only
      '"5127.0.0.1:1112"',   # invlaid address
      '"127.0.0.1:991112"',  # invalid port
    )

    for response in invalid_responses:
      self.controller.clear_cache()
      get_info_mock.return_value = response
      self.assertRaises(stem.ProtocolError, self.controller.get_socks_listeners)

  @patch('stem.control.Controller.get_info')
  @patch('time.time', Mock(return_value = 1410723598.276578))
  def test_get_accounting_stats(self, get_info_mock):
    """
    Exercises the get_accounting_stats() method.
    """

    get_info_mock.side_effect = lambda param, **kwargs: {
      'accounting/enabled': '1',
      'accounting/hibernating': 'awake',
      'accounting/interval-end': '2014-09-14 19:41:00',
      'accounting/bytes': '4837 2050',
      'accounting/bytes-left': '102944 7440',
    }[param]

    expected = stem.control.AccountingStats(
      1410723598.276578,
      'awake',
      datetime.datetime(2014, 9, 14, 19, 41),
      62,
      4837, 102944, 107781,
      2050, 7440, 9490,
    )

    self.assertEqual(expected, self.controller.get_accounting_stats())

    get_info_mock.side_effect = ControllerError('nope, too bad')
    self.assertRaises(ControllerError, self.controller.get_accounting_stats)
    self.assertEqual('my default', self.controller.get_accounting_stats('my default'))

  @patch('stem.connection.get_protocolinfo')
  def test_get_protocolinfo(self, get_protocolinfo_mock):
    """
    Exercises the get_protocolinfo() method.
    """

    # use the handy mocked protocolinfo response

    protocolinfo_msg = ControlMessage.from_str('250-PROTOCOLINFO 1\r\n250 OK\r\n', 'PROTOCOLINFO')
    get_protocolinfo_mock.return_value = protocolinfo_msg

    # compare the str representation of these object, because the class
    # does not have, nor need, a direct comparison operator

    self.assertEqual(
      str(protocolinfo_msg),
      str(self.controller.get_protocolinfo())
    )

    # raise an exception in the stem.connection.get_protocolinfo() call

    get_protocolinfo_mock.side_effect = ProtocolError

    # get a default value when the call fails

    self.assertEqual(
      'default returned',
      self.controller.get_protocolinfo(default = 'default returned')
    )

    # no default value, accept the error

    self.assertRaises(ProtocolError, self.controller.get_protocolinfo)

  @patch('stem.socket.ControlSocket.is_localhost', Mock(return_value = False))
  def test_get_user_remote(self):
    """
    Exercise the get_user() method for a non-local socket.
    """

    self.assertRaises(ValueError, self.controller.get_user)
    self.assertEqual(123, self.controller.get_user(123))

  @patch('stem.socket.ControlSocket.is_localhost', Mock(return_value = True))
  @patch('stem.control.Controller.get_info', Mock(return_value = 'atagar'))
  def test_get_user_by_getinfo(self):
    """
    Exercise the get_user() resolution via its getinfo option.
    """

    self.assertEqual('atagar', self.controller.get_user())

  @patch('stem.socket.ControlSocket.is_localhost', Mock(return_value = True))
  @patch('stem.util.system.pid_by_name', Mock(return_value = 432))
  @patch('stem.util.system.user', Mock(return_value = 'atagar'))
  def test_get_user_by_system(self):
    """
    Exercise the get_user() resolution via the system module.
    """

    self.assertEqual('atagar', self.controller.get_user())

  @patch('stem.socket.ControlSocket.is_localhost', Mock(return_value = False))
  def test_get_pid_remote(self):
    """
    Exercise the get_pid() method for a non-local socket.
    """

    self.assertRaises(ValueError, self.controller.get_pid)
    self.assertEqual(123, self.controller.get_pid(123))

  @patch('stem.socket.ControlSocket.is_localhost', Mock(return_value = True))
  @patch('stem.control.Controller.get_info', Mock(return_value = '321'))
  def test_get_pid_by_getinfo(self):
    """
    Exercise the get_pid() resolution via its getinfo option.
    """

    self.assertEqual(321, self.controller.get_pid())

  @patch('stem.socket.ControlSocket.is_localhost', Mock(return_value = True))
  @patch('stem.control.Controller.get_conf')
  @patch('stem.control.open', create = True)
  def test_get_pid_by_pid_file(self, open_mock, get_conf_mock):
    """
    Exercise the get_pid() resolution via a PidFile.
    """

    get_conf_mock.return_value = '/tmp/pid_file'
    open_mock.return_value = io.BytesIO(b'432')

    self.assertEqual(432, self.controller.get_pid())
    open_mock.assert_called_once_with('/tmp/pid_file')

  @patch('stem.socket.ControlSocket.is_localhost', Mock(return_value = True))
  @patch('stem.util.system.pid_by_name', Mock(return_value = 432))
  def test_get_pid_by_name(self):
    """
    Exercise the get_pid() resolution via the process name.
    """

    self.assertEqual(432, self.controller.get_pid())

  @patch('stem.control.Controller.get_info')
  def test_get_network_status_for_ourselves(self, get_info_mock):
    """
    Exercises the get_network_status() method for getting our own relay.
    """

    # when there's an issue getting our fingerprint

    get_info_mock.side_effect = ControllerError('nope, too bad')

    exc_msg = 'Unable to determine our own fingerprint: nope, too bad'
    self.assertRaisesRegexp(ControllerError, exc_msg, self.controller.get_network_status)
    self.assertEqual('boom', self.controller.get_network_status(default = 'boom'))

    # successful request

    desc = NS_DESC % ('moria1', '/96bKo4soysolMgKn5Hex2nyFSY')

    get_info_mock.side_effect = lambda param, **kwargs: {
      'fingerprint': '9695DFC35FFEB861329B9F1AB04C46397020CE31',
      'ns/id/9695DFC35FFEB861329B9F1AB04C46397020CE31': desc,
    }[param]

    self.assertEqual(stem.descriptor.router_status_entry.RouterStatusEntryV3(desc), self.controller.get_network_status())

  @patch('stem.control.Controller.get_info')
  def test_get_network_status_when_unavailable(self, get_info_mock):
    """
    Exercises the get_network_status() method.
    """

    get_info_mock.side_effect = InvalidArguments(None, 'GETINFO request contained unrecognized keywords: ns/id/5AC9C5AA75BA1F18D8459B326B4B8111A856D290')

    exc_msg = "Tor was unable to provide the descriptor for '5AC9C5AA75BA1F18D8459B326B4B8111A856D290'"
    self.assertRaisesRegexp(DescriptorUnavailable, exc_msg, self.controller.get_network_status, '5AC9C5AA75BA1F18D8459B326B4B8111A856D290')

  @patch('stem.control.Controller.get_info')
  def test_get_network_status(self, get_info_mock):
    """
    Exercises the get_network_status() method.
    """

    # build a single router status entry

    nickname = 'Beaver'
    fingerprint = '/96bKo4soysolMgKn5Hex2nyFSY'
    desc = NS_DESC % (nickname, fingerprint)
    router = stem.descriptor.router_status_entry.RouterStatusEntryV3(desc)

    # always return the same router status entry

    get_info_mock.return_value = desc

    # pretend to get the router status entry with its name

    self.assertEqual(router, self.controller.get_network_status(nickname))

    # pretend to get the router status entry with its fingerprint

    hex_fingerprint = stem.descriptor.router_status_entry._base64_to_hex(fingerprint, False)
    self.assertEqual(router, self.controller.get_network_status(hex_fingerprint))

    # mangle hex fingerprint and try again

    hex_fingerprint = hex_fingerprint[2:]
    self.assertRaises(ValueError, self.controller.get_network_status, hex_fingerprint)

    # raise an exception in the get_info() call

    get_info_mock.side_effect = InvalidArguments

    # get a default value when the call fails

    self.assertEqual(
      'default returned',
      self.controller.get_network_status(nickname, default = 'default returned')
    )

    # no default value, accept the error

    self.assertRaises(InvalidArguments, self.controller.get_network_status, nickname)

  @patch('stem.control.Controller.is_authenticated', Mock(return_value = True))
  @patch('stem.control.Controller._attach_listeners', Mock(return_value = ([], [])))
  @patch('stem.control.Controller.get_version')
  def test_event_listening(self, get_version_mock):
    """
    Exercises the add_event_listener and remove_event_listener methods.
    """

    # set up for failure to create any events

    get_version_mock.return_value = stem.version.Version('0.1.0.14')
    self.assertRaises(InvalidRequest, self.controller.add_event_listener, Mock(), EventType.BW)

    # set up to only fail newer events

    get_version_mock.return_value = stem.version.Version('0.2.0.35')

    # EventType.BW is one of the earliest events

    self.controller.add_event_listener(Mock(), EventType.BW)

    # EventType.SIGNAL was added in tor version 0.2.3.1-alpha
    self.assertRaises(InvalidRequest, self.controller.add_event_listener, Mock(), EventType.SIGNAL)

  def test_get_streams(self):
    """
    Exercises the get_streams() method.
    """

    # get a list of fake, but good looking, streams
    valid_streams = (
      ('1', 'NEW', '4', '10.10.10.1:80'),
      ('2', 'SUCCEEDED', '4', '10.10.10.1:80'),
      ('3', 'SUCCEEDED', '4', '10.10.10.1:80')
    )

    response = ''.join(['%s\r\n' % ' '.join(entry) for entry in valid_streams])

    with patch('stem.control.Controller.get_info', Mock(return_value = response)):
      streams = self.controller.get_streams()
      self.assertEqual(len(valid_streams), len(streams))

      for index, stream in enumerate(streams):
        self.assertEqual(valid_streams[index][0], stream.id)
        self.assertEqual(valid_streams[index][1], stream.status)
        self.assertEqual(valid_streams[index][2], stream.circ_id)
        self.assertEqual(valid_streams[index][3], stream.target)

  def test_attach_stream(self):
    """
    Exercises the attach_stream() method.
    """

    # Response when the stream is in a state where it can't be attached (for
    # instance, it's already open).

    response = stem.response.ControlMessage.from_str('555 Connection is not managed by controller.\r\n')

    with patch('stem.control.Controller.msg', Mock(return_value = response)):
      self.assertRaises(UnsatisfiableRequest, self.controller.attach_stream, 'stream_id', 'circ_id')

  def test_parse_circ_path(self):
    """
    Exercises the _parse_circ_path() helper function.
    """

    # empty input

    self.assertEqual([], _parse_circ_path(None))
    self.assertEqual([], _parse_circ_path(''))

    # check the pydoc examples

    pydoc_examples = {
      '$999A226EBED397F331B612FE1E4CFAE5C1F201BA=piyaz':
        [('999A226EBED397F331B612FE1E4CFAE5C1F201BA', 'piyaz')],
      '$E57A476CD4DFBD99B4EE52A100A58610AD6E80B9,hamburgerphone,PrivacyRepublic14':
        [
          ('E57A476CD4DFBD99B4EE52A100A58610AD6E80B9', None),
          (None, 'hamburgerphone'),
          (None, 'PrivacyRepublic14'),
        ],
    }

    for test_input, expected in pydoc_examples.items():
      self.assertEqual(expected, _parse_circ_path(test_input))

    # exercise with some invalid inputs

    malformed_inputs = [
      '=piyaz',  # no fingerprint
      '999A226EBED397F331B612FE1E4CFAE5C1F201BA=piyaz',  # fingerprint missing prefix
      '$999A226EBED397F331B612FE1E4CFAE5C1F201BAA=piyaz',  # fingerprint too long
      '$999A226EBED397F331B612FE1E4CFAE5C1F201B=piyaz',  # fingerprint too short
      '$999A226EBED397F331B612FE1E4CFAE5C1F201Bz=piyaz',  # invalid character in fingerprint
      '$999A226EBED397F331B612FE1E4CFAE5C1F201BA=',  # no nickname
    ]

    for test_input in malformed_inputs:
      self.assertRaises(ProtocolError, _parse_circ_path, test_input)

  @patch('stem.control.Controller.get_conf')
  def test_get_effective_rate(self, get_conf_mock):
    """
    Exercise the get_effective_rate() method.
    """

    # check default if nothing was set

    get_conf_mock.side_effect = lambda param, **kwargs: {
      'BandwidthRate': '1073741824',
      'BandwidthBurst': '1073741824',
      'RelayBandwidthRate': '0',
      'RelayBandwidthBurst': '0',
      'MaxAdvertisedBandwidth': '1073741824',
    }[param]

    self.assertEqual(1073741824, self.controller.get_effective_rate())
    self.assertEqual(1073741824, self.controller.get_effective_rate(burst = True))

    get_conf_mock.side_effect = ControllerError('nope, too bad')
    self.assertRaises(ControllerError, self.controller.get_effective_rate)
    self.assertEqual('my_default', self.controller.get_effective_rate('my_default'))

  @patch('stem.control.Controller.get_version')
  def test_drop_guards(self, get_version_mock):
    """
    Exercises the drop_guards() method.
    """

    get_version_mock.return_value = stem.version.Version('0.1.0.14')
    self.assertRaises(UnsatisfiableRequest, self.controller.drop_guards)

    with patch('stem.control.Controller.msg', Mock(return_value = None)):
      get_version_mock.return_value = stem.version.Version('0.2.5.2')
      self.controller.drop_guards()
Exemple #2
0
class TestControl(unittest.TestCase):
  def setUp(self):
    socket = stem.socket.ControlSocket()

    with patch('stem.control.Controller.add_event_listener', Mock()):
      self.controller = Controller(socket)

  @patch('stem.control.Controller.get_info')
  def test_get_version(self, get_info_mock):
    """
    Exercises the get_version() method.
    """

    try:
      # Use one version for first check.
      version_2_1 = "0.2.1.32"
      version_2_1_object = stem.version.Version(version_2_1)
      get_info_mock.return_value = version_2_1

      # Return a version with a cold cache.
      self.assertEqual(version_2_1_object, self.controller.get_version())

      # Use a different version for second check.
      version_2_2 = "0.2.2.39"
      version_2_2_object = stem.version.Version(version_2_2)
      get_info_mock.return_value = version_2_2

      # Return a version with a hot cache, so it will be the old version.
      self.assertEqual(version_2_1_object, self.controller.get_version())

      # Turn off caching.
      self.controller._is_caching_enabled = False
      # Return a version without caching, so it will be the new version.
      self.assertEqual(version_2_2_object, self.controller.get_version())

      # Raise an exception in the get_info() call.
      get_info_mock.side_effect = InvalidArguments

      # Get a default value when the call fails.
      self.assertEqual(
        "default returned",
        self.controller.get_version(default = "default returned")
      )

      # No default value, accept the error.
      self.assertRaises(InvalidArguments, self.controller.get_version)

      # Give a bad version.  The stem.version.Version ValueError should bubble up.
      version_A_42 = "0.A.42.spam"
      get_info_mock.return_value = version_A_42
      get_info_mock.side_effect = None
      self.assertRaises(ValueError, self.controller.get_version)
    finally:
      # Turn caching back on before we leave.
      self.controller._is_caching_enabled = True

  @patch('stem.control.Controller.get_info')
  @patch('stem.control.Controller.get_conf')
  def test_get_exit_policy(self, get_conf_mock, get_info_mock):
    """
    Exercises the get_exit_policy() method.
    """

    get_conf_mock.side_effect = lambda param, **kwargs: {
      "ExitPolicyRejectPrivate": "1",
      "ExitPolicy": ["accept *:80,   accept *:443", "accept 43.5.5.5,reject *:22"],
    }[param]

    get_info_mock.side_effect = lambda param, default = None: {
      "address": "123.45.67.89",
      "exit-policy/default": "reject *:25,reject *:119,reject *:135-139,reject *:445,reject *:563,reject *:1214,reject *:4661-4666,reject *:6346-6429,reject *:6699,reject *:6881-6999,accept *:*",
    }[param]

    expected = ExitPolicy(
      'reject 0.0.0.0/8:*',  # private entries
      'reject 169.254.0.0/16:*',
      'reject 127.0.0.0/8:*',
      'reject 192.168.0.0/16:*',
      'reject 10.0.0.0/8:*',
      'reject 172.16.0.0/12:*',
      'reject 123.45.67.89:*',  # relay's public address
      'accept *:80',  # finally we get to our ExitPolicy
      'accept *:443',
      'accept 43.5.5.5:*',
      'reject *:22',
      'reject *:25',  # default policy
      'reject *:119',
      'reject *:135-139',
      'reject *:445',
      'reject *:563',
      'reject *:1214',
      'reject *:4661-4666',
      'reject *:6346-6429',
      'reject *:6699',
      'reject *:6881-6999',
      'accept *:*',
    )

    self.assertEqual(expected, self.controller.get_exit_policy())

  @patch('stem.control.Controller.get_info')
  @patch('stem.control.Controller.get_conf')
  def test_get_socks_listeners_old(self, get_conf_mock, get_info_mock):
    """
    Exercises the get_socks_listeners() method as though talking to an old tor
    instance.
    """

    # An old tor raises stem.InvalidArguments for get_info about socks, but
    # get_socks_listeners should work anyway.

    get_info_mock.side_effect = InvalidArguments

    get_conf_mock.side_effect = lambda param, **kwargs: {
      "SocksPort": "9050",
      "SocksListenAddress": ["127.0.0.1"],
    }[param]

    self.assertEqual([('127.0.0.1', 9050)], self.controller.get_socks_listeners())

    # Again, an old tor, but SocksListenAddress overrides the port number.

    get_conf_mock.side_effect = lambda param, **kwargs: {
      "SocksPort": "9050",
      "SocksListenAddress": ["127.0.0.1:1112"],
    }[param]

    self.assertEqual([('127.0.0.1', 1112)], self.controller.get_socks_listeners())

    # Again, an old tor, but multiple listeners

    get_conf_mock.side_effect = lambda param, **kwargs: {
      "SocksPort": "9050",
      "SocksListenAddress": ["127.0.0.1:1112", "127.0.0.1:1114"],
    }[param]

    self.assertEqual([('127.0.0.1', 1112), ('127.0.0.1', 1114)], self.controller.get_socks_listeners())

    # Again, an old tor, but no SOCKS listeners

    get_conf_mock.side_effect = lambda param, **kwargs: {
      "SocksPort": "0",
      "SocksListenAddress": [],
    }[param]

    self.assertEqual([], self.controller.get_socks_listeners())

    # Where tor provides invalid ports or addresses

    get_conf_mock.side_effect = lambda param, **kwargs: {
      "SocksPort": "blarg",
      "SocksListenAddress": ["127.0.0.1"],
    }[param]

    self.assertRaises(stem.ProtocolError, self.controller.get_socks_listeners)

    get_conf_mock.side_effect = lambda param, **kwargs: {
      "SocksPort": "0",
      "SocksListenAddress": ["127.0.0.1:abc"],
    }[param]

    self.assertRaises(stem.ProtocolError, self.controller.get_socks_listeners)

    get_conf_mock.side_effect = lambda param, **kwargs: {
      "SocksPort": "40",
      "SocksListenAddress": ["500.0.0.1"],
    }[param]

    self.assertRaises(stem.ProtocolError, self.controller.get_socks_listeners)

  @patch('stem.control.Controller.get_info')
  def test_get_socks_listeners_new(self, get_info_mock):
    """
    Exercises the get_socks_listeners() method as if talking to a newer tor
    instance.
    """

    # multiple SOCKS listeners

    get_info_mock.return_value = '"127.0.0.1:1112" "127.0.0.1:1114"'

    self.assertEqual(
      [('127.0.0.1', 1112), ('127.0.0.1', 1114)],
      self.controller.get_socks_listeners()
    )

    # no SOCKS listeners

    get_info_mock.return_value = ''
    self.assertEqual([], self.controller.get_socks_listeners())

    # check where GETINFO provides malformed content

    invalid_responses = (
      '"127.0.0.1"',         # address only
      '"1112"',              # port only
      '"5127.0.0.1:1112"',   # invlaid address
      '"127.0.0.1:991112"',  # invalid port
    )

    for response in invalid_responses:
      get_info_mock.return_value = response
      self.assertRaises(stem.ProtocolError, self.controller.get_socks_listeners)

  @patch('stem.connection.get_protocolinfo')
  def test_get_protocolinfo(self, get_protocolinfo_mock):
    """
    Exercises the get_protocolinfo() method.
    """

    # use the handy mocked protocolinfo response

    get_protocolinfo_mock.return_value = mocking.get_protocolinfo_response()

    # compare the str representation of these object, because the class
    # does not have, nor need, a direct comparison operator

    self.assertEqual(
      str(mocking.get_protocolinfo_response()),
      str(self.controller.get_protocolinfo())
    )

    # raise an exception in the stem.connection.get_protocolinfo() call

    get_protocolinfo_mock.side_effect = ProtocolError

    # get a default value when the call fails

    self.assertEqual(
      "default returned",
      self.controller.get_protocolinfo(default = "default returned")
    )

    # no default value, accept the error

    self.assertRaises(ProtocolError, self.controller.get_protocolinfo)

  @patch('stem.socket.ControlSocket.is_localhost', Mock(return_value = False))
  def test_get_user_remote(self):
    """
    Exercise the get_user() method for a non-local socket.
    """

    self.assertRaises(ValueError, self.controller.get_user)
    self.assertEqual(123, self.controller.get_user(123))

  @patch('stem.socket.ControlSocket.is_localhost', Mock(return_value = True))
  @patch('stem.control.Controller.get_info', Mock(return_value = 'atagar'))
  def test_get_user_by_getinfo(self):
    """
    Exercise the get_user() resolution via its getinfo option.
    """

    self.assertEqual('atagar', self.controller.get_user())

  @patch('stem.socket.ControlSocket.is_localhost', Mock(return_value = True))
  @patch('stem.util.system.get_pid_by_name', Mock(return_value = 432))
  @patch('stem.util.system.get_user', Mock(return_value = 'atagar'))
  def test_get_user_by_system(self):
    """
    Exercise the get_user() resolution via the system module.
    """

    self.assertEqual('atagar', self.controller.get_user())

  @patch('stem.socket.ControlSocket.is_localhost', Mock(return_value = False))
  def test_get_pid_remote(self):
    """
    Exercise the get_pid() method for a non-local socket.
    """

    self.assertRaises(ValueError, self.controller.get_pid)
    self.assertEqual(123, self.controller.get_pid(123))

  @patch('stem.socket.ControlSocket.is_localhost', Mock(return_value = True))
  @patch('stem.control.Controller.get_info', Mock(return_value = '321'))
  def test_get_pid_by_getinfo(self):
    """
    Exercise the get_pid() resolution via its getinfo option.
    """

    self.assertEqual(321, self.controller.get_pid())

  @patch('stem.socket.ControlSocket.is_localhost', Mock(return_value = True))
  @patch('stem.control.Controller.get_conf')
  @patch('stem.control.open', create = True)
  def test_get_pid_by_pid_file(self, open_mock, get_conf_mock):
    """
    Exercise the get_pid() resolution via a PidFile.
    """

    get_conf_mock.return_value = '/tmp/pid_file'
    open_mock.return_value = io.BytesIO(b'432')

    self.assertEqual(432, self.controller.get_pid())
    open_mock.assert_called_once_with('/tmp/pid_file')

  @patch('stem.socket.ControlSocket.is_localhost', Mock(return_value = True))
  @patch('stem.util.system.get_pid_by_name', Mock(return_value = 432))
  def test_get_pid_by_name(self):
    """
    Exercise the get_pid() resolution via the process name.
    """

    self.assertEqual(432, self.controller.get_pid())

  @patch('stem.control.Controller.get_info')
  def test_get_network_status(self, get_info_mock):
    """
    Exercises the get_network_status() method.
    """

    # build a single router status entry

    nickname = "Beaver"
    fingerprint = "/96bKo4soysolMgKn5Hex2nyFSY"
    desc = "r %s %s u5lTXJKGsLKufRLnSyVqT7TdGYw 2012-12-30 22:02:49 77.223.43.54 9001 0\ns Fast Named Running Stable Valid\nw Bandwidth=75" % (nickname, fingerprint)
    router = stem.descriptor.router_status_entry.RouterStatusEntryV3(desc)

    # always return the same router status entry

    get_info_mock.return_value = desc

    # pretend to get the router status entry with its name

    self.assertEqual(router, self.controller.get_network_status(nickname))

    # pretend to get the router status entry with its fingerprint

    hex_fingerprint = stem.descriptor.router_status_entry._base64_to_hex(fingerprint, False)
    self.assertEqual(router, self.controller.get_network_status(hex_fingerprint))

    # mangle hex fingerprint and try again

    hex_fingerprint = hex_fingerprint[2:]
    self.assertRaises(ValueError, self.controller.get_network_status, hex_fingerprint)

    # raise an exception in the get_info() call

    get_info_mock.side_effect = InvalidArguments

    # get a default value when the call fails

    self.assertEqual(
      "default returned",
      self.controller.get_network_status(nickname, default = "default returned")
    )

    # no default value, accept the error

    self.assertRaises(InvalidArguments, self.controller.get_network_status, nickname)

  @patch('stem.control.Controller.is_authenticated', Mock(return_value = True))
  @patch('stem.control.Controller._attach_listeners', Mock(return_value = ([], [])))
  @patch('stem.control.Controller.get_version')
  def test_event_listening(self, get_version_mock):
    """
    Exercises the add_event_listener and remove_event_listener methods.
    """

    # set up for failure to create any events

    get_version_mock.return_value = stem.version.Version('0.1.0.14')
    self.assertRaises(InvalidRequest, self.controller.add_event_listener, Mock(), EventType.BW)

    # set up to only fail newer events

    get_version_mock.return_value = stem.version.Version('0.2.0.35')

    # EventType.BW is one of the earliest events

    self.controller.add_event_listener(Mock(), EventType.BW)

    # EventType.SIGNAL was added in tor version 0.2.3.1-alpha
    self.assertRaises(InvalidRequest, self.controller.add_event_listener, Mock(), EventType.SIGNAL)

  def test_get_streams(self):
    """
    Exercises the get_streams() method.
    """

    # get a list of fake, but good looking, streams
    valid_streams = (
      ("1", "NEW", "4", "10.10.10.1:80"),
      ("2", "SUCCEEDED", "4", "10.10.10.1:80"),
      ("3", "SUCCEEDED", "4", "10.10.10.1:80")
    )

    response = "".join(["%s\r\n" % " ".join(entry) for entry in valid_streams])

    with patch('stem.control.Controller.get_info', Mock(return_value = response)):
      streams = self.controller.get_streams()
      self.assertEqual(len(valid_streams), len(streams))

      for index, stream in enumerate(streams):
        self.assertEqual(valid_streams[index][0], stream.id)
        self.assertEqual(valid_streams[index][1], stream.status)
        self.assertEqual(valid_streams[index][2], stream.circ_id)
        self.assertEqual(valid_streams[index][3], stream.target)

  def test_attach_stream(self):
    """
    Exercises the attach_stream() method.
    """

    # Response when the stream is in a state where it can't be attached (for
    # instance, it's already open).

    response = stem.response.ControlMessage.from_str("555 Connection is not managed by controller.\r\n")

    with patch('stem.control.Controller.msg', Mock(return_value = response)):
      self.assertRaises(UnsatisfiableRequest, self.controller.attach_stream, 'stream_id', 'circ_id')

  def test_parse_circ_path(self):
    """
    Exercises the _parse_circ_path() helper function.
    """

    # empty input

    self.assertEqual([], _parse_circ_path(None))
    self.assertEqual([], _parse_circ_path(''))

    # check the pydoc examples

    pydoc_examples = {
      '$999A226EBED397F331B612FE1E4CFAE5C1F201BA=piyaz':
        [('999A226EBED397F331B612FE1E4CFAE5C1F201BA', 'piyaz')],
      '$E57A476CD4DFBD99B4EE52A100A58610AD6E80B9,hamburgerphone,PrivacyRepublic14':
        [
          ('E57A476CD4DFBD99B4EE52A100A58610AD6E80B9', None),
          (None, 'hamburgerphone'),
          (None, 'PrivacyRepublic14'),
        ],
    }

    for test_input, expected in pydoc_examples.items():
      self.assertEqual(expected, _parse_circ_path(test_input))

    # exercise with some invalid inputs

    malformed_inputs = [
      '=piyaz',  # no fingerprint
      '999A226EBED397F331B612FE1E4CFAE5C1F201BA=piyaz',  # fingerprint missing prefix
      '$999A226EBED397F331B612FE1E4CFAE5C1F201BAA=piyaz',  # fingerprint too long
      '$999A226EBED397F331B612FE1E4CFAE5C1F201B=piyaz',  # fingerprint too short
      '$999A226EBED397F331B612FE1E4CFAE5C1F201Bz=piyaz',  # invalid character in fingerprint
      '$999A226EBED397F331B612FE1E4CFAE5C1F201BA=',  # no nickname
    ]

    for test_input in malformed_inputs:
      self.assertRaises(ProtocolError, _parse_circ_path, test_input)
Exemple #3
0
class TestControl(unittest.TestCase):
    def setUp(self):
        socket = stem.socket.ControlSocket()

        # When initially constructing a controller we need to suppress msg, so our
        # constructor's SETEVENTS requests pass.

        with patch('stem.control.BaseController.msg', Mock()):
            self.controller = Controller(socket)

            self.circ_listener = Mock()
            self.controller.add_event_listener(self.circ_listener,
                                               EventType.CIRC)

            self.bw_listener = Mock()
            self.controller.add_event_listener(self.bw_listener, EventType.BW)

            self.malformed_listener = Mock()
            self.controller.add_event_listener(self.malformed_listener,
                                               MALFORMED_EVENTS)

    def test_event_description(self):
        self.assertEqual(
            "Logging at the debug runlevel. This is low level, high volume information about tor's internals that generally isn't useful to users.",
            stem.control.event_description('DEBUG'))
        self.assertEqual(
            'Event emitted every second with the bytes sent and received by tor.',
            stem.control.event_description('BW'))
        self.assertEqual(
            'Event emitted every second with the bytes sent and received by tor.',
            stem.control.event_description('bw'))

    def test_event_description_includes_all_events(self):
        self.assertEqual(None, stem.control.event_description('NO_SUCH_EVENT'))

        for event in stem.control.EventType:
            self.assertTrue(stem.control.event_description(event) is not None)

    @patch('stem.control.Controller.msg')
    def test_get_info(self, msg_mock):
        msg_mock.return_value = ControlMessage.from_str(
            '250-hello=hi right back!\r\n250 OK\r\n', 'GETINFO')
        self.assertEqual('hi right back!', self.controller.get_info('hello'))

    @patch('stem.control.Controller.msg')
    def test_get_info_address_caching(self, msg_mock):
        msg_mock.return_value = ControlMessage.from_str(
            '551 Address unknown\r\n')

        self.assertEqual(None, self.controller._last_address_exc)
        self.assertRaisesWith(stem.OperationFailed, 'Address unknown',
                              self.controller.get_info, 'address')
        self.assertEqual('Address unknown',
                         str(self.controller._last_address_exc))
        self.assertEqual(1, msg_mock.call_count)

        # now that we have a cached failure we should provide that back

        self.assertRaisesWith(stem.OperationFailed, 'Address unknown',
                              self.controller.get_info, 'address')
        self.assertEqual(1, msg_mock.call_count)

        # invalidates the cache, transitioning from no address to having one

        msg_mock.return_value = ControlMessage.from_str(
            '250-address=17.2.89.80\r\n250 OK\r\n', 'GETINFO')
        self.assertRaisesWith(stem.OperationFailed, 'Address unknown',
                              self.controller.get_info, 'address')
        self.controller._handle_event(
            ControlMessage.from_str(
                '650 STATUS_SERVER NOTICE EXTERNAL_ADDRESS ADDRESS=17.2.89.80 METHOD=DIRSERV\r\n'
            ))
        self.assertEqual('17.2.89.80', self.controller.get_info('address'))

        # invalidates the cache, transitioning from one address to another

        msg_mock.return_value = ControlMessage.from_str(
            '250-address=80.89.2.17\r\n250 OK\r\n', 'GETINFO')
        self.assertEqual('17.2.89.80', self.controller.get_info('address'))
        self.controller._handle_event(
            ControlMessage.from_str(
                '650 STATUS_SERVER NOTICE EXTERNAL_ADDRESS ADDRESS=80.89.2.17 METHOD=DIRSERV\r\n'
            ))
        self.assertEqual('80.89.2.17', self.controller.get_info('address'))

    @patch('stem.control.Controller.msg')
    @patch('stem.control.Controller.get_conf')
    def test_get_info_without_fingerprint(self, get_conf_mock, msg_mock):
        msg_mock.return_value = ControlMessage.from_str(
            '551 Not running in server mode\r\n')
        get_conf_mock.return_value = None

        self.assertEqual(None, self.controller._last_fingerprint_exc)
        self.assertRaisesWith(stem.OperationFailed,
                              'Not running in server mode',
                              self.controller.get_info, 'fingerprint')
        self.assertEqual('Not running in server mode',
                         str(self.controller._last_fingerprint_exc))
        self.assertEqual(1, msg_mock.call_count)

        # now that we have a cached failure we should provide that back

        self.assertRaisesWith(stem.OperationFailed,
                              'Not running in server mode',
                              self.controller.get_info, 'fingerprint')
        self.assertEqual(1, msg_mock.call_count)

        # ... but if we become a relay we'll call it again

        get_conf_mock.return_value = '443'
        self.assertRaisesWith(stem.OperationFailed,
                              'Not running in server mode',
                              self.controller.get_info, 'fingerprint')
        self.assertEqual(2, msg_mock.call_count)

    @patch('stem.control.Controller.get_info')
    def test_get_version(self, get_info_mock):
        """
    Exercises the get_version() method.
    """

        try:
            # Use one version for first check.
            version_2_1 = '0.2.1.32'
            version_2_1_object = stem.version.Version(version_2_1)
            get_info_mock.return_value = version_2_1

            # Return a version with a cold cache.
            self.assertEqual(version_2_1_object, self.controller.get_version())

            # Use a different version for second check.
            version_2_2 = '0.2.2.39'
            version_2_2_object = stem.version.Version(version_2_2)
            get_info_mock.return_value = version_2_2

            # Return a version with a hot cache, so it will be the old version.
            self.assertEqual(version_2_1_object, self.controller.get_version())

            # Turn off caching.
            self.controller._is_caching_enabled = False
            # Return a version without caching, so it will be the new version.
            self.assertEqual(version_2_2_object, self.controller.get_version())

            # Spec says the getinfo response may optionally be prefixed by 'Tor '. In
            # practice it doesn't but we should accept that.
            get_info_mock.return_value = 'Tor 0.2.1.32'
            self.assertEqual(version_2_1_object, self.controller.get_version())

            # Raise an exception in the get_info() call.
            get_info_mock.side_effect = InvalidArguments

            # Get a default value when the call fails.
            self.assertEqual(
                'default returned',
                self.controller.get_version(default='default returned'))

            # No default value, accept the error.
            self.assertRaises(InvalidArguments, self.controller.get_version)

            # Give a bad version.  The stem.version.Version ValueError should bubble up.
            version_A_42 = '0.A.42.spam'
            get_info_mock.return_value = version_A_42
            get_info_mock.side_effect = None
            self.assertRaises(ValueError, self.controller.get_version)
        finally:
            # Turn caching back on before we leave.
            self.controller._is_caching_enabled = True

    @patch('stem.control.Controller.get_info')
    def test_get_exit_policy(self, get_info_mock):
        """
    Exercises the get_exit_policy() method.
    """

        get_info_mock.side_effect = lambda param, default=None: {
            'exit-policy/full':
            'reject *:25,reject *:119,reject *:135-139,reject *:445,reject *:563,reject *:1214,reject *:4661-4666,reject *:6346-6429,reject *:6699,reject *:6881-6999,accept *:*',
        }[param]

        expected = ExitPolicy(
            'reject *:25',
            'reject *:119',
            'reject *:135-139',
            'reject *:445',
            'reject *:563',
            'reject *:1214',
            'reject *:4661-4666',
            'reject *:6346-6429',
            'reject *:6699',
            'reject *:6881-6999',
            'accept *:*',
        )

        self.assertEqual(str(expected), str(self.controller.get_exit_policy()))

    @patch('stem.control.Controller.get_info')
    @patch('stem.control.Controller.get_conf')
    def test_get_ports(self, get_conf_mock, get_info_mock):
        """
    Exercises the get_ports() and get_listeners() methods.
    """

        # Exercise as an old version of tor that doesn't support the 'GETINFO
        # net/listeners/*' options.

        get_info_mock.side_effect = InvalidArguments

        get_conf_mock.side_effect = lambda param, *args, **kwargs: {
            'ControlPort': '9050',
            'ControlListenAddress': ['127.0.0.1'],
        }[param]

        self.assertEqual([('127.0.0.1', 9050)],
                         self.controller.get_listeners(Listener.CONTROL))
        self.assertEqual([9050], self.controller.get_ports(Listener.CONTROL))
        self.controller.clear_cache()

        # non-local addresss

        get_conf_mock.side_effect = lambda param, *args, **kwargs: {
            'ControlPort': '9050',
            'ControlListenAddress': ['27.4.4.1'],
        }[param]

        self.assertEqual([('27.4.4.1', 9050)],
                         self.controller.get_listeners(Listener.CONTROL))
        self.assertEqual([], self.controller.get_ports(Listener.CONTROL))
        self.controller.clear_cache()

        # exercise via the GETINFO option

        get_info_mock.side_effect = None
        get_info_mock.return_value = '"127.0.0.1:1112" "127.0.0.1:1114"'

        self.assertEqual([('127.0.0.1', 1112), ('127.0.0.1', 1114)],
                         self.controller.get_listeners(Listener.CONTROL))

        self.assertEqual([1112, 1114],
                         self.controller.get_ports(Listener.CONTROL))
        self.controller.clear_cache()

        # with all localhost addresses, including a couple that aren't

        get_info_mock.side_effect = None
        get_info_mock.return_value = '"27.4.4.1:1113" "127.0.0.5:1114" "0.0.0.0:1115" "[::]:1116" "[::1]:1117" "[10::]:1118"'

        self.assertEqual([1114, 1115, 1116, 1117],
                         self.controller.get_ports(Listener.OR))
        self.controller.clear_cache()

        # IPv6 address

        get_info_mock.return_value = '"0.0.0.0:9001" "[fe80:0000:0000:0000:0202:b3ff:fe1e:8329]:9001"'

        self.assertEqual([('0.0.0.0', 9001),
                          ('fe80:0000:0000:0000:0202:b3ff:fe1e:8329', 9001)],
                         self.controller.get_listeners(Listener.CONTROL))

        # unix socket file

        self.controller.clear_cache()
        get_info_mock.return_value = '"unix:/tmp/tor/socket"'

        self.assertEqual([], self.controller.get_listeners(Listener.CONTROL))
        self.assertEqual([], self.controller.get_ports(Listener.CONTROL))

    @patch('stem.control.Controller.get_info')
    @patch('time.time', Mock(return_value=1410723598.276578))
    def test_get_accounting_stats(self, get_info_mock):
        """
    Exercises the get_accounting_stats() method.
    """

        get_info_mock.side_effect = lambda param, **kwargs: {
            'accounting/enabled': '1',
            'accounting/hibernating': 'awake',
            'accounting/interval-end': '2014-09-14 19:41:00',
            'accounting/bytes': '4837 2050',
            'accounting/bytes-left': '102944 7440',
        }[param]

        expected = stem.control.AccountingStats(
            1410723598.276578,
            'awake',
            datetime.datetime(2014, 9, 14, 19, 41),
            62,
            4837,
            102944,
            107781,
            2050,
            7440,
            9490,
        )

        self.assertEqual(expected, self.controller.get_accounting_stats())

        get_info_mock.side_effect = ControllerError('nope, too bad')
        self.assertRaises(ControllerError,
                          self.controller.get_accounting_stats)
        self.assertEqual('my default',
                         self.controller.get_accounting_stats('my default'))

    @patch('stem.connection.get_protocolinfo')
    def test_get_protocolinfo(self, get_protocolinfo_mock):
        """
    Exercises the get_protocolinfo() method.
    """

        # use the handy mocked protocolinfo response

        protocolinfo_msg = ControlMessage.from_str(
            '250-PROTOCOLINFO 1\r\n250 OK\r\n', 'PROTOCOLINFO')
        get_protocolinfo_mock.return_value = protocolinfo_msg

        # compare the str representation of these object, because the class
        # does not have, nor need, a direct comparison operator

        self.assertEqual(str(protocolinfo_msg),
                         str(self.controller.get_protocolinfo()))

        # raise an exception in the stem.connection.get_protocolinfo() call

        get_protocolinfo_mock.side_effect = ProtocolError

        # get a default value when the call fails

        self.assertEqual(
            'default returned',
            self.controller.get_protocolinfo(default='default returned'))

        # no default value, accept the error

        self.assertRaises(ProtocolError, self.controller.get_protocolinfo)

    @patch('stem.socket.ControlSocket.is_localhost', Mock(return_value=False))
    def test_get_user_remote(self):
        """
    Exercise the get_user() method for a non-local socket.
    """

        self.assertRaises(ValueError, self.controller.get_user)
        self.assertEqual(123, self.controller.get_user(123))

    @patch('stem.socket.ControlSocket.is_localhost', Mock(return_value=True))
    @patch('stem.control.Controller.get_info', Mock(return_value='atagar'))
    def test_get_user_by_getinfo(self):
        """
    Exercise the get_user() resolution via its getinfo option.
    """

        self.assertEqual('atagar', self.controller.get_user())

    @patch('stem.socket.ControlSocket.is_localhost', Mock(return_value=True))
    @patch('stem.util.system.pid_by_name', Mock(return_value=432))
    @patch('stem.util.system.user', Mock(return_value='atagar'))
    def test_get_user_by_system(self):
        """
    Exercise the get_user() resolution via the system module.
    """

        self.assertEqual('atagar', self.controller.get_user())

    @patch('stem.socket.ControlSocket.is_localhost', Mock(return_value=False))
    def test_get_pid_remote(self):
        """
    Exercise the get_pid() method for a non-local socket.
    """

        self.assertRaises(ValueError, self.controller.get_pid)
        self.assertEqual(123, self.controller.get_pid(123))

    @patch('stem.socket.ControlSocket.is_localhost', Mock(return_value=True))
    @patch('stem.control.Controller.get_info', Mock(return_value='321'))
    def test_get_pid_by_getinfo(self):
        """
    Exercise the get_pid() resolution via its getinfo option.
    """

        self.assertEqual(321, self.controller.get_pid())

    @patch('stem.socket.ControlSocket.is_localhost', Mock(return_value=True))
    @patch('stem.control.Controller.get_conf')
    @patch('stem.control.open', create=True)
    def test_get_pid_by_pid_file(self, open_mock, get_conf_mock):
        """
    Exercise the get_pid() resolution via a PidFile.
    """

        get_conf_mock.return_value = '/tmp/pid_file'
        open_mock.return_value = io.BytesIO(b'432')

        self.assertEqual(432, self.controller.get_pid())
        open_mock.assert_called_once_with('/tmp/pid_file')

    @patch('stem.socket.ControlSocket.is_localhost', Mock(return_value=True))
    @patch('stem.util.system.pid_by_name', Mock(return_value=432))
    def test_get_pid_by_name(self):
        """
    Exercise the get_pid() resolution via the process name.
    """

        self.assertEqual(432, self.controller.get_pid())

    @patch('stem.control.Controller.get_version',
           Mock(return_value=stem.version.Version('0.5.0.14')))
    @patch('stem.socket.ControlSocket.is_localhost', Mock(return_value=False))
    @patch('stem.control.Controller.get_info')
    @patch('time.time', Mock(return_value=1000.0))
    def test_get_uptime_by_getinfo(self, getinfo_mock):
        """
    Exercise the get_uptime() resolution via a GETINFO query.
    """

        getinfo_mock.return_value = '321'
        self.assertEqual(321.0, self.controller.get_uptime())
        self.controller.clear_cache()

        getinfo_mock.return_value = 'abc'
        self.assertRaisesWith(
            ValueError,
            "'GETINFO uptime' did not provide a valid numeric response: abc",
            self.controller.get_uptime)

    @patch('stem.socket.ControlSocket.is_localhost', Mock(return_value=True))
    @patch('stem.control.Controller.get_version',
           Mock(return_value=stem.version.Version('0.1.0.14')))
    @patch('stem.control.Controller.get_pid', Mock(return_value='12'))
    @patch('stem.util.system.start_time', Mock(return_value=5000.0))
    @patch('time.time', Mock(return_value=5200.0))
    def test_get_uptime_by_process(self):
        """
    Exercise the get_uptime() resolution via process age.
    """

        self.assertEqual(200.0, self.controller.get_uptime())

    @patch('stem.control.Controller.get_info')
    def test_get_network_status_for_ourselves(self, get_info_mock):
        """
    Exercises the get_network_status() method for getting our own relay.
    """

        # when there's an issue getting our fingerprint

        get_info_mock.side_effect = ControllerError('nope, too bad')

        exc_msg = 'Unable to determine our own fingerprint: nope, too bad'
        self.assertRaisesWith(ControllerError, exc_msg,
                              self.controller.get_network_status)
        self.assertEqual('boom',
                         self.controller.get_network_status(default='boom'))

        # successful request

        desc = NS_DESC % ('moria1', '/96bKo4soysolMgKn5Hex2nyFSY')

        get_info_mock.side_effect = lambda param, **kwargs: {
            'fingerprint': '9695DFC35FFEB861329B9F1AB04C46397020CE31',
            'ns/id/9695DFC35FFEB861329B9F1AB04C46397020CE31': desc,
        }[param]

        self.assertEqual(
            stem.descriptor.router_status_entry.RouterStatusEntryV3(desc),
            self.controller.get_network_status())

    @patch('stem.control.Controller.get_info')
    def test_get_network_status_when_unavailable(self, get_info_mock):
        """
    Exercises the get_network_status() method.
    """

        get_info_mock.side_effect = InvalidArguments(
            None,
            'GETINFO request contained unrecognized keywords: ns/id/5AC9C5AA75BA1F18D8459B326B4B8111A856D290'
        )

        exc_msg = "Tor was unable to provide the descriptor for '5AC9C5AA75BA1F18D8459B326B4B8111A856D290'"
        self.assertRaisesWith(DescriptorUnavailable, exc_msg,
                              self.controller.get_network_status,
                              '5AC9C5AA75BA1F18D8459B326B4B8111A856D290')

    @patch('stem.control.Controller.get_info')
    def test_get_network_status(self, get_info_mock):
        """
    Exercises the get_network_status() method.
    """

        # build a single router status entry

        nickname = 'Beaver'
        fingerprint = '/96bKo4soysolMgKn5Hex2nyFSY'
        desc = NS_DESC % (nickname, fingerprint)
        router = stem.descriptor.router_status_entry.RouterStatusEntryV3(desc)

        # always return the same router status entry

        get_info_mock.return_value = desc

        # pretend to get the router status entry with its name

        self.assertEqual(router, self.controller.get_network_status(nickname))

        # pretend to get the router status entry with its fingerprint

        hex_fingerprint = stem.descriptor.router_status_entry._base64_to_hex(
            fingerprint, False)
        self.assertEqual(router,
                         self.controller.get_network_status(hex_fingerprint))

        # mangle hex fingerprint and try again

        hex_fingerprint = hex_fingerprint[2:]
        self.assertRaises(ValueError, self.controller.get_network_status,
                          hex_fingerprint)

        # raise an exception in the get_info() call

        get_info_mock.side_effect = InvalidArguments

        # get a default value when the call fails

        self.assertEqual(
            'default returned',
            self.controller.get_network_status(nickname,
                                               default='default returned'))

        # no default value, accept the error

        self.assertRaises(InvalidArguments, self.controller.get_network_status,
                          nickname)

    @patch('stem.control.Controller.is_authenticated', Mock(return_value=True))
    @patch('stem.control.Controller._attach_listeners',
           Mock(return_value=([], [])))
    @patch('stem.control.Controller.get_version')
    def test_add_event_listener(self, get_version_mock):
        """
    Exercises the add_event_listener and remove_event_listener methods.
    """

        # set up for failure to create any events

        get_version_mock.return_value = stem.version.Version('0.1.0.14')
        self.assertRaises(InvalidRequest, self.controller.add_event_listener,
                          Mock(), EventType.BW)

        # set up to only fail newer events

        get_version_mock.return_value = stem.version.Version('0.2.0.35')

        # EventType.BW is one of the earliest events

        self.controller.add_event_listener(Mock(), EventType.BW)

        # EventType.SIGNAL was added in tor version 0.2.3.1-alpha

        self.assertRaises(InvalidRequest, self.controller.add_event_listener,
                          Mock(), EventType.SIGNAL)

    def test_events_get_received(self):
        """
    Trigger an event, checking that our listeners get notified.
    """

        self._emit_event(CIRC_EVENT)
        self.circ_listener.assert_called_once_with(CIRC_EVENT)
        self.bw_listener.assert_not_called()
        self.malformed_listener.assert_not_called()

        self._emit_event(BW_EVENT)
        self.bw_listener.assert_called_once_with(BW_EVENT)

    def test_event_listing_with_error(self):
        """
    Raise an exception in an event listener to confirm it doesn't break our
    event thread.
    """

        self.circ_listener.side_effect = ValueError('boom')

        self._emit_event(CIRC_EVENT)
        self.circ_listener.assert_called_once_with(CIRC_EVENT)
        self.bw_listener.assert_not_called()
        self.malformed_listener.assert_not_called()

        self._emit_event(BW_EVENT)
        self.bw_listener.assert_called_once_with(BW_EVENT)

    def test_event_listing_with_malformed_event(self):
        """
    Attempt to parse a malformed event emitted from Tor. It's important this
    doesn't break our event thread.
    """

        # When stem.response.convert() encounters malformed content we still recast
        # the message.

        expected_bad_event = ControlMessage.from_str(BAD_EVENT.raw_content())
        setattr(expected_bad_event, 'arrived_at', TEST_TIMESTAMP)
        expected_bad_event.__class__ = stem.response.events.BandwidthEvent

        self._emit_event(BAD_EVENT)
        self.circ_listener.assert_not_called()
        self.bw_listener.assert_not_called()
        self.malformed_listener.assert_called_once_with(expected_bad_event)

        self._emit_event(BW_EVENT)
        self.bw_listener.assert_called_once_with(BW_EVENT)

    @patch('stem.control.Controller.get_version',
           Mock(return_value=stem.version.Version('0.5.0.14')))
    @patch('stem.control.Controller.msg',
           Mock(return_value=ControlMessage.from_str('250 OK\r\n')))
    @patch('stem.control.Controller.add_event_listener', Mock())
    @patch('stem.control.Controller.remove_event_listener', Mock())
    def test_timeout(self):
        """
    Methods that have an 'await' argument also have an optional timeout. Check
    that we raise a Timeout exception when it's elapsed.
    """

        self.assertRaisesWith(stem.Timeout,
                              'Reached our 0.1 second timeout',
                              self.controller.get_hidden_service_descriptor,
                              '5g2upl4pq6kufc4m',
                              await_result=True,
                              timeout=0.1)

    def test_get_streams(self):
        """
    Exercises the get_streams() method.
    """

        # get a list of fake, but good looking, streams
        valid_streams = (('1', 'NEW', '4', '10.10.10.1:80'),
                         ('2', 'SUCCEEDED', '4', '10.10.10.1:80'),
                         ('3', 'SUCCEEDED', '4', '10.10.10.1:80'))

        response = ''.join(
            ['%s\r\n' % ' '.join(entry) for entry in valid_streams])

        with patch('stem.control.Controller.get_info',
                   Mock(return_value=response)):
            streams = self.controller.get_streams()
            self.assertEqual(len(valid_streams), len(streams))

            for index, stream in enumerate(streams):
                self.assertEqual(valid_streams[index][0], stream.id)
                self.assertEqual(valid_streams[index][1], stream.status)
                self.assertEqual(valid_streams[index][2], stream.circ_id)
                self.assertEqual(valid_streams[index][3], stream.target)

    def test_attach_stream(self):
        """
    Exercises the attach_stream() method.
    """

        # Response when the stream is in a state where it can't be attached (for
        # instance, it's already open).

        response = stem.response.ControlMessage.from_str(
            '555 Connection is not managed by controller.\r\n')

        with patch('stem.control.Controller.msg', Mock(return_value=response)):
            self.assertRaises(UnsatisfiableRequest,
                              self.controller.attach_stream, 'stream_id',
                              'circ_id')

    def test_parse_circ_path(self):
        """
    Exercises the _parse_circ_path() helper function.
    """

        # empty input

        self.assertEqual([], _parse_circ_path(None))
        self.assertEqual([], _parse_circ_path(''))

        # check the pydoc examples

        pydoc_examples = {
            '$999A226EBED397F331B612FE1E4CFAE5C1F201BA=piyaz':
            [('999A226EBED397F331B612FE1E4CFAE5C1F201BA', 'piyaz')],
            '$E57A476CD4DFBD99B4EE52A100A58610AD6E80B9,hamburgerphone,PrivacyRepublic14':
            [
                ('E57A476CD4DFBD99B4EE52A100A58610AD6E80B9', None),
                (None, 'hamburgerphone'),
                (None, 'PrivacyRepublic14'),
            ],
        }

        for test_input, expected in pydoc_examples.items():
            self.assertEqual(expected, _parse_circ_path(test_input))

        # exercise with some invalid inputs

        malformed_inputs = [
            '=piyaz',  # no fingerprint
            '999A226EBED397F331B612FE1E4CFAE5C1F201BA=piyaz',  # fingerprint missing prefix
            '$999A226EBED397F331B612FE1E4CFAE5C1F201BAA=piyaz',  # fingerprint too long
            '$999A226EBED397F331B612FE1E4CFAE5C1F201B=piyaz',  # fingerprint too short
            '$999A226EBED397F331B612FE1E4CFAE5C1F201Bz=piyaz',  # invalid character in fingerprint
            '$999A226EBED397F331B612FE1E4CFAE5C1F201BA=',  # no nickname
        ]

        for test_input in malformed_inputs:
            self.assertRaises(ProtocolError, _parse_circ_path, test_input)

    @patch('stem.control.Controller.get_conf')
    def test_get_effective_rate(self, get_conf_mock):
        """
    Exercise the get_effective_rate() method.
    """

        # check default if nothing was set

        get_conf_mock.side_effect = lambda param, *args, **kwargs: {
            'BandwidthRate': '1073741824',
            'BandwidthBurst': '1073741824',
            'RelayBandwidthRate': '0',
            'RelayBandwidthBurst': '0',
            'MaxAdvertisedBandwidth': '1073741824',
        }[param]

        self.assertEqual(1073741824, self.controller.get_effective_rate())
        self.assertEqual(1073741824,
                         self.controller.get_effective_rate(burst=True))

        get_conf_mock.side_effect = ControllerError('nope, too bad')
        self.assertRaises(ControllerError, self.controller.get_effective_rate)
        self.assertEqual('my_default',
                         self.controller.get_effective_rate('my_default'))

    def _emit_event(self, event):
        # Spins up our Controller's thread pool, emits an event, then shuts it
        # down. This last part is important for a couple reasons...
        #
        #   1. So we don't leave any lingering threads.
        #
        #   2. To ensure our event handlers are done being executed. Events are
        #      processed asynchronously, so the only way to endsure it's done
        #      with its work is to join on the thread.

        with patch('time.time', Mock(return_value=TEST_TIMESTAMP)):
            with patch('stem.control.Controller.is_alive') as is_alive_mock:
                is_alive_mock.return_value = True
                self.controller._launch_threads()

                try:
                    # Converting an event back into an uncast ControlMessage, then feeding it
                    # into our controller's event queue.

                    uncast_event = ControlMessage.from_str(event.raw_content())
                    self.controller._event_queue.put(uncast_event)
                    self.controller._event_notice.set()
                    self.controller._event_queue.join(
                    )  # block until the event is consumed
                finally:
                    is_alive_mock.return_value = False
                    self.controller._close()
Exemple #4
0
class TestControl(unittest.TestCase):
    def setUp(self):
        socket = stem.socket.ControlSocket()

        with patch('stem.control.Controller.add_event_listener', Mock()):
            self.controller = Controller(socket)

    @patch('stem.control.Controller.get_info')
    def test_get_version(self, get_info_mock):
        """
    Exercises the get_version() method.
    """

        try:
            # Use one version for first check.
            version_2_1 = "0.2.1.32"
            version_2_1_object = stem.version.Version(version_2_1)
            get_info_mock.return_value = version_2_1

            # Return a version with a cold cache.
            self.assertEqual(version_2_1_object, self.controller.get_version())

            # Use a different version for second check.
            version_2_2 = "0.2.2.39"
            version_2_2_object = stem.version.Version(version_2_2)
            get_info_mock.return_value = version_2_2

            # Return a version with a hot cache, so it will be the old version.
            self.assertEqual(version_2_1_object, self.controller.get_version())

            # Turn off caching.
            self.controller._is_caching_enabled = False
            # Return a version without caching, so it will be the new version.
            self.assertEqual(version_2_2_object, self.controller.get_version())

            # Raise an exception in the get_info() call.
            get_info_mock.side_effect = InvalidArguments

            # Get a default value when the call fails.
            self.assertEqual(
                "default returned",
                self.controller.get_version(default="default returned"))

            # No default value, accept the error.
            self.assertRaises(InvalidArguments, self.controller.get_version)

            # Give a bad version.  The stem.version.Version ValueError should bubble up.
            version_A_42 = "0.A.42.spam"
            get_info_mock.return_value = version_A_42
            get_info_mock.side_effect = None
            self.assertRaises(ValueError, self.controller.get_version)
        finally:
            # Turn caching back on before we leave.
            self.controller._is_caching_enabled = True

    @patch('stem.control.Controller.get_info')
    @patch('stem.control.Controller.get_conf')
    def test_get_exit_policy(self, get_conf_mock, get_info_mock):
        """
    Exercises the get_exit_policy() method.
    """

        get_conf_mock.side_effect = lambda param, **kwargs: {
            "ExitPolicyRejectPrivate":
            "1",
            "ExitPolicy":
            ["accept *:80,   accept *:443", "accept 43.5.5.5,reject *:22"],
        }[param]

        get_info_mock.side_effect = lambda param, default=None: {
            "address":
            "123.45.67.89",
            "exit-policy/default":
            "reject *:25,reject *:119,reject *:135-139,reject *:445,reject *:563,reject *:1214,reject *:4661-4666,reject *:6346-6429,reject *:6699,reject *:6881-6999,accept *:*",
        }[param]

        expected = ExitPolicy(
            'reject 0.0.0.0/8:*',  # private entries
            'reject 169.254.0.0/16:*',
            'reject 127.0.0.0/8:*',
            'reject 192.168.0.0/16:*',
            'reject 10.0.0.0/8:*',
            'reject 172.16.0.0/12:*',
            'reject 123.45.67.89:*',  # relay's public address
            'accept *:80',  # finally we get to our ExitPolicy
            'accept *:443',
            'accept 43.5.5.5:*',
            'reject *:22',
            'reject *:25',  # default policy
            'reject *:119',
            'reject *:135-139',
            'reject *:445',
            'reject *:563',
            'reject *:1214',
            'reject *:4661-4666',
            'reject *:6346-6429',
            'reject *:6699',
            'reject *:6881-6999',
            'accept *:*',
        )

        self.assertEqual(expected, self.controller.get_exit_policy())

    @patch('stem.control.Controller.get_info')
    @patch('stem.control.Controller.get_conf')
    def test_get_socks_listeners_old(self, get_conf_mock, get_info_mock):
        """
    Exercises the get_socks_listeners() method as though talking to an old tor
    instance.
    """

        # An old tor raises stem.InvalidArguments for get_info about socks, but
        # get_socks_listeners should work anyway.

        get_info_mock.side_effect = InvalidArguments

        get_conf_mock.side_effect = lambda param, **kwargs: {
            "SocksPort": "9050",
            "SocksListenAddress": ["127.0.0.1"],
        }[param]

        self.assertEqual([('127.0.0.1', 9050)],
                         self.controller.get_socks_listeners())

        # Again, an old tor, but SocksListenAddress overrides the port number.

        get_conf_mock.side_effect = lambda param, **kwargs: {
            "SocksPort": "9050",
            "SocksListenAddress": ["127.0.0.1:1112"],
        }[param]

        self.assertEqual([('127.0.0.1', 1112)],
                         self.controller.get_socks_listeners())

        # Again, an old tor, but multiple listeners

        get_conf_mock.side_effect = lambda param, **kwargs: {
            "SocksPort": "9050",
            "SocksListenAddress": ["127.0.0.1:1112", "127.0.0.1:1114"],
        }[param]

        self.assertEqual([('127.0.0.1', 1112), ('127.0.0.1', 1114)],
                         self.controller.get_socks_listeners())

        # Again, an old tor, but no SOCKS listeners

        get_conf_mock.side_effect = lambda param, **kwargs: {
            "SocksPort": "0",
            "SocksListenAddress": [],
        }[param]

        self.assertEqual([], self.controller.get_socks_listeners())

        # Where tor provides invalid ports or addresses

        get_conf_mock.side_effect = lambda param, **kwargs: {
            "SocksPort": "blarg",
            "SocksListenAddress": ["127.0.0.1"],
        }[param]

        self.assertRaises(stem.ProtocolError,
                          self.controller.get_socks_listeners)

        get_conf_mock.side_effect = lambda param, **kwargs: {
            "SocksPort": "0",
            "SocksListenAddress": ["127.0.0.1:abc"],
        }[param]

        self.assertRaises(stem.ProtocolError,
                          self.controller.get_socks_listeners)

        get_conf_mock.side_effect = lambda param, **kwargs: {
            "SocksPort": "40",
            "SocksListenAddress": ["500.0.0.1"],
        }[param]

        self.assertRaises(stem.ProtocolError,
                          self.controller.get_socks_listeners)

    @patch('stem.control.Controller.get_info')
    def test_get_socks_listeners_new(self, get_info_mock):
        """
    Exercises the get_socks_listeners() method as if talking to a newer tor
    instance.
    """

        # multiple SOCKS listeners

        get_info_mock.return_value = '"127.0.0.1:1112" "127.0.0.1:1114"'

        self.assertEqual([('127.0.0.1', 1112), ('127.0.0.1', 1114)],
                         self.controller.get_socks_listeners())

        # no SOCKS listeners

        get_info_mock.return_value = ''
        self.assertEqual([], self.controller.get_socks_listeners())

        # check where GETINFO provides malformed content

        invalid_responses = (
            '"127.0.0.1"',  # address only
            '"1112"',  # port only
            '"5127.0.0.1:1112"',  # invlaid address
            '"127.0.0.1:991112"',  # invalid port
        )

        for response in invalid_responses:
            get_info_mock.return_value = response
            self.assertRaises(stem.ProtocolError,
                              self.controller.get_socks_listeners)

    @patch('stem.connection.get_protocolinfo')
    def test_get_protocolinfo(self, get_protocolinfo_mock):
        """
    Exercises the get_protocolinfo() method.
    """

        # use the handy mocked protocolinfo response

        get_protocolinfo_mock.return_value = mocking.get_protocolinfo_response(
        )

        # compare the str representation of these object, because the class
        # does not have, nor need, a direct comparison operator

        self.assertEqual(str(mocking.get_protocolinfo_response()),
                         str(self.controller.get_protocolinfo()))

        # raise an exception in the stem.connection.get_protocolinfo() call

        get_protocolinfo_mock.side_effect = ProtocolError

        # get a default value when the call fails

        self.assertEqual(
            "default returned",
            self.controller.get_protocolinfo(default="default returned"))

        # no default value, accept the error

        self.assertRaises(ProtocolError, self.controller.get_protocolinfo)

    @patch('stem.socket.ControlSocket.is_localhost', Mock(return_value=False))
    def test_get_user_remote(self):
        """
    Exercise the get_user() method for a non-local socket.
    """

        self.assertRaises(ValueError, self.controller.get_user)
        self.assertEqual(123, self.controller.get_user(123))

    @patch('stem.socket.ControlSocket.is_localhost', Mock(return_value=True))
    @patch('stem.control.Controller.get_info', Mock(return_value='atagar'))
    def test_get_user_by_getinfo(self):
        """
    Exercise the get_user() resolution via its getinfo option.
    """

        self.assertEqual('atagar', self.controller.get_user())

    @patch('stem.socket.ControlSocket.is_localhost', Mock(return_value=True))
    @patch('stem.util.system.get_pid_by_name', Mock(return_value=432))
    @patch('stem.util.system.get_user', Mock(return_value='atagar'))
    def test_get_user_by_system(self):
        """
    Exercise the get_user() resolution via the system module.
    """

        self.assertEqual('atagar', self.controller.get_user())

    @patch('stem.socket.ControlSocket.is_localhost', Mock(return_value=False))
    def test_get_pid_remote(self):
        """
    Exercise the get_pid() method for a non-local socket.
    """

        self.assertRaises(ValueError, self.controller.get_pid)
        self.assertEqual(123, self.controller.get_pid(123))

    @patch('stem.socket.ControlSocket.is_localhost', Mock(return_value=True))
    @patch('stem.control.Controller.get_info', Mock(return_value='321'))
    def test_get_pid_by_getinfo(self):
        """
    Exercise the get_pid() resolution via its getinfo option.
    """

        self.assertEqual(321, self.controller.get_pid())

    @patch('stem.socket.ControlSocket.is_localhost', Mock(return_value=True))
    @patch('stem.control.Controller.get_conf')
    @patch('stem.control.open', create=True)
    def test_get_pid_by_pid_file(self, open_mock, get_conf_mock):
        """
    Exercise the get_pid() resolution via a PidFile.
    """

        get_conf_mock.return_value = '/tmp/pid_file'
        open_mock.return_value = io.BytesIO(b'432')

        self.assertEqual(432, self.controller.get_pid())
        open_mock.assert_called_once_with('/tmp/pid_file')

    @patch('stem.socket.ControlSocket.is_localhost', Mock(return_value=True))
    @patch('stem.util.system.get_pid_by_name', Mock(return_value=432))
    def test_get_pid_by_name(self):
        """
    Exercise the get_pid() resolution via the process name.
    """

        self.assertEqual(432, self.controller.get_pid())

    @patch('stem.control.Controller.get_info')
    def test_get_network_status(self, get_info_mock):
        """
    Exercises the get_network_status() method.
    """

        # build a single router status entry

        nickname = "Beaver"
        fingerprint = "/96bKo4soysolMgKn5Hex2nyFSY"
        desc = "r %s %s u5lTXJKGsLKufRLnSyVqT7TdGYw 2012-12-30 22:02:49 77.223.43.54 9001 0\ns Fast Named Running Stable Valid\nw Bandwidth=75" % (
            nickname, fingerprint)
        router = stem.descriptor.router_status_entry.RouterStatusEntryV3(desc)

        # always return the same router status entry

        get_info_mock.return_value = desc

        # pretend to get the router status entry with its name

        self.assertEqual(router, self.controller.get_network_status(nickname))

        # pretend to get the router status entry with its fingerprint

        hex_fingerprint = stem.descriptor.router_status_entry._base64_to_hex(
            fingerprint, False)
        self.assertEqual(router,
                         self.controller.get_network_status(hex_fingerprint))

        # mangle hex fingerprint and try again

        hex_fingerprint = hex_fingerprint[2:]
        self.assertRaises(ValueError, self.controller.get_network_status,
                          hex_fingerprint)

        # raise an exception in the get_info() call

        get_info_mock.side_effect = InvalidArguments

        # get a default value when the call fails

        self.assertEqual(
            "default returned",
            self.controller.get_network_status(nickname,
                                               default="default returned"))

        # no default value, accept the error

        self.assertRaises(InvalidArguments, self.controller.get_network_status,
                          nickname)

    @patch('stem.control.Controller.is_authenticated', Mock(return_value=True))
    @patch('stem.control.Controller._attach_listeners',
           Mock(return_value=([], [])))
    @patch('stem.control.Controller.get_version')
    def test_event_listening(self, get_version_mock):
        """
    Exercises the add_event_listener and remove_event_listener methods.
    """

        # set up for failure to create any events

        get_version_mock.return_value = stem.version.Version('0.1.0.14')
        self.assertRaises(InvalidRequest, self.controller.add_event_listener,
                          Mock(), EventType.BW)

        # set up to only fail newer events

        get_version_mock.return_value = stem.version.Version('0.2.0.35')

        # EventType.BW is one of the earliest events

        self.controller.add_event_listener(Mock(), EventType.BW)

        # EventType.SIGNAL was added in tor version 0.2.3.1-alpha
        self.assertRaises(InvalidRequest, self.controller.add_event_listener,
                          Mock(), EventType.SIGNAL)

    def test_get_streams(self):
        """
    Exercises the get_streams() method.
    """

        # get a list of fake, but good looking, streams
        valid_streams = (("1", "NEW", "4", "10.10.10.1:80"),
                         ("2", "SUCCEEDED", "4", "10.10.10.1:80"),
                         ("3", "SUCCEEDED", "4", "10.10.10.1:80"))

        response = "".join(
            ["%s\r\n" % " ".join(entry) for entry in valid_streams])

        with patch('stem.control.Controller.get_info',
                   Mock(return_value=response)):
            streams = self.controller.get_streams()
            self.assertEqual(len(valid_streams), len(streams))

            for index, stream in enumerate(streams):
                self.assertEqual(valid_streams[index][0], stream.id)
                self.assertEqual(valid_streams[index][1], stream.status)
                self.assertEqual(valid_streams[index][2], stream.circ_id)
                self.assertEqual(valid_streams[index][3], stream.target)

    def test_attach_stream(self):
        """
    Exercises the attach_stream() method.
    """

        # Response when the stream is in a state where it can't be attached (for
        # instance, it's already open).

        response = stem.response.ControlMessage.from_str(
            "555 Connection is not managed by controller.\r\n")

        with patch('stem.control.Controller.msg', Mock(return_value=response)):
            self.assertRaises(UnsatisfiableRequest,
                              self.controller.attach_stream, 'stream_id',
                              'circ_id')

    def test_parse_circ_path(self):
        """
    Exercises the _parse_circ_path() helper function.
    """

        # empty input

        self.assertEqual([], _parse_circ_path(None))
        self.assertEqual([], _parse_circ_path(''))

        # check the pydoc examples

        pydoc_examples = {
            '$999A226EBED397F331B612FE1E4CFAE5C1F201BA=piyaz':
            [('999A226EBED397F331B612FE1E4CFAE5C1F201BA', 'piyaz')],
            '$E57A476CD4DFBD99B4EE52A100A58610AD6E80B9,hamburgerphone,PrivacyRepublic14':
            [
                ('E57A476CD4DFBD99B4EE52A100A58610AD6E80B9', None),
                (None, 'hamburgerphone'),
                (None, 'PrivacyRepublic14'),
            ],
        }

        for test_input, expected in pydoc_examples.items():
            self.assertEqual(expected, _parse_circ_path(test_input))

        # exercise with some invalid inputs

        malformed_inputs = [
            '=piyaz',  # no fingerprint
            '999A226EBED397F331B612FE1E4CFAE5C1F201BA=piyaz',  # fingerprint missing prefix
            '$999A226EBED397F331B612FE1E4CFAE5C1F201BAA=piyaz',  # fingerprint too long
            '$999A226EBED397F331B612FE1E4CFAE5C1F201B=piyaz',  # fingerprint too short
            '$999A226EBED397F331B612FE1E4CFAE5C1F201Bz=piyaz',  # invalid character in fingerprint
            '$999A226EBED397F331B612FE1E4CFAE5C1F201BA=',  # no nickname
        ]

        for test_input in malformed_inputs:
            self.assertRaises(ProtocolError, _parse_circ_path, test_input)
Exemple #5
0
class TestControl(unittest.TestCase):
    def setUp(self):
        socket = stem.socket.ControlSocket()

        with patch("stem.control.Controller.add_event_listener", Mock()):
            self.controller = Controller(socket)

    @patch("stem.control.Controller.get_info")
    def test_get_version(self, get_info_mock):
        """
    Exercises the get_version() method.
    """

        try:
            # Use one version for first check.
            version_2_1 = "0.2.1.32"
            version_2_1_object = stem.version.Version(version_2_1)
            get_info_mock.return_value = version_2_1

            # Return a version with a cold cache.
            self.assertEqual(version_2_1_object, self.controller.get_version())

            # Use a different version for second check.
            version_2_2 = "0.2.2.39"
            version_2_2_object = stem.version.Version(version_2_2)
            get_info_mock.return_value = version_2_2

            # Return a version with a hot cache, so it will be the old version.
            self.assertEqual(version_2_1_object, self.controller.get_version())

            # Turn off caching.
            self.controller._is_caching_enabled = False
            # Return a version without caching, so it will be the new version.
            self.assertEqual(version_2_2_object, self.controller.get_version())

            # Raise an exception in the get_info() call.
            get_info_mock.side_effect = InvalidArguments

            # Get a default value when the call fails.
            self.assertEqual("default returned", self.controller.get_version(default="default returned"))

            # No default value, accept the error.
            self.assertRaises(InvalidArguments, self.controller.get_version)

            # Give a bad version.  The stem.version.Version ValueError should bubble up.
            version_A_42 = "0.A.42.spam"
            get_info_mock.return_value = version_A_42
            get_info_mock.side_effect = None
            self.assertRaises(ValueError, self.controller.get_version)
        finally:
            # Turn caching back on before we leave.
            self.controller._is_caching_enabled = True

    @patch("stem.control.Controller.get_info")
    @patch("stem.control.Controller.get_conf")
    def test_get_exit_policy(self, get_conf_mock, get_info_mock):
        """
    Exercises the get_exit_policy() method.
    """

        get_conf_mock.side_effect = lambda param, **kwargs: {
            "ExitPolicyRejectPrivate": "1",
            "ExitPolicy": ["accept *:80,   accept *:443", "accept 43.5.5.5,reject *:22"],
        }[param]

        get_info_mock.side_effect = lambda param, default=None: {
            "address": "123.45.67.89",
            "exit-policy/default": "reject *:25,reject *:119,reject *:135-139,reject *:445,reject *:563,reject *:1214,reject *:4661-4666,reject *:6346-6429,reject *:6699,reject *:6881-6999,accept *:*",
        }[param]

        expected = ExitPolicy(
            "reject 0.0.0.0/8:*",  # private entries
            "reject 169.254.0.0/16:*",
            "reject 127.0.0.0/8:*",
            "reject 192.168.0.0/16:*",
            "reject 10.0.0.0/8:*",
            "reject 172.16.0.0/12:*",
            "reject 123.45.67.89:*",  # relay's public address
            "accept *:80",  # finally we get to our ExitPolicy
            "accept *:443",
            "accept 43.5.5.5:*",
            "reject *:22",
            "reject *:25",  # default policy
            "reject *:119",
            "reject *:135-139",
            "reject *:445",
            "reject *:563",
            "reject *:1214",
            "reject *:4661-4666",
            "reject *:6346-6429",
            "reject *:6699",
            "reject *:6881-6999",
            "accept *:*",
        )

        self.assertEqual(expected, self.controller.get_exit_policy())

    @patch("stem.control.Controller.get_info")
    @patch("stem.control.Controller.get_conf")
    def test_get_ports(self, get_conf_mock, get_info_mock):
        """
    Exercises the get_ports() and get_listeners() methods.
    """

        # Exercise as an old version of tor that doesn't support the 'GETINFO
        # net/listeners/*' options.

        get_info_mock.side_effect = InvalidArguments

        get_conf_mock.side_effect = lambda param, **kwargs: {
            "ControlPort": "9050",
            "ControlListenAddress": ["127.0.0.1"],
        }[param]

        self.assertEqual([("127.0.0.1", 9050)], self.controller.get_listeners(Listener.CONTROL))
        self.assertEqual([9050], self.controller.get_ports(Listener.CONTROL))

        # non-local addresss

        get_conf_mock.side_effect = lambda param, **kwargs: {
            "ControlPort": "9050",
            "ControlListenAddress": ["27.4.4.1"],
        }[param]

        self.assertEqual([("27.4.4.1", 9050)], self.controller.get_listeners(Listener.CONTROL))
        self.assertEqual([], self.controller.get_ports(Listener.CONTROL))

        # Exercise via the GETINFO option.

        get_info_mock.side_effect = None
        get_info_mock.return_value = '"127.0.0.1:1112" "127.0.0.1:1114"'

        self.assertEqual([("127.0.0.1", 1112), ("127.0.0.1", 1114)], self.controller.get_listeners(Listener.CONTROL))

        self.assertEqual([1112, 1114], self.controller.get_ports(Listener.CONTROL))

        # unix socket file

        get_info_mock.return_value = '"unix:/tmp/tor/socket"'

        self.assertEqual([], self.controller.get_listeners(Listener.CONTROL))
        self.assertEqual([], self.controller.get_ports(Listener.CONTROL))

    @patch("stem.control.Controller.get_info")
    @patch("stem.control.Controller.get_conf")
    def test_get_socks_listeners_old(self, get_conf_mock, get_info_mock):
        """
    Exercises the get_socks_listeners() method as though talking to an old tor
    instance.
    """

        # An old tor raises stem.InvalidArguments for get_info about socks, but
        # get_socks_listeners should work anyway.

        get_info_mock.side_effect = InvalidArguments

        get_conf_mock.side_effect = lambda param, **kwargs: {"SocksPort": "9050", "SocksListenAddress": ["127.0.0.1"]}[
            param
        ]

        self.assertEqual([("127.0.0.1", 9050)], self.controller.get_socks_listeners())

        # Again, an old tor, but SocksListenAddress overrides the port number.

        get_conf_mock.side_effect = lambda param, **kwargs: {
            "SocksPort": "9050",
            "SocksListenAddress": ["127.0.0.1:1112"],
        }[param]

        self.assertEqual([("127.0.0.1", 1112)], self.controller.get_socks_listeners())

        # Again, an old tor, but multiple listeners

        get_conf_mock.side_effect = lambda param, **kwargs: {
            "SocksPort": "9050",
            "SocksListenAddress": ["127.0.0.1:1112", "127.0.0.1:1114"],
        }[param]

        self.assertEqual([("127.0.0.1", 1112), ("127.0.0.1", 1114)], self.controller.get_socks_listeners())

        # Again, an old tor, but no SOCKS listeners

        get_conf_mock.side_effect = lambda param, **kwargs: {"SocksPort": "0", "SocksListenAddress": []}[param]

        self.assertEqual([], self.controller.get_socks_listeners())

        # Where tor provides invalid ports or addresses

        get_conf_mock.side_effect = lambda param, **kwargs: {"SocksPort": "blarg", "SocksListenAddress": ["127.0.0.1"]}[
            param
        ]

        self.assertRaises(stem.ProtocolError, self.controller.get_socks_listeners)

        get_conf_mock.side_effect = lambda param, **kwargs: {"SocksPort": "0", "SocksListenAddress": ["127.0.0.1:abc"]}[
            param
        ]

        self.assertRaises(stem.ProtocolError, self.controller.get_socks_listeners)

        get_conf_mock.side_effect = lambda param, **kwargs: {"SocksPort": "40", "SocksListenAddress": ["500.0.0.1"]}[
            param
        ]

        self.assertRaises(stem.ProtocolError, self.controller.get_socks_listeners)

    @patch("stem.control.Controller.get_info")
    def test_get_socks_listeners_new(self, get_info_mock):
        """
    Exercises the get_socks_listeners() method as if talking to a newer tor
    instance.
    """

        # multiple SOCKS listeners

        get_info_mock.return_value = '"127.0.0.1:1112" "127.0.0.1:1114"'

        self.assertEqual([("127.0.0.1", 1112), ("127.0.0.1", 1114)], self.controller.get_socks_listeners())

        # no SOCKS listeners

        get_info_mock.return_value = ""
        self.assertEqual([], self.controller.get_socks_listeners())

        # check where GETINFO provides malformed content

        invalid_responses = (
            '"127.0.0.1"',  # address only
            '"1112"',  # port only
            '"5127.0.0.1:1112"',  # invlaid address
            '"127.0.0.1:991112"',  # invalid port
        )

        for response in invalid_responses:
            get_info_mock.return_value = response
            self.assertRaises(stem.ProtocolError, self.controller.get_socks_listeners)

    @patch("stem.control.Controller.get_info")
    @patch("time.time", Mock(return_value=1410723598.276578))
    def test_get_accounting_stats(self, get_info_mock):
        """
    Exercises the get_accounting_stats() method.
    """

        get_info_mock.side_effect = lambda param, **kwargs: {
            "accounting/enabled": "1",
            "accounting/hibernating": "awake",
            "accounting/interval-end": "2014-09-14 19:41:00",
            "accounting/bytes": "4837 2050",
            "accounting/bytes-left": "102944 7440",
        }[param]

        expected = stem.control.AccountingStats(
            1410723598.276578,
            "awake",
            datetime.datetime(2014, 9, 14, 19, 41),
            62,
            4837,
            102944,
            107781,
            2050,
            7440,
            9490,
        )

        self.assertEqual(expected, self.controller.get_accounting_stats())

        get_info_mock.side_effect = ControllerError("nope, too bad")
        self.assertRaises(ControllerError, self.controller.get_accounting_stats)
        self.assertEqual("my default", self.controller.get_accounting_stats("my default"))

    @patch("stem.connection.get_protocolinfo")
    def test_get_protocolinfo(self, get_protocolinfo_mock):
        """
    Exercises the get_protocolinfo() method.
    """

        # use the handy mocked protocolinfo response

        get_protocolinfo_mock.return_value = mocking.get_protocolinfo_response()

        # compare the str representation of these object, because the class
        # does not have, nor need, a direct comparison operator

        self.assertEqual(str(mocking.get_protocolinfo_response()), str(self.controller.get_protocolinfo()))

        # raise an exception in the stem.connection.get_protocolinfo() call

        get_protocolinfo_mock.side_effect = ProtocolError

        # get a default value when the call fails

        self.assertEqual("default returned", self.controller.get_protocolinfo(default="default returned"))

        # no default value, accept the error

        self.assertRaises(ProtocolError, self.controller.get_protocolinfo)

    @patch("stem.socket.ControlSocket.is_localhost", Mock(return_value=False))
    def test_get_user_remote(self):
        """
    Exercise the get_user() method for a non-local socket.
    """

        self.assertRaises(ValueError, self.controller.get_user)
        self.assertEqual(123, self.controller.get_user(123))

    @patch("stem.socket.ControlSocket.is_localhost", Mock(return_value=True))
    @patch("stem.control.Controller.get_info", Mock(return_value="atagar"))
    def test_get_user_by_getinfo(self):
        """
    Exercise the get_user() resolution via its getinfo option.
    """

        self.assertEqual("atagar", self.controller.get_user())

    @patch("stem.socket.ControlSocket.is_localhost", Mock(return_value=True))
    @patch("stem.util.system.pid_by_name", Mock(return_value=432))
    @patch("stem.util.system.user", Mock(return_value="atagar"))
    def test_get_user_by_system(self):
        """
    Exercise the get_user() resolution via the system module.
    """

        self.assertEqual("atagar", self.controller.get_user())

    @patch("stem.socket.ControlSocket.is_localhost", Mock(return_value=False))
    def test_get_pid_remote(self):
        """
    Exercise the get_pid() method for a non-local socket.
    """

        self.assertRaises(ValueError, self.controller.get_pid)
        self.assertEqual(123, self.controller.get_pid(123))

    @patch("stem.socket.ControlSocket.is_localhost", Mock(return_value=True))
    @patch("stem.control.Controller.get_info", Mock(return_value="321"))
    def test_get_pid_by_getinfo(self):
        """
    Exercise the get_pid() resolution via its getinfo option.
    """

        self.assertEqual(321, self.controller.get_pid())

    @patch("stem.socket.ControlSocket.is_localhost", Mock(return_value=True))
    @patch("stem.control.Controller.get_conf")
    @patch("stem.control.open", create=True)
    def test_get_pid_by_pid_file(self, open_mock, get_conf_mock):
        """
    Exercise the get_pid() resolution via a PidFile.
    """

        get_conf_mock.return_value = "/tmp/pid_file"
        open_mock.return_value = io.BytesIO(b"432")

        self.assertEqual(432, self.controller.get_pid())
        open_mock.assert_called_once_with("/tmp/pid_file")

    @patch("stem.socket.ControlSocket.is_localhost", Mock(return_value=True))
    @patch("stem.util.system.pid_by_name", Mock(return_value=432))
    def test_get_pid_by_name(self):
        """
    Exercise the get_pid() resolution via the process name.
    """

        self.assertEqual(432, self.controller.get_pid())

    @patch("stem.control.Controller.get_info")
    def test_get_network_status_for_ourselves(self, get_info_mock):
        """
    Exercises the get_network_status() method for getting our own relay.
    """

        # when there's an issue getting our fingerprint

        get_info_mock.side_effect = ControllerError("nope, too bad")

        try:
            self.controller.get_network_status()
            self.fail("We should've raised an exception")
        except ControllerError as exc:
            self.assertEqual("Unable to determine our own fingerprint: nope, too bad", str(exc))

        self.assertEqual("boom", self.controller.get_network_status(default="boom"))

        # successful request

        desc = NS_DESC % ("moria1", "/96bKo4soysolMgKn5Hex2nyFSY")

        get_info_mock.side_effect = lambda param, **kwargs: {
            "fingerprint": "9695DFC35FFEB861329B9F1AB04C46397020CE31",
            "ns/id/9695DFC35FFEB861329B9F1AB04C46397020CE31": desc,
        }[param]

        self.assertEqual(
            stem.descriptor.router_status_entry.RouterStatusEntryV3(desc), self.controller.get_network_status()
        )

    @patch("stem.control.Controller.get_info")
    def test_get_network_status_when_raising_descriptor_unavailable(self, get_info_mock):
        """
    Exercises the get_network_status() method.
    """

        get_info_mock.side_effect = InvalidArguments(
            None, "GETINFO request contained unrecognized keywords: ns/id/5AC9C5AA75BA1F18D8459B326B4B8111A856D290"
        )

        try:
            self.controller.get_network_status("5AC9C5AA75BA1F18D8459B326B4B8111A856D290")
            self.fail("We should've raised an exception")
        except DescriptorUnavailable as exc:
            self.assertEqual(
                "Tor was unable to provide the descriptor for '5AC9C5AA75BA1F18D8459B326B4B8111A856D290'", str(exc)
            )

    @patch("stem.control.Controller.get_info")
    def test_get_network_status(self, get_info_mock):
        """
    Exercises the get_network_status() method.
    """

        # build a single router status entry

        nickname = "Beaver"
        fingerprint = "/96bKo4soysolMgKn5Hex2nyFSY"
        desc = NS_DESC % (nickname, fingerprint)
        router = stem.descriptor.router_status_entry.RouterStatusEntryV3(desc)

        # always return the same router status entry

        get_info_mock.return_value = desc

        # pretend to get the router status entry with its name

        self.assertEqual(router, self.controller.get_network_status(nickname))

        # pretend to get the router status entry with its fingerprint

        hex_fingerprint = stem.descriptor.router_status_entry._base64_to_hex(fingerprint, False)
        self.assertEqual(router, self.controller.get_network_status(hex_fingerprint))

        # mangle hex fingerprint and try again

        hex_fingerprint = hex_fingerprint[2:]
        self.assertRaises(ValueError, self.controller.get_network_status, hex_fingerprint)

        # raise an exception in the get_info() call

        get_info_mock.side_effect = InvalidArguments

        # get a default value when the call fails

        self.assertEqual("default returned", self.controller.get_network_status(nickname, default="default returned"))

        # no default value, accept the error

        self.assertRaises(InvalidArguments, self.controller.get_network_status, nickname)

    @patch("stem.control.Controller.is_authenticated", Mock(return_value=True))
    @patch("stem.control.Controller._attach_listeners", Mock(return_value=([], [])))
    @patch("stem.control.Controller.get_version")
    def test_event_listening(self, get_version_mock):
        """
    Exercises the add_event_listener and remove_event_listener methods.
    """

        # set up for failure to create any events

        get_version_mock.return_value = stem.version.Version("0.1.0.14")
        self.assertRaises(InvalidRequest, self.controller.add_event_listener, Mock(), EventType.BW)

        # set up to only fail newer events

        get_version_mock.return_value = stem.version.Version("0.2.0.35")

        # EventType.BW is one of the earliest events

        self.controller.add_event_listener(Mock(), EventType.BW)

        # EventType.SIGNAL was added in tor version 0.2.3.1-alpha
        self.assertRaises(InvalidRequest, self.controller.add_event_listener, Mock(), EventType.SIGNAL)

    def test_get_streams(self):
        """
    Exercises the get_streams() method.
    """

        # get a list of fake, but good looking, streams
        valid_streams = (
            ("1", "NEW", "4", "10.10.10.1:80"),
            ("2", "SUCCEEDED", "4", "10.10.10.1:80"),
            ("3", "SUCCEEDED", "4", "10.10.10.1:80"),
        )

        response = "".join(["%s\r\n" % " ".join(entry) for entry in valid_streams])

        with patch("stem.control.Controller.get_info", Mock(return_value=response)):
            streams = self.controller.get_streams()
            self.assertEqual(len(valid_streams), len(streams))

            for index, stream in enumerate(streams):
                self.assertEqual(valid_streams[index][0], stream.id)
                self.assertEqual(valid_streams[index][1], stream.status)
                self.assertEqual(valid_streams[index][2], stream.circ_id)
                self.assertEqual(valid_streams[index][3], stream.target)

    def test_attach_stream(self):
        """
    Exercises the attach_stream() method.
    """

        # Response when the stream is in a state where it can't be attached (for
        # instance, it's already open).

        response = stem.response.ControlMessage.from_str("555 Connection is not managed by controller.\r\n")

        with patch("stem.control.Controller.msg", Mock(return_value=response)):
            self.assertRaises(UnsatisfiableRequest, self.controller.attach_stream, "stream_id", "circ_id")

    def test_parse_circ_path(self):
        """
    Exercises the _parse_circ_path() helper function.
    """

        # empty input

        self.assertEqual([], _parse_circ_path(None))
        self.assertEqual([], _parse_circ_path(""))

        # check the pydoc examples

        pydoc_examples = {
            "$999A226EBED397F331B612FE1E4CFAE5C1F201BA=piyaz": [("999A226EBED397F331B612FE1E4CFAE5C1F201BA", "piyaz")],
            "$E57A476CD4DFBD99B4EE52A100A58610AD6E80B9,hamburgerphone,PrivacyRepublic14": [
                ("E57A476CD4DFBD99B4EE52A100A58610AD6E80B9", None),
                (None, "hamburgerphone"),
                (None, "PrivacyRepublic14"),
            ],
        }

        for test_input, expected in pydoc_examples.items():
            self.assertEqual(expected, _parse_circ_path(test_input))

        # exercise with some invalid inputs

        malformed_inputs = [
            "=piyaz",  # no fingerprint
            "999A226EBED397F331B612FE1E4CFAE5C1F201BA=piyaz",  # fingerprint missing prefix
            "$999A226EBED397F331B612FE1E4CFAE5C1F201BAA=piyaz",  # fingerprint too long
            "$999A226EBED397F331B612FE1E4CFAE5C1F201B=piyaz",  # fingerprint too short
            "$999A226EBED397F331B612FE1E4CFAE5C1F201Bz=piyaz",  # invalid character in fingerprint
            "$999A226EBED397F331B612FE1E4CFAE5C1F201BA=",  # no nickname
        ]

        for test_input in malformed_inputs:
            self.assertRaises(ProtocolError, _parse_circ_path, test_input)

    @patch("stem.control.Controller.get_conf")
    def test_get_effective_rate(self, get_conf_mock):
        """
    Exercise the get_effective_rate() method.
    """

        # check default if nothing was set

        get_conf_mock.side_effect = lambda param, **kwargs: {
            "BandwidthRate": "1073741824",
            "BandwidthBurst": "1073741824",
            "RelayBandwidthRate": "0",
            "RelayBandwidthBurst": "0",
            "MaxAdvertisedBandwidth": "1073741824",
        }[param]

        self.assertEqual(1073741824, self.controller.get_effective_rate())
        self.assertEqual(1073741824, self.controller.get_effective_rate(burst=True))

        get_conf_mock.side_effect = ControllerError("nope, too bad")
        self.assertRaises(ControllerError, self.controller.get_effective_rate)
        self.assertEqual("my_default", self.controller.get_effective_rate("my_default"))

    @patch("stem.control.Controller.get_version")
    def test_drop_guards(self, get_version_mock):
        """
    Exercises the drop_guards() method.
    """

        get_version_mock.return_value = stem.version.Version("0.1.0.14")
        self.assertRaises(UnsatisfiableRequest, self.controller.drop_guards)

        with patch("stem.control.Controller.msg", Mock(return_value=None)):
            get_version_mock.return_value = stem.version.Version("0.2.5.2")
            self.controller.drop_guards()
Exemple #6
0
class TestControl(unittest.TestCase):
  def setUp(self):
    socket = stem.socket.ControlSocket()

    with patch('stem.control.Controller.add_event_listener', Mock()):
      self.controller = Controller(socket)

  def test_event_description(self):
    self.assertEqual("Logging at the debug runlevel. This is low level, high volume information about tor's internals that generally isn't useful to users.", stem.control.event_description('DEBUG'))
    self.assertEqual('Event emitted every second with the bytes sent and received by tor.', stem.control.event_description('BW'))
    self.assertEqual('Event emitted every second with the bytes sent and received by tor.', stem.control.event_description('bw'))

  def test_event_description_includes_all_events(self):
    self.assertEqual(None, stem.control.event_description('NO_SUCH_EVENT'))

    for event in stem.control.EventType:
      self.assertTrue(stem.control.event_description(event) is not None)

  @patch('stem.control.Controller.get_info')
  def test_get_version(self, get_info_mock):
    """
    Exercises the get_version() method.
    """

    try:
      # Use one version for first check.
      version_2_1 = '0.2.1.32'
      version_2_1_object = stem.version.Version(version_2_1)
      get_info_mock.return_value = version_2_1

      # Return a version with a cold cache.
      self.assertEqual(version_2_1_object, self.controller.get_version())

      # Use a different version for second check.
      version_2_2 = '0.2.2.39'
      version_2_2_object = stem.version.Version(version_2_2)
      get_info_mock.return_value = version_2_2

      # Return a version with a hot cache, so it will be the old version.
      self.assertEqual(version_2_1_object, self.controller.get_version())

      # Turn off caching.
      self.controller._is_caching_enabled = False
      # Return a version without caching, so it will be the new version.
      self.assertEqual(version_2_2_object, self.controller.get_version())

      # Spec says the getinfo response may optionally be prefixed by 'Tor '. In
      # practice it doesn't but we should accept that.
      get_info_mock.return_value = 'Tor 0.2.1.32'
      self.assertEqual(version_2_1_object, self.controller.get_version())

      # Raise an exception in the get_info() call.
      get_info_mock.side_effect = InvalidArguments

      # Get a default value when the call fails.
      self.assertEqual(
        'default returned',
        self.controller.get_version(default = 'default returned')
      )

      # No default value, accept the error.
      self.assertRaises(InvalidArguments, self.controller.get_version)

      # Give a bad version.  The stem.version.Version ValueError should bubble up.
      version_A_42 = '0.A.42.spam'
      get_info_mock.return_value = version_A_42
      get_info_mock.side_effect = None
      self.assertRaises(ValueError, self.controller.get_version)
    finally:
      # Turn caching back on before we leave.
      self.controller._is_caching_enabled = True

  @patch('stem.control.Controller.get_info')
  @patch('stem.control.Controller.get_conf')
  def test_get_exit_policy(self, get_conf_mock, get_info_mock):
    """
    Exercises the get_exit_policy() method.
    """

    get_conf_mock.side_effect = lambda param, **kwargs: {
      'ExitPolicyRejectPrivate': '1',
      'ExitPolicy': ['accept *:80,   accept *:443', 'accept 43.5.5.5,reject *:22'],
    }[param]

    get_info_mock.side_effect = lambda param, default = None: {
      'address': '123.45.67.89',
      'exit-policy/default': 'reject *:25,reject *:119,reject *:135-139,reject *:445,reject *:563,reject *:1214,reject *:4661-4666,reject *:6346-6429,reject *:6699,reject *:6881-6999,accept *:*',
    }[param]

    expected = ExitPolicy(
      'reject 0.0.0.0/8:*',  # private entries
      'reject 169.254.0.0/16:*',
      'reject 127.0.0.0/8:*',
      'reject 192.168.0.0/16:*',
      'reject 10.0.0.0/8:*',
      'reject 172.16.0.0/12:*',
      'reject 123.45.67.89:*',  # relay's public address
      'accept *:80',  # finally we get to our ExitPolicy
      'accept *:443',
      'accept 43.5.5.5:*',
      'reject *:22',
      'reject *:25',  # default policy
      'reject *:119',
      'reject *:135-139',
      'reject *:445',
      'reject *:563',
      'reject *:1214',
      'reject *:4661-4666',
      'reject *:6346-6429',
      'reject *:6699',
      'reject *:6881-6999',
      'accept *:*',
    )

    self.assertEqual(expected, self.controller.get_exit_policy())

  @patch('stem.control.Controller.get_info')
  @patch('stem.control.Controller.get_conf')
  def test_get_ports(self, get_conf_mock, get_info_mock):
    """
    Exercises the get_ports() and get_listeners() methods.
    """

    # Exercise as an old version of tor that doesn't support the 'GETINFO
    # net/listeners/*' options.

    get_info_mock.side_effect = InvalidArguments

    get_conf_mock.side_effect = lambda param, **kwargs: {
      'ControlPort': '9050',
      'ControlListenAddress': ['127.0.0.1'],
    }[param]

    self.assertEqual([('127.0.0.1', 9050)], self.controller.get_listeners(Listener.CONTROL))
    self.assertEqual([9050], self.controller.get_ports(Listener.CONTROL))

    # non-local addresss

    get_conf_mock.side_effect = lambda param, **kwargs: {
      'ControlPort': '9050',
      'ControlListenAddress': ['27.4.4.1'],
    }[param]

    self.assertEqual([('27.4.4.1', 9050)], self.controller.get_listeners(Listener.CONTROL))
    self.assertEqual([], self.controller.get_ports(Listener.CONTROL))

    # Exercise via the GETINFO option.

    get_info_mock.side_effect = None
    get_info_mock.return_value = '"127.0.0.1:1112" "127.0.0.1:1114"'

    self.assertEqual(
      [('127.0.0.1', 1112), ('127.0.0.1', 1114)],
      self.controller.get_listeners(Listener.CONTROL)
    )

    self.assertEqual([1112, 1114], self.controller.get_ports(Listener.CONTROL))

    # IPv6 address

    get_info_mock.return_value = '"0.0.0.0:9001" "[fe80:0000:0000:0000:0202:b3ff:fe1e:8329]:9001"'

    self.assertEqual(
      [('0.0.0.0', 9001), ('fe80:0000:0000:0000:0202:b3ff:fe1e:8329', 9001)],
      self.controller.get_listeners(Listener.CONTROL)
    )

    # unix socket file

    get_info_mock.return_value = '"unix:/tmp/tor/socket"'

    self.assertEqual([], self.controller.get_listeners(Listener.CONTROL))
    self.assertEqual([], self.controller.get_ports(Listener.CONTROL))

  @patch('stem.control.Controller.get_info')
  @patch('stem.control.Controller.get_conf')
  def test_get_socks_listeners_old(self, get_conf_mock, get_info_mock):
    """
    Exercises the get_socks_listeners() method as though talking to an old tor
    instance.
    """

    # An old tor raises stem.InvalidArguments for get_info about socks, but
    # get_socks_listeners should work anyway.

    get_info_mock.side_effect = InvalidArguments

    get_conf_mock.side_effect = lambda param, **kwargs: {
      'SocksPort': '9050',
      'SocksListenAddress': ['127.0.0.1'],
    }[param]

    self.assertEqual([('127.0.0.1', 9050)], self.controller.get_socks_listeners())

    # Again, an old tor, but SocksListenAddress overrides the port number.

    get_conf_mock.side_effect = lambda param, **kwargs: {
      'SocksPort': '9050',
      'SocksListenAddress': ['127.0.0.1:1112'],
    }[param]

    self.assertEqual([('127.0.0.1', 1112)], self.controller.get_socks_listeners())

    # Again, an old tor, but multiple listeners

    get_conf_mock.side_effect = lambda param, **kwargs: {
      'SocksPort': '9050',
      'SocksListenAddress': ['127.0.0.1:1112', '127.0.0.1:1114'],
    }[param]

    self.assertEqual([('127.0.0.1', 1112), ('127.0.0.1', 1114)], self.controller.get_socks_listeners())

    # Again, an old tor, but no SOCKS listeners

    get_conf_mock.side_effect = lambda param, **kwargs: {
      'SocksPort': '0',
      'SocksListenAddress': [],
    }[param]

    self.assertEqual([], self.controller.get_socks_listeners())

    # Where tor provides invalid ports or addresses

    get_conf_mock.side_effect = lambda param, **kwargs: {
      'SocksPort': 'blarg',
      'SocksListenAddress': ['127.0.0.1'],
    }[param]

    self.assertRaises(stem.ProtocolError, self.controller.get_socks_listeners)

    get_conf_mock.side_effect = lambda param, **kwargs: {
      'SocksPort': '0',
      'SocksListenAddress': ['127.0.0.1:abc'],
    }[param]

    self.assertRaises(stem.ProtocolError, self.controller.get_socks_listeners)

    get_conf_mock.side_effect = lambda param, **kwargs: {
      'SocksPort': '40',
      'SocksListenAddress': ['500.0.0.1'],
    }[param]

    self.assertRaises(stem.ProtocolError, self.controller.get_socks_listeners)

  @patch('stem.control.Controller.get_info')
  def test_get_socks_listeners_new(self, get_info_mock):
    """
    Exercises the get_socks_listeners() method as if talking to a newer tor
    instance.
    """

    # multiple SOCKS listeners

    get_info_mock.return_value = '"127.0.0.1:1112" "127.0.0.1:1114"'

    self.assertEqual(
      [('127.0.0.1', 1112), ('127.0.0.1', 1114)],
      self.controller.get_socks_listeners()
    )

    # no SOCKS listeners

    get_info_mock.return_value = ''
    self.assertEqual([], self.controller.get_socks_listeners())

    # check where GETINFO provides malformed content

    invalid_responses = (
      '"127.0.0.1"',         # address only
      '"1112"',              # port only
      '"5127.0.0.1:1112"',   # invlaid address
      '"127.0.0.1:991112"',  # invalid port
    )

    for response in invalid_responses:
      get_info_mock.return_value = response
      self.assertRaises(stem.ProtocolError, self.controller.get_socks_listeners)

  @patch('stem.control.Controller.get_info')
  @patch('time.time', Mock(return_value = 1410723598.276578))
  def test_get_accounting_stats(self, get_info_mock):
    """
    Exercises the get_accounting_stats() method.
    """

    get_info_mock.side_effect = lambda param, **kwargs: {
      'accounting/enabled': '1',
      'accounting/hibernating': 'awake',
      'accounting/interval-end': '2014-09-14 19:41:00',
      'accounting/bytes': '4837 2050',
      'accounting/bytes-left': '102944 7440',
    }[param]

    expected = stem.control.AccountingStats(
      1410723598.276578,
      'awake',
      datetime.datetime(2014, 9, 14, 19, 41),
      62,
      4837, 102944, 107781,
      2050, 7440, 9490,
    )

    self.assertEqual(expected, self.controller.get_accounting_stats())

    get_info_mock.side_effect = ControllerError('nope, too bad')
    self.assertRaises(ControllerError, self.controller.get_accounting_stats)
    self.assertEqual('my default', self.controller.get_accounting_stats('my default'))

  @patch('stem.connection.get_protocolinfo')
  def test_get_protocolinfo(self, get_protocolinfo_mock):
    """
    Exercises the get_protocolinfo() method.
    """

    # use the handy mocked protocolinfo response

    protocolinfo_msg = ControlMessage.from_str('250-PROTOCOLINFO 1\r\n250 OK\r\n', 'PROTOCOLINFO')
    get_protocolinfo_mock.return_value = protocolinfo_msg

    # compare the str representation of these object, because the class
    # does not have, nor need, a direct comparison operator

    self.assertEqual(
      str(protocolinfo_msg),
      str(self.controller.get_protocolinfo())
    )

    # raise an exception in the stem.connection.get_protocolinfo() call

    get_protocolinfo_mock.side_effect = ProtocolError

    # get a default value when the call fails

    self.assertEqual(
      'default returned',
      self.controller.get_protocolinfo(default = 'default returned')
    )

    # no default value, accept the error

    self.assertRaises(ProtocolError, self.controller.get_protocolinfo)

  @patch('stem.socket.ControlSocket.is_localhost', Mock(return_value = False))
  def test_get_user_remote(self):
    """
    Exercise the get_user() method for a non-local socket.
    """

    self.assertRaises(ValueError, self.controller.get_user)
    self.assertEqual(123, self.controller.get_user(123))

  @patch('stem.socket.ControlSocket.is_localhost', Mock(return_value = True))
  @patch('stem.control.Controller.get_info', Mock(return_value = 'atagar'))
  def test_get_user_by_getinfo(self):
    """
    Exercise the get_user() resolution via its getinfo option.
    """

    self.assertEqual('atagar', self.controller.get_user())

  @patch('stem.socket.ControlSocket.is_localhost', Mock(return_value = True))
  @patch('stem.util.system.pid_by_name', Mock(return_value = 432))
  @patch('stem.util.system.user', Mock(return_value = 'atagar'))
  def test_get_user_by_system(self):
    """
    Exercise the get_user() resolution via the system module.
    """

    self.assertEqual('atagar', self.controller.get_user())

  @patch('stem.socket.ControlSocket.is_localhost', Mock(return_value = False))
  def test_get_pid_remote(self):
    """
    Exercise the get_pid() method for a non-local socket.
    """

    self.assertRaises(ValueError, self.controller.get_pid)
    self.assertEqual(123, self.controller.get_pid(123))

  @patch('stem.socket.ControlSocket.is_localhost', Mock(return_value = True))
  @patch('stem.control.Controller.get_info', Mock(return_value = '321'))
  def test_get_pid_by_getinfo(self):
    """
    Exercise the get_pid() resolution via its getinfo option.
    """

    self.assertEqual(321, self.controller.get_pid())

  @patch('stem.socket.ControlSocket.is_localhost', Mock(return_value = True))
  @patch('stem.control.Controller.get_conf')
  @patch('stem.control.open', create = True)
  def test_get_pid_by_pid_file(self, open_mock, get_conf_mock):
    """
    Exercise the get_pid() resolution via a PidFile.
    """

    get_conf_mock.return_value = '/tmp/pid_file'
    open_mock.return_value = io.BytesIO(b'432')

    self.assertEqual(432, self.controller.get_pid())
    open_mock.assert_called_once_with('/tmp/pid_file')

  @patch('stem.socket.ControlSocket.is_localhost', Mock(return_value = True))
  @patch('stem.util.system.pid_by_name', Mock(return_value = 432))
  def test_get_pid_by_name(self):
    """
    Exercise the get_pid() resolution via the process name.
    """

    self.assertEqual(432, self.controller.get_pid())

  @patch('stem.control.Controller.get_info')
  def test_get_network_status_for_ourselves(self, get_info_mock):
    """
    Exercises the get_network_status() method for getting our own relay.
    """

    # when there's an issue getting our fingerprint

    get_info_mock.side_effect = ControllerError('nope, too bad')

    exc_msg = 'Unable to determine our own fingerprint: nope, too bad'
    self.assertRaisesRegexp(ControllerError, exc_msg, self.controller.get_network_status)
    self.assertEqual('boom', self.controller.get_network_status(default = 'boom'))

    # successful request

    desc = NS_DESC % ('moria1', '/96bKo4soysolMgKn5Hex2nyFSY')

    get_info_mock.side_effect = lambda param, **kwargs: {
      'fingerprint': '9695DFC35FFEB861329B9F1AB04C46397020CE31',
      'ns/id/9695DFC35FFEB861329B9F1AB04C46397020CE31': desc,
    }[param]

    self.assertEqual(stem.descriptor.router_status_entry.RouterStatusEntryV3(desc), self.controller.get_network_status())

  @patch('stem.control.Controller.get_info')
  def test_get_network_status_when_unavailable(self, get_info_mock):
    """
    Exercises the get_network_status() method.
    """

    get_info_mock.side_effect = InvalidArguments(None, 'GETINFO request contained unrecognized keywords: ns/id/5AC9C5AA75BA1F18D8459B326B4B8111A856D290')

    exc_msg = "Tor was unable to provide the descriptor for '5AC9C5AA75BA1F18D8459B326B4B8111A856D290'"
    self.assertRaisesRegexp(DescriptorUnavailable, exc_msg, self.controller.get_network_status, '5AC9C5AA75BA1F18D8459B326B4B8111A856D290')

  @patch('stem.control.Controller.get_info')
  def test_get_network_status(self, get_info_mock):
    """
    Exercises the get_network_status() method.
    """

    # build a single router status entry

    nickname = 'Beaver'
    fingerprint = '/96bKo4soysolMgKn5Hex2nyFSY'
    desc = NS_DESC % (nickname, fingerprint)
    router = stem.descriptor.router_status_entry.RouterStatusEntryV3(desc)

    # always return the same router status entry

    get_info_mock.return_value = desc

    # pretend to get the router status entry with its name

    self.assertEqual(router, self.controller.get_network_status(nickname))

    # pretend to get the router status entry with its fingerprint

    hex_fingerprint = stem.descriptor.router_status_entry._base64_to_hex(fingerprint, False)
    self.assertEqual(router, self.controller.get_network_status(hex_fingerprint))

    # mangle hex fingerprint and try again

    hex_fingerprint = hex_fingerprint[2:]
    self.assertRaises(ValueError, self.controller.get_network_status, hex_fingerprint)

    # raise an exception in the get_info() call

    get_info_mock.side_effect = InvalidArguments

    # get a default value when the call fails

    self.assertEqual(
      'default returned',
      self.controller.get_network_status(nickname, default = 'default returned')
    )

    # no default value, accept the error

    self.assertRaises(InvalidArguments, self.controller.get_network_status, nickname)

  @patch('stem.control.Controller.is_authenticated', Mock(return_value = True))
  @patch('stem.control.Controller._attach_listeners', Mock(return_value = ([], [])))
  @patch('stem.control.Controller.get_version')
  def test_event_listening(self, get_version_mock):
    """
    Exercises the add_event_listener and remove_event_listener methods.
    """

    # set up for failure to create any events

    get_version_mock.return_value = stem.version.Version('0.1.0.14')
    self.assertRaises(InvalidRequest, self.controller.add_event_listener, Mock(), EventType.BW)

    # set up to only fail newer events

    get_version_mock.return_value = stem.version.Version('0.2.0.35')

    # EventType.BW is one of the earliest events

    self.controller.add_event_listener(Mock(), EventType.BW)

    # EventType.SIGNAL was added in tor version 0.2.3.1-alpha
    self.assertRaises(InvalidRequest, self.controller.add_event_listener, Mock(), EventType.SIGNAL)

  def test_get_streams(self):
    """
    Exercises the get_streams() method.
    """

    # get a list of fake, but good looking, streams
    valid_streams = (
      ('1', 'NEW', '4', '10.10.10.1:80'),
      ('2', 'SUCCEEDED', '4', '10.10.10.1:80'),
      ('3', 'SUCCEEDED', '4', '10.10.10.1:80')
    )

    response = ''.join(['%s\r\n' % ' '.join(entry) for entry in valid_streams])

    with patch('stem.control.Controller.get_info', Mock(return_value = response)):
      streams = self.controller.get_streams()
      self.assertEqual(len(valid_streams), len(streams))

      for index, stream in enumerate(streams):
        self.assertEqual(valid_streams[index][0], stream.id)
        self.assertEqual(valid_streams[index][1], stream.status)
        self.assertEqual(valid_streams[index][2], stream.circ_id)
        self.assertEqual(valid_streams[index][3], stream.target)

  def test_attach_stream(self):
    """
    Exercises the attach_stream() method.
    """

    # Response when the stream is in a state where it can't be attached (for
    # instance, it's already open).

    response = stem.response.ControlMessage.from_str('555 Connection is not managed by controller.\r\n')

    with patch('stem.control.Controller.msg', Mock(return_value = response)):
      self.assertRaises(UnsatisfiableRequest, self.controller.attach_stream, 'stream_id', 'circ_id')

  def test_parse_circ_path(self):
    """
    Exercises the _parse_circ_path() helper function.
    """

    # empty input

    self.assertEqual([], _parse_circ_path(None))
    self.assertEqual([], _parse_circ_path(''))

    # check the pydoc examples

    pydoc_examples = {
      '$999A226EBED397F331B612FE1E4CFAE5C1F201BA=piyaz':
        [('999A226EBED397F331B612FE1E4CFAE5C1F201BA', 'piyaz')],
      '$E57A476CD4DFBD99B4EE52A100A58610AD6E80B9,hamburgerphone,PrivacyRepublic14':
        [
          ('E57A476CD4DFBD99B4EE52A100A58610AD6E80B9', None),
          (None, 'hamburgerphone'),
          (None, 'PrivacyRepublic14'),
        ],
    }

    for test_input, expected in pydoc_examples.items():
      self.assertEqual(expected, _parse_circ_path(test_input))

    # exercise with some invalid inputs

    malformed_inputs = [
      '=piyaz',  # no fingerprint
      '999A226EBED397F331B612FE1E4CFAE5C1F201BA=piyaz',  # fingerprint missing prefix
      '$999A226EBED397F331B612FE1E4CFAE5C1F201BAA=piyaz',  # fingerprint too long
      '$999A226EBED397F331B612FE1E4CFAE5C1F201B=piyaz',  # fingerprint too short
      '$999A226EBED397F331B612FE1E4CFAE5C1F201Bz=piyaz',  # invalid character in fingerprint
      '$999A226EBED397F331B612FE1E4CFAE5C1F201BA=',  # no nickname
    ]

    for test_input in malformed_inputs:
      self.assertRaises(ProtocolError, _parse_circ_path, test_input)

  @patch('stem.control.Controller.get_conf')
  def test_get_effective_rate(self, get_conf_mock):
    """
    Exercise the get_effective_rate() method.
    """

    # check default if nothing was set

    get_conf_mock.side_effect = lambda param, **kwargs: {
      'BandwidthRate': '1073741824',
      'BandwidthBurst': '1073741824',
      'RelayBandwidthRate': '0',
      'RelayBandwidthBurst': '0',
      'MaxAdvertisedBandwidth': '1073741824',
    }[param]

    self.assertEqual(1073741824, self.controller.get_effective_rate())
    self.assertEqual(1073741824, self.controller.get_effective_rate(burst = True))

    get_conf_mock.side_effect = ControllerError('nope, too bad')
    self.assertRaises(ControllerError, self.controller.get_effective_rate)
    self.assertEqual('my_default', self.controller.get_effective_rate('my_default'))

  @patch('stem.control.Controller.get_version')
  def test_drop_guards(self, get_version_mock):
    """
    Exercises the drop_guards() method.
    """

    get_version_mock.return_value = stem.version.Version('0.1.0.14')
    self.assertRaises(UnsatisfiableRequest, self.controller.drop_guards)

    with patch('stem.control.Controller.msg', Mock(return_value = None)):
      get_version_mock.return_value = stem.version.Version('0.2.5.2')
      self.controller.drop_guards()