
import unittest
import user_code
import ast
import re   
import unittest
import importlib
import io
from contextlib import redirect_stdout

class TestTask(unittest.TestCase):
    def test_prints_all_items_aligned(self):
        import user_code
        importlib.reload(user_code)
        expenses = [
            ("Groceries", 54.32),
            ("Utilities", 120.00),
            ("Coffee", 8.50),
            ("Internet", 45.99)
        ]
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.print_expense_report(expenses)
        output = f.getvalue()
        expected_rows = [
            "Item         | Amount",
            "-------------|-------",
            "Groceries    | $ 54.32",
            "Utilities    | $120.00",
            "Coffee       | $  8.50",
            "Internet     | $ 45.99",
            "-------------|-------",
            "Total        | $228.81"
        ]
        for row in expected_rows:
            _dynamic_test(
                self,
                normalize_text(row) in normalize_text(output),
                f"Output contains row: {row}",
                f"Expected row '{row}' not found in output: {output}",
            )

    def test_amounts_two_decimal_places(self):
        import user_code
        importlib.reload(user_code)
        expenses = [
            ("Lunch", 10),
            ("Snacks", 3.1)
        ]
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.print_expense_report(expenses)
        output = f.getvalue()
        _dynamic_test(
            self,
            "$ 10.00" in output and "$  3.10" in output and "$ 13.10" in output,
            "All amounts and total are formatted with two decimal places.",
            f"Amounts or total not formatted to two decimal places: {output}",
        )

    def test_total_label_and_sum(self):
        import user_code
        importlib.reload(user_code)
        expenses = [
            ("Book", 15.75),
            ("Pen", 1.25)
        ]
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.print_expense_report(expenses)
        output = f.getvalue()
        _dynamic_test(
            self,
            "Total        | $ 17.00" in output or "Total        | $17.00" in output,
            "Total row is printed with correct label and sum.",
            f"Total row with correct sum not found: {output}",
        )

    def test_empty_expenses(self):
        import user_code
        importlib.reload(user_code)
        expenses = []
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.print_expense_report(expenses)
        output = f.getvalue()
        _dynamic_test(
            self,
            "Total        | $  0.00" in output or "Total        | $0.00" in output,
            "Handles empty expenses list and prints total as 0.00.",
            f"Total for empty expenses should be 0.00, got: {output}",
        )

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()
    changed = False
    # Collect all assignment nodes to modify
    assign_nodes = [
        (i, node)
        for i, node in enumerate(tree.body)
        if isinstance(node, ast.Assign)
        and any(isinstance(target, ast.Name) and target.id == var_name for target in node.targets)
    ]

    # If nothing to change, return unmodified code
    if not assign_nodes:
        return code

    # Perform replacements for all matching assignments (from last to first to not break line offsets)
    for i, node in reversed(assign_nodes):
        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] = []
        changed = True

    return '\\n'.join(lines) if changed else code

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


test_main.py

def print_expense_report(expenses):
    print("Item         | Amount")
    print("-------------|-------")
    total = 0
    for item, amount in expenses:
        line = f"{item:<12} | ${amount:>6.2f}"
        print(line)
        total += amount
    total_line = f"{'Total':<12} | ${total:>6.2f}"
    print("-------------|-------")
    print(total_line)

expenses = [
    ("Groceries", 54.32),
    ("Utilities", 120.00),
    ("Coffee", 8.50),
    ("Internet", 45.99)
]
print_expense_report(expenses)

def print_expense_report(expenses):
    print("Item         | Amount")
    print("-------------|-------")
    # Write your code here

expenses = [
    ("Groceries", 54.32),
    ("Utilities", 120.00),
    ("Coffee", 8.50),
    ("Internet", 45.99)
]
print_expense_report(expenses)

Write a function that prints a neatly formatted table of items and expenses, including the total expense at the end.

- Print each item and its amount, formatted in aligned columns;
- After listing all items, print a row with the total amount, labeled "Total";
- The amount for each item and the total should be displayed with two decimal places.

### Unit Test Checklist

- Each item and its amount are printed in aligned columns;
- The total amount is printed after all items, labeled "Total";
- Amounts, including the total, are formatted with two decimal places;
- The function handles an empty list of expenses by showing only headers and the total as 0.00.

Master practical Python skills for everyday tasks, from calculations and data organization to visualizing information and automating routines. This course blends engaging theory with hands-on challenges, empowering you to solve real-world problems efficiently using Python.

Learn to use Python for automating calculations and streamlining daily routines, from budgeting to simple reminders.

Discover how Python can help you organize, analyze, and summarize everyday data, from to-do lists to simple statistics.

Learn to create simple visualizations and formatted outputs to communicate information clearly and effectively.

Challenge: Generate a Simple Expense Report

Solução

Unit Test Checklist