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

Este curso te ayudará a profundizar en los tipos de datos y a trabajar con ellos. Aquí aprenderás operaciones básicas y todos los aspectos de los números, el tipo de dato booleano y las cadenas de texto. El curso incluye numerosas tareas prácticas tras las cuales te convertirás en un programador competente.

Los tipos de datos numéricos son fundamentales en Python y constituyen la base de muchas tareas computacionales. En esta sección, se abordan los aspectos esenciales del trabajo con enteros y números de punto flotante, la realización de operaciones matemáticas básicas y la comprensión de las aplicaciones prácticas de los datos numéricos. También se exploran conceptos clave como la inmutabilidad y se adquiere experiencia práctica con las funciones y herramientas integradas de Python para gestionar números de manera eficaz.

El objetivo principal de esta sección es aclarar los tipos de datos booleanos; es un subtipo de datos numéricos, pero en realidad es más complejo. Dado que siempre es mejor destacar en los temas más difíciles, esta sección es una parte valiosa de tu plan de estudios.

Las cadenas de texto permiten implementar frases en Python, es decir, proporcionar instrucciones a los usuarios que son el público objetivo de su programa. De hecho, siempre es preferible trabajar con cadenas de texto, ya que deben utilizarse en su código. Pronto comprenderá el motivo.

Cambiar los valores al tipo necesario, limpiar el texto antes de comparar y mantener las operaciones matemáticas estrictamente con números mientras se formatean los resultados para su lectura. Marcar los datos faltantes de manera clara y gestionarlos intencionadamente, y tratar el texto humano de forma diferente al contenido bruto de archivos o redes. Los objetivos son reducir errores, obtener comparaciones fiables, resultados consistentes y una salida clara y legible.

Este capítulo consiste en tareas prácticas que combinan todos los temas examinados junto con un poco de teoría.

Desafío: Cálculo de Tiempo

Solución

Awesome!

Desafío: Cálculo de Tiempo

Solución