fix test format

2026-03-02 16:33:52 +01:00
parent 5dd9e19877
commit 0e48d1bbaa
20 changed files with 751 additions and 436 deletions
--- a/backend/tests/services/test_forms_service.py
+++ b/backend/tests/services/test_forms_service.py
@@ -6,30 +6,37 @@ import src.forms.service as forms_service
 import src.forms.exceptions as forms_exceptions
 import tests.factories.forms as forms_factory

+
 class TestFormsService:
-    def test_get_all_forms(self, session: Session, forms: list[models.FormPublic]):
+    def test_get_all_forms(self, session: Session,
+                           forms: list[models.FormPublic]):
        result = forms_service.get_all(session, [], [], False)

        assert len(result) == 2
        assert result == forms

-    def test_get_all_forms_filter_productors(self, session: Session, forms: list[models.FormPublic]):
+    def test_get_all_forms_filter_productors(
+            self, session: Session, forms: list[models.FormPublic]):
        result = forms_service.get_all(session, [], ['test productor'], False)

        assert len(result) == 2
        assert result == forms

-    def test_get_all_forms_filter_season(self, session: Session, forms: list[models.FormPublic]):
+    def test_get_all_forms_filter_season(
+            self, session: Session, forms: list[models.FormPublic]):
        result = forms_service.get_all(session, ['test season 1'], [], False)

        assert len(result) == 1

-    def test_get_all_forms_all_filters(self, session: Session, forms: list[models.FormPublic]):
-        result = forms_service.get_all(session, ['test season 1'], ['test productor'], True)
+    def test_get_all_forms_all_filters(
+            self, session: Session, forms: list[models.FormPublic]):
+        result = forms_service.get_all(
+            session, ['test season 1'], ['test productor'], True)

        assert result == forms

-    def test_get_one_form(self, session: Session, forms: list[models.FormPublic]):
+    def test_get_one_form(self, session: Session,
+                          forms: list[models.FormPublic]):
        result = forms_service.get_one(session, forms[0].id)

        assert result == forms[0]
@@ -37,10 +44,10 @@ class TestFormsService:
    def test_get_one_form_notfound(self, session: Session):
        result = forms_service.get_one(session, 122)

-        assert result == None
-    
+        assert result is None
+
    def test_create_form(
-        self, 
+        self,
        session: Session,
        productor: models.ProductorPublic,
        referer: models.ProductorPublic
@@ -56,10 +63,10 @@ class TestFormsService:
        assert result.id is not None
        assert result.name == "new test form"
        assert result.productor.name == "test productor"
-    
+
    def test_create_form_invalidinput(
-        self, 
-        session: Session, 
+        self,
+        session: Session,
        productor: models.Productor
    ):
        form_create = None
@@ -69,17 +76,16 @@ class TestFormsService:
        form_create = forms_factory.form_create_factory(productor_id=123)
        with pytest.raises(forms_exceptions.ProductorNotFoundError):
            result = forms_service.create_one(session, form_create)
-    
+
        form_create = forms_factory.form_create_factory(
-            productor_id=productor.id, 
+            productor_id=productor.id,
            referer_id=123
        )
        with pytest.raises(forms_exceptions.UserNotFoundError):
            result = forms_service.create_one(session, form_create)

-
    def test_update_form(
-        self, 
+        self,
        session: Session,
        productor: models.ProductorPublic,
        referer: models.ProductorPublic,
@@ -97,9 +103,9 @@ class TestFormsService:
        assert result.id == form_id
        assert result.name == 'updated test form'
        assert result.season == 'updated test season'
-    
+
    def test_update_form_notfound(
-        self, 
+        self,
        session: Session,
        productor: models.ProductorPublic,
        referer: models.ProductorPublic,
@@ -113,42 +119,41 @@ class TestFormsService:
        form_id = 123
        with pytest.raises(forms_exceptions.FormNotFoundError):
            result = forms_service.update_one(session, form_id, form_update)
-    
+
    def test_update_form_invalidinput(
-        self, 
-        session: Session, 
-        productor: models.ProductorPublic, 
+        self,
+        session: Session,
+        productor: models.ProductorPublic,
        forms: list[models.FormPublic]
    ):
        form_id = forms[0].id
        form_update = forms_factory.form_update_factory(productor_id=123)
        with pytest.raises(forms_exceptions.ProductorNotFoundError):
            result = forms_service.update_one(session, form_id, form_update)
-    
+
        form_update = forms_factory.form_update_factory(
-            productor_id=productor.id, 
+            productor_id=productor.id,
            referer_id=123
        )
        with pytest.raises(forms_exceptions.UserNotFoundError):
            result = forms_service.update_one(session, form_id, form_update)

    def test_delete_form(
-        self, 
-        session: Session, 
+        self,
+        session: Session,
        forms: list[models.FormPublic]
    ):
        form_id = forms[0].id
        result = forms_service.delete_one(session, form_id)

        check = forms_service.get_one(session, form_id)
-        assert check == None
-    
+        assert check is None
+
    def test_delete_form_notfound(
-        self, 
-        session: Session, 
+        self,
+        session: Session,
        forms: list[models.FormPublic]
    ):
        form_id = 123
        with pytest.raises(forms_exceptions.FormNotFoundError):
            result = forms_service.delete_one(session, form_id)
-
--- a/backend/tests/services/test_productors_service.py
+++ b/backend/tests/services/test_productors_service.py
@@ -6,10 +6,11 @@ import src.productors.service as productors_service
 import src.productors.exceptions as productors_exceptions
 import tests.factories.productors as productors_factory

+
 class TestProductorsService:
    def test_get_all_productors(
-        self, 
-        session: Session, 
+        self,
+        session: Session,
        productors: list[models.ProductorPublic],
        user: models.UserPublic
    ):
@@ -19,51 +20,53 @@ class TestProductorsService:
        assert result == [productors[0]]

    def test_get_all_productors_filter_names(
-        self, 
-        session: Session, 
+        self,
+        session: Session,
        productors: list[models.ProductorPublic],
        user: models.UserPublic
    ):
        result = productors_service.get_all(
-            session, 
-            user, 
-            ['test productor 1'], 
+            session,
+            user,
+            ['test productor 1'],
            []
        )

        assert len(result) == 1
-    
+
    def test_get_all_productors_filter_types(
-        self, 
-        session: Session, 
+        self,
+        session: Session,
        productors: list[models.ProductorPublic],
        user: models.UserPublic
    ):
        result = productors_service.get_all(
-            session, 
-            user, 
-            [], 
-            ['Légumineuses'], 
+            session,
+            user,
+            [],
+            ['Légumineuses'],
        )

        assert len(result) == 1

    def test_get_all_productors_all_filters(
-        self, 
-        session: Session, 
+        self,
+        session: Session,
        productors: list[models.ProductorPublic],
        user: models.UserPublic
    ):
        result = productors_service.get_all(
-            session, 
-            user, 
-            ['test productor 1'], 
-            ['Légumineuses'], 
+            session,
+            user,
+            ['test productor 1'],
+            ['Légumineuses'],
        )

        assert len(result) == 1

-    def test_get_one_productor(self, session: Session, productors: list[models.ProductorPublic]):
+    def test_get_one_productor(self,
+                               session: Session,
+                               productors: list[models.ProductorPublic]):
        result = productors_service.get_one(session, productors[0].id)

        assert result == productors[0]
@@ -71,10 +74,10 @@ class TestProductorsService:
    def test_get_one_productor_notfound(self, session: Session):
        result = productors_service.get_one(session, 122)

-        assert result == None
-    
+        assert result is None
+
    def test_create_productor(
-        self, 
+        self,
        session: Session,
        referer: models.ProductorPublic
    ):
@@ -85,17 +88,17 @@ class TestProductorsService:

        assert result.id is not None
        assert result.name == "new test productor"
-    
+
    def test_create_productor_invalidinput(
-        self, 
-        session: Session, 
+        self,
+        session: Session,
    ):
        productor_create = None
        with pytest.raises(productors_exceptions.ProductorCreateError):
            result = productors_service.create_one(session, productor_create)

    def test_update_productor(
-        self, 
+        self,
        session: Session,
        referer: models.ProductorPublic,
        productors: list[models.ProductorPublic]
@@ -104,13 +107,14 @@ class TestProductorsService:
            name='updated test productor',
        )
        productor_id = productors[0].id
-        result = productors_service.update_one(session, productor_id, productor_update)
+        result = productors_service.update_one(
+            session, productor_id, productor_update)

        assert result.id == productor_id
        assert result.name == 'updated test productor'
-    
+
    def test_update_productor_notfound(
-        self, 
+        self,
        session: Session,
        referer: models.ProductorPublic,
    ):
@@ -119,25 +123,25 @@ class TestProductorsService:
        )
        productor_id = 123
        with pytest.raises(productors_exceptions.ProductorNotFoundError):
-            result = productors_service.update_one(session, productor_id, productor_update)
-    
+            result = productors_service.update_one(
+                session, productor_id, productor_update)
+
    def test_delete_productor(
-        self, 
-        session: Session, 
+        self,
+        session: Session,
        productors: list[models.ProductorPublic]
    ):
        productor_id = productors[0].id
        result = productors_service.delete_one(session, productor_id)

        check = productors_service.get_one(session, productor_id)
-        assert check == None
-    
+        assert check is None
+
    def test_delete_productor_notfound(
-        self, 
-        session: Session, 
+        self,
+        session: Session,
        productors: list[models.ProductorPublic]
    ):
        productor_id = 123
        with pytest.raises(productors_exceptions.ProductorNotFoundError):
            result = productors_service.delete_one(session, productor_id)
-
--- a/backend/tests/services/test_products_service.py
+++ b/backend/tests/services/test_products_service.py
@@ -6,10 +6,11 @@ import src.products.service as products_service
 import src.products.exceptions as products_exceptions
 import tests.factories.products as products_factory

+
 class TestProductsService:
    def test_get_all_products(
-        self, 
-        session: Session, 
+        self,
+        session: Session,
        products: list[models.ProductPublic],
        user: models.UserPublic
    ):
@@ -19,16 +20,16 @@ class TestProductsService:
        assert result == products

    def test_get_all_products_filter_productors(
-        self, 
-        session: Session, 
+        self,
+        session: Session,
        products: list[models.ProductPublic],
        user: models.UserPublic
    ):
        result = products_service.get_all(
-            session, 
-            user, 
-            [], 
-            ['test productor'], 
+            session,
+            user,
+            [],
+            ['test productor'],
            []
        )

@@ -36,54 +37,55 @@ class TestProductsService:
        assert result == products

    def test_get_all_products_filter_names(
-        self, 
-        session: Session, 
+        self,
+        session: Session,
        products: list[models.ProductPublic],
        user: models.UserPublic
    ):
        result = products_service.get_all(
-            session, 
-            user, 
-            ['product 1 occasionnal'], 
-            [], 
+            session,
+            user,
+            ['product 1 occasionnal'],
+            [],
            []
        )

        assert len(result) == 1
-    
+
    def test_get_all_products_filter_types(
-        self, 
-        session: Session, 
+        self,
+        session: Session,
        products: list[models.ProductPublic],
        user: models.UserPublic
    ):
        result = products_service.get_all(
-            session, 
-            user, 
-            [], 
-            [], 
+            session,
+            user,
+            [],
+            [],
            ['1']
        )

        assert len(result) == 1

    def test_get_all_products_all_filters(
-        self, 
-        session: Session, 
+        self,
+        session: Session,
        products: list[models.ProductPublic],
        user: models.UserPublic
    ):
        result = products_service.get_all(
-            session, 
-            user, 
-            ['product 1 occasionnal'], 
-            ['test productor'], 
+            session,
+            user,
+            ['product 1 occasionnal'],
+            ['test productor'],
            ['1']
        )

        assert len(result) == 1

-    def test_get_one_product(self, session: Session, products: list[models.ProductPublic]):
+    def test_get_one_product(self, session: Session,
+                             products: list[models.ProductPublic]):
        result = products_service.get_one(session, products[0].id)

        assert result == products[0]
@@ -91,10 +93,10 @@ class TestProductsService:
    def test_get_one_product_notfound(self, session: Session):
        result = products_service.get_one(session, 122)

-        assert result == None
-    
+        assert result is None
+
    def test_create_product(
-        self, 
+        self,
        session: Session,
        productor: models.ProductorPublic,
        referer: models.ProductorPublic
@@ -108,22 +110,23 @@ class TestProductsService:
        assert result.id is not None
        assert result.name == "new test product"
        assert result.productor.name == "test productor"
-    
+
    def test_create_product_invalidinput(
-        self, 
-        session: Session, 
+        self,
+        session: Session,
        productor: models.Productor
    ):
        product_create = None
        with pytest.raises(products_exceptions.ProductCreateError):
            result = products_service.create_one(session, product_create)

-        product_create = products_factory.product_create_factory(productor_id=123)
+        product_create = products_factory.product_create_factory(
+            productor_id=123)
        with pytest.raises(products_exceptions.ProductorNotFoundError):
            result = products_service.create_one(session, product_create)

    def test_update_product(
-        self, 
+        self,
        session: Session,
        productor: models.ProductorPublic,
        referer: models.ProductorPublic,
@@ -134,13 +137,14 @@ class TestProductsService:
            productor_id=productor.id,
        )
        product_id = products[0].id
-        result = products_service.update_one(session, product_id, product_update)
+        result = products_service.update_one(
+            session, product_id, product_update)

        assert result.id == product_id
        assert result.name == 'updated test product'
-    
+
    def test_update_product_notfound(
-        self, 
+        self,
        session: Session,
        productor: models.ProductorPublic,
        referer: models.ProductorPublic,
@@ -151,41 +155,43 @@ class TestProductsService:
        )
        product_id = 123
        with pytest.raises(products_exceptions.ProductNotFoundError):
-            result = products_service.update_one(session, product_id, product_update)
-    
+            result = products_service.update_one(
+                session, product_id, product_update)
+
    def test_update_product_invalidinput(
-        self, 
-        session: Session, 
-        productor: models.ProductorPublic, 
+        self,
+        session: Session,
+        productor: models.ProductorPublic,
        products: list[models.ProductPublic]
    ):
        product_id = products[0].id
-        product_update = products_factory.product_update_factory(productor_id=123)
-        with pytest.raises(products_exceptions.ProductorNotFoundError):
-            result = products_service.update_one(session, product_id, product_update)
-    
        product_update = products_factory.product_update_factory(
-            productor_id=productor.id, 
+            productor_id=123)
+        with pytest.raises(products_exceptions.ProductorNotFoundError):
+            result = products_service.update_one(
+                session, product_id, product_update)
+
+        product_update = products_factory.product_update_factory(
+            productor_id=productor.id,
            referer_id=123
        )

    def test_delete_product(
-        self, 
-        session: Session, 
+        self,
+        session: Session,
        products: list[models.ProductPublic]
    ):
        product_id = products[0].id
        result = products_service.delete_one(session, product_id)

        check = products_service.get_one(session, product_id)
-        assert check == None
-    
+        assert check is None
+
    def test_delete_product_notfound(
-        self, 
-        session: Session, 
+        self,
+        session: Session,
        products: list[models.ProductPublic]
    ):
        product_id = 123
        with pytest.raises(products_exceptions.ProductNotFoundError):
            result = products_service.delete_one(session, product_id)
-
--- a/backend/tests/services/test_shipments_service.py
+++ b/backend/tests/services/test_shipments_service.py
@@ -7,10 +7,11 @@ 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, 
+        self,
+        session: Session,
        shipments: list[models.ShipmentPublic],
        user: models.UserPublic,
    ):
@@ -20,49 +21,54 @@ class TestShipmentsService:
        assert result == shipments

    def test_get_all_shipments_filter_names(
-        self, 
-        session: Session, 
+        self,
+        session: Session,
        shipments: list[models.ShipmentPublic],
        user: models.UserPublic,
    ):
-        result = shipments_service.get_all(session, user, ['test shipment 1'], [], [])
+        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, 
+        self,
+        session: Session,
        shipments: list[models.ShipmentPublic],
        user: models.UserPublic,
    ):
-        result = shipments_service.get_all(session, user, [], ['2025-10-10'], [])
+        result = shipments_service.get_all(
+            session, user, [], ['2025-10-10'], [])

        assert len(result) == 1
-    
+
    def test_get_all_shipments_filter_forms(
-        self, 
-        session: Session, 
+        self,
+        session: Session,
        shipments: list[models.ShipmentPublic],
        forms: list[models.FormPublic],
        user: models.UserPublic,
    ):
-        result = shipments_service.get_all(session, user, [], [], [forms[0].name])
+        result = shipments_service.get_all(
+            session, user, [], [], [forms[0].name])

        assert len(result) == 2

    def test_get_all_shipments_all_filters(
-        self, 
-        session: Session, 
+        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])
+        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]):
+    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]
@@ -70,10 +76,10 @@ class TestShipmentsService:
    def test_get_one_shipment_notfound(self, session: Session):
        result = shipments_service.get_one(session, 122)

-        assert result == None
-    
+        assert result is None
+
    def test_create_shipment(
-        self, 
+        self,
        session: Session,
    ):
        shipment_create = shipments_factory.shipment_create_factory(
@@ -84,17 +90,17 @@ class TestShipmentsService:

        assert result.id is not None
        assert result.name == "new test shipment"
-    
+
    def test_create_shipment_invalidinput(
-        self, 
-        session: Session, 
+        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, 
+        self,
        session: Session,
        shipments: list[models.ShipmentPublic]
    ):
@@ -103,14 +109,15 @@ class TestShipmentsService:
            date='2025-12-10',
        )
        shipment_id = shipments[0].id
-        result = shipments_service.update_one(session, shipment_id, shipment_update)
+        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, 
+        self,
        session: Session,
    ):
        shipment_update = shipments_factory.shipment_update_factory(
@@ -119,25 +126,25 @@ class TestShipmentsService:
        )
        shipment_id = 123
        with pytest.raises(shipments_exceptions.ShipmentNotFoundError):
-            result = shipments_service.update_one(session, shipment_id, shipment_update)
-    
+            result = shipments_service.update_one(
+                session, shipment_id, shipment_update)
+
    def test_delete_shipment(
-        self, 
-        session: Session, 
+        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
-    
+        assert check is None
+
    def test_delete_shipment_notfound(
-        self, 
-        session: Session, 
+        self,
+        session: Session,
        shipments: list[models.ShipmentPublic]
    ):
        shipment_id = 123
        with pytest.raises(shipments_exceptions.ShipmentNotFoundError):
            result = shipments_service.delete_one(session, shipment_id)
-
--- a/backend/tests/services/test_users_service.py
+++ b/backend/tests/services/test_users_service.py
@@ -6,30 +6,37 @@ 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]):
+    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]):
+    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]):
+    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'])
+    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]):
+    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]
@@ -37,10 +44,10 @@ class TestUsersService:
    def test_get_one_user_notfound(self, session: Session):
        result = users_service.get_one(session, 122)

-        assert result == None
-    
+        assert result is None
+
    def test_create_user(
-        self, 
+        self,
        session: Session,
    ):
        user_create = users_factory.user_create_factory(
@@ -54,17 +61,17 @@ class TestUsersService:
        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, 
+        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, 
+        self,
        session: Session,
        users: list[models.UserPublic]
    ):
@@ -79,9 +86,9 @@ class TestUsersService:
        assert result.id == user_id
        assert result.name == 'updated test user'
        assert result.email == 'test@testttt.fr'
-    
+
    def test_update_user_notfound(
-        self, 
+        self,
        session: Session,
    ):
        user_update = users_factory.user_update_factory(
@@ -92,24 +99,23 @@ class TestUsersService:
        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, 
+        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
-    
+        assert check is None
+
    def test_delete_user_notfound(
-        self, 
-        session: Session, 
+        self,
+        session: Session,
        users: list[models.UserPublic]
    ):
        user_id = 123
        with pytest.raises(users_exceptions.UserNotFoundError):
            result = users_service.delete_one(session, user_id)
-