saltstack/salt
1
0
Fork 0
mirror of https://github.com/saltstack/salt.git synced 2025-04-17 10:10:20 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

Migrate tests/integration/modules/test_state_jinja_filters.py to functional

Browse source 
Signed-off-by: Pedro Algarvio <palgarvio@vmware.com>
This commit is contained in:
Pedro Algarvio 2022-08-24 14:59:41 +01:00 • committed by Gareth J. Greenaway
parent 4ebb9c41d4
commit b767b52b16
76 changed files with 948 additions and 946 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
tests/filename_map.yml
View file

@ -166,7 +166,7 @@ salt/proxy/*:
- pytests.integration.proxy.test_simple
salt/state.py:
- integration.modules.test_state_jinja_filters
- pytests.functional.modules.state.test_jinja_filters
- integration.states.test_compiler
- integration.states.test_handle_error
- integration.states.test_handle_iorder
@ -177,7 +177,7 @@ salt/utils/decorators/*:
- integration.modules.test_decorators
salt/(utils|renderers)/jinja\.py:
- integration.modules.test_state_jinja_filters
- pytests.functional.modules.state.test_jinja_filters
- integration.states.test_renderers
salt/utils/minions.py:

4
tests/integration/files/file/base/jinja_filters/common.sls
View file

@ -1,4 +0,0 @@
test:
module.run:
- name: test.echo
- text: {{ result }}

4
tests/integration/files/file/base/jinja_filters/common_quotes.sls
View file

@ -1,4 +0,0 @@
test:
module.run:
- name: test.echo
- text: "{{ result }}"

6
tests/integration/files/file/base/jinja_filters/data_compare_dicts.sls
View file

@ -1,6 +0,0 @@
{% set dict_one = {'a': 'b', 'c': 'd'} %}
{% set dict_two = {'a': 'c', 'c': 'd'} %}
{% set result = dict_one | compare_dicts(dict_two) %}
{% include 'jinja_filters/tojson.sls' %}

6
tests/integration/files/file/base/jinja_filters/data_compare_lists.sls
View file

@ -1,6 +0,0 @@
{% set list_one = ['a', 'b', 'c', 'd'] %}
{% set list_two = ['a', 'c', 'd'] %}
{% set result = list_one | compare_lists(list_two) %}
{% include 'jinja_filters/tojson.sls' %}

5
tests/integration/files/file/base/jinja_filters/data_decode_dict.sls
View file

@ -1,5 +0,0 @@
{% set dict_one = {'a': 'b', 'c': 'd'} %}
{% set result = dict_one | json_decode_dict() %}
{% include 'jinja_filters/common.sls' %}

5
tests/integration/files/file/base/jinja_filters/data_decode_list.sls
View file

@ -1,5 +0,0 @@
{% set list_one = ['a', 'b', 'c', 'd'] %}
{% set result = list_one | json_decode_list() %}
{% include 'jinja_filters/common.sls' %}

5
tests/integration/files/file/base/jinja_filters/data_encode_dict.sls
View file

@ -1,5 +0,0 @@
{% set dict_one = {'a': 'b', 'c': 'd'} %}
{% set result = dict_one | json_encode_dict() %}
{% include 'jinja_filters/common.sls' %}

5
tests/integration/files/file/base/jinja_filters/data_encode_list.sls
View file

@ -1,5 +0,0 @@
{% set list_one = ['a', 'b', 'c', 'd'] %}
{% set result = list_one | json_encode_list() %}
{% include 'jinja_filters/common.sls' %}

5
tests/integration/files/file/base/jinja_filters/data_exactly_n.sls
View file

@ -1,5 +0,0 @@
{% set list = [True, False, False, True] %}
{% set result = list | exactly_n_true(2) %}
{% include 'jinja_filters/common.sls' %}

5
tests/integration/files/file/base/jinja_filters/data_exactly_one.sls
View file

@ -1,5 +0,0 @@
{% set list = [True, False, False, False] %}
{% set result = list | exactly_one_true() %}
{% include 'jinja_filters/common.sls' %}

5
tests/integration/files/file/base/jinja_filters/data_is_iter.sls
View file

@ -1,5 +0,0 @@
{% set list = ['abcd','efgh','ijk','lmno','pqrs'] %}
{% set result = list | is_iter() %}
{% include 'jinja_filters/common.sls' %}

5
tests/integration/files/file/base/jinja_filters/data_is_list.sls
View file

@ -1,5 +0,0 @@
{% set list = ['abcd','efgh','ijk','lmno','pqrs'] %}
{% set result = list | is_list() %}
{% include 'jinja_filters/common.sls' %}

9
tests/integration/files/file/base/jinja_filters/data_mysql_to_dict.sls
View file

@ -1,9 +0,0 @@
{% set test_mysql_output = ['+----+------+-----------+------+---------+------+-------+------------------+',
'| Id | User | Host | db | Command | Time | State | Info |',
'+----+------+-----------+------+---------+------+-------+------------------+',
'| 7 | root | localhost | NULL | Query | 0 | init | show processlist |',
'+----+------+-----------+------+---------+------+-------+------------------+'] %}
{% set result = test_mysql_output | mysql_to_dict('Info') %}
{% include 'jinja_filters/tojson.sls' %}

5
tests/integration/files/file/base/jinja_filters/data_sorted_ignorecase.sls
View file

@ -1,5 +0,0 @@
{% set list = ['lmno','efgh','Ijk','Pqrs','Abcd'] %}
{% set result = list | sorted_ignorecase() %}
{% include 'jinja_filters/common.sls' %}

6
tests/integration/files/file/base/jinja_filters/data_substring_in_list.sls
View file

@ -1,6 +0,0 @@
{% set string = 'lmno' %}
{% set list = ['abcd','efgh','ijk','lmno','pqrs'] %}
{% set result = string | substring_in_list(list) %}
{% include 'jinja_filters/common.sls' %}

3
tests/integration/files/file/base/jinja_filters/dateutils_strftime.sls
View file

@ -1,3 +0,0 @@
{% set result = none | strftime('%Y-%m-%d') %}
{% include 'jinja_filters/common.sls' %}

7
tests/integration/files/file/base/jinja_filters/files_is_binary.sls
View file

@ -1,7 +0,0 @@
{% if grains['os'] == 'Windows' %}
{% set result = 'c:\Windows\System32\cmd.exe' | is_bin_file() %}
{% else %}
{% set result = '/bin/ls' | is_bin_file() %}
{% endif %}
{% include 'jinja_filters/common.sls' %}

7
tests/integration/files/file/base/jinja_filters/files_is_empty.sls
View file

@ -1,7 +0,0 @@
{% if grains['os'] == 'Windows' %}
{% set result = 'c:\\empty_file' | is_empty() %}
{% else %}
{% set result = '/dev/null' | is_empty() %}
{% endif %}
{% include 'jinja_filters/common.sls' %}

7
tests/integration/files/file/base/jinja_filters/files_is_text.sls
View file

@ -1,7 +0,0 @@
{% if grains['os'] == 'Windows' %}
{% set result = 'c:\Windows\system.ini' | is_text_file() %}
{% else %}
{% set result = '/etc/passwd' | is_text_file() %}
{% endif %}
{% include 'jinja_filters/common.sls' %}

7
tests/integration/files/file/base/jinja_filters/files_list_files.sls
View file

@ -1,7 +0,0 @@
{% if grains['os'] == 'Windows' %}
{% set result = 'c:\salt\conf' | list_files() %}
{% else %}
{% set result = '/bin' | list_files() %}
{% endif %}
{% include 'jinja_filters/common.sls' %}

3
tests/integration/files/file/base/jinja_filters/hashutils_base4_64decode.sls
View file

@ -1,3 +0,0 @@
{% set result = 'U2FsdCBSb2NrcyE=' | base64_decode() %}
{% include 'jinja_filters/common.sls' %}

3
tests/integration/files/file/base/jinja_filters/hashutils_base4_64encode.sls
View file

@ -1,3 +0,0 @@
{% set result = 'Salt Rocks!' | base64_encode() %}
{% include 'jinja_filters/common.sls' %}

7
tests/integration/files/file/base/jinja_filters/hashutils_file_hashsum.sls
View file

@ -1,7 +0,0 @@
{% if grains['os'] == 'windows' %}
{% set result = 'c:\\Windows\\system.ini' | is_text_file() %}
{% else %}
{% set result = '/etc/passwd' | is_text_file() %}
{% endif %}
{% include 'jinja_filters/common.sls' %}

3
tests/integration/files/file/base/jinja_filters/hashutils_hmac.sls
View file

@ -1,3 +0,0 @@
{% set result = 'Salt Rocks!' | hmac(shared_secret='topsecret', challenge_hmac='nMgLxwHPFyRgGfunkXXAI3Z/ZR4p5lmPTUjk2eGDqks=') %}
{% include 'jinja_filters/common.sls' %}

3
tests/integration/files/file/base/jinja_filters/hashutils_md5_digest.sls
View file

@ -1,3 +0,0 @@
{% set result = 'Salt Rocks!' | md5() %}
{% include 'jinja_filters/common.sls' %}

3
tests/integration/files/file/base/jinja_filters/hashutils_random_hash.sls
View file

@ -1,3 +0,0 @@
{% set result = 9999999999 | random_hash() %}
{% include 'jinja_filters/common.sls' %}

3
tests/integration/files/file/base/jinja_filters/hashutils_sha256_digest.sls
View file

@ -1,3 +0,0 @@
{% set result = 'Salt Rocks!' | sha256() %}
{% include 'jinja_filters/common.sls' %}

3
tests/integration/files/file/base/jinja_filters/hashutils_sha512_digest.sls
View file

@ -1,3 +0,0 @@
{% set result = 'Salt Rocks!' | sha512() %}
{% include 'jinja_filters/common.sls' %}

3
tests/integration/files/file/base/jinja_filters/http_query.sls
View file

@ -1,3 +0,0 @@
{% set result = 'https://www.google.com' | http_query(test=True) %}
{% include 'jinja_filters/common.sls' %}

3
tests/integration/files/file/base/jinja_filters/jinja_avg.sls
View file

@ -1,3 +0,0 @@
{% set result = [1, 2, 3, 4] | avg() %}
{% include 'jinja_filters/common.sls' %}

3
tests/integration/files/file/base/jinja_filters/jinja_difference.sls
View file

@ -1,3 +0,0 @@
{% set result = [1, 2, 3, 4] | difference([2, 4, 6]) %}
{% include 'jinja_filters/common.sls' %}

3
tests/integration/files/file/base/jinja_filters/jinja_intersect.sls
View file

@ -1,3 +0,0 @@
{% set result = [1, 2, 3, 4] | intersect([2, 4, 6]) %}
{% include 'jinja_filters/common.sls' %}

3
tests/integration/files/file/base/jinja_filters/jinja_max.sls
View file

@ -1,3 +0,0 @@
{% set result = [1, 2, 3, 4] | max() %}
{% include 'jinja_filters/common.sls' %}

3
tests/integration/files/file/base/jinja_filters/jinja_min.sls
View file

@ -1,3 +0,0 @@
{% set result = [1, 2, 3, 4] | min() %}
{% include 'jinja_filters/common.sls' %}

3
tests/integration/files/file/base/jinja_filters/jinja_quote.sls
View file

@ -1,3 +0,0 @@
{% set result = 'Salt Rocks!' | quote() %}
{% include 'jinja_filters/common.sls' %}

3
tests/integration/files/file/base/jinja_filters/jinja_regex_escape.sls
View file

@ -1,3 +0,0 @@
{% set result = 'Salt Rocks' | regex_escape() %}
{% include 'jinja_filters/common.sls' %}

3
tests/integration/files/file/base/jinja_filters/jinja_regex_match.sls
View file

@ -1,3 +0,0 @@
{% set result = 'abcd' | regex_match('^(.*)BC(.*)$', ignorecase=True) %}
{% include 'jinja_filters/common.sls' %}

3
tests/integration/files/file/base/jinja_filters/jinja_regex_replace.sls
View file

@ -1,3 +0,0 @@
{% set result = 'lets replace spaces' | regex_replace('\s+', '__') %}
{% include 'jinja_filters/common.sls' %}

3
tests/integration/files/file/base/jinja_filters/jinja_regex_search.sls
View file

@ -1,3 +0,0 @@
{% set result = 'abcd' | regex_search('^(.*)BC(.*)$', ignorecase=True) %}
{% include 'jinja_filters/common.sls' %}

3
tests/integration/files/file/base/jinja_filters/jinja_sequence.sls
View file

@ -1,3 +0,0 @@
{% set result = 'Salt Rocks!' | sequence() %}
{% include 'jinja_filters/common.sls' %}

3
tests/integration/files/file/base/jinja_filters/jinja_skip.sls
View file

@ -1,3 +0,0 @@
{% set result = 'Salt Rocks!' | skip() %}
{% include 'jinja_filters/common.sls' %}

3
tests/integration/files/file/base/jinja_filters/jinja_symmetric_difference.sls
View file

@ -1,3 +0,0 @@
{% set result = [1, 2, 3, 4] | symmetric_difference([2, 4, 6]) %}
{% include 'jinja_filters/common.sls' %}

3
tests/integration/files/file/base/jinja_filters/jinja_to_bool.sls
View file

@ -1,3 +0,0 @@
{% set result = 'yes' | to_bool() %}
{% include 'jinja_filters/common.sls' %}

3
tests/integration/files/file/base/jinja_filters/jinja_union.sls
View file

@ -1,3 +0,0 @@
{% set result = [1, 2, 3, 4] | union([2, 4, 6]) %}
{% include 'jinja_filters/common.sls' %}

3
tests/integration/files/file/base/jinja_filters/jinja_unique.sls
View file

@ -1,3 +0,0 @@
{% set result = ['a', 'b', 'c', 'a', 'b'] | unique() %}
{% include 'jinja_filters/common.sls' %}

3
tests/integration/files/file/base/jinja_filters/jinja_uuid.sls
View file

@ -1,3 +0,0 @@
{% set result = 'Salt Rocks!' | uuid() %}
{% include 'jinja_filters/common.sls' %}

6
tests/integration/files/file/base/jinja_filters/json.sls
View file

@ -1,6 +0,0 @@
{% set result = {"Question": "Quieres Café?"} %}
test:
module.run:
- name: test.echo
- text: '{{ result | json }}'

3
tests/integration/files/file/base/jinja_filters/network_gen_mac.sls
View file

@ -1,3 +0,0 @@
{% set result = 'AC:DE:48' | gen_mac() %}
{% include 'jinja_filters/common.sls' %}

3
tests/integration/files/file/base/jinja_filters/network_ip_host.sls
View file

@ -1,3 +0,0 @@
{% set result = '192.168.0.12/24' | ip_host() %}
{% include 'jinja_filters/common.sls' %}

3
tests/integration/files/file/base/jinja_filters/network_ipaddr.sls
View file

@ -1,3 +0,0 @@
{% set result = ['127.0.0.1', '::1', 'random_junk'] | ipaddr() %}
{% include 'jinja_filters/common_quotes.sls' %}

3
tests/integration/files/file/base/jinja_filters/network_ipv4.sls
View file

@ -1,3 +0,0 @@
{% set result = ['127.0.0.1', '::1'] | ipv4() %}
{% include 'jinja_filters/tojson.sls' %}

3
tests/integration/files/file/base/jinja_filters/network_ipv6.sls
View file

@ -1,3 +0,0 @@
{% set result = ['127.0.0.1', '::1'] | ipv6() %}
{% include 'jinja_filters/common_quotes.sls' %}

3
tests/integration/files/file/base/jinja_filters/network_is_ip.sls
View file

@ -1,3 +0,0 @@
{% set result = '127.0.0.1' | is_ip() %}
{% include 'jinja_filters/common.sls' %}

3
tests/integration/files/file/base/jinja_filters/network_is_ipv4.sls
View file

@ -1,3 +0,0 @@
{% set result = '127.0.0.1' | is_ipv4() %}
{% include 'jinja_filters/common.sls' %}

3
tests/integration/files/file/base/jinja_filters/network_is_ipv6.sls
View file

@ -1,3 +0,0 @@
{% set result = '::1' | is_ipv6() %}
{% include 'jinja_filters/common.sls' %}

3
tests/integration/files/file/base/jinja_filters/network_network_hosts.sls
View file

@ -1,3 +0,0 @@
{% set result = '192.168.1.0/30' | network_hosts() %}
{% include 'jinja_filters/tojson.sls' %}

3
tests/integration/files/file/base/jinja_filters/network_network_size.sls
View file

@ -1,3 +0,0 @@
{% set result = '192.168.1.0/28' | network_size() %}
{% include 'jinja_filters/common.sls' %}

3
tests/integration/files/file/base/jinja_filters/path_join.sls
View file

@ -1,3 +0,0 @@
{% set result = '/a/b/c' | path_join('d') %}
{% include 'jinja_filters/common.sls' %}

3
tests/integration/files/file/base/jinja_filters/path_which.sls
View file

@ -1,3 +0,0 @@
{% set result = 'which' | which() %}
{% include 'jinja_filters/common.sls' %}

3
tests/integration/files/file/base/jinja_filters/stringutils_contains_whitespace.sls
View file

@ -1,3 +0,0 @@
{% set result = 'This string has whitespace' | contains_whitespace() %}
{% include 'jinja_filters/common.sls' %}

3
tests/integration/files/file/base/jinja_filters/stringutils_is_hex.sls
View file

@ -1,3 +0,0 @@
{% set result = '0x2a' | is_hex() %}
{% include 'jinja_filters/common.sls' %}

3
tests/integration/files/file/base/jinja_filters/stringutils_random_str.sls
View file

@ -1,3 +0,0 @@
{% set result = 32 | random_str() %}
{% include 'jinja_filters/common.sls' %}

3
tests/integration/files/file/base/jinja_filters/stringutils_to_bytes.sls
View file

@ -1,3 +0,0 @@
{% set result = 'Salt Rocks!' | to_bytes() %}
{% include 'jinja_filters/common.sls' %}

3
tests/integration/files/file/base/jinja_filters/stringutils_to_num.sls
View file

@ -1,3 +0,0 @@
{% set result = '42' | to_num() %}
{% include 'jinja_filters/common.sls' %}

3
tests/integration/files/file/base/jinja_filters/stringutils_whitelist_blacklist.sls
View file

@ -1,3 +0,0 @@
{% set result = 'string' | check_whitelist_blacklist(whitelist='string') %}
{% include 'jinja_filters/common.sls' %}

4
tests/integration/files/file/base/jinja_filters/tojson.sls
View file

@ -1,4 +0,0 @@
test:
module.run:
- name: test.echo
- text: {{ result|tojson }}

3
tests/integration/files/file/base/jinja_filters/user_get_uid.sls
View file

@ -1,3 +0,0 @@
{% set result = 'root' | get_uid() %}
{% include 'jinja_filters/common.sls' %}

6
tests/integration/files/file/base/jinja_filters/yaml.sls
View file

@ -1,6 +0,0 @@
{% set result = {"Question": "Quieres Café?"} %}
test:
module.run:
- name: test.echo
- text: "{{ result | yaml }}"

3
tests/integration/files/file/base/jinja_filters/yamlencoding_yaml_dquote.sls
View file

@ -1,3 +0,0 @@
{% set result = "A double-quoted string in YAML" | yaml_dquote() %}
{% include 'jinja_filters/common.sls' %}

3
tests/integration/files/file/base/jinja_filters/yamlencoding_yaml_encode.sls
View file

@ -1,3 +0,0 @@
{% set result = "An encoded string in YAML" | yaml_encode() %}
{% include 'jinja_filters/common.sls' %}

3
tests/integration/files/file/base/jinja_filters/yamlencoding_yaml_squote.sls
View file

@ -1,3 +0,0 @@
{% set result = "A single-quoted string in YAML" | yaml_squote() %}
{% include 'jinja_filters/common.sls' %}

8
tests/integration/modules/test_state_jinja_filters.py
View file

@ -1,8 +0,0 @@
from tests.support.case import ModuleCase
from tests.support.jinja_filters import JinjaFiltersTest
class StateModuleJinjaFiltersTest(ModuleCase, JinjaFiltersTest):
"""
testing Jinja filters are available via state system
"""

946
tests/pytests/functional/modules/state/test_jinja_filters.py Normal file
View file

@ -0,0 +1,946 @@
"""
Testing Jinja filters availablilty via state system
"""
import logging
import os
import attr
import pytest
import salt.utils.files
import salt.utils.path
log = logging.getLogger(__name__)
@attr.s
class Filter:
name = attr.ib()
sls = attr.ib()
expected = attr.ib(default=None)
_exits = attr.ib(init=False, repr=False, factory=list)
def check_skip(self, grains):
pass
def assert_result(self, changes):
__tracebackhide__ = True
assert changes
if self.expected:
if callable(self.expected):
assert self.expected(changes)
else:
assert changes == self.expected
def __call__(self, state_tree):
self.state_tree = state_tree
return self
def __enter__(self):
filter_sls = pytest.helpers.temp_file("filter.sls", self.sls, self.state_tree)
filter_sls.__enter__()
self._exits.append(filter_sls)
return self
def __exit__(self, *_):
for exit_callback in self._exits:
exit_callback.__exit__(*_)
@attr.s
class SkipOnWindowsFilter(Filter):
def check_skip(self, grains):
if grains["os"] == "Windows":
pytest.skip("Skipped on windows")
@attr.s
class StartsWithFilter(Filter):
def assert_result(self, changes):
__tracebackhide__ = True
assert changes
assert changes["ret"]
assert changes["ret"].startswith(self.expected)
@attr.s
class SortedFilter(Filter):
def assert_result(self, changes):
__tracebackhide__ = True
assert changes
assert changes["ret"]
assert sorted(changes["ret"]) == sorted(self.expected["ret"])
@attr.s
class EmptyFileFilter(Filter):
name = attr.ib(default="is_empty")
sls = attr.ib(
default="""
{% set result = 'FPATH' | is_empty() %}
test:
module.run:
- name: test.echo
- text: {{ result }}
"""
)
def __enter__(self):
empty_file = pytest.helpers.temp_file("empty-file", "", self.state_tree)
fpath = empty_file.__enter__()
self._exits.append(empty_file)
self.sls = self.sls.replace("FPATH", str(fpath))
return super().__enter__()
@attr.s
class TextFileFilter(Filter):
name = attr.ib(default="is_text_file")
sls = attr.ib(
default="""
{% set result = 'FPATH' | is_text_file() %}
test:
module.run:
- name: test.echo
- text: {{ result }}
"""
)
def __enter__(self):
text_file = pytest.helpers.temp_file(
"text-file", "This is a text file", self.state_tree
)
fpath = text_file.__enter__()
self._exits.append(text_file)
self.sls = self.sls.replace("FPATH", str(fpath))
return super().__enter__()
@attr.s
class ListFilesFilter(SortedFilter):
name = attr.ib(default="list_files")
sls = attr.ib(
default="""
{% set result = 'FPATH' | list_files() %}
test:
module.run:
- name: test.echo
- text: {{ result }}
"""
)
def __enter__(self):
text_file = pytest.helpers.temp_file(
"foo/text-file", "This is a text file", self.state_tree
)
fpath = text_file.__enter__()
self._exits.append(text_file)
self.sls = self.sls.replace("FPATH", str(self.state_tree / "foo"))
self.expected = {"ret": [str(self.state_tree / "foo"), str(fpath)]}
return super().__enter__()
@attr.s
class FileHashsumFilter(Filter):
name = attr.ib(default="file_hashsum")
expected = attr.ib(
default={
"ret": "bfae4a86e38196ebccd4b9ef32454ff4271afa4ad539106de37d318591533873"
}
)
sls = attr.ib(
default="""
{% set result = 'FPATH' | file_hashsum() %}
test:
module.run:
- name: test.echo
- text: {{ result }}
"""
)
def __enter__(self):
text_file = pytest.helpers.temp_file(
"text-file", "This is a text file", self.state_tree
)
fpath = text_file.__enter__()
self._exits.append(text_file)
self.sls = self.sls.replace("FPATH", str(fpath))
return super().__enter__()
def _filter_id(value):
return value.name
@pytest.fixture(
params=[
Filter(
name="compare_dicts",
expected={"ret": {"a": {"new": "c", "old": "b"}}},
sls="""
{% set dict_one = {'a': 'b', 'c': 'd'} %}
{% set dict_two = {'a': 'c', 'c': 'd'} %}
{% set result = dict_one | compare_dicts(dict_two) %}
test:
module.run:
- name: test.echo
- text: {{ result|tojson }}
""",
),
Filter(
name="compare_lists",
expected={"ret": {"old": ["b"]}},
sls="""
{% set list_one = ['a', 'b', 'c', 'd'] %}
{% set list_two = ['a', 'c', 'd'] %}
{% set result = list_one | compare_lists(list_two) %}
test:
module.run:
- name: test.echo
- text: {{ result|tojson }}
""",
),
Filter(
name="json_decode_dict",
expected={"ret": {"b'a'": "b'b'", "b'c'": "b'd'"}},
sls="""
{% set dict_one = {'a': 'b', 'c': 'd'} %}
{% set result = dict_one | json_decode_dict() %}
test:
module.run:
- name: test.echo
- text: {{ result }}
""",
),
Filter(
name="json_decode_list",
expected={"ret": ["b'a'", "b'b'", "b'c'", "b'd'"]},
sls="""
{% set list_one = ['a', 'b', 'c', 'd'] %}
{% set result = list_one | json_decode_list() %}
test:
module.run:
- name: test.echo
- text: {{ result }}
""",
),
Filter(
name="json_encode_dict",
expected={"ret": {"b'a'": "b'b'", "b'c'": "b'd'"}},
sls="""
{% set dict_one = {'a': 'b', 'c': 'd'} %}
{% set result = dict_one | json_encode_dict() %}
test:
module.run:
- name: test.echo
- text: {{ result }}
""",
),
Filter(
name="json_encode_list",
expected={"ret": ["b'a'", "b'b'", "b'c'", "b'd'"]},
sls="""
{% set list_one = ['a', 'b', 'c', 'd'] %}
{% set result = list_one | json_encode_list() %}
test:
module.run:
- name: test.echo
- text: {{ result }}
""",
),
Filter(
name="exactly_n_true",
expected={"ret": True},
sls="""
{% set list = [True, False, False, True] %}
{% set result = list | exactly_n_true(2) %}
test:
module.run:
- name: test.echo
- text: {{ result }}
""",
),
Filter(
name="exactly_one_true",
expected={"ret": True},
sls="""
{% set list = [True, False, False, False] %}
{% set result = list | exactly_one_true() %}
test:
module.run:
- name: test.echo
- text: {{ result }}
""",
),
Filter(
name="is_iter",
expected={"ret": True},
sls="""
{% set list = ['abcd','efgh','ijk','lmno','pqrs'] %}
{% set result = list | is_iter() %}
test:
module.run:
- name: test.echo
- text: {{ result }}
""",
),
Filter(
name="is_list",
expected={"ret": True},
sls="""
{% set list = ['abcd','efgh','ijk','lmno','pqrs'] %}
{% set result = list | is_list() %}
test:
module.run:
- name: test.echo
- text: {{ result }}
""",
),
Filter(
name="mysql_to_dict",
expected={
"ret": {
"show processlist": {
"Info": "show processlist",
"db": "NULL",
"Host": "localhost",
"State": "init",
"Command": "Query",
"User": "root",
"Time": 0,
"Id": 7,
}
}
},
sls="""
{% set test_mysql_output = ['+----+------+-----------+------+---------+------+-------+------------------+',
'| Id | User | Host | db | Command | Time | State | Info |',
'+----+------+-----------+------+---------+------+-------+------------------+',
'| 7 | root | localhost | NULL | Query | 0 | init | show processlist |',
'+----+------+-----------+------+---------+------+-------+------------------+'] %}
{% set result = test_mysql_output | mysql_to_dict('Info') %}
test:
module.run:
- name: test.echo
- text: {{ result|tojson }}
""",
),
Filter(
name="sorted_ignorecase",
expected={"ret": ["Abcd", "efgh", "Ijk", "lmno", "Pqrs"]},
sls="""
{% set list = ['lmno','efgh','Ijk','Pqrs','Abcd'] %}
{% set result = list | sorted_ignorecase() %}
test:
module.run:
- name: test.echo
- text: {{ result }}
""",
),
Filter(
name="substring_in_list",
expected={"ret": True},
sls="""
{% set string = 'lmno' %}
{% set list = ['abcd','efgh','ijk','lmno','pqrs'] %}
{% set result = string | substring_in_list(list) %}
test:
module.run:
- name: test.echo
- text: {{ result }}
""",
),
Filter(
name="strftime",
sls="""
{% set result = none | strftime('%Y-%m-%d') %}
test:
module.run:
- name: test.echo
- text: {{ result }}
""",
),
Filter(
name="is_bin_file",
expected={"ret": True},
sls=r"""
{% if grains['os'] == 'Windows' %}
{% set result = 'c:\Windows\System32\cmd.exe' | is_bin_file() %}
{% else %}
{% set result = '/bin/ls' | is_bin_file() %}
{% endif %}
test:
module.run:
- name: test.echo
- text: {{ result }}
""",
),
Filter(
name="base64_decode",
expected={"ret": "Salt Rocks!"},
sls="""
{% set result = 'U2FsdCBSb2NrcyE=' | base64_decode() %}
test:
module.run:
- name: test.echo
- text: {{ result }}
""",
),
Filter(
name="base64_encode",
expected={"ret": "U2FsdCBSb2NrcyE="},
sls="""
{% set result = 'Salt Rocks!' | base64_encode() %}
test:
module.run:
- name: test.echo
- text: {{ result }}
""",
),
EmptyFileFilter(),
TextFileFilter(),
ListFilesFilter(),
FileHashsumFilter(),
Filter(
name="hmac",
expected={"ret": True},
sls="""
{% set result = 'Salt Rocks!' | hmac(shared_secret='topsecret', challenge_hmac='nMgLxwHPFyRgGfunkXXAI3Z/ZR4p5lmPTUjk2eGDqks=') %}
test:
module.run:
- name: test.echo
- text: {{ result }}
""",
),
Filter(
name="md5",
expected={"ret": "85d6e71db655ee8e42c8b18475f0925f"},
sls="""
{% set result = 'Salt Rocks!' | md5() %}
test:
module.run:
- name: test.echo
- text: {{ result }}
""",
),
Filter(
name="random_hash",
sls="""
{% set result = 9999999999 | random_hash() %}
test:
module.run:
- name: test.echo
- text: {{ result }}
""",
),
Filter(
name="sha256",
expected={
"ret": "cce7fe00fd9cc6122fd3b2ed22feae215bcfe7ac4a7879d336c1993426a763fe"
},
sls="""
{% set result = 'Salt Rocks!' | sha256() %}
test:
module.run:
- name: test.echo
- text: {{ result }}
""",
),
Filter(
name="sha512",
expected={
"ret": "44d829491d8caa7039ad08a5b7fa9dd0f930138c614411c5326dd4755fdc9877ec6148219fccbe404139e7bb850e77237429d64f560c204f3697ab489fd8bfa5"
},
sls="""
{% set result = 'Salt Rocks!' | sha512() %}
test:
module.run:
- name: test.echo
- text: {{ result }}
""",
),
Filter(
name="http_query",
expected={"ret": {}},
sls="""
{% set result = 'https://www.google.com' | http_query(test=True) %}
test:
module.run:
- name: test.echo
- text: {{ result }}
""",
),
Filter(
name="avg",
expected={"ret": 2.5},
sls="""
{% set result = [1, 2, 3, 4] | avg() %}
test:
module.run:
- name: test.echo
- text: {{ result }}
""",
),
Filter(
name="difference",
expected={"ret": [1, 3]},
sls="""
{% set result = [1, 2, 3, 4] | difference([2, 4, 6]) %}
test:
module.run:
- name: test.echo
- text: {{ result }}
""",
),
Filter(
name="intersect",
expected={"ret": [2, 4]},
sls="""
{% set result = [1, 2, 3, 4] | intersect([2, 4, 6]) %}
test:
module.run:
- name: test.echo
- text: {{ result }}
""",
),
Filter(
name="max",
expected={"ret": 4},
sls="""
{% set result = [1, 2, 3, 4] | max() %}
test:
module.run:
- name: test.echo
- text: {{ result }}
""",
),
Filter(
name="min",
expected={"ret": 1},
sls="""
{% set result = [1, 2, 3, 4] | min() %}
test:
module.run:
- name: test.echo
- text: {{ result }}
""",
),
Filter(
name="quote",
expected={"ret": "Salt Rocks!"},
sls="""
{% set result = 'Salt Rocks!' | quote() %}
test:
module.run:
- name: test.echo
- text: {{ result }}
""",
),
Filter(
name="regex_escape",
expected={"ret": r"Salt\ Rocks"},
sls="""
{% set result = 'Salt Rocks' | regex_escape() %}
test:
module.run:
- name: test.echo
- text: {{ result }}
""",
),
Filter(
name="regex_match",
expected={"ret": "('a', 'd')"},
sls="""
{% set result = 'abcd' | regex_match('^(.*)BC(.*)$', ignorecase=True) %}
test:
module.run:
- name: test.echo
- text: {{ result }}
""",
),
Filter(
name="regex_replace",
expected={"ret": "lets__replace__spaces"},
sls=r"""
{% set result = 'lets replace spaces' | regex_replace('\s+', '__') %}
test:
module.run:
- name: test.echo
- text: {{ result }}
""",
),
Filter(
name="regex_search",
expected={"ret": "('a', 'd')"},
sls="""
{% set result = 'abcd' | regex_search('^(.*)BC(.*)$', ignorecase=True) %}
test:
module.run:
- name: test.echo
- text: {{ result }}
""",
),
Filter(
name="sequence",
expected={"ret": ["Salt Rocks!"]},
sls="""
{% set result = 'Salt Rocks!' | sequence() %}
test:
module.run:
- name: test.echo
- text: {{ result }}
""",
),
Filter(
name="skip",
expected={"ret": None},
sls="""
{% set result = 'Salt Rocks!' | skip() %}
test:
module.run:
- name: test.echo
- text: {{ result }}
""",
),
Filter(
name="symmetric_difference",
expected={"ret": [1, 3, 6]},
sls="""
{% set result = [1, 2, 3, 4] | symmetric_difference([2, 4, 6]) %}
test:
module.run:
- name: test.echo
- text: {{ result }}
""",
),
Filter(
name="to_bool",
expected={"ret": True},
sls="""
{% set result = 'yes' | to_bool() %}
test:
module.run:
- name: test.echo
- text: {{ result }}
""",
),
Filter(
name="union",
expected={"ret": [1, 2, 3, 4, 6]},
sls="""
{% set result = [1, 2, 3, 4] | union([2, 4, 6]) %}
test:
module.run:
- name: test.echo
- text: {{ result }}
""",
),
Filter(
name="unique",
expected={"ret": ["a", "b", "c"]},
sls="""
{% set result = ['a', 'b', 'c', 'a', 'b'] | unique() %}
test:
module.run:
- name: test.echo
- text: {{ result }}
""",
),
Filter(
name="uuid",
expected={"ret": "799192d9-7f32-5227-a45f-dfeb4a34e06f"},
sls="""
{% set result = 'Salt Rocks!' | uuid() %}
test:
module.run:
- name: test.echo
- text: {{ result }}
""",
),
StartsWithFilter(
name="gen_mac",
expected="AC:DE:48:",
sls="""
{% set result = 'AC:DE:48' | gen_mac() %}
test:
module.run:
- name: test.echo
- text: {{ result }}
""",
),
SortedFilter(
name="ipaddr",
expected={"ret": ["127.0.0.1", "::1"]},
sls="""
{% set result = 'Salt Rocks!' | uuid() %}
{% set result = ['127.0.0.1', '::1', 'random_junk'] | ipaddr() %}
test:
module.run:
- name: test.echo
- text: {{ result }}
""",
),
Filter(
name="ip_host",
expected={"ret": "192.168.0.12/24"},
sls="""
{% set result = '192.168.0.12/24' | ip_host() %}
test:
module.run:
- name: test.echo
- text: {{ result }}
""",
),
Filter(
name="ipv4",
expected={"ret": ["127.0.0.1"]},
sls="""
{% set result = ['127.0.0.1', '::1'] | ipv4() %}
test:
module.run:
- name: test.echo
- text: {{ result }}
""",
),
Filter(
name="ipv6",
expected={"ret": ["::1"]},
sls="""
{% set result = ['127.0.0.1', '::1'] | ipv6() %}
test:
module.run:
- name: test.echo
- text: {{ result }}
""",
),
Filter(
name="is_ip",
expected={"ret": True},
sls="""
{% set result = '127.0.0.1' | is_ip() %}
test:
module.run:
- name: test.echo
- text: {{ result }}
""",
),
Filter(
name="is_ipv4",
expected={"ret": True},
sls="""
{% set result = '127.0.0.1' | is_ipv4() %}
test:
module.run:
- name: test.echo
- text: {{ result }}
""",
),
Filter(
name="is_ipv6",
expected={"ret": True},
sls="""
{% set result = '::1' | is_ipv6() %}
test:
module.run:
- name: test.echo
- text: {{ result }}
""",
),
Filter(
name="network_hosts",
expected={"ret": ["192.168.1.1", "192.168.1.2"]},
sls="""
{% set result = '192.168.1.0/30' | network_hosts() %}
test:
module.run:
- name: test.echo
- text: {{ result }}
""",
),
Filter(
name="network_size",
expected={"ret": 16},
sls="""
{% set result = '192.168.1.0/28' | network_size() %}
test:
module.run:
- name: test.echo
- text: {{ result }}
""",
),
Filter(
name="path_join",
expected={"ret": os.path.sep + os.path.join("a", "b", "c", "d")},
sls="""
{% set result = '/a/b/c' | path_join('d') %}
test:
module.run:
- name: test.echo
- text: {{ result }}
""",
),
Filter(
name="which",
expected={"ret": salt.utils.path.which("which")},
sls="""
{% set result = 'which' | which() %}
test:
module.run:
- name: test.echo
- text: {{ result }}
""",
),
Filter(
name="contains_whitespace",
expected={"ret": True},
sls="""
{% set result = 'This string has whitespace' | contains_whitespace() %}
test:
module.run:
- name: test.echo
- text: {{ result }}
""",
),
Filter(
name="is_hex",
expected={"ret": True},
sls="""
{% set result = '0x2a' | is_hex() %}
test:
module.run:
- name: test.echo
- text: {{ result }}
""",
),
Filter(
name="random_str",
expected=lambda x: len(x["ret"]) == 32,
sls="""
{% set result = 32 | random_str() %}
test:
module.run:
- name: test.echo
- text: {{ result }}
""",
),
Filter(
name="to_num",
expected={"ret": 42},
sls="""
{% set result = '42' | to_num() %}
test:
module.run:
- name: test.echo
- text: {{ result }}
""",
),
Filter(
name="check_whitelist_blacklist",
expected={"ret": True},
sls="""
{% set result = 'string' | check_whitelist_blacklist(whitelist='string') %}
test:
module.run:
- name: test.echo
- text: {{ result }}
""",
),
SkipOnWindowsFilter(
name="get_uid",
expected={"ret": 0},
sls="""
{% set result = 'root' | get_uid() %}
test:
module.run:
- name: test.echo
- text: {{ result }}
""",
),
Filter(
name="yaml_dquote",
expected={"ret": "A double-quoted string in YAML"},
sls="""
{% set result = "A double-quoted string in YAML" | yaml_dquote() %}
test:
module.run:
- name: test.echo
- text: {{ result }}
""",
),
Filter(
name="yaml_squote",
expected={"ret": "A single-quoted string in YAML"},
sls="""
{% set result = 'A single-quoted string in YAML' | yaml_squote() %}
test:
module.run:
- name: test.echo
- text: {{ result }}
""",
),
Filter(
name="yaml_encode",
expected={"ret": "An encoded string in YAML"},
sls="""
{% set result = "An encoded string in YAML" | yaml_encode() %}
test:
module.run:
- name: test.echo
- text: {{ result }}
""",
),
Filter(
name="yaml",
expected={"ret": {"Question": "Quieres Café?"}},
sls="""
{% set result = {"Question": "Quieres Café?"} | yaml %}
test:
module.run:
- name: test.echo
- text: {{ result }}
""",
),
Filter(
name="json",
expected={"ret": {"Question": "Quieres Café?"}},
sls="""
{% set result = {"Question": "Quieres Café?"} | json %}
test:
module.run:
- name: test.echo
- text: {{ result }}
""",
),
],
ids=_filter_id,
)
def filter(request):
return request.param
def test_filter(state, state_tree, filter, grains):
filter.check_skip(grains)
with filter(state_tree):
ret = state.sls("filter")
log.debug("state.sls returned: %s", ret)
assert not ret.failed
for state_result in ret:
assert state_result.result is True
filter.assert_result(state_result.changes)

660
tests/support/jinja_filters.py
View file

@ -1,660 +0,0 @@
import os
import salt.utils.files
import salt.utils.platform
from tests.support.unit import skipIf
class JinjaFiltersTest:
"""
testing Jinja filters are available via state system
"""
def test_data_compare_dicts(self):
"""
test jinja filter data.compare_dicts
"""
_expected = {"ret": {"a": {"new": "c", "old": "b"}}}
ret = self.run_function("state.sls", ["jinja_filters.data_compare_dicts"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertEqual(ret["module_|-test_|-test.echo_|-run"]["changes"], _expected)
def test_data_compare_lists(self):
"""
test jinja filter data.compare_list
"""
_expected = {"ret": {"old": ["b"]}}
ret = self.run_function("state.sls", ["jinja_filters.data_compare_lists"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertEqual(ret["module_|-test_|-test.echo_|-run"]["changes"], _expected)
def test_data_decode_dict(self):
"""
test jinja filter data.decode_dict
"""
_expected = {"ret": {"a": "b", "c": "d"}}
ret = self.run_function("state.sls", ["jinja_filters.data_decode_dict"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertIn("ret", ret["module_|-test_|-test.echo_|-run"]["changes"])
def test_data_decode_list(self):
"""
test jinja filter data.decode_list
"""
_expected = {"ret": ["a", "b", "c", "d"]}
ret = self.run_function("state.sls", ["jinja_filters.data_decode_list"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertIn("ret", ret["module_|-test_|-test.echo_|-run"]["changes"])
def test_data_encode_dict(self):
"""
test jinja filter data.encode_dict
"""
_expected = {"ret": {"a": "b", "c": "d"}}
ret = self.run_function("state.sls", ["jinja_filters.data_encode_dict"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertIn("ret", ret["module_|-test_|-test.echo_|-run"]["changes"])
def test_data_encode_list(self):
"""
test jinja filter data.encode_list
"""
_expected = {"ret": ["a", "b", "c", "d"]}
ret = self.run_function("state.sls", ["jinja_filters.data_encode_list"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertIn("ret", ret["module_|-test_|-test.echo_|-run"]["changes"])
def test_data_exactly_n(self):
"""
test jinja filter data.exactly_n
"""
_expected = {"ret": True}
ret = self.run_function("state.sls", ["jinja_filters.data_exactly_n"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertEqual(ret["module_|-test_|-test.echo_|-run"]["changes"], _expected)
def test_data_exactly_one(self):
"""
test jinja filter data.exactly_one
"""
_expected = {"ret": True}
ret = self.run_function("state.sls", ["jinja_filters.data_exactly_one"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertEqual(ret["module_|-test_|-test.echo_|-run"]["changes"], _expected)
def test_data_is_iter(self):
"""
test jinja filter data.is_iter
"""
_expected = {"ret": True}
ret = self.run_function("state.sls", ["jinja_filters.data_is_iter"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertEqual(ret["module_|-test_|-test.echo_|-run"]["changes"], _expected)
def test_data_is_list(self):
"""
test jinja filter data.is_list
"""
_expected = {"ret": True}
ret = self.run_function("state.sls", ["jinja_filters.data_is_list"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertEqual(ret["module_|-test_|-test.echo_|-run"]["changes"], _expected)
def test_data_mysql_to_dict(self):
"""
test jinja filter data.mysql_to_dict
"""
_expected = {
"ret": {
"show processlist": {
"Info": "show processlist",
"db": "NULL",
"Host": "localhost",
"State": "init",
"Command": "Query",
"User": "root",
"Time": 0,
"Id": 7,
}
}
}
ret = self.run_function("state.sls", ["jinja_filters.data_mysql_to_dict"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertEqual(ret["module_|-test_|-test.echo_|-run"]["changes"], _expected)
def test_data_sorted_ignorecase(self):
"""
test jinja filter data.softed_ignorecase
"""
_expected = {"ret": ["Abcd", "efgh", "Ijk", "lmno", "Pqrs"]}
ret = self.run_function("state.sls", ["jinja_filters.data_sorted_ignorecase"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertEqual(ret["module_|-test_|-test.echo_|-run"]["changes"], _expected)
def test_data_substring_in_list(self):
"""
test jinja filter data.substring_in_list
"""
_expected = {"ret": True}
ret = self.run_function("state.sls", ["jinja_filters.data_substring_in_list"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertEqual(ret["module_|-test_|-test.echo_|-run"]["changes"], _expected)
def test_dateutils_strftime(self):
"""
test jinja filter datautils.strftime
"""
ret = self.run_function("state.sls", ["jinja_filters.dateutils_strftime"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertIn("ret", ret["module_|-test_|-test.echo_|-run"]["changes"])
def test_files_is_binary(self):
"""
test jinja filter files.is_binary
"""
_expected = {"ret": True}
ret = self.run_function("state.sls", ["jinja_filters.files_is_binary"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertEqual(ret["module_|-test_|-test.echo_|-run"]["changes"], _expected)
def test_files_is_empty(self):
"""
test jinja filter files.is_empty
"""
try:
if salt.utils.platform.is_windows():
with salt.utils.files.fopen("c:\\empty_file", "w") as fp:
pass
_expected = {"ret": True}
ret = self.run_function("state.sls", ["jinja_filters.files_is_empty"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertEqual(
ret["module_|-test_|-test.echo_|-run"]["changes"], _expected
)
finally:
if salt.utils.platform.is_windows():
os.remove("c:\\empty_file")
def test_files_is_text(self):
"""
test jinja filter files.is_text
"""
_expected = {"ret": True}
ret = self.run_function("state.sls", ["jinja_filters.files_is_text"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertEqual(ret["module_|-test_|-test.echo_|-run"]["changes"], _expected)
def test_files_list_files(self):
"""
test jinja filter files.list_files
"""
ret = self.run_function("state.sls", ["jinja_filters.files_list_files"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
if salt.utils.platform.is_windows():
self.assertIn(
"c:\\\\salt\\\\conf\\\\minion",
ret["module_|-test_|-test.echo_|-run"]["changes"]["ret"],
)
else:
self.assertIn(
"/bin/ls", ret["module_|-test_|-test.echo_|-run"]["changes"]["ret"]
)
def test_hashutils_base4_64decode(self):
"""
test jinja filter hashutils.base64_64decode
"""
_expected = {"ret": "Salt Rocks!"}
ret = self.run_function("state.sls", ["jinja_filters.hashutils_base4_64decode"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertEqual(ret["module_|-test_|-test.echo_|-run"]["changes"], _expected)
def test_hashutils_base4_64encode(self):
"""
test jinja filter hashutils.base64_64encode
"""
_expected = {"ret": "U2FsdCBSb2NrcyE="}
ret = self.run_function("state.sls", ["jinja_filters.hashutils_base4_64encode"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertEqual(ret["module_|-test_|-test.echo_|-run"]["changes"], _expected)
def test_hashutils_file_hashsum(self):
"""
test jinja filter hashutils.file_hashsum
"""
ret = self.run_function("state.sls", ["jinja_filters.hashutils_file_hashsum"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertIn("ret", ret["module_|-test_|-test.echo_|-run"]["changes"])
def test_hashutils_hmac(self):
"""
test jinja filter hashutils.hmac
"""
_expected = {"ret": True}
ret = self.run_function("state.sls", ["jinja_filters.hashutils_hmac"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertEqual(ret["module_|-test_|-test.echo_|-run"]["changes"], _expected)
def test_hashutils_md5_digest(self):
"""
test jinja filter hashutils.md5_digest
"""
_expected = {"ret": "85d6e71db655ee8e42c8b18475f0925f"}
ret = self.run_function("state.sls", ["jinja_filters.hashutils_md5_digest"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertEqual(ret["module_|-test_|-test.echo_|-run"]["changes"], _expected)
def test_hashutils_random_hash(self):
"""
test jinja filter hashutils.random_hash
"""
ret = self.run_function("state.sls", ["jinja_filters.hashutils_random_hash"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertIn("ret", ret["module_|-test_|-test.echo_|-run"]["changes"])
def test_hashutils_sha256_digest(self):
"""
test jinja filter hashutils.sha256_digest
"""
_expected = {
"ret": "cce7fe00fd9cc6122fd3b2ed22feae215bcfe7ac4a7879d336c1993426a763fe"
}
ret = self.run_function("state.sls", ["jinja_filters.hashutils_sha256_digest"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertEqual(ret["module_|-test_|-test.echo_|-run"]["changes"], _expected)
def test_hashutils_sha512_digest(self):
"""
test jinja filter hashutils.sha512_digest
"""
_expected = {
"ret": "44d829491d8caa7039ad08a5b7fa9dd0f930138c614411c5326dd4755fdc9877ec6148219fccbe404139e7bb850e77237429d64f560c204f3697ab489fd8bfa5"
}
ret = self.run_function("state.sls", ["jinja_filters.hashutils_sha512_digest"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertEqual(ret["module_|-test_|-test.echo_|-run"]["changes"], _expected)
def test_http_query(self):
"""
test jinja filter http.query
"""
_expected = {"ret": {}}
ret = self.run_function("state.sls", ["jinja_filters.http_query"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertEqual(ret["module_|-test_|-test.echo_|-run"]["changes"], _expected)
def test_jinja_avg(self):
"""
test jinja filter jinja.avg
"""
ret = self.run_function("state.sls", ["jinja_filters.jinja_avg"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertIn("ret", ret["module_|-test_|-test.echo_|-run"]["changes"])
def test_jinja_difference(self):
"""
test jinja filter jinja.difference
"""
_expected = {"ret": [1, 3]}
ret = self.run_function("state.sls", ["jinja_filters.jinja_difference"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertEqual(ret["module_|-test_|-test.echo_|-run"]["changes"], _expected)
def test_jinja_intersect(self):
"""
test jinja filter jinja.intersect
"""
_expected = {"ret": [2, 4]}
ret = self.run_function("state.sls", ["jinja_filters.jinja_intersect"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertEqual(ret["module_|-test_|-test.echo_|-run"]["changes"], _expected)
def test_jinja_max(self):
"""
test jinja filter jinja.max
"""
_expected = {"ret": 4}
ret = self.run_function("state.sls", ["jinja_filters.jinja_max"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertEqual(ret["module_|-test_|-test.echo_|-run"]["changes"], _expected)
def test_jinja_min(self):
"""
test jinja filter jinja.min
"""
_expected = {"ret": 1}
ret = self.run_function("state.sls", ["jinja_filters.jinja_min"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertEqual(ret["module_|-test_|-test.echo_|-run"]["changes"], _expected)
def test_jinja_quote(self):
"""
test jinja filter jinja.quote
"""
_expected = {"ret": "Salt Rocks!"}
ret = self.run_function("state.sls", ["jinja_filters.jinja_quote"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertEqual(ret["module_|-test_|-test.echo_|-run"]["changes"], _expected)
def test_jinja_regex_escape(self):
"""
test jinja filter jinja.regex_escape
"""
_expected = {"ret": "Salt\\ Rocks"}
ret = self.run_function("state.sls", ["jinja_filters.jinja_regex_escape"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertEqual(ret["module_|-test_|-test.echo_|-run"]["changes"], _expected)
def test_jinja_regex_match(self):
"""
test jinja filter jinja.regex_match
"""
_expected = {"ret": "('a', 'd')"}
ret = self.run_function("state.sls", ["jinja_filters.jinja_regex_match"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertEqual(ret["module_|-test_|-test.echo_|-run"]["changes"], _expected)
def test_jinja_regex_replace(self):
"""
test jinja filter jinja.regex_replace
"""
_expected = {"ret": "lets__replace__spaces"}
ret = self.run_function("state.sls", ["jinja_filters.jinja_regex_replace"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertEqual(ret["module_|-test_|-test.echo_|-run"]["changes"], _expected)
def test_jinja_regex_search(self):
"""
test jinja filter jinja.regex_search
"""
_expected = {"ret": "('a', 'd')"}
ret = self.run_function("state.sls", ["jinja_filters.jinja_regex_search"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertEqual(ret["module_|-test_|-test.echo_|-run"]["changes"], _expected)
def test_jinja_sequence(self):
"""
test jinja filter jinja.sequence
"""
_expected = {"ret": ["Salt Rocks!"]}
ret = self.run_function("state.sls", ["jinja_filters.jinja_sequence"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertEqual(ret["module_|-test_|-test.echo_|-run"]["changes"], _expected)
def test_jinja_skip(self):
"""
test jinja filter jinja.skip
"""
_expected = {"ret": None}
ret = self.run_function("state.sls", ["jinja_filters.jinja_skip"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertEqual(ret["module_|-test_|-test.echo_|-run"]["changes"], _expected)
def test_jinja_symmetric_difference(self):
"""
test jinja filter jinja.symmetric_difference
"""
_expected = {"ret": [1, 3, 6]}
ret = self.run_function(
"state.sls", ["jinja_filters.jinja_symmetric_difference"]
)
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertEqual(ret["module_|-test_|-test.echo_|-run"]["changes"], _expected)
def test_jinja_to_bool(self):
"""
test jinja filter jinja.to_bool
"""
_expected = {"ret": True}
ret = self.run_function("state.sls", ["jinja_filters.jinja_to_bool"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertEqual(ret["module_|-test_|-test.echo_|-run"]["changes"], _expected)
def test_jinja_union(self):
"""
test jinja filter jinja.union
"""
_expected = {"ret": [1, 2, 3, 4, 6]}
ret = self.run_function("state.sls", ["jinja_filters.jinja_union"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertEqual(ret["module_|-test_|-test.echo_|-run"]["changes"], _expected)
def test_jinja_unique(self):
"""
test jinja filter jinja.unique
"""
_expected = {"ret": ["a", "b", "c"]}
ret = self.run_function("state.sls", ["jinja_filters.jinja_unique"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertEqual(ret["module_|-test_|-test.echo_|-run"]["changes"], _expected)
def test_jinja_uuid(self):
"""
test jinja filter jinja.uuid
"""
_expected = {"ret": "799192d9-7f32-5227-a45f-dfeb4a34e06f"}
ret = self.run_function("state.sls", ["jinja_filters.jinja_uuid"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertEqual(ret["module_|-test_|-test.echo_|-run"]["changes"], _expected)
def test_network_gen_mac(self):
"""
test jinja filter network.gen_mac
"""
_expected = "AC:DE:48:"
ret = self.run_function("state.sls", ["jinja_filters.network_gen_mac"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertTrue(
ret["module_|-test_|-test.echo_|-run"]["changes"]["ret"].startswith(
_expected
)
)
def test_network_ipaddr(self):
"""
test jinja filter network.ipaddr
"""
ret = self.run_function("state.sls", ["jinja_filters.network_ipaddr"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertIn("ret", ret["module_|-test_|-test.echo_|-run"]["changes"])
def test_network_ip_host(self):
"""
test jinja filter network.ip_host
"""
_expected = {"ret": "192.168.0.12/24"}
ret = self.run_function("state.sls", ["jinja_filters.network_ip_host"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertEqual(ret["module_|-test_|-test.echo_|-run"]["changes"], _expected)
def test_network_ipv4(self):
"""
test jinja filter network.ipv4
"""
_expected = {"ret": ["127.0.0.1"]}
ret = self.run_function("state.sls", ["jinja_filters.network_ipv4"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertEqual(ret["module_|-test_|-test.echo_|-run"]["changes"], _expected)
def test_network_ipv6(self):
"""
test jinja filter network.ipv6
"""
ret = self.run_function("state.sls", ["jinja_filters.network_ipv6"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertIn("ret", ret["module_|-test_|-test.echo_|-run"]["changes"])
def test_network_is_ip(self):
"""
test jinja filter network.is_ip
"""
_expected = {"ret": True}
ret = self.run_function("state.sls", ["jinja_filters.network_is_ip"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertEqual(ret["module_|-test_|-test.echo_|-run"]["changes"], _expected)
def test_network_is_ipv4(self):
"""
test jinja filter network.is_ipv4
"""
_expected = {"ret": True}
ret = self.run_function("state.sls", ["jinja_filters.network_is_ipv4"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertEqual(ret["module_|-test_|-test.echo_|-run"]["changes"], _expected)
def test_network_is_ipv6(self):
"""
test jinja filter network.is_ipv6
"""
_expected = {"ret": True}
ret = self.run_function("state.sls", ["jinja_filters.network_is_ipv6"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertEqual(ret["module_|-test_|-test.echo_|-run"]["changes"], _expected)
def test_network_network_hosts(self):
"""
test jinja filter network.network_hosts
"""
_expected = {"ret": ["192.168.1.1", "192.168.1.2"]}
ret = self.run_function("state.sls", ["jinja_filters.network_network_hosts"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertEqual(ret["module_|-test_|-test.echo_|-run"]["changes"], _expected)
def test_network_network_size(self):
"""
test jinja filter network.network_size
"""
_expected = {"ret": 16}
ret = self.run_function("state.sls", ["jinja_filters.network_network_size"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertEqual(ret["module_|-test_|-test.echo_|-run"]["changes"], _expected)
def test_path_join(self):
"""
test jinja filter path.join
"""
_expected = {"ret": os.path.sep + os.path.join("a", "b", "c", "d")}
ret = self.run_function("state.sls", ["jinja_filters.path_join"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertEqual(ret["module_|-test_|-test.echo_|-run"]["changes"], _expected)
def test_path_which(self):
"""
test jinja filter path.which
"""
ret = self.run_function("state.sls", ["jinja_filters.path_which"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertIn("ret", ret["module_|-test_|-test.echo_|-run"]["changes"])
def test_stringutils_contains_whitespace(self):
"""
test jinja filter stringutils.contains_whitespace
"""
_expected = {"ret": True}
ret = self.run_function(
"state.sls", ["jinja_filters.stringutils_contains_whitespace"]
)
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertEqual(ret["module_|-test_|-test.echo_|-run"]["changes"], _expected)
def test_stringutils_is_hex(self):
"""
test jinja filter stringutils.is_hex
"""
_expected = {"ret": True}
ret = self.run_function("state.sls", ["jinja_filters.stringutils_is_hex"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertEqual(ret["module_|-test_|-test.echo_|-run"]["changes"], _expected)
def test_stringutils_random_str(self):
"""
test jinja filter stringutils.random_str
"""
ret = self.run_function("state.sls", ["jinja_filters.stringutils_random_str"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertIn("ret", ret["module_|-test_|-test.echo_|-run"]["changes"])
def test_stringutils_to_bytes(self):
"""
test jinja filter stringutils.to_bytes
"""
_expected = {"ret": "Salt Rocks!"}
ret = self.run_function("state.sls", ["jinja_filters.stringutils_to_bytes"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertIn("ret", ret["module_|-test_|-test.echo_|-run"]["changes"])
def test_stringutils_to_num(self):
"""
test jinja filter stringutils.to_num
"""
_expected = {"ret": 42}
ret = self.run_function("state.sls", ["jinja_filters.stringutils_to_num"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertEqual(ret["module_|-test_|-test.echo_|-run"]["changes"], _expected)
def test_stringutils_whitelist_blacklist(self):
"""
test jinja filter stringutils.whitelist_blacklist
"""
_expected = {"ret": True}
ret = self.run_function(
"state.sls", ["jinja_filters.stringutils_whitelist_blacklist"]
)
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertEqual(ret["module_|-test_|-test.echo_|-run"]["changes"], _expected)
@skipIf(salt.utils.platform.is_windows(), "Skip on windows")
def test_user_get_uid(self):
"""
test jinja filter user.get_uid
"""
_expected = {"ret": 0}
ret = self.run_function("state.sls", ["jinja_filters.user_get_uid"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertEqual(ret["module_|-test_|-test.echo_|-run"]["changes"], _expected)
def test_yamlencoding_yaml_dquote(self):
"""
test jinja filter yamlencoding.yaml_dquote
"""
_expected = {"ret": "A double-quoted string in YAML"}
ret = self.run_function("state.sls", ["jinja_filters.yamlencoding_yaml_dquote"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertEqual(ret["module_|-test_|-test.echo_|-run"]["changes"], _expected)
def test_yamlencoding_yaml_encode(self):
"""
test jinja filter yamlencoding.yaml_encode
"""
_expected = {"ret": "An encoded string in YAML"}
ret = self.run_function("state.sls", ["jinja_filters.yamlencoding_yaml_encode"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertEqual(ret["module_|-test_|-test.echo_|-run"]["changes"], _expected)
def test_yamlencoding_yaml_squote(self):
"""
test jinja filter yamlencoding.yaml_squote
"""
_expected = {"ret": "A single-quoted string in YAML"}
ret = self.run_function("state.sls", ["jinja_filters.yamlencoding_yaml_squote"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertEqual(ret["module_|-test_|-test.echo_|-run"]["changes"], _expected)
def test_yaml(self):
"""
test yaml filter
"""
_expected = {"ret": "{Question: 'Quieres Café?'}"}
ret = self.run_function("state.sls", ["jinja_filters.yaml"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertEqual(ret["module_|-test_|-test.echo_|-run"]["changes"], _expected)
def test_json(self):
"""
test json filter
"""
_expected = {"ret": '{"Question": "Quieres Café?"}'}
ret = self.run_function("state.sls", ["jinja_filters.json"])
self.assertIn("module_|-test_|-test.echo_|-run", ret)
self.assertEqual(ret["module_|-test_|-test.echo_|-run"]["changes"], _expected)

1
tests/unit/test_module_names.py
View file

@ -134,7 +134,6 @@ class BadTestModuleNamesTestCase(TestCase):
"integration.modules.test_decorators",
"integration.modules.test_pkg",
"integration.modules.test_service",
"integration.modules.test_state_jinja_filters",
"integration.modules.test_sysctl",
"integration.netapi.rest_tornado.test_app",
"integration.output.test_output",