File manager - Edit - /opt/saltstack/salt/lib/python3.10/site-packages/salt/modules/__pycache__/saltcheck.cpython-310.pyc
Back
o ;j7� � @ s� d Z ddlZddlZddlZddlZddlZddlmZ ddlZ ddl Z ddl Z ddl Z ddl Z ddlZ ddlZ ddlZ ddlmZ ddlmZ ddlmZmZ e�e�Zze W n e yd i ZY nw ded< dZ d d � Z d d � Z d d� Z d*dd�Z!d+dd�Z"dd� Z#e j$j%�&e"d�Z'd,dd�Z(dd� Z)d-dd �Z*d d � Z+ed d � �Z,ed!d"� �Z-d.d$d%�Z.G d&d'� d'�Z/G d(d)� d)�Z0dS )/a�# A module for testing the logic of states and highstates on salt minions :codeauthor: William Cannon <william.cannon@gmail.com> :maturity: new Saltcheck provides unittest like functionality requiring only the knowledge of salt module execution and yaml. Saltcheck uses salt modules to return data, then runs an assertion against that return. This allows for testing with all the features included in salt modules. In order to run state and highstate saltcheck tests, a sub-folder in the state directory must be created and named ``saltcheck-tests``. Tests for a state should be created in files ending in ``*.tst`` and placed in the ``saltcheck-tests`` folder. ``tst`` files are run through the salt rendering system, enabling tests to be written in yaml (or renderer of choice), and include jinja, as well as the usual grain and pillar information. Like states, multiple tests can be specified in a ``tst`` file. Multiple ``tst`` files can be created in the ``saltcheck-tests`` folder, and should be named the same as the associated state. The ``id`` of a test works in the same manner as in salt state files and should be unique and descriptive. .. versionadded:: 3000 The ``saltcheck-tests`` folder can be customized using the ``saltcheck_test_location`` minion configuration setting. This setting is a relative path from the formula's ``salt://`` path to the test files. Usage ===== Example Default file system layout: .. code-block:: text /srv/salt/apache/ init.sls config.sls saltcheck-tests/ init.tst config.tst deployment_validation.tst Alternative example file system layout with custom saltcheck_test_location: Minion configuration: --------------------- .. code-block:: yaml saltcheck_test_location: tests/integration/saltcheck Filesystem layout: ------------------ .. code-block:: text /srv/salt/apache/ init.sls config.sls tests/integration/saltcheck/ init.tst config.tst deployment_validation.tst Tests can be run for each state by name, for all ``apache/saltcheck/*.tst`` files, or for all states assigned to the minion in top.sls. Tests may also be created with no associated state. These tests will be run through the use of ``saltcheck.run_state_tests``, but will not be automatically run by ``saltcheck.run_highstate_tests``. .. code-block:: bash salt '*' saltcheck.run_state_tests apache,apache.config salt '*' saltcheck.run_state_tests apache check_all=True salt '*' saltcheck.run_highstate_tests salt '*' saltcheck.run_state_tests apache.deployment_validation Saltcheck Keywords ================== **module_and_function:** (str) This is the salt module which will be run locally, the same as ``salt-call --local <module>``. The ``saltcheck.state_apply`` module name is special as it bypasses the local option in order to resolve state names when run in a master/minion environment. **args:** (list) Optional arguments passed to the salt module **kwargs:** (dict) Optional keyword arguments to be passed to the salt module **assertion:** (str) One of the supported assertions and required except for ``saltcheck.state_apply`` Tests which fail the assertion and expected_return, cause saltcheck to exit which a non-zero exit code. **expected_return:** (str) Required except by ``assertEmpty``, ``assertNotEmpty``, ``assertTrue``, ``assertFalse``. The return of module_and_function is compared to this value in the assertion. **assertion_section:** (str) Optional keyword used to parse the module_and_function return. If a salt module returns a dictionary as a result, the ``assertion_section`` value is used to lookup a specific value in that return for the assertion comparison. **assertion_section_delimiter:** (str) Optional delimiter to use when splitting a nested structure. Defaults to ':' **print_result:** (bool) Optional keyword to show results in the ``assertEqual``, ``assertNotEqual``, ``assertIn``, and ``assertNotIn`` output. Defaults to True. **output_details:** (bool) Optional keyword to display ``module_and_function``, ``args``, ``assertion_section``, and assertion results text in the output. If print_result is False, assertion results will be hidden. This is a per test setting, but can be set globally for all tests by adding ``saltcheck_output_details: True`` in the minion configuration file. Defaults to False **pillar_data:** (dict) Optional keyword for passing in pillar data. Intended for use in potential test setup or teardown with the ``saltcheck.state_apply`` function. **skip:** (bool) Optional keyword to skip running the individual test .. versionadded:: 3000 Multiple assertions can be run against the output of a single ``module_and_function`` call. The ``assertion``, ``expected_return``, ``assertion_section``, and ``assertion_section_delimiter`` keys can be placed in a list under an ``assertions`` key. See the multiple assertions example below. Sample Cases/Examples ===================== Basic Example ------------- .. code-block:: yaml echo_test_hello: module_and_function: test.echo args: - "hello" kwargs: assertion: assertEqual expected_return: 'hello' Example with jinja ------------------ .. code-block:: jinja {% for package in ["apache2", "openssh"] %} {# or another example #} {# for package in salt['pillar.get']("packages") #} test_{{ package }}_latest: module_and_function: pkg.upgrade_available args: - {{ package }} assertion: assertFalse {% endfor %} Example with setup state including pillar ----------------------------------------- .. code-block:: yaml setup_test_environment: module_and_function: saltcheck.state_apply args: - common pillar_data: data: value verify_vim: module_and_function: pkg.version args: - vim assertion: assertNotEmpty Example with jinja ------------------ .. code-block:: jinja {% for package in ["apache2", "openssh"] %} {# or another example #} {# for package in salt['pillar.get']("packages") #} test_{{ package }}_latest: module_and_function: pkg.upgrade_available args: - {{ package }} assertion: assertFalse {% endfor %} Example with setup state including pillar ----------------------------------------- .. code-block:: yaml setup_test_environment: module_and_function: saltcheck.state_apply args: - common pillar-data: data: value verify_vim: module_and_function: pkg.version args: - vim assertion: assertNotEmpty Example with skip ----------------- .. code-block:: yaml package_latest: module_and_function: pkg.upgrade_available args: - apache2 assertion: assertFalse skip: True Example with assertion_section ------------------------------ .. code-block:: yaml validate_shell: module_and_function: user.info args: - root assertion: assertEqual expected_return: /bin/bash assertion_section: shell Example with a nested assertion_section --------------------------------------- .. code-block:: yaml validate_smb_signing: module_and_function: lgpo.get args: - 'Machine' kwargs: return_full_policy_names: True assertion: assertEqual expected_return: Enabled assertion_section: 'Computer Configuration|Microsoft network client: Digitally sign communications (always)' assertion_section_delimiter: '|' Example suppressing print results --------------------------------- .. code-block:: yaml validate_env_nameNode: module_and_function: hadoop.dfs args: - text - /oozie/common/env.properties expected_return: nameNode = hdfs://nameservice2 assertion: assertNotIn print_result: False Example with multiple assertions and output_details --------------------------------------------------- .. code-block:: yaml multiple_validations: module_and_function: network.netstat assertions: - assertion: assertEqual assertion_section: "0:program" expected_return: "systemd-resolve" - assertion: assertEqual assertion_section: "0:proto" expected_return: "udp" output_details: True Supported assertions ==================== * assertEqual * assertNotEqual * assertTrue * assertFalse * assertIn * assertNotIn * assertGreater * assertGreaterEqual * assertLess * assertLessEqual * assertEmpty * assertNotEmpty .. warning:: The saltcheck.state_apply function is an alias for :py:func:`state.apply <salt.modules.state.apply>`. If using the :ref:`ACL system <acl-eauth>` ``saltcheck.*`` might provide more capability than intended if only ``saltcheck.run_state_tests`` and ``saltcheck.run_highstate_tests`` are needed. � N)� OrderedDict)�DEFAULT_TARGET_DELIM)�memoize)�dumps�loads� global_scheckZ saltcheckc C s t jj�� stS dS )z> Set the virtual pkg module if not running as a proxy )FzIThe saltcheck execution module failed to load: only available on minions.)�salt�utils�platformZis_proxy�__virtualname__� r r �J/opt/saltstack/salt/lib/python3.10/site-packages/salt/modules/saltcheck.py� __virtual__J s r c K s. t � }| �dd�}|rt|t�r|�|�S dS )am Execute one saltcheck test and return result :param keyword arg test: CLI Example: .. code-block:: bash salt '*' saltcheck.run_test test='{"module_and_function": "test.echo", "assertion": "assertEqual", "expected_return": "This works!", "args":["This works!"] }' �testNz"Test argument must be a dictionary)� SaltCheck�get� isinstance�dict�run_test)�kwargsZscheckr r r r r V s r c K sn t �td �}tj�|�}dt�dd�v r d|d< t�d� tj j |d�}|r1|j d | fi |��S |� d | �S ) az Runs :py:func:`state.apply <salt.modules.state.apply>` with given options to set up test data. Intended to be used for optional test setup or teardown Reference the :py:func:`state.apply <salt.modules.state.apply>` module documentation for arguments and usage options CLI Example: .. code-block:: bash salt '*' saltcheck.state_apply postfix � conf_file�$running_data/var/run/salt-minion.pid�pidfileF�local� file_clientz#Detected salt-ssh, running as local�Zmopts� state.apply) �copy�deepcopy�__opts__r �config� minion_configr �log�debug�client�Caller�cmd)� state_namer r � local_optsZcallerr r r � state_applyo s r) c C s� | sdt v rt d rt d } nd} g }t| �}t| �}d}g }|D ]}|�|d� ||jvr7|d }|�|� q!|td< d|||jd�iS ) a Report on tests for states assigned to the minion through highstate. Quits with the exit code for the number of missing tests. CLI Example: .. code-block:: bash salt '*' saltcheck.report_highstate_tests .. versionadded:: 3000 �saltenv�baser F� �retcodezTEST REPORT RESULTS)� Missing TestszStates missing testszStates with tests)r �_get_top_states�StateTestLoader�add_test_files_for_sls� found_states�append� __context__)r* �sls_list�stl� missing_testsZstates_missing_testsr' r r r �report_highstate_tests� s, ���r8 Fc C s� |sdt v rt d rt d }nd}t|�td< td d�}td d�}t|�}t� }tjj� | �}|D ]�} |� | |� |� � t� } |r~t |t �rMt|�}t�� dk r[d}t�d � n#|d krgd}t�d � n|j�� D ]} d | �d g �v r}d}t�d� ql|r�|r�|} n tt|j�t�� �} t�d| � t�| �jt|j� � d�} | D ]}|� � D ]\}}|| |< q�q�n|j� � D ]\}}td � |�}|| |< q�|�| �s�| || < q3t ||d�S )a Execute tests for a salt state and return results Nested states will also be tested :param str state: state name for which to run associated .tst test files :param str saltenv: optional saltenv. Defaults to base :param bool check_all: boolean to run all tests in state/saltcheck-tests directory :param bool only_fails: boolean to only print failure results CLI Example: .. code-block:: bash salt '*' saltcheck.run_state_tests postfix,common Tests will be run in parallel by adding "saltcheck_parallel: True" in minion config. When enabled, saltcheck will use up to the number of cores detected. This can be limited by setting the "saltcheck_processes" value to an integer to set the maximum number of parallel processes. r* r+ r � config.getZsaltcheck_parallelZsaltcheck_processes� Fz$Only 1 CPU. Disabling parallization.r, z8Configuration limited to 1 CPU. Disabling parallization.r �module_and_functionz3Tests include state.apply. Disabling parallization.z+Running tests in parallel with %s processes)�func�iterable)� only_fails) r r r4 �__salt__r0 r r r �argsZ split_inputr1 �load_test_suiter �float�int�multiprocessing� cpu_countr" r# � test_dict�valuesr �warning�min�lenZPool�map�parallel_scheck�itemsr �_generate_out_list)�stater* � check_allr> ZparallelZnum_procr6 �resultsr5 r' � results_dictrM Z pool_sizeZpresults�item�key�value�resultr r r �run_state_tests� sd �� � �� � rW c C s* | d }| d }i }t d �|�||< |S )z triggers salt-call in parallelr r, r )r4 r )�datarT rU rQ r r r rL s rL �run_state_tests_sshc C sF | sdt v rt d rt d } nd} g }t| �}d�|�}t|| |d�S )a< Execute all tests for states assigned to the minion through highstate and return results :param str saltenv: optional saltenv. Defaults to base :param bool only_fails: boolean to only print failure results CLI Example: .. code-block:: bash salt '*' saltcheck.run_highstate_tests r* r+ �,)r* r> )r r/ �joinrW )r* r> r5 � all_statesr r r �run_highstate_tests s r] c C sv |r5i }|| D ]*}|| | d � d�r2|�| �r(|| �||| | i� q||| | i|| < q|S | || iS )z< For given results, only return failures if desired �status�Fail)� startswithr �update)r' rQ r> Z failed_testsr r r r �_eval_failure_only_print1 s � rb c C s� d}d}d}d}d}g }| D ]J}| | � � s|d }n4| | � � D ]-\} } | d �d�r0|d }| d �d�r;|d }| d �d�rF|d }|t| d � }q!|�t|| |�� qt|d d � d �}|�d t|d �||||d�i� |rudndtd< |S )z+ generate test results output list r � r, r^ �Passr_ �Skip�durationc S s t | �� �S �N)�sorted�keys)�xr r r �<lambda>Z s z$_generate_out_list.<locals>.<lambda>)rT z TEST RESULTS� )zExecution TimeZPassedZFailedZSkippedr. r- )rM r` rB r3 rb rh �roundr4 ) rQ r> ZpassedZfailedZskippedr7 Z total_timeZout_listrO �_�valr r r rN C s> ��� rN c C s& t d | td jd�}t�d|� |S )z0 call the salt utility to render a file zslsutil.rendererr �r* z rendered: %s)r? r4 r* r" �info)Z file_pathZrenderedr r r � _render_filel s � rr c C s t d � }t| |v �S )z: Return a list of all modules available on minion zsys.list_modules)r? �bool)�module�modulesr r r �_is_valid_modulex s rv c C s@ zt d | �}W n tjjy dg}Y nw | � d|� �|v S )z7 Determine if a function is valid for a module zsys.list_functionszunable to look up functions�.)r? r � exceptionsZ SaltException)� module_name�functionZ functionsr r r �_is_valid_function� s �r{ r+ c C s( g }t d | d�| }t�d| |� |S )z; Equivalent to a salt cli: salt web state.show_top zstate.show_toprp z.saltcheck for saltenv: %s found top states: %s)r? r" r# )r* Z top_statesr r r r/ � s r/ c @ s� e Zd ZdZd+dd�Zdd� Zdd� Zd d � Zd d � Zd d� Z e dd� �Z e d,dd��Z e d,dd��Z e dd� �Ze dd� �Ze d,dd��Ze d,d d ��Ze d d � �Ze d d!� �Ze d"d#� �Ze d$d%� �Ze d&d'� �Ze d(d)� �Zd*S )-r z6 This class validates and runs the saltchecks r+ c C s, g | _ g | _i | _i | _|| _d�� | _d S )Nai assertEqual assertNotEqual assertTrue assertFalse assertIn assertNotIn assertGreater assertGreaterEqual assertLess assertLessEqual assertEmpty assertNotEmpty)Zsls_list_stateru rR Zresults_dict_summaryr* �split�assertions_list��selfr* r r r �__init__� s �zSaltCheck.__init__c s� d}� � dd�}t� fdd�dD ��}� � d� � dd��}|| jvr*t�d |� d }|d vrD|du r9t�d � d }|du rDt�d � d }|S )zValidate assertion keysT� assertionNc 3 s � | ] }|� � � v V qd S rg )ri )�.0rT �r r r � <genexpr>� s � �z.SaltCheck._check_assertions.<locals>.<genexpr>)�expected_return�expected-returnr� r� z+Saltcheck: %s is not in the assertions listF)� assertEmpty�assertNotEmpty� assertTrue� assertFalsez"Saltcheck: missing expected_returnz*Saltcheck: expected_return missing a value)r �anyr} r" �error)r r �is_validr� Z exp_ret_keyZ exp_ret_valr r� r �_check_assertions� s" � zSaltCheck._check_assertionsc C s� t �d|� d}|�dd�}|�dd�}|dkr|S |�d�r-|�d�D ]}| �|�}q$n| �|�}|rV|�d �\}}t|�sGd}t �d |� t||�sTd}t �d |� |S t �d � d}|S ) z� Determine if a test contains: - a test name - a valid module and function - a valid assertion, or valid grouping under an assertions key - an expected return value - if assertion type requires it z Saltcheck: validating data: %sT�skipFr; N�saltcheck.state_apply� assertionsrw z#Saltcheck: %s is not a valid modulez%Saltcheck: %s is not a valid functionz&Saltcheck: missing module_and_function)r" rq r r� r| rv r� r{ )r rF r� r� Zm_and_fZassertion_grouprt rz r r r Z__is_valid_test� s. � �zSaltCheck.__is_valid_testc C s� dg}dg}|j ddd�d }td }tj�|�}|d } t�|�} ||vr.||vr.d | d< d } |rF|rFtjj| d �j |g|�R i |��} n0|rY|sYtjj| d �j |g|�R � } n |sl|rltjj| d �j |fi |��} n tjj| d �� |�} | td< | S ) z5 Generic call of salt Caller command zfile.check_managed_changesZcprw r, )�maxsplitr r r r Fr ) r| r r r r! r r r$ r% r& ) r Zfunr@ r Zremote_functionsZremote_modules�modr r( Zorig_file_clientZ mlocal_optsrU r r r �_call_salt_command� s& $ z SaltCheck._call_salt_commandc C s^ i }|� dd�}|� dt�} |rtjjj||d| d�}|dv r"d} n|d } |� d |� d d��} | d vr:| �| |�} | d krJd } | �| ||�|d< n�| dkrZd} | �| ||�|d< n�| dkrhd} | � |�|d< n�| dkrvd} | � |�|d< n|| dkr�d} | � | ||�|d< nl| dkr�d} | � | ||�|d< n\| dkr�d} | � | |�|d< nM| dkr�d } | �| |�|d< n>| d kr�d } | �| |�|d< n/| d kr�d } | �| |�|d< n | d!kr�d"} | �|�|d< n| dkr�d#} | �|�|d< nd$|d< |�r-|�rd%�d�} d&|� �}nd'} d'}d(�|t|�|�|d)| � �< d*�| du �r d'n| � d&�| |�s(d+n|�|d,< |S )-z- Run assertion against input �assertion_sectionN�assertion_section_delimiterF)�default� delimiter)r� r� r� r� r� )�assertIn� assertNotInr� r� r� r� Z assertEqualz==r^ ZassertNotEqualz!=r� zTrue isr� zFalse isr� �INr� zNOT INZ assertGreater�>ZassertGreaterEqualz>=Z assertLess�<ZassertLessEqualz<=r� zIS EMPTYz IS NOT EMPTYzFail - bad assertionz {}� � z{} {}{}zmodule.function [args]z{}{} {}Zhiddenzsaltcheck assertion)r r r r rX Ztraverse_dict_and_list� _cast_expected_to_returned_type�_SaltCheck__assert_equal� _SaltCheck__assert_not_equal�_SaltCheck__assert_true�_SaltCheck__assert_false�_SaltCheck__assert_in�_SaltCheck__assert_not_in�_SaltCheck__assert_greater� _SaltCheck__assert_greater_equal�_SaltCheck__assert_less� _SaltCheck__assert_less_equal�_SaltCheck__assert_empty� _SaltCheck__assert_not_empty�formatr )r � mod_and_funcr@ rX Z module_output�output_details�assert_print_resultrU r� r� r� r� Zassertion_descZ assertion_section_repr_titleZ assertion_section_repr_valuer r r �_run_assertions s� ��� � � � � � � � �zSaltCheck._run_assertionsc C s� i }t � � }td dd�}|�d|�}| �|�r�|�dd�}|r%ddd�S |d }|�d d �}|�d d �} |�d |�dd ��} | rJ| sEi } | | d< n| rR| �dd � |�dd�} | �||| �} |�d�r�t|�d�dd�D ]\} }| �|||| || �|d| � �< qmt� |�� � D ]%\}}|� d�r�|| � � D ]\}}|� d�r�|| | dkr�d|d< q�q�|�d�s�d|d< n|� | �|||| || �� nd|d< t � � }t || d�|d< |S ) z- Run a single saltcheck test r9 Zsaltcheck_output_detailsFr� r� re rc )r^ rf r; r@ Nr � pillar_dataz pillar-dataZpillarZ print_resultTr� r, )�startr� r^ rd r_ zFail - invalid testrl rf )�timer? r �_SaltCheck__is_valid_test�popr� � enumerater� r r rM r` ra rm )r rF rV r� Zglobal_output_detailsr� r� r� r@ r r� r� Z actual_return�numZ assert_group�k�vZassert_kZassert_v�endr r r r � sx � � �� � ��� zSaltCheck.run_testc C s� | }|durGt |�}| dkr|tkrd} z|| �}W |S tyF t�d� t�d|� t�dt |�� t�d| � t�dt | �� Y |S w |S ) zt Determine the type of variable returned Cast the expected to the type of variable returned N�FalseFz-Unable to cast expected into type of returnedz returned = %sztype of returned = %sz expected = %sztype of expected = %s)�typers � ValueErrorr" rq )�expected�returnedZ new_expectedZret_typer r r r� � s" � �z)SaltCheck._cast_expected_to_returned_typeTc C sp d}z |r| |ksJ d� | |���W |S | |ks J d��W |S ty7 } z dt|� }W Y d}~|S d}~ww )z/ Test if two objects are equal rd z{} is not equal to {}zResult is not equal�Fail: N�r� �AssertionError�str�r� r� r� rV �errr r r Z__assert_equal� s �����zSaltCheck.__assert_equalc C sp d}z |r| |ksJ d� | |���W |S | |ks J d��W |S ty7 } z dt|� }W Y d}~|S d}~ww )z3 Test if two objects are not equal rd z{} is equal to {}zResult is equalr� Nr� r� r r r Z__assert_not_equal� � �����z SaltCheck.__assert_not_equalc C sT d}z| du sJ | � d���W |S t y) } z dt|� }W Y d}~|S d}~ww )z, Test if an boolean is True rd Tz not Truer� N�r� r� �r� rV r� r r r Z __assert_true � ���zSaltCheck.__assert_truec C sf d}t | t�r t| �} z| du sJ | � d���W |S ty2 } z dt|� }W Y d}~|S d}~ww )z- Test if an boolean is False rd F� not Falser� N)r r� rs r� r� r r r Z__assert_false s ���zSaltCheck.__assert_falsec C sp d}z |r| |v sJ d� | |���W |S | |v s J d��W |S ty7 } z dt|� }W Y d}~|S d}~ww )zC Test if a value is in the list of returned values rd z{} not found in {}zResult not foundr� Nr� r� r r r Z __assert_in r� zSaltCheck.__assert_inc C sp d}z |r| |vsJ d� | |���W |S | |vs J d��W |S ty7 } z dt|� }W Y d}~|S d}~ww )zG Test if a value is not in the list of returned values rd z{} was found in {}zResult was foundr� Nr� r� r r r Z__assert_not_in. r� zSaltCheck.__assert_not_inc C sT d}z| |ksJ |� d���W |S t y) } z dt|� }W Y d}~|S d}~ww )zD Test if a value is greater than the returned value rd r� r� Nr� �r� r� rV r� r r r Z__assert_greater? r� zSaltCheck.__assert_greaterc C sT d}z| |ksJ |� d���W |S t y) } z dt|� }W Y d}~|S d}~ww )zP Test if a value is greater than or equal to the returned value rd r� r� Nr� r� r r r Z__assert_greater_equalK r� z SaltCheck.__assert_greater_equalc C sT d}z| |k sJ |� d���W |S t y) } z dt|� }W Y d}~|S d}~ww )zA Test if a value is less than the returned value rd r� r� Nr� r� r r r Z __assert_lessW r� zSaltCheck.__assert_lessc C sT d}z| |ksJ |� d���W |S t y) } z dt|� }W Y d}~|S d}~ww )zM Test if a value is less than or equal to the returned value rd r� r� Nr� r� r r r Z__assert_less_equalc r� z SaltCheck.__assert_less_equalc C sP d}z | r J | � d���W |S t y' } z dt|� }W Y d}~|S d}~ww )z3 Test if a returned value is empty rd z is not emptyr� Nr� r� r r r Z__assert_emptyo s ���zSaltCheck.__assert_emptyc C sJ d}z | s J d��W |S t y$ } z dt|� }W Y d}~|S d}~ww )z7 Test if a returned value is not empty rd zvalue is emptyr� Nr� r� r r r Z__assert_not_empty{ s ���z SaltCheck.__assert_not_emptyN�r+ )T)�__name__� __module__� __qualname__�__doc__r� r� r� r� r� r � staticmethodr� r� r� r� r� r� r� r� r� r� r� r� r� r r r r r � sD & sK r c @ sP e Zd ZdZddd�Zdd� Zdd� Zd d � Zd d � Ze d d� �Z ddd�Z dS )r0 zh Class loads in test files for a state e.g. state_dir/saltcheck-tests/[1.tst, 2.tst, 3.tst] r+ c C s6 d | _ t� | _t� | _|| _td dd�| _g | _d S )Nr9 �saltcheck_test_locationzsaltcheck-tests) � path_type�set� test_filesr rF r* r? r� r2 r~ r r r r� � s � zStateTestLoader.__init__c C s* t � | _| jD ]}| �|� qt� | _dS )zD Load tests either from one file, or a set of files N)r rF r� �_load_file_salt_renderedr� )r Zmyfiler r r rA � s z StateTestLoader.load_test_suitec C s8 t |�}tt|�td�}|�� D ] \}}|| j|< qdS )z( loads in one test file )�object_pairs_hookN)rr r r r rM rF )r �filepathZtestsZmydictrT rU r r r r� � s z(StateTestLoader._load_file_salt_renderedc C s� g }|| j vr7t�d|� td || jdd�}|r5|r)t�d|� | j�|� |S t�d|� | j �|� |S t�d| j � |S )z� Copy tst files for a given path and return results of the copy. If check_all is enabled, also add all tests found z looking in %s to cache testsz cp.cache_dirz*.tst)r* Z include_patz Adding all found test files: %szMarking found_state: %sz#Not copying already found_state: %s)r2 r" r# r? r* r� ra r3 )r �sls_pathr' rP Z cache_retr r r �_copy_state_files� s � � �z!StateTestLoader._copy_state_filesc C s� g }d� |�dd�| j�}|�|� |�d�}|�� d� d�|�| j�}|�|� |�d�d }d|� d| j� �}|�|� t|�}tt |t dd��S )a� For a given state_name, return list of paths to search for .tst files possible formula paths are then path/to/formula.sls with tests of path/to/saltcheck-tests/formula.tst path/to/formula/init.sls with tests of path/to/formula/saltcheck-tests/init.tst or if a custom saltcheck_test_location is used path/to/forumla.sls with tests of path/saltcheck_test_location/init.tst z salt://{}/{}rw �/r zsalt://T)rT �reverse) r� �replacer� r3 r| r� r[ r� �listrh rJ )r r' Z all_sls_pathsZ test_pathZ sls_splitZstate_name_baseZ unique_pathsr r r �_generate_sls_path� s � � z"StateTestLoader._generate_sls_pathc C s t d | jd�S )z@ Returns (cached) list of states for the minion zcp.list_statesrp )r? r* )r r r r � _get_states� s zStateTestLoader._get_statesFc C s� d}dt �dd�v rBd}t�d|� tj�t d d| jd�}tj j � |d ��}t tj j �|�� ��}W d � n1 s<w Y n| �� }g }g }|r�t�d � tj�t d d| j|d �} z(tj j � | d ��}|�t tj j �|�� ��� W d � n1 s�w Y W nK ty� |�d �} d �| d d� �} tj�t d d| j| d �} tj j � | d ��}|�t tj j �|�� ��� W d � n1 s�w Y Y nw ||v �r!|�rt�d|d � tj�t d d| j|d �} tj j � | d ��}t tj j �|�� ��}W d � n 1 �sw Y ntd || jdd�}nd|ig}|D ]�} t| t��s9t�d| � d S d }d| v �r�| d }| �|�D ]}| �|||�}|�r`t�d|� |�|� �qI|�ru|�rudd� |D �}| j�|� |�s�| d �d �}tj�tj �|�tj� | j �d�tj�tj �|d t |�d � �tj� | j �|d � d��tj�|d tj� | j �tj �|dd� �|d � d��h}t t!|��}|D ] }|�"t#|���r�| j�$|� |�%|� t�d|� �qҐq(d S ) zQ Detects states used, caches needed files, and adds to test list Fr r Tz+Running on salt-ssh minion. Reading file %sZcachedir�filesz cp_output.txt�rNz8Running on salt-ssh minion. Populating test file resultsz.copyrw ���z.lowzstate.show_low_sls)r* r Z__sls__z6low data from show_low_sls is not formed as a dict: %szfound tests: %sc S s g | ] }|� d �r|�qS )�.tst)�endswith)r� Z file_stringr r r � <listcomp>G s ��z:StateTestLoader.add_test_files_for_sls.<locals>.<listcomp>zinit.tstr, r� r zAdding .tst file: %s)&r r r" r# �os�pathr[ r* r r r� Zfopenr Z stringutilsZ to_unicode�readr� �extend�OSErrorr| r? r r r� r� r� r� ra �sep�normpathr� rJ r� r� r� �tuple�add�remove)r Zsls_namerP Zsalt_sshZcp_output_file�fpr\ �retZcached_copied_filesZstate_copy_fileZ sls_name_listZ sls_root_nameZstate_low_fileZlow_dataZthis_cache_retr' r� Z tst_filesZ split_slsZsls_path_namesZthis_cached_test_filer r r r1 � s� � �� �� �� �� ��� �� ��� � � �� � � �� ��z&StateTestLoader.add_test_files_for_slsNr� �F) r� r� r� r� r� rA r� r� r� r r� r1 r r r r r0 � s * r0 rg )NFF)NFr� r� )1r� r �loggingrD r� r� � collectionsr Z salt.clientr Zsalt.exceptionsZsalt.utils.dataZsalt.utils.filesZsalt.utils.functoolsZsalt.utils.pathZsalt.utils.platformZsalt.utils.yamlZ salt.defaultsr Zsalt.utils.decoratorsr Zsalt.utils.jsonr r � getLoggerr� r" r4 � NameErrorr r r r) r8 rW rL r � functoolsZalias_functionrY r] rb rN rr rv r{ r/ r r0 r r r r �<module> sf - � 'W � ) t
| ver. 1.4 |
Github
|
.
| PHP 8.2.30 | Generation time: 0 |
proxy
|
phpinfo
|
Settings