def _testDataForward(self, data, method="GET", body=""):
"""
Build a fake proxy connection, and send C{data} over it, checking that
it's forwarded to the originating request.
"""
# Connect everything
clientTransport = StringTransportWithDisconnection()
serverTransport = StringTransportWithDisconnection()
channel = DummyChannel(serverTransport)
parent = DummyParent(channel)
serverTransport.protocol = channel
client = ProxyClient(method, '/foo', 'HTTP/1.0',
{"accept": "text/html"}, body, parent)
clientTransport.protocol = client
client.makeConnection(clientTransport)
# Check data sent
self.assertEquals(
clientTransport.value(), "%s /foo HTTP/1.0\r\n"
"connection: close\r\n"
"accept: text/html\r\n\r\n%s" % (method, body))
# Fake an answer
client.dataReceived(data)
# Check that the data has been forwarded
self.assertEquals(serverTransport.value(), data)
clientTransport.loseConnection()
self.assertIsInstance(channel.lostReason, ConnectionDone)
def test_renderRealRequest(self):
"""
The request managed by L{WebSocketsResource.render} doesn't contain
unnecessary HTTP headers like I{Content-Type} or I{Transfer-Encoding}.
"""
channel = DummyChannel()
channel.transport = StringTransportWithDisconnection()
channel.transport.protocol = channel
request = Request(channel, False)
headers = {
"upgrade": "Websocket",
"connection": "Upgrade",
"sec-websocket-key": "secure",
"sec-websocket-version": "13"
}
for key, value in headers.items():
request.requestHeaders.setRawHeaders(key, [value])
request.method = "GET"
request.clientproto = "HTTP/1.1"
result = self.resource.render(request)
self.assertEqual(NOT_DONE_YET, result)
self.assertEqual(
[("Connection", ["Upgrade"]), ("Upgrade", ["WebSocket"]),
("Sec-Websocket-Accept", ["oYBv54i42V5dw6KnZqOFroecUTc="])],
list(request.responseHeaders.getAllRawHeaders()))
self.assertEqual(
"HTTP/1.1 101 Switching Protocols\r\n"
"Connection: Upgrade\r\n"
"Upgrade: WebSocket\r\n"
"Sec-Websocket-Accept: oYBv54i42V5dw6KnZqOFroecUTc=\r\n\r\n",
channel.transport.value())
self.assertEqual(101, request.code)
self.assertIdentical(None, request.transport)
def test_renderSecureRequest(self):
"""
When the rendered request is over HTTPS, L{WebSocketsResource} wraps
the protocol of the C{TLSMemoryBIOProtocol} instance.
"""
request = DummyRequest("/")
request.requestHeaders = Headers()
transport = StringTransportWithDisconnection()
secureProtocol = TLSMemoryBIOProtocol(Factory(), Protocol())
transport.protocol = secureProtocol
request.transport = transport
request.headers.update({
"upgrade": "Websocket",
"connection": "Upgrade",
"sec-websocket-key": "secure",
"sec-websocket-version": "13"
})
result = self.resource.render(request)
self.assertEqual(NOT_DONE_YET, result)
self.assertEqual(
{
"connection": "Upgrade",
"upgrade": "WebSocket",
"sec-websocket-accept": "oYBv54i42V5dw6KnZqOFroecUTc="
}, request.outgoingHeaders)
self.assertEqual([""], request.written)
self.assertEqual(101, request.responseCode)
self.assertIdentical(None, request.transport)
self.assertIsInstance(transport.protocol.wrappedProtocol,
WebSocketsProtocol)
self.assertIsInstance(transport.protocol.wrappedProtocol._receiver,
SavingEchoReceiver)
def test_render(self):
"""
When rendering a request, L{WebSocketsResource} uses the
C{Sec-WebSocket-Key} header to generate a C{Sec-WebSocket-Accept}
value. It creates a L{WebSocketsProtocol} instance connected to the
protocol provided by the user factory.
"""
request = DummyRequest("/")
request.requestHeaders = Headers()
transport = StringTransportWithDisconnection()
transport.protocol = Protocol()
request.transport = transport
request.headers.update({
"upgrade": "Websocket",
"connection": "Upgrade",
"sec-websocket-key": "secure",
"sec-websocket-version": "13"
})
result = self.resource.render(request)
self.assertEqual(NOT_DONE_YET, result)
self.assertEqual(
{
"connection": "Upgrade",
"upgrade": "WebSocket",
"sec-websocket-accept": "oYBv54i42V5dw6KnZqOFroecUTc="
}, request.outgoingHeaders)
self.assertEqual([""], request.written)
self.assertEqual(101, request.responseCode)
self.assertIdentical(None, request.transport)
self.assertIsInstance(transport.protocol._receiver, SavingEchoReceiver)
def testThingsGetLogged(self):
wrappedFactory = Server()
wrappedFactory.protocol = WriteSequenceEchoProtocol
t = StringTransportWithDisconnection()
f = TestLoggingFactory(wrappedFactory, 'test')
p = f.buildProtocol(('1.2.3.4', 5678))
t.protocol = p
p.makeConnection(t)
v = f.openFile.getvalue()
self.failUnless('*' in v, "* not found in %r" % (v,))
self.failIf(t.value())
p.dataReceived('here are some bytes')
v = f.openFile.getvalue()
self.assertNotEqual(-1, v.find("C 1: 'here are some bytes'"), "Expected client string not found in %r" % (v,))
self.assertNotEqual(-1, v.find("S 1: 'here are some bytes'"), "Expected server string not found in %r" % (v,))
self.assertEquals(t.value(), 'here are some bytes')
t.clear()
p.dataReceived('prepare for vector! to the extreme')
v = f.openFile.getvalue()
self.assertNotEqual(-1, v.find("SV 1: ['prepare for vector! to the extreme']"), "Expected server string not found in %r" % (v,))
self.assertEquals(t.value(), 'prepare for vector! to the extreme')
p.loseConnection()
v = f.openFile.getvalue()
self.assertNotEqual(-1, v.find('ConnectionDone'), "Connection done notification not found in %r" % (v,))
def test_renderIProtocol(self):
"""
If the protocol returned by C{lookupProtocol} isn't a
C{WebSocketsProtocol}, L{WebSocketsResource} wraps it automatically
with L{WebSocketsProtocolWrapper}.
"""
def lookupProtocol(names, otherRequest):
return AccumulatingProtocol(), None
self.resource = WebSocketsResource(lookupProtocol)
request = DummyRequest(b"/")
request.requestHeaders = Headers({
b"user-agent": [b"user-agent"],
b"host": [b"host"],
})
transport = StringTransportWithDisconnection()
transport.protocol = Protocol()
request.transport = transport
self.update_headers(request,
headers={
b"upgrade": b"Websocket",
b"connection": b"Upgrade",
b"sec-websocket-key": b"secure",
b"sec-websocket-version": b"13"
})
result = self.resource.render(request)
self.assertEqual(NOT_DONE_YET, result)
self.assertIsInstance(transport.protocol, WebSocketsProtocolWrapper)
self.assertIsInstance(transport.protocol.wrappedProtocol,
AccumulatingProtocol)
def test_stratum_connection(self):
transport = StringTransportWithDisconnection()
protocol = self.factory.buildProtocol('127.0.0.1')
protocol.makeConnection(transport)
self.assertEqual(len(self.factory.miner_protocols), 2)
protocol.connectionLost()
self.assertEqual(len(self.factory.miner_protocols), 1)
def test_writeLimit(self):
"""
Check the writeLimit parameter: write data, and check for the pause
status.
"""
server = Server()
tServer = TestableThrottlingFactory(task.Clock(), server, writeLimit=10)
port = tServer.buildProtocol(address.IPv4Address('TCP', '127.0.0.1', 0))
tr = StringTransportWithDisconnection()
tr.protocol = port
port.makeConnection(tr)
port.producer = port.wrappedProtocol
port.dataReceived(b"0123456789")
port.dataReceived(b"abcdefghij")
self.assertEqual(tr.value(), b"0123456789abcdefghij")
self.assertEqual(tServer.writtenThisSecond, 20)
self.assertFalse(port.wrappedProtocol.paused)
# at this point server should've written 20 bytes, 10 bytes
# above the limit so writing should be paused around 1 second
# from 'now', and resumed a second after that
tServer.clock.advance(1.05)
self.assertEqual(tServer.writtenThisSecond, 0)
self.assertTrue(port.wrappedProtocol.paused)
tServer.clock.advance(1.05)
self.assertEqual(tServer.writtenThisSecond, 0)
self.assertFalse(port.wrappedProtocol.paused)
def setUp(self):
self.clock = task.Clock()
self.factory = HeartbeatProtocolFactory(self.clock)
self.protocol = self.factory.buildProtocol(address.IPv4Address('TCP', 'localhost', 1234))
self.transport = StringTransportWithDisconnection()
self.protocol.makeConnection(self.transport)
self.transport.protocol = self.protocol
def test_thingsGetLogged(self):
"""
Check the output produced by L{policies.TrafficLoggingFactory}.
"""
wrappedFactory = Server()
wrappedFactory.protocol = WriteSequenceEchoProtocol
t = StringTransportWithDisconnection()
f = TestLoggingFactory(wrappedFactory, "test")
p = f.buildProtocol(("1.2.3.4", 5678))
t.protocol = p
p.makeConnection(t)
v = f.openFile.getvalue()
self.assertIn("*", v)
self.assertFalse(t.value())
p.dataReceived(b"here are some bytes")
v = f.openFile.getvalue()
self.assertIn("C 1: {!r}".format(b"here are some bytes"), v)
self.assertIn("S 1: {!r}".format(b"here are some bytes"), v)
self.assertEqual(t.value(), b"here are some bytes")
t.clear()
p.dataReceived(b"prepare for vector! to the extreme")
v = f.openFile.getvalue()
self.assertIn("SV 1: {!r}".format([b"prepare for vector! to the extreme"]), v)
self.assertEqual(t.value(), b"prepare for vector! to the extreme")
p.loseConnection()
v = f.openFile.getvalue()
self.assertIn("ConnectionDone", v)
def setUp(self):
self.receiver = SavingEchoReceiver()
self.protocol = WebSocketsProtocol(self.receiver)
self.factory = Factory.forProtocol(lambda: self.protocol)
self.transport = StringTransportWithDisconnection()
self.protocol.makeConnection(self.transport)
self.transport.protocol = self.protocol
def setUp(self):
super(WebSocketsProtocolWrapperTest, self).setUp()
self.accumulatingProtocol = AccumulatingProtocol()
self.protocol = WebSocketsProtocolWrapper(self.accumulatingProtocol)
self.transport = StringTransportWithDisconnection()
self.protocol.makeConnection(self.transport)
self.transport.protocol = self.protocol
def test_validIPv6HeaderResolves_getPeerHost(self):
"""
Test if IPv6 headers result in the correct host and peer data.
"""
factory = HAProxyWrappingFactory(Factory.forProtocol(StaticProtocol))
proto = factory.buildProtocol(address.IPv6Address('TCP', b'::1',
8080), )
transport = StringTransportWithDisconnection()
proto.makeConnection(transport)
proto.dataReceived(b'PROXY TCP6 ::1 ::2 8080 8888\r\n')
self.assertEqual(proto.getPeer().host, b'::1')
self.assertEqual(proto.getPeer().port, 8080)
self.assertEqual(
proto.wrappedProtocol.transport.getPeer().host,
b'::1',
)
self.assertEqual(
proto.wrappedProtocol.transport.getPeer().port,
8080,
)
self.assertEqual(proto.getHost().host, b'::2')
self.assertEqual(proto.getHost().port, 8888)
self.assertEqual(
proto.wrappedProtocol.transport.getHost().host,
b'::2',
)
self.assertEqual(
proto.wrappedProtocol.transport.getHost().port,
8888,
)
def test_renderNoProtocol(self):
"""
If the underlying factory doesn't return any protocol,
L{WebSocketsResource} returns a failed request with a C{502} code.
"""
request = DummyRequest(b"/")
request.requestHeaders = Headers({
b"user-agent": [b"user-agent"],
b"host": [b"host"],
})
request.transport = StringTransportWithDisconnection()
self.echoProtocol = None
self.update_headers(request,
headers={
b"upgrade": b"Websocket",
b"connection": b"Upgrade",
b"sec-websocket-key": b"secure",
b"sec-websocket-version": b"13"
})
result = self.resource.render(request)
self.assertEqual(b"", result)
self.assertEqual({}, {
name: value
for name, value in request.responseHeaders.getAllRawHeaders()
})
self.assertEqual([], request.written)
self.assertEqual(502, request.responseCode)
def test_validIPv4HeaderResolves_getPeerHost(self):
"""
Test if IPv4 headers result in the correct host and peer data.
"""
factory = HAProxyWrappingFactory(Factory.forProtocol(StaticProtocol))
proto = factory.buildProtocol(
address.IPv4Address("TCP", b"127.0.0.1", 8080), )
transport = StringTransportWithDisconnection()
proto.makeConnection(transport)
proto.dataReceived(b"PROXY TCP4 1.1.1.1 2.2.2.2 8080 8888\r\n")
self.assertEqual(proto.getPeer().host, b"1.1.1.1")
self.assertEqual(proto.getPeer().port, 8080)
self.assertEqual(
proto.wrappedProtocol.transport.getPeer().host,
b"1.1.1.1",
)
self.assertEqual(
proto.wrappedProtocol.transport.getPeer().port,
8080,
)
self.assertEqual(proto.getHost().host, b"2.2.2.2")
self.assertEqual(proto.getHost().port, 8888)
self.assertEqual(
proto.wrappedProtocol.transport.getHost().host,
b"2.2.2.2",
)
self.assertEqual(
proto.wrappedProtocol.transport.getHost().port,
8888,
)
def test_renderRealRequest(self):
"""
The request managed by L{WebSocketsResource.render} doesn't contain
unnecessary HTTP headers like I{Content-Type}.
"""
channel = DummyChannel()
channel.transport = StringTransportWithDisconnection()
channel.transport.protocol = channel
request = Request(channel, False)
headers = {
b"upgrade": b"Websocket",
b"connection": b"Upgrade",
b"sec-websocket-key": b"secure",
b"sec-websocket-version": b"13"
}
for key, value in headers.items():
request.requestHeaders.setRawHeaders(key, [value])
request.method = b"GET"
request.clientproto = b"HTTP/1.1"
result = self.resource.render(request)
self.assertEqual(NOT_DONE_YET, result)
self.assertEqual(
[(b"Connection", [b"Upgrade"]),
(b"Sec-Websocket-Accept", [b"oYBv54i42V5dw6KnZqOFroecUTc="]),
(b"Upgrade", [b"WebSocket"])],
sorted(request.responseHeaders.getAllRawHeaders()))
self.assertThat(
channel.transport.value(),
StartsWith(b"HTTP/1.1 101 Switching Protocols\r\n"
b"Transfer-Encoding: chunked\r\n"))
self.assertEqual(101, request.code)
self.assertIdentical(None, request.transport)
def test_validIPv6HeaderResolves_getPeerHost(self) -> None:
"""
Test if IPv6 headers result in the correct host and peer data.
"""
factory = HAProxyWrappingFactory(Factory.forProtocol(StaticProtocol))
proto = factory.buildProtocol(address.IPv4Address("TCP", "::1",
8080), )
transport = StringTransportWithDisconnection()
proto.makeConnection(transport)
proto.dataReceived(self.IPV6HEADER)
self.assertEqual(proto.getPeer().host, "0:0:0:0:0:0:0:1")
self.assertEqual(proto.getPeer().port, 8080)
self.assertEqual(
proto.wrappedProtocol.transport.getPeer().host,
"0:0:0:0:0:0:0:1",
)
self.assertEqual(
proto.wrappedProtocol.transport.getPeer().port,
8080,
)
self.assertEqual(proto.getHost().host, "0:0:0:0:0:0:0:1")
self.assertEqual(proto.getHost().port, 8888)
self.assertEqual(
proto.wrappedProtocol.transport.getHost().host,
"0:0:0:0:0:0:0:1",
)
self.assertEqual(
proto.wrappedProtocol.transport.getHost().port,
8888,
)
def setUp(self):
self.maximum = 100
self.factory = PingPongClientFactory(self.maximum)
self.protocol = self.factory.buildProtocol(address.IPv4Address('TCP', 'localhost', 1234))
self.transport = StringTransportWithDisconnection()
self.protocol.makeConnection(self.transport)
self.transport.protocol = self.protocol
def setUp(self):
self.proto = Redis()
self.clock = Clock()
self.proto.callLater = self.clock.callLater
self.transport = StringTransportWithDisconnection()
self.transport.protocol = self.proto
self.proto.makeConnection(self.transport)
def test_thingsGetLogged(self):
"""
Check the output produced by L{policies.TrafficLoggingFactory}.
"""
wrappedFactory = Server()
wrappedFactory.protocol = WriteSequenceEchoProtocol
t = StringTransportWithDisconnection()
f = TestLoggingFactory(wrappedFactory, 'test')
p = f.buildProtocol(('1.2.3.4', 5678))
t.protocol = p
p.makeConnection(t)
v = f.openFile.getvalue()
self.assertIn('*', v)
self.assertFalse(t.value())
p.dataReceived(b'here are some bytes')
v = f.openFile.getvalue()
self.assertIn("C 1: %r" % (b'here are some bytes',), v)
self.assertIn("S 1: %r" % (b'here are some bytes',), v)
self.assertEqual(t.value(), b'here are some bytes')
t.clear()
p.dataReceived(b'prepare for vector! to the extreme')
v = f.openFile.getvalue()
self.assertIn("SV 1: %r" % ([b'prepare for vector! to the extreme'],), v)
self.assertEqual(t.value(), b'prepare for vector! to the extreme')
p.loseConnection()
v = f.openFile.getvalue()
self.assertIn('ConnectionDone', v)
def _testRender(self, uri, expectedURI):
"""
Check that a request pointing at C{uri} produce a new proxy connection,
with the path of this request pointing at C{expectedURI}.
"""
root = Resource()
reactor = FakeReactor()
resource = ReverseProxyResource("127.0.0.1", 1234, "/path", reactor)
root.putChild('index', resource)
site = Site(root)
transport = StringTransportWithDisconnection()
channel = site.buildProtocol(None)
channel.makeConnection(transport)
# Clear the timeout if the tests failed
self.addCleanup(channel.connectionLost, None)
channel.dataReceived("GET %s HTTP/1.1\r\nAccept: text/html\r\n\r\n" %
(uri, ))
# Check that one connection has been created, to the good host/port
self.assertEquals(len(reactor.connect), 1)
self.assertEquals(reactor.connect[0][0], "127.0.0.1")
self.assertEquals(reactor.connect[0][1], 1234)
# Check the factory passed to the connect, and its given path
factory = reactor.connect[0][2]
self.assertIsInstance(factory, ProxyClientFactory)
self.assertEquals(factory.rest, expectedURI)
self.assertEquals(factory.headers["host"], "127.0.0.1:1234")
def _testProcess(self, uri, expectedURI, method=b"GET", data=b""):
"""
Build a request pointing at C{uri}, and check that a proxied request
is created, pointing a C{expectedURI}.
"""
transport = StringTransportWithDisconnection()
channel = DummyChannel(transport)
reactor = MemoryReactor()
request = ProxyRequest(channel, False, reactor)
request.gotLength(len(data))
request.handleContentChunk(data)
request.requestReceived(method, b"http://example.com" + uri,
b"HTTP/1.0")
self.assertEqual(len(reactor.tcpClients), 1)
self.assertEqual(reactor.tcpClients[0][0], "example.com")
self.assertEqual(reactor.tcpClients[0][1], 80)
factory = reactor.tcpClients[0][2]
self.assertIsInstance(factory, ProxyClientFactory)
self.assertEqual(factory.command, method)
self.assertEqual(factory.version, b"HTTP/1.0")
self.assertEqual(factory.headers, {b"host": b"example.com"})
self.assertEqual(factory.data, data)
self.assertEqual(factory.rest, expectedURI)
self.assertEqual(factory.father, request)
def setUp(self):
self.sp = CredReceiver()
self.sp.factory = CredAMPServerFactory()
self.transport = StringTransportWithDisconnection()
self.sp.makeConnection(self.transport)
self.transport.protocol = self.sp
def _testProcess(self, uri, expectedURI, method="GET", data=""):
"""
Build a request pointing at C{uri}, and check that a proxied request
is created, pointing a C{expectedURI}.
"""
transport = StringTransportWithDisconnection()
channel = DummyChannel(transport)
reactor = FakeReactor()
proxy_factory = proxy.TurtleHTTPFactory({}, False, reactor)
channel.factory = proxy_factory
request = proxy.TurtleProxyRequest(channel, False, reactor)
request.gotLength(len(data))
request.handleContentChunk(data)
request.requestReceived(method, 'http://example.com%s' % (uri,),
'HTTP/1.0')
self.assertEquals(len(reactor.connect), 1)
self.assertEquals(reactor.connect[0][0], "example.com")
self.assertEquals(reactor.connect[0][1], 80)
factory = reactor.connect[0][2]
self.assertIsInstance(factory, proxy.TurtleProxyClientFactory)
self.assertEquals(factory.command, method)
self.assertEquals(factory.version, 'HTTP/1.0')
self.assertEquals(factory.headers, {'host': 'example.com'})
self.assertEquals(factory.data, data)
self.assertEquals(factory.rest, expectedURI)
self.assertEquals(factory.father, request)
def _testRender(self, uri, expectedURI):
"""
Check that a request pointing at C{uri} produce a new proxy connection,
with the path of this request pointing at C{expectedURI}.
"""
root = Resource()
reactor = MemoryReactor()
resource = ReverseProxyResource("127.0.0.1", 1234, b"/path", reactor)
root.putChild(b"index", resource)
site = Site(root)
transport = StringTransportWithDisconnection()
channel = site.buildProtocol(None)
channel.makeConnection(transport)
# Clear the timeout if the tests failed
self.addCleanup(channel.connectionLost, None)
channel.dataReceived(b"GET " + uri +
b" HTTP/1.1\r\nAccept: text/html\r\n\r\n")
[(host, port, factory, _timeout, _bind_addr)] = reactor.tcpClients
# Check that one connection has been created, to the good host/port
self.assertEqual(host, "127.0.0.1")
self.assertEqual(port, 1234)
# Check the factory passed to the connect, and its given path
self.assertIsInstance(factory, ProxyClientFactory)
self.assertEqual(factory.rest, expectedURI)
self.assertEqual(factory.headers[b"host"], b"127.0.0.1:1234")
def connect(self, protocolFactory):
string_transport = StringTransportWithDisconnection()
protocol = protocolFactory.buildProtocol(None)
protocol.makeConnection(string_transport)
string_transport.protocol = protocol
self.connect_callback(protocol)
d = Deferred()
d.callback(protocol)
return d
def connect_transport(protocol, factory=None):
""" Connect a StringTransport to a client protocol. """
if factory is None:
factory = ClientFactory()
transport = StringTransportWithDisconnection()
protocol.makeConnection(transport)
transport.protocol = protocol
protocol.factory = factory
return transport
def gen_prot(self, app):
from spyne.server.twisted.msgpack import TwistedMessagePackProtocol
from twisted.test.proto_helpers import StringTransportWithDisconnection
prot = TwistedMessagePackProtocol(app)
transport = StringTransportWithDisconnection()
prot.makeConnection(transport)
transport.protocol = prot
return prot
def setUp(self):
super().setUp()
self.manager = self.create_peer('testnet')
self.manager.allow_mining_without_peers()
self.factory = StratumFactory(self.manager, port=8123, reactor=MemoryReactorClock())
self.factory.start()
self.protocol = self.factory.buildProtocol('127.0.0.1')
self.transport = StringTransportWithDisconnection()
self.transport.protocol = self.protocol
self.protocol.makeConnection(self.transport)
def test_loseConnectionCodeAndReason(self):
"""
L{WebSocketsTransport.loseConnection} accepts a code and a reason which
are used to build the closing frame.
"""
transport = StringTransportWithDisconnection()
transport.protocol = Protocol()
webSocketsTranport = WebSocketsTransport(transport)
webSocketsTranport.loseConnection(STATUSES.GOING_AWAY, b"Going away")
self.assertEqual(b"\x88\x0c\x03\xe9Going away", transport.value())
