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

Refactor state tests again

Browse source
This commit is contained in:
jeanluc 2023-11-17 18:24:11 +01:00 • committed by Pedro Algarvio
parent 6e312ce8be
commit 27334a4935
6 changed files with 89 additions and 193 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

34
tests/pytests/integration/ssh/state/test_pillar_override_template.py
View file

@ -77,31 +77,21 @@ def override(base):
return expected, poverride
def test_state_sls(salt_ssh_cli, override, _write_pillar_state):
@pytest.mark.parametrize(
"args,kwargs",
(
(("state.sls", "writepillar"), {}),
(("state.highstate",), {"whitelist": "writepillar"}),
(("state.top", "top.sls"), {}),
),
)
def test_it(salt_ssh_cli, args, kwargs, override, _write_pillar_state):
expected, override = override
ret = salt_ssh_cli.run("state.sls", "writepillar", pillar=override)
_assert_pillar(ret, expected, _write_pillar_state)
def test_state_highstate(salt_ssh_cli, override, _write_pillar_state):
expected, override = override
ret = salt_ssh_cli.run(
"state.highstate", pillar=override, whitelist=["writepillar"]
)
_assert_pillar(ret, expected, _write_pillar_state)
def test_state_top(salt_ssh_cli, override, _write_pillar_state):
expected, override = override
ret = salt_ssh_cli.run("state.top", "top.sls", pillar=override)
_assert_pillar(ret, expected, _write_pillar_state)
def _assert_pillar(ret, expected, path):
ret = salt_ssh_cli.run(*args, **kwargs, pillar=override)
assert ret.returncode == 0
assert isinstance(ret.data, dict)
assert ret.data
assert path.exists()
pillar = json.loads(path.read_text())
assert _write_pillar_state.exists()
pillar = json.loads(_write_pillar_state.read_text())
assert pillar["raw"] == expected
assert pillar["modules"] == expected

46
tests/pytests/integration/ssh/state/test_retcode_highstate_verification_requisite_fail.py
View file

@ -39,38 +39,20 @@ def state_tree_req_fail(base_env_state_tree_root_dir):
yield
def test_retcode_state_sls_invalid_requisite(salt_ssh_cli):
ret = salt_ssh_cli.run("state.sls", "fail_req")
_assert_ret(ret, EX_AGGREGATE)
def test_retcode_state_highstate_invalid_requisite(salt_ssh_cli):
ret = salt_ssh_cli.run("state.highstate")
_assert_ret(ret, EX_AGGREGATE)
def test_retcode_state_show_sls_invalid_requisite(salt_ssh_cli):
ret = salt_ssh_cli.run("state.show_sls", "fail_req")
_assert_ret(ret, EX_AGGREGATE)
def test_retcode_state_show_low_sls_invalid_requisite(salt_ssh_cli):
ret = salt_ssh_cli.run("state.show_low_sls", "fail_req")
_assert_ret(ret, EX_AGGREGATE)
def test_retcode_state_show_lowstate_invalid_requisite(salt_ssh_cli):
ret = salt_ssh_cli.run("state.show_lowstate")
# state.show_lowstate exits with 0 for non-ssh as well
_assert_ret(ret, 0)
def test_retcode_state_top_invalid_requisite(salt_ssh_cli):
ret = salt_ssh_cli.run("state.top", "top.sls")
_assert_ret(ret, EX_AGGREGATE)
def _assert_ret(ret, retcode):
@pytest.mark.parametrize(
"args,retcode",
(
(("state.sls", "fail_req"), EX_AGGREGATE),
(("state.highstate",), EX_AGGREGATE),
(("state.show_sls", "fail_req"), EX_AGGREGATE),
(("state.show_low_sls", "fail_req"), EX_AGGREGATE),
# state.show_lowstate exits with 0 for non-ssh as well
(("state.show_lowstate",), 0),
(("state.top", "top.sls"), EX_AGGREGATE),
),
)
def test_it(salt_ssh_cli, args, retcode):
ret = salt_ssh_cli.run(*args)
assert ret.returncode == retcode
assert isinstance(ret.data, list)
assert ret.data

46
tests/pytests/integration/ssh/state/test_retcode_highstate_verification_structure_fail.py
View file

@ -41,38 +41,20 @@ def state_tree_structure_fail(base_env_state_tree_root_dir):
yield
def test_retcode_state_sls_invalid_structure(salt_ssh_cli):
ret = salt_ssh_cli.run("state.sls", "fail_structure")
_assert_ret(ret, EX_AGGREGATE)
def test_retcode_state_highstate_invalid_structure(salt_ssh_cli):
ret = salt_ssh_cli.run("state.highstate")
_assert_ret(ret, EX_AGGREGATE)
def test_retcode_state_show_sls_invalid_structure(salt_ssh_cli):
ret = salt_ssh_cli.run("state.show_sls", "fail_structure")
_assert_ret(ret, EX_AGGREGATE)
def test_retcode_state_show_low_sls_invalid_structure(salt_ssh_cli):
ret = salt_ssh_cli.run("state.show_low_sls", "fail_structure")
_assert_ret(ret, EX_AGGREGATE)
def test_retcode_state_show_lowstate_invalid_structure(salt_ssh_cli):
ret = salt_ssh_cli.run("state.show_lowstate")
# state.show_lowstate exits with 0 for non-ssh as well
_assert_ret(ret, 0)
def test_retcode_state_top_invalid_structure(salt_ssh_cli):
ret = salt_ssh_cli.run("state.top", "top.sls")
_assert_ret(ret, EX_AGGREGATE)
def _assert_ret(ret, retcode):
@pytest.mark.parametrize(
"args,retcode",
(
(("state.sls", "fail_structure"), EX_AGGREGATE),
(("state.highstate",), EX_AGGREGATE),
(("state.show_sls", "fail_structure"), EX_AGGREGATE),
(("state.show_low_sls", "fail_structure"), EX_AGGREGATE),
# state.show_lowstate exits with 0 for non-ssh as well
(("state.show_lowstate",), 0),
(("state.top", "top.sls"), EX_AGGREGATE),
),
)
def test_it(salt_ssh_cli, args, retcode):
ret = salt_ssh_cli.run(*args)
assert ret.returncode == retcode
assert isinstance(ret.data, list)
assert ret.data

56
tests/pytests/integration/ssh/state/test_retcode_pillar_render_exception.py
View file

@ -34,47 +34,21 @@ def pillar_tree_render_fail(base_env_pillar_tree_root_dir):
yield
def test_retcode_state_sls_pillar_render_exception(salt_ssh_cli):
ret = salt_ssh_cli.run("state.sls", "basic")
_assert_ret(ret)
def test_retcode_state_highstate_pillar_render_exception(salt_ssh_cli):
ret = salt_ssh_cli.run("state.highstate")
_assert_ret(ret)
def test_retcode_state_sls_id_pillar_render_exception(salt_ssh_cli):
ret = salt_ssh_cli.run("state.sls_id", "foo", "basic")
_assert_ret(ret)
def test_retcode_state_show_sls_pillar_render_exception(salt_ssh_cli):
ret = salt_ssh_cli.run("state.show_sls", "basic")
_assert_ret(ret)
def test_retcode_state_show_low_sls_pillar_render_exception(salt_ssh_cli):
ret = salt_ssh_cli.run("state.show_low_sls", "basic")
_assert_ret(ret)
def test_retcode_state_show_highstate_pillar_render_exception(salt_ssh_cli):
ret = salt_ssh_cli.run("state.show_highstate")
_assert_ret(ret)
def test_retcode_state_show_lowstate_pillar_render_exception(salt_ssh_cli):
ret = salt_ssh_cli.run("state.show_lowstate")
_assert_ret(ret)
def test_retcode_state_top_pillar_render_exception(salt_ssh_cli):
ret = salt_ssh_cli.run("state.top", "top.sls")
_assert_ret(ret)
def _assert_ret(ret):
@pytest.mark.parametrize(
"args",
(
("state.sls", "basic"),
("state.highstate",),
("state.sls_id", "foo", "basic"),
("state.show_sls", "basic"),
("state.show_low_sls", "basic"),
("state.show_highstate",),
("state.show_lowstate",),
("state.top", "top.sls"),
),
)
def test_it(salt_ssh_cli, args):
ret = salt_ssh_cli.run(*args)
assert ret.returncode == EX_AGGREGATE
assert isinstance(ret.data, list)
assert ret.data

72
tests/pytests/integration/ssh/state/test_retcode_render_exception.py
View file

@ -35,55 +35,22 @@ def state_tree_render_fail(base_env_state_tree_root_dir):
yield
def test_retcode_state_sls_render_exception(salt_ssh_cli):
ret = salt_ssh_cli.run("state.sls", "fail_render")
_assert_ret(ret, EX_AGGREGATE)
def test_retcode_state_highstate_render_exception(salt_ssh_cli):
ret = salt_ssh_cli.run("state.highstate")
_assert_ret(ret, EX_AGGREGATE)
def test_retcode_state_sls_id_render_exception(salt_ssh_cli):
ret = salt_ssh_cli.run("state.sls_id", "foo", "fail_render")
_assert_ret(ret, EX_AGGREGATE)
def test_retcode_state_show_sls_render_exception(salt_ssh_cli):
ret = salt_ssh_cli.run("state.show_sls", "fail_render")
_assert_ret(ret, EX_AGGREGATE)
def test_retcode_state_show_low_sls_render_exception(salt_ssh_cli):
ret = salt_ssh_cli.run("state.show_low_sls", "fail_render")
_assert_ret(ret, EX_AGGREGATE)
def test_retcode_state_show_highstate_render_exception(salt_ssh_cli):
ret = salt_ssh_cli.run("state.show_highstate")
_assert_ret(ret, EX_AGGREGATE)
def test_retcode_state_show_lowstate_render_exception(salt_ssh_cli):
ret = salt_ssh_cli.run("state.show_lowstate")
# state.show_lowstate exits with 0 for non-ssh as well
_assert_ret(ret, 0)
def test_retcode_state_top_render_exception(salt_ssh_cli):
ret = salt_ssh_cli.run("state.top", "top.sls")
_assert_ret(ret, EX_AGGREGATE)
def test_retcode_state_single_render_exception(salt_ssh_cli):
ret = salt_ssh_cli.run("state.single", "file")
assert ret.returncode == EX_AGGREGATE
assert isinstance(ret.data, str)
assert "single() missing 1 required positional argument" in ret.data
def _assert_ret(ret, retcode):
@pytest.mark.parametrize(
"args,retcode",
(
(("state.sls", "fail_render"), EX_AGGREGATE),
(("state.highstate",), EX_AGGREGATE),
(("state.sls_id", "foo", "fail_render"), EX_AGGREGATE),
(("state.show_sls", "fail_render"), EX_AGGREGATE),
(("state.show_low_sls", "fail_render"), EX_AGGREGATE),
(("state.show_highstate",), EX_AGGREGATE),
# state.show_lowstate exits with 0 for non-ssh as well
(("state.show_lowstate",), 0),
(("state.top", "top.sls"), EX_AGGREGATE),
),
)
def test_it(salt_ssh_cli, args, retcode):
ret = salt_ssh_cli.run(*args)
assert ret.returncode == retcode
assert isinstance(ret.data, list)
assert ret.data
@ -91,3 +58,10 @@ def _assert_ret(ret, retcode):
assert ret.data[0].startswith(
"Rendering SLS 'base:fail_render' failed: Jinja variable 'abc' is undefined;"
)
def test_state_single(salt_ssh_cli):
ret = salt_ssh_cli.run("state.single", "file")
assert ret.returncode == EX_AGGREGATE
assert isinstance(ret.data, str)
assert "single() missing 1 required positional argument" in ret.data

28
tests/pytests/integration/ssh/state/test_retcode_run_fail.py
View file

@ -38,21 +38,15 @@ def state_tree_run_fail(base_env_state_tree_root_dir):
yield
def test_retcode_state_sls_run_fail(salt_ssh_cli):
ret = salt_ssh_cli.run("state.sls", "fail_run")
assert ret.returncode == EX_AGGREGATE
def test_retcode_state_highstate_run_fail(salt_ssh_cli):
ret = salt_ssh_cli.run("state.highstate")
assert ret.returncode == EX_AGGREGATE
def test_retcode_state_sls_id_render_exception(salt_ssh_cli):
ret = salt_ssh_cli.run("state.sls_id", "This file state fails", "fail_run")
assert ret.returncode == EX_AGGREGATE
def test_retcode_state_top_run_fail(salt_ssh_cli):
ret = salt_ssh_cli.run("state.top", "top.sls")
@pytest.mark.parametrize(
"args",
(
("state.sls", "fail_run"),
("state.highstate",),
("state.sls_id", "This file state fails", "fail_run"),
("state.top", "top.sls"),
),
)
def test_it(salt_ssh_cli, args):
ret = salt_ssh_cli.run(*args)
assert ret.returncode == EX_AGGREGATE