amap/backend/tests/routers/test_contracts.py

import src.contracts.service as service
import tests.factories.contract_products as contract_products_factory
import tests.factories.contracts as contract_factory
import tests.factories.forms as form_factory
from fastapi.exceptions import HTTPException
from src import models
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,
            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(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_user):
        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,
            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):
        contract_body = contract_factory.contract_body_factory(
            products=[
                contract_products_factory.contract_product_body_factory(
                    product_id=1
                ),
                contract_products_factory.contract_product_body_factory(
                    product_id=2
                ),
                contract_products_factory.contract_product_body_factory(
                    product_id=3
                )
            ],
            cheques=[{'name': '123123', 'value': '100'}]
        )
        contract_result = contract_factory.contract_factory(
            products=[
                contract_products_factory.contract_product_factory(
                    product_id=1
                ),
                contract_products_factory.contract_product_factory(
                    product_id=2
                ),
                contract_products_factory.contract_product_factory(
                    product_id=3
                )
            ],
            form=form_factory.form_factory(),
            cheques=[models.Cheque(name='123123', value='100')]
        )
        mock = mocker.patch.object(
            service,
            'create_one',
            return_value=contract_result
        )
        print(mock, service.create_one)
        mocker.patch.object(
            service,
            'add_contract_file',
            return_value=True
        )
        mocker.patch(
            'src.contracts.generate_contract.generate_html_contract')

        response = client.post('/api/contracts', json=contract_body)
        assert response.status_code == 200
        contract_id = 'test_test_test type_hiver-2026'
        assert response.headers[
            'Content-Disposition'] == (
                f'attachment; filename=contract_{contract_id}.pdf'
        )

    def test_delete_one(self, client, mocker, mock_session, mock_user):
        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,
            mock_user
    ):
        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,
            mock_session,
            mock_user
    ):
        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()