o #if5@sdZddlmZddlZddlmZddlmZddlmZddlm Z ddlm Z dd lm Z dd lm Z dd lm Z dd lmZdd lmZddlmZddlmZddlmZddlmZddlZddlmZddlmZddlmZddlmZedZede dfddZeddde eeeefddfdd Zed!edefd"ed#edefd$d Z d.d!e edefd"ed#ededeffd%d Ze d/ddd&eee eee dffde eeeefdd'fd(d)Z!ed&eee eee dffd!edefd"ed#edef d*d)Z!e fddd&eee eee dffd"ede eeeefd#eded'eff d+d)Z!Gd,ddej"Z#e Gd-d'd'e#Z$dS)0z/Record warnings during test function execution.pformatN) TracebackType)Any)Callable)final) Generator)Iterator)List)Optional)overload)Pattern)Tuple)Type)TypeVar)Union)check_ispytest)fixture)Exit)failTreturn)WarningsRecorderNNccsFtdd}|td|VWddS1swYdS)zReturn a :class:`WarningsRecorder` instance that records all warnings emitted by test functions. See https://docs.pytest.org/en/latest/how-to/capture-warnings.html for information on warning categories. T _ispytestdefaultN)rwarnings simplefilter)wrecrH/var/www/html/corbot_env/lib/python3.10/site-packages/_pytest/recwarn.pyrecwarns   "r!.matchr#rcCdSNrr"rrr deprecated_call,sr&funcargskwargscOr$r%r)r'r(r)rrr r&2scOs4d}|dur |g|R}ttttfg|Ri|S)aAssert that code produces a ``DeprecationWarning`` or ``PendingDeprecationWarning`` or ``FutureWarning``. This function can be used as a context manager:: >>> import warnings >>> def api_call_v2(): ... warnings.warn('use v3 of this api', DeprecationWarning) ... return 200 >>> import pytest >>> with pytest.deprecated_call(): ... assert api_call_v2() == 200 It can also be used by passing a function and ``*args`` and ``**kwargs``, in which case it will ensure calling ``func(*args, **kwargs)`` produces one of the warnings types above. The return value is the return value of the function. In the context manager form you may use the keyword argument ``match`` to assert that the warning matches a text or regex. The context manager produces a list of :class:`warnings.WarningMessage` objects, one for each warning raised. TN)warnsDeprecationWarningPendingDeprecationWarning FutureWarning)r'r(r)__tracebackhide__rrr r&6s expected_warningWarningsCheckercCr$r%r)r/r#rrr r*Xsr*cOr$r%r)r/r'r(r)rrr r*`scOsd}|s|rdt|}td|dt||ddS|d}t|s0t|dt|dt|dd ||d d i|Wd S1sLwYd S) aAssert that code raises a particular class of warning. Specifically, the parameter ``expected_warning`` can be a warning class or tuple of warning classes, and the code inside the ``with`` block must issue at least one warning of that class or classes. This helper produces a list of :class:`warnings.WarningMessage` objects, one for each warning emitted (regardless of whether it is an ``expected_warning`` or not). Since pytest 8.0, unmatched warnings are also re-emitted when the context closes. This function can be used as a context manager:: >>> import pytest >>> with pytest.warns(RuntimeWarning): ... warnings.warn("my warning", RuntimeWarning) In the context manager form you may use the keyword argument ``match`` to assert that the warning matches a text or regex:: >>> with pytest.warns(UserWarning, match='must be 0 or None'): ... warnings.warn("value must be 0 or None", UserWarning) >>> with pytest.warns(UserWarning, match=r'must be \d+$'): ... warnings.warn("value must be 42", UserWarning) >>> with pytest.warns(UserWarning): # catch re-emitted warning ... with pytest.warns(UserWarning, match=r'must be \d+$'): ... warnings.warn("this is not here", UserWarning) Traceback (most recent call last): ... Failed: DID NOT WARN. No warnings of type ...UserWarning... were emitted... **Using with** ``pytest.mark.parametrize`` When using :ref:`pytest.mark.parametrize ref` it is possible to parametrize tests such that some runs raise a warning and others do not. This could be achieved in the same way as with exceptions, see :ref:`parametrizing_conditional_raising` for an example. Tz, z5Unexpected keyword arguments passed to pytest.warns: z" Use context-manager form instead?) match_exprrrz object (type: z) must be callablerN)joinsorted TypeErrorr0callabletype)r/r#r(r)r.argnamesr'rrr r*is/ $cseZdZdZdddeddffddZeded fd d Zd e dd fd dZ de d fddZ de fddZ efdeedd fddZdddZd fdd Zdeeedeedeeddffdd ZZS)!raFA context manager to record raised warnings. Each recorded warning is an instance of :class:`warnings.WarningMessage`. Adapted from `warnings.catch_warnings`. .. note:: ``DeprecationWarning`` and ``PendingDeprecationWarning`` are treated differently; see :ref:`ensuring_function_triggers`. FrrrNcs&t|tjddd|_g|_dS)NT)recordF)rsuper__init___entered_list)selfr __class__rr r;s zWarningsRecorder.__init__zwarnings.WarningMessagecCs|jS)zThe list of recorded warnings.r=r>rrr listszWarningsRecorder.listicCs |j|S)z Get a recorded warning by index.rA)r>rDrrr __getitem__ zWarningsRecorder.__getitem__cC t|jS)z&Iterate through the recorded warnings.)iterr=rBrrr __iter__rFzWarningsRecorder.__iter__cCrG)z The number of recorded warnings.)lenr=rBrrr __len__rFzWarningsRecorder.__len__clscCsd}t|jD]'\}}|j|kr|j|St|j|r.|dus,t|j|j|js.|}q|dur9|j|Sd}t|d)zPop the first recorded warning which is an instance of ``cls``, but not an instance of a child class of any other match. Raises ``AssertionError`` if there is no match. NTz not found in warning list) enumerater=categorypop issubclassAssertionError)r>rLbest_idxrDwr.rrr rOs   zWarningsRecorder.popcCsg|jdd<dS)z$Clear the list of recorded warnings.NrArBrrr clearszWarningsRecorder.clearcsD|jr d}td|dt}|dusJ||_td|S)NTz Cannot enter z twicealways)r< RuntimeErrorr: __enter__r=rr)r>r.r=r?rr rWs   zWarningsRecorder.__enter__exc_typeexc_valexc_tbcs4|js d}td|dt|||d|_dS)NTz Cannot exit z without entering firstF)r<rVr:__exit__)r>rXrYrZr.r?rr r[s  zWarningsRecorder.__exit__)rN)rr)__name__ __module__ __qualname____doc__boolr;propertyr rCintrEr rIrKWarningrrOrTrWr BaseExceptionrr[ __classcell__rrr?r rs(   c seZdZedfdddeeeeeedffdeeee efde ddffd d Z d e j de fd d Zdeeedeedeeddffdd ZZS)r0NFrr/.r1rrcst|tjddd}t|tr'|D]}t|ts#t|t|q|}nt|tr5t|tr5|f}nt|t|||_ ||_ dS)NTrz/exceptions must be derived from Warning, not %s) rr:r; isinstancetuplerPrcr5r7r/r1)r>r/r1rmsgexcexpected_warning_tupr?rr r;s     zWarningsChecker.__init__warningcCs>|jdusJt|j|jot|jdupt|jt|jSr%) r/rPrNr`r1researchstrmessage)r>rkrrr matchesszWarningsChecker.matchesrXrYrZcst|||d}|durt|trt|trdSdtffdd }z~tfddDs=tdjd|d ntfd dDsYtdjd j d |d WD]} |stt j |j |j|j|j|j|jd q\D](}t|j turqw|j jsqw|j jd}t|trqwtd|dt|jddSD]} |st j |j |j|j|j|j|jd qD](}t|j turq|j jsq|j jd}t|trqtd|dt|jdw)NTrcstddDddS)NcSsg|]}|jqSr)ro).0r9rrr :sz?WarningsChecker.__exit__..found_str..)indentrrrBrr found_str9sz+WarningsChecker.__exit__..found_strc3s|] }t|jjVqdSr%)rPrNr/rqrSrBrr =sz+WarningsChecker.__exit__..z"DID NOT WARN. No warnings of type z" were emitted. Emitted warnings: .c3s|]}|VqdSr%)rprvrBrr rwBsz* matching the regex were emitted. Regex: z Emitted warnings: )rorNfilenamelinenomodulesourcerz$Warning must be str or Warning, got z (type ))r:r[rf Exceptionrrnanyrr/r1rpr warn_explicitrorNryrzr]r|r7 UserWarningr(r5r\)r>rXrYrZr.rurSrhr?rBr r[$s        zWarningsChecker.__exit__)r\r]r^rcrrrr rnr r`r;rWarningMessagerprdrr[rerrr?r r0s0 r%).)%r_pprintrrltypesrtypingrrrrr r r r r rrrrr_pytest.deprecatedr_pytest.fixturesr_pytest.outcomesrrrr!rnr&rcr*catch_warningsrr0rrrr s                     $  "      @Y