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

    def test_successful_addition(self):
        """Checks that a new user is added to the database successfully"""
        import user_code
        try:
            result = user_code.add_user("Alice", 30)
            expected_output = "User Alice added successfully!"
            condition = result == expected_output
            failure_message = f"For input `('Alice', 30)`, expected `{expected_output}`, but got `{result}`."
        
        except AttributeError:
            condition = False
            failure_message = "The function `add_user` is not defined."
        
        _dynamic_test(self, condition, "The `add_user` function correctly adds a new user.", failure_message)

    def test_user_count_after_adding(self):
        """Checks that the number of users in the database is correct after adding a new user"""
        import user_code
        try:
            user_code.add_user("Alice", 30)
            condition = len(user_code.users_db) == 1
            failure_message = f"For input `('Alice', 30)`, expected 1 user in the `users_db`, but found {len(user_code.users_db)}."
        
        except AttributeError:
            condition = False
            failure_message = "The function `add_user` is not defined."
        
        _dynamic_test(self, condition, "The number of users in the `users_db` is correct after adding a user.", failure_message)

    def test_add_user_with_default_role_and_status(self):
        """Checks that a new user is added with the default role and status"""
        import user_code
        try:
            user_code.add_user("Alice", 30)
            new_user = user_code.users_db[0]
            condition = (new_user["role"] == "user" and new_user["status"] == "active")
            failure_message = f"For input `('Alice', 30)`, expected user data with default role and status, but got {new_user}."
        
        except AttributeError:
            condition = False
            failure_message = "The function `add_user` is not defined."
        except Exception:
            condition = False
            failure_message = "For input `('Alice', 30)`, expected user data with the default role and status, but the user was not found in `users_db`."
        
        _dynamic_test(self, condition, "The new user is added with default `role` and `status`.", failure_message)

    def test_successful_update(self):
        """Checks that an existing user's data is updated correctly"""
        import user_code
        try:
            user_code.add_user("Alice", 30)
            result = user_code.add_user("Alice", 31, role="admin", status="inactive")
            expected_output = "User Alice updated successfully!"
            condition = result == expected_output and user_code.users_db[0]["age"] == 31 and user_code.users_db[0]["role"] == "admin" and user_code.users_db[0]["status"] == "inactive"
            failure_message = f"For input ('Alice', 30), followed by ('Alice', 31, 'admin', 'inactive'), expected {expected_output} and user data update in users_db, but got {result}."
        
        except AttributeError:
            condition = False
            failure_message = "The function `add_user` is not defined."
        
        _dynamic_test(self, condition, "The `add_user` function correctly updates existing user data.", failure_message)

    def test_user_count_after_update(self):
        """Checks that the number of users in the database remains the same after updating an existing user"""
        import user_code
        try:
            user_code.add_user("Alice", 30)
            user_code.add_user("Alice", 31, role="admin", status="inactive")
            condition = len(user_code.users_db) == 1
            failure_message = f"For input ('Alice', 30), followed by ('Alice', 31, 'admin', 'inactive'), expected users_db to contain exactly 1 user, but found {len(user_code.users_db)}."
        
        except AttributeError:
            condition = False
            failure_message = "The function `add_user` is not defined."
        
        _dynamic_test(self, condition, "The number of users in the `users_db` remains the same after updating a user.", 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

Saat vankan ymmärryksen funktioiden merkityksestä Pythonissa riippumatta tietojenkäsittelytieteen alastasi. Käsittelemme funktioiden luomista, argumenttien määrittelyä, palautusarvojen käsittelyä sekä niiden käyttöä Pythonissa.

Tarkastelemme, mitä funktio Pythonissa on ja joitakin perusmenetelmiä funktioiden luomiseen: mitkä ovat funktion argumentit, mikä on funktion paluuarvo, mikä on funktion runko ja miten funktiota käytetään koodissa.

Opi määrittämään funktioita Pythonissa käyttämällä paikallisia ja valinnaisia argumentteja. Hallitse joustavuus luoda funktioita, jotka mukautuvat erilaisiin syöteskenaarioihin.

Opi käsittelemään mielivaltaisia argumentteja ja avainsana-argumentteja Pythonissa vaihtelevan määrän syötteiden hallitsemiseksi. Ymmärrä, kuinka mielivaltaiset argumentit hallitsevat joustavia paikallisia syötteitä ja kuinka avainsana-argumentit järjestävät nimettyjä argumentteja sanakirjaksi tehokasta funktiosuunnittelua varten.

Funktion palautusarvo on suora seuraus funktion suorituksesta, jota voidaan hyödyntää ohjelmassa. Funktion palautusarvoja on useita eri tyyppejä – tarkastelemme yleisimmin käytettyjä.

Tutustu rekurssioiden ja lambda-funktioiden tehokkuuteen Pythonissa. Ymmärrä, kuinka rekurssio mahdollistaa funktion kutsuvan itseään monimutkaisten ongelmien ratkaisemiseksi, ja kuinka lambda-funktiot tarjoavat tiiviin tavan määritellä anonyymejä funktioita yksinkertaisiin tehtäviin.

Haaste: Valinnaiset Argumentit

Ratkaisu

Awesome!

Haaste: Valinnaiset Argumentit

Ratkaisu