kanban-app/backend/tests/test_models.py

"""Test models"""
from decimal import Decimal

import pytest

from app.models import Order, OrderItem, Product, User


class TestUserModel:
    """Test User model"""

    @pytest.mark.unit
    def test_user_creation(self, db_session):
        """Test creating a user"""
        user = User(
            email="test2@example.com",
            username="testuser2",
            first_name="Test",
            last_name="User",
            is_admin=False,
            is_active=True,
        )
        user.set_password("password123")
        db_session.add(user)
        db_session.commit()

        assert user.id is not None
        assert user.email == "test2@example.com"
        assert user.username == "testuser2"
        assert user.first_name == "Test"
        assert user.last_name == "User"

    @pytest.mark.unit
    def test_user_password_hashing(self, db_session):
        """Test password hashing and verification"""
        user = User(email="test1@example.com", username="testuser1")
        user.set_password("password123")
        db_session.add(user)
        db_session.commit()

        assert user.check_password("password123") is True
        assert user.check_password("wrongpassword") is False

    @pytest.mark.unit
    def test_user_to_dict(self, db_session):
        """Test user serialization to dictionary"""
        user = User(
            email="test@example.com",
            username="testuser",
            first_name="Test",
            last_name="User",
        )
        user.set_password("password123")
        db_session.add(user)
        db_session.commit()

        user_dict = user.to_dict()
        assert user_dict["email"] == "test@example.com"
        assert user_dict["username"] == "testuser"
        assert "password" not in user_dict
        assert "password_hash" not in user_dict

    @pytest.mark.unit
    def test_user_repr(self, db_session):
        """Test user string representation"""
        user = User(email="test3@example.com", username="testuser3")
        user.set_password("password123")
        db_session.add(user)
        db_session.commit()

        assert repr(user) == "<User testuser3>"


class TestProductModel:
    """Test Product model"""

    @pytest.mark.unit
    def test_product_creation(self, db_session):
        """Test creating a product"""
        product = Product(
            name="Test Product",
            description="A test product",
            price=Decimal("99.99"),
            stock=10,
            image_url="https://example.com/product.jpg",
        )
        db_session.add(product)
        db_session.commit()

        assert product.id is not None
        assert product.name == "Test Product"
        assert product.price == Decimal("99.99")
        assert product.stock == 10
        assert product.is_active is True

    @pytest.mark.unit
    def test_product_to_dict(self, db_session):
        """Test product serialization to dictionary"""
        product = Product(
            name="Test Product",
            description="A test product",
            price=Decimal("99.99"),
            stock=10,
        )
        db_session.add(product)
        db_session.commit()

        product_dict = product.to_dict()
        assert product_dict["name"] == "Test Product"
        assert product_dict["price"] == 99.99
        assert isinstance(product_dict["created_at"], str)
        assert isinstance(product_dict["updated_at"], str)

    @pytest.mark.unit
    def test_product_defaults(self, db_session):
        """Test product default values"""
        product = Product(name="Test Product", price=Decimal("9.99"))
        db_session.add(product)
        db_session.commit()

        assert product.stock == 0
        assert product.is_active is True
        assert product.description is None
        assert product.image_url is None

    @pytest.mark.unit
    def test_product_repr(self, db_session):
        """Test product string representation"""
        product = Product(name="Test Product", price=Decimal("9.99"))
        db_session.add(product)
        db_session.commit()

        assert repr(product) == "<Product Test Product>"


class TestOrderModel:
    """Test Order model"""

    @pytest.mark.unit
    def test_order_creation(self, db_session, regular_user):
        """Test creating an order"""
        order = Order(
            user_id=regular_user.id,
            total_amount=Decimal("199.99"),
            shipping_address="123 Test St",
        )
        db_session.add(order)
        db_session.commit()

        assert order.id is not None
        assert order.user_id == regular_user.id
        assert order.total_amount == Decimal("199.99")

    @pytest.mark.unit
    def test_order_to_dict(self, db_session, regular_user):
        """Test order serialization to dictionary"""
        order = Order(
            user_id=regular_user.id,
            total_amount=Decimal("199.99"),
            shipping_address="123 Test St",
        )
        db_session.add(order)
        db_session.commit()

        order_dict = order.to_dict()
        assert order_dict["user_id"] == regular_user.id
        assert order_dict["total_amount"] == 199.99
        assert isinstance(order_dict["created_at"], str)


class TestOrderItemModel:
    """Test OrderItem model"""

    @pytest.mark.unit
    def test_order_item_creation(self, db_session, order, product):
        """Test creating an order item"""
        order_item = OrderItem(
            order_id=order.id, product_id=product.id, quantity=2, price=product.price
        )
        db_session.add(order_item)
        db_session.commit()

        assert order_item.id is not None
        assert order_item.order_id == order.id
        assert order_item.product_id == product.id
        assert order_item.quantity == 2

    @pytest.mark.unit
    def test_order_item_to_dict(self, db_session, order, product):
        """Test order item serialization to dictionary"""
        order_item = OrderItem(
            order_id=order.id, product_id=product.id, quantity=2, price=product.price
        )
        db_session.add(order_item)
        db_session.commit()

        item_dict = order_item.to_dict()
        assert item_dict["order_id"] == order.id
        assert item_dict["product_id"] == product.id
        assert item_dict["quantity"] == 2