import src.contracts.service as service
import tests.factories.contracts as contract_factory
from fastapi.exceptions import HTTPException
from src.auth.auth import get_current_user
from src.main import app


class TestContracts:
    def test_get_all(
        self, 
        client, 
        mocker, 
        mock_session, 
        mock_user
    ):
        mock_results = [
            contract_factory.contract_public_factory(id=1),
            contract_factory.contract_public_factory(id=2),
            contract_factory.contract_public_factory(id=3),
        ]
        mock = mocker.patch.object(
            service,
            'get_all',
            return_value=mock_results
        )

        response = client.get('/api/contracts')
        response_data = response.json()
        assert response.status_code == 200
        assert response_data[0]['id'] == 1
        assert len(response_data) == len(mock_results)
        mock.assert_called_once_with(
            mock_session,
            mock_user,
            [],
        )

    def test_get_all_filters(
        self, 
        client, 
        mocker, 
        mock_session, 
        mock_user
    ):
        mock_results = [
            contract_factory.contract_public_factory(id=2),
        ]
        mock = mocker.patch.object(
            service,
            'get_all',
            return_value=mock_results
        )

        response = client.get('/api/contracts?forms=form test')
        response_data = response.json()
        assert response.status_code == 200
        assert response_data[0]['id'] == 2
        assert len(response_data) == len(mock_results)
        mock.assert_called_once_with(
            mock_session,
            mock_user,
            ['form test'],
        )

    def test_get_all_unauthorized(
        self,
        client,
        mocker,
    ):
        def unauthorized():
            raise HTTPException(status_code=401)

        app.dependency_overrides[get_current_user] = unauthorized

        mock = mocker.patch('src.contracts.service.get_all')
        response = client.get('/api/contracts')

        assert response.status_code == 401
        mock.assert_not_called()

        app.dependency_overrides.clear()

    def test_get_one(
        self, 
        client, 
        mocker, 
        mock_session, 
    ):
        mock_result = contract_factory.contract_public_factory(id=2)

        mock = mocker.patch.object(
            service,
            'get_one',
            return_value=mock_result
        )
        mocker.patch.object(
            service,
            'is_allowed',
            return_value=True
        )
        response = client.get('/api/contracts/2')
        response_data = response.json()

        assert response.status_code == 200
        assert response_data['id'] == 2
        mock.assert_called_once_with(
            mock_session,
            2
        )

    def test_get_one_notfound(
        self, 
        client, 
        mocker, 
        mock_session, 
    ):
        mock_result = None
        mock = mocker.patch.object(
            service,
            'get_one',
            return_value=mock_result
        )

        mocker.patch.object(
            service,
            'is_allowed',
            return_value=True
        )
        response = client.get('/api/contracts/2')
        assert response.status_code == 404
        mock.assert_called_once_with(
            mock_session,
            2
        )

    def test_get_one_unauthorized(
        self,
        client,
        mocker,
    ):
        def unauthorized():
            raise HTTPException(status_code=401)

        app.dependency_overrides[get_current_user] = unauthorized

        mock = mocker.patch('src.contracts.service.get_one')
        response = client.get('/api/contracts/2')

        assert response.status_code == 401
        mock.assert_not_called()

        app.dependency_overrides.clear()

    def test_delete_one(
        self, 
        client, 
        mocker, 
        mock_session,
    ):
        contract_result = contract_factory.contract_public_factory()

        mock = mocker.patch.object(
            service,
            'delete_one',
            return_value=contract_result
        )

        mocker.patch.object(
            service,
            'is_allowed',
            return_value=True
        )

        response = client.delete('/api/contracts/2')

        assert response.status_code == 200
        mock.assert_called_once_with(
            mock_session,
            2,
        )

    def test_delete_one_notfound(
        self,
        client,
        mocker,
        mock_session,
    ):
        contract_result = None

        mock = mocker.patch.object(
            service,
            'delete_one',
            return_value=contract_result
        )

        mocker.patch.object(
            service,
            'is_allowed',
            return_value=True
        )

        response = client.delete('/api/contracts/2')

        assert response.status_code == 404
        mock.assert_called_once_with(
            mock_session,
            2,
        )

    def test_delete_one_unauthorized(
        self,
        client,
        mocker,
    ):
        def unauthorized():
            raise HTTPException(status_code=401)

        app.dependency_overrides[get_current_user] = unauthorized

        mock = mocker.patch('src.contracts.service.delete_one')
        response = client.delete('/api/contracts/2')

        assert response.status_code == 401
        mock.assert_not_called()

        app.dependency_overrides.clear()