Mc add endpoint tests

app.py

@@ -25,9 +25,7 @@
     api.add_resource(resource, endpoint, resource_class_kwargs=kwargs)
 
 
-def create_app() -> Flask:
-    psycopg2_connection = initialize_psycopg2_connection()
-
+def create_app(psycopg2_connection) -> Flask:
     app = Flask(__name__)
     api = Api(app)
     CORS(app)
@@ -57,5 +55,5 @@
 
 
 if __name__ == "__main__":
-    app = create_app()
+    app = create_app(initialize_psycopg2_connection())
     app.run(debug=True, host="0.0.0.0")

resources/PsycopgResource.py

@@ -48,15 +48,3 @@ def __init__(self, **kwargs):
         - kwargs (dict): Keyword arguments containing 'psycopg2_connection' for database connection.
         """
         self.psycopg2_connection = kwargs["psycopg2_connection"]
-
-    def get(self):
-        """
-        Base implementation of GET. Override in subclasses as needed.
-        """
-        raise NotImplementedError("This method should be overridden by subclasses")
-
-    def post(self):
-        """
-        Base implementation of POST. Override in subclasses as needed.
-        """
-        raise NotImplementedError("This method should be overridden by subclasses")

tests/resources/app_test.py

@@ -32,20 +32,9 @@
 
 
 @pytest.fixture()
-def test_app_with_mock():
+def test_app_with_mock(mocker):
     # Patch the initialize_psycopg2_connection function so it returns a MagicMock
-    with patch("app.initialize_psycopg2_connection") as mock_init:
-        mock_connection = MagicMock()
-        mock_init.return_value = mock_connection
-
-        app = create_app()
-        # If your app stores the connection in a global or app context,
-        # you can also directly assign the mock_connection there
-
-        # Provide access to the mock within the app for assertions in tests
-        app.mock_connection = mock_connection
-
-        yield app
+    yield create_app(mocker.MagicMock())
 
 
 @pytest.fixture()
@@ -171,8 +160,6 @@
         json_data = response.get_json()
         assert "api_key" in json_data
         assert response.status_code == 200
-        test_app_with_mock.mock_connection.cursor().execute.assert_called_once()
-        test_app_with_mock.mock_connection.commit.assert_called_once()
 
 
 # endregion

tests/test_endpoints.py

@@ -0,0 +1,113 @@
+"""
+This module tests the functionality of all endpoints, ensuring that, as designed, they call (or don't call)
+the appropriate methods in their supporting classes
+"""
+
+from collections import namedtuple
+from typing import Type, Any, List
+
+import pytest
+from unittest.mock import patch
+
+from flask.testing import FlaskClient
+from flask_restful import Resource
+
+from app import create_app
+from resources.Agencies import Agencies
+from resources.ApiKey import ApiKey
+from resources.Archives import Archives
+from resources.DataSources import (
+    DataSources,
+    DataSourcesMap,
+    DataSourcesNeedsIdentification,
+    DataSourceById,
+)
+from resources.Login import Login
+from resources.QuickSearch import QuickSearch
+from resources.RefreshSession import RefreshSession
+from resources.RequestResetPassword import RequestResetPassword
+from resources.ResetPassword import ResetPassword
+from resources.ResetTokenValidation import ResetTokenValidation
+from resources.SearchTokens import SearchTokens
+from resources.User import User
+
+
+# Define constants for HTTP methods
+GET = "get"
+POST = "post"
+PUT = "put"
+DELETE = "delete"
+
+
+@pytest.fixture
+def client(mocker) -> FlaskClient:
+    """
+    Create a client with a mocked database connection
+    :param mocker:
+    :return:
+    """
+    app = create_app(mocker.MagicMock())
+    with app.test_client() as client:
+        yield client
+
+
+def run_endpoint_tests(
+    client: FlaskClient, endpoint: str, class_type: Resource, allowed_methods: list[str]
+):
+    methods = [GET, POST, PUT, DELETE]
+    for method in methods:
+        if method in allowed_methods:
+            with patch.object(
+                class_type, method, return_value="Mocked response"
+            ) as mock_method:
+                response = getattr(client, method)(endpoint)
+                assert (
+                    response.status_code == 200
+                ), f"{method.upper()} {endpoint} failed with status code {response.status_code}, expected 200"
+                mock_method.assert_called_once(), f"{method.upper()} {endpoint} should have called the {method} method on {class_type.__name__}"
+        else:
+            response = getattr(client, method)(endpoint)
+            assert (
+                response.status_code == 405
+            ), f"{method.upper()} {endpoint} failed with status code {response.status_code}, expected 405"
+
+
+TestParameters = namedtuple("Resource", ["class_type", "endpoint", "allowed_methods"])
+test_parameters = [
+    TestParameters(User, "/user", [POST, PUT]),
+    TestParameters(Login, "/login", [POST]),
+    TestParameters(RefreshSession, "/refresh-session", [POST]),
+    TestParameters(ApiKey, "/api_key", [GET]),
+    TestParameters(RequestResetPassword, "/request-reset-password", [POST]),
+    TestParameters(ResetPassword, "/reset-password", [POST]),
+    TestParameters(ResetTokenValidation, "/reset-token-validation", [POST]),
+    TestParameters(QuickSearch, "/quick-search/<search>/<location>", [GET]),
+    TestParameters(Archives, "/archives", [GET, PUT]),
+    TestParameters(DataSources, "/data-sources", [GET, POST]),
+    TestParameters(DataSourcesMap, "/data-sources-map", [GET]),
+    TestParameters(
+        DataSourcesNeedsIdentification, "/data-sources-needs-identification", [GET]
+    ),
+    TestParameters(DataSourceById, "/data-sources-by-id/<data_source_id>", [GET, PUT]),
+    TestParameters(Agencies, "/agencies/<page>", [GET]),
+    TestParameters(SearchTokens, "/search-tokens", [GET]),
+]
+
+
+@pytest.mark.parametrize("test_parameter", test_parameters)
+def test_endpoints(client: FlaskClient, test_parameter) -> None:
+    """
+    Using the test_parameters list, this tests all endpoints to ensure that
+    only the appropriate methods can be called from the endpoints
+    :param client: the client fixture
+    :param class_type:
+    :param endpoint:
+    :param allowed_methods:
+    :return:
+    """
+    run_endpoint_tests(
+        client,
+        test_parameter.endpoint,
+        test_parameter.class_type,
+        test_parameter.allowed_methods,
+    )