def test_client_connect_auto(self):
"""
A server will automatically accept client connections by default.
"""
fake_server = FakeServer(self.server_factory)
conn_d = fake_server.await_connection()
self.assertNoResult(conn_d)
client_d = fake_server.endpoint.connect(self.client_factory)
client = self.successResultOf(client_d)
conn = self.successResultOf(conn_d)
self.assert_connected(conn, client)
def test_server_abort(self):
"""
If the server aborts, the client's connection is also lost.
"""
fake_server = FakeServer(self.server_factory)
conn, client = self.connect_client(fake_server)
finished_d = conn.await_finished()
self.assertNoResult(finished_d)
# The disconnection gets scheduled, but doesn't actually happen until
# the next reactor tick.
conn.server_protocol.transport.abortConnection()
self.assert_connected(conn, client)
self.assertNoResult(finished_d)
# Allow the reactor to run so the disconnection gets processed.
yield wait0()
self.assert_disconnected(conn, server_reason=ConnectionAborted)
self.successResultOf(finished_d)
def test_send_client_to_server(self):
"""
Bytes can be sent from the client to the server.
"""
fake_server = FakeServer(self.server_factory)
conn, client = self.connect_client(fake_server)
server = conn.server_protocol
self.assertEqual(server.received, b"")
# Bytes sent, but not received until reactor runs.
d = client.write(b"foo")
self.assertEqual(server.received, b"")
yield d
self.assertEqual(server.received, b"foo")
client.write(b"bar")
d = client.write(b"baz")
self.assertEqual(server.received, b"foo")
yield d
self.assertEqual(server.received, b"foobarbaz")
def test_reject_connection_with_reason(self):
"""
Connections can be rejected with a custom reason.
"""
fake_server = FakeServer(self.server_factory, auto_accept=False)
conn_d = fake_server.await_connection()
self.assertNoResult(conn_d)
client_d = fake_server.endpoint.connect(self.client_factory)
self.assertNoResult(client_d)
conn = self.successResultOf(conn_d)
self.assert_pending(conn)
connected_d = conn.await_connected()
self.assertNoResult(connected_d)
conn.reject_connection(UnknownHostError())
self.assertNoResult(connected_d)
self.failureResultOf(client_d, UnknownHostError)
self.assert_connection_rejected(conn)
def test_reject_connection(self):
"""
Connections can be rejected manually if desired.
"""
fake_server = FakeServer(self.server_factory, auto_accept=False)
conn_d = fake_server.await_connection()
self.assertNoResult(conn_d)
client_d = fake_server.endpoint.connect(self.client_factory)
self.assertNoResult(client_d)
conn = self.successResultOf(conn_d)
self.assert_pending(conn)
connected_d = conn.await_connected()
self.assertNoResult(connected_d)
conn.reject_connection()
self.assertNoResult(connected_d)
self.failureResultOf(client_d, ConnectionRefusedError)
self.assert_connection_rejected(conn)
def test_http_request_potential_data_loss(self):
"""
In the absence of a Content-Length header or chunked transfer encoding,
we need to swallow a PotentialDataLoss exception.
"""
# We can't use Twisted's HTTP server, because that always does the
# sensible thing. We also pretend to be HTTP 1.0 for simplicity.
factory = Factory()
factory.protocol = FakeHTTP10
factory.response_body = ("HTTP/1.0 201 CREATED\r\n"
"Date: Mon, 23 Jan 2012 15:08:47 GMT\r\n"
"Server: Fake HTTP 1.0\r\n"
"Content-Type: text/html; charset=utf-8\r\n"
"\r\n"
"Yay")
fake_server = FakeServer(factory)
agent_factory = lambda *a, **kw: ProxyAgentWithContext(
fake_server.endpoint, *a, **kw)
data = yield http_request(self.url, '', agent_class=agent_factory)
self.assertEqual(data, "Yay")
def test_send_server_to_client(self):
"""
Bytes can be sent from the server to the client.
"""
fake_server = FakeServer(self.server_factory)
conn, client = self.connect_client(fake_server)
server = conn.server_protocol
self.assertEqual(server.received, b"")
# Bytes sent, but not received until reactor runs.
d = server.write(b"foo")
self.assertEqual(client.received, b"")
yield d
self.assertEqual(client.received, b"foo")
# Send two sets of bytes at once, waiting for the second.
server.write(b"bar")
d = server.write(b"baz")
self.assertEqual(client.received, b"foo")
yield d
self.assertEqual(client.received, b"foobarbaz")
def test_client_connect_hook(self):
"""
An on_connect function can be passed to the server to be called
whenever a connection is made.
"""
def on_connect(conn):
conn.hook_was_called = True
conn.client_id_from_hook = id(conn.client_protocol)
conn.server_id_from_hook = id(conn.server_protocol)
fake_server = FakeServer(self.server_factory, on_connect=on_connect)
conn_d = fake_server.await_connection()
self.assertNoResult(conn_d)
client_d = fake_server.endpoint.connect(self.client_factory)
client = self.successResultOf(client_d)
conn = self.successResultOf(conn_d)
self.assert_connected(conn, client)
self.assertEqual(conn.hook_was_called, True)
self.assertEqual(conn.client_id_from_hook, id(client))
self.assertEqual(conn.server_id_from_hook, id(conn.server_protocol))
def test_accept_connection(self):
"""
Connections can be accepted manually if desired.
"""
fake_server = FakeServer(self.server_factory, auto_accept=False)
conn_d = fake_server.await_connection()
self.assertNoResult(conn_d)
client_d = fake_server.endpoint.connect(self.client_factory)
self.assertNoResult(client_d)
conn = self.successResultOf(conn_d)
self.assert_pending(conn)
connected_d = conn.await_connected()
self.assertNoResult(connected_d)
accepted_d = conn.accept_connection()
self.successResultOf(accepted_d)
self.successResultOf(connected_d)
client = self.successResultOf(client_d)
self.assert_connected(conn, client)
