speed up tests by by removing redundant logins

tests/conftest.py

@@ -42,11 +42,16 @@ def _login(email, password):
 @pytest.fixture
 def create_authenticated_headers(register_user, login_user):
     def _get_headers(email="[email protected]", password="testpassword"):
-        register_user(email, password)
-        resp = login_user(email, password)
-        tokens = resp.get_json()
-        return utils.get_auth_header(tokens["access_token"])
+        nonlocal headers
+        if not headers:
+            register_user(email, password)
+            resp = login_user(email, password)
+            tokens = resp.get_json()
+            headers = utils.get_auth_header(tokens["access_token"])
 
+        return headers
+
+    headers = None
     return _get_headers
 
 

tests/test_auth.py

@@ -1,10 +1,10 @@
 import math
 
 import pytest
+from flask_jwt_extended import decode_token
 
 from app.models import User
 from tests import utils
-from flask_jwt_extended import decode_token
 
 
 class TestAuth:
@@ -50,6 +50,7 @@ def _decode_token(self, token):
         # Needs Flask app context for secret/algorithms from current_app.config
         with self.client.application.app_context():
             return decode_token(token, allow_expired=False)
+
     def _assert_jwt_structure(self, token, expected_sub, expected_type, fresh=False):
         assert token.count(".") == 2, f"Token does not have three segments: {token}"
         payload = self._decode_token(token)

tests/test_category.py

@@ -39,12 +39,11 @@ def test_create_category(self, create_category):
         assert "id" in data
         self._verify_category_in_db(self.TEST_CATEGORY_NAME)
 
-    def test_create_category_duplicate_name(self, create_category, create_authenticated_headers):
-        headers = create_authenticated_headers()
-        create_category(self.TEST_CATEGORY_NAME, headers=headers)
+    def test_create_category_duplicate_name(self, create_category):
+        create_category(self.TEST_CATEGORY_NAME)
 
         with pytest.raises(IntegrityError) as ie:
-            create_category(self.TEST_CATEGORY_NAME, headers=headers)
+            create_category(self.TEST_CATEGORY_NAME)
 
         assert isinstance(ie.value.orig, sqlite3.IntegrityError)
         assert "UNIQUE constraint failed" in str(ie.value.orig)

tests/test_product.py

@@ -152,9 +152,8 @@ def test_create_product_token_error(self, get_headers, expected_code):
             (lambda self: None, "authorization_required")
         ]
     )
-    def test_update_product_token_error(self, get_headers, create_product, create_authenticated_headers, expected_code):
-        headers = create_authenticated_headers()
-        response = create_product("UpdateTokenError", "desc", headers=headers)
+    def test_update_product_token_error(self, get_headers, create_product, expected_code):
+        response = create_product("UpdateTokenError", "desc")
         data = response.get_json()
         p_id = data["id"]
 
@@ -177,9 +176,8 @@ def test_update_product_token_error(self, get_headers, create_product, create_au
             (lambda self: None, "authorization_required")
         ]
     )
-    def test_delete_product_token_error(self, get_headers, create_product, create_authenticated_headers, expected_code):
-        headers = create_authenticated_headers()
-        response = create_product("DeleteTokenError", "desc", headers=headers)
+    def test_delete_product_token_error(self, get_headers, create_product, expected_code):
+        response = create_product("DeleteTokenError", "desc")
         data = response.get_json()
         p_id = data["id"]
 

tests/test_relationships.py

@@ -100,10 +100,10 @@ def test_update_category_adds_subcategories(self, create_authenticated_headers,
         assert self._category_subcategory_ids(category["id"]) == sorted([subcategory1["id"], subcategory2["id"]])
 
     def test_update_category_adds_linked_subcategories(self, create_authenticated_headers, create_category, create_subcategory):
-        headers = create_authenticated_headers()
-        subcategory = create_subcategory("U_SC1", headers=headers).get_json()
-        category = create_category("U_Cat", subcategories=[subcategory["id"]], headers=headers).get_json()
+        subcategory = create_subcategory("U_SC1").get_json()
+        category = create_category("U_Cat", subcategories=[subcategory["id"]]).get_json()
 
+        headers = create_authenticated_headers()
         with pytest.raises(IntegrityError) as ie:
             self.client.put(f"/categories/{category['id']}", json={"subcategories": [subcategory["id"]]}, headers=headers)
 
@@ -112,13 +112,13 @@ def test_update_category_adds_linked_subcategories(self, create_authenticated_he
         assert self._category_subcategory_ids(category["id"]) == [subcategory["id"]]
 
     def test_update_subcategory_adds_categories_and_products(self, create_authenticated_headers, create_category, create_product, create_subcategory):
-        headers = create_authenticated_headers()
-        category1 = create_category("UC1", headers=headers).get_json()
-        category2 = create_category("UC2", headers=headers).get_json()
-        product1 = create_product("UP1", headers=headers).get_json()
-        product2 = create_product("UP2", headers=headers).get_json()
-        subcategory = create_subcategory("U_SC", headers=headers).get_json()
+        category1 = create_category("UC1").get_json()
+        category2 = create_category("UC2").get_json()
+        product1 = create_product("UP1").get_json()
+        product2 = create_product("UP2").get_json()
+        subcategory = create_subcategory("U_SC").get_json()
 
+        headers = create_authenticated_headers()
         update_response = self.client.put(
             f"/subcategories/{subcategory['id']}",
             json={"categories": [category1["id"], category2["id"]], "products": [product1["id"], product2["id"]]},
@@ -130,11 +130,11 @@ def test_update_subcategory_adds_categories_and_products(self, create_authentica
         assert self._subcategory_product_ids(subcategory["id"]) == sorted([product1["id"], product2["id"]])
 
     def test_update_subcategory_adds_linked_categories_and_products(self, create_authenticated_headers, create_category, create_product, create_subcategory):
-        headers = create_authenticated_headers()
-        category = create_category("UC1", headers=headers).get_json()
-        product = create_product("UP1", headers=headers).get_json()
-        subcategory = create_subcategory("U_SC", categories=[category["id"]], products=[product["id"]], headers=headers).get_json()
+        category = create_category("UC1").get_json()
+        product = create_product("UP1").get_json()
+        subcategory = create_subcategory("U_SC", categories=[category["id"]], products=[product["id"]]).get_json()
 
+        headers = create_authenticated_headers()
         with pytest.raises(IntegrityError) as ie_c:
             self.client.put(
                 f"/subcategories/{subcategory['id']}",
@@ -215,11 +215,10 @@ def test_get_subcategory_categories_empty(self, create_subcategory):
         resp = self.client.get(f"/subcategories/{subcategory['id']}/categories")
         self._assert_related_collection(resp, "categories")
 
-    def test_get_subcategory_categories_populated(self, create_category, create_subcategory, create_authenticated_headers):
-        headers = create_authenticated_headers()
-        category1 = create_category("C1", headers=headers).get_json()
-        category2 = create_category("C2", headers=headers).get_json()
-        subcategory = create_subcategory("SC_Cats", categories=[category1["id"], category2["id"]], headers=headers).get_json()
+    def test_get_subcategory_categories_populated(self, create_category, create_subcategory):
+        category1 = create_category("C1").get_json()
+        category2 = create_category("C2").get_json()
+        subcategory = create_subcategory("SC_Cats", categories=[category1["id"], category2["id"]]).get_json()
 
         resp = self.client.get(f"/subcategories/{subcategory['id']}/categories")
         self._assert_related_collection(resp, "categories", expected_ids=[category1["id"], category2["id"]])
@@ -229,13 +228,12 @@ def test_get_subcategory_products_empty(self, create_subcategory):
         resp = self.client.get(f"/subcategories/{subcategory['id']}/products")
         self._assert_related_collection(resp, "products")
 
-    def test_get_subcategory_products_populated_with_pagination(self, create_subcategory, create_product, create_authenticated_headers):
-        headers = create_authenticated_headers()
-        subcategory = create_subcategory("SC_Pag", headers=headers).get_json()
+    def test_get_subcategory_products_populated_with_pagination(self, create_subcategory, create_product):
+        subcategory = create_subcategory("SC_Pag").get_json()
 
         product_ids = set()
         for index in range(11):
-            product_resp = create_product(f"SP{index}", "desc", subcategories=[subcategory["id"]], headers=headers)
+            product_resp = create_product(f"SP{index}", "desc", subcategories=[subcategory["id"]])
             product_ids.add(product_resp.get_json().get("id"))
 
         page1 = self.client.get(f"/subcategories/{subcategory['id']}/products?page=1").get_json()

tests/test_subcategory.py

@@ -39,12 +39,11 @@ def test_create_subcategory(self, create_subcategory):
         assert "id" in data
         self._verify_subcategory_in_db(self.TEST_SUBCATEGORY_NAME)
 
-    def test_create_subcategory_duplicate_name(self, create_subcategory, create_authenticated_headers):
-        headers = create_authenticated_headers()
-        create_subcategory(self.TEST_SUBCATEGORY_NAME, headers=headers)
+    def test_create_subcategory_duplicate_name(self, create_subcategory):
+        create_subcategory(self.TEST_SUBCATEGORY_NAME)
 
         with pytest.raises(IntegrityError) as ie:
-            create_subcategory(self.TEST_SUBCATEGORY_NAME, headers=headers)
+            create_subcategory(self.TEST_SUBCATEGORY_NAME)
 
         assert isinstance(ie.value.orig, sqlite3.IntegrityError)
         assert "UNIQUE constraint failed" in str(ie.value.orig)
@@ -62,10 +61,9 @@ def test_get_subcategory_by_id(self, create_subcategory):
         assert data["name"] == "Laptops"
         assert data["id"] == sc_id
 
-    def test_get_all_subcategories(self, create_subcategory, create_authenticated_headers):
-        headers = create_authenticated_headers()
-        create_subcategory("A", headers=headers)
-        create_subcategory("B", headers=headers)
+    def test_get_all_subcategories(self, create_subcategory):
+        create_subcategory("A")
+        create_subcategory("B")
         resp = self.client.get("/subcategories")
 
         assert resp.status_code == 200
@@ -128,9 +126,8 @@ def test_create_subcategory_token_error(self, get_headers, expected_code):
             (lambda self: None, "authorization_required")
         ]
     )
-    def test_update_subcategory_token_error(self, get_headers, create_subcategory, create_authenticated_headers, expected_code):
-        headers = create_authenticated_headers()
-        response = create_subcategory("UpdateTokenError", headers=headers)
+    def test_update_subcategory_token_error(self, get_headers, create_subcategory, expected_code):
+        response = create_subcategory("UpdateTokenError")
         data = response.get_json()
         sc_id = data["id"]
 
@@ -153,9 +150,8 @@ def test_update_subcategory_token_error(self, get_headers, create_subcategory, c
             (lambda self: None, "authorization_required")
         ]
     )
-    def test_delete_subcategory_token_error(self, get_headers, create_subcategory, create_authenticated_headers, expected_code):
-        headers = create_authenticated_headers()
-        response = create_subcategory("DeleteTokenError", headers=headers)
+    def test_delete_subcategory_token_error(self, get_headers, create_subcategory, expected_code):
+        response = create_subcategory("DeleteTokenError")
         data = response.get_json()
         sc_id = data["id"]