import unittest
import importlib
import re

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

class TestUserCode(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        cls.m = importlib.import_module('user_code')
        with open('user_code.py', 'r', encoding='utf-8') as f:
            cls.src = f.read()

        # Expected outcomes from the fixed inputs
        cls.expected_is_adult = (17 >= 18)                     # False
        cls.expected_can_enter = (True and cls.expected_is_adult)  # False
        cls.expected_free_shipping = (120.0 >= 100.0) or False     # True
        cls.expected_eligible_discount = (False and (120.0 >= 80.0)) or ((not False) and (120.0 >= 150.0))  # False
        cls.expected_needs_review = (not True) or (not False)  # True
        cls.expected_valid_score_range = (0 <= 74 <= 100)      # True

    # 1) is_adult
    def test_is_adult_group(self):
        declared = hasattr(self.m, 'is_adult')
        is_bool = isinstance(getattr(self.m, 'is_adult', None), bool)
        correct_value = declared and (self.m.is_adult == self.expected_is_adult)

        pattern = r"""is_adult\s*=\s*[^#\n]*age[^#\n]*>=\s*[^#\n]*adult_age"""
        used_cmp = re.search(pattern, self.src, re.MULTILINE) is not None

        _dynamic_test(
            self,
            declared and is_bool and correct_value and used_cmp,
            "is_adult computed correctly",
            "is_adult computed incorrectly"
        )

    # 2) can_enter
    def test_can_enter_group(self):
        declared = hasattr(self.m, 'can_enter')
        is_bool = isinstance(getattr(self.m, 'can_enter', None), bool)
        correct_value = declared and (self.m.can_enter == self.expected_can_enter)

        pattern = r"""can_enter\s*=\s*[^#\n]*has_id[^#\n]*and[^#\n]*is_adult"""
        used_and = re.search(pattern, self.src, re.MULTILINE) is not None

        _dynamic_test(
            self,
            declared and is_bool and correct_value and used_and,
            "can_enter computed correctly",
            "can_enter computed incorrectly"
        )

    # 3) qualifies_free_shipping
    def test_free_shipping_group(self):
        declared = hasattr(self.m, 'qualifies_free_shipping')
        is_bool = isinstance(getattr(self.m, 'qualifies_free_shipping', None), bool)
        correct_value = declared and (self.m.qualifies_free_shipping == self.expected_free_shipping)

        pattern = r"""qualifies_free_shipping\s*=\s*[^#\n]*purchase_total[^#\n]*>=\s*[^#\n]*free_shipping_threshold[^#\n]*or[^#\n]*is_member"""
        used_cmp_or = re.search(pattern, self.src, re.MULTILINE) is not None

        _dynamic_test(
            self,
            declared and is_bool and correct_value and used_cmp_or,
            "qualifies_free_shipping computed correctly",
            "qualifies_free_shipping computed incorrectly"
        )

    # 4) eligible_discount
    def test_eligible_discount_group(self):
        declared = hasattr(self.m, 'eligible_discount')
        is_bool = isinstance(getattr(self.m, 'eligible_discount', None), bool)
        correct_value = declared and (self.m.eligible_discount == self.expected_eligible_discount)
    
        # Branch structure checks (multiline-safe)
        left_branch = re.search(
            r"""is_member[^#\n]*and[^#\n]*purchase_total[^#\n]*>=\s*member_min_spend""",
            self.src, re.DOTALL
        ) is not None
        right_branch = re.search(
            r"""not\s*is_member[^#\n]*and[^#\n]*purchase_total[^#\n]*>=\s*guest_min_spend""",
            self.src, re.DOTALL
        ) is not None
    
        # Ensure the two branches are joined by 'or' in the eligible_discount assignment
        used_or_between_branches = re.search(
            r"""eligible_discount\s*=\s*\(.*?\)\s*or\s*\(.*?\)""",
            self.src, re.DOTALL
        ) is not None

        _dynamic_test(
            self,
            declared and is_bool and correct_value and left_branch and right_branch and used_or_between_branches,
            "eligible_discount computed correctly",
            "eligible_discount computed incorrectly"
        )


    # 5) needs_manual_review
    def test_needs_review_group(self):
        declared = hasattr(self.m, 'needs_manual_review')
        is_bool = isinstance(getattr(self.m, 'needs_manual_review', None), bool)
        correct_value = declared and (self.m.needs_manual_review == self.expected_needs_review)

        pattern = r"""needs_manual_review\s*=\s*[^#\n]*not\s*email_verified[^#\n]*or[^#\n]*not\s*phone_verified"""
        used_not_or = re.search(pattern, self.src, re.MULTILINE) is not None

        _dynamic_test(
            self,
            declared and is_bool and correct_value and used_not_or,
            "needs_manual_review computed correctly",
            "needs_manual_review computed incorrectly"
        )

    # 6) valid_score_range (chained)
    def test_valid_score_range_group(self):
        declared = hasattr(self.m, 'valid_score_range')
        is_bool = isinstance(getattr(self.m, 'valid_score_range', None), bool)
        correct_value = declared and (self.m.valid_score_range == self.expected_valid_score_range)

        pattern = r"""min_score[^#\n]*<=\s*score\s*<=\s*max_score"""
        used_chain = re.search(pattern, self.src, re.MULTILINE) is not None

        _dynamic_test(
            self,
            declared and is_bool and correct_value and used_chain,
            "valid_score_range computed correctly",
            "valid_score_range computed incorrectly"
        )

if __name__ == '__main__':
    unittest.main()


test_code.py

This course is going to help you dive deeper into data types and try to work with them. Here you will learn basic operations and all ins and outs of numbers, boolean data type, and strings. This course consists of a lot of practical tasks after which you will become a skillful programmer.

Numerical data types are fundamental in Python, forming the backbone of many computational tasks. In this section, you'll dive into the essentials of working with integers and floating-point numbers, performing basic mathematical operations, and understanding the real-world applications of numerical data. You'll also explore critical concepts such as immutability and gain hands-on experience with Python’s built-in functions and tools for handling numbers effectively.

The main goal of this section is to clarify the boolean data types; it's a sub type of numeric data, but indeed it is more challenging. Since it is always better to excel in the more difficult topics, this section is a valuable part of your curriculum.

Strings are a way for us to implement your phrases in Python, that is, to give instructions to users who are the target audience of your program. Indeed, it is always better to be able to work with strings because they should be used in your code. You'll understand why soon.

Change values to the kind you need, clean text before comparing, and keep math strictly with numbers while formatting results for people to read. Mark missing data clearly and handle it on purpose, and treat human text differently from raw file or network content. The goals are fewer mistakes, reliable comparisons, consistent results, and clear, readable output.


This chapter consists of practical tasks that combine all the examined topics together with a bit of theory.

Challenge: Access and Perks Checker

Solution

Awesome!

Challenge: Access and Perks Checker

Solution

Awesome!