
import unittest
import user_code
import ast
import re   
import unittest
import os
import pandas as pd
import importlib
import user_code

class TestTask(unittest.TestCase):
    def setUp(self):
        # Create a temporary CSV with sample data
        self.input_csv = 'test_expenses_raw.csv'
        self.output_csv = 'test_expense_summary.csv'
        data = [
            {'Amount': 25.00, 'Description': 'Uber ride downtown'},
            {'Amount': 40.00, 'Description': 'Office stationery purchase'},
            {'Amount': 15.50, 'Description': 'Lunch at local cafe'},
            {'Amount': 120.00, 'Description': 'Hotel stay'},
            {'Amount': 10.00, 'Description': 'Monthly software subscription'},
            {'Amount': 30.00, 'Description': 'Electric utilities payment'},
            {'Amount': 17.00, 'Description': 'Fuel for company car'},
            {'Amount': 9.99, 'Description': 'Water utilities'},
            {'Amount': 50.00, 'Description': 'Flight to conference'},
            {'Amount': 20.00, 'Description': 'Dining with client'},
            {'Amount': None, 'Description': 'Taxi to airport'},  # Should be excluded
            {'Amount': 5.00, 'Description': None},               # Should be excluded
            {'Amount': 8.00, 'Description': 'Book purchase'}     # Should be "Other"
        ]
        df = pd.DataFrame(data)
        df.to_csv(self.input_csv, index=False)

    def tearDown(self):
        if os.path.exists(self.input_csv):
            os.remove(self.input_csv)
        if os.path.exists(self.output_csv):
            os.remove(self.output_csv)

    def test_categorize_expense_keywords(self):
        # Check that categorize_expense returns correct category for various descriptions
        func = getattr(user_code, 'categorize_expense', None)
        self.assertIsNotNone(func, "categorize_expense function is missing")
        test_cases = [
            ("Uber ride downtown", "Travel"),
            ("Office stationery purchase", "Office Supplies"),
            ("Lunch at local cafe", "Meals & Entertainment"),
            ("Hotel stay", "Lodging"),
            ("Flight to conference", "Travel"),
            ("Monthly software subscription", "Software & Subscriptions"),
            ("Electric utilities payment", "Utilities"),
            ("Fuel for company car", "Automobile"),
            ("Water utilities", "Utilities"),
            ("Dining with client", "Meals & Entertainment"),
            ("Book purchase", "Other"),
        ]
        for desc, expected in test_cases:
            result = func(desc)
            _dynamic_test(
                self,
                result == expected,
                f"Description '{desc}' correctly categorized as '{expected}'",
                f"Description '{desc}' incorrectly categorized as '{result}', expected '{expected}'"
            )

    def test_dropna_excludes_incomplete_rows(self):
        # Run the main function and check that rows with missing Amount or Description are excluded
        importlib.reload(user_code)
        summary = user_code.automate_expense_categorization(self.input_csv, self.output_csv)
        df = pd.read_csv(self.input_csv)
        filtered = df.dropna(subset=["Amount", "Description"])
        # There are 13 rows, but 2 have missing data, so should be 11 processed
        _dynamic_test(
            self,
            len(filtered) == 11,
            "Rows with both Amount and Description present are processed",
            f"Expected 11 rows after dropna, got {len(filtered)}"
        )

    def test_aggregation_totals_by_category(self):
        importlib.reload(user_code)
        summary = user_code.automate_expense_categorization(self.input_csv, self.output_csv)
        # Manually build expected sums
        expected = {
            "Travel": 25.00 + 50.00,
            "Office Supplies": 40.00,
            "Meals & Entertainment": 15.50 + 20.00,
            "Lodging": 120.00,
            "Software & Subscriptions": 10.00,
            "Utilities": 30.00 + 9.99,
            "Automobile": 17.00,
            "Other": 8.00,
        }
        # Convert summary to dict
        actual = dict(zip(summary['Category'], summary['Amount']))
        for cat, amt in expected.items():
            _dynamic_test(
                self,
                cat in actual and abs(actual[cat] - amt) < 1e-2,
                f"Category '{cat}' has correct total {amt}",
                f"Category '{cat}' has incorrect total {actual.get(cat, None)}, expected {amt}"
            )

    def test_summary_csv_exported(self):
        importlib.reload(user_code)
        user_code.automate_expense_categorization(self.input_csv, self.output_csv)
        # Check that output file exists and has correct columns
        exists = os.path.exists(self.output_csv)
        _dynamic_test(
            self,
            exists,
            "Summary CSV file is created",
            "Summary CSV file was not created"
        )
        if exists:
            df = pd.read_csv(self.output_csv)
            _dynamic_test(
                self,
                set(df.columns) == {"Category", "Amount"},
                "Summary CSV file has correct columns",
                f"Summary CSV columns incorrect: {df.columns}"
            )

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

A practical course designed for accountants to leverage Python for automating, analyzing, and visualizing financial data. Learn to streamline accounting workflows, perform insightful analyses, and create compelling reports using Python and essential data libraries.

Learn how to automate common accounting tasks using Python, including data import, cleaning, and reconciliation.

Delve into financial data analysis using Python, including trend analysis, ratio calculations, and benchmarking.

Learn to retrieve financial data from online sources and create automated reports for accounting purposes.

Challenge: Automate Expense Categorization

Solution

Challenge: Automate Expense Categorization

Solution