amap/backend/tests/routers/test_contracts.py

import src.contracts.service as service
import src.models as models
from src.main import app
from src.auth.auth import get_current_user
import tests.factories.contracts as contract_factory

from fastapi.exceptions import HTTPException

class TestContracts:
    def test_get_all(self, client, mocker, mock_session, mock_user):
        mock_results = [
            contract_factory.contract_public_factory(name="test 1", id=1),
            contract_factory.contract_public_factory(name="test 2", id=2),
            contract_factory.contract_public_factory(name="test 3", 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(name="test 2", 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, mock_session, mock_user):
        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_user):
        mock_result = contract_factory.contract_public_factory(name="test 2", id=2)

        mock = mocker.patch.object(
            service,
            'get_one',
            return_value=mock_result
        )
        mock_is_allowed = 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_user):
        mock_result = None
        mock = mocker.patch.object(
            service,
            'get_one',
            return_value=mock_result
        )

        mock_is_allowed = mocker.patch.object(
            service,
            'is_allowed',
            return_value=True
        )
        response = client.get('/api/contracts/2')
        response_data = response.json()
        assert response.status_code == 404
        mock.assert_called_once_with(
            mock_session,
            2
        )
    
    def test_get_one_unauthorized(self, client, mocker, mock_session, mock_user):
        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_create_one(self, client, mocker, mock_session, mock_user):
        pass

    def test_delete_one(self, client, mocker, mock_session, mock_user):
        contract_result = contract_factory.contract_public_factory(name='test contract delete')

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

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

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

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

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

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

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

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

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

    def test_delete_one_unauthorized(self, client, mocker, mock_session, mock_user):
        def unauthorized():
            raise HTTPException(status_code=401)
        contract_body = contract_factory.contract_body_factory(name='test contract delete')
            
        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()