def test_getNodeConnection(self):
"""
L{Process._getNodeConnection}, if no connection is established, as a
connection to a L{OneShotPortMapperFactory}. Once it gets a connection
it sets the calls handler to the client factory to the process handler.
"""
d = self.process._getNodeConnection("egg@spam")
epmd = self.process.oneShotEpmds["spam"]
transport = StringTransportWithDisconnection()
proto = epmd.buildProtocol(("127.0.01", 4369))
proto.makeConnection(transport)
transport.protocol = proto
self.assertEqual(transport.value(), "\x00\x04zegg")
self.assertEqual(epmd.connect, [("spam", 4369, epmd)])
proto.dataReceived(
"w\x00\x00\x09M\x01\x00\x05\x00\x05\x00\x03bar\x00")
[factory] = epmd.factories
self.assertEqual(
epmd.factoriesArgs,
[("foo@bar", "test_cookie", epmd.onConnectionLost)])
clientProto = TestableNodeProtocol()
clientProto.factory = factory
factory._connectDeferred.callback(clientProto)
def check(proto):
self.assertIdentical(proto, clientProto)
self.assertIdentical(factory.handler, self.process.handler)
return d.addCallback(check)
def test_rawsocket_with_factory(self):
"""
Speaking RawSocket when the connection is made will make UniSocket
create a new RawSocket protocol and send the data to it.
"""
t = StringTransport()
class MyFakeRawSocket(Protocol):
"""
A fake RawSocket factory which just echos data back.
"""
def dataReceived(self, data):
self.transport.write(data)
fake_rawsocket = Factory.forProtocol(MyFakeRawSocket)
f = UniSocketServerFactory(rawsocket_factory=fake_rawsocket)
p = f.buildProtocol(None)
p.makeConnection(t)
t.protocol = p
self.assertTrue(t.connected)
p.dataReceived(b'\x7F0000000')
p.dataReceived(b'moredata')
self.assertTrue(t.connected)
self.assertEqual(t.value(), b'\x7F0000000moredata')
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 test_renderProtocol(self):
"""
If protocols are specified via the C{Sec-WebSocket-Protocol} header,
L{WebSocketsResource} passes them to its C{lookupProtocol} argument,
which can decide which protocol to return, and which is accepted.
"""
def lookupProtocol(names, otherRequest):
self.assertEqual(["foo", "bar"], names)
self.assertIdentical(request, otherRequest)
return self.echoProtocol, "bar"
self.resource = WebSocketsResource(lookupProtocol)
request = DummyRequest("/")
request.requestHeaders = Headers(
{"sec-websocket-protocol": ["foo", "bar"]})
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-protocol": "bar",
"sec-websocket-accept": "oYBv54i42V5dw6KnZqOFroecUTc="},
request.outgoingHeaders)
self.assertEqual([""], request.written)
self.assertEqual(101, request.responseCode)
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_websocket_with_map(self):
"""
Speaking WebSocket when the connection is made will make UniSocket
create a new WebSocket protocol and send the data to it.
"""
t = StringTransport()
class MyFakeWebSocket(Protocol):
"""
A fake WebSocket factory which just echos data back.
"""
def dataReceived(self, data):
self.transport.write(data)
fake_websocket = Factory.forProtocol(MyFakeWebSocket)
websocket_map = OrderedDict({u"baz": None})
websocket_map["ws"] = fake_websocket
f = UniSocketServerFactory(websocket_factory_map=websocket_map)
p = f.buildProtocol(None)
p.makeConnection(t)
t.protocol = p
self.assertTrue(t.connected)
p.dataReceived(b'GET /ws HTTP/1.1\r\nConnection: close\r\n\r\n')
self.assertTrue(t.connected)
self.assertEqual(t.value(),
b'GET /ws HTTP/1.1\r\nConnection: close\r\n\r\n')
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("/")
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.assertIsInstance(transport.protocol, WebSocketsProtocolWrapper)
self.assertIsInstance(transport.protocol.wrappedProtocol,
AccumulatingProtocol)
def test_web_with_factory(self):
"""
Speaking HTTP will pass it down to the HTTP factory.
"""
t = StringTransport()
class MyResource(Resource):
isLeaf = True
def render_GET(self, request):
return b"hi!"
r = MyResource()
s = Site(r)
f = UniSocketServerFactory(web_factory=s)
p = f.buildProtocol(None)
p.makeConnection(t)
t.protocol = p
self.assertTrue(t.connected)
p.dataReceived(b'GET / HTTP/1.1\r\nConnection: close\r\n\r\n')
self.assertFalse(t.connected)
self.assertIn(b"hi!", t.value())
def test_connectToNode(self):
"""
L{OneShotPortMapperFactory.connectToNode} should return a L{Deferred}
that will be called back with the instance of the protocol connected
to the erlang node.
"""
clientFactory = DummyClientFactory()
self.factory.nodeFactoryClass = lambda a, b, c: clientFactory
d = self.factory.connectToNode("egg@spam")
transport = StringTransportWithDisconnection()
proto = self.factory.buildProtocol(("127.0.01", 4369))
proto.makeConnection(transport)
transport.protocol = proto
self.assertEqual(transport.value(), "\x00\x04zegg")
self.assertEqual(
self.factory.connect, [("127.0.0.1", 4369, self.factory)])
proto.dataReceived(
"w\x00\x00\x09M\x01\x00\x05\x00\x05\x00\x03bar\x00")
clientProto = object()
clientFactory._connectDeferred.callback(clientProto)
self.assertEqual(
self.factory.connect,
[("127.0.0.1", 4369, self.factory),
("127.0.0.1", 9, clientFactory)])
return d.addCallback(self.assertIdentical, clientProto)
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("0123456789")
port.dataReceived("abcdefghij")
self.assertEqual(tr.value(), "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)
class CommandFailureTests(CommandMixin, TestCase):
"""
Tests for correct failure of commands on a disconnected
L{MemCacheProtocol}.
"""
def setUp(self):
"""
Create a disconnected memcache client, using a deterministic clock.
"""
self.proto = MemCacheProtocol()
self.clock = Clock()
self.proto.callLater = self.clock.callLater
self.transport = StringTransportWithDisconnection()
self.transport.protocol = self.proto
self.proto.makeConnection(self.transport)
self.transport.loseConnection()
def _test(self, d, send, recv, result):
"""
Implementation of C{_test} which checks that the command fails with
C{RuntimeError} because the transport is disconnected. All the
parameters except C{d} are ignored.
"""
return self.assertFailure(d, RuntimeError)
class ProtocolTestCase(unittest.TestCase):
def setUp(self):
self.proto = Redis()
self.transport = StringTransportWithDisconnection()
self.transport.protocol = self.proto
self.proto.makeConnection(self.transport)
def sendResponse(self, data):
self.proto.dataReceived(data)
def test_error_response(self):
# pretending 'foo' is a set, so get is incorrect
d = self.proto.get("foo")
self.assertEquals(
self.transport.value(),
'*2\r\n$3\r\nGET\r\n$3\r\nfoo\r\n')
msg = "Operation against a key holding the wrong kind of value"
self.sendResponse("-%s\r\n" % msg)
self.failUnlessFailure(d, ResponseError)
def check_err(r):
self.assertEquals(str(r), msg)
return d
@defer.inlineCallbacks
def test_singleline_response(self):
d = self.proto.ping()
self.assertEquals(self.transport.value(), '*1\r\n$4\r\nPING\r\n')
self.sendResponse("+PONG\r\n")
r = yield d
self.assertEquals(r, 'PONG')
@defer.inlineCallbacks
def test_bulk_response(self):
d = self.proto.get("foo")
self.assertEquals(
self.transport.value(),
'*2\r\n$3\r\nGET\r\n$3\r\nfoo\r\n')
self.sendResponse("$3\r\nbar\r\n")
r = yield d
self.assertEquals(r, 'bar')
@defer.inlineCallbacks
def test_multibulk_response(self):
d = self.proto.lrange("foo", 0, 1)
expected = '*4\r\n$6\r\nLRANGE\r\n$3\r\nfoo\r\n$1\r\n0\r\n$1\r\n1\r\n'
self.assertEquals(self.transport.value(), expected)
self.sendResponse("*2\r\n$3\r\nbar\r\n$6\r\nlolwut\r\n")
r = yield d
self.assertEquals(r, ['bar', 'lolwut'])
@defer.inlineCallbacks
def test_integer_response(self):
d = self.proto.dbsize()
self.assertEquals(self.transport.value(), '*1\r\n$6\r\nDBSIZE\r\n')
self.sendResponse(":1234\r\n")
r = yield d
self.assertEquals(r, 1234)
class TestProtocol(common.TestCase):
def setUp(self):
self.transport = StringTransportWithDisconnection()
self.protocol = httpclient.Protocol(self, owner=None)
self.protocol.factory = MockFactory()
self.protocol.makeConnection(self.transport)
self.transport.protocol = self.protocol
self.addCleanup(self._disconnect_protocol)
@defer.inlineCallbacks
def testSimpleRequest(self):
self.assertTrue(self.protocol.factory.onConnectionMade_called)
self.assertTrue(self.protocol.is_idle())
d = self.protocol.request(http.Methods.GET, '/',
headers={'accept': 'text/html'})
self.assertEqual('GET / HTTP/1.1\r\n'
'Accept: text/html\r\n\r\n', self.transport.value())
self.assertFalse(self.protocol.is_idle())
self.protocol.dataReceived(
self.protocol.delimiter.join([
"HTTP/1.1 200 OK",
"Content-Type: text/html",
"Content-Length: 12",
"",
"This is body",
]))
response = yield d
self.assertIsInstance(response, httpclient.Response)
self.assertEqual(200, response.status)
self.assertEqual({'content-type': 'text/html',
'content-length': '12'}, response.headers)
self.assertEqual('This is body', response.body)
self.assertTrue(self.protocol.is_idle())
self.assertTrue(self.protocol.factory.onConnectionReset_called)
@defer.inlineCallbacks
def testCancelledRequest(self):
d = self.protocol.request(http.Methods.GET, '/',
headers={'accept': 'text/html'})
d.cancel()
self.assertFalse(self.transport.connected)
self.assertFailure(d, httpclient.RequestCancelled)
f = yield d
exp = ('GET to http://10.0.0.1:12345/ was cancelled '
'0.(\d+)s after it was sent.')
self.assertTrue(re.match(exp, str(f)), str(f))
def _disconnect_protocol(self):
if self.transport.connected:
self.transport.loseConnection()
self.assertTrue(self.protocol.factory.onConnectionLost_called)
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 _serverSetup(self):
wrappedFactory = protocol.ServerFactory()
wrappedFactory.protocol = SimpleProtocol
factory = policies.TimeoutFactory(wrappedFactory, 3)
proto = factory.buildProtocol(address.IPv4Address('TCP', '127.0.0.1', 12345))
transport = StringTransportWithDisconnection()
transport.protocol = proto
proto.makeConnection(transport)
return factory, proto, transport
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 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, "Going away")
self.assertEqual("\x88\x0c\x03\xe9Going away", transport.value())
def test_connection(self):
"""
On connection, the EPMD client should send an ALIVE2 request.
"""
self.factory.nodePortNumber = 1234
transport = StringTransportWithDisconnection()
proto = self.factory.buildProtocol(("127.0.01", 4369))
proto.makeConnection(transport)
transport.protocol = proto
self.assertEquals(transport.value(),
"\x00\x10x\x04\xd2H\x00\x00\x05\x00\x05\x00\x03foo\x00\x00")
def connectProxy(self, proxyClient):
"""
Connect a proxy client to a L{StringTransportWithDisconnection}.
@param proxyClient: A L{ProxyClient}.
@return: The L{StringTransportWithDisconnection}.
"""
clientTransport = StringTransportWithDisconnection()
clientTransport.protocol = proxyClient
proxyClient.makeConnection(clientTransport)
return clientTransport
def test_invalidHeaderDisconnects(self):
"""
Test if invalid headers result in connectionLost events.
"""
factory = HAProxyWrappingFactory(Factory.forProtocol(StaticProtocol))
proto = factory.buildProtocol(address.IPv4Address("TCP", b"127.1.1.1", 8080))
transport = StringTransportWithDisconnection()
transport.protocol = proto
proto.makeConnection(transport)
proto.dataReceived(b"NOTPROXY anything can go here\r\n")
self.assertFalse(transport.connected)
def test_invalidHeaderDisconnects(self):
"""
Test if invalid headers result in connectionLost events.
"""
factory = HAProxyWrappingFactory(Factory.forProtocol(StaticProtocol))
proto = factory.buildProtocol(address.IPv6Address("TCP", b"::1", 8080))
transport = StringTransportWithDisconnection()
transport.protocol = proto
proto.makeConnection(transport)
proto.dataReceived(b"\x00" + self.IPV4HEADER[1:])
self.assertFalse(transport.connected)
def makeTestConnections(client):
client.factories = []
transports = []
for addr in client.hosts:
factory = MemCacheClientFactory()
client.factories.append(factory)
proto = factory.buildProtocol(addr, timeOut=None)
transport = StringTransportWithDisconnection()
transport.protocol = proto
proto.makeConnection(transport)
transports.append(transport)
return transports
class Protocol(unittest.TestCase):
def setUp(self):
self.proto = Redis()
self.transport = StringTransportWithDisconnection()
self.transport.protocol = self.proto
self.proto.makeConnection(self.transport)
def sendResponse(self, data):
self.proto.dataReceived(data)
@defer.inlineCallbacks
def test_error_response(self):
# pretending 'foo' is a set, so get is incorrect
d = self.proto.get("foo")
self.assertEquals(self.transport.value(), "GET foo\r\n")
msg = "Operation against a key holding the wrong kind of value"
self.sendResponse("-%s\r\n" % msg)
r = yield d
self.assertEquals(str(r), msg)
@defer.inlineCallbacks
def test_singleline_response(self):
d = self.proto.ping()
self.assertEquals(self.transport.value(), "PING\r\n")
self.sendResponse("+PONG\r\n")
r = yield d
self.assertEquals(r, 'PONG')
@defer.inlineCallbacks
def test_bulk_response(self):
d = self.proto.get("foo")
self.assertEquals(self.transport.value(), "GET foo\r\n")
self.sendResponse("$3\r\nbar\r\n")
r = yield d
self.assertEquals(r, 'bar')
@defer.inlineCallbacks
def test_multibulk_response(self):
d = self.proto.lrange("foo", 0, 1)
self.assertEquals(self.transport.value(), "LRANGE foo 0 1\r\n")
self.sendResponse("*2\r\n$3\r\nbar\r\n$6\r\nlolwut\r\n")
r = yield d
self.assertEquals(r, ['bar', 'lolwut'])
@defer.inlineCallbacks
def test_integer_response(self):
d = self.proto.dbsize()
self.assertEquals(self.transport.value(), "DBSIZE\r\n")
self.sendResponse(":1234\r\n")
r = yield d
self.assertEquals(r, 1234)
def test_loseConnection(self):
"""
L{WebSocketsTransport.loseConnection} sends a close frame and closes
the transport afterwards.
"""
transport = StringTransportWithDisconnection()
transport.protocol = Protocol()
webSocketsTranport = WebSocketsTransport(transport)
webSocketsTranport.loseConnection()
self.assertFalse(transport.connected)
self.assertEqual(b"\x88\x02\x03\xe8", transport.value())
# We can call loseConnection again without side effects
webSocketsTranport.loseConnection()
def test_invalidHeaderDisconnects(self):
"""
Test if invalid headers result in connectionLost events.
"""
factory = HAProxyWrappingFactory(Factory.forProtocol(StaticProtocol))
proto = factory.buildProtocol(
address.IPv6Address('TCP', b'::1', 8080),
)
transport = StringTransportWithDisconnection()
transport.protocol = proto
proto.makeConnection(transport)
proto.dataReceived(b'\x00' + self.IPV4HEADER[1:])
self.assertFalse(transport.connected)
def test_invalidHeaderDisconnects(self):
"""
Test if invalid headers result in connectionLost events.
"""
factory = HAProxyWrappingFactory(Factory.forProtocol(StaticProtocol))
proto = factory.buildProtocol(
address.IPv4Address('TCP', b'127.1.1.1', 8080),
)
transport = StringTransportWithDisconnection()
transport.protocol = proto
proto.makeConnection(transport)
proto.dataReceived(b'NOTPROXY anything can go here\r\n')
self.assertFalse(transport.connected)
def test_loseConnection(self):
"""
L{WebSocketsTransport.loseConnection} sends a close frame and closes
the transport afterwards.
"""
transport = StringTransportWithDisconnection()
transport.protocol = Protocol()
webSocketsTranport = WebSocketsTransport(transport)
webSocketsTranport.loseConnection()
self.assertFalse(transport.connected)
self.assertEqual("\x88\x02\x03\xe8", transport.value())
# We can call loseConnection again without side effects
webSocketsTranport.loseConnection()
def test_invalidPartialHeaderDisconnects(self):
"""
Test if invalid headers result in connectionLost events.
"""
factory = HAProxyWrappingFactory(Factory.forProtocol(StaticProtocol))
proto = factory.buildProtocol(
address.IPv4Address("TCP", b"127.1.1.1", 8080), )
transport = StringTransportWithDisconnection()
transport.protocol = proto
proto.makeConnection(transport)
proto.dataReceived(b"PROXY TCP4 1.1.1.1\r\n")
proto.dataReceived(b"2.2.2.2 8080\r\n")
self.assertFalse(transport.connected)
def test_renderProtocol(self):
"""
If protocols are specified via the C{Sec-WebSocket-Protocol} header,
L{WebSocketsResource} passes them to its C{lookupProtocol} argument,
which can decide which protocol to return, and which is accepted.
"""
def lookupProtocol(names, otherRequest):
self.assertEqual([b"foo", b"bar"], names)
self.assertIs(request, otherRequest)
return self.echoProtocol, b"bar"
self.resource = WebSocketsResource(lookupProtocol)
request = DummyRequest(b"/")
request.requestHeaders = Headers(
{
b"sec-websocket-protocol": [b"foo", b"bar"],
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.assertEqual(
{
b"Connection": [b"Upgrade"],
b"Upgrade": [b"WebSocket"],
b"Sec-Websocket-Protocol": [b"bar"],
b"Sec-Websocket-Accept": [b"oYBv54i42V5dw6KnZqOFroecUTc="],
},
{
name: value
for name, value in request.responseHeaders.getAllRawHeaders()
},
)
self.assertEqual([b""], request.written)
self.assertEqual(101, request.responseCode)
def setUp(self):
super().setUp()
from hathor.transaction.genesis import _get_genesis_transactions_unsafe
self.block = next(x for x in _get_genesis_transactions_unsafe(None)
if x.is_block)
self.transport = StringTransportWithDisconnection()
self.protocol = StratumClient()
self.protocol.makeConnection(self.transport)
self.job_request_params = {
'data': self.block.get_header_without_nonce().hex(),
'job_id': 'a734d03fe4b64739be2894742f3de20f',
'nonce_size': Block.SERIALIZATION_NONCE_SIZE,
'weight': self.block.weight,
}
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_websocket_mechanics():
"""
Shows that we can put our protocol (hey_joe._WayDownSouth) and factory (hey_joe.WebSocketService)
together, along with a transport, and properly open a websocket connection.
"""
transport = StringTransportWithDisconnection()
service = hey_joe.WebSocketService("127.0.0.1", 9000)
protocol = service.buildProtocol(service._hey_joe_addr)
protocol.transport = transport
transport.protocol = protocol
protocol.connectionMade()
data_to_send = b'GET / HTTP/1.1\r\nHost: somewhere_in_the_world:9000\r\nConnection: keep-alive, Upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 13\r\nSec-WebSocket-Key: F76ObkF/aCKX8WkmAgx2OQ==\r\n\r\n'
protocol.dataReceived(data_to_send)
assert transport.value().startswith(b'HTTP/1.1 101 Switching Protocols\r\nServer: hendrix')
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 test_writeSequence(self):
"""
L{ThrottlingProtocol.writeSequence} is called on the underlying factory.
"""
server = Server()
tServer = TestableThrottlingFactory(task.Clock(), server)
protocol = tServer.buildProtocol(address.IPv4Address("TCP", "127.0.0.1", 0))
transport = StringTransportWithDisconnection()
transport.protocol = protocol
protocol.makeConnection(transport)
protocol.writeSequence([b"bytes"] * 4)
self.assertEqual(transport.value(), b"bytesbytesbytesbytes")
self.assertEqual(tServer.writtenThisSecond, 20)
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_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 test_kill(self):
"""
L{OneShotPortMapperFactory.kill} should return a L{Deferred} that
will be called back when the kill request is complete.
"""
d = self.factory.kill()
transport = StringTransportWithDisconnection()
proto = self.factory.buildProtocol(("127.0.01", 4369))
proto.makeConnection(transport)
transport.protocol = proto
self.assertEqual(transport.value(), "\x00\x01k")
proto.dataReceived("OK")
transport.loseConnection()
return d.addCallback(self.assertEqual, "OK")
class BaseStratumClientTest(unittest.TestCase):
__test__ = False
def setUp(self):
super().setUp()
from hathor.transaction.genesis import _get_genesis_transactions_unsafe
self.block = next(x for x in _get_genesis_transactions_unsafe(None)
if x.is_block)
self.transport = StringTransportWithDisconnection()
self.protocol = StratumClient()
self.protocol.makeConnection(self.transport)
self.job_request_params = {
'data': self.block.get_header_without_nonce().hex(),
'job_id': 'a734d03fe4b64739be2894742f3de20f',
'nonce_size': Block.SERIALIZATION_NONCE_SIZE,
'weight': self.block.weight,
}
def tearDown(self):
super().tearDown()
self.protocol.stop()
@pytest.mark.skip(reason='hangs on some systems')
def test_n_core_mining(self):
self.protocol.start(self.clock)
self.protocol.handle_request('job', self.job_request_params, None)
# Ignore subscribe request and empty line after line break
requests = self.transport.value().split(JSONRPC.delimiter)[1:-1]
while len(requests) < 1:
sleep(1)
self.clock.advance(1)
requests = self.transport.value().split(JSONRPC.delimiter)[1:-1]
submits = [json_loads(request) for request in requests]
submits_params = [submit['params'] for submit in submits]
methods = [submit['method'] for submit in submits]
jobs_id = [params['job_id'] for params in submits_params]
nonces = [params['nonce'] for params in submits_params]
self.assertTrue(all(method == 'submit' for method in methods))
self.assertTrue(
all(job_id == self.job_request_params['job_id']
for job_id in jobs_id))
for nonce in nonces:
self.block.nonce = int(nonce, 16)
self.block.update_hash()
self.block.verify_pow()
def test_names(self):
"""
L{OneShotPortMapperFactory.names} should return a L{Deferred} that
will be called back when the names request is complete.
"""
d = self.factory.names()
transport = StringTransportWithDisconnection()
proto = self.factory.buildProtocol(("127.0.01", 4369))
proto.makeConnection(transport)
transport.protocol = proto
self.assertEqual(transport.value(), "\x00\x01n")
proto.dataReceived("\x00\x00\x00\x01")
proto.dataReceived("name %s at port %s\n" % ("foo", 1234))
transport.loseConnection()
return d.addCallback(self.assertEqual, [("foo", 1234)])
def test_writeSequence(self):
"""
L{ThrottlingProtocol.writeSequence} is called on the underlying factory.
"""
server = Server()
tServer = TestableThrottlingFactory(task.Clock(), server)
protocol = tServer.buildProtocol(
address.IPv4Address('TCP', '127.0.0.1', 0))
transport = StringTransportWithDisconnection()
transport.protocol = protocol
protocol.makeConnection(transport)
protocol.writeSequence([b'bytes'] * 4)
self.assertEqual(transport.value(), b"bytesbytesbytesbytes")
self.assertEqual(tServer.writtenThisSecond, 20)
def test_web_with_no_factory(self):
"""
Trying to speak HTTP without a factory will drop the connection.
"""
t = StringTransport()
f = UniSocketServerFactory()
p = f.buildProtocol(None)
p.makeConnection(t)
t.protocol = p
self.assertTrue(t.connected)
p.dataReceived(b'GET /foo HTTP/1.1\r\n\r\n')
self.assertFalse(t.connected)
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 = 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 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_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} 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_breakReferenceCycle(self):
"""
L{policies.ProtocolWrapper.connectionLost} sets C{wrappedProtocol} to
C{None} in order to break reference cycle between wrapper and wrapped
protocols.
:return:
"""
wrapper = policies.ProtocolWrapper(policies.WrappingFactory(Server()),
protocol.Protocol())
transport = StringTransportWithDisconnection()
transport.protocol = wrapper
wrapper.makeConnection(transport)
self.assertIsNotNone(wrapper.wrappedProtocol)
transport.loseConnection()
self.assertIsNone(wrapper.wrappedProtocol)
class TestLogin(TestCase):
def setUp(self):
self.sp = CredReceiver()
self.sp.factory = CredAMPServerFactory()
self.sp.factory.sUsername = '******'
self.transport = StringTransportWithDisconnection()
self.sp.makeConnection(self.transport)
self.transport.protocol = self.sp
self.testFrame = ("00:82:a0:00:00:53:45:52:50:2d:42:30:91:1d:1b:03:" +
"8d:0b:5c:03:02:28:01:9c:01:ab:02:4c:02:98:01:da:" +
"02:40:00:00:00:10:0a:46:58:10:00:c4:9d:cb:a2:21:39")
def tearDown(self):
self.sp.factory.active_protocols = {}
self.sp.factory.active_connections = {}
def test_serverSendsAnythingWhenReceiveFrame(self):
self.sp.dataReceived(self.testFrame)
return self.assertEquals('', self.transport.value())
@patch.object(CredReceiver, 'resetTimeout')
def test_timeoutResetWhenReceivesMessage(self, resetTimeout):
self.sp.dataReceived(self.testFrame)
return self.assertEqual(resetTimeout.call_count, 1)
def test_invalid_status_line(self):
"""
Not speaking RawSocket or MQTT but also not speaking a type of HTTP
will cause the connection to be dropped.
"""
t = StringTransport()
f = UniSocketServerFactory()
p = f.buildProtocol(None)
p.makeConnection(t)
t.protocol = p
self.assertTrue(t.connected)
p.dataReceived(b'this is not HTTP\r\n\r\n')
self.assertFalse(t.connected)
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.sp = CredReceiver()
self.sp.factory = CredAMPServerFactory()
self.transport = StringTransportWithDisconnection()
self.sp.makeConnection(self.transport)
self.transport.protocol = self.sp
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_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 _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):
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)
# subscribe and ignore response
_send_subscribe(self.protocol)
self.job = self._get_latest_message()['params']
self.transport.clear()
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 test_subscribe(self):
transport = StringTransportWithDisconnection()
protocol = self.factory.buildProtocol('127.0.0.1')
protocol.makeConnection(transport)
id = uuid4()
_send_subscribe(protocol, id)
self.assertEqual(len(self.factory.miner_protocols), 2)
data = transport.value().split(JSONRPC.delimiter)
self.assertEqual(len(data), 3)
response = json_loads(data[0])
self.assertEqual(response['id'], str(id))
self.assertEqual(response['result'], "ok")
job = json_loads(data[1])
self.assertEqual(job['method'], 'job')
