chore: rename check_config in testing_context

Author: azmeuk

tests/conftest.py

@@ -17,6 +17,6 @@ def scim_client(httpserver):
 
 
 @pytest.fixture
-def check_config(scim_client):
+def testing_context(scim_client):
     conf = CheckConfig()
     return CheckContext(scim_client, conf)

tests/test_discovery.py

@@ -6,7 +6,7 @@
 from scim2_tester.utils import Status
 
 
-def test_discovery_endpoint_methods_return_405(httpserver, check_config):
+def test_discovery_endpoint_methods_return_405(httpserver, testing_context):
     """Test that discovery endpoints return 405 for unsupported HTTP methods."""
     endpoint = "/ServiceProviderConfig"
 
@@ -16,7 +16,7 @@ def test_discovery_endpoint_methods_return_405(httpserver, check_config):
             "", status=405
         )
 
-    results = _test_discovery_endpoint_methods(check_config, endpoint)
+    results = _test_discovery_endpoint_methods(testing_context, endpoint)
 
     assert len(results) == 4
     assert all(result.status == Status.SUCCESS for result in results)
@@ -27,7 +27,7 @@ def test_discovery_endpoint_methods_return_405(httpserver, check_config):
         )
 
 
-def test_discovery_endpoint_methods_wrong_status_codes(httpserver, check_config):
+def test_discovery_endpoint_methods_wrong_status_codes(httpserver, testing_context):
     """Test that non-405 responses are reported as errors."""
     endpoint = "/ResourceTypes"
 
@@ -48,7 +48,7 @@ def test_discovery_endpoint_methods_wrong_status_codes(httpserver, check_config)
         "", status=405
     )  # This one should succeed
 
-    results = _test_discovery_endpoint_methods(check_config, endpoint)
+    results = _test_discovery_endpoint_methods(testing_context, endpoint)
 
     assert len(results) == 4
     assert results[0].status == Status.ERROR
@@ -65,23 +65,23 @@ def test_discovery_endpoint_methods_wrong_status_codes(httpserver, check_config)
     assert all(result.data is not None for result in results)
 
 
-def test_discovery_endpoint_methods_connection_error(check_config):
+def test_discovery_endpoint_methods_connection_error(testing_context):
     """Test handling of connection errors during HTTP method testing."""
     # Mock the client to raise SCIMClientError
-    original_request = check_config.client.client.request
+    original_request = testing_context.client.client.request
 
     def mock_request(*args, **kwargs):
         raise SCIMClientError("Connection failed")
 
-    check_config.client.client.request = mock_request
+    testing_context.client.client.request = mock_request
 
     try:
-        results = _test_discovery_endpoint_methods(check_config, "/TestEndpoint")
+        results = _test_discovery_endpoint_methods(testing_context, "/TestEndpoint")
 
         assert len(results) == 4
         assert all(result.status == Status.ERROR for result in results)
         for result in results:
             assert "failed: Connection failed" in result.reason
     finally:
         # Restore original method
-        check_config.client.client.request = original_request
+        testing_context.client.client.request = original_request

tests/test_random_url.py

@@ -7,21 +7,21 @@
 from scim2_tester.utils import Status
 
 
-def test_random_url(httpserver, check_config):
+def test_random_url(httpserver, testing_context):
     """Test reaching a random URL that returns a SCIM 404 error."""
     httpserver.expect_request(re.compile(r".*")).respond_with_json(
         Error(status=404, detail="Endpoint Not Found").model_dump(),
         status=404,
         content_type="application/scim+json",
     )
 
-    result = random_url(check_config)
+    result = random_url(testing_context)
 
     assert result.status == Status.SUCCESS
     assert "correctly returned a 404 error" in result.reason
 
 
-def test_random_url_valid_object(httpserver, check_config):
+def test_random_url_valid_object(httpserver, testing_context):
     """Test reaching a random URL that returns a SCIM object."""
     httpserver.expect_request(re.compile(r".*")).respond_with_json(
         User(
@@ -31,21 +31,21 @@ def test_random_url_valid_object(httpserver, check_config):
         content_type="application/scim+json",
     )
 
-    result = random_url(check_config)
+    result = random_url(testing_context)
 
     assert result.status == Status.ERROR
     assert "did not return an Error object" in result.reason
 
 
-def test_random_url_not_404(httpserver, check_config):
+def test_random_url_not_404(httpserver, testing_context):
     """Test reaching a random URL that returns a non-404 status code."""
     httpserver.expect_request(re.compile(r".*")).respond_with_json(
         Error(status=200, detail="Endpoint Not Found").model_dump(),
         status=200,
         content_type="application/scim+json",
     )
 
-    result = random_url(check_config)
+    result = random_url(testing_context)
 
     assert result.status == Status.ERROR
     assert "did return an object, but the status code is 200" in result.reason

tests/test_resource.py

@@ -85,7 +85,7 @@ class MockClient:
     assert all(val in ["foo", "bar"] for val in obj.example_multiple)
 
 
-def test_resource_type_tests_with_unknown_schema(check_config):
+def test_resource_type_tests_with_unknown_schema(testing_context):
     """Test CRUD operations on a resource type with unknown schema."""
     resource_type = ResourceType(
         id="urn:test:UnknownResource",
@@ -94,7 +94,7 @@ def test_resource_type_tests_with_unknown_schema(check_config):
         schema_="urn:ietf:params:scim:schemas:core:2.0:UnknownResource",
     )
 
-    results = resource_type_tests(check_config, resource_type)
+    results = resource_type_tests(testing_context, resource_type)
 
     assert len(results) == 1
     assert results[0].status == Status.ERROR
@@ -103,7 +103,7 @@ def test_resource_type_tests_with_unknown_schema(check_config):
     )
 
 
-def test_model_resolution_from_resource_type(check_config):
+def test_model_resolution_from_resource_type(testing_context):
     """Test model resolution from ResourceType schema."""
     unknown_resource_type = ResourceType(
         id="urn:test:UnknownResource",
@@ -112,7 +112,7 @@ def test_model_resolution_from_resource_type(check_config):
         schema_="urn:ietf:params:scim:schemas:core:2.0:UnknownResource",
     )
 
-    model = _model_from_resource_type(check_config, unknown_resource_type)
+    model = _model_from_resource_type(testing_context, unknown_resource_type)
     assert model is None
 
     # Test when model matches the schema
@@ -123,12 +123,12 @@ def test_model_resolution_from_resource_type(check_config):
         schema_="urn:ietf:params:scim:schemas:core:2.0:User",
     )
 
-    model = _model_from_resource_type(check_config, user_resource_type)
+    model = _model_from_resource_type(testing_context, user_resource_type)
     assert model == User
 
 
 def test_object_query_without_id_when_object_missing_from_list(
-    httpserver, check_config
+    httpserver, testing_context
 ):
     """Test querying objects when the created object is missing from the list response."""
     # Mock user creation first (it happens before the query)
@@ -148,15 +148,15 @@ def test_object_query_without_id_when_object_missing_from_list(
         content_type="application/scim+json",
     )
 
-    result = object_query_without_id(check_config, User)
+    result = object_query_without_id(testing_context, User)
 
     assert result.status == Status.ERROR
     assert (
         "Could not find User object with id test-id in list response" in result.reason
     )
 
 
-def test_object_deletion_with_null_id(check_config):
+def test_object_deletion_with_null_id(testing_context):
     """Test deletion of objects without an ID."""
 
     class MockResourceManager:
@@ -172,18 +172,18 @@ def create_and_register(self, model):
         def cleanup(self):
             pass
 
-    original_rm = check_config.resource_manager
-    check_config.resource_manager = MockResourceManager()
+    original_rm = testing_context.resource_manager
+    testing_context.resource_manager = MockResourceManager()
 
     try:
-        result = object_deletion(check_config, User)
+        result = object_deletion(testing_context, User)
         assert result.status == Status.SUCCESS
         assert "Successfully deleted User object with id None" in result.reason
     finally:
-        check_config.resource_manager = original_rm
+        testing_context.resource_manager = original_rm
 
 
-def test_object_deletion_when_object_persists(httpserver, check_config):
+def test_object_deletion_when_object_persists(httpserver, testing_context):
     """Test deletion failure when object persists after DELETE request."""
     user_id = "test-user-123"
     test_user = User(id=user_id, user_name="testuser")
@@ -207,13 +207,13 @@ def test_object_deletion_when_object_persists(httpserver, check_config):
         content_type="application/scim+json",
     )
 
-    result = object_deletion(check_config, User)
+    result = object_deletion(testing_context, User)
 
     assert result.status == Status.ERROR
     assert f"User object with id {user_id} still exists after deletion" in result.reason
 
 
-def test_object_deletion_successful(httpserver, check_config):
+def test_object_deletion_successful(httpserver, testing_context):
     """Test successful object deletion when object is properly removed."""
     user_id = "test-user-456"
     test_user = User(id=user_id, user_name="testuser")
@@ -235,7 +235,7 @@ def test_object_deletion_successful(httpserver, check_config):
         "Not Found", status=404
     )
 
-    result = object_deletion(check_config, User)
+    result = object_deletion(testing_context, User)
 
     assert result.status == Status.SUCCESS
     assert f"Successfully deleted User object with id {user_id}" in result.reason

tests/test_resource_types.py

@@ -13,17 +13,17 @@
 from scim2_tester.utils import Status
 
 
-def test_resource_types_endpoint(httpserver, check_config):
+def test_resource_types_endpoint(httpserver, testing_context):
     """Test a fully functional resource types endpoint."""
     httpserver.expect_request(re.compile(r"^/ResourceTypes$")).respond_with_json(
         ListResponse[ResourceType](
-            resources=check_config.client.resource_types,
-            total_results=len(check_config.client.resource_types),
+            resources=testing_context.client.resource_types,
+            total_results=len(testing_context.client.resource_types),
         ).model_dump(scim_ctx=Context.RESOURCE_QUERY_RESPONSE),
         status=200,
         content_type="application/scim+json",
     )
-    for resource_type in check_config.client.resource_types:
+    for resource_type in testing_context.client.resource_types:
         httpserver.expect_request(
             re.compile(rf"^/ResourceTypes/{resource_type.id}$")
         ).respond_with_json(
@@ -49,35 +49,35 @@ def test_resource_types_endpoint(httpserver, check_config):
         content_type="application/scim+json",
     )
 
-    results = _resource_types_endpoint(check_config)
+    results = _resource_types_endpoint(testing_context)
 
     assert all(result.status == Status.SUCCESS for result in results)
 
 
-def test_resource_missing_query_endpoint(httpserver, check_config):
+def test_resource_missing_query_endpoint(httpserver, testing_context):
     """Test that individual ResourceType endpoints are missing."""
     httpserver.expect_request(re.compile(r"^/ResourceTypes$")).respond_with_json(
         ListResponse[ResourceType](
-            resources=check_config.client.resource_types,
-            total_results=len(check_config.client.resource_types),
+            resources=testing_context.client.resource_types,
+            total_results=len(testing_context.client.resource_types),
         ).model_dump(scim_ctx=Context.RESOURCE_QUERY_RESPONSE),
         status=200,
         content_type="application/scim+json",
     )
-    results = _resource_types_endpoint(check_config)
+    results = _resource_types_endpoint(testing_context)
 
     assert all(result.status == Status.ERROR for result in results[1:])
 
 
-def test_resource_types_endpoint_methods(httpserver, check_config):
+def test_resource_types_endpoint_methods(httpserver, testing_context):
     """Test that resource types endpoint returns proper errors for unsupported HTTP methods."""
     # Mock all HTTP methods to return 405
     for method in ["POST", "PUT", "PATCH", "DELETE"]:
         httpserver.expect_request(
             uri="/ResourceTypes", method=method
         ).respond_with_data("", status=405)
 
-    results = resource_types_endpoint_methods(check_config)
+    results = resource_types_endpoint_methods(testing_context)
 
     assert len(results) == 4
     assert all(result.status == Status.SUCCESS for result in results)
@@ -88,7 +88,7 @@ def test_resource_types_endpoint_methods(httpserver, check_config):
         )
 
 
-def test_query_resource_type_by_id_client_returns_error(httpserver, check_config):
+def test_query_resource_type_by_id_client_returns_error(httpserver, testing_context):
     """Test query_resource_type_by_id when server returns HTTP error."""
     resource_type = ResourceType(
         id="test-id", name="Test", endpoint="/Test", schema_="urn:test"
@@ -102,21 +102,21 @@ def test_query_resource_type_by_id_client_returns_error(httpserver, check_config
         content_type="application/scim+json",
     )
 
-    result = query_resource_type_by_id(check_config, resource_type)
+    result = query_resource_type_by_id(testing_context, resource_type)
     assert result.status == Status.ERROR
     assert "Resource Type not found" in result.reason
 
 
-def test_access_resource_type_by_id_success(httpserver, check_config):
+def test_access_resource_type_by_id_success(httpserver, testing_context):
     """Test successfully accessing a resource type by ID."""
-    resource_type = check_config.client.resource_types[0]
+    resource_type = testing_context.client.resource_types[0]
     httpserver.expect_request(f"/ResourceTypes/{resource_type.id}").respond_with_json(
         resource_type.model_dump(scim_ctx=Context.RESOURCE_QUERY_RESPONSE),
         status=200,
         content_type="application/scim+json",
     )
 
-    result = query_resource_type_by_id(check_config, resource_type)
+    result = query_resource_type_by_id(testing_context, resource_type)
     assert result.status == Status.SUCCESS
     assert (
         f"Successfully accessed the /ResourceTypes/{resource_type.id} endpoint."
@@ -125,7 +125,7 @@ def test_access_resource_type_by_id_success(httpserver, check_config):
     assert result.data == resource_type
 
 
-def test_access_invalid_resource_type_non_error_response(httpserver, check_config):
+def test_access_invalid_resource_type_non_error_response(httpserver, testing_context):
     """Test accessing an invalid resource type that returns a non-Error object."""
     mock_resource_type = ResourceType(
         id="invalid-resource-type",
@@ -142,14 +142,14 @@ def test_access_invalid_resource_type_non_error_response(httpserver, check_confi
         content_type="application/scim+json",
     )
 
-    result = access_invalid_resource_type(check_config)
+    result = access_invalid_resource_type(testing_context)
 
     assert result.status == Status.ERROR
     assert "invalid URL did not return an Error object" in result.reason
     assert result.data == mock_resource_type
 
 
-def test_access_invalid_resource_type_wrong_status_code(httpserver, check_config):
+def test_access_invalid_resource_type_wrong_status_code(httpserver, testing_context):
     """Test accessing an invalid resource type that returns wrong status code."""
     error = Error(status=400, detail="Bad Request")
 
@@ -161,7 +161,7 @@ def test_access_invalid_resource_type_wrong_status_code(httpserver, check_config
         content_type="application/scim+json",
     )
 
-    result = access_invalid_resource_type(check_config)
+    result = access_invalid_resource_type(testing_context)
 
     assert result.status == Status.ERROR
     assert "did return an object, but the status code is 400" in result.reason