<jbUddlZddlZddlZddlZddlZddlZddlmZddlm Z ddlm Z ddlm Z ddl m Z ddl mZddlmZdd lmZdd lmZdd lmZdd lmZdd lmZddlmZddlZddlmZddlmZedZejjZeejjejjejj fZ!Gdde"Z#e GddZ$e GddZ%GddZ&dedee&ddffdZ'ej(e'Z)ej(de'Z*ej(d e'Z+ej(d!e'Z,ej(d"e'Z-gZ.e/ee0d#<iZ1e2e3efe0d$<d%ed&efd'ed(eddfd)Z4d%ed&efd'ed(eddfd*Z5d'ed(eddfd+Z6d'ed(eddfd,Z7d'ed(eddfd-Z8d'ed(eddfd.Z9d'ed(eddfd/Z:d'ed(eddfd0Z;d'ed(eddfd1Zd'ed(eddfd4Z?d'ed(eddfd5Z@d'ed(eddfd6ZAd'ed(eddfd7ZBd'ed(eddfd8ZCd9eddfd:ZDd?d;ZEdZGdS)@N) Generator)Iterable)Iterator)Mapping) dataclass)field)Any)Callable)Optional)TypeVar)Union)cast)overload)get_mock_module)parse_ini_boolean_TceZdZdZdS)PytestMockWarningz3Base class for all warnings emitted by pytest-mock.N)__name__ __module__ __qualname____doc__O/home/lighthouse/health/venv/lib/python3.11/site-packages/pytest_mock/plugin.pyrr$s====rrc4eZdZUeed<dZeeed<dS) MockCacheItemmockNpatch)rrrMockType__annotations__r r r rrrrr(s/ NNNE8C=rrceZdZUdZeeZeeed<de defdZ de de defdZ de dd fd Z d d Zdeefd Zd S) MockCachezJ Cache MagicMock and Patcher instances so we can undo them later. )default_factorycacherreturncN|jD]}|j|ur|cStd)Nz"This mock object is not registered)r&r ValueErrorselfr mock_items r_findzMockCache._find6s@ ! !I~%%    &=>>>rkwargsc h|jtdd|i||jdS)Nrr)r&appendr)r+rr.s raddz MockCache.add<s7 -<<88 y~'899 413 .y~'899 615 .).*GHH ,))!-;*))++++ , ,rc8|jdS)zi Stop all patchers started by this fixture. Can be safely called multiple times. N)rFr9r<s rstopallzMockerFixture.stopalls      rrc:|j|dS)zp Stops a previous patch or spy call by passing the ``MagicMock`` object returned by it. N)rFr6)r+rs rr5zMockerFixture.stops! %%%%%robjnameduplicate_iteratorsc t|| fd} fd}tjrtj|}ntj|}tjptj}|j|||| d _ d _ g _ d _ S)ak Create a spy of method. It will run method normally, but it is now possible to use `mock` call features with it, like call count. :param obj: An object. :param name: A method in object. :param duplicate_iterators: Whether to keep a copy of the returned iterator in `spy_return_iter`. :return: Spy object. c*d_d_ |i|}r5t|tr t j|d\}}|_nd_|_j|n#t$r }|_d}~wwxYw|S)N) spy_return spy_exceptionrbr itertoolsteerar`r1 BaseException)argsr.rduplicated_iteratorerjmethodspy_objs rwrapperz"MockerFixture.spy..wrappers!%G $(G ! 2FD+F++ '3:a+B+B3-6]1a-@-@*A*.AG++.2G+%&"'..q1111!   ()% HsA99 BB  BcKd_d_ |i|d{V}|_j|n#t$r }|_d}~wwxYw|Sr4)rnror`r1rr)rsr.rtrvrwrxs r async_wrapperz(MockerFixture.spy..async_wrappers!%G $(G ! 2 &$1&11111111 &'"'..q1111 !   ()%  HsA A AA)r]autospecN) getattrinspectiscoroutinefunction functoolsupdate_wrapperismethod isfunctionr objectrnrar`ro) r+rhrirjryr{wrappedr|rwrxs ` @@rspyzMockerFixture.spysd##       &        &v . . @.}fEEGG.w??G#F++Iw/A&/I/I*##C7X#VV!"&"$ $rcvttjj|jd|S)z Create a stub method. It accepts any arguments. Ideal to register to callbacks in tests. :param name: the constructed stub's name as used in repr :return: Stub object. cdSr4rrsr.s rz$MockerFixture.stub..DrrUri)runittestrrJrGr+ris rstubzMockerFixture.stubs; M #   & &,H,Ht & T T   rcbtt|jd|S)z Create a async stub method. It accepts any arguments. Ideal to register to callbacks in tests. :param name: the constructed stub's name as used in repr :return: Stub object. cdSr4rrs rrz*MockerFixture.async_stub..rrr)r AsyncMockTyperGrDrs r async_stubzMockerFixture.async_stubs6    & &,H,Ht & T T   rcLeZdZdZeZdZdedededede f dZ ed d d d d fd ed e d ede edede ede ededede fdZed d d d d fd e jd e d e jde e jdede e jde e jde jdede fdZ d!d e jde e jdede e jde e jde e jdedee e ffdZ d"deeeefe fdeeeefeeeeffdededef dZe d#d e d d de e jdede e jde e jdd dede fdZe d$d e d ede e jdede e jde e jdd dedefdZed e d d de e jdede e jde e jdegefdedefdZe d$d e d d de e jdede e jde e jdegefdedefdZed d d d d fd e d e jde e jdede e jde e jde egefdedefd Zd S)%MockerFixture._Patcherz Object to provide the same interface as mock.patch, mock.patch.object, etc. We need this indirection to keep the same API of the mock package. c"||_||_dSr4)_Patcher__mock_cacherG)r+ mock_cacherGs rrTzMockerFixture._Patcher.__init__s *D *D   r mock_funcwarn_on_mock_enterrsr.r'c||i|}|}|j||t|drt|dr|r d|j_|S)zPatches something by calling the given function from the mock module, registering the patch to stop it later and returns the mock object resulting from the mock call. )rr r_ __enter__c:tjdtdS)Na.Mocks returned by pytest-mock do not need to be used as context managers. The mocker fixture automatically undoes mocking at the end of a test. This warning can be ignored if it was triggered by mocking a context manager. https://pytest-mock.readthedocs.io/en/latest/usage.html#usage-as-context-manager) stacklevel)warningswarnrrrrrz5MockerFixture._Patcher._start_patch..s%8=k*#$ <<<r)startrr2rNrr])r+rrrsr.pmockeds r _start_patchz#MockerFixture._Patcher._start_patchs 4*6**A wwyyF   ! !vQ ! 7 7 7v|,, 6;//4F44F$0MrNFtarget attributenewrUcreaterVr| new_callablec z||jur |jj}|j|jjjd||f||||||d| S)zAPI to mock.patch.objectTrrUrrVr|rrQrGrr r r+rrrrUrrVr|rr.s rrzMockerFixture._Patcher.objectspdl""&.$4$ &-  !!)     rc z||jur |jj}|j|jjjd||f||||||d| S)zThis is equivalent to mock.patch.object except that the returned mock does not issue a warning when used as a context manager.Frrrs rcontext_managerz&MockerFixture._Patcher.context_manager7spdl""&.$4$ &-  !!)     rc L|j|jjjd|f|||||d|S)zAPI to mock.patch.multipleT)rUrrVr|r)rrGr multiple)r+rrUrrVr|rr.s rrzMockerFixture._Patcher.multipleUsR%4$ &/ !!)     rrin_dictvaluesr9c F|j|jjjd|f||d|S)zAPI to mock.patch.dictT)rr9)rrGr dict)r+rrr9r.s rrzMockerFixture._Patcher.dictlsI%4$ &+    r.c dSr4r r+rrrUrrVr|rr.s r__call__zMockerFixture._Patcher.__call__}s src dSr4rrs rrzMockerFixture._Patcher.__call__ rc dSr4rrs rrzMockerFixture._Patcher.__call__rrc dSr4rrs rrzMockerFixture._Patcher.__call__s rc n||jur |jj}|j|jjd|f||||||d|S)zAPI to mock.patchTr)rQrGrr rs rrzMockerFixture._Patcher.__call__sjdl""&.$4$ & !!)     r)NFNNN)rF)......).....)rrrrrrQrTr boolr!rstrr builtinsrrrr rrtuplerrrr rrrrHrs  &(( + + +   6: CF RU      8"%) )-)-#'       6"     v& v& !      B$+.2 2626,0  O     8?+     x/ x/ #/      B/3 26266:  O 8?+    x/   x/  #8?3  #x-     4KM   738,c12 '#s(+XeCHo-FFG            " .12525!$    8?+    x/ x/          /22525!$    8?+    x/ x/            8?+    x/ x/ #2r6*        .12525    8?+    x/ x/ #2r6*        $+.2 26268<    8?+      x/  x/ #8BG#45        rrH)FFr>)Fr4)rrrrr rTrr!rYrdrfrrrJr5rrrr rrrrHrrrrArAPs )s)t))))*CH#';?SV ',,,,#,:>, ,,,,>!!!!&0&T&&&&CH:::!$:;?: ::::x   #  (-2I        x}      UUUUUUUUUUrrA pytestconfigr'c#XKt|}|V|dS)z Return an object that has the same interface to the `mock` module, but takes care of automatically undoing all patches after each test method. N)rArf)rresults r_mockerrs4 < ( (F LLL NNrclass)scopemodulepackagesession_mock_module_patches_mock_module_originals__wrapped_mock_method__.rsr.cd} ||i|dS#t$r}t|ddrt|}n|d}t|}|j|j\}}d} ||ddksJn,#t$r} | dt| zz } Yd} ~ nd} ~ wwxYw ||ksJn,#t$r} | dt| zz } Yd} ~ nd} ~ wwxYw| r|d| zz }t|}d|_|d}~wwxYw) NT_mock_introspection_appliedrr Args: Kwargs: pytest introspection follows: )AssertionErrorr}r call_argsr) rrsr.__tracebackhide__rvmsg __mock_self actual_args actual_kwargs introspectione_argse_kwargss rassert_wrapperrs0000  13Q 7 7 Qa&&CCq'Ka&&C$0-8-B* ] " ?&$qrr(22222%???![3v;;%>>MMMMMM?C(F22222%CCC!]S]]%BBMMMMMMC Q@=PPC 3  (,%+si C>A C9$A54C95 B?BC9BC9"B+*C9+ C5C C9C%C99C>cd} ||i|dS#t$rP}|dd}t|dds|rt|}n|d}t|}|jt |j}|d} d} ddlm} | || D]\} } | | \}}nt}i}| | \}}}nt}i} ||ksJn,#t$r}| d t|zz } Yd}~nd}~wwxYw ||ksJv#t$r}| d t|zz } Yd}~d}~wwxYw| r|d | zz }t|}d|_ |d}~wwxYw) NT any_orderFrrrr) zip_longestrrr) rgetr}rcall_args_listr?rprrr)rrsr.rrvrrr actual_calls expect_callsrr actual_call expect_callrr_ expect_args expect_kwargsrrs rassert_has_calls_wrapperrs$)0000 &&&JJ{E22 13Q 7 7! Q9! Qa&&CCq'Ka&&C)5#K$>?? #Aw " 1111110; L,0W0WGG,K".5@2 ]]&+gg (* ".8C5; &+gg (* C*k99999)CCC%s6{{)BB CG, =====)GGG%X)FF G Q@=PPC 3  (,%M&si E)B=E$C E$ D *D?E$D  E$ DE$ D? D:5E$:D??%E$$E)c@d}ttdg|Ri|dS)NTassert_not_calledrrrsr.rs rwrap_assert_not_calledr23)*=>PPPPPPPPPrc@d}ttdg|Ri|dS)NTassert_called_withrrs rwrap_assert_called_withr73)*>?Q$QQQ&QQQQQrc@d}ttdg|Ri|dS)NTassert_called_oncerrs rwrap_assert_called_oncer<rrc@d}ttdg|Ri|dS)NTassert_called_once_withrrs rwrap_assert_called_once_withrAs3)*CDVtVVVvVVVVVrc@d}ttdg|Ri|dS)NTassert_has_calls)rrrs rwrap_assert_has_callsrFsG1259=Crc@d}ttdg|Ri|dS)NTassert_any_callrrs rwrap_assert_any_callrMs3)*;<NtNNNvNNNNNrc@d}ttdg|Ri|dS)NT assert_calledrrs rwrap_assert_calledrRs2)/:LTLLLVLLLLLrc@d}ttdg|Ri|dS)NTassert_not_awaitedrrs rwrap_assert_not_awaitedrWrrc@d}ttdg|Ri|dS)NTassert_awaited_withrrs rwrap_assert_awaited_withr \3)*?@R4RRR6RRRRRrc@d}ttdg|Ri|dS)NTassert_awaited_oncerrs rwrap_assert_awaited_oncerar rc@d}ttdg|Ri|dS)NTassert_awaited_once_withrrs rwrap_assert_awaited_once_withrfs4)*DEWWWWPVWWWWWrc@d}ttdg|Ri|dS)NTassert_has_awaitsrrs rwrap_assert_has_awaitsrkrrc@d}ttdg|Ri|dS)NTassert_any_awaitrrs rwrap_assert_any_awaitrps3)*<=OOOOOOOOOrc@d}ttdg|Ri|dS)NTassert_awaitedrrs rwrap_assert_awaitedrus3)*:;MdMMMfMMMMMrrBctrdSt|}tttt t ttd}| D]\}} t|j |}n#t$rY(wxYw|t|<|j |j ||}|t |t%|drt&t(t*t,t.t0t2d}| D]\}} t|j|}n#t$rY(wxYw|t|<|j |j||}|t ||t8dS)z Wrap assert methods of mock module so we can hide their traceback and add introspection information to specified argument asserts. N)rrrrrrrrD)rrr rrrr)rrrrrrrrritemsr}rKAttributeErrorr rrrr1rNrrr rrrrrD add_cleanupunwrap_assert_methods)rBrGwrappersrwryoriginalpatcherasync_wrapperss rwrap_assert_methodsr%zs !&))K,55#?/13H$>>++-- {:FCCHH    H )1v&#**;+FPWXX ##G,,,,{K((11#;#;(E 5!7"9   .3355 1 1OFG ";#8&AA!    -5 "6 *!'..{/DfgVVG MMOOO ' ' 0 0 0 0 ,-----s$ A66 BB7E  EEctD]C} |#t$r}t|dkrnYd}~)Hrrr~rp unittest.mockrrcollections.abcrrrr dataclassesrrtypingr r r r r rrpytest_utilrrrrrDrrJrLr! UserWarningrrr$rArfixturemocker class_mocker module_mockerpackage_mockersession_mockerrr?r"rrrrrrrrrrrrrr rrrrrr%r r/r6rrrrDs%%%%%%$$$$$$$$$$$$######!!!!!! """"""$$$$$$ WT]] '  M M M&( >>>>> >>>                    B{{{{{{{{| #)M4,E"F   ' " ",~v~G,,,W55 .X...w77 0i000990i00099#%d3i$$$)+S#X+++%c3h/8;GJ >-%c3h/-8;-GJ- ----`Q#QQQQQQ R3R#R$RRRR R3R#R$RRRR WWsWtWWWW OOsOtOOOO McMSMTMMMM R3R#R$RRRR SCS3S4SSSS SCS3S4SSSS XXXXXXX Q#QQQQQQ PPPPPPP NsNcNdNNNN 2.2.2.2.2.2.j####" S T    $S$T$$$$$$r