add forms, shipments tests

backend/tests/fixtures.py

@@ -1,12 +1,15 @@
 import pytest
+import datetime
 from sqlmodel import Session
 
 import src.models as models
 import src.forms.service as forms_service
+import src.shipments.service as shipments_service
 import src.productors.service as productors_service
 import src.products.service as products_service
 import src.users.service as users_service
 import tests.factories.forms as forms_factory
+import tests.factories.shipments as shipments_factory
 import tests.factories.productors as productors_factory
 import tests.factories.products as products_factory
 import tests.factories.users as users_factory
@@ -77,6 +80,36 @@ def user(session: Session) -> models.UserPublic:
     )
     return user
 
+@pytest.fixture
+def users(session: Session) -> list[models.UserPublic]:
+    users = [
+        users_service.create_one(
+            session,
+            users_factory.user_create_factory(
+                name='test user 1 (admin)', 
+                email='test1@test.com',
+                role_names=['Légumineuses', 'Légumes', 'Oeufs', 'Porc-Agneau', 'Vin', 'Fruits']
+            )
+        ),
+        users_service.create_one(
+            session,
+            users_factory.user_create_factory(
+                name='test user 2', 
+                email='test2@test.com',
+                role_names=['Légumineuses']
+            )
+        ),
+        users_service.create_one(
+            session,
+            users_factory.user_create_factory(
+                name='test user 3', 
+                email='test3@test.com',
+                role_names=['Porc-Agneau']
+            )
+        )
+    ]
+    return users
+
 @pytest.fixture
 def referer(session: Session) -> models.UserPublic:
     referer = users_service.create_one(
@@ -89,6 +122,30 @@ def referer(session: Session) -> models.UserPublic:
     )
     return referer
 
+@pytest.fixture
+def shipments(session: Session, forms: list[models.FormPublic], products: list[models.ProductPublic]):
+    shipments = [
+        shipments_service.create_one(
+            session, 
+            shipments_factory.shipment_create_factory(
+                name='test shipment 1',
+                date=datetime.date(2025, 10, 10),
+                form_id=forms[0].id,
+                product_ids=[p.id for p in products]
+            )
+        ),
+        shipments_service.create_one(
+            session, 
+            shipments_factory.shipment_create_factory(
+                name='test shipment 2',
+                date=datetime.date(2025, 11, 10),
+                form_id=forms[0].id,
+                product_ids=[p.id for p in products]
+            )
+        ),
+    ]
+    return shipments
+
 @pytest.fixture
 def forms(
     session: Session, 

backend/tests/routers/test_contracts.py

@@ -122,6 +122,9 @@ class TestContracts:
 
         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')
 

backend/tests/routers/test_forms.py

@@ -5,6 +5,7 @@ from src.main import app
 from src.auth.auth import get_current_user
 import tests.factories.forms as form_factory
 from fastapi.exceptions import HTTPException
+import src.messages as messages
 
 class TestForms:
     def test_get_all(self, client, mocker, mock_session, mock_user):
@@ -123,6 +124,44 @@ class TestForms:
             mock_session,
             form_create
         )
+    
+    def test_create_one_referer_notfound(self, client, mocker, mock_session, mock_user):
+        form_body = form_factory.form_body_factory(name='test form create', referer_id=12312)
+        form_create = form_factory.form_create_factory(name='test form create', referer_id=12312)
+
+        mock = mocker.patch.object(
+            service,
+            'create_one',
+            side_effect=forms_exceptions.UserNotFoundError(messages.Messages.not_found('referer'))
+        )
+
+        response = client.post('/api/forms', json=form_body)
+        response_data = response.json()
+
+        assert response.status_code == 404
+        mock.assert_called_once_with(
+            mock_session,
+            form_create
+        )
+
+    def test_create_one_productor_notfound(self, client, mocker, mock_session, mock_user):
+        form_body = form_factory.form_body_factory(name='test form create', productor_id=1231)
+        form_create = form_factory.form_create_factory(name='test form create', productor_id=1231)
+
+        mock = mocker.patch.object(
+            service,
+            'create_one',
+            side_effect=forms_exceptions.ProductorNotFoundError(messages.Messages.not_found('productor'))
+        )
+
+        response = client.post('/api/forms', json=form_body)
+        response_data = response.json()
+
+        assert response.status_code == 404
+        mock.assert_called_once_with(
+            mock_session,
+            form_create
+        )
 
     def test_create_one_unauthorized(self, client, mocker, mock_session, mock_user):
         def unauthorized():
@@ -164,12 +203,51 @@ class TestForms:
     def test_update_one_notfound(self, client, mocker, mock_session, mock_user):
         form_body = form_factory.form_body_factory(name='test form update')
         form_update = form_factory.form_update_factory(name='test form update')
-        form_result = None
 
         mock = mocker.patch.object(
             service,
             'update_one',
-            side_effect=forms_exceptions.FormNotFoundError('Form 1 not found')
+            side_effect=forms_exceptions.FormNotFoundError(messages.Messages.not_found('form'))
+        )
+
+        response = client.put('/api/forms/2', json=form_body)
+        response_data = response.json()
+
+        assert response.status_code == 404
+        mock.assert_called_once_with(
+            mock_session,
+            2,
+            form_update
+        )
+    
+    def test_update_one_referer_notfound(self, client, mocker, mock_session, mock_user):
+        form_body = form_factory.form_body_factory(name='test form update')
+        form_update = form_factory.form_update_factory(name='test form update')
+
+        mock = mocker.patch.object(
+            service,
+            'update_one',
+            side_effect=forms_exceptions.UserNotFoundError(messages.Messages.not_found('referer'))
+        )
+
+        response = client.put('/api/forms/2', json=form_body)
+        response_data = response.json()
+
+        assert response.status_code == 404
+        mock.assert_called_once_with(
+            mock_session,
+            2,
+            form_update
+        )
+
+    def test_update_one_productor_notfound(self, client, mocker, mock_session, mock_user):
+        form_body = form_factory.form_body_factory(name='test form update')
+        form_update = form_factory.form_update_factory(name='test form update')
+
+        mock = mocker.patch.object(
+            service,
+            'update_one',
+            side_effect=forms_exceptions.ProductorNotFoundError(messages.Messages.not_found('productor'))
         )
 
         response = client.put('/api/forms/2', json=form_body)
@@ -222,7 +300,7 @@ class TestForms:
         mock = mocker.patch.object(
             service,
             'delete_one',
-            side_effect=forms_exceptions.FormNotFoundError('Form 2 not found')
+            side_effect=forms_exceptions.FormNotFoundError(messages.Messages.not_found('form'))
         )
 
         response = client.delete('/api/forms/2')

backend/tests/routers/test_productors.py

@@ -1,11 +1,14 @@
-import src.productors.service as service
-import src.models as models
+from fastapi.exceptions import HTTPException
+
 from src.main import app
+import src.models as models
+import src.messages as messages
 from src.auth.auth import get_current_user
-import tests.factories.productors as productor_factory
+
+import src.productors.service as service
 import src.productors.exceptions as exceptions
 
-from fastapi.exceptions import HTTPException
+import tests.factories.productors as productor_factory
 
 class TestProductors:
     def test_get_all(self, client, mocker, mock_session, mock_user):
@@ -181,7 +184,7 @@ class TestProductors:
         mock = mocker.patch.object(
             service,
             'update_one',
-            side_effect=exceptions.ProductorNotFoundError('Productor 1 not found')
+            side_effect=exceptions.ProductorNotFoundError(messages.Messages.not_found('productor'))
         )
 
         response = client.put('/api/productors/2', json=productor_body)
@@ -234,7 +237,7 @@ class TestProductors:
         mock = mocker.patch.object(
             service,
             'delete_one',
-            side_effect=exceptions.ProductorNotFoundError('Productor 1 not found')
+            side_effect=exceptions.ProductorNotFoundError(messages.Messages.not_found('productor'))
         )
 
         response = client.delete('/api/productors/2')

backend/tests/routers/test_shipments.py

@@ -1,6 +1,8 @@
 import src.shipments.service as service
 import src.models as models
 from src.main import app
+import src.messages as messages
+import src.shipments.exceptions as exceptions
 from src.auth.auth import get_current_user
 import tests.factories.shipments as shipment_factory
 
@@ -177,12 +179,11 @@ class TestShipments:
     def test_update_one_notfound(self, client, mocker, mock_session, mock_user):
         shipment_body = shipment_factory.shipment_body_factory(name='test shipment update')
         shipment_update = shipment_factory.shipment_update_factory(name='test shipment update')
-        shipment_result = None
 
         mock = mocker.patch.object(
             service,
             'update_one',
-            return_value=shipment_result
+            side_effect=exceptions.ShipmentNotFoundError(messages.Messages.not_found('shipment'))
         )
 
         response = client.put('/api/shipments/2', json=shipment_body)
@@ -235,7 +236,7 @@ class TestShipments:
         mock = mocker.patch.object(
             service,
             'delete_one',
-            return_value=shipment_result
+            side_effect=exceptions.ShipmentNotFoundError(messages.Messages.not_found('shipment'))
         )
 
         response = client.delete('/api/shipments/2')

backend/tests/routers/test_users.py

@@ -3,6 +3,7 @@ import src.models as models
 from src.main import app
 from src.auth.auth import get_current_user
 import tests.factories.users as user_factory
+import src.users.exceptions as exceptions
 
 from fastapi.exceptions import HTTPException
 
@@ -178,7 +179,7 @@ class TestUsers:
         mock = mocker.patch.object(
             service,
             'update_one',
-            return_value=user_result
+            side_effect=exceptions.UserNotFoundError('User 2 not found')
         )
 
         response = client.put('/api/users/2', json=user_body)
@@ -231,7 +232,7 @@ class TestUsers:
         mock = mocker.patch.object(
             service,
             'delete_one',
-            return_value=user_result
+            side_effect=exceptions.UserNotFoundError('User 2 not found')
         )
 
         response = client.delete('/api/users/2')

backend/tests/services/test_shipments_service.py

@@ -0,0 +1,143 @@
+import pytest
+import datetime
+from sqlmodel import Session
+
+import src.models as models
+import src.shipments.service as shipments_service
+import src.shipments.exceptions as shipments_exceptions
+import tests.factories.shipments as shipments_factory
+
+class TestShipmentsService:
+    def test_get_all_shipments(
+        self, 
+        session: Session, 
+        shipments: list[models.ShipmentPublic],
+        user: models.UserPublic,
+    ):
+        result = shipments_service.get_all(session, user, [], [], [])
+
+        assert len(result) == 2
+        assert result == shipments
+
+    def test_get_all_shipments_filter_names(
+        self, 
+        session: Session, 
+        shipments: list[models.ShipmentPublic],
+        user: models.UserPublic,
+    ):
+        result = shipments_service.get_all(session, user, ['test shipment 1'], [], [])
+
+        assert len(result) == 1
+        assert result == [shipments[0]]
+
+    def test_get_all_shipments_filter_dates(
+        self, 
+        session: Session, 
+        shipments: list[models.ShipmentPublic],
+        user: models.UserPublic,
+    ):
+        result = shipments_service.get_all(session, user, [], ['2025-10-10'], [])
+
+        assert len(result) == 1
+    
+    def test_get_all_shipments_filter_forms(
+        self, 
+        session: Session, 
+        shipments: list[models.ShipmentPublic],
+        forms: list[models.FormPublic],
+        user: models.UserPublic,
+    ):
+        result = shipments_service.get_all(session, user, [], [], [forms[0].name])
+
+        assert len(result) == 2
+
+    def test_get_all_shipments_all_filters(
+        self, 
+        session: Session, 
+        shipments: list[models.ShipmentPublic],
+        forms: list[models.FormPublic],
+        user: models.UserPublic,
+    ):
+        result = shipments_service.get_all(session, user, ['test shipment 1'], ['2025-10-10'], [forms[0].name])
+
+        assert len(result) == 1
+
+    def test_get_one_shipment(self, session: Session, shipments: list[models.ShipmentPublic]):
+        result = shipments_service.get_one(session, shipments[0].id)
+
+        assert result == shipments[0]
+
+    def test_get_one_shipment_notfound(self, session: Session):
+        result = shipments_service.get_one(session, 122)
+
+        assert result == None
+    
+    def test_create_shipment(
+        self, 
+        session: Session,
+    ):
+        shipment_create = shipments_factory.shipment_create_factory(
+            name='new test shipment',
+            date='2025-10-10',
+        )
+        result = shipments_service.create_one(session, shipment_create)
+
+        assert result.id is not None
+        assert result.name == "new test shipment"
+    
+    def test_create_shipment_invalidinput(
+        self, 
+        session: Session, 
+    ):
+        shipment_create = None
+        with pytest.raises(shipments_exceptions.ShipmentCreateError):
+            result = shipments_service.create_one(session, shipment_create)
+
+    def test_update_shipment(
+        self, 
+        session: Session,
+        shipments: list[models.ShipmentPublic]
+    ):
+        shipment_update = shipments_factory.shipment_update_factory(
+            name='updated shipment 1',
+            date='2025-12-10',
+        )
+        shipment_id = shipments[0].id
+        result = shipments_service.update_one(session, shipment_id, shipment_update)
+
+        assert result.id == shipment_id
+        assert result.name == 'updated shipment 1'
+        assert result.date == datetime.date(2025, 12, 10)
+    
+    def test_update_shipment_notfound(
+        self, 
+        session: Session,
+    ):
+        shipment_update = shipments_factory.shipment_update_factory(
+            name='updated shipment 1',
+            date=datetime.date(2025, 10, 10),
+        )
+        shipment_id = 123
+        with pytest.raises(shipments_exceptions.ShipmentNotFoundError):
+            result = shipments_service.update_one(session, shipment_id, shipment_update)
+    
+    def test_delete_shipment(
+        self, 
+        session: Session, 
+        shipments: list[models.ShipmentPublic]
+    ):
+        shipment_id = shipments[0].id
+        result = shipments_service.delete_one(session, shipment_id)
+
+        check = shipments_service.get_one(session, shipment_id)
+        assert check == None
+    
+    def test_delete_shipment_notfound(
+        self, 
+        session: Session, 
+        shipments: list[models.ShipmentPublic]
+    ):
+        shipment_id = 123
+        with pytest.raises(shipments_exceptions.ShipmentNotFoundError):
+            result = shipments_service.delete_one(session, shipment_id)
+

backend/tests/services/test_users_service.py

@@ -0,0 +1,115 @@
+import pytest
+from sqlmodel import Session
+
+import src.models as models
+import src.users.service as users_service
+import src.users.exceptions as users_exceptions
+import tests.factories.users as users_factory
+
+class TestUsersService:
+    def test_get_all_users(self, session: Session, users: list[models.UserPublic]):
+        result = users_service.get_all(session, [], [])
+
+        assert len(result) == 3
+        assert result == users
+
+    def test_get_all_users_filter_names(self, session: Session, users: list[models.UserPublic]):
+        result = users_service.get_all(session, ['test user 1 (admin)'], [])
+
+        assert len(result) == 1
+        assert result == [users[0]]
+
+    def test_get_all_users_filter_emails(self, session: Session, users: list[models.UserPublic]):
+        result = users_service.get_all(session, [], ['test1@test.com'])
+
+        assert len(result) == 1
+
+    def test_get_all_users_all_filters(self, session: Session, users: list[models.UserPublic]):
+        result = users_service.get_all(session, ['test user 1 (admin)'], ['test1@test.com'])
+
+        assert len(result) == 1
+
+    def test_get_one_user(self, session: Session, users: list[models.UserPublic]):
+        result = users_service.get_one(session, users[0].id)
+
+        assert result == users[0]
+
+    def test_get_one_user_notfound(self, session: Session):
+        result = users_service.get_one(session, 122)
+
+        assert result == None
+    
+    def test_create_user(
+        self, 
+        session: Session,
+    ):
+        user_create = users_factory.user_create_factory(
+            name="new test user",
+            email='test@test.fr',
+            role_names=['test role']
+        )
+        result = users_service.create_one(session, user_create)
+
+        assert result.id is not None
+        assert result.name == "new test user"
+        assert result.email == "test@test.fr"
+        assert len(result.roles) == 1
+    
+    def test_create_user_invalidinput(
+        self, 
+        session: Session, 
+    ):
+        user_create = None
+        with pytest.raises(users_exceptions.UserCreateError):
+            result = users_service.create_one(session, user_create)
+
+    def test_update_user(
+        self, 
+        session: Session,
+        users: list[models.UserPublic]
+    ):
+        user_update = users_factory.user_update_factory(
+            name="updated test user",
+            email='test@testttt.fr',
+            role_names=['test role']
+        )
+        user_id = users[0].id
+        result = users_service.update_one(session, user_id, user_update)
+
+        assert result.id == user_id
+        assert result.name == 'updated test user'
+        assert result.email == 'test@testttt.fr'
+    
+    def test_update_user_notfound(
+        self, 
+        session: Session,
+    ):
+        user_update = users_factory.user_update_factory(
+            name="updated test user",
+            email='test@testttt.fr',
+            role_names=['test role']
+        )
+        user_id = 123
+        with pytest.raises(users_exceptions.UserNotFoundError):
+            result = users_service.update_one(session, user_id, user_update)
+    
+    def test_delete_user(
+        self, 
+        session: Session, 
+        users: list[models.UserPublic]
+    ):
+        user_id = users[0].id
+        result = users_service.delete_one(session, user_id)
+
+        check = users_service.get_one(session, user_id)
+        assert check == None
+    
+    def test_delete_user_notfound(
+        self, 
+        session: Session, 
+        users: list[models.UserPublic]
+    ):
+        user_id = 123
+        with pytest.raises(users_exceptions.UserNotFoundError):
+            result = users_service.delete_one(session, user_id)
+