In this exercise, you will practice writing basic tests to check the correctness of a Python function. **Testing** is essential for maintaining code quality because it helps you verify that your code works as expected and catches mistakes early. You will be given a function, and your goal is to write a few **assert-based tests** that confirm the function behaves correctly for different inputs.


import unittest
import user_code
import ast
import re   
import importlib
import user_code

class TestTask(unittest.TestCase):
    def test_reverse_string_hello(self):
        importlib.reload(user_code)
        result = user_code.reverse_string("hello")
        expected = "olleh"
        _dynamic_test(
            self,
            result == expected,
            f"reverse_string('hello') returns '{expected}'",
            f"Expected {expected} but got {result}",
        )

    def test_reverse_string_empty(self):
        importlib.reload(user_code)
        result = user_code.reverse_string("")
        expected = ""
        _dynamic_test(
            self,
            result == expected,
            f"reverse_string('') returns empty string",
            f"Expected {expected} but got {result}",
        )

    def test_reverse_string_python(self):
        importlib.reload(user_code)
        result = user_code.reverse_string("Python")
        expected = "nohtyP"
        _dynamic_test(
            self,
            result == expected,
            f"reverse_string('Python') returns '{expected}'",
            f"Expected {expected} but got {result}",
        )

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)

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\s{2,}", " ", text)
    text = re.sub(r"\s*([,:?])\s*", r"\1 ", text)
    return text.strip()

def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    for i, node in enumerate(tree.body):
        if isinstance(node, ast.Assign):
            for target in node.targets:
                if isinstance(target, ast.Name) and target.id == var_name:
                    start_line = node.lineno - 1
                    line = lines[start_line]
                    indent = ' ' * (len(line) - len(line.lstrip()))
                    lines[start_line] = f"{indent}{var_name} = {value}"
                    next_line = len(lines)
                    for next_node in tree.body[i+1:]:
                        if hasattr(next_node, 'lineno'):
                            next_line = next_node.lineno - 1
                            break
                    if next_line > start_line + 1:
                        lines[start_line+1:next_line] = []
                    
                    return '\\n'.join(lines)
    return code

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


test_main.py

Master the principles of writing clean, maintainable, and efficient Python code. Learn to identify code smells, apply refactoring techniques, and adopt best practices for code quality. Practice your skills with hands-on tasks designed for those familiar with basic Python syntax.

Explore the fundamental concepts of code quality, why it matters, and how to recognize poor code in Python.

Delve into practical refactoring methods to enhance Python code structure and eliminate code smells.

Adopt Pythonic conventions and idioms to write elegant, efficient, and maintainable code.

Learn strategies for maintaining code quality over time, including documentation, testing, and code reviews.

Challenge: Add Simple Tests

Solution