gM78ddlZddlmZddlmZddlmZmZddlmZddl m Z ddlm Z Gd d e Z ejd e e fZd Zd ZdZ ddZd dZdZ d!dZGddeZeZd dZdZd"dZ d#dZdZdZdZdZ dZ!dZ"y)$N) invocation) verification)get_objget_obj_attr_tuple)Mock) mock_registry)VerificationErrorc eZdZy) ArgumentErrorN)__name__ __module__ __qualname__D/var/www/openai/venv/lib/python3.12/site-packages/mockito/mockito.pyr r srr errisinstancecJt|Dcgc]}|s| c}dkDScc}w)Nr)len)argsxs r_multiple_arguments_in_user)s& 4%4a14% & **%s  c&|duxr|dkxs|dk(S)Nrrr)values r_invalid_argumentr-s   +%!) : :rcH| |\}}||kDs|dkryy#t$rYywxYw)NTrF) Exception)betweenstartends r_invalid_betweenr!1s?  JE3 3;%!)    s  !!c||dkrtd|zt|||r tdt|rtd|zt|rtd|zt|rtd||rt j |S|rt j |S|rt j|S|t j|Sy)NrzX'times' argument has invalid value. It should be at least 0. You wanted to set it to: %izHYou can set only one of the arguments: 'atleast', 'atmost' or 'between'.z['atleast' argument has invalid value. It should be at least 1. You wanted to set it to: %izZ'atmost' argument has invalid value. It should be at least 1. You wanted to set it to: %iz'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: ) r rrr!rAtLeastAtMostBetweenTimestimesatleastatmostrs r_get_wanted_verificationr+<s  UQY"$)*+ +"'67; %& &!%'./0 0 %'-./ / #* ,- - ##G,, ""6** ##W--  !!%(( rc|tj|}|$t|||}tj|||S)N)strictspec)r mock_forrregister)objr-theMocks r _get_mockr3^s:$$S)Gs64sG, NrcPtj|}|td|z|S)Nzobj '%s' is not registered)r r/r )r1r2s r_get_mock_or_raiser5es-$$S)G83>?? Nrct|tr t|}t|||||rt j t |Gfddt}|S)aCentral interface to verify interactions. `verify` uses a fluent interface:: verify(, times=2).() `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'ceZdZfdZy)verify..Verifyc2tj|SN)rVerifiableInvocation)self method_namer2verification_fns r __getattr__z"verify..Verify.__getattr__s22o7 7rNr rrr?)r2r>srVerifyr8s 7rrA) isinstancestrrr+rInOrderr5object) r1r(r)r*rinorderrAr2r>s @@rverifyrGks^0#scl.WVWFO&..? %G77 8OrceZdZdZy)_OMITTEDcy)NOMITTEDr)r<s r__repr__z_OMITTED.__repr__srN)r rrrLrrrrIrIsrrIct|tr t|}t|Gfddt}|S)a 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().().thenReturn() Compared to simple *patching*, stubbing in mockito requires you to specify concrete `args` for which the stub will answer with a concrete ``. 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-ceZdZfdZy)when..Whenc4tj|S)NrNrStubbedInvocation)r<r=r-r2s rr?zwhen..When.__getattr__s//V5 5rNr@)r-r2srWhenrPs 5rrT)rBrCrr3rE)r1r-rTr2s ` @rwhenrUs:@#sclF+G5v5 6Mrcpt|\}}t|d}tj|||i|S)a 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`, `thenAnswer`, and `thenCallOriginalImplementation` 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. TrN)rr3rrS)fnrkwargsr1namer2s rwhen2rZs=&#2&ICD)G 6: ' ' 6 G GGrc|!|}t|tj|S||}}t|d}t j ||dtj|S)awPatch/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. TrNF)rZEllipsis thenAnswerr3rrS)rWattr_or_replacement replacementr1rYr2s rpatchr`sn() R"--k::+TC-)z++ T%))133=:k3J Krct|tr t|}t|t ||||Gfddt }|S)a1Stub 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` rNr'ceZdZfdZy)expect..Expectc6tj|S)N)rr-rR)r<r=r-r2r>s rr?z"expect..Expect.__getattr__?s //? rNr@)r-r2r>srExpectrc>s rre)rBrCrr3r+rE) r1r-r(r)r*rrer2r>s ` @@rexpectrf!sR*#sclF+G.WVWFO 8Orcj|r|D]}tj|ytjy)aSUnstubs 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 unstub unstub_all)objsr1s rrhrhHs- C   %   "rcH|D]}t|}|jy)a`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)r5clear_invocationsrjr1r2s rforget_invocationsrnZs$$S)!!#rct||D]8}t|}|jD]}|jrt d|z:y)N Unwanted interaction: %s)verifyNoUnwantedInteractionsr5 invocationsverifiedr )rjr1r2is rverifyNoMoreInteractionsruhsF $'$S)$$A::'(Dq(HII%rc|D]@}t|}t|jdkDs'td|jdzy)aqVerify 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. rrpN)r5rrrr rms rverifyZeroInteractionsrwssM$S) w"" #a '#,w/B/B1/EEG G rc|rtt|}ntj}|D]#}|jD]}|j %y)aVerifies 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)mapr5r get_registered_mocksstubbed_invocationsrGrjtheMocksmockrts rrqrqsE& )40 557))A HHJ*rc|rtt|}ntj}|D]#}|jD]}|j %y)aEnsure 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`. N)ryr5r rzr{ check_usedr|s rverifyStubbedInvocationsAreUsedrsG )40 557))A LLN*r)NNNN)T)rNNNFr:)TNNNN)#operatorrrutilsrrmockingrr r rr methodcaller__tracebackhide__rrr!r+r3r5rGrErIrKrUrZr`rfrhrnrurwrqrrrrrs*.(+ I *H))m%67 +; 8< )D =A'Tv *JZH0K>:>#N#$ $JG&8r