import unittest
import importlib
import re

# Helper function to dynamically generate test names and assertions
def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message  # Rename the test for better readability
        test_case.assertTrue(True, success_message)  # Pass the test with a success message
    else:
        test_case._testMethodName = failure_message  # Rename the test with a failure description
        test_case.fail(failure_message)  # Fail the test with a failure message

class TestUserCode(unittest.TestCase):

    def setUp(self):
        # Reload the module to make sure we are testing the latest code
        self.module = importlib.import_module('user_code')
        importlib.reload(self.module)

    # Test if `remaining_tasks` is declared
    def test_remaining_tasks_is_declared(self):
        _dynamic_test(
            self,
            hasattr(self.module, 'remaining_tasks'),
            "The `remaining_tasks` variable is declared.",
            "Expected `remaining_tasks` variable to be declared."
        )

    # Test if `required_time` is declared
    def test_required_time_is_declared(self):
        _dynamic_test(
            self,
            hasattr(self.module, 'required_time'),
            "The `required_time` variable is declared.",
            "Expected `required_time` variable to be declared."
        )

    # Test if `remaining_tasks` is an integer
    def test_remaining_tasks_is_integer(self):
        _dynamic_test(
            self,
            hasattr(self.module, 'remaining_tasks') and isinstance(self.module.remaining_tasks, int),
            "The `remaining_tasks` is of type `int`.",
            "Expected `remaining_tasks` to be of type `int`."
        )

    # Test if `required_time` is an integer
    def test_required_time_is_integer(self):
        _dynamic_test(
            self,
            hasattr(self.module, 'required_time') and isinstance(self.module.required_time, int),
            "The `required_time` is of type `int`.",
            "Expected `required_time` to be of type `int`."
        )

    # Test if `remaining_tasks` has the correct value
    def test_remaining_tasks_correct_value(self):
        completed = 60 // 7  # Completed transactions
        expected_value = 10 - completed  # Remaining tasks
        _dynamic_test(
            self,
            hasattr(self.module, 'remaining_tasks') and self.module.remaining_tasks == expected_value,
            f"The `remaining_tasks` is `{expected_value}`.",
            f"Expected `remaining_tasks` to be `{expected_value}`, but got `{getattr(self.module, 'remaining_tasks', 'undefined')}`."
        )

    # Test if `required_time` has the correct value
    def test_required_time_correct_value(self):
        expected_value = 10 * 7  # Total time needed for all transactions
        _dynamic_test(
            self,
            hasattr(self.module, 'required_time') and self.module.required_time == expected_value,
            f"The `required_time` is `{expected_value}`.",
            f"Expected `required_time` to be `{expected_value}`, but got `{getattr(self.module, 'required_time', 'undefined')}`."
        )

    # Test if subtraction is used for `remaining_tasks`
    def test_subtraction_used_for_remaining_tasks(self):
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()
        _dynamic_test(
            self,
            re.search(r'remaining_tasks\s*=\s*10\s*-\s*[\w_]+', user_code_source),
            "Subtraction is used for `remaining_tasks`.",
            "Expected subtraction to be used for `remaining_tasks`."
        )

    # Test if multiplication is used for `required_time`
    def test_multiplication_used_for_required_time(self):
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()
        _dynamic_test(
            self,
            re.search(r'required_time\s*=\s*10\s*\*\s*7', user_code_source),
            "Multiplication is used for `required_time`.",
            "Expected multiplication to be used for `required_time`."
        )

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 las operaciones básicas y todo lo relacionado a los números, los datos booleanos y las cadenas (strings). Este curso consiste en un montón de tareas prácticas con las que al final te convertirás en un programador hábil.

Los tipos de datos numéricos son cruciales en Python, por lo que es importante empezar con ellos. Aquí trabajarás con operaciones matemáticas sencillas y descubrirás los propósitos de aprender diferentes tipos de datos numéricos.

El objetivo principal de esta sección es clarificar los tipos de datos booleanos; se trata de un subtipo de los datos numéricos, pero uno más desafiante. Ya que siempre es mejor destacar en los temas más complicados, esta sección se convertirá en una parte valiosa de tu currículo.

Las strings de caracteres son una forma de implementar nuestras frases en Python, es decir, de dar instrucciones a los usuarios quiénes son el público objetivo de tu programa. De hecho, siempre es bueno ser capaz de trabajar con strings ya que deberán ser utilizadas en tu código. Pronto entenderás por qué.

Este capítulo consta de tareas prácticas que combinan todos los temas estudiados con un poco de teoría.

Tipos de Datos en Python

Challenge: Time Calculation in Python

Solución

Challenge: Time Calculation in Python

Solución