Current File : //opt/alt/python27/lib/python2.7/site-packages/nose/plugins/plugintest.pyo
�
k�6Sc @ s` d Z d d l Z d d l Z d d l m Z y d d l m Z Wn! e k
re d d l m Z n Xd d g Z d d l m
Z
d e f d � � YZ y d d
l
m Z e Z Wn e k
r� e Z n Xd e f d � � YZ d e f d
� � YZ d � Z d � Z d � Z d � Z d � Z d � Z d � Z e d k r\d d l Z e j � n d S( sX
Testing Plugins
===============
The plugin interface is well-tested enough to safely unit test your
use of its hooks with some level of confidence. However, there is also
a mixin for unittest.TestCase called PluginTester that's designed to
test plugins in their native runtime environment.
Here's a simple example with a do-nothing plugin and a composed suite.
>>> import unittest
>>> from nose.plugins import Plugin, PluginTester
>>> class FooPlugin(Plugin):
... pass
>>> class TestPluginFoo(PluginTester, unittest.TestCase):
... activate = '--with-foo'
... plugins = [FooPlugin()]
... def test_foo(self):
... for line in self.output:
... # i.e. check for patterns
... pass
...
... # or check for a line containing ...
... assert "ValueError" in self.output
... def makeSuite(self):
... class TC(unittest.TestCase):
... def runTest(self):
... raise ValueError("I hate foo")
... return [TC('runTest')]
...
>>> res = unittest.TestResult()
>>> case = TestPluginFoo('test_foo')
>>> _ = case(res)
>>> res.errors
[]
>>> res.failures
[]
>>> res.wasSuccessful()
True
>>> res.testsRun
1
And here is a more complex example of testing a plugin that has extra
arguments and reads environment variables.
>>> import unittest, os
>>> from nose.plugins import Plugin, PluginTester
>>> class FancyOutputter(Plugin):
... name = "fancy"
... def configure(self, options, conf):
... Plugin.configure(self, options, conf)
... if not self.enabled:
... return
... self.fanciness = 1
... if options.more_fancy:
... self.fanciness = 2
... if 'EVEN_FANCIER' in self.env:
... self.fanciness = 3
...
... def options(self, parser, env=os.environ):
... self.env = env
... parser.add_option('--more-fancy', action='store_true')
... Plugin.options(self, parser, env=env)
...
... def report(self, stream):
... stream.write("FANCY " * self.fanciness)
...
>>> class TestFancyOutputter(PluginTester, unittest.TestCase):
... activate = '--with-fancy' # enables the plugin
... plugins = [FancyOutputter()]
... args = ['--more-fancy']
... env = {'EVEN_FANCIER': '1'}
...
... def test_fancy_output(self):
... assert "FANCY FANCY FANCY" in self.output, (
... "got: %s" % self.output)
... def makeSuite(self):
... class TC(unittest.TestCase):
... def runTest(self):
... raise ValueError("I hate fancy stuff")
... return [TC('runTest')]
...
>>> res = unittest.TestResult()
>>> case = TestFancyOutputter('test_fancy_output')
>>> _ = case(res)
>>> res.errors
[]
>>> res.failures
[]
>>> res.wasSuccessful()
True
>>> res.testsRun
1
i����N( t warn( t StringIOt PluginTestert run( t getpidt MultiProcessFilec B sP e Z d Z d � Z d � Z d � Z d � Z d d � Z d � Z d � Z RS( s\
helper for testing multiprocessing
multiprocessing poses a problem for doctests, since the strategy
of replacing sys.stdout/stderr with file-like objects then
inspecting the results won't work: the child processes will
write to the objects, but the data will not be reflected
in the parent doctest-ing process.
The solution is to create file-like objects which will interact with
multiprocessing in a more desirable way.
All processes can write to this object, but only the creator can read.
This allows the testing system to see a unified picture of I/O.
c C s7 t � | _ t � j � | _ t � | _ d | _ d S( Ni ( R t _MultiProcessFile__mastert Managert Queuet _MultiProcessFile__queueR t _MultiProcessFile__buffert softspace( t self( ( sH /opt/alt/python27/lib/python2.7/site-packages/nose/plugins/plugintest.pyt __init__~ s c C s� t � | j k r d Sd d l m } d d l m } | t � } x] t r� y | j j � \ } } Wn | k
rx Pn X| d k r� d } n | | c | 7<qE Wx( t
| � D] } | j j | | � q� Wd S( Ni����( t Empty( t defaultdictg}Ô%�I�T( ( g}Ô%�I�T(
R R R R t collectionsR t strt TrueR t
get_nowaitt sortedR
t write( R R R t cachet pidt data( ( sH /opt/alt/python27/lib/python2.7/site-packages/nose/plugins/plugintest.pyt buffer� s
c C s6 d d l m } | � j } | j j | | f � d S( Ni����( t current_process( t multiprocessingR t _identityR t put( R R R R ( ( sH /opt/alt/python27/lib/python2.7/site-packages/nose/plugins/plugintest.pyR � s c C s | j � | j S( s getattr doesn't work for iter()( R R
( R ( ( sH /opt/alt/python27/lib/python2.7/site-packages/nose/plugins/plugintest.pyt __iter__� s
i c C s | j � | j j | | � S( N( R R
t seek( R t offsett whence( ( sH /opt/alt/python27/lib/python2.7/site-packages/nose/plugins/plugintest.pyR � s
c C s | j � | j j � S( N( R R
t getvalue( R ( ( sH /opt/alt/python27/lib/python2.7/site-packages/nose/plugins/plugintest.pyR" � s
c C s t | j | � S( N( t getattrR
( R t attr( ( sH /opt/alt/python27/lib/python2.7/site-packages/nose/plugins/plugintest.pyt __getattr__� s (
t __name__t
__module__t __doc__R
R R R R R" R% ( ( ( sH /opt/alt/python27/lib/python2.7/site-packages/nose/plugins/plugintest.pyR n s ( R c B sS e Z d Z d Z d Z d Z i Z d Z g Z d Z
d � Z d � Z d � Z
RS( s% A mixin for testing nose plugins in their runtime environment.
Subclass this and mix in unittest.TestCase to run integration/functional
tests on your plugin. When setUp() is called, the stub test suite is
executed with your plugin so that during an actual test you can inspect the
artifacts of how your plugin interacted with the stub test suite.
- activate
- the argument to send nosetests to activate the plugin
- suitepath
- if set, this is the path of the suite to test. Otherwise, you
will need to use the hook, makeSuite()
- plugins
- the list of plugins to make available during the run. Note
that this does not mean these plugins will be *enabled* during
the run -- only the plugins enabled by the activate argument
or other settings in argv or env will be enabled.
- args
- a list of arguments to add to the nosetests command, in addition to
the activate argument
- env
- optional dict of environment variables to send nosetests
c C s
t � d S( s� returns a suite object of tests to run (unittest.TestSuite())
If self.suitepath is None, this must be implemented. The returned suite
object will be executed with all plugins activated. It may return
None.
Here is an example of a basic suite object you can return ::
>>> import unittest
>>> class SomeTest(unittest.TestCase):
... def runTest(self):
... raise ValueError("Now do something, plugin!")
...
>>> unittest.TestSuite([SomeTest()]) # doctest: +ELLIPSIS
<unittest...TestSuite tests=[<...SomeTest testMethod=runTest>]>
N( t NotImplementedError( R ( ( sH /opt/alt/python27/lib/python2.7/site-packages/nose/plugins/plugintest.pyt makeSuite� s c C s� d d l m } d d l m } d d l m } d } t � } | d | j d | d | d | j � � } | j
d k r� | j
| _
n | j s� | j � } n | d | j
d | d
| d t � | _ t | � | _ d S(
s7 execute the plugin on the internal test suite.
i����( t Config( t TestProgram( t
PluginManagert envt streamt pluginst argvt configt suitet exitN( t nose.configR+ t nose.coreR, t nose.plugins.managerR- t Nonet BufferR. R0 t ignoreFilest suitepathR* R1 t Falset noset AccessDecoratort output( R R+ R, R- R3 R/ t conf( ( sH /opt/alt/python27/lib/python2.7/site-packages/nose/plugins/plugintest.pyt _execPlugin� s c C s^ d | j g | _ | j r1 | j j | j � n | j rP | j j | j � n | j � d S( sU runs nosetests with the specified test suite, all plugins
activated.
t nosetestsN( t activateR1 t argst extendR; t appendRA ( R ( ( sH /opt/alt/python27/lib/python2.7/site-packages/nose/plugins/plugintest.pyt setUp s N( R& R' R( R8 RC R; RD R. R1 R0 R: R* RA RG ( ( ( sH /opt/alt/python27/lib/python2.7/site-packages/nose/plugins/plugintest.pyR � s ! R> c B s8 e Z d Z d Z d � Z d � Z d � Z d � Z RS( c C s6 | | _ | j d � | j � | _ | j d � d S( Ni ( R/ R t readt _buf( R R/ ( ( sH /opt/alt/python27/lib/python2.7/site-packages/nose/plugins/plugintest.pyR
s
c C s
| | j k S( N( RI ( R t val( ( sH /opt/alt/python27/lib/python2.7/site-packages/nose/plugins/plugintest.pyt __contains__ s c C s
t | j � S( N( t iterR/ ( R ( ( sH /opt/alt/python27/lib/python2.7/site-packages/nose/plugins/plugintest.pyR s c C s | j S( N( RI ( R ( ( sH /opt/alt/python27/lib/python2.7/site-packages/nose/plugins/plugintest.pyt __str__ s N( R& R' R8 R/ RI R
RK R RM ( ( ( sH /opt/alt/python27/lib/python2.7/site-packages/nose/plugins/plugintest.pyR> s c c s� g } xm | j t � D]\ } | j | � | j � } | s[ | j d � r | j d � r d j | � Vg } q q W| r� d j | � Vn d S( s9 a bunch of === characters is also considered a blank lines ===t =t N( t
splitlinesR RF t stript
startswitht join( t textt blockt line( ( sH /opt/alt/python27/lib/python2.7/site-packages/nose/plugins/plugintest.pyt blankline_separated_blocks# s
&
c C sf t j d t j t j Bt j B� } g } x- t | � D] } | j | j d | � � q6 Wd j | � S( NsD
# Grab the traceback header. Different versions of Python have
# said different things on the first traceback line.
^(?P<hdr> Traceback\ \(
(?: most\ recent\ call\ last
| innermost\ last
) \) :
)
\s* $ # toss trailing whitespace on the header.
(?P<stack> .*?) # don't blink: absorb stuff until...
^(?=\w) # a line *starts* with alphanum.
.*?(?P<exception> \w+ ) # exception name
(?P<msg> [:\n] .*) # the rest
s" \g<hdr>\n...\n\g<exception>\g<msg>RO ( t ret compilet VERBOSEt MULTILINEt DOTALLRW RF t subRS ( t outt traceback_ret blocksRU ( ( sH /opt/alt/python27/lib/python2.7/site-packages/nose/plugins/plugintest.pyt remove_stack_traces0 s
c C s, t j d t j t j B� } | j d | � S( Ns�
# Cut the file and line no, up to the warning name
^.*:\d+:\s
(?P<category>\w+): \s+ # warning category
(?P<detail>.+) $ \n? # warning message
^ .* $ # stack frame
s \g<category>: \g<detail>( RX RY RZ R[ R] ( R^ t warn_re( ( sH /opt/alt/python27/lib/python2.7/site-packages/nose/plugins/plugintest.pyt simplify_warningsF s c C s t j d d | � S( Ns Ran (\d+ tests?) in [0-9.]+ss Ran \1 in ...s( RX R] ( R^ ( ( sH /opt/alt/python27/lib/python2.7/site-packages/nose/plugins/plugintest.pyt remove_timingsQ s c C s. t | � } t | � } t | � } | j � S( s6 Modify nose output to make it easy to use in doctests.( Ra Rc Rd RQ ( R^ ( ( sH /opt/alt/python27/lib/python2.7/site-packages/nose/plugins/plugintest.pyt munge_nose_output_for_doctestV s c O ss d d l m } d d l m } d d l m } t � } d | k r� | j d g � } t | t � rx | d | � } n | j d i � } | d | d | � | d <n d | k r� d d
g | d <n | | d _
t j } t j
} | j d t � r| t _
t _ t }
n t }
t d t d
d �z | | | � Wd |
rW| t _ | t _
n X| j � } t | � GHd S( s�
Specialized version of nose.run for use inside of doctests that
test test runs.
This version of run() prints the result output to stdout. Before
printing, the output is processed by replacing the timing
information with an ellipsis (...), removing traceback stacks, and
removing trailing whitespace.
Use this version of run wherever you are writing a doctest that
tests nose (or unittest) test result output.
Note: do not use doctest: +ELLIPSIS when testing nose output,
since ellipses ("test_foo ... ok") in your expected test runner
output may match multiple lines of output, causing spurious test
passes!
i����( R ( R+ ( R- R2 R0 R. R1 RB s -vt
buffer_alls The behavior of nose.plugins.plugintest.run() will change in the next release of nose. The current behavior does not correctly account for output to stdout and stderr. To enable correct behavior, use run_buffered() instead, or pass the keyword argument buffer_all=True to run().t
stackleveli N( R= R R5 R+ R7 R- R9 t popt
isinstancet listR/ t syst stderrt stdoutR< R R t DeprecationWarningR" Re ( t argt kwR R+ R- R R0 R. Rl Rm t restoreR^ ( ( sH /opt/alt/python27/lib/python2.7/site-packages/nose/plugins/plugintest.pyR ^ s8
c O s t | d <t | | � d S( NRf ( R R ( Ro Rp ( ( sH /opt/alt/python27/lib/python2.7/site-packages/nose/plugins/plugintest.pyt run_buffered� s
t __main__( R( RX Rk t warningsR t cStringIOR t ImportErrort __all__t osR t objectR R R R9 R R> RW Ra Rc Rd Re R Rr R& t doctestt testmod( ( ( sH /opt/alt/python27/lib/python2.7/site-packages/nose/plugins/plugintest.pyt <module>` s6
?
`
<
Mini Shell