def test_registerProducers(self): """ The proxy client registers itself as a producer of the proxy server and vice versa. """ # create a ProxyServer instance addr = address.IPv4Address('TCP', '127.0.0.1', 0) server = portforward.ProxyFactory('127.0.0.1', 0).buildProtocol(addr) # set the reactor for this test reactor = proto_helpers.MemoryReactor() server.reactor = reactor # make the connection serverTransport = proto_helpers.StringTransport() server.makeConnection(serverTransport) # check that the ProxyClientFactory is connecting to the backend self.assertEqual(len(reactor.tcpClients), 1) # get the factory instance and check it's the one we expect host, port, clientFactory, timeout, _ = reactor.tcpClients[0] self.assertIsInstance(clientFactory, portforward.ProxyClientFactory) # Connect it client = clientFactory.buildProtocol(addr) clientTransport = proto_helpers.StringTransport() client.makeConnection(clientTransport) # check that the producers are registered self.assertIs(clientTransport.producer, serverTransport) self.assertIs(serverTransport.producer, clientTransport) # check the streaming attribute in both transports self.assertTrue(clientTransport.streaming) self.assertTrue(serverTransport.streaming)
def test_pendingEmptiedInPlaceOnError(self): """ When the TCP connection attempt fails, the L{client.Resolver.pending} list is emptied in place. It is not replaced with a new empty list. """ reactor = proto_helpers.MemoryReactor() resolver = client.Resolver(servers=[("192.0.2.100", 53)], reactor=reactor) d = resolver.queryTCP(dns.Query("example.com")) host, port, factory, timeout, bindAddress = reactor.tcpClients[0] prePending = resolver.pending self.assertEqual(len(prePending), 1) class SentinelException(Exception): pass factory.clientConnectionFailed( reactor.connectors[0], failure.Failure(SentinelException()) ) self.failureResultOf(d, SentinelException) self.assertIs(resolver.pending, prePending) self.assertEqual(len(prePending), 0)
def test_streamAcceptEstablished(self): mreactor = proto_helpers.MemoryReactor() session = Mock() listeningPort = Mock() fac, proto = self.makeProto(Mock(), session, listeningPort) # Shortcut to end of SAM stream accept protocol proto.receiver.currentRule = 'State_accept' proto._parser._setupInterp() proto.dataReceived('STREAM STATUS RESULT=OK\n') session.addStream.assert_called_with(proto.receiver) listeningPort.addAccept.assert_called_with(proto.receiver)
def test_streamForwardEstablished(self): mreactor = proto_helpers.MemoryReactor() session = Mock() fac, proto = self.makeProto(session, '') # Shortcut to end of SAM stream forward protocol proto.receiver.currentRule = 'State_forward' proto._parser._setupInterp() proto.dataReceived('STREAM STATUS RESULT=OK\n') session.addStream.assert_called_with(proto.receiver) streamProto = self.successResultOf(fac.deferred) self.assertEqual(proto.receiver, streamProto)
def TODO_test_noProtocolFromWrappedFactory(self): wrappedFac = FakeFactory(returnNoProtocol=True) mreactor = proto_helpers.MemoryReactor() fac, proto = self.makeProto(mreactor, wrappedFac, None, '') fac.tunnelNick = 'spam' # Shortcut to end of BOB protocol proto.receiver.currentRule = 'State_start' proto._parser._setupInterp() proto.dataReceived('OK HTTP 418\n') self.assert_(self.aborted) # TODO: Check the Deferred chain return self.assertFailure(fac.deferred, defer.CancelledError)
def test_streamConnectionEstablished(self): mreactor = proto_helpers.MemoryReactor() wrappedFactory = FakeFactory() session = Mock() fac, proto = self.makeProto(wrappedFactory, session, 'spam.i2p', 'foo') # Shortcut to end of SAM stream connect protocol proto.receiver.currentRule = 'State_connect' proto._parser._setupInterp() proto.dataReceived('STREAM STATUS RESULT=OK\n') session.addStream.assert_called_with(proto.receiver) streamProto = self.successResultOf(fac.deferred) self.assertEqual(proto.receiver.wrappedProto, streamProto)
def test_destGenerated(self): tmp = '/tmp/TestDestGenerateFactory.privKey' mreactor = proto_helpers.MemoryReactor() fac, proto = self.makeProto(tmp) # Shortcut to end of SAM dest generate protocol proto.receiver.currentRule = 'State_dest' proto._parser._setupInterp() proto.dataReceived('DEST REPLY PUB=%s PRIV=%s\n' % (TEST_B64, 'TEST_PRIV')) s = self.successResultOf(fac.deferred) self.assertEqual(I2PAddress(TEST_B64), s) os.remove(tmp)
def test_streamAcceptIncoming(self): mreactor = proto_helpers.MemoryReactor() wrappedFactory = FakeFactory() session = Mock() listeningPort = Mock() fac, proto = self.makeProto(wrappedFactory, session, listeningPort) # Shortcut to end of SAM stream accept protocol proto.receiver.currentRule = 'State_readData' proto._parser._setupInterp() proto.dataReceived('%s FROM_PORT=34444 TO_PORT=0\n' % TEST_B64) listeningPort.removeAccept.assert_called_with(proto.receiver) self.assertEqual(wrappedFactory.proto, proto.receiver.wrappedProto)
def test_sessionCreated(self): mreactor = proto_helpers.MemoryReactor() fac, proto = self.makeProto('foo') fac.samVersion = '3.1' # Shortcut to end of SAM session create protocol proto.receiver.currentRule = 'State_naming' proto._parser._setupInterp() proto.dataReceived('NAMING REPLY RESULT=OK NAME=ME VALUE=%s\n' % TEST_B64) s = self.successResultOf(fac.deferred) self.assertEqual( ('3.1', 'STREAM', 'foo', proto.receiver, TEST_B64, None), s)
def test_endpoint_launch_tor(self, private_tor, global_tor, system_tor): """ we just want to confirm that calling listen results in the spawning of a Tor process; the parsing/setup from string are checked elsewhere. """ reactor = proto_helpers.MemoryReactor() ep = serverFromString(reactor, 'onion:8888') r = yield ep.listen(NoOpProtocolFactory()) self.assertEqual(global_tor.call_count, 1) self.assertEqual(private_tor.call_count, 0) self.assertEqual(system_tor.call_count, 0)
def test_destGenerated_privKeySaved(self): tmp = '/tmp/TestDestGenerateFactory.privKey' mreactor = proto_helpers.MemoryReactor() fac, proto = self.makeProto(tmp) # Shortcut to end of SAM dest generate protocol proto.receiver.currentRule = 'State_dest' proto._parser._setupInterp() proto.dataReceived('DEST REPLY PUB=%s PRIV=%s\n' % (TEST_B64, 'TEST_PRIV')) f = open(tmp, 'r') privKey = f.read() f.close() self.assertEqual('TEST_PRIV', privKey) os.remove(tmp)
def test_endpoint_connect_tor(self, private_tor, global_tor, system_tor): """ similar to above test, we're confirming that an endpoint-string with 'controlPort=xxxx' in it calls the API that will connect to a running Tor. """ reactor = proto_helpers.MemoryReactor() ep = serverFromString(reactor, 'onion:8888:controlPort=9055:localPort=1234') r = yield ep.listen(NoOpProtocolFactory()) self.assertEqual(global_tor.call_count, 0) self.assertEqual(private_tor.call_count, 0) self.assertEqual(system_tor.call_count, 1)
def test_destGenerated_keyfileExists(self): tmp = '/tmp/TestDestGenerateFactory.privKey' f = open(tmp, 'w') f.write('foo') f.close() mreactor = proto_helpers.MemoryReactor() fac, proto = self.makeProto(tmp) # Shortcut to end of SAM dest generate protocol proto.receiver.currentRule = 'State_dest' proto._parser._setupInterp() proto.dataReceived('DEST REPLY PUB=%s PRIV=%s\n' % (TEST_B64, 'TEST_PRIV')) self.assertIsInstance( self.failureResultOf(fac.deferred).value, ValueError) os.remove(tmp)
def test_reentrantTCPQueryErrbackOnConnectionFailure(self): """ An errback on the deferred returned by L{client.Resolver.queryTCP} may trigger another TCP query. """ reactor = proto_helpers.MemoryReactor() resolver = client.Resolver( servers=[('127.0.0.1', 10053)], reactor=reactor) q = dns.Query('example.com') # First query sent d = resolver.queryTCP(q) # Repeat the query when the first query fails def reissue(e): e.trap(ConnectionRefusedError) return resolver.queryTCP(q) d.addErrback(reissue) self.assertEqual(len(reactor.tcpClients), 1) self.assertEqual(len(reactor.connectors), 1) host, port, factory, timeout, bindAddress = reactor.tcpClients[0] # First query fails f1 = failure.Failure(ConnectionRefusedError()) factory.clientConnectionFailed( reactor.connectors[0], f1) # A second TCP connection is immediately attempted self.assertEqual(len(reactor.tcpClients), 2) self.assertEqual(len(reactor.connectors), 2) # No result expected until the second chained query returns self.assertNoResult(d) # Second query fails f2 = failure.Failure(ConnectionRefusedError()) factory.clientConnectionFailed( reactor.connectors[1], f2) # Original deferred now fires with the second failure f = self.failureResultOf(d, ConnectionRefusedError) self.assertIdentical(f, f2)
def test_sessionCreatedWithKeyfile(self): tmp = '/tmp/TestSessionCreateFactory.privKey' mreactor = proto_helpers.MemoryReactor() fac, proto = self.makeProto('foo', keyfile=tmp) fac.samVersion = '3.1' fac.privKey = 'bar' fac._writeKeypair = True # Shortcut to end of SAM session create protocol proto.receiver.currentRule = 'State_naming' proto._parser._setupInterp() proto.dataReceived('NAMING REPLY RESULT=OK NAME=ME VALUE=%s\n' % TEST_B64) f = open(tmp, 'r') privKey = f.read() f.close() self.assertEqual('bar', privKey) # Cleanup os.remove(tmp)
def test_singleTCPQueryErrbackOnConnectionFailure(self): """ The deferred returned by L{client.Resolver.queryTCP} will errback when the TCP connection attempt fails. The reason for the connection failure is passed as the argument to errback. """ reactor = proto_helpers.MemoryReactor() resolver = client.Resolver(servers=[("192.0.2.100", 53)], reactor=reactor) d = resolver.queryTCP(dns.Query("example.com")) host, port, factory, timeout, bindAddress = reactor.tcpClients[0] class SentinelException(Exception): pass factory.clientConnectionFailed( reactor.connectors[0], failure.Failure(SentinelException()) ) self.failureResultOf(d, SentinelException)
def test_multipleTCPQueryErrbackOnConnectionFailure(self): """ All pending L{resolver.queryTCP} C{deferred}s will C{errback} with the same C{Failure} if the connection attempt fails. """ reactor = proto_helpers.MemoryReactor() resolver = client.Resolver(servers=[("192.0.2.100", 53)], reactor=reactor) d1 = resolver.queryTCP(dns.Query("example.com")) d2 = resolver.queryTCP(dns.Query("example.net")) host, port, factory, timeout, bindAddress = reactor.tcpClients[0] class SentinelException(Exception): pass factory.clientConnectionFailed( reactor.connectors[0], failure.Failure(SentinelException()) ) f1 = self.failureResultOf(d1, SentinelException) f2 = self.failureResultOf(d2, SentinelException) self.assertIs(f1, f2)
def test_reconnection(self): clock = task.Clock() self.factory.clock = clock self.factory.maxRetries = 3 fakeReactor = proto_helpers.MemoryReactor() self.assertEquals(0, len(fakeReactor.tcpClients)) connector = fakeReactor.connectTCP('fakehost', 1234, self.factory) self.assertEquals(1, len(fakeReactor.tcpClients)) for i in xrange(self.factory.maxRetries): self.factory.clientConnectionFailed(connector, "Attempt %d" % i) self.assertEquals(1, len(clock.getDelayedCalls())) clock.advance(self.factory.delay) self.assertEquals(0, len(clock.getDelayedCalls())) self.assertEquals(i + 1, connector.connectionAttempts) self.factory.clientConnectionFailed(connector, "Attempt %d" % i) self.assertEquals(0, len(clock.getDelayedCalls())) clock.advance(self.factory.delay) self.assertEquals(self.factory.retries - 1, connector.connectionAttempts)
def setUp(self): self.reactor = proto_helpers.MemoryReactor()
def setUp(self): self.reactor = proto_helpers.MemoryReactor() self.env = _createEnv(self.reactor) self.clock = task.Clock() self.checker = TestChecker(5) self.scan = scanner.Scan(self.clock, '127.0.0.1')
def test_onion_parse_unix_socket(self): r = proto_helpers.MemoryReactor() serverFromString(r, "onion:80:controlPort=/tmp/foo")
def test_samConnected(self): mreactor = proto_helpers.MemoryReactor() fac, proto = self.makeProto() proto.dataReceived('HELLO REPLY RESULT=OK VERSION=3.1\n') s = self.successResultOf(fac.deferred) self.assertEqual(True, s)