amap/backend/tests/routers/test_users.py

import src.users.exceptions as exceptions
import src.users.service as service
import tests.factories.users as user_factory
from fastapi.exceptions import HTTPException
from src.auth.auth import get_current_user
from src.main import app


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

        response = client.get('/api/users')
        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,
            [],
            [],
        )
        assert mock_user

    def test_get_all_filters(
        self,
        client,
        mocker,
        mock_session,
        mock_user,
    ):
        mock_results = [
            user_factory.user_public_factory(name="test 2", id=2),
        ]
        mock = mocker.patch.object(
            service,
            'get_all',
            return_value=mock_results
        )
        response = client.get('/api/users?emails=test@test.test&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,
            ['test 2'],
            ['test@test.test'],
        )
        assert mock_user

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

        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 = user_factory.user_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/users/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_user
        )

    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/users/2')
        assert response.status_code == 404
        mock.assert_called_once_with(
            mock_session,
            2
        )
        mock_is_allowed.assert_called_once_with(
            mock_user
        )

    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.users.service.get_one')
        response = client.get('/api/users/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,
    ):
        user_body = user_factory.user_body_factory(name='test user create')
        user_create = user_factory.user_create_factory(name='test user create')
        user_result = user_factory.user_public_factory(name='test user create')

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

        response = client.post('/api/users', json=user_body)
        response_data = response.json()

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

    def test_create_one_unauthorized(
        self,
        client,
        mocker,
    ):
        def unauthorized():
            raise HTTPException(status_code=401)
        user_body = user_factory.user_body_factory(name='test user create')

        app.dependency_overrides[get_current_user] = unauthorized

        mock = mocker.patch('src.users.service.create_one')
        response = client.post('/api/users', json=user_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,
    ):
        user_body = user_factory.user_body_factory(name='test user update')
        user_update = user_factory.user_update_factory(name='test user update')
        user_result = user_factory.user_public_factory(name='test user update')

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

        response = client.put('/api/users/2', json=user_body)
        response_data = response.json()

        assert response.status_code == 200
        assert response_data['name'] == 'test user update'
        mock.assert_called_once_with(
            mock_session,
            2,
            user_update
        )
        mock_is_allowed.assert_called_once_with(
            mock_user
        )

    def test_update_one_notfound(
        self,
        client,
        mocker,
        mock_session,
        mock_user,
    ):
        user_body = user_factory.user_body_factory(name='test user update')
        user_update = user_factory.user_update_factory(name='test user update')

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

        response = client.put('/api/users/2', json=user_body)

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

    def test_update_one_unauthorized(
        self,
        client,
        mocker,
    ):
        def unauthorized():
            raise HTTPException(status_code=401)
        user_body = user_factory.user_body_factory(name='test user update')

        app.dependency_overrides[get_current_user] = unauthorized

        mock = mocker.patch('src.users.service.update_one')
        response = client.put('/api/users/2', json=user_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,
    ):
        user_result = user_factory.user_public_factory(name='test user delete')

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

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

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

    def test_delete_one_notfound(
        self,
        client,
        mocker,
        mock_session,
        mock_user,
    ):
        mock = mocker.patch.object(
            service,
            'delete_one',
            side_effect=exceptions.UserNotFoundError('User 2 not found')
        )
        mock_is_allowed = mocker.patch.object(
            service,
            'is_allowed',
            return_value=True
        )

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

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

    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.users.service.delete_one')
        response = client.delete('/api/users/2')

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

        app.dependency_overrides.clear()