def test_the_little_relay_that_could(self):
def tutorial_example():
from stem.control import Controller
with Controller.from_port(control_port = 9051) as controller:
controller.authenticate() # provide the password here if you set one
bytes_read = controller.get_info("traffic/read")
bytes_written = controller.get_info("traffic/written")
print "My Tor relay has read %s bytes and written %s." % (bytes_read, bytes_written)
controller = mocking.get_object(Controller, {
'authenticate': mocking.no_op(),
'close': mocking.no_op(),
'get_info': mocking.return_for_args({
('traffic/read',): '33406',
('traffic/written',): '29649',
}, is_method = True),
})
mocking.mock(
Controller.from_port, mocking.return_value(controller),
target_module = Controller,
is_static = True,
)
tutorial_example()
self.assertEqual("My Tor relay has read 33406 bytes and written 29649.\n", self.stdout.getvalue())
def test_example(self):
"""
Exercises the add_event_listener() pydoc example, but without the sleep().
"""
import time
from stem.control import Controller, EventType
def print_bw(event):
msg = "sent: %i, received: %i" % (event.written, event.read)
self.assertEqual("sent: 25, received: 15", msg)
def event_sender():
for index in xrange(3):
print_bw(_get_event("650 BW 15 25"))
time.sleep(0.05)
controller = mocking.get_object(
Controller, {"authenticate": mocking.no_op(), "add_event_listener": mocking.no_op()}
)
controller.authenticate()
controller.add_event_listener(print_bw, EventType.BW)
events_thread = threading.Thread(target=event_sender)
events_thread.start()
time.sleep(0.2)
events_thread.join()
def test_mirror_mirror_on_the_wall_1(self):
def tutorial_example():
from stem.control import Controller
with Controller.from_port(control_port = 9051) as controller:
controller.authenticate()
for desc in controller.get_network_statuses():
print "found relay %s (%s)" % (desc.nickname, desc.fingerprint)
controller = mocking.get_object(Controller, {
'authenticate': mocking.no_op(),
'close': mocking.no_op(),
'get_network_statuses': mocking.return_value(
[mocking.get_router_status_entry_v2()],
),
})
mocking.mock(
Controller.from_port, mocking.return_value(controller),
target_module = Controller,
is_static = True,
)
tutorial_example()
self.assertEqual("found relay caerSidi (A7569A83B5706AB1B1A9CB52EFF7D2D32E4553EB)\n", self.stdout.getvalue())
def test_example(self):
"""
Exercises the add_event_listener() pydoc example, but without the sleep().
"""
import time
from stem.control import Controller, EventType
def print_bw(event):
msg = "sent: %i, received: %i" % (event.written, event.read)
self.assertEqual("sent: 25, received: 15", msg)
def event_sender():
for index in xrange(3):
print_bw(_get_event("650 BW 15 25"))
time.sleep(0.05)
controller = mocking.get_object(
Controller, {
'authenticate': mocking.no_op(),
'add_event_listener': mocking.no_op(),
})
controller.authenticate()
controller.add_event_listener(print_bw, EventType.BW)
events_thread = threading.Thread(target=event_sender)
events_thread.start()
time.sleep(0.2)
events_thread.join()
def test_mirror_mirror_on_the_wall_1(self):
def tutorial_example():
from stem.control import Controller
with Controller.from_port(control_port=9051) as controller:
controller.authenticate()
for desc in controller.get_network_statuses():
print "found relay %s (%s)" % (desc.nickname,
desc.fingerprint)
controller = mocking.get_object(
Controller, {
'authenticate':
mocking.no_op(),
'close':
mocking.no_op(),
'get_network_statuses':
mocking.return_value([mocking.get_router_status_entry_v2()], ),
})
mocking.mock(
Controller.from_port,
mocking.return_value(controller),
target_module=Controller,
is_static=True,
)
tutorial_example()
self.assertEqual(
"found relay caerSidi (A7569A83B5706AB1B1A9CB52EFF7D2D32E4553EB)\n",
self.stdout.getvalue())
def test_mirror_mirror_on_the_wall_4(self):
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 = mocking.get_object(Controller, {
'authenticate': mocking.no_op(),
'close': mocking.no_op(),
'get_server_descriptors': mocking.return_value([
exit_descriptor,
mocking.get_relay_server_descriptor(), # non-exit
exit_descriptor,
exit_descriptor,
])
})
mocking.mock(
Controller.from_port, mocking.return_value(controller),
target_module = Controller,
is_static = True,
)
tutorial_example()
self.assertEqual(MIRROR_MIRROR_OUTPUT, self.stdout.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_the_little_relay_that_could(self):
def tutorial_example():
from stem.control import Controller
with Controller.from_port(control_port=9051) as controller:
controller.authenticate(
) # provide the password here if you set one
bytes_read = controller.get_info("traffic/read")
bytes_written = controller.get_info("traffic/written")
print "My Tor relay has read %s bytes and written %s." % (
bytes_read, bytes_written)
controller = mocking.get_object(
Controller, {
'authenticate':
mocking.no_op(),
'close':
mocking.no_op(),
'get_info':
mocking.return_for_args(
{
('traffic/read', ): '33406',
('traffic/written', ): '29649',
},
is_method=True),
})
mocking.mock(
Controller.from_port,
mocking.return_value(controller),
target_module=Controller,
is_static=True,
)
tutorial_example()
self.assertEqual(
"My Tor relay has read 33406 bytes and written 29649.\n",
self.stdout.getvalue())
def test_the_little_relay_that_could(self):
from stem.control import Controller
controller = mocking.get_object(Controller, {
'authenticate': mocking.no_op(),
'close': mocking.no_op(),
'get_info': mocking.return_for_args({
'traffic/read': '1234',
'traffic/written': '5678',
}),
})
controller.authenticate()
bytes_read = controller.get_info("traffic/read")
bytes_written = controller.get_info("traffic/written")
expected_line = "My Tor relay has read 1234 bytes and written 5678."
printed_line = "My Tor relay has read %s bytes and written %s." % (bytes_read, bytes_written)
self.assertEqual(expected_line, printed_line)
controller.close()
def test_the_little_relay_that_could(self):
from stem.control import Controller
controller = mocking.get_object(Controller, {
'authenticate': mocking.no_op(),
'close': mocking.no_op(),
'get_info': mocking.return_for_args({
('traffic/read',): '1234',
('traffic/written',): '5678',
}, is_method = True),
})
controller.authenticate()
bytes_read = controller.get_info("traffic/read")
bytes_written = controller.get_info("traffic/written")
expected_line = "My Tor relay has read 1234 bytes and written 5678."
printed_line = "My Tor relay has read %s bytes and written %s." % (bytes_read, bytes_written)
self.assertEqual(expected_line, printed_line)
controller.close()
def test_mirror_mirror_on_the_wall_4(self):
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 = mocking.get_object(
Controller,
{
'authenticate':
mocking.no_op(),
'close':
mocking.no_op(),
'get_server_descriptors':
mocking.return_value([
exit_descriptor,
mocking.get_relay_server_descriptor(), # non-exit
exit_descriptor,
exit_descriptor,
])
})
mocking.mock(
Controller.from_port,
mocking.return_value(controller),
target_module=Controller,
is_static=True,
)
tutorial_example()
self.assertEqual(MIRROR_MIRROR_OUTPUT, self.stdout.getvalue())
