import unittest
import importlib
import re

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 TestUserCode(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        cls.m = importlib.import_module('user_code')
        with open('user_code.py', 'r', encoding='utf-8') as f:
            cls.src = f.read()
        # Expected values based on the challenge setup
        cls.expected_total_required = 10 * 7     # 70
        cls.expected_shortfall = cls.expected_total_required - 60   # 10
        cls.expected_total_hours = cls.expected_total_required / 60 # 70/60
        cls.expected_completed = 60 // 7         # 8
        cls.expected_unused = 60 % 7             # 4

    def test_shortfall_minutes_group(self):
        """
        One message validating EVERYTHING about `shortfall_minutes`:
        - declared, int, correct value (10)
        - source uses `total_required - available_minutes`
        - and `total_required` is computed via `num_calls * avg_minutes_per_call`
        """
        declared = hasattr(self.m, 'shortfall_minutes')
        correct_type = isinstance(getattr(self.m, 'shortfall_minutes', None), int)
        correct_value = declared and (self.m.shortfall_minutes == self.expected_shortfall)

        # shortfall_minutes: uses subtraction
        uses_subtraction = re.search(
            r"""shortfall_minutes\s*=\s*[^#\n]*total_required[^#\n]*-[^#\n]*available_minutes""",
            self.src
        ) is not None

        total_required_from_vars = re.search(
            r"""total_required\s*=\s*[^#\n]*num_calls[^#\n]*\*[^#\n]*avg_minutes_per_call""", self.src
        ) is not None

        all_ok = declared and correct_type and correct_value and uses_subtraction and total_required_from_vars
        _dynamic_test(
            self,
            all_ok,
            "Minutes you are short computed correctly",
            "Minutes you are short computed incorrectly"
        )

    def test_total_hours_group(self):
        """
        One message validating EVERYTHING about `total_hours`:
        - declared, float, correct value (70/60)
        - source uses `total_required / minutes_in_hour`
        """
        declared = hasattr(self.m, 'total_hours')
        correct_type = isinstance(getattr(self.m, 'total_hours', None), float)
        correct_value = declared and abs(self.m.total_hours - self.expected_total_hours) < 1e-9

        # total_hours: uses division
        uses_division = re.search(
            r"""total_hours\s*=\s*[^#\n]*total_required[^#\n]*/[^#\n]*minutes_in_hour""",
            self.src
        ) is not None

        all_ok = declared and correct_type and correct_value and uses_division
        _dynamic_test(
            self,
            all_ok,
            "Total duration in hours for all calls computed correctly",
            "Total duration in hours for all calls computed incorrectly"
        )

    def test_completed_calls_group(self):
        """
        One message validating EVERYTHING about `completed_calls`:
        - declared, int, correct value (8)
        - source uses floor division: `available_minutes // avg_minutes_per_call`
        """
        declared = hasattr(self.m, 'completed_calls')
        correct_type = isinstance(getattr(self.m, 'completed_calls', None), int)
        correct_value = declared and (self.m.completed_calls == self.expected_completed)

        # completed_calls: uses floor division //
        uses_floor_div = re.search(
            r"""completed_calls\s*=\s*[^#\n]*available_minutes[^#\n]*//[^#\n]*avg_minutes_per_call""",
            self.src
        ) is not None

        all_ok = declared and correct_type and correct_value and uses_floor_div
        _dynamic_test(
            self,
            all_ok,
            "Completed calls within available time computed correctly",
            "Completed calls within available time computed incorrectly"
        )

    def test_unused_minutes_group(self):
        """
        One message validating EVERYTHING about `unused_minutes`:
        - declared, int, correct value (4)
        - source uses modulo: `available_minutes % avg_minutes_per_call`
        """
        declared = hasattr(self.m, 'unused_minutes')
        correct_type = isinstance(getattr(self.m, 'unused_minutes', None), int)
        correct_value = declared and (self.m.unused_minutes == self.expected_unused)

        # unused_minutes: uses modulo %
        uses_modulo = re.search(
            r"""unused_minutes\s*=\s*[^#\n]*available_minutes[^#\n]*%[^#\n]*avg_minutes_per_call""",
            self.src
        ) is not None

        all_ok = declared and correct_type and correct_value and uses_modulo
        _dynamic_test(
            self,
            all_ok,
            "Unused minutes within available time computed correctly",
            "Unused minutes within available time computed incorrectly"
        )

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


test_main.py

This course is going to help you dive deeper into data types and try to work with them. Here you will learn basic operations and all ins and outs of numbers, boolean data type, and strings. This course consists of a lot of practical tasks after which you will become a skillful programmer.

Numerical data types are fundamental in Python, forming the backbone of many computational tasks. In this section, you'll dive into the essentials of working with integers and floating-point numbers, performing basic mathematical operations, and understanding the real-world applications of numerical data. You'll also explore critical concepts such as immutability and gain hands-on experience with Python’s built-in functions and tools for handling numbers effectively.

The main goal of this section is to clarify the boolean data types; it's a sub type of numeric data, but indeed it is more challenging. Since it is always better to excel in the more difficult topics, this section is a valuable part of your curriculum.

Strings are a way for us to implement your phrases in Python, that is, to give instructions to users who are the target audience of your program. Indeed, it is always better to be able to work with strings because they should be used in your code. You'll understand why soon.

Change values to the kind you need, clean text before comparing, and keep math strictly with numbers while formatting results for people to read. Mark missing data clearly and handle it on purpose, and treat human text differently from raw file or network content. The goals are fewer mistakes, reliable comparisons, consistent results, and clear, readable output.


This chapter consists of practical tasks that combine all the examined topics together with a bit of theory.

Challenge: Time Calculation

Solution

Awesome!

Challenge: Time Calculation

Solution