@opslane/claude-code-game 0.1.0

package/levels/08-mcp-servers/exercise/tests/test_database.py

@@ -0,0 +1,244 @@
+"""Tests for database operations."""
+
+import pytest
+from datetime import datetime
+from database import (
+    init_db,
+    save_expense,
+    load_expenses,
+    get_expense_by_id,
+    remove_expense,
+    clear_all_expenses,
+    get_expense_count
+)
+from models import Expense
+
+
+class TestDatabaseInit:
+    """Tests for database initialization."""
+
+    def test_init_creates_table(self):
+        """Test that init_db creates the expenses table."""
+        init_db()
+        # If we get here without error, table was created
+        expenses = load_expenses()
+        assert isinstance(expenses, list)
+
+    def test_init_idempotent(self):
+        """Test that init_db can be called multiple times safely."""
+        init_db()
+        init_db()
+        init_db()
+        # Should not raise any errors
+
+
+class TestSaveAndLoad:
+    """Tests for saving and loading expenses."""
+
+    def test_save_and_load_single(self):
+        """Test saving and loading a single expense."""
+        expense = Expense(
+            id="test123",
+            amount=50.0,
+            category="Food",
+            description="Test expense",
+            date=datetime(2026, 1, 15, 12, 0)
+        )
+        save_expense(expense)
+
+        expenses = load_expenses()
+        assert len(expenses) == 1
+        assert expenses[0].id == "test123"
+        assert expenses[0].amount == 50.0
+        assert expenses[0].category == "Food"
+
+    def test_save_multiple(self):
+        """Test saving multiple expenses."""
+        for i in range(5):
+            expense = Expense(
+                id=f"test{i}",
+                amount=float(i * 10),
+                category="Test",
+                description=f"Expense {i}",
+                date=datetime.now()
+            )
+            save_expense(expense)
+
+        expenses = load_expenses()
+        assert len(expenses) == 5
+
+    def test_load_preserves_data(self):
+        """Test that all expense fields are preserved on load."""
+        original = Expense(
+            id="preserve123",
+            amount=99.99,
+            category="Shopping",
+            description="Test all fields",
+            date=datetime(2026, 6, 15, 14, 30),
+            recurring=True,
+            recurring_frequency="monthly"
+        )
+        save_expense(original)
+
+        loaded = load_expenses()[0]
+        assert loaded.id == original.id
+        assert loaded.amount == original.amount
+        assert loaded.category == original.category
+        assert loaded.description == original.description
+        assert loaded.date == original.date
+        assert loaded.recurring == original.recurring
+        assert loaded.recurring_frequency == original.recurring_frequency
+
+    def test_load_ordered_by_date(self):
+        """Test that load_expenses returns results ordered by date descending."""
+        dates = [
+            datetime(2026, 1, 1),
+            datetime(2026, 1, 15),
+            datetime(2026, 1, 10),
+        ]
+        for i, date in enumerate(dates):
+            expense = Expense(
+                id=f"date{i}",
+                amount=10.0,
+                category="Test",
+                description=f"Expense {i}",
+                date=date
+            )
+            save_expense(expense)
+
+        expenses = load_expenses()
+        loaded_dates = [e.date for e in expenses]
+        assert loaded_dates == sorted(loaded_dates, reverse=True)
+
+
+class TestGetExpenseById:
+    """Tests for getting expense by ID."""
+
+    def test_get_existing(self):
+        """Test retrieving an existing expense by ID."""
+        expense = Expense(
+            id="findme123",
+            amount=25.0,
+            category="Transport",
+            description="Bus fare",
+            date=datetime.now()
+        )
+        save_expense(expense)
+
+        result = get_expense_by_id("findme123")
+        assert result is not None
+        assert result.id == "findme123"
+        assert result.description == "Bus fare"
+
+    def test_get_nonexistent(self):
+        """Test that non-existent ID returns None."""
+        result = get_expense_by_id("does-not-exist")
+        assert result is None
+
+    def test_get_after_multiple_saves(self):
+        """Test getting specific expense after saving multiple."""
+        for i in range(10):
+            expense = Expense(
+                id=f"multi{i}",
+                amount=float(i),
+                category="Test",
+                description=f"Expense {i}",
+                date=datetime.now()
+            )
+            save_expense(expense)
+
+        result = get_expense_by_id("multi5")
+        assert result is not None
+        assert result.amount == 5.0
+
+
+class TestRemoveExpense:
+    """Tests for removing expenses."""
+
+    def test_remove_existing(self):
+        """Test removing an existing expense."""
+        expense = Expense(
+            id="removeme",
+            amount=10.0,
+            category="Test",
+            description="To be removed",
+            date=datetime.now()
+        )
+        save_expense(expense)
+        assert get_expense_by_id("removeme") is not None
+
+        result = remove_expense("removeme")
+        assert result is True
+        assert get_expense_by_id("removeme") is None
+
+    def test_remove_nonexistent(self):
+        """Test removing non-existent expense returns False."""
+        result = remove_expense("fake-id")
+        assert result is False
+
+    def test_remove_only_target(self):
+        """Test that remove only deletes the target expense."""
+        for i in range(3):
+            expense = Expense(
+                id=f"keep{i}",
+                amount=float(i),
+                category="Test",
+                description=f"Expense {i}",
+                date=datetime.now()
+            )
+            save_expense(expense)
+
+        remove_expense("keep1")
+
+        expenses = load_expenses()
+        ids = [e.id for e in expenses]
+        assert "keep0" in ids
+        assert "keep1" not in ids
+        assert "keep2" in ids
+
+
+class TestClearAll:
+    """Tests for clearing all expenses."""
+
+    def test_clear_removes_all(self):
+        """Test that clear_all_expenses removes everything."""
+        for i in range(5):
+            expense = Expense(
+                id=f"clear{i}",
+                amount=float(i),
+                category="Test",
+                description=f"Expense {i}",
+                date=datetime.now()
+            )
+            save_expense(expense)
+
+        assert len(load_expenses()) == 5
+
+        clear_all_expenses()
+        assert len(load_expenses()) == 0
+
+    def test_clear_empty_db(self):
+        """Test that clearing empty database doesn't error."""
+        clear_all_expenses()  # Should not raise
+
+
+class TestExpenseCount:
+    """Tests for getting expense count."""
+
+    def test_count_empty(self):
+        """Test count on empty database."""
+        assert get_expense_count() == 0
+
+    def test_count_with_expenses(self):
+        """Test count with expenses."""
+        for i in range(7):
+            expense = Expense(
+                id=f"count{i}",
+                amount=float(i),
+                category="Test",
+                description=f"Expense {i}",
+                date=datetime.now()
+            )
+            save_expense(expense)
+
+        assert get_expense_count() == 7

package/levels/08-mcp-servers/exercise/tests/test_models.py

@@ -0,0 +1,240 @@
+"""Tests for expense models.
+
+This test file includes intentionally failing tests that students fix
+during the course:
+
+- test_add_negative_amount_should_fail: Fails until Lesson 3 (validation bug)
+- test_list_by_category_case_insensitive: Fails until a later lesson (case bug)
+"""
+
+import pytest
+from datetime import datetime
+from models import (
+    add_expense,
+    list_expenses,
+    delete_expense,
+    get_expense,
+    get_total_by_category,
+    Expense
+)
+
+
+class TestAddExpense:
+    """Tests for the add_expense function."""
+
+    def test_add_basic_expense(self):
+        """Test adding a simple expense."""
+        expense = add_expense(50.0, "Food", "Lunch at cafe")
+
+        assert expense.amount == 50.0
+        assert expense.category == "Food"
+        assert expense.description == "Lunch at cafe"
+        assert expense.id is not None
+        assert len(expense.id) == 8  # UUID prefix
+
+    def test_add_expense_with_date(self):
+        """Test adding expense with specific date."""
+        date = datetime(2026, 1, 15, 12, 30)
+        expense = add_expense(25.0, "Transport", "Uber to meeting", date)
+
+        assert expense.date == date
+        assert expense.amount == 25.0
+
+    def test_add_expense_default_date(self):
+        """Test that expense gets current date if not specified."""
+        before = datetime.now()
+        expense = add_expense(10.0, "Food", "Snack")
+        after = datetime.now()
+
+        assert before <= expense.date <= after
+
+    def test_add_expense_persists(self):
+        """Test that added expense can be retrieved."""
+        expense = add_expense(75.0, "Shopping", "New book")
+
+        retrieved = get_expense(expense.id)
+        assert retrieved is not None
+        assert retrieved.amount == 75.0
+        assert retrieved.description == "New book"
+
+    # =========================================================
+    # BUG TESTS - These fail until students fix them in Lesson 3
+    # =========================================================
+
+    def test_add_negative_amount_should_fail(self):
+        """BUG TEST: Negative amounts should raise ValueError.
+
+        This test FAILS initially - students fix this in Lesson 3
+        by adding validation to add_expense().
+
+        Expected fix:
+            if amount <= 0:
+                raise ValueError("Amount must be greater than 0")
+        """
+        with pytest.raises(ValueError, match="[Aa]mount"):
+            add_expense(-50.0, "Food", "Invalid expense")
+
+    def test_add_zero_amount_should_fail(self):
+        """BUG TEST: Zero amount should raise ValueError.
+
+        This test FAILS initially - students fix this in Lesson 3.
+        """
+        with pytest.raises(ValueError, match="[Aa]mount"):
+            add_expense(0, "Food", "Free lunch doesn't exist")
+
+    def test_add_empty_category_should_fail(self):
+        """BUG TEST: Empty category should raise ValueError.
+
+        This test FAILS initially - students fix this in Lesson 3.
+        """
+        with pytest.raises(ValueError, match="[Cc]ategory"):
+            add_expense(50.0, "", "No category")
+
+    def test_add_whitespace_category_should_fail(self):
+        """BUG TEST: Whitespace-only category should raise ValueError."""
+        with pytest.raises(ValueError, match="[Cc]ategory"):
+            add_expense(50.0, "   ", "Whitespace category")
+
+
+class TestListExpenses:
+    """Tests for the list_expenses function."""
+
+    def test_list_all_expenses(self, sample_expenses):
+        """Test listing all expenses without filters."""
+        expenses = list_expenses()
+        assert len(expenses) == 5
+
+    def test_list_empty(self):
+        """Test listing when no expenses exist."""
+        expenses = list_expenses()
+        assert len(expenses) == 0
+
+    def test_list_by_category(self):
+        """Test filtering by category (exact match)."""
+        add_expense(50.0, "Food", "Lunch")
+        add_expense(30.0, "Transport", "Uber")
+        add_expense(25.0, "Food", "Coffee")
+
+        food = list_expenses(category="Food")
+        assert len(food) == 2
+        assert all(e.category == "Food" for e in food)
+
+    def test_list_by_month(self):
+        """Test filtering by month."""
+        add_expense(50.0, "Food", "Jan expense", datetime(2026, 1, 15))
+        add_expense(30.0, "Food", "Feb expense", datetime(2026, 2, 10))
+
+        jan = list_expenses(month="2026-01")
+        assert len(jan) == 1
+        assert jan[0].description == "Jan expense"
+
+    def test_list_with_limit(self):
+        """Test limiting number of results."""
+        for i in range(10):
+            add_expense(float(i + 1), "Food", f"Expense {i}")
+
+        limited = list_expenses(limit=5)
+        assert len(limited) == 5
+
+    def test_list_sorted_by_date(self):
+        """Test that results are sorted by date descending."""
+        add_expense(10.0, "Food", "Old", datetime(2026, 1, 1))
+        add_expense(20.0, "Food", "New", datetime(2026, 1, 15))
+        add_expense(30.0, "Food", "Middle", datetime(2026, 1, 10))
+
+        expenses = list_expenses()
+        dates = [e.date for e in expenses]
+        assert dates == sorted(dates, reverse=True)
+
+    # =========================================================
+    # BUG TESTS - These fail until students fix them in a later lesson
+    # =========================================================
+
+    def test_list_by_category_case_insensitive(self, mixed_case_expenses):
+        """BUG TEST: Category filter should be case-insensitive.
+
+        This test FAILS initially - students fix this in a later lesson.
+
+        The seed data includes lowercase "food" entries that won't
+        match "Food" until the bug is fixed.
+
+        Expected fix in list_expenses():
+            if category:
+                category_lower = category.lower()
+                expenses = [e for e in expenses if e.category.lower() == category_lower]
+        """
+        # mixed_case_expenses has: "Food", "food", "FOOD"
+        food = list_expenses(category="Food")
+        assert len(food) == 3, (
+            f"Expected 3 'Food' expenses (case-insensitive), got {len(food)}. "
+            "Fix: make category filtering case-insensitive."
+        )
+
+    def test_list_category_lowercase_query(self, mixed_case_expenses):
+        """BUG TEST: Lowercase category query should still find matches."""
+        food = list_expenses(category="food")  # lowercase query
+        assert len(food) == 3, "Lowercase 'food' should match all Food variants"
+
+
+class TestDeleteExpense:
+    """Tests for the delete_expense function."""
+
+    def test_delete_existing(self):
+        """Test deleting an existing expense."""
+        expense = add_expense(50.0, "Food", "To be deleted")
+
+        result = delete_expense(expense.id)
+        assert result is True
+
+        # Verify it's gone
+        assert get_expense(expense.id) is None
+
+    def test_delete_nonexistent(self):
+        """Test deleting non-existent expense returns False."""
+        result = delete_expense("fake-id-12345")
+        assert result is False
+
+    def test_delete_twice(self):
+        """Test that deleting same expense twice fails second time."""
+        expense = add_expense(50.0, "Food", "Delete me")
+
+        assert delete_expense(expense.id) is True
+        assert delete_expense(expense.id) is False
+
+
+class TestGetExpense:
+    """Tests for the get_expense function."""
+
+    def test_get_existing(self):
+        """Test getting an existing expense."""
+        created = add_expense(99.99, "Shopping", "Test item")
+
+        retrieved = get_expense(created.id)
+        assert retrieved is not None
+        assert retrieved.id == created.id
+        assert retrieved.amount == 99.99
+
+    def test_get_nonexistent(self):
+        """Test getting non-existent expense returns None."""
+        result = get_expense("nonexistent-id")
+        assert result is None
+
+
+class TestGetTotalByCategory:
+    """Tests for the get_total_by_category function."""
+
+    def test_total_single_category(self):
+        """Test total for a single category."""
+        add_expense(50.0, "Food", "Item 1")
+        add_expense(30.0, "Food", "Item 2")
+        add_expense(100.0, "Shopping", "Other category")
+
+        total = get_total_by_category("Food")
+        assert total == 80.0
+
+    def test_total_empty_category(self):
+        """Test total for category with no expenses."""
+        add_expense(50.0, "Food", "Food item")
+
+        total = get_total_by_category("Transport")
+        assert total == 0.0

package/levels/08-mcp-servers/exercise/tests/test_reports.py

@@ -0,0 +1,190 @@
+"""Tests for report generation.
+
+Note: These tests will FAIL until students implement reports.py in Lesson 4.
+The tests serve as a specification for what needs to be implemented.
+"""
+
+import pytest
+from datetime import datetime
+from models import add_expense, Expense
+from reports import (
+    generate_monthly_report,
+    get_category_breakdown,
+    get_top_expenses,
+    save_report
+)
+
+
+class TestGenerateMonthlyReport:
+    """Tests for the generate_monthly_report function."""
+
+    @pytest.mark.skip(reason="Implement in Lesson 4")
+    def test_report_for_empty_month(self):
+        """Test report generation for month with no expenses."""
+        report = generate_monthly_report("2020-01")
+        assert "No expenses" in report or "no expenses" in report.lower()
+
+    @pytest.mark.skip(reason="Implement in Lesson 4")
+    def test_report_includes_total(self):
+        """Test that report includes total amount."""
+        add_expense(100.0, "Food", "Groceries", datetime(2026, 1, 15))
+        add_expense(50.0, "Transport", "Uber", datetime(2026, 1, 15))
+
+        report = generate_monthly_report("2026-01")
+
+        # Should contain total of $150
+        assert "150" in report
+
+    @pytest.mark.skip(reason="Implement in Lesson 4")
+    def test_report_includes_categories(self):
+        """Test that report includes category breakdown."""
+        add_expense(100.0, "Food", "Groceries", datetime(2026, 1, 15))
+        add_expense(50.0, "Transport", "Uber", datetime(2026, 1, 15))
+
+        report = generate_monthly_report("2026-01")
+
+        assert "Food" in report
+        assert "Transport" in report
+
+    @pytest.mark.skip(reason="Implement in Lesson 4")
+    def test_report_defaults_to_current_month(self):
+        """Test that no month argument uses current month."""
+        # This test is tricky since it depends on current date
+        # Just verify it doesn't error
+        report = generate_monthly_report()
+        assert report is not None
+        assert isinstance(report, str)
+
+    @pytest.mark.skip(reason="Implement in Lesson 4")
+    def test_report_format_is_markdown(self):
+        """Test that report is formatted as markdown."""
+        add_expense(100.0, "Food", "Test", datetime(2026, 1, 15))
+        report = generate_monthly_report("2026-01")
+
+        # Should have markdown headers
+        assert "#" in report
+
+
+class TestGetCategoryBreakdown:
+    """Tests for the get_category_breakdown function."""
+
+    @pytest.mark.skip(reason="Implement in Lesson 4")
+    def test_single_category(self):
+        """Test breakdown with single category."""
+        expenses = [
+            Expense("1", 50.0, "Food", "Lunch", datetime.now()),
+            Expense("2", 25.0, "Food", "Coffee", datetime.now()),
+        ]
+
+        breakdown = get_category_breakdown(expenses)
+
+        assert "Food" in breakdown
+        assert breakdown["Food"] == 75.0
+
+    @pytest.mark.skip(reason="Implement in Lesson 4")
+    def test_multiple_categories(self):
+        """Test breakdown with multiple categories."""
+        expenses = [
+            Expense("1", 50.0, "Food", "Lunch", datetime.now()),
+            Expense("2", 30.0, "Transport", "Bus", datetime.now()),
+            Expense("3", 20.0, "Food", "Snack", datetime.now()),
+        ]
+
+        breakdown = get_category_breakdown(expenses)
+
+        assert breakdown["Food"] == 70.0
+        assert breakdown["Transport"] == 30.0
+
+    @pytest.mark.skip(reason="Implement in Lesson 4")
+    def test_empty_list(self):
+        """Test breakdown with empty expense list."""
+        breakdown = get_category_breakdown([])
+        assert breakdown == {}
+
+
+class TestGetTopExpenses:
+    """Tests for the get_top_expenses function."""
+
+    @pytest.mark.skip(reason="Implement in Lesson 4")
+    def test_top_expenses_ordering(self):
+        """Test that expenses are sorted by amount descending."""
+        expenses = [
+            Expense("1", 25.0, "Food", "Small", datetime.now()),
+            Expense("2", 100.0, "Bills", "Big", datetime.now()),
+            Expense("3", 50.0, "Shopping", "Medium", datetime.now()),
+        ]
+
+        top = get_top_expenses(expenses, 3)
+
+        assert top[0].amount == 100.0
+        assert top[1].amount == 50.0
+        assert top[2].amount == 25.0
+
+    @pytest.mark.skip(reason="Implement in Lesson 4")
+    def test_top_n_limit(self):
+        """Test limiting to N expenses."""
+        expenses = [
+            Expense(str(i), float(i * 10), "Cat", "Desc", datetime.now())
+            for i in range(1, 11)
+        ]
+
+        top = get_top_expenses(expenses, 3)
+        assert len(top) == 3
+
+    @pytest.mark.skip(reason="Implement in Lesson 4")
+    def test_top_with_fewer_expenses(self):
+        """Test when requesting more than available."""
+        expenses = [
+            Expense("1", 50.0, "Food", "Only one", datetime.now()),
+        ]
+
+        top = get_top_expenses(expenses, 5)
+        assert len(top) == 1
+
+    @pytest.mark.skip(reason="Implement in Lesson 4")
+    def test_default_n_is_5(self):
+        """Test that default n value is 5."""
+        expenses = [
+            Expense(str(i), float(i), "Cat", "Desc", datetime.now())
+            for i in range(10)
+        ]
+
+        top = get_top_expenses(expenses)
+        assert len(top) == 5
+
+
+class TestSaveReport:
+    """Tests for the save_report function."""
+
+    @pytest.mark.skip(reason="Implement in Lesson 4")
+    def test_save_creates_file(self, tmp_path, monkeypatch):
+        """Test that save_report creates a file."""
+        import os
+        monkeypatch.chdir(tmp_path)
+
+        report_content = "# Test Report\n\nThis is a test."
+        path = save_report(report_content, "test-report.md")
+
+        assert path.exists()
+        assert path.read_text() == report_content
+
+    @pytest.mark.skip(reason="Implement in Lesson 4")
+    def test_save_creates_directory(self, tmp_path, monkeypatch):
+        """Test that save_report creates reports directory if needed."""
+        import os
+        monkeypatch.chdir(tmp_path)
+
+        save_report("# Test", "2026-01.md")
+
+        assert (tmp_path / "reports").is_dir()
+
+    @pytest.mark.skip(reason="Implement in Lesson 4")
+    def test_save_returns_path(self, tmp_path, monkeypatch):
+        """Test that save_report returns the file path."""
+        import os
+        monkeypatch.chdir(tmp_path)
+
+        path = save_report("# Test", "my-report.md")
+
+        assert path.name == "my-report.md"
+        assert "reports" in str(path)