chore(tests): add Platform and Utils module specfication ids to related tests missing tests [skip:ci]

Author: muhabalwan-aginx

tests/aignostics/platform/authentication_test.py

@@ -52,8 +52,9 @@ def mock_settings() -> MagicMock:
 
 
 @pytest.fixture
-def mock_token_file(tmp_path) -> Path:
+def mock_token_file(tmp_path, record_property) -> Path:
     """Create a temporary token file for testing."""
+    record_property("tested-item-id", "SPEC-PLATFORM-SERVICE")
     return tmp_path / "token"  # Return directly, no need for assignment
 
 
@@ -107,8 +108,9 @@ class TestGetToken:
     """Test cases for the get_token function."""
 
     @staticmethod
-    def test_get_token_from_cache_valid(mock_settings, valid_token_with_expiry) -> None:
+    def test_get_token_from_cache_valid(record_property, mock_settings, valid_token_with_expiry) -> None:
         """Test retrieving a valid token from cache."""
+        record_property("tested-item-id", "SPEC-PLATFORM-SERVICE")
         # Create a mock for Path that can be properly asserted on
         mock_write_text = MagicMock()
 
@@ -123,8 +125,9 @@ def test_get_token_from_cache_valid(mock_settings, valid_token_with_expiry) -> N
             mock_write_text.assert_not_called()
 
     @staticmethod
-    def test_get_token_from_cache_expired(mock_settings, expired_token) -> None:
+    def test_get_token_from_cache_expired(record_property, mock_settings, expired_token) -> None:
         """Test retrieving an expired token from cache, which should trigger re-authentication."""
+        record_property("tested-item-id", "SPEC-PLATFORM-SERVICE")
         # Create a mock for Path that can be properly asserted on
         mock_write_text = MagicMock()
 
@@ -144,8 +147,9 @@ def test_get_token_from_cache_expired(mock_settings, expired_token) -> None:
             assert mock_write_text.call_count == 1
 
     @staticmethod
-    def test_get_token_no_cache(mock_settings) -> None:
+    def test_get_token_no_cache(record_property, mock_settings) -> None:
         """Test retrieving a token without using cache."""
+        record_property("tested-item-id", "SPEC-PLATFORM-SERVICE")
         # Create a mock for Path that can be properly asserted on
         mock_write_text = MagicMock()
 
@@ -163,8 +167,9 @@ def test_get_token_no_cache(mock_settings) -> None:
             mock_write_text.assert_not_called()
 
     @staticmethod
-    def test_authenticate_uses_refresh_token_when_available(mock_settings) -> None:
+    def test_authenticate_uses_refresh_token_when_available(record_property, mock_settings) -> None:
         """Test that _authenticate uses refresh token flow when refresh token is available."""
+        record_property("tested-item-id", "SPEC-PLATFORM-SERVICE")
         # Set up refresh token in settings
         mock_settings.return_value.refresh_token = SecretStr("test-refresh-token")
 
@@ -176,8 +181,9 @@ def test_authenticate_uses_refresh_token_when_available(mock_settings) -> None:
             mock_refresh.assert_called_once_with(mock_settings.return_value.refresh_token)
 
     @staticmethod
-    def test_authenticate_uses_browser_flow_when_available(mock_settings) -> None:
+    def test_authenticate_uses_browser_flow_when_available(record_property, mock_settings) -> None:
         """Test that _authenticate uses browser flow when browser is available."""
+        record_property("tested-item-id", "SPEC-PLATFORM-SERVICE")
         mock_settings.return_value.refresh_token = None
 
         with (
@@ -192,8 +198,9 @@ def test_authenticate_uses_browser_flow_when_available(mock_settings) -> None:
             mock_browser.assert_called_once()
 
     @staticmethod
-    def test_authenticate_falls_back_to_device_flow(mock_settings) -> None:
+    def test_authenticate_falls_back_to_device_flow(record_property, mock_settings) -> None:
         """Test that _authenticate falls back to device flow when browser and refresh token are unavailable."""
+        record_property("tested-item-id", "SPEC-PLATFORM-SERVICE")
         mock_settings.return_value.refresh_token = None
 
         with (
@@ -207,8 +214,9 @@ def test_authenticate_falls_back_to_device_flow(mock_settings) -> None:
             mock_device.assert_called_once()
 
     @staticmethod
-    def test_authenticate_raises_error_on_failure(mock_settings) -> None:
+    def test_authenticate_raises_error_on_failure(record_property, mock_settings) -> None:
         """Test that _authenticate raises an error when all authentication methods fail."""
+        record_property("tested-item-id", "SPEC-PLATFORM-SERVICE")
         mock_settings.return_value.refresh_token = None
 
         with (
@@ -223,8 +231,9 @@ class TestVerifyAndDecodeToken:
     """Test cases for the verify_and_decode_token function."""
 
     @staticmethod
-    def test_verify_and_decode_valid_token() -> None:
+    def test_verify_and_decode_valid_token(record_property) -> None:
         """Test that a valid token is properly verified and decoded."""
+        record_property("tested-item-id", "SPEC-PLATFORM-SERVICE")
         mock_jwt_client = MagicMock()
         mock_signing_key = MagicMock()
         mock_signing_key.key = "test-key"
@@ -240,8 +249,9 @@ def test_verify_and_decode_valid_token() -> None:
             assert "exp" in result
 
     @staticmethod
-    def test_verify_and_decode_invalid_token() -> None:
+    def test_verify_and_decode_invalid_token(record_property) -> None:
         """Test that an invalid token raises an appropriate error."""
+        record_property("tested-item-id", "SPEC-PLATFORM-SERVICE")
         with (
             patch("jwt.PyJWKClient"),
             patch("jwt.get_unverified_header"),
@@ -255,8 +265,9 @@ class TestBrowserCapabilityCheck:
     """Test cases for the browser capability check functionality."""
 
     @staticmethod
-    def test_can_open_browser_true() -> None:
+    def test_can_open_browser_true(record_property) -> None:
         """Test that _can_open_browser returns True when a browser is available."""
+        record_property("tested-item-id", "SPEC-PLATFORM-SERVICE")
         # We need to override the autouse fixture here
         with (
             patch("webbrowser.get", return_value=MagicMock()),
@@ -265,8 +276,9 @@ def test_can_open_browser_true() -> None:
             assert _can_open_browser() is True
 
     @staticmethod
-    def test_can_open_browser_false() -> None:
+    def test_can_open_browser_false(record_property) -> None:
         """Test that _can_open_browser returns False when no browser is available."""
+        record_property("tested-item-id", "SPEC-PLATFORM-SERVICE")
         with patch("webbrowser.get", side_effect=webbrowser.Error):
             assert _can_open_browser() is False
 
@@ -275,8 +287,9 @@ class TestAuthorizationCodeFlow:
     """Test cases for the authorization code flow with PKCE."""
 
     @staticmethod
-    def test_perform_authorization_code_flow_success(mock_settings) -> None:
+    def test_perform_authorization_code_flow_success(record_property, mock_settings) -> None:
         """Test successful authorization code flow with PKCE."""
+        record_property("tested-item-id", "SPEC-PLATFORM-SERVICE")
         # Mock OAuth session
         mock_session = MagicMock(spec=OAuth2Session)
         mock_session.authorization_url.return_value = ("https://test.auth/authorize?code_challenge=abc", None)
@@ -328,8 +341,9 @@ def handle_request_side_effect():
             mock_session.authorization_url.assert_called_once()
 
     @staticmethod
-    def test_perform_authorization_code_flow_invalid_redirect(mock_settings) -> None:
+    def test_perform_authorization_code_flow_invalid_redirect(record_property, mock_settings) -> None:
         """Test authorization code flow fails with invalid redirect URI."""
+        record_property("tested-item-id", "SPEC-PLATFORM-SERVICE")
         # Mock OAuth session to prevent it from being created
         mock_session = MagicMock(spec=OAuth2Session)
         mock_session.authorization_url.return_value = ("https://test.auth/authorize?code_challenge=abc", None)
@@ -347,8 +361,9 @@ def test_perform_authorization_code_flow_invalid_redirect(mock_settings) -> None
                 _perform_authorization_code_with_pkce_flow()
 
     @staticmethod
-    def test_perform_authorization_code_flow_failure(mock_settings) -> None:
+    def test_perform_authorization_code_flow_failure(record_property, mock_settings) -> None:
         """Test authorization code flow when authentication fails."""
+        record_property("tested-item-id", "SPEC-PLATFORM-SERVICE")
         # Mock OAuth session
         mock_session = MagicMock(spec=OAuth2Session)
         mock_session.authorization_url.return_value = ("https://test.auth/authorize?code_challenge=abc", None)
@@ -400,8 +415,9 @@ class TestDeviceFlow:
     """Test cases for the device flow authentication."""
 
     @staticmethod
-    def test_perform_device_flow_success(mock_settings) -> None:
+    def test_perform_device_flow_success(record_property, mock_settings) -> None:
         """Test successful device flow authentication."""
+        record_property("tested-item-id", "SPEC-PLATFORM-SERVICE")
         device_response = {
             "device_code": "device-code-123",
             "verification_uri_complete": "https://test.auth/device/activate",
@@ -441,30 +457,34 @@ class TestPortAvailability:
     """Test cases for checking port availability."""
 
     @staticmethod
-    def test_port_available() -> None:
+    def test_port_available(record_property) -> None:
         """Test that _ensure_local_port_is_available returns True when the port is available."""
+        record_property("tested-item-id", "SPEC-PLATFORM-SERVICE")
         with patch("socket.socket.bind", return_value=None) as mock_bind:
             assert _ensure_local_port_is_available(8000) is True
             mock_bind.assert_called_once()
 
     @staticmethod
-    def test_port_unavailable() -> None:
+    def test_port_unavailable(record_property) -> None:
         """Test that _ensure_local_port_is_available returns False when the port is unavailable."""
+        record_property("tested-item-id", "SPEC-PLATFORM-SERVICE")
         with patch("socket.socket.bind", side_effect=socket.error) as mock_bind:
             assert _ensure_local_port_is_available(8000) is False
             mock_bind.assert_called()
 
     @staticmethod
-    def test_port_retries() -> None:
+    def test_port_retries(record_property) -> None:
         """Test that _ensure_local_port_is_available retries the specified number of times."""
+        record_property("tested-item-id", "SPEC-PLATFORM-SERVICE")
         with patch("socket.socket.bind", side_effect=socket.error) as mock_bind, patch("time.sleep") as mock_sleep:
             assert _ensure_local_port_is_available(8000, max_retries=3) is False
             assert mock_bind.call_count == 4  # Initial attempt + 3 retries
             assert mock_sleep.call_count == 3
 
     @staticmethod
-    def test_port_availability_uses_socket_reuse() -> None:
+    def test_port_availability_uses_socket_reuse(record_property) -> None:
         """Test that _ensure_local_port_is_available uses SO_REUSEADDR socket option."""
+        record_property("tested-item-id", "SPEC-PLATFORM-SERVICE")
         mock_socket = MagicMock()
         # Make the mock work as a context manager
         mock_socket.__enter__ = MagicMock(return_value=mock_socket)
@@ -479,8 +499,9 @@ def test_port_availability_uses_socket_reuse() -> None:
             mock_socket.bind.assert_called_with(("localhost", 8000))
 
     @staticmethod
-    def test_authorization_flow_sets_socket_reuse(mock_settings) -> None:
+    def test_authorization_flow_sets_socket_reuse(record_property, mock_settings) -> None:
         """Test that the HTTPServer in authorization flow uses SO_REUSEADDR."""
+        record_property("tested-item-id", "SPEC-PLATFORM-SERVICE")
         mock_server = MagicMock()
         mock_socket = MagicMock()
         mock_server.socket = mock_socket
@@ -511,8 +532,9 @@ class TestRemoveCachedToken:
     """Test cases for the remove_cached_token function."""
 
     @staticmethod
-    def test_remove_cached_token_exists(mock_settings) -> None:
+    def test_remove_cached_token_exists(record_property, mock_settings) -> None:
         """Test removing a cached token when the token file exists."""
+        record_property("tested-item-id", "SPEC-PLATFORM-SERVICE")
         with (
             patch.object(Path, "exists", return_value=True),
             patch.object(Path, "unlink") as mock_unlink,
@@ -523,16 +545,18 @@ def test_remove_cached_token_exists(mock_settings) -> None:
             mock_unlink.assert_called_once_with(missing_ok=True)
 
     @staticmethod
-    def test_remove_cached_token_not_exists(mock_settings) -> None:
+    def test_remove_cached_token_not_exists(record_property, mock_settings) -> None:
         """Test removing a cached token when the token file does not exist."""
+        record_property("tested-item-id", "SPEC-PLATFORM-SERVICE")
         with patch.object(Path, "exists", return_value=False):
             result = remove_cached_token()
 
             assert result is False
 
     @staticmethod
-    def test_remove_cached_token_unlink_error(mock_settings) -> None:
+    def test_remove_cached_token_unlink_error(record_property, mock_settings) -> None:
         """Test that remove_cached_token handles unlink errors gracefully."""
+        record_property("tested-item-id", "SPEC-PLATFORM-SERVICE")
         with (
             patch.object(Path, "exists", return_value=True),
             patch.object(Path, "unlink", side_effect=OSError("Permission denied")) as mock_unlink,
@@ -546,8 +570,9 @@ class TestSentryIntegration:
     """Test cases for Sentry integration in the authentication module."""
 
     @staticmethod
-    def test_get_token_calls_sentry_set_user(mock_settings) -> None:
+    def test_get_token_calls_sentry_set_user(record_property, mock_settings) -> None:
         """Test that get_token calls sentry_sdk.set_user with correct user information extracted from token claims."""
+        record_property("tested-item-id", "SPEC-PLATFORM-SERVICE")
         # Mock token claims with the required fields
         mock_claims = {
             "sub": "user123",
@@ -579,8 +604,9 @@ def test_get_token_calls_sentry_set_user(mock_settings) -> None:
             mock_sentry_sdk.set_user.assert_called_once_with({"id": "user123", "org_id": "org456"})
 
     @staticmethod
-    def test_get_token_sentry_unavailable(mock_settings) -> None:
+    def test_get_token_sentry_unavailable(record_property, mock_settings) -> None:
         """Test that get_token works correctly when sentry_sdk is not available."""
+        record_property("tested-item-id", "SPEC-PLATFORM-SERVICE")
         # Mock token claims
         mock_claims = {
             "sub": "user123",
@@ -606,8 +632,9 @@ def test_get_token_sentry_unavailable(mock_settings) -> None:
             assert token == "test.token"  # noqa: S105 - Test credential
 
     @staticmethod
-    def test_get_token_sentry_missing_sub_claim(mock_settings) -> None:
+    def test_get_token_sentry_missing_sub_claim(record_property, mock_settings) -> None:
         """Test that get_token handles missing 'sub' claim gracefully when informing Sentry."""
+        record_property("tested-item-id", "SPEC-PLATFORM-SERVICE")
         # Mock token claims without 'sub' field
         mock_claims = {
             "org_id": "org456",
@@ -638,8 +665,9 @@ def test_get_token_sentry_missing_sub_claim(mock_settings) -> None:
             mock_sentry_sdk.set_user.assert_not_called()
 
     @staticmethod
-    def test_get_token_sentry_handles_token_verification_error(mock_settings) -> None:
+    def test_get_token_sentry_handles_token_verification_error(record_property, mock_settings) -> None:
         """Test that get_token fails when token verification fails, and Sentry is not informed."""
+        record_property("tested-item-id", "SPEC-PLATFORM-SERVICE")
         # Create a mock for sentry_sdk
         mock_sentry_sdk = MagicMock()