wbcompliance 2.2.1__py2.py3-none-any.whl

wbcompliance/tests/risk_management/models/test_checks.py

@@ -0,0 +1,55 @@
+from datetime import timedelta
+
+import pandas as pd
+import pytest
+from faker import Faker
+from pandas.tseries.offsets import BDay
+
+fake = Faker()
+
+
+@pytest.mark.django_db
+class TestChecks:
+    def test_init(self, risk_check):
+        assert risk_check
+
+    @pytest.mark.parametrize("evaluation_date", [fake.date_object()])
+    def test_previous_check(self, risk_rule, risk_check_factory, rule_checked_object_relationship, evaluation_date):
+        check1 = risk_check_factory.create(
+            rule_checked_object_relationship=rule_checked_object_relationship, evaluation_date=evaluation_date
+        )
+        assert not check1.previous_check
+        check2 = risk_check_factory.create(
+            rule_checked_object_relationship=rule_checked_object_relationship, evaluation_date=evaluation_date
+        )
+        check3 = risk_check_factory.create(
+            rule_checked_object_relationship=rule_checked_object_relationship,
+            evaluation_date=evaluation_date + timedelta(days=1),
+        )
+
+        assert check2.previous_check is None
+        assert check3.previous_check == check2
+        # Shouldn't include this check in the queryset
+        other_check = risk_check_factory.create(
+            rule_checked_object_relationship=rule_checked_object_relationship,
+            evaluation_date=evaluation_date + timedelta(days=1),
+        )
+        assert other_check.previous_check == check2
+
+    def test_get_unchecked_dates(
+        self, weekday, risk_rule, risk_check_factory, rule_checked_object_relationship_factory
+    ):
+        rel = rule_checked_object_relationship_factory.create(rule=risk_rule)
+        maximum_day_interval = 10
+        assert list(rel.get_unchecked_dates(to_date=weekday, maximum_day_interval=maximum_day_interval)) == list(
+            map(lambda _d: _d.date(), pd.date_range(weekday - timedelta(days=maximum_day_interval), weekday, freq="B"))
+        )
+        risk_check = risk_check_factory.create(rule_checked_object_relationship=rel, evaluation_date=weekday)
+
+        assert list(rel.get_unchecked_dates()) == [(risk_check.evaluation_date + BDay(1)).date()]
+        assert list(rel.get_unchecked_dates(to_date=risk_check.evaluation_date)) == list()
+
+        risk_check2 = risk_check_factory.create(
+            rule_checked_object_relationship=rel, evaluation_date=risk_check.evaluation_date + BDay(1)
+        )
+        assert list(rel.get_unchecked_dates()) == [(risk_check2.evaluation_date + BDay(1)).date()]

wbcompliance/tests/risk_management/models/test_incidents.py

@@ -0,0 +1,327 @@
+from datetime import timedelta
+from unittest.mock import patch
+
+import pytest
+from django.contrib.auth import get_user_model
+from django.contrib.auth.models import Permission
+from django.contrib.contenttypes.models import ContentType
+from django.core.exceptions import ValidationError
+from faker import Faker
+from guardian.shortcuts import assign_perm
+from guardian.utils import get_anonymous_user
+from pandas.tseries.offsets import BDay
+from wbcompliance.models.risk_management.incidents import (
+    RiskIncident,
+    resolve_all_incidents_as_task,
+)
+from wbcompliance.models.risk_management.rules import RiskRule
+
+User = get_user_model()
+
+fake = Faker()
+
+
+@pytest.mark.django_db
+class TestRiskIncidentFactory:
+    def test_init(self, risk_incident):
+        assert risk_incident.computed_str
+
+    def test_closing_incident(self, risk_incident, checked_object_incident_relationship_factory):
+        checked_object_incident_relationship_factory.create(incident=risk_incident)
+        assert risk_incident.checked_object_relationships.filter(status=RiskIncident.Status.OPEN).exists()
+        risk_incident.status = RiskIncident.Status.CLOSED
+        risk_incident.save()
+        assert not risk_incident.checked_object_relationships.filter(status=RiskIncident.Status.OPEN).exists()
+
+    def test_incident_date_range(
+        self,
+        risk_incident,
+        checked_object_incident_relationship_factory,
+        risk_check_factory,
+        rule_checked_object_relationship_factory,
+    ):
+        rel1 = checked_object_incident_relationship_factory.create(incident=risk_incident)
+        checked_object_relationship = rule_checked_object_relationship_factory.create(rule=risk_incident.rule)
+        for i in range(7):
+            next_date = (rel1.incident_date + BDay(i)).date()
+            check = risk_check_factory.create(
+                evaluation_date=next_date, rule_checked_object_relationship=checked_object_relationship
+            )
+            checked_object_incident_relationship_factory.create(incident=risk_incident, rule_check=check)
+            risk_incident.refresh_from_db()
+            assert risk_incident.date_range.upper == next_date + timedelta(days=1)
+            assert RiskIncident.objects.count() == 1
+
+    def test_incident_always_max_severity(
+        self,
+        risk_incident_factory,
+        checked_object_incident_relationship_factory,
+        risk_incident_type_factory,
+    ):
+        minor_severity = risk_incident_type_factory.create(severity_order=0)
+        major_severity = risk_incident_type_factory.create(severity_order=1)
+        critical_severity = risk_incident_type_factory.create(severity_order=2)
+
+        incident = risk_incident_factory.create(severity=minor_severity)
+        assert incident.severity == minor_severity
+
+        checked_object_incident_relationship_factory.create(incident=incident, severity=minor_severity)
+        incident.save()
+        assert incident.severity == minor_severity
+
+        checked_object_incident_relationship_factory.create(incident=incident, severity=major_severity)
+        incident.save()
+        assert incident.severity == major_severity
+
+        incident.severity = critical_severity
+        incident.save()
+        assert incident.severity == critical_severity
+
+    @pytest.mark.parametrize(
+        "evaluation_date, is_breached_object",
+        [
+            (fake.date_object(), True),
+            (fake.date_object(), False),
+        ],
+    )
+    def test_get_or_create_incident(self, risk_rule, risk_incident_type, evaluation_date, is_breached_object):
+        if is_breached_object:
+            breached_object = get_anonymous_user()
+            breached_object_repr = str(get_anonymous_user())
+        else:
+            breached_object = None
+            breached_object_repr = fake.text(max_nb_chars=125)
+
+        assert not RiskIncident.objects.exists()
+        risk_rule.get_or_create_incident(evaluation_date, risk_incident_type, breached_object, breached_object_repr)
+        if breached_object:
+            assert (
+                RiskIncident.objects.filter(
+                    rule=risk_rule,
+                    date_range__contains=evaluation_date,
+                    breached_content_type=ContentType.objects.get_for_model(breached_object),
+                    breached_object_id=breached_object.id,
+                ).count()
+                == 1
+            )
+        else:
+            assert (
+                RiskIncident.objects.filter(
+                    rule=risk_rule, date_range__contains=evaluation_date, breached_object_repr=breached_object_repr
+                ).count()
+                == 1
+            )
+        assert RiskIncident.objects.count() == 1
+        # Check if we reevaluate this incident one business day later, the incident is consider the same
+        risk_rule.get_or_create_incident(
+            (evaluation_date + BDay(1)).date(), risk_incident_type, breached_object, breached_object_repr
+        )
+        assert RiskIncident.objects.count() == 1
+
+        # Check if we reevaluate this incident three business day later, the incident is consider the discontinue, and then a new incident is created
+        risk_rule.get_or_create_incident(
+            (evaluation_date + BDay(3)).date(), risk_incident_type, breached_object, breached_object_repr
+        )
+
+        assert RiskIncident.objects.count() == 2
+
+    def test_get_or_create_incident_with_resolve_incident(
+        self, risk_incident, checked_object_incident_relationship_factory
+    ):
+        subincident = checked_object_incident_relationship_factory.create(incident=risk_incident)
+        assert risk_incident.status == RiskIncident.Status.OPEN
+        risk_incident.resolve()
+        risk_incident.save()
+        assert risk_incident.status == RiskIncident.Status.RESOLVED
+        new_evaluation_date = subincident.rule_check.evaluation_date + timedelta(days=1)
+        incident, created = risk_incident.rule.get_or_create_incident(
+            new_evaluation_date,
+            subincident.severity,
+            risk_incident.breached_content_object,
+            risk_incident.breached_object_repr,
+        )
+        assert incident == risk_incident
+        assert incident.date_range.upper == new_evaluation_date
+
+    @pytest.mark.parametrize("incident_report", [fake.paragraph()])
+    def test_update_or_create_relationship(
+        self, risk_incident_factory, risk_check, incident_report, risk_incident_type
+    ):
+        risk_incident = risk_incident_factory.create(rule=risk_check.rule_checked_object_relationship.rule)
+        assert not risk_incident.checked_object_relationships.exists()
+        risk_incident.update_or_create_relationship(
+            risk_check, incident_report, dict(), fake.pyfloat(), risk_incident_type
+        )
+        assert risk_incident.checked_object_relationships.filter(
+            rule_check=risk_check, severity=risk_incident_type
+        ).exists()
+
+    @pytest.mark.parametrize(
+        "incident_report, override_incident",
+        [
+            (fake.paragraph(), True),
+            (fake.paragraph(), False),
+        ],
+    )
+    def test_update_or_create_relationship_already_existing(
+        self, risk_incident_factory, risk_check_factory, incident_report, risk_incident_type, override_incident
+    ):
+        check1 = risk_check_factory.create()
+        check2 = risk_check_factory.create(
+            rule_checked_object_relationship=check1.rule_checked_object_relationship,
+            evaluation_date=check1.evaluation_date,
+        )
+        risk_incident = risk_incident_factory.create(rule=check1.rule_checked_object_relationship.rule)
+
+        # We check the first time
+        initial_breached_value = str(fake.pyfloat())
+        risk_incident.update_or_create_relationship(
+            check1, incident_report, dict(), initial_breached_value, risk_incident_type
+        )
+        # verify that the relationship was created
+        assert risk_incident.checked_object_relationships.count() == 1
+        assert (
+            risk_incident.checked_object_relationships.filter(rule_check=check1, severity=risk_incident_type).count()
+            == 1
+        )
+
+        # Closing incident because open incident are override by default
+        risk_incident.status = RiskIncident.Status.CLOSED
+        risk_incident.save()
+        breached_value = str(fake.pyfloat())
+        risk_incident.update_or_create_relationship(
+            check2, incident_report, dict(), breached_value, risk_incident_type, override_incident
+        )
+        subincidents = risk_incident.checked_object_relationships.all()
+        if not override_incident:
+            assert subincidents.get(rule_check=check1).breached_value == initial_breached_value
+            assert subincidents.get(rule_check=check2).breached_value == breached_value
+        else:
+            assert subincidents.get(rule_check=check1).breached_value == breached_value
+            assert not subincidents.filter(rule_check=check2).exists()
+        # asser the parent incident were reopened
+        risk_incident.refresh_from_db()
+        if not override_incident:
+            assert risk_incident.status == RiskIncident.Status.OPEN
+        else:
+            assert risk_incident.status == RiskIncident.Status.CLOSED
+
+        if not override_incident:
+            risk_incident.status = RiskIncident.Status.CLOSED
+            risk_incident.save()
+            # we submit a new check the next day with the same breached value. We test if the parent incident remains close because of it
+            check3 = risk_check_factory.create(
+                rule_checked_object_relationship=check1.rule_checked_object_relationship,
+                evaluation_date=check1.evaluation_date + timedelta(days=1),
+            )
+            risk_incident.update_or_create_relationship(
+                check3, incident_report, dict(), breached_value, risk_incident_type
+            )
+            risk_incident.refresh_from_db()
+            assert risk_incident.status == RiskIncident.Status.CLOSED
+            assert (
+                subincidents.get(rule_check=check3, breached_value=breached_value).status == RiskIncident.Status.CLOSED
+            )
+
+    @patch.object(RiskIncident, "resolve_all_incidents")
+    @pytest.mark.parametrize("reviewer_comment", [(fake.paragraph())])
+    def test_resolve_all_incidents_as_task(self, mock_function, risk_incident, user, reviewer_comment):
+        resolve_all_incidents_as_task(user.id, reviewer_comment, risk_incident.id)
+        assert mock_function.call_count == 1
+
+    @pytest.mark.parametrize(
+        "is_superuser, is_admin",
+        [
+            (True, True),
+            (False, True),
+            (False, False),
+            (True, False),
+            (False, False),
+        ],
+    )
+    def test_can_manage_without_incident(self, user, is_superuser, is_admin):
+        if is_superuser:
+            user.is_superuser = True
+            user.save()
+        if is_admin:
+            admin_perm = Permission.objects.get(codename="administrate_riskrule")
+            user.user_permissions.add(admin_perm)
+        res = RiskIncident.can_manage(user)
+        assert res == (is_admin or is_superuser)
+
+    def test_can_manage_with_incident(self, user, risk_incident):
+        assert not RiskIncident.can_manage(user, risk_incident.rule)
+        assign_perm(RiskRule.change_perm_str, user, risk_incident.rule)
+        assert RiskIncident.can_manage(user, risk_incident.rule)
+
+    @pytest.mark.parametrize("risk_rule__automatically_close_incident", [True, False])
+    def test_post_workflow_change_status(self, risk_incident_factory, risk_rule):
+        risk_incident = risk_incident_factory.create(rule=risk_rule)
+        assert not risk_incident.status == RiskIncident.Status.CLOSED
+        risk_incident.post_workflow()
+        assert (
+            risk_incident.status == RiskIncident.Status.CLOSED
+            if risk_incident.rule.automatically_close_incident
+            else RiskIncident.Status.OPEN
+        )
+
+    def test_post_workflow_elevate_incident(self, risk_incident, rule_threshold_factory):
+        current_threshold = risk_incident.threshold
+        current_threshold.upgradable_after_days = risk_incident.business_days - 1
+        current_threshold.save()
+        next_threshold_1 = rule_threshold_factory.create(
+            rule=risk_incident.rule, upgradable_after_days=risk_incident.business_days - 1
+        )
+        assert next_threshold_1.severity.severity_order == 1
+        next_threshold_2 = rule_threshold_factory.create(rule=risk_incident.rule)
+        assert next_threshold_2.severity.severity_order == 2
+        assert risk_incident.threshold == current_threshold
+        risk_incident.post_workflow()
+        assert risk_incident.threshold == next_threshold_1
+        risk_incident.post_workflow()
+        assert risk_incident.threshold == next_threshold_2
+        risk_incident.post_workflow()
+        assert risk_incident.threshold == next_threshold_2
+
+
+@pytest.mark.django_db
+class TestCheckedObjectIncidentRelationshipFactory:
+    def test_init(self, rule_checked_object_relationship):
+        assert rule_checked_object_relationship
+
+    def test_init_checked_object_not_valid(
+        self,
+        checked_object_incident_relationship_factory,
+        rule_checked_object_relationship_factory,
+        risk_incident_factory,
+        risk_check_factory,
+    ):
+        rel_user = rule_checked_object_relationship_factory.create()
+        rel_other = rule_checked_object_relationship_factory.create(
+            checked_object_content_type=ContentType.objects.get_for_model(rel_user)
+        )
+
+        incident = risk_incident_factory.create(rule=rel_user.rule)
+        check = risk_check_factory.create(rule_checked_object_relationship=rel_other)
+        with pytest.raises(ValidationError):
+            checked_object_incident_relationship_factory.create(incident=incident, rule_check=check)
+
+    def test_init_backend_allowed_content_type_not_valid(
+        self,
+        checked_object_incident_relationship_factory,
+        rule_checked_object_relationship_factory,
+        risk_incident_factory,
+    ):
+        rel_user = rule_checked_object_relationship_factory.create()
+        rel_user.rule.rule_backend.allowed_checked_object_content_type = ContentType.objects.get_for_model(rel_user)
+        rel_user.rule.rule_backend.save()
+        incident = risk_incident_factory.create(rule=rel_user.rule)
+        with pytest.raises(ValidationError):
+            checked_object_incident_relationship_factory.create(incident=incident)
+
+    def test_checked_object(self, checked_object_incident_relationship):
+        assert checked_object_incident_relationship.checked_object
+        assert (
+            checked_object_incident_relationship.checked_object
+            == checked_object_incident_relationship.rule_check.rule_checked_object_relationship.checked_object
+        )

wbcompliance/tests/risk_management/models/test_rules.py

@@ -0,0 +1,255 @@
+import random
+from datetime import date, timedelta
+from unittest.mock import patch
+
+import pytest
+from django.contrib.auth.models import Group
+from django.contrib.contenttypes.models import ContentType
+from django.core.exceptions import ValidationError
+from faker import Faker
+from guardian.utils import get_anonymous_user
+from psycopg.types.range import NumericRange
+from wbcompliance.models import (
+    RiskIncident,
+    RiskRule,
+    RuleCheckedObjectRelationship,
+    RuleThreshold,
+)
+from wbcompliance.models.risk_management.rules import process_rule_as_task
+from wbcore.permissions.utils import perm_to_permission
+
+fake = Faker()
+
+
+@pytest.mark.django_db
+class TestRuleCheckedObjectRelationship:
+    def test_init(self, rule_checked_object_relationship):
+        assert rule_checked_object_relationship
+
+    def test_init_wrong_content_type(self, risk_rule, rule_checked_object_relationship_factory):
+        risk_rule.rule_backend.allowed_checked_object_content_type = ContentType.objects.get_for_model(RuleThreshold)
+        risk_rule.rule_backend.save()
+        with pytest.raises(ValidationError):
+            rule_checked_object_relationship_factory.create(
+                rule=risk_rule,
+                checked_object_content_type=ContentType.objects.get_for_model(RuleCheckedObjectRelationship),
+            )
+
+
+@pytest.mark.django_db
+class TestRuleBackend:
+    def test_init(self, rule_backend):
+        assert rule_backend
+
+    def test_backend_class(self, rule_backend):
+        assert rule_backend.backend_class.__module__
+        assert rule_backend.backend_class.__class__
+
+    @pytest.mark.parametrize("evaluation_date", [fake.date_object()])
+    def test_backend(self, rule_backend, risk_rule, evaluation_date):
+        assert rule_backend.backend(evaluation_date, risk_rule, risk_rule.parameters, RuleThreshold.objects.none())
+
+
+@pytest.mark.django_db
+class TestRuleThreshold:
+    def test_init(self, rule_threshold):
+        assert rule_threshold
+
+    @pytest.mark.parametrize(
+        "lower,upper,value,result",
+        [
+            (0, 1, random.random(), True),
+            (1, 2, random.random(), False),
+            (-1, 0, random.random(), False),
+            (None, 1, random.random(), True),
+            (0, None, random.random(), True),
+        ],
+    )
+    def test_is_inrange(self, rule_threshold_factory, lower, upper, value, result):
+        threshold = rule_threshold_factory.create(range=NumericRange(lower=lower, upper=upper))
+        assert threshold.is_inrange(value) == result
+
+    def test_get_notifiable_users(self, rule_threshold, user_factory):
+        assert not rule_threshold.get_notifiable_users().exists()
+        user = user_factory.create()
+        user_group = user_factory.create()
+        group_test = Group.objects.create(name="test")
+        user_group.groups.add(group_test)
+        rule_threshold.notifiable_users.add(user.profile)  # Add user to threshold person group
+        rule_threshold.notifiable_groups.add(group_test)  # Add user to threshold group
+        users = rule_threshold.get_notifiable_users()
+        assert set(users.values_list("id", flat=True)) == {user.id, user_group.id}
+
+
+@pytest.mark.django_db
+class TestRiskRule:
+    def test_init(self, risk_rule):
+        assert risk_rule
+
+    def test_checked_objects(self, risk_rule_factory, rule_threshold_factory):
+        rule = risk_rule_factory.create()
+        other_rule = risk_rule_factory.create()
+        threshold1 = rule_threshold_factory.create()
+        threshold2 = rule_threshold_factory.create()
+        RuleCheckedObjectRelationship.objects.create(checked_object=threshold1, rule=rule)
+        RuleCheckedObjectRelationship.objects.create(checked_object=get_anonymous_user(), rule=rule)
+        RuleCheckedObjectRelationship.objects.create(checked_object=threshold2, rule=other_rule)
+        assert set(rule.checked_objects) == {threshold1, get_anonymous_user()}
+
+    def test_checks(self, risk_rule_factory, rule_checked_object_relationship_factory, risk_check_factory):
+        rule = risk_rule_factory.create()
+        other_rule = risk_rule_factory.create()
+        rel1 = rule_checked_object_relationship_factory.create(rule=rule)
+        rel2 = rule_checked_object_relationship_factory.create(rule=rule)
+        other_rel = rule_checked_object_relationship_factory.create(rule=other_rule)
+        check1 = risk_check_factory.create(rule_checked_object_relationship=rel1)
+        check2 = risk_check_factory.create(rule_checked_object_relationship=rel2)
+        risk_check_factory.create(rule_checked_object_relationship=other_rel)
+        assert set(rule.checks.values_list("id", flat=True)) == {check1.id, check2.id}
+
+    @pytest.mark.parametrize(
+        "risk_rule__automatically_close_incident, evaluation_date, expected_incident_status",
+        [
+            (True, fake.date_object(), RiskIncident.Status.CLOSED),
+            (False, fake.date_object(), RiskIncident.Status.OPEN),
+        ],
+    )
+    def test_process_rule(
+        self,
+        risk_rule,
+        rule_checked_object_relationship_factory,
+        rule_threshold_factory,
+        evaluation_date,
+        expected_incident_status,
+    ):
+        rule_threshold_factory.create(rule=risk_rule)
+        rule_checked_object_relationship_factory.create(rule=risk_rule)
+
+        risk_rule.process_rule(evaluation_date)
+        incident = RiskIncident.objects.get(rule=risk_rule, status=expected_incident_status)
+        assert incident.checked_object_relationships.count() == 1
+
+    def test_get_permissions_for_user(self, risk_rule, user_factory):
+        user_with_permission = user_factory.create()
+        user_without_permission = user_factory.create()
+        user_with_permission.user_permissions.add(perm_to_permission(RiskRule.view_perm_str))
+        assert risk_rule.get_permissions_for_user(user_with_permission)[RiskRule.view_perm_str] is False
+        assert not risk_rule.get_permissions_for_user(user_without_permission)
+
+    def test_get_rules_for_object(self, risk_rule_factory, rule_checked_object_relationship_factory):
+        rule1 = risk_rule_factory.create()
+        rule2 = risk_rule_factory.create()
+
+        rule_checked_object_relationship_factory.create(rule=rule1)
+        rule_checked_object_relationship_factory.create(rule=rule2)
+
+        res = RiskRule.get_rules_for_object(get_anonymous_user())
+        assert res.exists()
+        assert set(res.values_list("id", flat=True)) == {rule1.id, rule2.id}
+
+    @patch.object(RiskRule, "process_rule")
+    @pytest.mark.parametrize(
+        "evaluation_date, override_incident",
+        [(fake.date_object(), fake.pybool())],
+    )
+    def test_process_rule_as_task(self, mock_function, risk_rule, evaluation_date, override_incident):
+        process_rule_as_task(risk_rule.id, evaluation_date, override_incident)
+        assert mock_function.call_count == 1
+
+    @patch("wbcompliance.models.risk_management.rules.send_notification")
+    def test_do_not_notify_no_open_incidents(
+        self,
+        mock_fct,
+        risk_incident_factory,
+        rule_checked_object_relationship,
+        risk_check_factory,
+        checked_object_incident_relationship_factory,
+    ):
+        risk_rule = rule_checked_object_relationship.rule
+        risk_incident = risk_incident_factory.create(rule=risk_rule)
+        sub_incident = checked_object_incident_relationship_factory.create(incident=risk_incident)
+
+        incident_date = sub_incident.incident_date
+        risk_rule.notify(incident_date)
+        assert mock_fct.call_count == 1
+
+        risk_incident.refresh_from_db()
+        assert risk_incident.is_notified is True
+
+        # renotifying this incident still triggers the method because the incident (even marked as notified) is still open
+        risk_rule.notify(incident_date)
+        assert mock_fct.call_count == 2
+
+        risk_incident.ignore()
+        risk_incident.save()
+        risk_rule.notify(incident_date)
+        assert mock_fct.call_count == 2
+
+        tomorrow = incident_date + timedelta(days=1)
+        tomorrow_risk_check = risk_check_factory.create(
+            rule_checked_object_relationship=rule_checked_object_relationship, evaluation_date=tomorrow
+        )
+        tomorrow_sub_incident = checked_object_incident_relationship_factory.create(  # noqa
+            rule_check=tomorrow_risk_check, incident=risk_incident
+        )
+
+        risk_incident.refresh_from_db()
+        assert risk_incident.status == RiskIncident.Status.OPEN
+        # the incident was already notified and is closed, so another subincident will mark the incident as open and retrigger notification
+        risk_rule.notify(tomorrow)
+        assert mock_fct.call_count == 3
+
+        after_tomorrow = tomorrow + timedelta(days=1)
+        risk_incident.ignore()
+        risk_incident.last_ignored_date = tomorrow
+        risk_incident.ignore_duration = timedelta(days=1)
+        risk_incident.save()
+
+        # this shoudn't reopen the incident
+        after_tomorrow_risk_check = risk_check_factory.create(
+            rule_checked_object_relationship=rule_checked_object_relationship, evaluation_date=after_tomorrow
+        )
+        after_tomorrow_sub_incident = checked_object_incident_relationship_factory.create(  # noqa
+            rule_check=after_tomorrow_risk_check, incident=risk_incident
+        )
+        risk_incident.refresh_from_db()
+        assert risk_incident.status == RiskIncident.Status.IGNORED
+        # then notify shouldn't happen
+        risk_rule.notify(after_tomorrow)
+        assert mock_fct.call_count == 3
+
+    def test_is_evaluation_date_valid(self, risk_rule):
+        risk_rule.activation_date = None
+        risk_rule.save()
+        assert risk_rule.is_evaluation_date_valid(fake.date_object()) is False
+
+        activation_date = fake.date_object()
+        risk_rule.activation_date = activation_date
+        risk_rule.save()
+        assert (
+            risk_rule.is_evaluation_date_valid(
+                fake.date_between(activation_date, activation_date + timedelta(days=365))
+            )
+            is True
+        )
+        assert (
+            risk_rule.is_evaluation_date_valid(
+                fake.date_between(activation_date - timedelta(days=365), activation_date - timedelta(days=1))
+            )
+            is False
+        )
+
+        # enable a rule to be checked every week on monday (i.e. every monday)
+        activation_date = date(2024, 11, 25)  # Monday
+        risk_rule.activation_date = activation_date
+        risk_rule.frequency = "RRULE:FREQ=WEEKLY"
+        risk_rule.save()
+
+        assert risk_rule.is_evaluation_date_valid(date(2024, 11, 25)) is True
+        assert risk_rule.is_evaluation_date_valid(date(2024, 11, 26)) is False
+        assert risk_rule.is_evaluation_date_valid(date(2024, 11, 27)) is False
+        assert risk_rule.is_evaluation_date_valid(date(2024, 11, 28)) is False
+        assert risk_rule.is_evaluation_date_valid(date(2024, 11, 29)) is False
+        assert risk_rule.is_evaluation_date_valid(date(2024, 11, 30)) is False
+        assert risk_rule.is_evaluation_date_valid(date(2024, 12, 1)) is False
+        assert risk_rule.is_evaluation_date_valid(date(2024, 12, 2)) is True