from sqlalchemy import Engine
from typing import Callable
from src.infra import CRUDRepoImpl, Base
import pytest


class CRUDRepoHelper[A: Base, B, C]:
    @pytest.fixture
    def repo(self, db: Engine) -> CRUDRepoImpl[A, B, C]:
        import pdb

        pdb.set_trace()
        raise NotImplementedError()

    @pytest.fixture
    def dto(self) -> C:
        raise NotImplementedError()

    @pytest.fixture
    def item(self, repo: CRUDRepoImpl[A, B, C], dto: C) -> B:
        return repo.create(dto, None)

    @pytest.fixture
    def transform(self) -> Callable[[B], B]:
        raise NotImplementedError

    @pytest.fixture
    def expected_transformed_value(self, item: B) -> B:
        raise NotImplementedError()

    def test_create(self, item: B):
        assert item is not None

    def test_create_returns_none_if_invalid(self, repo: CRUDRepoImpl[A, B, C], dto: C):
        def always_invalid(*_args, **_kw):
            raise ValueError('test')

        with pytest.raises(ValueError):
            repo.create(dto, always_invalid)

    def test_create_returns_a_value_if_valid(self, repo: CRUDRepoImpl[A, B, C], dto: C):
        assert repo.create(dto, lambda _: None) is not None

    def test_get_returns_none_when_missing(self, repo: CRUDRepoImpl[A, B, C]):
        assert repo.get(42) is None

    def test_get_returns_a_value_if_it_exists(self, repo: CRUDRepoImpl[A, B, C], item: B):
        assert repo.get(1) == item

    def test_update(
        self, repo: CRUDRepoImpl[A, B, C], transform: Callable[[B], B], item: B, expected_transformed_value: B
    ):
        assert repo.update(1, transform) == expected_transformed_value

    def test_delete(self, repo: CRUDRepoImpl[A, B, C], item: B):
        assert repo.get(1) is not None
        repo.delete(1, None)
        assert repo.get(1) is None