def test_build_circuit_not_timedout(self):
class FakeRouter:
def __init__(self, i):
self.id_hex = i
self.flags = []
path = []
for x in range(3):
path.append(FakeRouter("$%040d" % x))
path[0].flags = ['guard']
timeout = 10
clock = task.Clock()
d = build_timeout_circuit(self.state, clock, path, timeout, using_guards=True)
d.addCallback(self.circuit_callback)
self.assertEqual(self.transport.value(), 'EXTENDCIRCUIT 0 0000000000000000000000000000000000000000,0000000000000000000000000000000000000001,0000000000000000000000000000000000000002\r\n')
self.send('250 EXTENDED 1234')
# we can't just .send('650 CIRC 1234 BUILT') this because we
# didn't fully hook up the protocol to the state, e.g. via
# post_bootstrap etc.
self.state.circuits[1234].update(['1234', 'BUILT'])
# should have gotten a warning about this not being an entry
# guard
self.assertEqual(len(self.flushWarnings()), 1)
return d
def test_build_circuit_timeout_after_progress(self):
"""
Similar to above but we timeout after Tor has ack'd our
circuit-creation attempt, but before reaching BUILT.
"""
class FakeRouter:
def __init__(self, i):
self.id_hex = i
self.flags = []
class FakeCircuit(Circuit):
def close(self):
return defer.succeed(None)
path = []
for x in range(3):
path.append(FakeRouter("$%040d" % x))
def fake_queue(cmd):
self.assertTrue(cmd.startswith('EXTENDCIRCUIT 0'))
return defer.succeed("EXTENDED 1234")
queue_command = patch.object(self.protocol, 'queue_command', fake_queue)
circuit_factory = patch.object(self.state, 'circuit_factory', FakeCircuit)
with queue_command, circuit_factory:
timeout = 10
clock = task.Clock()
d = build_timeout_circuit(self.state, clock, path, timeout, using_guards=False)
clock.advance(timeout + 1)
def check_for_timeout_error(f):
self.assertTrue(isinstance(f.type(), CircuitBuildTimedOutError))
d.addErrback(check_for_timeout_error)
return d
def test_build_circuit_timedout(self):
class FakeRouter:
def __init__(self, i):
self.id_hex = i
self.flags = []
path = []
for x in range(3):
path.append(FakeRouter("$%040d" % x))
# can't just check flags for guard status, need to know if
# it's in the running Tor's notion of Entry Guards
path[0].flags = ['guard']
# FIXME TODO we should verify we get a circuit_new event for
# this circuit
timeout = 10
clock = task.Clock()
d = build_timeout_circuit(self.state, clock, path, timeout, using_guards=False)
clock.advance(10)
def check_for_timeout_error(f):
self.assertTrue(isinstance(f.type(), CircuitBuildTimedOutError))
d.addErrback(check_for_timeout_error)
return d
def test_build_circuit_not_timedout(self):
class FakeRouter:
def __init__(self, i):
self.id_hex = i
self.flags = []
path = []
for x in range(3):
path.append(FakeRouter("$%040d" % x))
path[0].flags = ['guard']
timeout = 10
clock = task.Clock()
d = build_timeout_circuit(self.state,
clock,
path,
timeout,
using_guards=True)
d.addCallback(self.circuit_callback)
self.assertEqual(
self.transport.value(),
'EXTENDCIRCUIT 0 0000000000000000000000000000000000000000,0000000000000000000000000000000000000001,0000000000000000000000000000000000000002\r\n'
)
self.send('250 EXTENDED 1234')
# we can't just .send('650 CIRC 1234 BUILT') this because we
# didn't fully hook up the protocol to the state, e.g. via
# post_bootstrap etc.
self.state.circuits[1234].update(['1234', 'BUILT'])
# should have gotten a warning about this not being an entry
# guard
self.assertEqual(len(self.flushWarnings()), 1)
return d
def test_build_circuit_timedout(self):
class FakeRouter:
def __init__(self, i):
self.id_hex = i
self.flags = []
path = []
for x in range(3):
path.append(FakeRouter("$%040d" % x))
# can't just check flags for guard status, need to know if
# it's in the running Tor's notion of Entry Guards
path[0].flags = ['guard']
# FIXME TODO we should verify we get a circuit_new event for
# this circuit
timeout = 10
clock = task.Clock()
d = build_timeout_circuit(self.state,
clock,
path,
timeout,
using_guards=True)
clock.advance(10)
def check_for_timeout_error(f):
self.assertTrue(isinstance(f.type(), CircuitBuildTimedOutError))
d.addErrback(check_for_timeout_error)
return d
def test_build_circuit_timeout_after_progress(self):
"""
Similar to above but we timeout after Tor has ack'd our
circuit-creation attempt, but before reaching BUILT.
"""
class FakeRouter:
def __init__(self, i):
self.id_hex = i
self.flags = []
class FakeCircuit(Circuit):
def close(self):
return defer.succeed(None)
path = []
for x in range(3):
path.append(FakeRouter("$%040d" % x))
def fake_queue(cmd):
self.assertTrue(cmd.startswith('EXTENDCIRCUIT 0'))
return defer.succeed("EXTENDED 1234")
queue_command = patch.object(self.protocol, 'queue_command',
fake_queue)
circuit_factory = patch.object(self.state, 'circuit_factory',
FakeCircuit)
with queue_command, circuit_factory:
timeout = 10
clock = task.Clock()
d = build_timeout_circuit(self.state,
clock,
path,
timeout,
using_guards=False)
clock.advance(timeout + 1)
def check_for_timeout_error(f):
self.assertTrue(isinstance(f.type(),
CircuitBuildTimedOutError))
d.addErrback(check_for_timeout_error)
return d