Current File : //lib64/python2.7/site-packages/tornado/testing.pyc
�
��L]c @� s� d Z d d l m Z m Z m Z m Z yz d d l m Z d d l m Z d d l
m Z d d l m
Z
d d l m Z m Z d d l m Z d d l m Z Wn; e k
r� d
Z d
Z d
Z d
Z d
Z d
Z
d
Z n Xd d
l m Z m Z d d l m Z d d l m Z m Z d d
l Z d d
l Z d d
l Z d d
l! Z! d d
l" Z" d d
l# Z# d d
l$ Z$ d d
l% Z% y d d l& m' Z' Wn! e k
r�d d l( m' Z' n Xe$ j) d# k r�d d
l* Z* n0 y d d
l+ Z* Wn e k
rd d
l* Z* n Xd a, d � Z- d � Z. d � Z/ d e0 f d � � YZ1 d e* j2 f d � � YZ3 d e3 f d � � YZ4 d e4 f d � � YZ5 d
d
d � Z6 e7 e6 _8 d e* j2 f d � � YZ9 d e j: f d � � YZ; d! � Z< e= d" k r�e< � n d
S($ s� Support classes for automated testing.
* `AsyncTestCase` and `AsyncHTTPTestCase`: Subclasses of unittest.TestCase
with additional support for testing asynchronous (`.IOLoop` based) code.
* `ExpectLog` and `LogTrapTestCase`: Make test logs less spammy.
* `main()`: A simple test runner (wrapper around unittest.main()) with support
for the tornado.autoreload module to rerun the tests when code changes.
i ( t absolute_importt divisiont print_functiont with_statement( t gen( t AsyncHTTPClient( t
HTTPServer( t SimpleAsyncHTTPClient( t IOLoopt TimeoutError( t netutil( t
Subprocess( t gen_logt app_log( t ExceptionStackContext( t raise_exc_infot basestring_typeN( t StringIOi i' c C� s t } t d a | S( s@ Returns a (hopefully) unused port number.
This function does not guarantee that the port it returns is available,
only that a series of get_unused_port calls in a single process return
distinct ports.
.. deprecated::
Use bind_unused_port instead, which is guaranteed to find an unused port.
i ( t
_next_port( t port( ( s5 /usr/lib64/python2.7/site-packages/tornado/testing.pyt get_unused_portC s
c C� s8 t j d d d t j �\ } | j � d } | | f S( sb Binds a server socket to an available port on localhost.
Returns a tuple (socket, port).
t localhostt familyi N( R
t bind_socketst Nonet sockett AF_INETt getsockname( t sockR ( ( s5 /usr/lib64/python2.7/site-packages/tornado/testing.pyt bind_unused_portS s c C� s9 y t t j j d � � SWn t t f k
r4 d SXd S( s} Get the global timeout setting for async tests.
Returns a float, the timeout in seconds.
.. versionadded:: 3.1
t ASYNC_TEST_TIMEOUTi N( t floatt ost environt gett
ValueErrort TypeError( ( ( s5 /usr/lib64/python2.7/site-packages/tornado/testing.pyt get_async_test_timeout] s t _TestMethodWrapperc B� s) e Z d Z d � Z d � Z d � Z RS( s} Wraps a test method to raise an error if it returns a value.
This is mainly used to detect undecorated generators (if a test
method yields it must use a decorator to consume the generator),
but will also detect other kinds of return values (these are not
necessarily errors, but we alert anyway since there is no good
reason to return a value from a test.
c C� s
| | _ d S( N( t orig_method( t selfR' ( ( s5 /usr/lib64/python2.7/site-packages/tornado/testing.pyt __init__s s c O� sV | j | | � } t | t j � r3 t d � � n | d k rR t d | � � n d S( NsH Generator test methods should be decorated with tornado.testing.gen_tests) Return value from test method ignored: %r( R' t
isinstancet typest
GeneratorTypeR$ R R# ( R( t argst kwargst result( ( s5 /usr/lib64/python2.7/site-packages/tornado/testing.pyt __call__v s c C� s t | j | � S( s� Proxy all unknown attributes to the original method.
This is important for some of the decorators in the `unittest`
module, such as `unittest.skipIf`.
( t getattrR' ( R( t name( ( s5 /usr/lib64/python2.7/site-packages/tornado/testing.pyt __getattr__ s ( t __name__t
__module__t __doc__R) R0 R3 ( ( ( s5 /usr/lib64/python2.7/site-packages/tornado/testing.pyR& j s t
AsyncTestCasec B� sn e Z d Z d d � Z d � Z d � Z d � Z d � Z d � Z d d � Z
d d � Z d d d
� Z RS( sk `~unittest.TestCase` subclass for testing `.IOLoop`-based
asynchronous code.
The unittest framework is synchronous, so the test must be
complete by the time the test method returns. This means that
asynchronous code cannot be used in quite the same way as usual.
To write test functions that use the same ``yield``-based patterns
used with the `tornado.gen` module, decorate your test methods
with `tornado.testing.gen_test` instead of
`tornado.gen.coroutine`. This class also provides the `stop()`
and `wait()` methods for a more manual style of testing. The test
method itself must call ``self.wait()``, and asynchronous
callbacks should call ``self.stop()`` to signal completion.
By default, a new `.IOLoop` is constructed for each test and is available
as ``self.io_loop``. This `.IOLoop` should be used in the construction of
HTTP clients/servers, etc. If the code being tested requires a
global `.IOLoop`, subclasses should override `get_new_ioloop` to return it.
The `.IOLoop`'s ``start`` and ``stop`` methods should not be
called directly. Instead, use `self.stop <stop>` and `self.wait
<wait>`. Arguments passed to ``self.stop`` are returned from
``self.wait``. It is possible to have multiple ``wait``/``stop``
cycles in the same test.
Example::
# This test uses coroutine style.
class MyTestCase(AsyncTestCase):
@tornado.testing.gen_test
def test_http_fetch(self):
client = AsyncHTTPClient(self.io_loop)
response = yield client.fetch("http://www.tornadoweb.org")
# Test contents of response
self.assertIn("FriendFeed", response.body)
# This test uses argument passing between self.stop and self.wait.
class MyTestCase2(AsyncTestCase):
def test_http_fetch(self):
client = AsyncHTTPClient(self.io_loop)
client.fetch("http://www.tornadoweb.org/", self.stop)
response = self.wait()
# Test contents of response
self.assertIn("FriendFeed", response.body)
# This test uses an explicit callback-based style.
class MyTestCase3(AsyncTestCase):
def test_http_fetch(self):
client = AsyncHTTPClient(self.io_loop)
client.fetch("http://www.tornadoweb.org/", self.handle_fetch)
self.wait()
def handle_fetch(self, response):
# Test contents of response (failures and exceptions here
# will cause self.wait() to throw an exception and end the
# test).
# Exceptions thrown here are magically propagated to
# self.wait() in test_http_fetch() via stack_context.
self.assertIn("FriendFeed", response.body)
self.stop()
t runTestc K� si t t | � j | | � t | _ t | _ d | _ d | _ d | _ t
| | t t | | � � � d S( N(
t superR7 R) t Falset _AsyncTestCase__stoppedt _AsyncTestCase__runningR t _AsyncTestCase__failuret _AsyncTestCase__stop_argst _AsyncTestCase__timeoutt setattrR& R1 ( R( t
methodNameR. ( ( s5 /usr/lib64/python2.7/site-packages/tornado/testing.pyR) � s c C� s3 t t | � j � | j � | _ | j j � d S( N( R9 R7 t setUpt get_new_ioloopt io_loopt make_current( R( ( ( s5 /usr/lib64/python2.7/site-packages/tornado/testing.pyRB � s c C� sp t j � | j j � t j � s9 | j t j � k rO | j j d t � n t t
| � j � | j � d S( Nt all_fds(
R t uninitializeRD t
clear_currentR t initializedt instancet closet TrueR9 R7 t tearDownt _AsyncTestCase__rethrow( R( ( ( s5 /usr/lib64/python2.7/site-packages/tornado/testing.pyRM � s
c C� s t � S( s� Creates a new `.IOLoop` for this test. May be overridden in
subclasses for tests that require a specific `.IOLoop` (usually
the singleton `.IOLoop.instance()`).
( R ( R( ( ( s5 /usr/lib64/python2.7/site-packages/tornado/testing.pyRC � s c C� sN | j d k r$ | | | f | _ n t j d d | | | f �| j � t S( Ns% multiple unhandled exceptions in testt exc_info( R= R R
t errort stopRL ( R( t typt valuet tb( ( s5 /usr/lib64/python2.7/site-packages/tornado/testing.pyt _handle_exception� s
c C� s2 | j d k r. | j } d | _ t | � n d S( N( R= R R ( R( t failure( ( s5 /usr/lib64/python2.7/site-packages/tornado/testing.pyt __rethrow� s c C� s: t | j � � t t | � j | � Wd QX| j � d S( N( R RU R9 R7 t runRN ( R( R/ ( ( s5 /usr/lib64/python2.7/site-packages/tornado/testing.pyRX s c K� sW | d k s | s t � | p" | | _ | j rJ | j j � t | _ n t | _ d S( s� Stops the `.IOLoop`, causing one pending (or future) call to `wait()`
to return.
Keyword arguments or a single positional argument passed to `stop()` are
saved and will be returned by `wait()`.
N( R t AssertionErrorR> R< RD RQ R: RL R; ( R( t _argR. ( ( s5 /usr/lib64/python2.7/site-packages/tornado/testing.pyRQ
s
c � s � d k r t � � n � j s� � ra � � f d � } � j j � j j � � | � � _ n xH t r� t � _ � j j � � j
d k s� | d k s� | � rd Pqd qd W� j d k r� � j j � j � d � _ q� n � j s� t � t
� _ � j � � j } d � _ | S( s" Runs the `.IOLoop` until stop is called or timeout has passed.
In the event of a timeout, an exception will be thrown. The
default timeout is 5 seconds; it may be overridden with a
``timeout`` keyword argument or globally with the
``ASYNC_TEST_TIMEOUT`` environment variable.
If ``condition`` is not None, the `.IOLoop` will be restarted
after `stop()` until ``condition()`` returns true.
.. versionchanged:: 3.1
Added the ``ASYNC_TEST_TIMEOUT`` environment variable.
c � sH y � j d � � � Wn t k
r9 t j � � _ n X� j � d S( Ns* Async operation timed out after %s seconds( t failureExceptiont Exceptiont sysRO R= RQ ( ( R( t timeout( s5 /usr/lib64/python2.7/site-packages/tornado/testing.pyt timeout_func+ s
N( R R% R; RD t add_timeoutt timeR? RL R< t startR= t remove_timeoutRY R: RN R> ( R( t conditionR^ R_ R/ ( ( R( R^ s5 /usr/lib64/python2.7/site-packages/tornado/testing.pyt wait s* (
N(
R4 R5 R6 R) RB RM RC RU RN R RX RQ Re ( ( ( s5 /usr/lib64/python2.7/site-packages/tornado/testing.pyR7 � s = t AsyncHTTPTestCasec B� sh e Z d Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z
d � Z d
� Z RS( sS A test case that starts up an HTTP server.
Subclasses must override `get_app()`, which returns the
`tornado.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
c C� so t t | � j � t � \ } } | | _ | j � | _ | j � | _ | j � | _
| j
j | g � d S( N( R9 Rf RB R t _AsyncHTTPTestCase__portt get_http_clientt http_clientt get_appt _appt get_http_servert http_servert add_sockets( R( R R ( ( s5 /usr/lib64/python2.7/site-packages/tornado/testing.pyRB \ s c C� s t d | j � S( NRD ( R RD ( R( ( ( s5 /usr/lib64/python2.7/site-packages/tornado/testing.pyRh f s c C� s t | j d | j | j � �S( NRD ( R Rk RD t get_httpserver_options( R( ( ( s5 /usr/lib64/python2.7/site-packages/tornado/testing.pyRl i s c C� s
t � � d S( sz Should be overridden by subclasses to return a
`tornado.web.Application` or other `.HTTPServer` callback.
N( t NotImplementedError( R( ( ( s5 /usr/lib64/python2.7/site-packages/tornado/testing.pyRj m s c K� s, | j j | j | � | j | � | j � S( s1 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).
( Ri t fetcht get_urlRQ Re ( R( t pathR. ( ( s5 /usr/lib64/python2.7/site-packages/tornado/testing.pyRq s s "c C� s i S( sg May be overridden by subclasses to return additional
keyword arguments for the server.
( ( R( ( ( s5 /usr/lib64/python2.7/site-packages/tornado/testing.pyRo ~ s c C� s | j S( sZ Returns the port used by the server.
A new port is chosen for each test.
( Rg ( R( ( ( s5 /usr/lib64/python2.7/site-packages/tornado/testing.pyt
get_http_port� s c C� s d S( Nt http( ( R( ( ( s5 /usr/lib64/python2.7/site-packages/tornado/testing.pyt get_protocol� s c C� s d | j � | j � | f S( s> Returns an absolute url for the given path on the test server.s %s://localhost:%s%s( Rv Rt ( R( Rs ( ( s5 /usr/lib64/python2.7/site-packages/tornado/testing.pyRr � s c C� sx | j j � | j j | j j d t � �t j � sQ | j j t j � k ra | j j
� n t t | � j
� d S( NR^ ( Rm RQ RD t run_synct close_all_connectionsR% R RI Ri RJ RK R9 Rf RM ( R( ( ( s5 /usr/lib64/python2.7/site-packages/tornado/testing.pyRM � s
(
R4 R5 R6 RB Rh Rl Rj Rq Ro Rt Rv Rr RM ( ( ( s5 /usr/lib64/python2.7/site-packages/tornado/testing.pyRf E s
t AsyncHTTPSTestCasec B� s2 e Z d Z d � Z d � Z d � Z d � Z RS( sj A test case that starts an HTTPS server.
Interface is generally the same as `AsyncHTTPTestCase`.
c C� s% t d | j d t d t d t � � S( NRD t force_instancet defaultst
validate_cert( R RD RL t dictR: ( R( ( ( s5 /usr/lib64/python2.7/site-packages/tornado/testing.pyRh � s c C� s t d | j � � S( Nt ssl_options( R} t get_ssl_options( R( ( ( s5 /usr/lib64/python2.7/site-packages/tornado/testing.pyRo � s c C� sI t j j t � } t d t j j | d d � d t j j | d d � � S( s May be overridden by subclasses to select SSL options.
By default includes a self-signed testing certificate.
t certfilet tests test.crtt keyfiles test.key( R Rs t dirnamet __file__R} t join( R( t
module_dir( ( s5 /usr/lib64/python2.7/site-packages/tornado/testing.pyR � s c C� s d S( Nt https( ( R( ( ( s5 /usr/lib64/python2.7/site-packages/tornado/testing.pyRv � s ( R4 R5 R6 Rh Ro R Rv ( ( ( s5 /usr/lib64/python2.7/site-packages/tornado/testing.pyRy � s
c � sE � d k r t � � n � f d � } | d k r= | | � S| Sd S( s> Testing equivalent of ``@gen.coroutine``, to be applied to test methods.
``@gen.coroutine`` cannot be used on tests because the `.IOLoop` is not
already running. ``@gen_test`` should be applied to test methods
on subclasses of `AsyncTestCase`.
Example::
class MyTest(AsyncHTTPTestCase):
@gen_test
def test_something(self):
response = yield gen.Task(self.fetch('/'))
By default, ``@gen_test`` times out after 5 seconds. The timeout may be
overridden globally with the ``ASYNC_TEST_TIMEOUT`` environment variable,
or for each test with the ``timeout`` keyword argument::
class MyTest(AsyncHTTPTestCase):
@gen_test(timeout=10)
def test_something_slow(self):
response = yield gen.Task(self.fetch('/'))
.. versionadded:: 3.1
The ``timeout`` argument and ``ASYNC_TEST_TIMEOUT`` environment
variable.
.. versionchanged:: 4.0
The wrapper now passes along ``*args, **kwargs`` so it can be used
on functions with arguments.
c � sR t j � � � f d � � } t j | � � t j � � � � f d � � } | S( Nc � s= � | | | � } t | t j � r0 | | _ n d | _ | S( N( R* R+ R, t _test_generatorR ( R( R- R. R/ ( t f( s5 /usr/lib64/python2.7/site-packages/tornado/testing.pyt
pre_coroutine� s
c � sY y, | j j t j � | | | � d � �SWn& t k
rT } | j j | � � n Xd S( NR^ ( RD Rw t functoolst partialR R� t throw( R( R- R. t e( t coroR^ ( s5 /usr/lib64/python2.7/site-packages/tornado/testing.pyt post_coroutine� s ( R� t wrapsR t coroutine( R� R� R� ( R^ ( R� R� s5 /usr/lib64/python2.7/site-packages/tornado/testing.pyt wrap� s !N( R R% ( t funcR^ R� ( ( R^ s5 /usr/lib64/python2.7/site-packages/tornado/testing.pyt gen_test� s %
t LogTrapTestCasec B� s e Z d Z d d � Z RS( sQ A test case that captures and discards all logging output
if the test passes.
Some libraries can produce a lot of logging output even when
the test succeeds, so this class can be useful to minimize the noise.
Simply use it as a base class for your test case. It is safe to combine
with AsyncTestCase via multiple inheritance
(``class MyTestCase(AsyncHTTPTestCase, LogTrapTestCase):``)
This class assumes that only one log handler is configured and
that it is a `~logging.StreamHandler`. This is true for both
`logging.basicConfig` and the "pretty logging" configured by
`tornado.options`. It is not compatible with other log buffering
mechanisms, such as those provided by some test runners.
.. deprecated:: 4.1
Use the unittest module's ``--buffer`` option instead, or `.ExpectLog`.
c C� s% t j � } | j s" t j � n | j d } t | j � d k sW t | t j � rq t t | � j | � d S| j
} z� t � | _
t j
d t | � � t | j � t | j � } t t | � j | � t | j � t | j � } | | k r| j | j
j � � n Wd | | _
Xd S( Ni i s RUNNING TEST: ( t loggingt getLoggert handlerst basicConfigt lenR* t
StreamHandlerR9 R� RX t streamR R t infot strt failurest errorst writet getvalue( R( R/ t loggert handlert
old_streamt old_error_countt new_error_count( ( s5 /usr/lib64/python2.7/site-packages/tornado/testing.pyRX # s$
N( R4 R5 R6 R RX ( ( ( s5 /usr/lib64/python2.7/site-packages/tornado/testing.pyR� s t ExpectLogc B� s5 e Z d Z e d � Z d � Z d � Z d � Z RS( sP Context manager to capture and suppress expected log output.
Useful to make tests of error conditions less noisy, while still
leaving unexpected log entries visible. *Not thread safe.*
Usage::
with ExpectLog('tornado.application', "Uncaught exception"):
error_response = self.fetch("/some_page")
c C� sR t | t � r! t j | � } n | | _ t j | � | _ | | _ t | _
d S( s� Constructs an ExpectLog context manager.
:param logger: Logger object (or name of logger) to watch. Pass
an empty string to watch the root logger.
:param regex: Regular expression to match. Any log entries on
the specified logger that match this regex will be suppressed.
:param required: If true, an exeption will be raised if the end of
the ``with`` statement is reached without matching any log entries.
N( R* R R� R� R� t ret compilet regext requiredR: t matched( R( R� R� R� ( ( s5 /usr/lib64/python2.7/site-packages/tornado/testing.pyR) F s
c C� s/ | j � } | j j | � r+ t | _ t St S( N( t
getMessageR� t matchRL R� R: ( R( t recordt message( ( s5 /usr/lib64/python2.7/site-packages/tornado/testing.pyt filterW s
c C� s | j j | � d S( N( R� t addFilter( R( ( ( s5 /usr/lib64/python2.7/site-packages/tornado/testing.pyt __enter__^ s c C� s= | j j | � | r9 | j r9 | j r9 t d � � n d S( Ns did not get expected log message( R� t removeFilterR� R� R\ ( R( RR RS RT ( ( s5 /usr/lib64/python2.7/site-packages/tornado/testing.pyt __exit__a s ( R4 R5 R6 RL R) R� R� R� ( ( ( s5 /usr/lib64/python2.7/site-packages/tornado/testing.pyR� ; s
c K� s( d d l m } m } m } | d d t d t d d �| d d t �| d d t �| d
d t �| d d t �| d d t �t j d g | t j � } | j s� t j t j
t j � n | j d k r� d
| d <n | j d k r� d | d <n | j d k rt | d
<n | j d k r7t | d <n | j d k rSt | d <n t d k r�t | � d k r�t d d t j �t j d � n yK t | � d k r�t j d d d | | � n t j d d d | | � WnB t k
r#} | j d k rt j d � n
t j d � � n Xd S( s� 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 tornado.testing tornado.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
``tornado/test/runtests.py``. This script should define a method
``all()`` which returns a test suite and then call
`tornado.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
python -m tornado.test.runtests
# Runs one test
python -m tornado.test.runtests tornado.test.stack_context_test
Additional keyword arguments passed through to ``unittest.main()``.
For example, use ``tornado.testing.main(verbosity=2)``
to show many test details as they are run.
See http://docs.python.org/library/unittest.html#unittest.main
for full argument list.
i ( t definet optionst parse_command_linet exception_on_interruptt typet defaultt helps� If true (default), ctrl-c raises a KeyboardInterrupt exception. This prints a stack trace but cannot interrupt certain operations. If false, the process is more reliably killed, but does not print a stack trace.t verboset quiett failfastt catcht bufferi t verbosityt
catchbreakt __main__i s No tests specifiedt filet modulet argvt defaultTestt allt PASSt FAILN( t tornado.optionsR� R� R� t boolRL R] R� R� t signalt SIGINTt SIG_DFLR� R R� R� R� R� R4 R� t printt stderrt exitt unittestt maint
SystemExitt codeR R� RP ( R. R� R� R� R� R� ( ( s5 /usr/lib64/python2.7/site-packages/tornado/testing.pyR� g sB
R� ( i (> R6 t
__future__R R R R t tornadoR t tornado.httpclientR t tornado.httpserverR t tornado.simple_httpclientR t tornado.ioloopR R R
t tornado.processR t ImportErrorR t tornado.logR R
t tornado.stack_contextR t tornado.utilR R R� R� R R� R� R R] R+ t cStringIOR t iot version_infoR� t unittest2R R R R% t objectR& t TestCaseR7 Rf Ry R� R: t __test__R� t FilterR� R� R4 ( ( ( s5 /usr/lib64/python2.7/site-packages/tornado/testing.pyt <module>
sj "
�X T +, T
Mini Shell