Grinch-AP/worlds/stardew_valley/test/TestStardewRule.py

import unittest
from unittest.mock import MagicMock, Mock

from ..stardew_rule import Received, And, Or, HasProgressionPercent, false_, true_


class TestSimplification(unittest.TestCase):
    """
    Those feature of simplifying the rules when they are built have proven to improve the fill speed considerably.
    """

    def test_simplify_and_and_and(self):
        rule = And(Received('Summer', 0, 1), Received('Fall', 0, 1)) & And(Received('Winter', 0, 1), Received('Spring', 0, 1))

        self.assertEqual(And(Received('Summer', 0, 1), Received('Fall', 0, 1), Received('Winter', 0, 1), Received('Spring', 0, 1)), rule)

    def test_simplify_and_in_and(self):
        rule = And(And(Received('Summer', 0, 1), Received('Fall', 0, 1)), And(Received('Winter', 0, 1), Received('Spring', 0, 1)))
        self.assertEqual(And(Received('Summer', 0, 1), Received('Fall', 0, 1), Received('Winter', 0, 1), Received('Spring', 0, 1)), rule)

    def test_simplify_duplicated_and(self):
        # This only works because "Received"s are combinable.
        rule = And(And(Received('Summer', 0, 1), Received('Fall', 0, 1)), And(Received('Summer', 0, 1), Received('Fall', 0, 1)))
        self.assertEqual(And(Received('Summer', 0, 1), Received('Fall', 0, 1)), rule)

    def test_simplify_or_or_or(self):
        rule = Or(Received('Summer', 0, 1), Received('Fall', 0, 1)) | Or(Received('Winter', 0, 1), Received('Spring', 0, 1))
        self.assertEqual(Or(Received('Summer', 0, 1), Received('Fall', 0, 1), Received('Winter', 0, 1), Received('Spring', 0, 1)), rule)

    def test_simplify_or_in_or(self):
        rule = Or(Or(Received('Summer', 0, 1), Received('Fall', 0, 1)), Or(Received('Winter', 0, 1), Received('Spring', 0, 1)))
        self.assertEqual(Or(Received('Summer', 0, 1), Received('Fall', 0, 1), Received('Winter', 0, 1), Received('Spring', 0, 1)), rule)

    def test_simplify_duplicated_or(self):
        rule = Or(Or(Received('Summer', 0, 1), Received('Fall', 0, 1)), Or(Received('Summer', 0, 1), Received('Fall', 0, 1)))
        self.assertEqual(Or(Received('Summer', 0, 1), Received('Fall', 0, 1)), rule)


class TestHasProgressionPercentSimplification(unittest.TestCase):
    def test_has_progression_percent_and_uses_max(self):
        rule = HasProgressionPercent(1, 20) & HasProgressionPercent(1, 10)
        self.assertEqual(rule, HasProgressionPercent(1, 20))

    def test_has_progression_percent_or_uses_min(self):
        rule = HasProgressionPercent(1, 20) | HasProgressionPercent(1, 10)
        self.assertEqual(rule, HasProgressionPercent(1, 10))

    def test_and_between_progression_percent_and_other_progression_percent_uses_max(self):
        cases = [
            And(HasProgressionPercent(1, 10)) & HasProgressionPercent(1, 20),
            HasProgressionPercent(1, 10) & And(HasProgressionPercent(1, 20)),
            And(HasProgressionPercent(1, 20)) & And(HasProgressionPercent(1, 10)),
        ]
        for i, case in enumerate(cases):
            with self.subTest(f"{i} {repr(case)}"):
                self.assertEqual(case, And(HasProgressionPercent(1, 20)))

    def test_or_between_progression_percent_and_other_progression_percent_uses_max(self):
        cases = [
            Or(HasProgressionPercent(1, 10)) | HasProgressionPercent(1, 20),
            HasProgressionPercent(1, 10) | Or(HasProgressionPercent(1, 20)),
            Or(HasProgressionPercent(1, 20)) | Or(HasProgressionPercent(1, 10))
        ]
        for i, case in enumerate(cases):
            with self.subTest(f"{i} {repr(case)}"):
                self.assertEqual(case, Or(HasProgressionPercent(1, 10)))


class TestEvaluateWhileSimplifying(unittest.TestCase):
    def test_propagate_evaluate_while_simplifying(self):
        expected_result = True
        collection_state = MagicMock()
        other_rule = MagicMock()
        other_rule.evaluate_while_simplifying = Mock(return_value=(other_rule, expected_result))
        rule = And(Or(other_rule))

        _, actual_result = rule.evaluate_while_simplifying(collection_state)

        other_rule.evaluate_while_simplifying.assert_called_with(collection_state)
        self.assertEqual(expected_result, actual_result)

    def test_return_complement_when_its_found(self):
        expected_simplified = false_
        expected_result = False
        collection_state = MagicMock()
        rule = And(expected_simplified)

        actual_simplified, actual_result = rule.evaluate_while_simplifying(collection_state)

        self.assertEqual(expected_result, actual_result)
        self.assertEqual(expected_simplified, actual_simplified)

    def test_short_circuit_when_complement_found(self):
        collection_state = MagicMock()
        other_rule = MagicMock()
        rule = Or(true_, )

        rule.evaluate_while_simplifying(collection_state)

        other_rule.evaluate_while_simplifying.assert_not_called()

    def test_short_circuit_when_combinable_rules_is_false(self):
        collection_state = MagicMock()
        other_rule = MagicMock()
        rule = And(HasProgressionPercent(1, 10), other_rule)

        rule.evaluate_while_simplifying(collection_state)

        other_rule.evaluate_while_simplifying.assert_not_called()

    def test_identity_is_removed_from_other_rules(self):
        collection_state = MagicMock()
        rule = Or(false_, HasProgressionPercent(1, 10))

        rule.evaluate_while_simplifying(collection_state)

        self.assertEqual(1, len(rule.current_rules))
        self.assertIn(HasProgressionPercent(1, 10), rule.current_rules)

    def test_complement_replaces_combinable_rules(self):
        collection_state = MagicMock()
        rule = Or(HasProgressionPercent(1, 10), true_)

        rule.evaluate_while_simplifying(collection_state)

        self.assertTrue(rule.current_rules)

    def test_simplifying_to_complement_propagates_complement(self):
        expected_simplified = true_
        expected_result = True
        collection_state = MagicMock()
        rule = Or(Or(expected_simplified), HasProgressionPercent(1, 10))

        actual_simplified, actual_result = rule.evaluate_while_simplifying(collection_state)

        self.assertEqual(expected_result, actual_result)
        self.assertEqual(expected_simplified, actual_simplified)
        self.assertTrue(rule.current_rules)

    def test_already_simplified_rules_are_not_simplified_again(self):
        collection_state = MagicMock()
        other_rule = MagicMock()
        other_rule.evaluate_while_simplifying = Mock(return_value=(other_rule, False))
        rule = Or(other_rule, HasProgressionPercent(1, 10))

        rule.evaluate_while_simplifying(collection_state)
        other_rule.assert_not_called()
        other_rule.evaluate_while_simplifying.reset_mock()

        rule.evaluate_while_simplifying(collection_state)
        other_rule.assert_called_with(collection_state)
        other_rule.evaluate_while_simplifying.assert_not_called()

    def test_continue_simplification_after_short_circuited(self):
        collection_state = MagicMock()
        a_rule = MagicMock()
        a_rule.evaluate_while_simplifying = Mock(return_value=(a_rule, False))
        another_rule = MagicMock()
        another_rule.evaluate_while_simplifying = Mock(return_value=(another_rule, False))
        rule = And(a_rule, another_rule)

        rule.evaluate_while_simplifying(collection_state)
        # This test is completely messed up because sets are used internally and order of the rules cannot be ensured.
        not_yet_simplified, already_simplified = (another_rule, a_rule) if a_rule.evaluate_while_simplifying.called else (a_rule, another_rule)
        not_yet_simplified.evaluate_while_simplifying.assert_not_called()
        already_simplified.return_value = True

        rule.evaluate_while_simplifying(collection_state)
        not_yet_simplified.evaluate_while_simplifying.assert_called_with(collection_state)


class TestEvaluateWhileSimplifyingDoubleCalls(unittest.TestCase):
    """
    So, there is a situation where a rule kind of calls itself while it's being evaluated, because its evaluation triggers a region cache refresh.

    The region cache check every entrance, so if a rule is also used in an entrances, it can be reevaluated.

    For instance, but not limited to
    Has Melon -> (Farm & Summer) | Greenhouse -> Greenhouse triggers an update of the region cache
        -> Every entrance are evaluated, for instance "can start farming" -> Look that any crop can be grown (calls Has Melon).
    """

    def test_nested_call_in_the_internal_rule_being_evaluated_does_check_the_internal_rule(self):
        collection_state = MagicMock()
        internal_rule = MagicMock()
        rule = Or(internal_rule)

        called_once = False
        internal_call_result = None

        def first_call_to_internal_rule(state):
            nonlocal internal_call_result
            nonlocal called_once
            if called_once:
                return internal_rule, True
            called_once = True

            _, internal_call_result = rule.evaluate_while_simplifying(state)
            internal_rule.evaluate_while_simplifying = Mock(return_value=(internal_rule, True))
            return internal_rule, True

        internal_rule.evaluate_while_simplifying = first_call_to_internal_rule

        rule.evaluate_while_simplifying(collection_state)

        self.assertTrue(called_once)
        self.assertTrue(internal_call_result)

    def test_nested_call_to_already_simplified_rule_does_not_steal_rule_to_simplify_from_parent_call(self):
        collection_state = MagicMock()
        an_internal_rule = MagicMock()
        an_internal_rule.evaluate_while_simplifying = Mock(return_value=(an_internal_rule, True))
        another_internal_rule = MagicMock()
        another_internal_rule.evaluate_while_simplifying = Mock(return_value=(another_internal_rule, True))
        rule = Or(an_internal_rule, another_internal_rule)

        rule.evaluate_while_simplifying(collection_state)
        # This test is completely messed up because sets are used internally and order of the rules cannot be ensured.
        if an_internal_rule.evaluate_while_simplifying.called:
            not_yet_simplified, already_simplified = another_internal_rule, an_internal_rule
        else:
            not_yet_simplified, already_simplified = an_internal_rule, another_internal_rule

        called_once = False
        internal_call_result = None

        def call_to_already_simplified(state):
            nonlocal internal_call_result
            nonlocal called_once
            if called_once:
                return False
            called_once = True

            _, internal_call_result = rule.evaluate_while_simplifying(state)
            return False

        already_simplified.side_effect = call_to_already_simplified
        not_yet_simplified.return_value = True

        _, actual_result = rule.evaluate_while_simplifying(collection_state)

        self.assertTrue(called_once)
        self.assertTrue(internal_call_result)
        self.assertTrue(actual_result)