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 results from fixed inputs
        cls.exp_name_clean = "Ada Lovelace"
        cls.exp_has_quick = True
        cls.exp_inside_parens = "quick"
        cls.exp_o_count = 4
        cls.exp_id_prefix = "USR"
        cls.exp_id_number = "00042"
        cls.exp_id_suffix = "xy"
        cls.exp_domain = "example.com"
        cls.exp_report = f"{cls.exp_name_clean} | {cls.exp_domain} | {cls.exp_id_number} | {cls.exp_o_count}"

    # 1) name_clean group
    def test_name_clean_group(self):
        declared = hasattr(self.m, 'name_clean')
        correct = declared and (self.m.name_clean == self.exp_name_clean)
        pattern = r"""name_clean\s*=\s*full_name\s*\.\s*strip\s*\(\s*\)"""
        used_strip = re.search(pattern, self.src, re.DOTALL) is not None
        _dynamic_test(
            self,
            declared and correct and used_strip,
            "name_clean computed correctly",
            "name_clean computed incorrectly"
        )

    # 2) has_quick + o_count group (content checks)
    def test_content_checks_group(self):
        has_q_decl = hasattr(self.m, 'has_quick')
        oc_decl = hasattr(self.m, 'o_count')
        has_q_val = has_q_decl and (self.m.has_quick == self.exp_has_quick)
        oc_val = oc_decl and (self.m.o_count == self.exp_o_count)

        pat_has_quick = r"""has_quick\s*=\s*target_word\s+in\s+sentence\s*\.\s*lower\s*\(\s*\)"""
        pat_o_count = r"""o_count\s*=\s*sentence\s*\.\s*lower\s*\(\s*\)\s*\.\s*count\s*\(\s*'o'\s*\)"""
        ok_has_quick = re.search(pat_has_quick, self.src, re.DOTALL) is not None
        ok_o_count = re.search(pat_o_count, self.src, re.DOTALL) is not None

        _dynamic_test(
            self,
            has_q_decl and oc_decl and has_q_val and oc_val and ok_has_quick and ok_o_count,
            "content checks computed correctly",
            "content checks computed incorrectly"
        )

    # 3) inside_parens group
    def test_inside_parens_group(self):
        declared = hasattr(self.m, 'inside_parens')
        correct = declared and (self.m.inside_parens == self.exp_inside_parens)

        pat_left = r"""left\s*=\s*sentence\s*\.\s*find\s*\(\s*LPAREN\s*\)"""
        pat_right = r"""right\s*=\s*sentence\s*\.\s*find\s*\(\s*RPAREN\s*\)"""
        pat_slice = r"""inside_parens\s*=\s*sentence\s*\[\s*left\s*\+\s*1\s*:\s*right\s*\]"""
        ok_left = re.search(pat_left, self.src, re.DOTALL) is not None
        ok_right = re.search(pat_right, self.src, re.DOTALL) is not None
        ok_slice = re.search(pat_slice, self.src, re.DOTALL) is not None

        _dynamic_test(
            self,
            declared and correct and ok_left and ok_right and ok_slice,
            "inside_parens computed correctly",
            "inside_parens computed incorrectly"
        )

    # 4) id parts group
    def test_id_parts_group(self):
        pre = hasattr(self.m, 'id_prefix') and hasattr(self.m, 'id_number') and hasattr(self.m, 'id_suffix')
        vals = pre and (self.m.id_prefix == self.exp_id_prefix) and (self.m.id_number == self.exp_id_number) and (self.m.id_suffix == self.exp_id_suffix)

        pat_pre = r"""id_prefix\s*=\s*id_code\s*\[\s*:\s*3\s*\]"""
        pat_num = r"""id_number\s*=\s*id_code\s*\[\s*4\s*:\s*9\s*\]"""
        pat_suf = r"""id_suffix\s*=\s*id_code\s*\[\s*-2\s*:\s*\]"""
        ok_pre = re.search(pat_pre, self.src, re.DOTALL) is not None
        ok_num = re.search(pat_num, self.src, re.DOTALL) is not None
        ok_suf = re.search(pat_suf, self.src, re.DOTALL) is not None

        _dynamic_test(
            self,
            pre and vals and ok_pre and ok_num and ok_suf,
            "id parts computed correctly",
            "id parts computed incorrectly"
        )

    # 5) domain group
    def test_domain_group(self):
        declared = hasattr(self.m, 'domain') and hasattr(self.m, 'email_clean') and hasattr(self.m, 'domain_at')
        correct = declared and (self.m.domain == self.exp_domain)

        pat_clean = r"""email_clean\s*=\s*email\s*\.\s*strip\s*\(\s*\)\s*\.\s*lower\s*\(\s*\)"""
        pat_find = r"""domain_at\s*=\s*email_clean\s*\.\s*find\s*\(\s*AT\s*\)"""
        pat_dom = r"""domain\s*=\s*email_clean\s*\[\s*domain_at\s*\+\s*1\s*:\s*\]"""
        ok_clean = re.search(pat_clean, self.src, re.DOTALL) is not None
        ok_find = re.search(pat_find, self.src, re.DOTALL) is not None
        ok_dom = re.search(pat_dom, self.src, re.DOTALL) is not None

        _dynamic_test(
            self,
            declared and correct and ok_clean and ok_find and ok_dom,
            "domain computed correctly",
            "domain computed incorrectly"
        )

    # 6) report group
    def test_report_group(self):
        declared = hasattr(self.m, 'report')
        correct = declared and (self.m.report == self.exp_report)

        # Minimal check: an f-string is used and references required fields
        pat = r"""report\s*=\s*f["'].*\{name_clean\}.*\{SEP\}.*\{domain\}.*\{SEP\}.*\{id_number\}.*\{SEP\}.*\{o_count\}["']"""
        used_f = re.search(pat, self.src, re.DOTALL) is not None

        _dynamic_test(
            self,
            declared and correct and used_f,
            "report computed correctly",
            "report computed incorrectly"
        )

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


test_code.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: Ejercicios de Segmentación y Búsqueda

Solución

Awesome!

Desafío: Ejercicios de Segmentación y Búsqueda

Solución