def test_generate_pull_request_body_no_changes_no_passing_law():
failing_rule = ExampleRule(name="Test failed rule 1", param=Mock())
failing_rule.made_changes = False
law_3 = Law(
name="Test law 3", description="Test description 3", rules=[failing_rule]
)
law_3.rules[0].made_changes = False
law_3._failed_rules = (failing_rule,)
mocked_pillar = Mock()
mocked_pillar.laws = [law_3]
expected_body = """## Description
Below you can find the executed laws and information about them.
### Test law 3
Test description 3
<details open>
<summary>Failed rules (manual fix needed)</summary>
* Test failed rule 1
</details>"""
pr_helper = get_pull_request_helper_mixin_consumer()
body = pr_helper.generate_pull_request_body(mocked_pillar)
assert body == expected_body
def test_validate_param(value):
rule = ExampleRule(name="Test", param="Rule")
# Casting to string is the safest
result = rule.validate(value, cast_to=str)
assert result == str(value)
def test_validate_param_required():
rule = ExampleRule(name="Test", param="Rule")
with pytest.raises(ValueError) as exc:
rule.validate(val=None, cast_to=str, required=True)
assert str(exc.value) == "The given value is empty"
def test_generate_pull_request_body():
mocked_pillar = Mock()
mocked_pillar.laws = [
Law(
name="Test law 1",
description="Test description 1",
rules=[ExampleRule(name="Test rule 1", param=Mock())],
),
Law(
name="Test law 2",
description="Test description 2",
rules=[ExampleRule(name="Test rule 2", param=Mock())],
),
Law(
name="Test law 3",
description="Test description 3",
rules=[
ExampleRule(name="Test rule 3", param=Mock()),
ExampleRule(name="Test rule 4", param=Mock()),
],
),
]
expected_body = """## Description
Below you can find the executed laws and information about them.
### Test law 1
Test description 1
<details>
<summary>Passed rules</summary>
* Test rule 1
</details>
### Test law 2
Test description 2
<details>
<summary>Passed rules</summary>
* Test rule 2
</details>
### Test law 3
Test description 3
<details>
<summary>Passed rules</summary>
* Test rule 3
* Test rule 4
</details>"""
pr_helper = get_pull_request_helper_mixin_consumer()
body = pr_helper.generate_pull_request_body(mocked_pillar)
assert body == expected_body
def test_execution_order_no_chain():
rule_1 = ExampleRule(name="rule_1", param="rule_1")
rule_1.get_rule_chain = Mock(return_value=[])
expected_execution_order = [rule_1]
order = rule_1.get_execution_order()
assert order == expected_execution_order
assert rule_1.get_rule_chain.called is False
def test_validate_param_required():
rule = ExampleRule(name="Test", param="Rule")
with pytest.raises(ValueError) as exc:
rule.validate(val=None, cast_to=str, required=True)
assert (
str(exc.value) ==
f"Parameter validation of {str(rule)} failed, the given value is empty"
)
def test_repr():
expected = 'ExampleRule(name="Test", param="Rule", preconditions=(), pipe=None, children=())'
rule = ExampleRule(name="Test", param="Rule")
assert repr(rule) == expected
# The repr should be used with eval
assert repr(eval(repr(rule))) == expected
def test_description(mock_full_strip):
expected_description = "test description"
mock_full_strip.return_value = expected_description
rule = ExampleRule(name="Test", param="Rule")
assert rule.description == expected_description
mock_full_strip.assert_called_once_with("ExampleRule task docstring")
def test_execution_order():
rule_1 = ExampleRule(name="rule_1", param="rule_1")
rule_2 = ExampleRule(name="rule_2", param="rule_2")
rule_3 = ExampleRule(name="rule_3", param="rule_3")
rule_1.get_execution_order = Mock(return_value=[])
rule_2.get_execution_order = Mock(return_value=[])
rule_3.get_execution_order = Mock(return_value=[])
law = Law(name="Passing", description="passing law", rules=(rule_1, rule_2, rule_3))
law.get_execution_order()
rule_1.get_execution_order.assert_called_once_with()
rule_2.get_execution_order.assert_called_once_with()
rule_3.get_execution_order.assert_called_once_with()
def test_execution_order():
rule_1 = ExampleRule(name="rule_1", param="rule_1")
rule_2 = ExampleRule(name="rule_2", param="rule_2")
rule_3 = ExampleRule(name="rule_3", param="rule_3")
rule_4 = ExampleRule(name="rule_4", param="rule_4")
rule_1.pipe = rule_2
rule_1.children = [rule_3, rule_4]
rule_1.get_rule_chain = Mock(side_effect=[[rule_2], [rule_3], [rule_4]])
rule_1.preconditions = [PASSING_PRECONDITION]
expected_execution_order = [
PASSING_PRECONDITION, rule_1, rule_2, rule_3, rule_4
]
order = rule_1.get_execution_order()
assert order == expected_execution_order
rule_1.get_rule_chain.assert_has_calls(
[call(rule_2), call(rule_3), call(rule_4)])
def test_execute_pipe(mocked_config):
mocked_config.settings.dry_run = False
piped_rule = ExampleRule(name="Test", param=None)
piped_rule.execute = Mock()
rule = ExampleRule(name="Test", param="Rule", pipe=piped_rule)
rule.execute()
# Asserting that the output of the original rule - which in this case
# the input as well - is passed to the piped rule as an input.
piped_rule.execute.assert_called_once_with(rule.param)
def test_documentation(mock_full_strip):
expected_description = "test description"
expected_documentation = "test docstring"
mock_full_strip.side_effect = [
expected_description, expected_documentation
]
rule = ExampleRule(name="Test", param="Rule")
documentation = f"{rule.name}\n{expected_description}\n{expected_documentation}"
assert rule.documentation == documentation
mock_full_strip.has_calls(
[call(expected_description),
call(expected_documentation)])
def test_executed(name: str, param: Any, mocked_config):
mocked_config.settings.dry_run = False
rule = ExampleRule(name=name, param=param)
rule.pre_task_hook = Mock()
rule.post_task_hook = Mock()
rule.task = Mock()
rule.execute(param)
rule.task.assert_called_once_with()
rule.pre_task_hook.assert_called_once_with()
rule.post_task_hook.assert_called_once_with()
def test_cannot_proceed_dry_run(config):
config.dry_run = True
rule = ExampleRule(name="Test", param="Rule")
rule.pre_task_hook = Mock()
rule.post_task_hook = Mock()
with pytest.raises(AssertionError) as exc:
rule.execute("Rule")
assert str(exc.value) == '"Test" cannot proceed because of dry run'
assert not rule.pre_task_hook.called
assert not rule.post_task_hook.called
def test_executed_no_direct_param(mocked_config):
"""
This test case covers the situation of piped and child rules
which has no direct parameter (it is set to None), but getting
it from the output of the previous rule as an input.
"""
mocked_config.settings.dry_run = False
rule = ExampleRule(name="Test", param=None)
rule.param = "Rule"
rule.pre_task_hook = Mock()
rule.post_task_hook = Mock()
rule.task = Mock()
rule.execute()
rule.task.assert_called_once_with()
rule.pre_task_hook.assert_called_once_with()
rule.post_task_hook.assert_called_once_with()
def test_cannot_proceed_precondition(mocked_config):
mocked_config.settings.dry_run = False
rule = ExampleRule(
name="Test",
param="Rule",
preconditions=(
copy.deepcopy(FAILING_PRECONDITION),
copy.deepcopy(PASSING_PRECONDITION),
),
)
rule.pre_task_hook = Mock()
rule.post_task_hook = Mock()
with pytest.raises(PreconditionFailedError) as exc:
rule.execute("Rule")
assert str(exc.value) == '"Test" cannot proceed'
assert not rule.pre_task_hook.called
assert not rule.post_task_hook.called
def test_generate_pull_request_body_with_chained_rules():
failed_rule = ExampleRule(
name="Test failed rule 1",
param=Mock(),
preconditions=[PASSING_PRECONDITION],
children=[get_passing_rule("Child rule")],
)
failed_rule.made_changes = False
passing_rule = ExampleRule(
name="Test rule 1",
param=Mock(),
preconditions=[PASSING_PRECONDITION],
children=[get_passing_rule("Passing child rule")],
)
failed_execution_law = Law(
name="Test law 1",
description="Test description 1",
rules=[passing_rule, failed_rule],
)
failed_execution_law._failed_rules = (failed_rule,)
mocked_pillar = Mock()
mocked_pillar.laws = [
failed_execution_law,
Law(
name="Test law 2",
description="Test description 2",
rules=[ExampleRule(name="Test rule 2", param=Mock())],
),
Law(
name="Test law 3",
description="Test description 3",
rules=[
ExampleRule(name="Test rule 3", param=Mock()),
ExampleRule(name="Test rule 4", param=Mock()),
],
),
]
expected_body = """## Description
Below you can find the executed laws and information about them.
### Test law 1
Test description 1
<details>
<summary>Passed rules</summary>
* Test rule 1
* Passing child rule
</details>
<details open>
<summary>Failed rules (manual fix needed)</summary>
* Test failed rule 1
* Child rule
</details>
### Test law 2
Test description 2
<details>
<summary>Passed rules</summary>
* Test rule 2
</details>
### Test law 3
Test description 3
<details>
<summary>Passed rules</summary>
* Test rule 3
* Test rule 4
</details>"""
pr_helper = get_pull_request_helper_mixin_consumer()
body = pr_helper.generate_pull_request_body(mocked_pillar)
assert body == expected_body
def test_execute_children(mocked_config):
mocked_config.settings.dry_run = False
child_rule_1 = ExampleRule(name="Test", param=None)
child_rule_1.execute = Mock()
child_rule_2 = ExampleRule(name="Test", param=None)
child_rule_2.execute = Mock()
child_rule_3 = ExampleRule(name="Test", param=None)
child_rule_3.execute = Mock()
rule = ExampleRule(name="Test",
param="Rule",
children=[child_rule_1, child_rule_2, child_rule_3])
rule.execute()
child_rule_1.execute.assert_called_once_with(rule.param)
child_rule_2.execute.assert_called_once_with(rule.param)
child_rule_3.execute.assert_called_once_with(rule.param)
def test_rule_chain_no_rule():
rule_1 = ExampleRule(name="rule_1", param="rule_1")
chain = rule_1.get_rule_chain(rule_1)
assert chain == [rule_1]
def test_rule_chain():
rule_1 = ExampleRule(name="rule_1", param="rule_1")
rule_2 = ExampleRule(name="rule_2", param="rule_2")
rule_3 = ExampleRule(name="rule_3", param="rule_3")
rule_4 = ExampleRule(name="rule_4", param="rule_4")
rule_5 = ExampleRule(name="rule_5", param="rule_5")
rule_6 = ExampleRule(name="rule_6", param="rule_6")
rule_7 = ExampleRule(name="rule_7", param="rule_7")
rule_1.pipe = rule_2
rule_1.preconditions = [FAILING_PRECONDITION]
rule_1.children = [rule_3, rule_4, rule_7]
rule_4.pipe = rule_5
rule_5.children = [rule_6]
rule_5.preconditions = [PASSING_PRECONDITION]
expected_chain_order = [
FAILING_PRECONDITION,
rule_1,
rule_2,
rule_3,
rule_4,
PASSING_PRECONDITION,
rule_5,
rule_6,
rule_7,
]
chain = rule_1.get_rule_chain(rule_1)
assert chain == expected_chain_order
def test_validate_no_casting(value):
rule = ExampleRule(name="Test", param="Rule")
result = rule.validate(val=value)
assert result is value
def test_str():
expected = "Test rule"
rule = ExampleRule(name="Test", param="Rule")
assert str(rule) == expected
def test_validate_param_empty():
rule = ExampleRule(name="Test", param="Rule")
result = rule.validate(val=None, cast_to=str)
assert result == "None"