import unittest
import importlib

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 TestRegisterUser(unittest.TestCase):
    def setUp(self):
        """Reset users_db before each test"""
        import user_code
        user_code.users_db.clear()

    def test_successful_registration(self):
        import user_code
        try:
            result = user_code.register_user(
                username="Test",
                email="test@example.com",
                age=18
            )
            expected_output = "User Test registered successfully!"
            condition = result == expected_output
            failure_message = (
                "The success message should use the provided `username` parameter. "
                f"For input ('Test', 'test@example.com', 18), expected "
                f"`{expected_output}`, but got `{result}`."
            )
        except AttributeError:
            condition = False
            failure_message = "The function `register_user` is not defined."

        _dynamic_test(
            self,
            condition,
            "User is registered successfully with valid input.",
            failure_message
        )

    def test_user_count_after_registration(self):
        import user_code
        try:
            user_code.register_user("Test", "test@example.com", 18)
            condition = len(user_code.users_db) == 1
            failure_message = (
                "After one successful registration, `users_db` should contain exactly one user."
            )
        except AttributeError:
            condition = False
            failure_message = "The function `register_user` is not defined."

        _dynamic_test(
            self,
            condition,
            "User count after registration is correct.",
            failure_message
        )

    def test_user_data_after_registration(self):
        import user_code
        try:
            user_code.register_user("Test", "test@example.com", 18)
            registered_user = user_code.users_db[0]
            condition = (
                registered_user == {
                    "username": "Test",
                    "email": "test@example.com",
                    "age": 18
                }
            )
            failure_message = (
                "The user dictionary should be created from function parameters. "
                "Expected {'username': username, 'email': email, 'age': age} "
                f"but got {registered_user}."
            )
        except Exception:
            condition = False
            failure_message = (
                "User data was not stored correctly in `users_db`."
            )

        _dynamic_test(
            self,
            condition,
            "User data is stored correctly using function parameters.",
            failure_message
        )

    def test_underage_registration(self):
        import user_code
        try:
            result = user_code.register_user("Test", "test@example.com", 16)
            expected_output = "Registration failed: age must be 18 or older."
            condition = result == expected_output and len(user_code.users_db) == 0
            failure_message = (
                "Users under 18 should not be registered and `users_db` must remain empty."
            )
        except AttributeError:
            condition = False
            failure_message = "The function `register_user` is not defined."

        _dynamic_test(
            self,
            condition,
            "Underage users are blocked correctly.",
            failure_message
        )

    def test_multiple_registrations(self):
        import user_code
        try:
            user_code.register_user("Test", "test@example.com", 18)
            user_code.register_user("Another", "another@example.com", 30)
            condition = len(user_code.users_db) == 2
            failure_message = (
                "Each call to `register_user` should append a new user to `users_db`."
            )
        except AttributeError:
            condition = False
            failure_message = "The function `register_user` is not defined."

        _dynamic_test(
            self,
            condition,
            "Multiple users can be registered successfully.",
            failure_message
        )

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


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


test_main.py

Få en gedigen förståelse för hur funktioner formar Python-programmering. Behärska att definiera och anropa funktioner, arbeta med argument, hantera returvärden samt skapa flexibel och effektiv kod med rekursion och lambda-uttryck.

Utforska vad funktioner är och varför de är viktiga i Python. Lär dig hur man skapar funktioner, definierar argument, hanterar returvärden och använder inbyggda funktioner effektivt.

Lär dig hur positionella och valfria argument fungerar i Python. Skapa anpassningsbara funktioner som hanterar olika indata och förbättrar flexibiliteten i din kod.

Förstå hur man arbetar med godtyckliga och nyckelordsargument för att hantera variabla inmatningsstorlekar. Lär dig hur dessa tekniker gör dina funktioner mer dynamiska och organiserade.

Utforska hur returvärden representerar en funktions utdata. Lär dig att returnera enstaka eller flera värden, använda None samt undersöka generatorer för mer avancerad styrning av dataflöde.

Lås upp avancerade funktionskoncept med rekursion och lambda-funktioner. Utforska hur rekursion löser repetitiva problem och hur lambda-uttryck skapar koncisa, enradiga funktioner.

Utmaning: Positionella Argument

Lösning