def test_platform_empty(self):
"""
Constructs with an empty platform entry.
"""
desc_text = RelayDescriptor.content({'platform': ''})
desc = RelayDescriptor(desc_text, validate=False)
self.assertEqual(b'', desc.platform)
# does the same but with 'platform ' replaced with 'platform'
desc_text = desc_text.replace(b'platform ', b'platform')
desc = RelayDescriptor(desc_text, validate=False)
self.assertEqual(b'', desc.platform)
def test_platform_empty(self):
"""
Constructs with an empty platform entry.
"""
desc_text = get_relay_server_descriptor({"platform": ""}, content = True)
desc = RelayDescriptor(desc_text, validate = False)
self.assertEquals(b"", desc.platform)
# does the same but with 'platform ' replaced with 'platform'
desc_text = desc_text.replace(b"platform ", b"platform")
desc = RelayDescriptor(desc_text, validate = False)
self.assertEquals(b"", desc.platform)
def test_mirror_mirror_on_the_wall_5(self, downloader_mock, stdout_mock):
def tutorial_example():
from stem.descriptor.remote import DescriptorDownloader
from stem.util import str_tools
# provides a mapping of observed bandwidth to the relay nicknames
def get_bw_to_relay():
bw_to_relay = {}
downloader = DescriptorDownloader()
try:
for desc in downloader.get_server_descriptors().run():
if desc.exit_policy.is_exiting_allowed():
bw_to_relay.setdefault(desc.observed_bandwidth,
[]).append(desc.nickname)
except Exception as exc:
print('Unable to retrieve the server descriptors: %s' %
exc)
return bw_to_relay
# prints the top fifteen relays
bw_to_relay = get_bw_to_relay()
count = 1
for bw_value in sorted(bw_to_relay.keys(), reverse=True):
for nickname in bw_to_relay[bw_value]:
print('%i. %s (%s/s)' %
(count, nickname, str_tools.size_label(bw_value, 2)))
count += 1
if count > 15:
return
exit_descriptor = mocking.get_relay_server_descriptor(
{
'router': 'speedyexit 149.255.97.109 9001 0 0'
}, content=True).replace(b'reject *:*', b'accept *:*')
exit_descriptor = mocking.sign_descriptor_content(exit_descriptor)
exit_descriptor = RelayDescriptor(exit_descriptor)
downloader_mock().get_server_descriptors().run.return_value = [
exit_descriptor,
mocking.get_relay_server_descriptor(), # non-exit
exit_descriptor,
exit_descriptor,
]
tutorial_example()
self.assertEqual(MIRROR_MIRROR_OUTPUT, stdout_mock.getvalue())
def test_published_leap_year(self):
"""
Constructs with a published entry for a leap year, and when the date is
invalid.
"""
desc_text = get_relay_server_descriptor({"published": "2011-02-29 04:03:19"}, content = True)
self._expect_invalid_attr(desc_text, "published")
desc_text = get_relay_server_descriptor({"published": "2012-02-29 04:03:19"}, content = True)
expected_published = datetime.datetime(2012, 2, 29, 4, 3, 19)
self.assertEquals(expected_published, RelayDescriptor(desc_text).published)
def test_mirror_mirror_on_the_wall_4(self, from_port_mock, stdout_mock):
def tutorial_example():
from stem.control import Controller
from stem.util import str_tools
# provides a mapping of observed bandwidth to the relay nicknames
def get_bw_to_relay():
bw_to_relay = {}
with Controller.from_port(control_port=9051) as controller:
controller.authenticate()
for desc in controller.get_server_descriptors():
if desc.exit_policy.is_exiting_allowed():
bw_to_relay.setdefault(desc.observed_bandwidth,
[]).append(desc.nickname)
return bw_to_relay
# prints the top fifteen relays
bw_to_relay = get_bw_to_relay()
count = 1
for bw_value in sorted(bw_to_relay.keys(), reverse=True):
for nickname in bw_to_relay[bw_value]:
print "%i. %s (%s/s)" % (
count, nickname, str_tools.get_size_label(bw_value, 2))
count += 1
if count > 15:
return
exit_descriptor = mocking.get_relay_server_descriptor(
{
'router': 'speedyexit 149.255.97.109 9001 0 0'
}, content=True).replace(b'reject *:*', b'accept *:*')
exit_descriptor = mocking.sign_descriptor_content(exit_descriptor)
exit_descriptor = RelayDescriptor(exit_descriptor)
controller = from_port_mock().__enter__()
controller.get_server_descriptors.return_value = [
exit_descriptor,
mocking.get_relay_server_descriptor(), # non-exit
exit_descriptor,
exit_descriptor,
]
tutorial_example()
self.assertEqual(MIRROR_MIRROR_OUTPUT, stdout_mock.getvalue())
def test_mirror_mirror_on_the_wall(self):
from stem.descriptor.server_descriptor import RelayDescriptor
from stem.descriptor.reader import DescriptorReader
from stem.util import str_tools
exit_descriptor = mocking.get_relay_server_descriptor({
'router': 'speedyexit 149.255.97.109 9001 0 0'
}, content = True).replace('reject *:*', 'accept *:*')
exit_descriptor = mocking.sign_descriptor_content(exit_descriptor)
exit_descriptor = RelayDescriptor(exit_descriptor)
reader_wrapper = mocking.get_object(DescriptorReader, {
'__enter__': lambda x: x,
'__exit__': mocking.no_op(),
'__iter__': mocking.return_value(iter((
exit_descriptor,
mocking.get_relay_server_descriptor(), # non-exit
exit_descriptor,
exit_descriptor,
)))
})
# provides a mapping of observed bandwidth to the relay nicknames
def get_bw_to_relay():
bw_to_relay = {}
with reader_wrapper as reader:
for desc in reader:
if desc.exit_policy.is_exiting_allowed():
bw_to_relay.setdefault(desc.observed_bandwidth, []).append(desc.nickname)
return bw_to_relay
# prints the top fifteen relays
bw_to_relay = get_bw_to_relay()
count = 1
for bw_value in sorted(bw_to_relay.keys(), reverse = True):
for nickname in bw_to_relay[bw_value]:
expected_line = "%i. speedyexit (102.13 KB/s)" % count
printed_line = "%i. %s (%s/s)" % (count, nickname, str_tools.get_size_label(bw_value, 2))
self.assertEqual(expected_line, printed_line)
count += 1
if count > 15:
return
self.assertEqual(4, count)
def test_tor_descriptors(self, stdout_mock, downloader_mock):
exit_descriptor = RelayDescriptor.content({
'router':
'speedyexit 149.255.97.109 9001 0 0'
}).replace(b'reject *:*', b'accept *:*')
exit_descriptor = RelayDescriptor(exit_descriptor)
downloader_mock().get_server_descriptors().run.return_value = [
exit_descriptor,
RelayDescriptor.create(), # non-exit
exit_descriptor,
exit_descriptor,
]
import tor_descriptors
self.assertEqual(EXPECTED_TOR_DESCRIPTORS, stdout_mock.getvalue())
def _expect_invalid_attr(self, desc_text, attr=None, expected_value=None):
"""
Asserts that construction will fail due to desc_text having a malformed
attribute. If an attr is provided then we check that it matches an expected
value when we're constructed without validation.
"""
self.assertRaises(ValueError, RelayDescriptor, desc_text, True)
desc = RelayDescriptor(desc_text, validate=False)
if attr:
# check that the invalid attribute matches the expected value when
# constructed without validation
self.assertEqual(expected_value, getattr(desc, attr))
else:
# check a default attribute
self.assertEqual('caerSidi', desc.nickname)
def main(reactor):
proto = yield txtorcon.build_local_tor_connection(reactor,
build_state=False)
or_nickname = "moria1"
print "Trying to get decriptor information about", or_nickname
# If the fingerprint is used in place of nickname then, desc/id/<OR identity>
# should be used.
descriptor_info = yield proto.get_info('desc/name/' + or_nickname)
descriptor_info = descriptor_info['desc/name/' + or_nickname]
try:
from stem.descriptor.server_descriptor import RelayDescriptor
relay_info = RelayDescriptor(descriptor_info)
print "The relay's fingerprint is:", relay_info.fingerprint
print "Time in UTC when the descriptor was made:", relay_info.published
except ImportError as e:
print "Error:", e
def test_missing_required_attr(self):
"""
Test making a descriptor with a missing required attribute.
"""
for attr in stem.descriptor.server_descriptor.REQUIRED_FIELDS:
desc_text = RelayDescriptor.content(exclude=[attr])
self.assertRaises(ValueError, RelayDescriptor, desc_text, True)
# check that we can still construct it without validation
desc = RelayDescriptor(desc_text, validate=False)
# for one of them checks that the corresponding values are None
if attr == 'router':
self.assertEqual(None, desc.nickname)
self.assertEqual(None, desc.address)
self.assertEqual(None, desc.or_port)
self.assertEqual(None, desc.socks_port)
self.assertEqual(None, desc.dir_port)
def main(reactor):
tor = yield txtorcon.connect(reactor)
or_nickname = "moria1"
print("Trying to get decriptor information about '{}'".format(or_nickname))
# If the fingerprint is used in place of nickname then, desc/id/<OR identity>
# should be used.
try:
descriptor_info = yield tor.protocol.get_info('desc/name/' +
or_nickname)
except txtorcon.TorProtocolError:
print(
"No information found. Enable descriptor downloading by setting:")
print(" UseMicrodescritors 0")
print("In your torrc")
raise SystemExit(1)
descriptor_info = descriptor_info.values()[0]
relay_info = RelayDescriptor(descriptor_info)
print("The relay's fingerprint is: {}".format(relay_info.fingerprint))
print("Time in UTC when the descriptor was made: {}".format(
relay_info.published))