Freestyle Sparring

import codewars_test as test
from solution import Pet


def defaultPet():
    return Pet("Bob", "Dog", "Male", 5)


@test.describe("Core behaviour")
def core_tests():
    @test.it("String representation and defaults")
    def test_str_and_defaults():
        p = defaultPet()
        test.assert_equals(
            str(p),
            "Bob the Male Dog, age 5 has 4 legs!",
        )

        # Default values
        p2 = Pet("Unnamed", "Unknown")
        test.assert_equals(
            str(p2),
            "Unnamed the not defined Unknown, age 0 has 4 legs!",
        )

    @test.it("Growing legs and aging")
    def test_mutation():
        p = defaultPet()
        p.n_legs = 6
        test.assert_equals(
            str(p),
            "Bob the Male Dog, age 5 has 6 legs!",
        )

        age = p.have_birthday()
        test.assert_equals(age, 6)
        test.assert_equals(
            str(p),
            "Bob the Male Dog, age 6 has 6 legs!",
        )
        

        # Multiple increment, from int and from str
        p.have_birthday(3)
        test.assert_equals(p.age, 9)
        p.have_birthday("2")
        test.assert_equals(p.age, 11)

    @test.it("Abnormal legs")
    def test_one_leg():
        p = defaultPet()
        p.n_legs = 1
        test.assert_equals(
            str(p),
            "Bob the Male Dog, age 5 has 1 leg!",
        )
        
        p.n_legs = 0
        test.assert_equals(
            str(p),
            "Bob the Male Dog, age 5 has 0 legs!",
        )
        
        p.n_legs = -1
        test.assert_equals(
            str(p),
            "Bob the Male Dog, age 5 has -1 leg!",
        )
        
        p.n_legs = -2
        test.assert_equals(
            str(p),
            "Bob the Male Dog, age 5 has -2 legs!",
        )
        
    @test.it("Gender and species updates")
    def test_gender_species():
        p = defaultPet()
        p.gender = "Female"
        test.assert_equals(
            str(p),
            "Bob the Female Dog, age 5 has 4 legs!",
        )

        p.gender = "Prefer not to Specify"
        test.assert_equals(
            str(p),
            "Bob the Prefer not to Specify Dog, age 5 has 4 legs!",
        )

        p.species = "Cat"
        test.assert_equals(
            str(p),
            "Bob the Prefer not to Specify Cat, age 5 has 4 legs!",
        )


@test.describe("Type conversion and flexibility")
def conversion_tests():
    @test.it("Name, species, gender convertible to str")
    def test_str_like_fields():
        p = Pet(123, ["Dog"], gender=("M", "ale"))
        test.assert_equals(p.name, "123")
        test.assert_equals(p.species, "['Dog']")
        test.assert_equals(p.gender, "('M', 'ale')")

        # Using setters
        p.name = 3.14
        p.species = {"type": "Dragon"}
        p.gender = None
        test.assert_equals(p.name, "3.14")
        test.assert_equals(p.species, "{'type': 'Dragon'}")
        test.assert_equals(p.gender, "None")

    @test.it("Age and n_legs convertible to int")
    def test_int_like_fields():
        p = Pet("X", "Y", age="10", n_legs="8")
        test.assert_equals(p.age, 10)
        test.assert_equals(p.n_legs, 8)

        p.age = 7.9  # int(7.9) == 7
        p.n_legs = True  # int(True) == 1
        test.assert_equals(p.age, 7)
        test.assert_equals(p.n_legs, 1)

        # have_birthday conversions
        p.have_birthday("5")
        test.assert_equals(p.age, 12)
        p.have_birthday(2.3)  # int(2.3) == 2
        test.assert_equals(p.age, 14)

    @test.it("Custom objects with __str__ and __int__")
    def test_custom_objects():
        class NameLike:
            def __str__(self):
                return "Fluffy"

        class IntLike:
            def __int__(self):
                return 42

        p = Pet(NameLike(), "Dog", age=IntLike(), n_legs=IntLike())
        test.assert_equals(p.name, "Fluffy")
        test.assert_equals(p.age, 42)
        test.assert_equals(p.n_legs, 42)


@test.describe("Validation and error handling")
def error_tests():
    @test.it("Invalid age and n_legs should raise ValueError")
    def test_invalid_int_conversion():
        def make_pet_bad_age():
            Pet("X", "Y", age="not-an-int")

        def make_pet_bad_legs():
            Pet("X", "Y", n_legs="four")

        p = defaultPet()

        def set_bad_age():
            p.age = "old"

        def set_bad_legs():
            p.n_legs = object()  # int(object()) fails

        test.expect_error("age must be convertible to int", make_pet_bad_age)
        test.expect_error("n_legs must be convertible to int", make_pet_bad_legs)
        test.expect_error("setting age to non-int-like should fail", set_bad_age)
        test.expect_error("setting n_legs to non-int-like should fail", set_bad_legs)

    @test.it("Invalid birthday increment should raise ValueError")
    def test_invalid_birthday_increment():
        p = defaultPet()

        def bad_bday_nan():
            p.have_birthday("NaN")

        def bad_bday_obj():
            p.have_birthday(object())

        test.expect_error("birthday increment 'NaN' should fail", bad_bday_nan)
        test.expect_error("birthday increment object() should fail", bad_bday_obj)

    @test.it("Name/species/gender: extremely unlikely to fail, but still guarded")
    def test_invalid_str_conversion():
        class BadStr:
            def __str__(self):
                raise RuntimeError("boom")

        p = defaultPet()

        def set_bad_name():
            p.name = BadStr()

        def set_bad_species():
            p.species = BadStr()

        def set_bad_gender():
            p.gender = BadStr()

        test.expect_error("bad __str__ on name should fail", set_bad_name)
        test.expect_error("bad __str__ on species should fail", set_bad_species)
        test.expect_error("bad __str__ on gender should fail", set_bad_gender)