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_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 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 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 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 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 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 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_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 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 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 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 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 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 _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_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):
     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"])