>TZ x d dl Z d dlZd dlZd dlZd dlZd dlmZmZ d dlm Z d dl
Z
dZ n
# e $ r dZ Y nw xY wdZ
dZdZd Zd
Zd Z ed eeeefZn# e$ r ed eeeefZY nw xY we G d d
e Zd Z d Z d Z d dZ d dZ d dej! fdZ"d Z#d Z$d Z%d Z&d Z'd Z(d dZ)dS ) N)Enumunique)wrapsTFz1.4.4z%valuesz
%file_pathz %yaml_loaderz%unpackz
%index_lenc e Zd ZdZdZdZdS )TestNameFormata
An enum to configure how ``mk_test_name()`` to compose a test name. Given
the following example:
.. code-block:: python
@data("a", "b")
def testSomething(self, value):
...
if using just ``@ddt`` or together with ``DEFAULT``:
* ``testSomething_1_a``
* ``testSomething_2_b``
if using ``INDEX_ONLY``:
* ``testSomething_1``
* ``testSomething_2``
r N)__name__
__module__ __qualname____doc__DEFAULT
INDEX_ONLY U/builddir/build/BUILD/cloudlinux-venv-1.0.10/venv/lib/python3.11/site-packages/ddt.pyr r * s$ * GJJJr r c t | t rdS t | t t f r"t t t | S dS )NTF)
isinstance
trivial_typeslisttupleallmap
is_trivial)values r r r E sL % '' +t ED%= ) ) +3z5))*** 5r c 2 t | t d | S )z2
Method decorator to add unpack feature.
T)setattr UNPACK_ATTR)funcs r unpackr M s
D+t$$$ Kr c t | S )z
Method decorator to add to your test methods.
Should be added to methods of instances of ``unittest.TestCase``.
)idata)valuess r datar# V s ==r c 8t t t t fd}|S )a
Method decorator to add to your test methods.
Should be added to methods of instances of ``unittest.TestCase``.
:param iterable: iterable of the values to provide to the test function.
:param index_len: an optional integer specifying the width to zero-pad the
test identifier indices to. If not provided, this will add the fewest
zeros necessary to make all identifiers the same length.
Nc ` t | t t | t | S N)r DATA_ATTR INDEX_LEN)r index_leniterables r wrapperzidata..wrapperp s, i***i+++ r )r lenstr)r* r) r+ s `` r r! r! ` sW ??CMM**++
Nr c fd}|S )a
Method decorator to add to your test methods.
Should be added to methods of instances of ``unittest.TestCase``.
``value`` should be a path relative to the directory of the file
containing the decorated ``unittest.TestCase``. The file
should contain JSON encoded data, that can either be a list or a
dict.
In case of a list, each value in the list will correspond to one
test case, and the value will be concatenated to the test method
name.
In case of a dict, keys will be used as suffixes to the name of the
test case, and values will be fed as test data.
``yaml_loader`` can be used to customize yaml deserialization.
The default is ``None``, which results in using the ``yaml.safe_load``
method.
c d t | t rt | t | S r& )r FILE_ATTRYAML_LOADER_ATTR)r r yaml_loaders r r+ zfile_data..wrapper s5 i''' 9 D*K 8 8 8 r r )r r2 r+ s `` r file_datar3 x s) ,
Nr c b d |dz | }|t j u st | sd | | S t | }n&# t
$ r | dd }Y nw xY wd | || }t j dd| S ) a
Generate a new name for a test case.
It will take the original test name and append an ordinal index and a
string representation of the value, and convert the result into a valid
python identifier by replacing extraneous characters with ``_``.
We avoid doing str(value) if dealing with non-trivial values.
The problem is possible different names with different runs, e.g.
different order of dictionary keys (see PYTHONHASHSEED) or dealing
with mock objects.
Trivial scalar values are passed as is.
A "trivial" value is a plain scalar, or a tuple or list consisting
only of trivial values.
The test name format is controlled by enum ``TestNameFormat`` as well. See
the enum documentation for further details.
z{0:0{1}}r z{0}_{1}asciibackslashreplacez {0}_{1}_{2}z
\W|^(?=\d)_) formatr r r r- UnicodeEncodeErrorencoderesub)namer indexr) name_fmt test_names r mk_test_namerB s ,
eai 3 3E>,,,Ju4E4E, e,,,:E
: : : W&899: $$T5%88I
6-i 0 00s A B Bc t fd }||_ |_ |||_ n7 j r0 j j i |_ n# t
t f$ r Y nw xY w|S )zO
This internal method decorator feeds the test data item to the test.
c | gR i S r& r )selfargsr kwargss r r+ zfeed_data..wrapper s# tD*4***6***r )r r __wrapped__r r9
IndexErrorKeyError)r new_nametest_data_docstringrF rG r+ s ` `` r feed_datarM s
4[[+ + + + + + [+ G G&- <
"5$,"5t"Fv"F"F )
Ns A A,+A,c H t | |t |||g|R i | dS )z~
Add a test case to this class.
The test will be based on an existing function but will give it a new
name.
N)r rM )clsrA test_docstringr rF rG s r add_testrQ sP CIdI~
r c t j t j | }t j t j | }fd}t j | s0t |d }d}t | || |d d dS |
d } | r7t s0t |d }d}t | || |d d dS t j
|dd 5 }
| rVt |t r,t! |t } t# j |
|
} n)t# j |
} nt) j |
} ddd n # 1 swxY w Y t+ | ||| dS ) z=
Process the parameter in the `file_data` decorator.
c fd}|S )Nc ( t z r& )
ValueError)rF file_attrmessages r r z:process_file_data..create_error_func..func s Wy 011 1r r )rW r rV s ` r create_error_funcz,process_file_data..create_error_func s' 2 2 2 2 2 2 r errorzError!z%s does not existN)z.ymlz.yamlz(%s is a YAML file, please install PyYAMLrzutf-8)Loader)ospathabspathinspect
getsourcefilejoindirnameexistsrB rQ endswith
_have_yamlcodecsopenhasattrr1 getattryamlload safe_loadjson_add_tests_from_data)
rO r> r rV cls_pathdata_file_pathrX rA rP
_is_yaml_filefr2 r# s
` r process_file_datars s ww 4S 9 9::HW\\"'//(";";YGGN 7>>. ) ) w// %i ""#677 ? ? ?"++,=>>M
Z
w// % H I I
^S' 2 2 a t -..
) %d,< = = y;777~a((9Q< r r# r) ielemkeyr rA s
r rn rn s CD NN##I T??
=
=4 dD ! ! @ tDzC$T39==II
d
#
# @E$T5!Y??I eT " " = S)Y > > > > > > S)Ye < < < <
=
=r c $ t | d S )zNFinds out if the obj is a "primitive". It is somewhat hacky but it works.
__dict__)rh )objs r
_is_primitiver} " s sJ'' ''r c @ t | s|j r|j S dS )zReturns a docstring based on the following resolution strategy:
1. Passed value is not a "primitive" and has a docstring, then use it.
2. In all other cases return None, i.e the test name is used.
N)r} r )r r s r _get_test_data_docstringr ( s*
EM } tr c | dt j fd}t j | r || n|S )a
Class decorator for subclasses of ``unittest.TestCase``.
Apply this decorator to the test case class, and then
decorate test methods with ``@data``.
For each method decorated with ``@data``, this will effectively create as
many methods as data items are passed as parameters to ``@data``.
The names of the test methods follow the pattern
``original_test_name_{ordinal}_{data}``. ``ordinal`` is the position of the
data argument, starting with 1.
For data we use a string representation of the data value converted into a
valid python identifier. If ``data.__name__`` exists, we use that instead.
For each method decorated with ``@file_data('test_data.json')``, the
decorator will try to load the test_data.json file located relative
to the python file containing the method that is decorated. It will,
for each ``test_name`` key create as many methods in the list of values
from the ``data`` key.
Decorating with the keyword argument ``testNameFormat`` can control the
format of the generated test names. For example:
- ``@ddt(testNameFormat=TestNameFormat.DEFAULT)`` will be index and values.
- ``@ddt(testNameFormat=TestNameFormat.INDEX_ONLY)`` will be index only.
- ``@ddt`` is the same as DEFAULT.
testNameFormatc
t | j D ]\\ }}t |t rt |t }t t |t D ]\ }}t |t |d| || }t || }t |t rLt |t st |t rt | |||g|R t | |||fi | t | |||| t | | t |t r7t |t }t! | ||| t | | ^| S )Nr )r r{ itemsrh r' ri r( ru rB r r r r rQ delattrr0 rs )
rO r> r r) rw vrA rL rV
fmt_test_names
r r+ zddt..wrapperV s s| 1 1 3 344 $ # $ #JD$tY'' #
# #D) 4 4 %gdI&>&> ? ? O ODAq , :q11!% ! !I +C4*K*K' t[11 O%a// :a3F3F $ # ) 3 $
"# % # ) 3 $
#$ !i1DdANNNNT""""y))
# #D) 4 4 !#tT9===T"""
r )getr r
r_ isclass)argrG r+ r s @r ddtr 3 sZ B JJ / 1GHHM& & & & &T #?3// <773<<r s?
KKK JJ JJJ
! 8T$ZZsE:>MM 8 8 8T$ZZsE37MMM8 T 4 0 < %&^=S 1 1 1 1D 6 .0 .0 .0b= = =$( ( ( M= M= M= M= M= M=s + 55A A.-A.