165 lines
5.3 KiB
Python
165 lines
5.3 KiB
Python
from datetime import date
|
|
from decimal import Decimal
|
|
|
|
import pytest
|
|
|
|
from src.models.category import Category, CategoryBudget
|
|
from tests.factories import CategoryFactory
|
|
|
|
|
|
class TestCategoryComputedFields:
|
|
"""Tests for Category's computed fields and special methods."""
|
|
|
|
def test_hash_id_computed_field_simple(self):
|
|
"""Test hash_id for single-level category."""
|
|
c = Category.from_str("single")
|
|
assert c
|
|
assert hasattr(c, "hash_id")
|
|
assert isinstance(c.hash_id, str)
|
|
# Hash should be deterministic for same inputs
|
|
c2 = Category.from_str("single")
|
|
assert c2
|
|
assert c.hash_id == c2.hash_id
|
|
|
|
def test_hash_id_computed_field_nested(self):
|
|
"""Test hash_id for multi-level category hierarchy."""
|
|
c1 = Category.from_str("level1:level2:level3")
|
|
assert c1
|
|
assert hasattr(c1, "hash_id")
|
|
|
|
c2 = Category.from_str("level1:level2:level3")
|
|
assert c2
|
|
assert c1.hash_id == c2.hash_id
|
|
|
|
def test_hash_id_different_hierarchy(self):
|
|
"""Test that different hierarchies have different hash_ids."""
|
|
c1 = Category.from_str("A:B")
|
|
c2 = Category.from_str("A:C")
|
|
assert c1
|
|
assert c2
|
|
# Different last level -> different hash_id
|
|
assert c1.hash_id != c2.hash_id
|
|
|
|
def test_hash_id_same_name_different_parent(self):
|
|
"""Test that same name but different parent gives different hash."""
|
|
root = Category(name="Budget")
|
|
cat1 = Category(name="Budget", parent=root)
|
|
|
|
# Create another with same name but no parent
|
|
orphan = Category.from_str("Budget")
|
|
assert orphan
|
|
|
|
assert cat1.hash_id != orphan.hash_id
|
|
|
|
def test_to_str_single_level(self):
|
|
"""Test to_str() for single-level category."""
|
|
c = Category.from_str("single")
|
|
assert c
|
|
assert c.to_str() == "single"
|
|
|
|
def test_to_str_nested(self):
|
|
"""Test to_str() for nested category."""
|
|
c = Category.from_str("parent:child:grandchild")
|
|
assert c
|
|
assert c.to_str() == "parent:child:grandchild"
|
|
|
|
def test_str_uses_to_str(self):
|
|
"""Test that __str__ delegates to to_str()."""
|
|
c = Category.from_str("A:B:C")
|
|
assert c
|
|
assert str(c) == c.to_str() == "A:B:C"
|
|
|
|
def test_repr_simple(self):
|
|
"""Test repr() for single-level category."""
|
|
c = Category.from_str("single")
|
|
expected = 'Category.from_str("single")'
|
|
assert repr(c) == expected
|
|
|
|
def test_repr_nested(self):
|
|
"""Test repr() for nested category."""
|
|
c = Category.from_str("parent:child")
|
|
expected = 'Category.from_str("parent:child")'
|
|
assert repr(c) == expected
|
|
|
|
|
|
class TestCategoryBudgetValidation:
|
|
"""Tests for CategoryBudget's date range validation."""
|
|
|
|
def test_valid_budget_no_dates(self):
|
|
"""Budget with None dates is valid."""
|
|
cat = CategoryFactory.build()
|
|
budget = CategoryBudget(
|
|
category=cat,
|
|
amount_eur=Decimal("100.00"),
|
|
)
|
|
assert budget.valid_from is None
|
|
assert budget.valid_to is None
|
|
|
|
def test_valid_budget_with_dates(self):
|
|
"""Budget with valid date range is accepted."""
|
|
|
|
cat = CategoryFactory.build()
|
|
budget = CategoryBudget(
|
|
category=cat,
|
|
amount_eur=Decimal("100.00"),
|
|
valid_from=date(2026, 10, 1),
|
|
valid_to=date(2026, 10, 31),
|
|
)
|
|
assert budget.valid_from == date(2026, 10, 1)
|
|
assert budget.valid_to == date(2026, 10, 31)
|
|
|
|
def test_invalid_date_range_raises(self):
|
|
"""Budget with valid_from > valid_to raises ValueError."""
|
|
|
|
cat = CategoryFactory.build()
|
|
|
|
with pytest.raises(ValueError) as exc_info:
|
|
CategoryBudget(
|
|
category=cat,
|
|
amount_eur=Decimal("100.00"),
|
|
valid_from=date(2026, 10, 31),
|
|
valid_to=date(2026, 10, 1),
|
|
)
|
|
|
|
assert "valid_from" in str(exc_info.value)
|
|
assert "valid_to" in str(exc_info.value)
|
|
assert "nor in order" in str(exc_info.value)
|
|
|
|
def test_valid_budget_exact_boundary(self):
|
|
"""Budget with exact same from and to is valid (single day)."""
|
|
|
|
cat = CategoryFactory.build()
|
|
budget = CategoryBudget(
|
|
category=cat,
|
|
amount_eur=Decimal("100.00"),
|
|
valid_from=date(2026, 10, 1),
|
|
valid_to=date(2026, 10, 1),
|
|
)
|
|
assert budget.valid_from == date(2026, 10, 1)
|
|
assert budget.valid_to == date(2026, 10, 1)
|
|
|
|
def test_validation_preserves_original_values(self):
|
|
"""Validation doesn't change the model's original values."""
|
|
|
|
cat = CategoryFactory.build()
|
|
budget = CategoryBudget(
|
|
category=cat,
|
|
amount_eur=Decimal("150.75"),
|
|
valid_from=date(2026, 9, 1),
|
|
valid_to=date(2026, 9, 30),
|
|
)
|
|
|
|
# Create an invalid one (valid_from > valid_to) and verify validation catches it
|
|
try:
|
|
CategoryBudget(
|
|
category=cat,
|
|
amount_eur=Decimal("200.00"),
|
|
valid_from=date(2026, 12, 31),
|
|
valid_to=date(2026, 12, 30),
|
|
)
|
|
except ValueError:
|
|
pass # Expected
|
|
|
|
# Valid one should still have original values
|
|
assert budget.amount_eur == 150.75
|