def test_get_xp_remaining_until_next_level_percentage(self):
        unit_generator = UnitGenerator()
        unit = unit_generator.generate()

        unit_level = UnitLevel()

        level_42_xp = unit_level.get_xp_for_level(42)
        ten_percent_of_total_xp = level_42_xp * .10
        unit.experience = level_42_xp - ten_percent_of_total_xp
        total_xp = level_42_xp

        # Test 90%
        expected_percentage = 90
        actual_percentage = unit.get_xp_remaining_until_next_level_percentage(
            total_xp)

        self.assertEqual(expected_percentage, actual_percentage)

        # Test 50%
        expected_fifty_percentage = 50
        fifty_percent_of_total_xp = level_42_xp * .50
        unit.experience = level_42_xp - fifty_percent_of_total_xp
        a_fifty = unit.get_xp_remaining_until_next_level_percentage(total_xp)

        self.assertEqual(expected_fifty_percentage, a_fifty)

        # Test xp over max level
        expected_one_twenty_percent = 120
        max_level_xp = unit_level.get_xp_for_max_level()
        twenty_percent_of_max = max_level_xp * .20
        unit.experience = max_level_xp + twenty_percent_of_max
        a_120 = unit.get_xp_remaining_until_next_level_percentage(max_level_xp)

        self.assertEqual(expected_one_twenty_percent, a_120)
    def _get_unit_model(self, **kwargs):
        unit_level = UnitLevel()
        is_player = False
        level = randrange(1, 100)
        xp = unit_level.get_xp_for_level(level)
        unit_id = uuid4()
        unit_name = "Unit%s" % unit_id
        unit_types = (1, 2, 3)
        unit_type_id = choice(unit_types)

        if "is_player" in kwargs:
            is_player = kwargs["is_player"]

        user_id = 0

        if is_player:
            user_id = randrange(1, 999)

        unit_model = {
            "id": unit_id,
            "unit_name": unit_name,
            "items": [],
            "effects": [],
            "dialogue": [],
            "experience": xp,
            "level": level,
            "user_id": user_id,
            "is_boss": 0,
            "unit_type_id": unit_type_id,
            "unit_type_name": "quux",
            "combat_status": "hostile",
            "base_items": []
        }

        return unit_model
    def generate(self, **kwargs):
        unit_level = UnitLevel()
        level = randrange(1, 100)
        unit_id = uuid4()
        combat_status = "passive"

        if "level" in kwargs:
            level = kwargs["level"]

        xp = unit_level.get_xp_for_level(level) + 1

        if "combat_status" in kwargs:
            combat_status = kwargs["combat_status"]

        if "unit_name" in kwargs:
            unit_name = kwargs["unit_name"]
        else:
            unit_name = "Level%sUnit%s" % (level, unit_id)

        unit_types = (1, 2, 3)
        unit_type_id = choice(unit_types)

        if "unit_type_id" in kwargs:
            unit_type_id = kwargs["unit_type_id"]

        user_id = 0

        if "is_player" in kwargs:
            user_id = randrange(1, 999)

        if "user_id" in kwargs:
            user_id = kwargs["user_id"]

        if "base_items" in kwargs:
            base_items = kwargs["base_items"]
        else:
            base_items = []

        unit_model = {
            "id": unit_id,
            "unit_name": unit_name,
            "items": [],
            "effects": [],
            "dialogue": [],
            "experience": xp,
            "level": level,
            "user_id": user_id,
            "is_boss": 0,
            "unit_type_id": unit_type_id,
            "unit_type_name": "quux",
            "combat_status": combat_status,
            "base_items": base_items
        }

        with LogCapture():
            logger = logging.getLogger()
            unit = Unit(unit=unit_model, log=logger)

        return unit