def test_connection_pool(self):
'''Test the connection pool. A very important test!'''
client = Echo(self.server_cfg.addresses[0], pool_size=2)
self.assertEqual(client.pool.pool_size, 2)
self.assertEqual(client.pool.in_use, 0)
self.assertEqual(client.pool.available, 0)
self.assertEqual(client.sessions, 0)
self.assertEqual(client._requests_processed, 0)
#
response = yield client(b'test connection')
self.assertEqual(response, b'test connection')
self.assertEqual(client.pool.in_use, 0)
self.assertEqual(client.pool.available, 1)
self.assertEqual(client.sessions, 1)
self.assertEqual(client._requests_processed, 1)
#
response = yield client(b'test connection 2')
self.assertEqual(response, b'test connection 2')
self.assertEqual(client.pool.in_use, 0)
self.assertEqual(client.pool.available, 1)
self.assertEqual(client.sessions, 1)
self.assertEqual(client._requests_processed, 2)
#
result = yield multi_async((client(b'ciao'),
client(b'pippo'),
client(b'foo')))
self.assertEqual(len(result), 3)
self.assertTrue(b'ciao' in result)
self.assertTrue(b'pippo' in result)
self.assertTrue(b'foo' in result)
self.assertEqual(client.pool.in_use, 0)
self.assertEqual(client.pool.available, 2)
self.assertEqual(client.sessions, 2)
self.assertEqual(client._requests_processed, 5)
#
# drop a connection
conn1 = client.pool._queue.get_nowait()
conn1.close()
conn2 = client.pool._queue.get_nowait()
client.pool._queue.put_nowait(conn1)
client.pool._queue.put_nowait(conn2)
#
result = yield multi_async((client(b'ciao'),
client(b'pippo'),
client(b'foo')))
self.assertEqual(len(result), 3)
self.assertEqual(client.pool.in_use, 0)
self.assertEqual(client.pool.available, 2)
self.assertEqual(client.sessions, 3)
self.assertEqual(client._requests_processed, 8)
#
client.pool.close()
self.assertEqual(client.pool.in_use, 0)
self.assertEqual(client.pool.available, 0)
self.assertEqual(client.sessions, 3)
self.assertEqual(client._requests_processed, 8)
def test_connection_pool(self):
'''Test the connection pool. A very important test!'''
client = Echo(self.server_cfg.addresses[0], pool_size=2)
self.assertEqual(client._loop, get_event_loop())
#
self.assertEqual(client.pool.pool_size, 2)
self.assertEqual(client.pool.in_use, 0)
self.assertEqual(client.pool.available, 0)
self.assertEqual(client.sessions, 0)
self.assertEqual(client._requests_processed, 0)
#
response = yield from client(b'test connection')
self.assertEqual(response, b'test connection')
self.assertEqual(client.pool.in_use, 0)
self.assertEqual(client.pool.available, 1)
self.assertEqual(client.sessions, 1)
self.assertEqual(client._requests_processed, 1)
#
response = yield from client(b'test connection 2')
self.assertEqual(response, b'test connection 2')
self.assertEqual(client.pool.in_use, 0)
self.assertEqual(client.pool.available, 1)
self.assertEqual(client.sessions, 1)
self.assertEqual(client._requests_processed, 2)
#
result = yield from multi_async((client(b'ciao'),
client(b'pippo'),
client(b'foo')))
self.assertEqual(len(result), 3)
self.assertTrue(b'ciao' in result)
self.assertTrue(b'pippo' in result)
self.assertTrue(b'foo' in result)
self.assertEqual(client.pool.in_use, 0)
self.assertEqual(client.pool.available, 2)
self.assertEqual(client.sessions, 2)
self.assertEqual(client._requests_processed, 5)
#
# drop a connection
yield from run_in_loop(client._loop, self._drop_conection, client)
#
result = yield from multi_async((client(b'ciao'),
client(b'pippo'),
client(b'foo')))
self.assertEqual(len(result), 3)
self.assertEqual(client.pool.in_use, 0)
self.assertEqual(client.pool.available, 2)
self.assertEqual(client.sessions, 3)
self.assertEqual(client._requests_processed, 8)
#
yield from run_in_loop(client._loop, client.pool.close)
#
self.assertEqual(client.pool.in_use, 0)
self.assertEqual(client.pool.available, 0)
self.assertEqual(client.sessions, 3)
self.assertEqual(client._requests_processed, 8)
def test_connection_pool(self):
'''Test the connection pool. A very important test!'''
client = Echo(self.server_cfg.addresses[0], pool_size=2)
self.assertNotEqual(client._loop, get_event_loop())
#
self.assertEqual(client.pool.pool_size, 2)
self.assertEqual(client.pool.in_use, 0)
self.assertEqual(client.pool.available, 0)
self.assertEqual(client.sessions, 0)
self.assertEqual(client._requests_processed, 0)
#
response = yield client(b'test connection')
self.assertEqual(response, b'test connection')
self.assertEqual(client.pool.in_use, 0)
self.assertEqual(client.pool.available, 1)
self.assertEqual(client.sessions, 1)
self.assertEqual(client._requests_processed, 1)
#
response = yield client(b'test connection 2')
self.assertEqual(response, b'test connection 2')
self.assertEqual(client.pool.in_use, 0)
self.assertEqual(client.pool.available, 1)
self.assertEqual(client.sessions, 1)
self.assertEqual(client._requests_processed, 2)
#
result = yield multi_async(
(client(b'ciao'), client(b'pippo'), client(b'foo')))
self.assertEqual(len(result), 3)
self.assertTrue(b'ciao' in result)
self.assertTrue(b'pippo' in result)
self.assertTrue(b'foo' in result)
self.assertEqual(client.pool.in_use, 0)
self.assertEqual(client.pool.available, 2)
self.assertEqual(client.sessions, 2)
self.assertEqual(client._requests_processed, 5)
#
# drop a connection
yield run_in_loop(client._loop, self._drop_conection, client)
#
result = yield multi_async(
(client(b'ciao'), client(b'pippo'), client(b'foo')))
self.assertEqual(len(result), 3)
self.assertEqual(client.pool.in_use, 0)
self.assertEqual(client.pool.available, 2)
self.assertEqual(client.sessions, 3)
self.assertEqual(client._requests_processed, 8)
#
yield run_in_loop(client._loop, client.pool.close)
#
self.assertEqual(client.pool.in_use, 0)
self.assertEqual(client.pool.available, 0)
self.assertEqual(client.sessions, 3)
self.assertEqual(client._requests_processed, 8)
def test_connection_pool(self):
"""Test the connection pool. A very important test!"""
client = Echo(self.server_cfg.addresses[0], pool_size=2)
self.assertNotEqual(client._loop, get_event_loop())
#
self.assertEqual(client.pool.pool_size, 2)
self.assertEqual(client.pool.in_use, 0)
self.assertEqual(client.pool.available, 0)
self.assertEqual(client.sessions, 0)
self.assertEqual(client._requests_processed, 0)
#
response = yield client(b"test connection")
self.assertEqual(response, b"test connection")
self.assertEqual(client.pool.in_use, 0)
self.assertEqual(client.pool.available, 1)
self.assertEqual(client.sessions, 1)
self.assertEqual(client._requests_processed, 1)
#
response = yield client(b"test connection 2")
self.assertEqual(response, b"test connection 2")
self.assertEqual(client.pool.in_use, 0)
self.assertEqual(client.pool.available, 1)
self.assertEqual(client.sessions, 1)
self.assertEqual(client._requests_processed, 2)
#
result = yield multi_async((client(b"ciao"), client(b"pippo"), client(b"foo")))
self.assertEqual(len(result), 3)
self.assertTrue(b"ciao" in result)
self.assertTrue(b"pippo" in result)
self.assertTrue(b"foo" in result)
self.assertEqual(client.pool.in_use, 0)
self.assertEqual(client.pool.available, 2)
self.assertEqual(client.sessions, 2)
self.assertEqual(client._requests_processed, 5)
#
# drop a connection
yield run_in_loop(client._loop, self._drop_conection, client)
#
result = yield multi_async((client(b"ciao"), client(b"pippo"), client(b"foo")))
self.assertEqual(len(result), 3)
self.assertEqual(client.pool.in_use, 0)
self.assertEqual(client.pool.available, 2)
self.assertEqual(client.sessions, 3)
self.assertEqual(client._requests_processed, 8)
#
yield run_in_loop(client._loop, client.pool.close)
#
self.assertEqual(client.pool.in_use, 0)
self.assertEqual(client.pool.available, 0)
self.assertEqual(client.sessions, 3)
self.assertEqual(client._requests_processed, 8)
def test_multi(self):
# need From because this is called by test_client method too
result = yield From(multi_async((self.client(b"ciao"), self.client(b"pippo"), self.client(b"foo"))))
self.assertEqual(len(result), 3)
self.assertTrue(b"ciao" in result)
self.assertTrue(b"pippo" in result)
self.assertTrue(b"foo" in result)
def run_testcls(self, consumer, runner, testcls, all_tests):
'''Run all test functions from the :attr:`testcls`.
It uses the following algorithm:
* Run the class method ``setUpClass`` of :attr:`testcls` if defined,
unless the test class should be skipped
* Call :meth:`run_test` for each test functions in :attr:`testcls`
* Run the class method ``tearDownClass`` of :attr:`testcls` if defined,
unless the test class should be skipped.
'''
cfg = testcls.cfg
runner.startTestClass(testcls)
error = None
sequential = getattr(testcls, '_sequential_execution', cfg.sequential)
skip_tests = getattr(testcls, '__unittest_skip__', False)
if not skip_tests:
error = yield self._run(runner,
testcls,
'setUpClass',
add_err=False)
# run the tests
if sequential:
# Loop over all test cases in class
for test in all_tests:
yield self.run_test(test, runner, error)
else:
all = (self.run_test(test, runner, error) for test in all_tests)
yield multi_async(all)
if not skip_tests:
yield self._run(runner, testcls, 'tearDownClass', add_err=False)
runner.stopTestClass(testcls)
coroutine_return(runner.result)
def create_tables(self, remove_existing=False):
'''Loop though :attr:`registered_models` and issue the
:meth:`.Manager.create_table` method.'''
executed = []
for manager in self._registered_models.values():
executed.append(manager.create_table(remove_existing))
return multi_async(executed, loop=self._loop)
def stream_mapping(value, request=None):
result = {}
for key, value in iteritems(value):
if isinstance(value, AsyncString):
value = value.render(request)
result[key] = value
return multi_async(result)
def http_response(self, request, *stream):
'''Return a :class:`.WsgiResponse` or a :class:`~asyncio.Future`.
This method asynchronously wait for :meth:`stream` and subsequently
returns a :class:`.WsgiResponse`.
'''
content_types = request.content_types
if not content_types or self._content_type in content_types:
response = request.response
response.content_type = self._content_type
response.encoding = self.charset
if stream:
stream = stream[0]
else:
stream = multi_async(self.stream(request))
if stream.done():
stream = stream.result()
else:
return chain_future(stream,
callback=partial(
self.http_response, request))
response.content = self.to_string(stream)
return response
else:
raise HttpException(status=415, msg=request.content_types)
def stream_mapping(value, request=None):
result = {}
for key, value in iteritems(value):
if isinstance(value, AsyncString):
value = value.render(request)
result[key] = value
return multi_async(result)
def monitor_start(self, monitor):
'''When the monitor starts load all test classes into the queue'''
# Create a datastore for this test suite
if not self.cfg.task_backend:
server = PulsarDS(bind='127.0.0.1:0',
workers=0,
key_value_save=[],
name='%s_store' % self.name)
yield server()
address = 'pulsar://%s:%s' % server.cfg.addresses[0]
else:
address = self.cfg.task_backend
store = create_store(address, pool_size=2, loop=monitor._loop)
self.get_backend(store)
loader = self.loader
tags = self.cfg.labels
exclude_tags = self.cfg.exclude_labels
if self.cfg.show_leaks:
show = show_leaks if self.cfg.show_leaks == 1 else hide_leaks
self.cfg.set('when_exit', show)
arbiter = pulsar.arbiter()
arbiter.cfg.set('when_exit', show)
try:
tests = []
loader.runner.on_start()
for tag, testcls in loader.testclasses(tags, exclude_tags):
suite = loader.runner.loadTestsFromTestCase(testcls)
if suite and suite._tests:
tests.append((tag, testcls))
self._time_start = None
if tests:
self.logger.info('loading %s test classes', len(tests))
monitor.cfg.set('workers', min(self.cfg.workers, len(tests)))
self._time_start = default_timer()
queued = []
self._tests_done = set()
self._tests_queued = None
#
# Bind to the task_done event
self.backend.bind_event('task_done',
partial(self._test_done, monitor))
for tag, testcls in tests:
r = self.backend.queue_task('test',
testcls=testcls,
tag=tag)
queued.append(r)
queued = yield multi_async(queued)
self.logger.debug('loaded %s test classes', len(tests))
self._tests_queued = set(queued)
yield self._test_done(monitor)
else: # pragma nocover
raise ExitTest('Could not find any tests.')
except ExitTest as e: # pragma nocover
monitor.stream.writeln(str(e))
monitor._loop.stop()
except Exception: # pragma nocover
monitor.logger.critical('Error occurred while starting tests',
exc_info=True)
monitor._loop.call_soon(self._exit, 3)
def test_multi_requests(self):
client = yield get_client(self.server.address)
requests = (client.send_message('Msg%s' % n) for n in range(20))
results = yield multi_async(requests)
self.assertEqual(len(results), 20)
for n, result in enumerate(results):
self.assertEqual(result, 'Msg%s' % n)
def run(self, consumer, runner, testcls, all_tests):
'''Run all test functions from the :attr:`testcls`.
It uses the following algorithm:
* Run the class method ``setUpClass`` of :attr:`testcls` if defined,
unless the test class should be skipped
* Call :meth:`run_test` for each test functions in :attr:`testcls`
* Run the class method ``tearDownClass`` of :attr:`testcls` if defined,
unless the test class should be skipped.
'''
cfg = testcls.cfg
loop = consumer._loop
runner.startTestClass(testcls)
error = None
sequential = getattr(testcls, '_sequential_execution', cfg.sequential)
skip_tests = getattr(testcls, '__unittest_skip__', False)
if not skip_tests:
error = yield self._run(runner, testcls, 'setUpClass',
add_err=False)
# run the tests
if sequential:
# Loop over all test cases in class
for test in all_tests:
yield self.run_test(test, runner, error)
else:
all = (self.run_test(test, runner, error) for test in all_tests)
yield multi_async(all, loop=loop)
if not skip_tests:
yield self._run(runner, testcls, 'tearDownClass', add_err=False)
runner.stopTestClass(testcls)
coroutine_return(runner.result)
def test_multi_requests(self):
client = yield get_client(self.server.address)
requests = (client.send_message('Msg%s' % n) for n in range(20))
results = yield multi_async(requests)
self.assertEqual(len(results), 20)
for n, result in enumerate(results):
self.assertEqual(result, 'Msg%s' % n)
def drop_tables(self):
'''Loop though :attr:`registered_models` and issue the
:meth:`.Manager.drop_table` method.'''
executed = []
for manager in self._registered_models.values():
executed.append(manager.drop_table())
return multi_async(executed, loop=self._loop)
def to_json(self):
self.body._tag = None
body = yield multi_async(self.body.stream(request))
self.head._tag = None
data = {'body': body}
data.extend(self.head.to_json())
coroutine_return(json.dumps(data))
def drop_tables(self):
'''Loop though :attr:`registered_models` and issue the
:meth:`.Manager.drop_table` method.'''
executed = []
for manager in self._registered_models.values():
executed.append(manager.drop_table())
return multi_async(executed, loop=self._loop)
def test_multi(self):
result = yield multi_async(
(self.echo(b'ciao'), self.echo(b'pippo'), self.echo(b'foo')))
self.assertEqual(len(result), 3)
self.assertTrue(b'ciao' in result)
self.assertTrue(b'pippo' in result)
self.assertTrue(b'foo' in result)
def create_tables(self, remove_existing=False):
'''Loop though :attr:`registered_models` and issue the
:meth:`.Manager.create_table` method.'''
executed = []
for manager in self._registered_models.values():
executed.append(manager.create_table(remove_existing))
return multi_async(executed, loop=self._loop)
def test_call_at(self):
loop = get_event_loop()
d1 = Future()
d2 = Future()
c1 = loop.call_at(loop.time()+1, lambda: d1.set_result(loop.time()))
c2 = loop.call_later(1, lambda: d2.set_result(loop.time()))
t1, t2 = yield pulsar.multi_async((d1, d2))
self.assertTrue(t1 <= t2)
def content(self, request=None):
'''Return a :class:`pulsar.Deferred` called once the string is ready.
This method can be called once only since it invokes the :meth:`stream`
method.
'''
stream = self.stream(request)
return multi_async(stream).add_callback(self.to_string)
def test_nodata(self):
yield self.create_feeds('bla', 'foo')
session = self.session()
feeds = yield session.query(Feed1).filter(name=('bla', 'foo')).all()
for feed in feeds:
live, prev = yield multi_async((feed.live, feed.prev))
self.assertFalse(live)
self.assertFalse(prev)
def do_stream(self, request):
# stream the body
body = multi_async(self.body.stream(request))
# the body has asynchronous components
# delay the header untl later
if not body.done():
yield self._html(request, body)
else:
head = multi_async(self.head.stream(request))
#
# header not ready (this should never occur really)
if not head.done():
yield self._html(request, body, head)
else:
yield self._template % (self.flatatt(),
self.head.to_string(head.result()),
self.body.to_string(body.result()))
def _html(self, request, body, head=None):
if head is None:
body = yield body
head = multi_async(self.head.stream(request))
head = yield head
result = self._template % (self.flatatt(), self.head.to_string(head),
self.body.to_string(body))
coroutine_return(result)
def test_multi(self):
result = yield multi_async((self.client(b'ciao'),
self.client(b'pippo'),
self.client(b'foo')))
self.assertEqual(len(result), 3)
self.assertTrue(b'ciao' in result)
self.assertTrue(b'pippo' in result)
self.assertTrue(b'foo' in result)
def content(self, request=None):
'''Return a :class:`pulsar.Deferred` called once the string is ready.
This method can be called once only since it invokes the :meth:`stream`
method.
'''
stream = self.stream(request)
return multi_async(stream).add_callback(self.to_string)
def test_call_at(self):
ioloop = get_event_loop()
d1 = pulsar.Deferred()
d2 = pulsar.Deferred()
c1 = ioloop.call_at(ioloop.timer()+1, lambda: d1.callback(ioloop.timer()))
c2 = ioloop.call_later(1, lambda: d2.callback(ioloop.timer()))
t1, t2 = yield pulsar.multi_async((d1, d2))
self.assertTrue(t1 <= t2)
def do_stream(self, request):
# stream the body
body = multi_async(self.body.stream(request))
# the body has asynchronous components
# delay the header untl later
if not body.done():
yield self._html(request, body)
else:
head = multi_async(self.head.stream(request))
#
# header not ready (this should never occur really)
if not head.done():
yield self._html(request, body, head)
else:
yield self._template % (self.flatatt(),
self.head.to_string(head.result()),
self.body.to_string(body.result()))
def test_call_at(self):
loop = get_event_loop()
d1 = Future()
d2 = Future()
c1 = loop.call_at(loop.time() + 1, lambda: d1.set_result(loop.time()))
c2 = loop.call_later(1, lambda: d2.set_result(loop.time()))
t1, t2 = yield pulsar.multi_async((d1, d2))
self.assertTrue(t1 <= t2)
def monitor_start(self, monitor):
'''When the monitor starts load all test classes into the queue'''
# Create a datastore for this test suite
if not self.cfg.task_backend:
server = PulsarDS(bind='127.0.0.1:0', workers=0,
key_value_save=[],
name='%s_store' % self.name)
yield server()
address = 'pulsar://%s:%s' % server.cfg.addresses[0]
else:
address = self.cfg.task_backend
store = create_store(address, pool_size=2, loop=monitor._loop)
self.get_backend(store)
loader = self.loader
tags = self.cfg.labels
exclude_tags = self.cfg.exclude_labels
if self.cfg.show_leaks:
show = show_leaks if self.cfg.show_leaks == 1 else hide_leaks
self.cfg.set('when_exit', show)
arbiter = pulsar.arbiter()
arbiter.cfg.set('when_exit', show)
try:
tests = []
loader.runner.on_start()
for tag, testcls in loader.testclasses(tags, exclude_tags):
suite = loader.runner.loadTestsFromTestCase(testcls)
if suite and suite._tests:
tests.append((tag, testcls))
self._time_start = None
if tests:
self.logger.info('loading %s test classes', len(tests))
monitor.cfg.set('workers', min(self.cfg.workers, len(tests)))
self._time_start = default_timer()
queued = []
self._tests_done = set()
self._tests_queued = None
#
# Bind to the task_done event
self.backend.bind_event('task_done',
partial(self._test_done, monitor))
for tag, testcls in tests:
r = self.backend.queue_task('test', testcls=testcls,
tag=tag)
queued.append(r)
queued = yield multi_async(queued)
self.logger.debug('loaded %s test classes', len(tests))
self._tests_queued = set(queued)
yield self._test_done(monitor)
else: # pragma nocover
raise ExitTest('Could not find any tests.')
except ExitTest as e: # pragma nocover
monitor.stream.writeln(str(e))
monitor.arbiter.stop()
except Exception: # pragma nocover
monitor.logger.critical('Error occurred while starting tests',
exc_info=True)
monitor._loop.call_soon(self._exit, 3)
def test_ping_test_worker(self):
arbiter = pulsar.get_actor()
info = arbiter.info()
test = info['monitors']['test']
workers = [w['actor']['actor_id'] for w in test['workers']]
self.assertTrue(workers)
result = yield multi_async((arbiter.send(w, 'ping') for w in workers))
self.assertEqual(len(result), len(workers))
self.assertEqual(result, len(result) * ['pong'])
def test_ping_test_worker(self):
arbiter = pulsar.get_actor()
info = arbiter.info()
test = info['monitors']['test']
workers = [w['actor']['actor_id'] for w in test['workers']]
self.assertTrue(workers)
result = yield multi_async((arbiter.send(w, 'ping') for w in workers))
self.assertEqual(len(result), len(workers))
self.assertEqual(result, len(result)*['pong'])
def test_multi(self):
# need From because this is called by test_client method too
result = yield From(
multi_async((self.client(b'ciao'), self.client(b'pippo'),
self.client(b'foo'))))
self.assertEqual(len(result), 3)
self.assertTrue(b'ciao' in result)
self.assertTrue(b'pippo' in result)
self.assertTrue(b'foo' in result)
def test_call_at(self):
ioloop = get_event_loop()
d1 = pulsar.Deferred()
d2 = pulsar.Deferred()
c1 = ioloop.call_at(ioloop.timer() + 1,
lambda: d1.callback(ioloop.timer()))
c2 = ioloop.call_later(1, lambda: d2.callback(ioloop.timer()))
t1, t2 = yield pulsar.multi_async((d1, d2))
self.assertTrue(t1 <= t2)
def _html(self, request, body, head=None):
if head is None:
body = yield body
head = multi_async(self.head.stream(request))
head = yield head
result = self._template % (self.flatatt(),
self.head.to_string(head),
self.body.to_string(body))
coroutine_return(result)
def stream_mapping(value, request):
result = {}
async = False
for key, value in value.items():
if isinstance(value, String):
value = value.render(request)
if is_async(value):
async = True
result[key] = value
return multi_async(result) if async else result
def stream_mapping(value, request):
result = {}
async = False
for key, value in value.items():
if isinstance(value, String):
value = value.render(request)
if isawaitable(value):
async = True
result[key] = value
return multi_async(result) if async else result
def test_multi(self):
d1 = Future()
d2 = Future()
d = multi_async([d1, d2, 'bla'])
self.assertFalse(d.done())
d2.set_result('first')
self.assertFalse(d.done())
d1.set_result('second')
result = yield from d
self.assertEqual(result, ['second', 'first', 'bla'])
def stream_mapping(value, request=None):
result = {}
async = False
for key, value in iteritems(value):
if isinstance(value, AsyncString):
value = value.content(request)
value = maybe_async(value)
async = async or isinstance(value, Deferred)
result[key] = value
return multi_async(result) if async else result
def stream_mapping(value, request=None):
result = {}
async = False
for key, value in iteritems(value):
if isinstance(value, AsyncString):
value = value.content(request)
value = maybe_async(value)
async = async or isinstance(value, Deferred)
result[key] = value
return multi_async(result) if async else result
async def test_multi(self):
d1 = Future()
d2 = Future()
d = multi_async([d1, d2, 'bla'])
self.assertFalse(d.done())
d2.set_result('first')
self.assertFalse(d.done())
d1.set_result('second')
result = await d
self.assertEqual(result, ['second', 'first', 'bla'])
def test_multi(self):
d1 = Future()
d2 = Future()
d = multi_async([d1, d2, "bla"])
self.assertFalse(d.done())
d2.set_result("first")
self.assertFalse(d.done())
d1.set_result("second")
result = yield from d
self.assertEqual(result, ["second", "first", "bla"])
def test_multiple_execute(self):
m = yield from multi_async((send('arbiter', 'run', wait, 1.2),
send('arbiter', 'ping'),
send('arbiter', 'echo', 'ciao!'),
send('arbiter', 'run', wait, 2.1),
send('arbiter', 'echo', 'ciao again!')))
self.assertTrue(m[0] >= 1.1)
self.assertEqual(m[1], 'pong')
self.assertEqual(m[2], 'ciao!')
self.assertTrue(m[3] >= 2.0)
self.assertEqual(m[4], 'ciao again!')
def test_multiple_execute(self):
m = yield from multi_async(
(send('arbiter', 'run', wait, 1.2), send('arbiter', 'ping'),
send('arbiter', 'echo',
'ciao!'), send('arbiter', 'run', wait,
2.1), send('arbiter', 'echo', 'ciao again!')))
self.assertTrue(m[0] >= 1.1)
self.assertEqual(m[1], 'pong')
self.assertEqual(m[2], 'ciao!')
self.assertTrue(m[3] >= 2.0)
self.assertEqual(m[4], 'ciao again!')
def render(self, request=None):
'''Render this string.
This method returns a string or a :class:`.Future` which results
in a string.
'''
stream = multi_async(self.stream(request))
if stream.done():
return self.to_string(stream.result())
else:
return chain_future(stream, callback=self.to_string)
def http_response(self, request):
'''Return a coroutine which results in a :class:`.WsgiResponse`.
This method asynchronously wait for :meth:`stream` and subsequently
returns a :class:`.WsgiResponse`.
'''
response = request.response
response.content_type = self.content_type
body = yield multi_async(self.stream(request))
response.content = self.to_string(body)
coroutine_return(response)
def render(self, request=None):
'''Render this string.
This method returns a string or a :class:`~asyncio.Future` which
results in a string. On the other hand, the callable method of
a :class:`.AsyncString` **always** returns a :class:`~asyncio.Future`.
'''
stream = multi_async(self.stream(request))
if stream.done():
return self.to_string(stream.result())
else:
return chain_future(stream, callback=self.to_string)
def render(self, request=None):
'''Render this string.
This method returns a string or a :class:`~asyncio.Future` which
results in a string. On the other hand, the callable method of
a :class:`.AsyncString` **always** returns a :class:`~asyncio.Future`.
'''
stream = multi_async(self.stream(request))
if stream.done():
return self.to_string(stream.result())
else:
return chain_future(stream, callback=self.to_string)
def test_get(self):
models = self.mapper
d = models.register(self.structure())
session = models.session()
with session.begin() as t:
d = t.add(d)
d['baba'] = 'foo'
d['bee'] = 3
self.assertEqual(len(d.cache.toadd), 2)
yield t.on_result
result = yield multi_async((d['baba'], d.get('bee'), d.get('ggg'),
d.get('ggg', 1)))
self.assertEqual(result, ['foo', 3, None, 1])
yield self.async.assertRaises(KeyError, lambda : d['gggggg'])
def test_get(self):
models = self.mapper
d = models.register(self.structure())
session = models.session()
with session.begin() as t:
d = t.add(d)
d['baba'] = 'foo'
d['bee'] = 3
self.assertEqual(len(d.cache.toadd), 2)
yield t.on_result
result = yield multi_async(
(d['baba'], d.get('bee'), d.get('ggg'), d.get('ggg', 1)))
self.assertEqual(result, ['foo', 3, None, 1])
yield self. async .assertRaises(KeyError, lambda: d['gggggg'])
def commit(self):
'''Commit the transaction.
This method can be invoked once only otherwise an
:class:`.InvalidOperation` occurs.
:return: a :class:`~asyncio.Future` which results in this transaction
'''
if self._executed is None:
fut = multi_async((store.execute_transaction(commands) for
store, commands in iteritems(self._commands)))
self._executed = fut
return self._executed
else:
raise InvalidOperation('Transaction already executed.')
def _unwind(self):
is_bound = self.is_bound
if is_bound:
self._cleaned_data = {}
self._errors = {}
rawdata = self.rawdata
yield multi_async(self._clean_fields(rawdata))
if is_bound:
if not self._errors:
# Invoke the form clean method.
# Useful for cross fields checking
try:
yield self.clean()
except ValidationError as err:
self._form_message(self._errors, FORMKEY, err)
if self._errors:
del self._cleaned_data
def commit(self):
"""Commit the transaction.
This method can be invoked once only otherwise an
:class:`.InvalidOperation` occurs.
:return: a :class:`~asyncio.Future` which results in the list
of transaction
"""
if self._executed is None:
executed = dict(
((store, store.execute_transaction(commands)) for store, commands in iteritems(self._commands))
)
self._executed = multi_async(executed, loop=self._loop)
return self._executed
else:
raise InvalidOperation("Transaction already executed.")
def test_shutdown(self):
# Test an error
pool = greenio.GreenPool()
yield from self. async .assertEqual(pool.submit(lambda: 'OK'), 'OK')
self.assertEqual(len(pool._greenlets), 1)
self.assertEqual(len(pool._available), 1)
a = pool.submit(lambda: 'a')
b = pool.submit(lambda: 'b')
self.assertEqual(len(pool._greenlets), 2)
self.assertEqual(len(pool._available), 0)
result = yield from multi_async([a, b])
self.assertEqual(result[0], 'a')
self.assertEqual(result[1], 'b')
self.assertEqual(len(pool._greenlets), 2)
self.assertEqual(len(pool._available), 2)
yield from pool.shutdown()
self.assertEqual(len(pool._greenlets), 0)
self.assertEqual(len(pool._available), 0)
def run(self, runner, testcls, all_tests, cfg):
'''Run all test functions from the :attr:`testcls`.
It uses the following algorithm:
* Run the class method ``setUpClass`` of :attr:`testcls` if defined,
unless the test class should be skipped
* Call :meth:`run_test` for each test functions in :attr:`testcls`
* Run the class method ``tearDownClass`` of :attr:`testcls` if defined,
unless the test class should be skipped.
'''
runner.startTestClass(testcls)
error = None
timeout = cfg.test_timeout
sequential = getattr(testcls, '_sequential_execution', cfg.sequential)
skip_tests = getattr(testcls, '__unittest_skip__', False)
if not skip_tests:
error = yield self._run(runner,
testcls,
'setUpClass',
timeout,
add_err=False)
# run the tests
if not error:
if sequential:
# Loop over all test cases in class
for test in all_tests:
yield self.run_test(test, runner, cfg)
else:
all = (self.run_test(test, runner, cfg) for test in all_tests)
yield multi_async(all)
else:
for test in all_tests:
runner.startTest(test)
self.add_failure(test, runner, error[0], error[1])
runner.stopTest(test)
if not skip_tests:
yield self._run(runner,
testcls,
'tearDownClass',
timeout,
add_err=False)
yield runner.result
runner.stopTestClass(testcls)
def test_run_producerconsumer(self):
'''A task which produce other tasks'''
sample = 5
r = yield self.proxy.run_new_task(jobname='standarddeviation',
sample=sample, size=100)
self.assertTrue(r)
r = yield self.proxy.wait_for_task(r)
self.assertEqual(r['status'], tasks.SUCCESS)
self.assertEqual(r['result'], 'produced %s new tasks' % sample)
self.assertTrue(tasks.nice_task_message(r))
# We check for the tasks created
created = yield self.proxy.get_tasks(from_task=r['id'])
self.assertEqual(len(created), sample)
stasks = []
for task in created:
stasks.append(self.proxy.wait_for_task(task['id']))
created = yield multi_async(stasks)
self.assertEqual(len(created), sample)
for task in created:
self.assertEqual(task['status'], tasks.SUCCESS)
def _execute_request(self, request):
response = request.response
try:
data = yield from as_coroutine(request.body_data())
except ValueError:
res, status = self._get_error_and_status(InvalidRequest(
status=415, msg='Content-Type must be application/json'))
else:
# if it's batch request
if isinstance(data, list):
status = 200
tasks = [self._call(request, each) for each in data]
yield from multi_async(tasks, raise_on_error=False)
res = [each.result()[0] for each in tasks]
else:
res, status = yield from self._call(request, data)
response.status_code = status
return res
def render(self, request=None, callback=None):
'''Render this string.
This method returns a string or a :class:`~asyncio.Future` which
results in a string. On the other hand, the callable method of
a :class:`.String` **always** returns a :class:`~asyncio.Future`.
'''
stream = []
async = False
for data in self.stream(request):
if isawaitable(data):
async = True
stream.append(data)
if not callback:
callback = self.to_string
if async:
return chain_future(multi_async(stream), callback=callback)
else:
return callback(stream)
