amap/backend/tests/routers/test_products.py

import src.products.service as service
import tests.factories.products as product_factory
from fastapi.exceptions import HTTPException
from src.auth.auth import get_current_user
from src.main import app
from src.products import exceptions


class TestProducts:
    def test_get_all(
        self,
        client,
        mocker,
        mock_session,
        mock_user
    ):
        mock_results = [
            product_factory.product_public_factory(name="test 1", id=1),
            product_factory.product_public_factory(name="test 2", id=2),
            product_factory.product_public_factory(name="test 3", id=3),
        ]
        mock = mocker.patch.object(
            service,
            'get_all',
            return_value=mock_results
        )

        response = client.get('/api/products')
        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 = [
            product_factory.product_public_factory(name="test 2", id=2),
        ]
        mock = mocker.patch.object(
            service,
            'get_all',
            return_value=mock_results
        )

        response = client.get('/api/products?types=1&names=test 2')
        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,
            ['test 2'],
            [],
            ['1'],
        )

    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.products.service.get_all')
        response = client.get('/api/products')

        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 = product_factory.product_public_factory(
            name="test 2", id=2)

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

        mock = mocker.patch.object(
            service,
            'get_one',
            return_value=mock_result
        )

        response = client.get('/api/products/2')
        response_data = response.json()

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

    def test_get_one_notfound(
        self,
        client,
        mocker,
        mock_session,
        mock_user,
    ):
        mock_result = None
        mock_is_allowed = mocker.patch.object(
            service,
            'is_allowed',
            return_value=True
        )
        mock = mocker.patch.object(
            service,
            'get_one',
            return_value=mock_result
        )
        response = client.get('/api/products/2')
        assert response.status_code == 404
        mock.assert_called_once_with(
            mock_session,
            2
        )
        mock_is_allowed.assert_called_once_with(
            mock_session,
            mock_user,
            _id=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.products.service.get_one')
        response = client.get('/api/products/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,
    ):
        product_body = product_factory.product_body_factory(
            name='test product create')
        product_create = product_factory.product_create_factory(
            name='test product create')
        product_result = product_factory.product_public_factory(
            name='test product create')

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

        response = client.post('/api/products', json=product_body)
        response_data = response.json()

        assert response.status_code == 200
        assert response_data['name'] == 'test product create'
        mock.assert_called_once_with(
            mock_session,
            product_create
        )
        mock_is_allowed.assert_called_once_with(
            mock_session,
            mock_user,
            product=product_create
        )

    def test_create_one_unauthorized(
        self,
        client,
        mocker,
    ):
        def unauthorized():
            raise HTTPException(status_code=401)
        product_body = product_factory.product_body_factory(
            name='test product create')

        app.dependency_overrides[get_current_user] = unauthorized

        mock = mocker.patch('src.products.service.create_one')
        response = client.post('/api/products', json=product_body)

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

        app.dependency_overrides.clear()

    def test_update_one(
        self,
        client,
        mocker,
        mock_session,
        mock_user,
    ):
        product_body = product_factory.product_body_factory(
            name='test product update'
        )
        product_update = product_factory.product_update_factory(
            name='test product update'
        )
        product_result = product_factory.product_public_factory(
            name='test product update'
        )

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

        response = client.put('/api/products/2', json=product_body)
        response_data = response.json()

        assert response.status_code == 200
        assert response_data['name'] == 'test product update'
        mock.assert_called_once_with(
            mock_session,
            2,
            product_update
        )

        mock_is_allowed.assert_called_once_with(
            mock_session,
            mock_user,
            _id=2
        )

    def test_update_one_notfound(
        self,
        client,
        mocker,
        mock_session,
        mock_user,
    ):
        product_body = product_factory.product_body_factory(
            name='test product update'
        )
        product_update = product_factory.product_update_factory(
            name='test product update'
        )

        mock_is_allowed = mocker.patch.object(
            service,
            'is_allowed',
            return_value=True
        )
        mock = mocker.patch.object(
            service,
            'update_one',
            side_effect=exceptions.ProductNotFoundError('Product not found')
        )

        response = client.put('/api/products/2', json=product_body)

        assert response.status_code == 404
        mock.assert_called_once_with(
            mock_session,
            2,
            product_update
        )
        mock_is_allowed.assert_called_once_with(
            mock_session,
            mock_user,
            _id=2
        )

    def test_update_one_unauthorized(
        self,
        client,
        mocker,
    ):
        def unauthorized():
            raise HTTPException(status_code=401)
        product_body = product_factory.product_body_factory(
            name='test product update')

        app.dependency_overrides[get_current_user] = unauthorized

        mock = mocker.patch('src.products.service.update_one')
        response = client.put('/api/products/2', json=product_body)

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

        app.dependency_overrides.clear()

    def test_delete_one(
        self,
        client,
        mocker,
        mock_session,
        mock_user,
    ):
        product_result = product_factory.product_public_factory(
            name='test product delete')

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

        mock_is_allowed = mocker.patch.object(
            service,
            'is_allowed',
            return_value=True
        )
        response = client.delete('/api/products/2')
        response_data = response.json()

        assert response.status_code == 200
        assert response_data['name'] == 'test product delete'
        mock.assert_called_once_with(
            mock_session,
            2,
        )
        mock_is_allowed.assert_called_once_with(
            mock_session,
            mock_user,
            _id=2
        )

    def test_delete_one_notfound(
        self,
        client,
        mocker,
        mock_session,
        mock_user,
    ):
        mock = mocker.patch.object(
            service,
            'delete_one',
            side_effect=exceptions.ProductNotFoundError('Product not found')
        )

        mock_is_allowed = mocker.patch.object(
            service,
            'is_allowed',
            return_value=True
        )
        response = client.delete('/api/products/2')

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

        mock_is_allowed.assert_called_once_with(
            mock_session,
            mock_user,
            _id=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.products.service.delete_one')
        response = client.delete('/api/products/2')

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

        app.dependency_overrides.clear()