Summary  
This chapter demonstrates how to use the str() function to convert non-string values into strings for concatenation in code.

General domain of usage  
Formatting printed output

import unittest

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):
    # Expected values based on the provided starter data
    EXP_AGE = 19
    EXP_HAS_ID = True
    EXP_TIER = "VIP"
    EXP_SEAT_NUMBER_STR = "023"
    EXP_ZONE = "A"
    EXP_SEAT_NUMBER = 23

    EXP_IS_ADULT = True
    EXP_CAN_ENTER = True
    EXP_VIP_PERK = True
    EXP_MEMBER_FASTLANE = False
    EXP_SEAT_OK = True
    EXP_ENTRY_GRANTED = True

    EXP_SUMMARY = (
        f"{EXP_TIER}-{EXP_SEAT_NUMBER_STR}-{EXP_ZONE} | "
        f"age={EXP_AGE} | enter={EXP_ENTRY_GRANTED} | "
        f"vip={EXP_VIP_PERK} | fastlane={EXP_MEMBER_FASTLANE}"
    )

    def test_age_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, "age"),
            "The `age` variable is declared.",
            "Expected `age` to be declared."
        )

    def test_has_id_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, "has_id"),
            "The `has_id` variable is declared.",
            "Expected `has_id` to be declared."
        )

    def test_conversions_values_and_types(self):
        import user_code
        try:
            age_ok = isinstance(user_code.age, int) and user_code.age == self.EXP_AGE
            has_id_ok = isinstance(user_code.has_id, bool) and user_code.has_id == self.EXP_HAS_ID
            condition = age_ok and has_id_ok
            failure = (
                f"Expected `age` to be int `{self.EXP_AGE}` and `has_id` to be bool `{self.EXP_HAS_ID}`, "
                f"but got `age={getattr(user_code, 'age', None)}` and `has_id={getattr(user_code, 'has_id', None)}`."
            )
        except Exception as e:
            condition = False
            failure = f"Could not validate `age` and `has_id` due to an error: {type(e).__name__}."
        _dynamic_test(
            self,
            condition,
            f"`age` is `{self.EXP_AGE}` (int) and `has_id` is `{self.EXP_HAS_ID}` (bool).",
            failure
        )

    def test_ticket_parts_declared(self):
        import user_code
        needed = ["tier", "seat_number_str", "zone", "seat_number"]
        missing = [v for v in needed if not hasattr(user_code, v)]
        _dynamic_test(
            self,
            len(missing) == 0,
            "Ticket parts variables are declared (`tier`, `seat_number_str`, `zone`, `seat_number`).",
            f"Expected these variables to be declared: {', '.join(missing) if missing else '(none)'}."
        )

    def test_ticket_parts_values(self):
        import user_code
        try:
            condition = (
                user_code.tier == self.EXP_TIER and
                user_code.seat_number_str == self.EXP_SEAT_NUMBER_STR and
                user_code.zone == self.EXP_ZONE and
                user_code.seat_number == self.EXP_SEAT_NUMBER
            )
            failure = (
                f"Expected tier/seat/zone/seat_number to be "
                f"`{self.EXP_TIER}`, `{self.EXP_SEAT_NUMBER_STR}`, `{self.EXP_ZONE}`, `{self.EXP_SEAT_NUMBER}`, "
                f"but got `{getattr(user_code, 'tier', None)}`, `{getattr(user_code, 'seat_number_str', None)}`, "
                f"`{getattr(user_code, 'zone', None)}`, `{getattr(user_code, 'seat_number', None)}`."
            )
        except Exception as e:
            condition = False
            failure = f"Could not validate ticket parts due to an error: {type(e).__name__}."
        _dynamic_test(
            self,
            condition,
            "Ticket parts parsed correctly.",
            failure
        )

    def test_rules_declared(self):
        import user_code
        names = ["is_adult", "can_enter", "vip_perk", "member_fastlane", "seat_ok", "entry_granted"]
        missing = [n for n in names if not hasattr(user_code, n)]
        _dynamic_test(
            self,
            len(missing) == 0,
            "All rule variables are declared.",
            f"Expected these rule variables to be declared: {', '.join(missing) if missing else '(none)'}."
        )

    def test_rules_values(self):
        import user_code
        try:
            condition = (
                user_code.is_adult == self.EXP_IS_ADULT and
                user_code.can_enter == self.EXP_CAN_ENTER and
                user_code.vip_perk == self.EXP_VIP_PERK and
                user_code.member_fastlane == self.EXP_MEMBER_FASTLANE and
                user_code.seat_ok == self.EXP_SEAT_OK and
                user_code.entry_granted == self.EXP_ENTRY_GRANTED
            )
            failure = (
                "Expected rules to be: "
                f"is_adult={self.EXP_IS_ADULT}, can_enter={self.EXP_CAN_ENTER}, vip_perk={self.EXP_VIP_PERK}, "
                f"member_fastlane={self.EXP_MEMBER_FASTLANE}, seat_ok={self.EXP_SEAT_OK}, entry_granted={self.EXP_ENTRY_GRANTED}, "
                f"but got: is_adult={getattr(user_code, 'is_adult', None)}, can_enter={getattr(user_code, 'can_enter', None)}, "
                f"vip_perk={getattr(user_code, 'vip_perk', None)}, member_fastlane={getattr(user_code, 'member_fastlane', None)}, "
                f"seat_ok={getattr(user_code, 'seat_ok', None)}, entry_granted={getattr(user_code, 'entry_granted', None)}."
            )
        except Exception as e:
            condition = False
            failure = f"Could not validate rules due to an error: {type(e).__name__}."
        _dynamic_test(
            self,
            condition,
            "Rules computed correctly.",
            failure
        )

    def test_summary_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, "summary"),
            "The `summary` variable is declared.",
            "Expected `summary` to be declared."
        )

    def test_summary_value(self):
        import user_code
        try:
            actual = user_code.summary
            condition = actual == self.EXP_SUMMARY
            failure = f"Expected `summary` to be `{self.EXP_SUMMARY}`, but got `{actual}`."
        except Exception as e:
            condition = False
            failure = f"Could not validate `summary` due to an error: {type(e).__name__}."
        _dynamic_test(
            self,
            condition,
            "Summary string computed correctly.",
            failure
        )


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


test_main.py

A focused, beginner-friendly course on working with numbers in Python. Learn about integers, floats, arithmetic operations, type conversion, and how to avoid common pitfalls when handling numerical data.

Challenge: Access & Ticket Perks Engine

Løsning