File: //opt/alt/python27/lib/python2.7/site-packages/mockito/mockito.pyc
�
f��Zc @ sk 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 d d l m Z d e
f d � � YZ d � Z d
� Z
d � Z d d d d d � Z e d
� Z d � Z d d d d e d � Z d e f d � � YZ e � Z d d � Z d � Z d d � Z d d d d d d � Z d � Z d � Z d � Z d � Z d � Z! d � Z" d S( i ( t
invocation( t verification( t get_objt get_obj_attr_tuple( t Mock( t
mock_registry( t VerificationErrort
ArgumentErrorc B s e Z RS( ( t __name__t
__module__( ( ( s@ /opt/alt/python27/lib/python2.7/site-packages/mockito/mockito.pyR s c G s t t d � | � � d k S( Nc S s | S( N( ( t x( ( s@ /opt/alt/python27/lib/python2.7/site-packages/mockito/mockito.pyt <lambda># t i ( t lent filter( t args( ( s@ /opt/alt/python27/lib/python2.7/site-packages/mockito/mockito.pyt _multiple_arguments_in_use" s c C s" | d k r | d k p! | d k S( Ni i ( t None( t value( ( s@ /opt/alt/python27/lib/python2.7/site-packages/mockito/mockito.pyt _invalid_argument& s c C s; | d k r7 | \ } } | | k s0 | d k r7 t Sn t S( Ni ( R t Truet False( t betweent startt end( ( s@ /opt/alt/python27/lib/python2.7/site-packages/mockito/mockito.pyt _invalid_between* s
c C s� | d k r+ | d k r+ t d | � � n t | | | � rL t d � � n t | � rk t d | � � n t | � r� t d | � � n t | � r� t d | � � n | r� t j | � S| r� t j | � S| r� t j | � S| d k r� t j | � Sd S( Ni sX 'times' argument has invalid value.
It should be at least 0. You wanted to set it to: %isH You can set only one of the arguments: 'atleast', 'atmost' or 'between'.s[ 'atleast' argument has invalid value.
It should be at least 1. You wanted to set it to: %isZ 'atmost' argument has invalid value.
It should be at least 1. You wanted to set it to: %is� 'between' argument has invalid value.
It should consist of positive values with second number not greater
than first e.g. [1, 4] or [0, 3] or [2, 2]
You wanted to set it to: %s(
R R R R R R t AtLeastt AtMostt Betweent Times( t timest atleastt atmostR ( ( s@ /opt/alt/python27/lib/python2.7/site-packages/mockito/mockito.pyt _get_wanted_verification1 s.
c C sJ t j | � } | d k rF t | d | d | �} t j | | � n | S( Nt strictt spec( R t mock_forR R t register( t objR" t theMock( ( s@ /opt/alt/python27/lib/python2.7/site-packages/mockito/mockito.pyt _get_mockR s
c C s2 t j | � } | d k r. t d | � � n | S( Ns obj '%s' is not registered( R R$ R R ( R& R' ( ( s@ /opt/alt/python27/lib/python2.7/site-packages/mockito/mockito.pyt _get_mock_or_raiseY s c s� t | t � r t | � } n t d | d | d | d | � � | rW t j � � � n t | � � d t f � � f d � � Y} | � S( s� Central interface to verify interactions.
`verify` uses a fluent interface::
verify(<obj>, times=2).<method_name>(<args>)
`args` can be as concrete as necessary. Often a catch-all is enough,
especially if you're working with strict mocks, bc they throw at call
time on unwanted, unconfigured arguments::
from mockito import ANY, ARGS, KWARGS
when(manager).add_tasks(1, 2, 3)
...
# no need to duplicate the specification; every other argument pattern
# would have raised anyway.
verify(manager).add_tasks(1, 2, 3) # duplicates `when`call
verify(manager).add_tasks(*ARGS)
verify(manager).add_tasks(...) # Py3
verify(manager).add_tasks(Ellipsis) # Py2
R R R R t Verifyc s e Z � � f d � Z RS( c s t j � | � � S( N( R t VerifiableInvocation( t selft method_name( R' t verification_fn( s@ /opt/alt/python27/lib/python2.7/site-packages/mockito/mockito.pyt __getattr__� s ( R R R/ ( ( R' R. ( s@ /opt/alt/python27/lib/python2.7/site-packages/mockito/mockito.pyR* � s ( t
isinstancet strR R! R t InOrderR) t object( R& R R R R t inorderR* ( ( R' R. s@ /opt/alt/python27/lib/python2.7/site-packages/mockito/mockito.pyt verify_ s t _OMITTEDc B s e Z d � Z RS( c C s d S( Nt OMITTED( ( R, ( ( s@ /opt/alt/python27/lib/python2.7/site-packages/mockito/mockito.pyt __repr__� s ( R R R8 ( ( ( s@ /opt/alt/python27/lib/python2.7/site-packages/mockito/mockito.pyR6 � s c sk t | t � r t | � } n � d k r3 t � n t | d � �� d t f � � f d � � Y} | � S( s� Central interface to stub functions on a given `obj`
`obj` should be a module, a class or an instance of a class; it can be
a Dummy you created with :func:`mock`. ``when`` exposes a fluent interface
where you configure a stub in three steps::
when(<obj>).<method_name>(<args>).thenReturn(<value>)
Compared to simple *patching*, stubbing in mockito requires you to specify
conrete `args` for which the stub will answer with a concrete `<value>`.
All invocations that do not match this specific call signature will be
rejected. They usually throw at call time.
Stubbing in mockito's sense thus means not only to get rid of unwanted
side effects, but effectively to turn function calls into constants.
E.g.::
# Given ``dog`` is an instance of a ``Dog``
when(dog).bark('Grrr').thenReturn('Wuff')
when(dog).bark('Miau').thenRaise(TypeError())
# With this configuration set up:
assert dog.bark('Grrr') == 'Wuff'
dog.bark('Miau') # will throw TypeError
dog.bark('Wuff') # will throw unwanted interaction
Stubbing can effectively be used as monkeypatching; usage shown with
the `with` context managing::
with when(os.path).exists('/foo').thenReturn(True):
...
Most of the time verifying your interactions is not necessary, because
your code under tests implicitly verifies the return value by evaluating
it. See :func:`verify` if you need to, see also :func:`expect` to setup
expected call counts up front.
If your function is pure side effect and does not return something, you
can omit the specific answer. The default then is `None`::
when(manager).do_work()
`when` verifies the method name, the expected argument signature, and the
actual, factual arguments your code under test uses against the original
object and its function so its easier to spot changing interfaces.
Sometimes it's tedious to spell out all arguments::
from mockito import ANY, ARGS, KWARGS
when(requests).get('http://example.com/', **KWARGS).thenReturn(...)
when(os.path).exists(ANY)
when(os.path).exists(ANY(str))
.. note:: You must :func:`unstub` after stubbing, or use `with`
statement.
Set ``strict=False`` to bypass the function signature checks.
See related :func:`when2` which has a more pythonic interface.
R" t Whenc s e Z � � f d � Z RS( c s t j � | d � �S( NR" ( R t StubbedInvocation( R, R- ( R" R' ( s@ /opt/alt/python27/lib/python2.7/site-packages/mockito/mockito.pyR/ � s ( R R R/ ( ( R" R' ( s@ /opt/alt/python27/lib/python2.7/site-packages/mockito/mockito.pyR9 � s N( R0 R1 R R R R( R3 ( R& R" R9 ( ( R" R' s@ /opt/alt/python27/lib/python2.7/site-packages/mockito/mockito.pyt when� s @ c O s= t | � \ } } t | d t �} t j | | � | | � S( s� Stub a function call with the given arguments
Exposes a more pythonic interface than :func:`when`. See :func:`when` for
more documentation.
Returns `AnswerSelector` interface which exposes `thenReturn`,
`thenRaise`, and `thenAnswer` as usual. Always `strict`.
Usage::
# Given `dog` is an instance of a `Dog`
when2(dog.bark, 'Miau').thenReturn('Wuff')
.. note:: You must :func:`unstub` after stubbing, or use `with`
statement.
R" ( R R( R R R: ( t fnR t kwargsR& t nameR' ( ( s@ /opt/alt/python27/lib/python2.7/site-packages/mockito/mockito.pyt when2� s c C ss | d k r+ | } t | t � j | � nD | | } } t | d t �} t j | | d t �t � j | � Sd S( sw Patch/Replace a function.
This is really like monkeypatching, but *note* that all interactions
will be recorded and can be verified. That is, using `patch` you stay in
the domain of mockito.
Two ways to call this. Either::
patch(os.path.exists, lambda str: True) # two arguments
# OR
patch(os.path, 'exists', lambda str: True) # three arguments
If called with three arguments, the mode is *not* strict to allow *adding*
methods. If called with two arguments, mode is always `strict`.
.. note:: You must :func:`unstub` after stubbing, or use `with`
statement.
R" N( R R? t Ellipsist
thenAnswerR( R R R: R ( R< t attr_or_replacementt replacementR& R> R' ( ( s@ /opt/alt/python27/lib/python2.7/site-packages/mockito/mockito.pyt patch� s
c sq � d k r t � n t | d � �� t d | d | d | d | � � d t f � � � f d � � Y} | � S( s1 Stub a function call, and set up an expected call count.
Usage::
# Given `dog` is an instance of a `Dog`
expect(dog, times=1).bark('Wuff').thenReturn('Miau')
dog.bark('Wuff')
dog.bark('Wuff') # will throw at call time: too many invocations
# maybe if you need to ensure that `dog.bark()` was called at all
verifyNoUnwantedInteractions()
.. note:: You must :func:`unstub` after stubbing, or use `with`
statement.
See :func:`when`, :func:`when2`, :func:`verifyNoUnwantedInteractions`
R" R R R R t Expectc s e Z � � � f d � Z RS( c s t j � | d � d � �S( NR R" ( R R: ( R, R- ( R" R' R. ( s@ /opt/alt/python27/lib/python2.7/site-packages/mockito/mockito.pyR/ 3 s ( R R R/ ( ( R" R' R. ( s@ /opt/alt/python27/lib/python2.7/site-packages/mockito/mockito.pyRE 2 s N( R R R( R! R3 ( R& R" R R R R RE ( ( R" R' R. s@ /opt/alt/python27/lib/python2.7/site-packages/mockito/mockito.pyt expect s "c G s5 | r' x( | D] } t j | � q
Wn
t j � d S( sS Unstubs all stubbed methods and functions
If you don't pass in any argument, *all* registered mocks and
patched modules, classes etc. will be unstubbed.
Note that additionally, the underlying registry will be cleaned.
After an `unstub` you can't :func:`verify` anymore because all
interactions will be forgotten.
N( R t unstubt
unstub_all( t objsR& ( ( s@ /opt/alt/python27/lib/python2.7/site-packages/mockito/mockito.pyRG < s
c G s+ x$ | D] } t | � } | j � q Wd S( s` Forget all invocations of given objs.
If you already *call* mocks during your setup routine, you can now call
``forget_invocations`` at the end of your setup, and have a clean
'recording' for your actual test code. T.i. you don't have
to count the invocations from your setup code anymore when using
:func:`verify` afterwards.
N( R) t clear_invocations( RI R& R' ( ( s@ /opt/alt/python27/lib/python2.7/site-packages/mockito/mockito.pyt forget_invocationsN s
c G s[ t | � xJ | D]B } t | � } x- | j D]" } | j s- t d | � � q- q- Wq Wd S( Ns
Unwanted interaction: %s( t verifyNoUnwantedInteractionsR) t invocationst verifiedR ( RI R& R' t i( ( s@ /opt/alt/python27/lib/python2.7/site-packages/mockito/mockito.pyt verifyNoMoreInteractions\ s
c G sP xI | D]A } t | � } t | j � d k r t d | j d � � q q Wd S( sq Verify that no methods have been called on given objs.
Note that strict mocks usually throw early on unexpected, unstubbed
invocations. Partial mocks ('monkeypatched' objects or modules) do not
support this functionality at all, bc only for the stubbed invocations
the actual usage gets recorded. So this function is of limited use,
nowadays.
i s
Unwanted interaction: %sN( R) R
RM R ( RI R& R' ( ( s@ /opt/alt/python27/lib/python2.7/site-packages/mockito/mockito.pyt verifyZeroInteractionsg s
c G sW | r t t | � } n t j � } x, | D]$ } x | j D] } | j � q; Wq+ Wd S( s� Verifies that expectations set via `expect` are met
E.g.::
expect(os.path, times=1).exists(...).thenReturn(True)
os.path('/foo')
verifyNoUnwantedInteractions(os.path) # ok, called once
If you leave out the argument *all* registered objects will
be checked.
.. note:: **DANGERZONE**: If you did not :func:`unstub` correctly,
it is possible that old registered mocks, from other tests
leak.
See related :func:`expect`
N( t mapR) R t get_registered_mockst stubbed_invocationsR5 ( RI t theMockst mockRO ( ( s@ /opt/alt/python27/lib/python2.7/site-packages/mockito/mockito.pyRL z s
c G s� | r t t | � } n t j � } xW | D]O } xF | j D]; } | j r; | j t | j � k r; t d | � � q; q; Wq+ Wd S( s Ensure stubs are actually used.
This functions just ensures that stubbed methods are actually used. Its
purpose is to detect interface changes after refactorings. It is meant
to be invoked usually without arguments just before :func:`unstub`.
s
Unused stub: %sN(
RR R) R RS RT t allow_zero_invocationst usedR
t answersR ( RI RU RV RO ( ( s@ /opt/alt/python27/lib/python2.7/site-packages/mockito/mockito.pyt verifyStubbedInvocationsAreUsed� s
"N(# R R R t utilsR R t mockingR R R t ExceptionR R R R R R! R R( R) R R5 R3 R6 R7 R; R? RD RF RG RK RP RQ RL RZ ( ( ( s@ /opt/alt/python27/lib/python2.7/site-packages/mockito/mockito.pyt <module> s6 * O $