no need for app context as already pushed with client in setup fixture

Author: piyush-jaiswal

tests/test_auth.py

@@ -16,22 +16,19 @@ class TestAuth:
     @pytest.fixture(autouse=True)
     def setup(self, client):
         self.client = client
-        with client.application.app_context():
-            assert User.query.count() == 0
+        assert User.query.count() == 0
 
     def _verify_user_in_db(self, email, should_exist=True):
-        with self.client.application.app_context():
-            user = User.get(email=email)
-            if should_exist:
-                assert user is not None
-                assert user.email == email
-                return user
-            else:
-                assert user is None
+        user = User.get(email=email)
+        if should_exist:
+            assert user is not None
+            assert user.email == email
+            return user
+        else:
+            assert user is None
 
     def _count_users(self):
-        with self.client.application.app_context():
-            return User.query.count()
+        return User.query.count()
 
     def _test_invalid_request_data(self, endpoint, expected_status=422):
         response = self.client.post(endpoint, json={})
@@ -47,9 +44,7 @@ def _test_invalid_request_data(self, endpoint, expected_status=422):
         assert response.status_code == expected_status
 
     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)
+        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}"

tests/test_category.py

@@ -13,22 +13,19 @@ class TestCategory:
     @pytest.fixture(autouse=True)
     def setup(self, client):
         self.client = client
-        with client.application.app_context():
-            assert Category.query.count() == 0
+        assert Category.query.count() == 0
 
     def _count_categories(self):
-        with self.client.application.app_context():
-            return Category.query.count()
+        return Category.query.count()
 
     def _verify_category_in_db(self, name, should_exist=True):
-        with self.client.application.app_context():
-            category = Category.query.filter_by(name=name).first()
-            if should_exist:
-                assert category is not None
-                assert category.name == name
-                return category
-            else:
-                assert category is None
+        category = Category.query.filter_by(name=name).first()
+        if should_exist:
+            assert category is not None
+            assert category.name == name
+            return category
+        else:
+            assert category is None
 
     def test_create_category(self, create_category):
         response = create_category(self.TEST_CATEGORY_NAME)

tests/test_product.py

@@ -14,22 +14,19 @@ class TestProduct:
     @pytest.fixture(autouse=True)
     def setup(self, client):
         self.client = client
-        with client.application.app_context():
-            assert Product.query.count() == 0
+        assert Product.query.count() == 0
 
     def _count_products(self):
-        with self.client.application.app_context():
-            return Product.query.count()
+        return Product.query.count()
 
     def _verify_product_in_db(self, name, should_exist=True):
-        with self.client.application.app_context():
-            product = Product.query.filter_by(name=name).first()
-            if should_exist:
-                assert product is not None
-                assert product.name == name
-                return product
-            else:
-                assert product is None
+        product = Product.query.filter_by(name=name).first()
+        if should_exist:
+            assert product is not None
+            assert product.name == name
+            return product
+        else:
+            assert product is None
 
     def test_create_product(self, create_product):
         response = create_product(self.TEST_PRODUCT_NAME, self.TEST_PRODUCT_DESC)

tests/test_relationships.py

@@ -10,40 +10,34 @@ class TestRelationships:
     @pytest.fixture(autouse=True)
     def setup(self, client):
         self.client = client
-        with client.application.app_context():
-            assert Category.query.count() == 0
-            assert Subcategory.query.count() == 0
-            assert Product.query.count() == 0
+        assert Category.query.count() == 0
+        assert Subcategory.query.count() == 0
+        assert Product.query.count() == 0
 
     def _category_subcategory_ids(self, category_id):
-        with self.client.application.app_context():
-            category = Category.query.get(category_id)
-            assert category is not None
-            return sorted([subcategory.id for subcategory in category.subcategories])
+        category = Category.query.get(category_id)
+        assert category is not None
+        return sorted([subcategory.id for subcategory in category.subcategories])
 
     def _subcategory_category_ids(self, subcategory_id):
-        with self.client.application.app_context():
-            subcategory = Subcategory.query.get(subcategory_id)
-            assert subcategory is not None
-            return sorted([category.id for category in subcategory.categories])
+        subcategory = Subcategory.query.get(subcategory_id)
+        assert subcategory is not None
+        return sorted([category.id for category in subcategory.categories])
 
     def _subcategory_product_ids(self, subcategory_id):
-        with self.client.application.app_context():
-            subcategory = Subcategory.query.get(subcategory_id)
-            assert subcategory is not None
-            return sorted([product.id for product in subcategory.products])
+        subcategory = Subcategory.query.get(subcategory_id)
+        assert subcategory is not None
+        return sorted([product.id for product in subcategory.products])
 
     def _product_subcategory_ids(self, product_id):
-        with self.client.application.app_context():
-            product = Product.query.get(product_id)
-            assert product is not None
-            return sorted([subcategory.id for subcategory in product.subcategories])
+        product = Product.query.get(product_id)
+        assert product is not None
+        return sorted([subcategory.id for subcategory in product.subcategories])
 
     def _category_product_ids_via_subcategories(self, category_id):
-        with self.client.application.app_context():
-            category = Category.query.get(category_id)
-            assert category is not None
-            return sorted({product.id for subcategory in category.subcategories for product in subcategory.products.all()})
+        category = Category.query.get(category_id)
+        assert category is not None
+        return sorted({product.id for subcategory in category.subcategories for product in subcategory.products.all()})
 
     def _assert_related_collection(self, resp, key, expected_ids=None, status_code=200):
         assert resp.status_code == status_code

tests/test_subcategory.py

@@ -13,22 +13,19 @@ class TestSubcategory:
     @pytest.fixture(autouse=True)
     def setup(self, client):
         self.client = client
-        with client.application.app_context():
-            assert Subcategory.query.count() == 0
+        assert Subcategory.query.count() == 0
 
     def _count_subcategories(self):
-        with self.client.application.app_context():
-            return Subcategory.query.count()
+        return Subcategory.query.count()
 
     def _verify_subcategory_in_db(self, name, should_exist=True):
-        with self.client.application.app_context():
-            subcategory = Subcategory.query.filter_by(name=name).first()
-            if should_exist:
-                assert subcategory is not None
-                assert subcategory.name == name
-                return subcategory
-            else:
-                assert subcategory is None
+        subcategory = Subcategory.query.filter_by(name=name).first()
+        if should_exist:
+            assert subcategory is not None
+            assert subcategory.name == name
+            return subcategory
+        else:
+            assert subcategory is None
 
     def test_create_subcategory(self, create_subcategory):
         response = create_subcategory(self.TEST_SUBCATEGORY_NAME)