test_unique.py

"""Test the Unique constraint."""

import warnings
from typing import Annotated

import pytest
from pytest_mock import MockerFixture

from sqliter import SqliterDB
from sqliter.exceptions import RecordInsertionError, RecordUpdateError
from sqliter.model import BaseDBModel, Unique, unique


class TestUnique:
    """Test suite for the Unique constraint."""

    def test_unique_constraint_single_field(self) -> None:
        """Test that the Unique constraint is applied to a single field."""

        class User(BaseDBModel):
            name: str
            email: Annotated[str, unique()]

        db = SqliterDB(":memory:")
        db.create_table(User)

        # Insert a user successfully
        user1 = User(name="Alice", email="alice@example.com")
        db.insert(user1)

        # Attempt to insert a user with the same email
        user2 = User(name="Bob", email="alice@example.com")

        with pytest.raises(RecordInsertionError) as excinfo:
            db.insert(user2)

        assert "UNIQUE constraint failed: users.email" in str(excinfo.value)

        # Verify that only one user was inserted
        users = db.select(User).fetch_all()
        assert len(users) == 1
        assert users[0].name == "Alice"
        assert users[0].email == "alice@example.com"

    def test_unique_constraint_multi_column(self) -> None:
        """Test the Unique constraint on multiple fields."""

        class User(BaseDBModel):
            name: Annotated[str, unique()]
            email: str

        db = SqliterDB(":memory:")
        db.create_table(User)

        # Insert a user successfully
        user1 = User(name="Alice", email="alice@example.com")
        db.insert(user1)

        # Insert another user with the same email but different name (no
        # conflict)
        user2 = User(name="Bob", email="alice@example.com")
        db.insert(user2)

        # Attempt to insert a user with the same name (should fail)
        user3 = User(name="Alice", email="charlie@example.com")

        with pytest.raises(RecordInsertionError) as excinfo:
            db.insert(user3)

        assert "UNIQUE constraint failed: users.name" in str(excinfo.value)

    def test_unique_constraint_sql_generation(
        self, mocker: MockerFixture
    ) -> None:
        """Test that the correct SQL for the Unique constraint is generated."""

        class User(BaseDBModel):
            name: Annotated[str, unique()]
            email: str

        # Mock the cursor to capture executed SQL
        mock_cursor = mocker.MagicMock()
        mocker.patch.object(
            SqliterDB, "connect"
        ).return_value.cursor.return_value = mock_cursor

        db = SqliterDB(":memory:")
        db.create_table(User)

        # Capture the generated SQL statement for table creation
        sql = next(
            call.args[0]
            for call in mock_cursor.execute.call_args_list
            if "CREATE TABLE" in call.args[0]
        )

        # Remove the primary key part from the SQL for easier assertion
        sql_without_pk = sql.replace(
            '"pk" INTEGER PRIMARY KEY AUTOINCREMENT, ', ""
        )

        # Assert that the correct UNIQUE syntax is present for the 'name' field
        assert "CREATE TABLE" in sql
        assert '"name" TEXT UNIQUE' in sql_without_pk  # Correct SQLite syntax

    def test_unique_constraint_across_records(self) -> None:
        """Test that unique constraints hold across multiple records."""

        class User(BaseDBModel):
            name: str
            email: Annotated[str, unique()]

        db = SqliterDB(":memory:")
        db.create_table(User)

        # Insert multiple users with unique emails
        user1 = User(name="Alice", email="alice@example.com")
        user2 = User(name="Bob", email="bob@example.com")
        db.insert(user1)
        db.insert(user2)

        # Insert another user with a duplicate email (should fail)
        user3 = User(name="Charlie", email="bob@example.com")
        with pytest.raises(RecordInsertionError) as excinfo:
            db.insert(user3)

        assert "UNIQUE constraint failed: users.email" in str(excinfo.value)

        # Verify that only two users are inserted
        users = db.select(User).fetch_all()
        assert len(users) == 2

    def test_unique_constraint_with_null(self) -> None:
        """Test that the Unique constraint allows null values if applicable."""

        class User(BaseDBModel):
            name: str
            email: Annotated[str | None, unique()]

        db = SqliterDB(":memory:")
        db.create_table(User)

        # Insert a user with a null email
        user1 = User(name="Alice", email=None)
        db.insert(user1)

        # Insert another user with a null email (no conflict)
        user2 = User(name="Bob", email=None)
        db.insert(user2)

        # Verify that both users were inserted successfully
        users = db.select(User).fetch_all()
        assert len(users) == 2
        assert {u.name for u in users} == {"Alice", "Bob"}
        assert {u.email for u in users} == {None}

    def test_unique_constraint_with_different_values(self) -> None:
        """Test that Unique constraint allows different unique values."""

        class User(BaseDBModel):
            name: str
            email: Annotated[str, unique()]

        db = SqliterDB(":memory:")
        db.create_table(User)

        # Insert a user with a unique email
        user1 = User(name="Alice", email="alice@example.com")
        db.insert(user1)

        # Insert another user with a different email (no conflict)
        user2 = User(name="Bob", email="bob@example.com")
        db.insert(user2)

        # Verify that both users were inserted successfully
        users = db.select(User).fetch_all()
        assert len(users) == 2
        assert {u.email for u in users} == {
            "alice@example.com",
            "bob@example.com",
        }

    def test_unique_constraint_multiple_fields(self) -> None:
        """Test that multiple fields with unique constraints are respected."""

        class User(BaseDBModel):
            username: Annotated[str, unique()]
            email: Annotated[str, unique()]

        db = SqliterDB(":memory:")
        db.create_table(User)

        # Insert a user successfully
        user1 = User(username="Alice", email="alice@example.com")
        db.insert(user1)

        # Attempt to insert a user with the same username (should fail)
        user2 = User(username="Alice", email="bob@example.com")
        with pytest.raises(RecordInsertionError):
            db.insert(user2)

        # Attempt to insert a user with the same email (should fail)
        user3 = User(username="Bob", email="alice@example.com")
        with pytest.raises(RecordInsertionError):
            db.insert(user3)

    def test_unique_constraint_case_sensitivity(self) -> None:
        """Test that the unique constraint is case-sensitive for text fields."""

        class User(BaseDBModel):
            email: Annotated[str, unique()]

        db = SqliterDB(":memory:")
        db.create_table(User)

        # Insert user with lowercase email
        user1 = User(email="alice@example.com")
        db.insert(user1)

        # Attempt to insert user with same email but different case (should
        # pass)
        user2 = User(email="ALICE@example.com")
        db.insert(user2)

        users = db.select(User).fetch_all()
        assert len(users) == 2

    def test_unique_constraint_empty_string_vs_null(self) -> None:
        """Test SQLite diffs between empty strings & null for unique."""

        class User(BaseDBModel):
            email: Annotated[str | None, unique()]

        db = SqliterDB(":memory:")
        db.create_table(User)

        # Insert user with a NULL email
        user1 = User(email=None)
        db.insert(user1)

        # Insert user with an empty string as email (should pass)
        user2 = User(email="")
        db.insert(user2)

        # Verify both users were inserted
        users = db.select(User).fetch_all()
        assert len(users) == 2

    def test_unique_constraint_on_update(self) -> None:
        """Test modifying a record to violate the unique constraint fails."""

        class User(BaseDBModel):
            email: Annotated[str, unique()]
            name: str

        db = SqliterDB(":memory:")
        db.create_table(User)

        # Insert two users
        user1 = User(name="Alice", email="alice@example.com")
        user2 = User(name="Bob", email="bob@example.com")
        db.insert(user1)
        user2 = db.insert(user2)

        # Attempt to update user2's email to match user1's email (should fail)
        user2.email = "alice@example.com"
        with pytest.raises(RecordUpdateError):
            db.update(user2)

    @pytest.mark.filterwarnings("ignore::DeprecationWarning")
    def test_unique_alias_backward_compatibility(self) -> None:
        """Test that the deprecated Unique alias still works."""

        class User(BaseDBModel):
            name: str
            email: Annotated[str, Unique()]

        db = SqliterDB(":memory:")
        db.create_table(User)

        # Insert a user successfully
        user1 = User(name="Alice", email="alice@example.com")
        db.insert(user1)

        # Attempt to insert a user with the same email (should fail)
        user2 = User(name="Bob", email="alice@example.com")
        with pytest.raises(RecordInsertionError) as excinfo:
            db.insert(user2)

        assert "UNIQUE constraint failed: users.email" in str(excinfo.value)

        # Verify that only one user was inserted
        users = db.select(User).fetch_all()
        assert len(users) == 1

    @pytest.mark.filterwarnings("ignore::DeprecationWarning")
    def test_unique_alias_deprecation_warning(self) -> None:
        """Test that using Unique alias triggers a deprecation warning."""
        with warnings.catch_warnings(record=True) as w:
            warnings.simplefilter("always")

            # This should trigger a deprecation warning
            class User(BaseDBModel):
                email: Annotated[str, Unique()]

            # dont need to do this for the test, but it stops Codacy linter
            # complaining.
            db = SqliterDB(":memory:")
            db.create_table(User)

            # Check that a warning was issued
            assert len(w) >= 1
            assert issubclass(w[0].category, DeprecationWarning)
            assert "Use 'unique' instead" in str(w[0].message)
            assert "future version" in str(w[0].message)

    def test_unique_with_non_dict_json_schema_extra(self) -> None:
        """Test that unique handles non-dict json_schema_extra correctly."""

        # Pass a non-dict value for json_schema_extra (e.g., a list)
        # This should trigger line 23 which converts it to an empty dict
        class User(BaseDBModel):
            name: str
            email: Annotated[
                str, unique(json_schema_extra=["not", "a", "dict"])
            ]

        db = SqliterDB(":memory:")
        db.create_table(User)

        # Verify the unique constraint still works despite the non-dict input
        user1 = User(name="Alice", email="alice@example.com")
        db.insert(user1)

        user2 = User(name="Bob", email="alice@example.com")
        with pytest.raises(RecordInsertionError) as excinfo:
            db.insert(user2)

        assert "UNIQUE constraint failed: users.email" in str(excinfo.value)