def test_bind_error(self):
first_listener = self.Listener('SomeService', ('localhost', 59357))
second_listener = self.Listener('SomeService', ('localhost', 59357))
with self.assertRaises(BindError):
with start_stop_ctx(first_listener):
with start_stop_ctx(second_listener):
pass
def test_bind_from_pool(self):
self.app.port_range = (59000, 59100)
first_listener = self.Listener('SomeService', ('localhost', None))
second_listener = self.Listener('SomeService', ('localhost', None))
with start_stop_ctx(first_listener):
with start_stop_ctx(second_listener):
self.assertEqual(1, second_listener.port - first_listener.port)
def check_request(self, worker):
connection, data, request_id = Mock(), StringIO(''), 1
with start_stop_ctx(worker):
producer = worker.create_producer(self.service_name)
producer(connection, data, request_id)
self.wait_for_predicate(lambda: not connection.ready.called)
self.assertEqual(1, self.processor.process.call_count)
self.assertEqual(1, connection.ready.call_count)
self.assertEqual((True, '', 1), connection.ready.call_args[0])
def maybe_connect(self, source, acceptor):
client = socket.socket()
client.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
source.bind(('localhost', 0))
source.listen(0)
with closing(source), closing(client), start_stop_ctx(acceptor):
client.settimeout(TIMEOUT)
client.connect(source.getsockname())
self.wakeup_loop()
yield client
def maybe_connect(self, source, acceptor):
client = socket.socket()
client.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
source.bind(('localhost', 0))
source.listen(0)
with closing(source), closing(client), start_stop_ctx(acceptor):
client.settimeout(TIMEOUT)
client.connect(source.getsockname())
self.wakeup_loop()
yield client
def test_producer(self):
connection, data, request_id = \
object(), object(), object()
with start_stop_ctx(self.create_worker()) as worker:
producer = worker.create_producer(self.service_name)
producer(connection, data, request_id)
consumer = worker.consumer
self.assertEqual(1, consumer.call_count)
args, kwargs = consumer.call_args
self.assertEqual(2, len(args))
self.assertTrue(callable(args[0]))
self.assertTrue(callable(args[1]))
def test_producer(self):
connection, data, request_id = \
object(), object(), object()
with start_stop_ctx(self.create_worker()) as worker:
producer = worker.create_producer(self.service_name)
producer(connection, data, request_id)
consumer = worker.consumer
self.assertEqual(1, consumer.call_count)
args, kwargs = consumer.call_args
self.assertEqual(2, len(args))
self.assertTrue(callable(args[0]))
self.assertTrue(callable(args[1]))
def test_callback(self):
connection, data, request_id, result = \
Mock(), object(), object(), (None, object())
connection.is_waiting.return_value = True
with start_stop_ctx(self.create_worker()) as worker:
request = self.Worker.Request(self.loop, connection, data,
request_id, self.service_name)
request.execute(Mock(return_value=result))
callback = worker.create_callback()
callback(request, result)
self.assertEqual(1, connection.ready.call_count)
args, kwargs = connection.ready.call_args
self.assertTrue(args[0])
self.assertIs(result[1], args[1])
self.assertIs(request_id, args[2])
def test_callback(self):
connection, data, request_id, result = \
Mock(), object(), object(), (None, object())
connection.is_waiting.return_value = True
with start_stop_ctx(self.create_worker()) as worker:
request = self.Worker.Request(
self.loop, connection, data, request_id, self.service_name)
request.execute(Mock(return_value=result))
callback = worker.create_callback()
callback(request, result)
self.assertEqual(1, connection.ready.call_count)
args, kwargs = connection.ready.call_args
self.assertTrue(args[0])
self.assertIs(result[1], args[1])
self.assertIs(request_id, args[2])
def test_register(self):
acceptors = self.Acceptors()
sock = socket.socket()
sock.bind(('localhost', 0))
sock.listen(0)
with closing(sock), start_stop_ctx(acceptors):
acceptors.register(sock.fileno(), self.service_name)
self.wakeup_loop()
registered_acceptors = list(acceptors)
self.assertEqual(1, len(registered_acceptors))
acceptor = registered_acceptors[0]
self.assertFalse(acceptor.active)
acceptors.start_by_name(self.service_name)
self.wakeup_loop()
self.wait_for_predicate(lambda: not acceptor.active)
self.assertTrue(acceptor.active)
self.assertFalse(acceptor.active)
def test_start_stop(self):
listener = self.Listener('SomeService', ('localhost', 0))
with start_stop_ctx(listener):
self.assertLess(0, listener.port)
self.assertEqual(socket.gethostbyname('localhost'), listener.host)
self.assertFalse(listener.channel.closed)
def context(self):
hub = self.hub
return start_stop_ctx(hub)
def context(self):
hub = self.hub
return start_stop_ctx(hub)
