def wsgi_app(env, start): start('200 OK', [('Content-Type', 'text/plain')]) f1 = tulip.Future(loop=self.loop) f1.set_result(b'data') fut = tulip.Future(loop=self.loop) fut.set_result([f1]) return fut
def reset(ws): global size, expected, connected, subscribed, sub_latch, run_latch, subscribers size = int((yield from ws.recv())) expected = size * size connected = 0 subscribed = 0 sub_latch = tulip.Future() run_latch = tulip.Future() subscribers = [[set() for col in range(size)] for row in range(size)]
def test_ctor(self): fut = tulip.Future(loop=self.loop) tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol, fut) test_utils.run_briefly(self.loop) self.assertIsNone(fut.result()) self.protocol.connection_made(tr) self.proactor.recv.assert_called_with(self.sock, 4096)
def wait_for_blocker(blocker): """Run a recursive mainloop until blocker is triggered. @param blocker: event to wait on @type blocker: L{Blocker} @since: 0.53""" assert wait_for_blocker.x is None # Avoid recursion loop = get_loop() glib = loop.glib if not blocker.happened: def quitter(): yield blocker if glib: wait_for_blocker.x.quit() else: wait_for_blocker.x.set_result(None) Task(quitter(), "quitter") wait_for_blocker.x = glib.MainLoop() if glib else tulip.Future() try: logger.debug(_("Entering mainloop, waiting for %s"), blocker) if glib: wait_for_blocker.x.run() else: get_loop().run_until_complete(wait_for_blocker.x) finally: wait_for_blocker.x = None assert blocker.happened, "Someone quit the main loop!" check(blocker)
def run(loop, fut): thread_loop = tulip.new_event_loop() tulip.set_event_loop(thread_loop) socks = thread_loop.run_until_complete( thread_loop.start_serving(lambda: TestHttpServer(keep_alive=0.5), host, port, ssl=sslcontext)) waiter = tulip.Future(loop=thread_loop) loop.call_soon_threadsafe( fut.set_result, (thread_loop, waiter, socks[0].getsockname())) thread_loop.run_until_complete(waiter) # close opened trnsports for tr in transports: tr.close() run_briefly(thread_loop) # call close callbacks for s in socks: thread_loop.stop_serving(s) thread_loop.stop() thread_loop.close() gc.collect()
def test_pause_resume(self): tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol) futures = [] for msg in [b'data1', b'data2', b'data3', b'data4', b'']: f = tulip.Future(loop=self.loop) f.set_result(msg) futures.append(f) self.loop._proactor.recv.side_effect = futures self.loop._run_once() self.assertFalse(tr._paused) self.loop._run_once() self.protocol.data_received.assert_called_with(b'data1') self.loop._run_once() self.protocol.data_received.assert_called_with(b'data2') tr.pause() self.assertTrue(tr._paused) for i in range(10): self.loop._run_once() self.protocol.data_received.assert_called_with(b'data2') tr.resume() self.assertFalse(tr._paused) self.loop._run_once() self.protocol.data_received.assert_called_with(b'data3') self.loop._run_once() self.protocol.data_received.assert_called_with(b'data4') tr.close()
def test_loop_writing_stop(self): fut = tulip.Future(loop=self.loop) fut.set_result(b'data') tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol) tr._write_fut = fut tr._loop_writing(fut) self.assertIsNone(tr._write_fut)
def test_ctor(self): fut = tulip.Future(loop=self.loop) tr = _ProactorSocketTransport( self.loop, self.sock, self.protocol, fut) self.loop.call_soon.mock_calls[0].assert_called_with(tr._loop_reading) self.loop.call_soon.mock_calls[1].assert_called_with( self.protocol.connection_made, tr) self.loop.call_soon.mock_calls[2].assert_called_with( fut.set_result, None)
def run_server(cls, host, port): handler = StaticFilesHandler(get_internal_wsgi_application()) # Save the event loop for the thread in a class variable # so we can unblock it when the tests are finished. cls.server_thread_loop = tulip.new_event_loop() tulip.set_event_loop(cls.server_thread_loop) cls.server_stop = tulip.Future() run(host, port, handler, cls.server_thread_loop, cls.server_stop) cls.server_thread_loop.close()
def test_loop_reading_data(self): res = tulip.Future(loop=self.loop) res.set_result(b'data') tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol) tr._read_fut = res tr._loop_reading(res) self.loop._proactor.recv.assert_called_with(self.sock, 4096) self.protocol.data_received.assert_called_with(b'data')
def test_loop_writing_closing(self): fut = tulip.Future(loop=self.loop) fut.set_result(1) tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol) self.loop.reset_mock() tr._write_fut = fut tr.close() tr._loop_writing(fut) self.assertIsNone(tr._write_fut) self.loop.call_soon.assert_called_with(tr._call_connection_lost, None)
def test_loop_writing_closing(self): fut = tulip.Future(loop=self.loop) fut.set_result(1) tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol) tr._write_fut = fut tr.close() tr._loop_writing(fut) self.assertIsNone(tr._write_fut) test_utils.run_briefly(self.loop) self.protocol.connection_lost.assert_called_with(None)
def test_create_server_cancel(self): pf = unittest.mock.Mock() call_soon = self.loop.call_soon = unittest.mock.Mock() self.loop._start_serving(pf, self.sock) loop = call_soon.call_args[0][0] # cancelled fut = tulip.Future(loop=self.loop) fut.cancel() loop(fut) self.assertTrue(self.sock.close.called)
def test_write_eof_buffer(self): tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol) f = tulip.Future(loop=self.loop) tr._loop._proactor.send.return_value = f tr.write(b'data') tr.write_eof() self.assertTrue(tr._eof_written) self.assertFalse(self.sock.shutdown.called) tr._loop._proactor.send.assert_called_with(self.sock, b'data') f.set_result(4) self.loop._run_once() self.sock.shutdown.assert_called_with(socket.SHUT_WR) tr.close()
def test_loop_reading_no_data(self): res = tulip.Future(loop=self.loop) res.set_result(b'') tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol) self.assertRaises(AssertionError, tr._loop_reading, res) tr.close = unittest.mock.Mock() tr._read_fut = res tr._loop_reading(res) self.assertFalse(self.loop._proactor.recv.called) self.assertTrue(self.protocol.eof_received.called) self.assertTrue(tr.close.called)
def run_test_server(loop, *, host='127.0.0.1', port=0, use_ssl=False, router=None): properties = {} transports = [] class HttpServer: def __init__(self, host, port): self.host = host self.port = port self.address = (host, port) self._url = '{}://{}:{}'.format('https' if use_ssl else 'http', host, port) def __getitem__(self, key): return properties[key] def __setitem__(self, key, value): properties[key] = value def url(self, *suffix): return urllib.parse.urljoin(self._url, '/'.join(str(s) for s in suffix)) class TestHttpServer(tulip.http.ServerHttpProtocol): def connection_made(self, transport): transports.append(transport) super().connection_made(transport) def handle_request(self, message, payload): if properties.get('close', False): return if properties.get('noresponse', False): yield from tulip.sleep(99999) if router is not None: body = bytearray() chunk = yield from payload.read() while chunk: body.extend(chunk) chunk = yield from payload.read() rob = router(self, properties, self.transport, message, bytes(body)) rob.dispatch() else: response = tulip.http.Response(self.transport, 200, message.version) text = b'Test message' response.add_header('Content-type', 'text/plain') response.add_header('Content-length', str(len(text))) response.send_headers() response.write(text) response.write_eof() if use_ssl: here = os.path.join(os.path.dirname(__file__), '..', 'tests') keyfile = os.path.join(here, 'sample.key') certfile = os.path.join(here, 'sample.crt') sslcontext = ssl.SSLContext(ssl.PROTOCOL_SSLv23) sslcontext.load_cert_chain(certfile, keyfile) else: sslcontext = None def run(loop, fut): thread_loop = tulip.new_event_loop() tulip.set_event_loop(thread_loop) socks = thread_loop.run_until_complete( thread_loop.start_serving(lambda: TestHttpServer(keep_alive=0.5), host, port, ssl=sslcontext)) waiter = tulip.Future(loop=thread_loop) loop.call_soon_threadsafe( fut.set_result, (thread_loop, waiter, socks[0].getsockname())) thread_loop.run_until_complete(waiter) # close opened trnsports for tr in transports: tr.close() run_briefly(thread_loop) # call close callbacks for s in socks: thread_loop.stop_serving(s) thread_loop.stop() thread_loop.close() gc.collect() fut = tulip.Future(loop=loop) server_thread = threading.Thread(target=run, args=(loop, fut)) server_thread.start() thread_loop, waiter, addr = loop.run_until_complete(fut) try: yield HttpServer(*addr) finally: thread_loop.call_soon_threadsafe(waiter.set_result, None) server_thread.join()
def __init__(self): self.future = tulip.Future()
def async_func(value): p = tulip.Future() loop.call_later(0.01, p.set_result, value) return p