import unittest
import importlib
import re
import io
import contextlib


class TestTask(unittest.TestCase):
    def test_classes_exist(self):
        import user_code
        importlib.reload(user_code)

        Weapon = getattr(user_code, "Weapon", None)
        Warrior = getattr(user_code, "Warrior", None)

        _dynamic_test(
            self,
            Weapon is not None and Warrior is not None,
            "Weapon and Warrior classes exist",
            "Weapon and Warrior classes missing",
        )

    def test_weapon_init(self):
        import user_code
        importlib.reload(user_code)

        Weapon = getattr(user_code, "Weapon", None)
        sword = Weapon("Sword", 5)

        _dynamic_test(
            self,
            hasattr(sword, "name") and hasattr(sword, "attack"),
            "Weapon has name and attack attributes",
            "Weapon missing name or attack attribute",
        )
        _dynamic_test(
            self,
            sword.name == "Sword" and sword.attack == 5,
            "Weapon stores name and attack correctly",
            f"Expected ('Sword', 5), got ({getattr(sword,'name',None)}, {getattr(sword,'attack',None)})",
        )

    def test_warrior_init(self):
        import user_code
        importlib.reload(user_code)

        Warrior = getattr(user_code, "Warrior", None)
        w = Warrior("Conan")

        _dynamic_test(
            self,
            hasattr(w, "name") and w.name == "Conan",
            "Warrior stores name correctly",
            "Warrior missing name or stores it incorrectly",
        )
        _dynamic_test(
            self,
            hasattr(w, "weapon") and w.weapon is None,
            "Warrior starts unarmed (weapon is None)",
            "Warrior weapon should start as None",
        )

    def test_equip_weapon_composition(self):
        import user_code
        importlib.reload(user_code)

        Weapon = getattr(user_code, "Weapon", None)
        Warrior = getattr(user_code, "Warrior", None)

        sword = Weapon("Sword", 5)
        w = Warrior("Conan")
        w.equip_weapon(sword)

        _dynamic_test(
            self,
            hasattr(w, "weapon") and w.weapon is sword,
            "Warrior equips weapon via composition",
            "Weapon not equipped correctly (should store the same object)",
        )

    def test_show_weapon_output_unarmed(self):
        import user_code
        importlib.reload(user_code)

        Warrior = getattr(user_code, "Warrior", None)
        w = Warrior("Conan")

        out = _capture_print(w.show_weapon)
        expected = normalize_text("Conan is unarmed")

        _dynamic_test(
            self,
            normalize_text(out) == expected,
            "show_weapon prints unarmed message",
            f"Expected '{expected}', got '{normalize_text(out)}'",
        )

    def test_show_weapon_output_armed(self):
        import user_code
        importlib.reload(user_code)

        Weapon = getattr(user_code, "Weapon", None)
        Warrior = getattr(user_code, "Warrior", None)

        sword = Weapon("Sword", 5)
        w = Warrior("Conan")
        w.equip_weapon(sword)

        out = _capture_print(w.show_weapon)
        expected = normalize_text("Conan is holding a Sword")

        _dynamic_test(
            self,
            normalize_text(out) == expected,
            "show_weapon prints armed message",
            f"Expected '{expected}', got '{normalize_text(out)}'",
        )


def _capture_print(func, *args, **kwargs) -> str:
    buf = io.StringIO()
    with contextlib.redirect_stdout(buf):
        func(*args, **kwargs)
    return buf.getvalue().strip()


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)


def normalize_text(text: str) -> str:
    text = text.strip().lower()
    text = re.sub(r"\s{2,}", " ", text)
    return text


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

test_main.py

Aprenda a construir aplicações limpas, seguras e escaláveis com Programação Orientada a Objetos em Python. Aborde os fundamentos de classes e objetos, avançando para conceitos avançados como herança, composição, polimorfismo e encapsulamento. Com explicações claras e exemplos práticos, você desenvolverá a capacidade de projetar programas Python poderosos, manuteníveis e prontos para uso no mundo real.

Aprenda os principais blocos de construção da programação orientada a objetos em Python. Esta seção aborda classes, objetos, métodos e variáveis, proporcionando uma base sólida para compreender como a POO organiza e estrutura o código.

Desafio: Construindo um Guerreiro Composto

Solução