def main(): """A simple test runner. This test runner is essentially equivalent to `unittest.main` from the standard library, but adds support for tornado-style option parsing and log formatting. The easiest way to run a test is via the command line:: python -m anzu.testing anzu.test.stack_context_test See the standard library unittest module for ways in which tests can be specified. Projects with many tests may wish to define a test script like anzu/test/runtests.py. This script should define a method all() which returns a test suite and then call anzu.testing.main(). Note that even when a test script is used, the all() test suite may be overridden by naming a single test on the command line:: # Runs all tests tornado/test/runtests.py # Runs one test tornado/test/runtests.py anzu.test.stack_context_test """ from anzu.options import define, options, parse_command_line define('autoreload', type=bool, default=False, help="DEPRECATED: use anzu.autoreload.main instead") define('httpclient', type=str, default=None) argv = [sys.argv[0]] + parse_command_line(sys.argv) if options.httpclient: from anzu.httpclient import AsyncHTTPClient AsyncHTTPClient.configure(options.httpclient) if __name__ == '__main__' and len(argv) == 1: print >> sys.stderr, "No tests specified" sys.exit(1) try: # In order to be able to run tests by their fully-qualified name # on the command line without importing all tests here, # module must be set to None. Python 3.2's unittest.main ignores # defaultTest if no module is given (it tries to do its own # test discovery, which is incompatible with auto2to3), so don't # set module if we're not asking for a specific test. if len(argv) > 1: unittest.main(module=None, argv=argv) else: unittest.main(defaultTest="all", argv=argv) except SystemExit, e: if e.code == 0: logging.info('PASS') else: logging.error('FAIL') if not options.autoreload: raise
def main(): """A simple test runner. This test runner is essentially equivalent to `unittest.main` from the standard library, but adds support for tornado-style option parsing and log formatting. The easiest way to run a test is via the command line:: python -m anzu.testing anzu.test.stack_context_test See the standard library unittest module for ways in which tests can be specified. Projects with many tests may wish to define a test script like anzu/test/runtests.py. This script should define a method all() which returns a test suite and then call anzu.testing.main(). Note that even when a test script is used, the all() test suite may be overridden by naming a single test on the command line:: # Runs all tests tornado/test/runtests.py # Runs one test tornado/test/runtests.py anzu.test.stack_context_test """ from anzu.options import define, options, parse_command_line define("autoreload", type=bool, default=False, help="DEPRECATED: use anzu.autoreload.main instead") define("httpclient", type=str, default=None) argv = [sys.argv[0]] + parse_command_line(sys.argv) if options.httpclient: from anzu.httpclient import AsyncHTTPClient AsyncHTTPClient.configure(options.httpclient) if __name__ == "__main__" and len(argv) == 1: print >>sys.stderr, "No tests specified" sys.exit(1) try: # In order to be able to run tests by their fully-qualified name # on the command line without importing all tests here, # module must be set to None. Python 3.2's unittest.main ignores # defaultTest if no module is given (it tries to do its own # test discovery, which is incompatible with auto2to3), so don't # set module if we're not asking for a specific test. if len(argv) > 1: unittest.main(module=None, argv=argv) else: unittest.main(defaultTest="all", argv=argv) except SystemExit, e: if e.code == 0: logging.info("PASS") else: logging.error("FAIL") if not options.autoreload: raise
def setUp(self): super(AsyncHTTPTestCase, self).setUp() self.__port = None self.http_client = AsyncHTTPClient(io_loop=self.io_loop) self._app = self.get_app() self.http_server = HTTPServer(self._app, io_loop=self.io_loop, **self.get_httpserver_options()) self.http_server.listen(self.get_http_port(), address="127.0.0.1")
for key, value in san: if key == 'DNS': if _dnsname_to_pat(value).match(hostname): return dnsnames.append(value) if not san: # The subject is only checked when subjectAltName is empty for sub in cert.get('subject', ()): for key, value in sub: # XXX according to RFC 2818, the most specific Common Name # must be used. if key == 'commonName': if _dnsname_to_pat(value).match(hostname): return dnsnames.append(value) if len(dnsnames) > 1: raise CertificateError("hostname %r " "doesn't match either of %s" % (hostname, ', '.join(map(repr, dnsnames)))) elif len(dnsnames) == 1: raise CertificateError("hostname %r " "doesn't match %r" % (hostname, dnsnames[0])) else: raise CertificateError("no appropriate commonName or " "subjectAltName fields were found") if __name__ == "__main__": AsyncHTTPClient.configure(SimpleAsyncHTTPClient) main()
def get(self): io_loop = self.request.connection.stream.io_loop client = AsyncHTTPClient(io_loop=io_loop) response = yield gen.Task(client.fetch, self.get_argument('url')) response.rethrow() self.finish(b("got response: ") + response.body)
def get_http_client(self): """Returns AsyncHTTPClient instance. May be overridden in subclass.""" return AsyncHTTPClient(io_loop=self.io_loop)
# there may not be any other threads running at the time we call # threading.activeCount. curl.setopt(pycurl.NOSIGNAL, 1) if request.prepare_curl_callback is not None: request.prepare_curl_callback(curl) def _curl_header_callback(headers, header_line): # header_line as returned by curl includes the end-of-line characters. header_line = header_line.strip() if header_line.startswith("HTTP/"): headers.clear() return if not header_line: return headers.parse_line(header_line) def _curl_debug(debug_type, debug_msg): debug_types = ('I', '<', '>', '<', '>') if debug_type == 0: logging.debug('%s', debug_msg.strip()) elif debug_type in (1, 2): for line in debug_msg.splitlines(): logging.debug('%s %s', debug_types[debug_type], line) elif debug_type == 4: logging.debug('%s %r', debug_types[debug_type], debug_msg) if __name__ == "__main__": AsyncHTTPClient.configure(CurlAsyncHTTPClient) main()
class AsyncHTTPTestCase(AsyncTestCase): '''A test case that starts up an HTTP server. Subclasses must override get_app(), which returns the anzu.web.Application (or other HTTPServer callback) to be tested. Tests will typically use the provided self.http_client to fetch URLs from this server. Example:: class MyHTTPTest(AsyncHTTPTestCase): def get_app(self): return Application([('/', MyHandler)...]) def test_homepage(self): # The following two lines are equivalent to # response = self.fetch('/') # but are shown in full here to demonstrate explicit use # of self.stop and self.wait. self.http_client.fetch(self.get_url('/'), self.stop) response = self.wait() # test contents of response ''' def setUp(self): super(AsyncHTTPTestCase, self).setUp() self.__port = None self.http_client = AsyncHTTPClient(io_loop=self.io_loop) self._app = self.get_app() self.http_server = HTTPServer(self._app, io_loop=self.io_loop, **self.get_httpserver_options()) self.http_server.listen(self.get_http_port(), address="127.0.0.1") def get_app(self): """Should be overridden by subclasses to return a anzu.web.Application or other HTTPServer callback. """ raise NotImplementedError() def fetch(self, path, **kwargs): """Convenience method to synchronously fetch a url. The given path will be appended to the local server's host and port. Any additional kwargs will be passed directly to AsyncHTTPClient.fetch (and so could be used to pass method="POST", body="...", etc). """ self.http_client.fetch(self.get_url(path), self.stop, **kwargs) return self.wait() def get_httpserver_options(self): """May be overridden by subclasses to return additional keyword arguments for HTTPServer. """ return {} def get_http_port(self): """Returns the port used by the HTTPServer. A new port is chosen for each test. """ if self.__port is None: self.__port = get_unused_port() return self.__port def get_url(self, path): """Returns an absolute url for the given path on the test server.""" return 'http://localhost:%s%s' % (self.get_http_port(), path) def tearDown(self): self.http_server.stop() self.http_client.close() super(AsyncHTTPTestCase, self).tearDown()
class AsyncHTTPTestCase(AsyncTestCase): """A test case that starts up an HTTP server. Subclasses must override get_app(), which returns the anzu.web.Application (or other HTTPServer callback) to be tested. Tests will typically use the provided self.http_client to fetch URLs from this server. Example:: class MyHTTPTest(AsyncHTTPTestCase): def get_app(self): return Application([('/', MyHandler)...]) def test_homepage(self): # The following two lines are equivalent to # response = self.fetch('/') # but are shown in full here to demonstrate explicit use # of self.stop and self.wait. self.http_client.fetch(self.get_url('/'), self.stop) response = self.wait() # test contents of response """ def setUp(self): super(AsyncHTTPTestCase, self).setUp() self.__port = None self.http_client = AsyncHTTPClient(io_loop=self.io_loop) self._app = self.get_app() self.http_server = HTTPServer(self._app, io_loop=self.io_loop, **self.get_httpserver_options()) self.http_server.listen(self.get_http_port(), address="127.0.0.1") def get_app(self): """Should be overridden by subclasses to return a anzu.web.Application or other HTTPServer callback. """ raise NotImplementedError() def fetch(self, path, **kwargs): """Convenience method to synchronously fetch a url. The given path will be appended to the local server's host and port. Any additional kwargs will be passed directly to AsyncHTTPClient.fetch (and so could be used to pass method="POST", body="...", etc). """ self.http_client.fetch(self.get_url(path), self.stop, **kwargs) return self.wait() def get_httpserver_options(self): """May be overridden by subclasses to return additional keyword arguments for HTTPServer. """ return {} def get_http_port(self): """Returns the port used by the HTTPServer. A new port is chosen for each test. """ if self.__port is None: self.__port = get_unused_port() return self.__port def get_url(self, path): """Returns an absolute url for the given path on the test server.""" return "http://localhost:%s%s" % (self.get_http_port(), path) def tearDown(self): self.http_server.stop() self.http_client.close() super(AsyncHTTPTestCase, self).tearDown()