Fixed tests, refactoring them so that independent tests run indep'ly

services/capability/test/test_capability_request_views.py

@@ -23,6 +23,7 @@ The logic can be found in `capability/views/capability_request.py`.
 
 import http
 
+import pytest
 from capability.views.capability_request import (
     create_capability_request,
     delete_capability_request,
@@ -210,9 +211,9 @@ def test_delete_capability_request(request_null_capability: DummyRequest):
     assert response.status_code == http.HTTPStatus.OK
 
 
-def test_delete_capability_request_error(request_null_capability: DummyRequest):
+def test_delete_capability_request_error_undeletable_request(request_null_capability: DummyRequest):
     """
-    Tests that the delete_capability_request view correctly executes its logic
+    Tests that the delete_capability_request view correctly executes its logic for a request that can't be deleted
 
     :param request_null_capability: Dummy Pyramid request object set up with mocked DB access
     supporting the null capability
@@ -224,11 +225,20 @@ def test_delete_capability_request_error(request_null_capability: DummyRequest):
     request_null_capability.matchdict["capability_name"] = "null"
 
     request_null_capability.capability_service.run_capability(capability_request)
-    response = delete_capability_request(request_null_capability)
-    assert response.status_code == http.HTTPStatus.BAD_REQUEST
-    assert isinstance(response, HTTPBadRequest)
+    with pytest.raises(HTTPBadRequest):
+        response = delete_capability_request(request_null_capability)
+        assert response.status_code == http.HTTPStatus.BAD_REQUEST
+        assert isinstance(response, HTTPBadRequest)
+
+
+def test_delete_capability_request_error_nonexistent_request(request_null_capability: DummyRequest):
+    """
+    Tests that the delete_capability_request view correctly executes its logic when a request does not exist
 
-    # Request does not exist
+    :param request_null_capability: Dummy Pyramid request object set up with mocked DB access
+    supporting the null capability
+    """
+    request_null_capability.matchdict["capability_name"] = "null"
     request_null_capability.matchdict["request_id"] = -1
     response = delete_capability_request(request_null_capability)
     assert response.status_code == http.HTTPStatus.PRECONDITION_FAILED

services/capability/test/test_capability_views.py

@@ -20,11 +20,13 @@ Tests that test the view functionality of our capability REST API.
 The logic can be found in `capability/views/capability.py`.
 """
 import http
+from typing import Optional
 
 import pytest
 from pyramid.config import Configurator
 from pyramid.httpexceptions import (
     HTTPBadRequest,
+    HTTPException,
     HTTPExpectationFailed,
     HTTPNotFound,
     HTTPPreconditionFailed,
@@ -182,7 +184,22 @@ def test_edit_capability(test_config: Configurator, request_null_capability: Dum
     assert response_jobs_only.status_code == http.HTTPStatus.OK
 
 
-def test_edit_capability_error(test_config: Configurator, request_null_capability: DummyRequest):
+@pytest.mark.parametrize(
+    ["capability_name", "max_jobs", "response_type", "is_raised"],
+    [
+        ("not_found", 3, HTTPPreconditionFailed, False),
+        ("null", None, HTTPBadRequest, False),
+        ("error", 3, HTTPExpectationFailed, True),
+    ],
+)
+def test_edit_capability_error(
+    test_config: Configurator,
+    request_null_capability: DummyRequest,
+    capability_name: str,
+    max_jobs: int | None,
+    response_type: HTTPException,
+    is_raised: bool,
+):
     """
     Tests that the edit_capability view correctly responds with exceptions
 
@@ -192,23 +209,20 @@ def test_edit_capability_error(test_config: Configurator, request_null_capabilit
     """
     from capability.views.capability import edit_capability
 
-    request_null_capability.matchdict["capability_name"] = "not_found"
-    request_null_capability.json_body = {"max_jobs": 3}
-    response_cap_not_exists = edit_capability(request_null_capability)
-    assert response_cap_not_exists.status_code == http.HTTPStatus.PRECONDITION_FAILED
-    assert type(response_cap_not_exists) is HTTPPreconditionFailed
-
-    request_null_capability.matchdict["capability_name"] = "null"
-    request_null_capability.json_body = {}
-    response_empty = edit_capability(request_null_capability)
-    assert response_empty.status_code == http.HTTPStatus.BAD_REQUEST
-    assert type(response_empty) is HTTPBadRequest
-
-    request_null_capability.matchdict["capability_name"] = "error"
-    request_null_capability.json_body = {"max_jobs": 3}
-    response_edit_failed = edit_capability(request_null_capability)
-    assert response_edit_failed.status_code == http.HTTPStatus.EXPECTATION_FAILED
-    assert type(response_edit_failed) is HTTPExpectationFailed
+    request_null_capability.matchdict["capability_name"] = capability_name
+    if max_jobs is not None:
+        request_null_capability.json_body = {"max_jobs": max_jobs}
+    else:
+        request_null_capability.json_body = {}
+    if is_raised:
+        with pytest.raises(response_type):
+            response = edit_capability(request_null_capability)
+            assert response.status_code == response_type.code
+            assert type(response) is response_type
+    else:
+        response = edit_capability(request_null_capability)
+        assert response.status_code == response_type.code
+        assert type(response) is response_type
 
 
 def test_enable_capability(test_config: Configurator, request_null_capability: DummyRequest):
@@ -226,7 +240,17 @@ def test_enable_capability(test_config: Configurator, request_null_capability: D
     assert response.status_code == http.HTTPStatus.OK
 
 
-def test_enable_capability_error(test_config: Configurator, request_null_capability: DummyRequest):
+@pytest.mark.parametrize(
+    ["capability_name", "response_type", "is_raised"],
+    [("does_not_exist", HTTPPreconditionFailed, False), ("error", HTTPExpectationFailed, True)],
+)
+def test_enable_capability_error(
+    test_config: Configurator,
+    request_null_capability: DummyRequest,
+    capability_name: str,
+    response_type: HTTPException,
+    is_raised: bool,
+):
     """
     Tests that enable_capability view properly responds with HTTP exceptions given bad input
 
@@ -236,14 +260,16 @@ def test_enable_capability_error(test_config: Configurator, request_null_capabil
     """
     from capability.views.capability import enable_capability
 
-    request_null_capability.matchdict["capability_name"] = "does_not_exist"
-    response_does_not_exist = enable_capability(request_null_capability)
-    assert response_does_not_exist.status_code == http.HTTPStatus.PRECONDITION_FAILED
-    assert type(response_does_not_exist) is HTTPPreconditionFailed
-    request_null_capability.matchdict["capability_name"] = "error"
-    response_enable_failed = enable_capability(request_null_capability)
-    assert response_enable_failed.status_code == http.HTTPStatus.EXPECTATION_FAILED
-    assert type(response_enable_failed) is HTTPExpectationFailed
+    request_null_capability.matchdict["capability_name"] = capability_name
+    if is_raised:
+        with pytest.raises(response_type):
+            response_enable_failed = enable_capability(request_null_capability)
+            assert response_enable_failed.status_code == response_type.code
+            assert type(response_enable_failed) is response_type
+    else:
+        response_enable_failed = enable_capability(request_null_capability)
+        assert response_enable_failed.status_code == response_type.code
+        assert type(response_enable_failed) is response_type
 
 
 def test_disable_capability(test_config: Configurator, request_null_capability: DummyRequest):
@@ -261,7 +287,17 @@ def test_disable_capability(test_config: Configurator, request_null_capability:
     assert response.status_code == http.HTTPStatus.OK
 
 
-def test_disable_capability_error(test_config: Configurator, request_null_capability: DummyRequest):
+@pytest.mark.parametrize(
+    ["capability_name", "response_type", "is_raised"],
+    [("does_not_exist", HTTPPreconditionFailed, False), ("error", HTTPExpectationFailed, True)],
+)
+def test_disable_capability_error(
+    test_config: Configurator,
+    request_null_capability: DummyRequest,
+    capability_name: str,
+    response_type: HTTPException,
+    is_raised: bool,
+):
     """
     Tests that disable_capability view properly responds with HTTP exceptions given bad input
 
@@ -271,11 +307,13 @@ def test_disable_capability_error(test_config: Configurator, request_null_capabi
     """
     from capability.views.capability import disable_capability
 
-    request_null_capability.matchdict["capability_name"] = "does_not_exist"
-    response_does_not_exist = disable_capability(request_null_capability)
-    assert response_does_not_exist.status_code == http.HTTPStatus.PRECONDITION_FAILED
-    assert type(response_does_not_exist) is HTTPPreconditionFailed
-    request_null_capability.matchdict["capability_name"] = "error"
-    response_disable_failed = disable_capability(request_null_capability)
-    assert response_disable_failed.status_code == http.HTTPStatus.EXPECTATION_FAILED
-    assert type(response_disable_failed) is HTTPExpectationFailed
+    request_null_capability.matchdict["capability_name"] = capability_name
+    if is_raised:
+        with pytest.raises(response_type):
+            response_enable_failed = disable_capability(request_null_capability)
+            assert response_enable_failed.status_code == response_type.code
+            assert type(response_enable_failed) is response_type
+    else:
+        response_enable_failed = disable_capability(request_null_capability)
+        assert response_enable_failed.status_code == response_type.code
+        assert type(response_enable_failed) is response_type