Fix test cases

mrunalhirve128 · mrunalhirve128 · commit 81c792e0a9d5 · 2025-11-25T11:41:50.000-08:00
diff --git a/tests/runtime/test_environment_utils.py b/tests/runtime/test_environment_utils.py
@@ -4,69 +4,39 @@
 """Unit tests for environment_utils module."""
 
 import os
-import unittest
+import pytest
 
 from microsoft_agents_a365.runtime.environment_utils import (
-    DEVELOPMENT_ENVIRONMENT_NAME,
-    PROD_OBSERVABILITY_CLUSTER_CATEGORY,
     PROD_OBSERVABILITY_SCOPE,
-    PRODUCTION_ENVIRONMENT_NAME,
     get_observability_authentication_scope,
     is_development_environment,
 )
 
 
-class TestEnvironmentUtils(unittest.TestCase):
-    """Test cases for environment utility functions.
+def test_get_observability_authentication_scope():
+    """Test get_observability_authentication_scope returns production scope."""
+    result = get_observability_authentication_scope()
+    assert result == [PROD_OBSERVABILITY_SCOPE]
 
-    Tests: Constants validation, observability scope retrieval, and environment detection logic.
-    """
 
-    def tearDown(self):
-        """Clean up environment variables after each test."""
-        if "PYTHON_ENVIRONMENT" in os.environ:
-            del os.environ["PYTHON_ENVIRONMENT"]
-
-    def test_constants(self):
-        """Test that environment constants have expected values."""
-        self.assertEqual(PROD_OBSERVABILITY_SCOPE, "https://api.powerplatform.com/.default")
-        self.assertEqual(PROD_OBSERVABILITY_CLUSTER_CATEGORY, "prod")
-        self.assertEqual(PRODUCTION_ENVIRONMENT_NAME, "production")
-        self.assertEqual(DEVELOPMENT_ENVIRONMENT_NAME, "Development")
-
-    def test_get_observability_authentication_scope_returns_prod_scope(self):
-        """Test that get_observability_authentication_scope returns production scope."""
-        result = get_observability_authentication_scope()
-
-        self.assertIsInstance(result, list)
-        self.assertEqual(len(result), 1)
-        self.assertEqual(result[0], PROD_OBSERVABILITY_SCOPE)
-
-    def test_is_development_environment_with_no_env_var(self):
-        """Test is_development_environment returns False when no environment variable is set."""
-        if "PYTHON_ENVIRONMENT" in os.environ:
-            del os.environ["PYTHON_ENVIRONMENT"]
-
-        result = is_development_environment()
-
-        self.assertFalse(result)
-
-    def test_is_development_environment_with_development_env_var(self):
-        """Test is_development_environment returns True when PYTHON_ENVIRONMENT is 'Development'."""
-        os.environ["PYTHON_ENVIRONMENT"] = "Development"
-
-        result = is_development_environment()
-
-        self.assertTrue(result)
-
-    def test_is_development_environment_with_production_env_var(self):
-        """Test is_development_environment returns False when PYTHON_ENVIRONMENT is 'production'."""
-        os.environ["PYTHON_ENVIRONMENT"] = "production"
-
-        result = is_development_environment()
-
-        self.assertFalse(result)
-
-
-if __name__ == "__main__":
-    unittest.main()
+@pytest.mark.parametrize(
+    "env_value,expected",
+    [
+        (None, False),
+        ("Development", True),
+        ("production", False),
+        ("staging", False),
+    ],
+)
+def test_is_development_environment(env_value, expected):
+    """Test is_development_environment returns correct value based on PYTHON_ENVIRONMENT."""
+    if env_value is None:
+        os.environ.pop("PYTHON_ENVIRONMENT", None)
+    else:
+        os.environ["PYTHON_ENVIRONMENT"] = env_value
+
+    result = is_development_environment()
+    assert result == expected
+
+    # Cleanup
+    os.environ.pop("PYTHON_ENVIRONMENT", None)
diff --git a/tests/runtime/test_utility.py b/tests/runtime/test_utility.py
@@ -1,159 +1,126 @@
-# Copyright (c) Microsoft. All rights reserved.
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+"""Unit tests for Utility class."""
 
-import unittest
 import uuid
-import jwt
+from unittest.mock import Mock
 
+import jwt
+import pytest
 from microsoft_agents_a365.runtime.utility import Utility
 
 
-class TestUtility(unittest.TestCase):
-    """Test cases for the Utility class."""
+# Fixtures (Mocks and Helpers)
+@pytest.fixture
+def create_test_jwt():
+    """Fixture to create test JWT tokens."""
 
-    def setUp(self):
-        """Set up test fixtures."""
-        self.test_app_id = "12345678-1234-1234-1234-123456789abc"
-        self.test_azp_id = "87654321-4321-4321-4321-cba987654321"
-
-    def create_test_jwt(self, claims: dict) -> str:
-        """Create a test JWT token with the given claims."""
-        # Use PyJWT to create a proper JWT token (unsigned for testing)
+    def _create(claims: dict) -> str:
         return jwt.encode(claims, key="", algorithm="none")
 
-    def test_get_app_id_from_token_with_none_token(self):
-        """Test get_app_id_from_token with None token."""
-        result = Utility.get_app_id_from_token(None)
-        self.assertEqual(result, str(uuid.UUID(int=0)))
-
-    def test_get_app_id_from_token_with_empty_token(self):
-        """Test get_app_id_from_token with empty token."""
-        result = Utility.get_app_id_from_token("")
-        self.assertEqual(result, str(uuid.UUID(int=0)))
-
-        result = Utility.get_app_id_from_token("   ")
-        self.assertEqual(result, str(uuid.UUID(int=0)))
-
-    def test_get_app_id_from_token_with_appid_claim(self):
-        """Test get_app_id_from_token with appid claim."""
-        token = self.create_test_jwt({"appid": self.test_app_id, "other": "value"})
-        result = Utility.get_app_id_from_token(token)
-        self.assertEqual(result, self.test_app_id)
-
-    def test_get_app_id_from_token_with_azp_claim(self):
-        """Test get_app_id_from_token with azp claim."""
-        token = self.create_test_jwt({"azp": self.test_azp_id, "other": "value"})
-        result = Utility.get_app_id_from_token(token)
-        self.assertEqual(result, self.test_azp_id)
-
-    def test_get_app_id_from_token_with_both_claims(self):
-        """Test get_app_id_from_token with both appid and azp claims (appid takes precedence)."""
-        token = self.create_test_jwt({"appid": self.test_app_id, "azp": self.test_azp_id})
-        result = Utility.get_app_id_from_token(token)
-        self.assertEqual(result, self.test_app_id)
-
-    def test_get_app_id_from_token_without_app_claims(self):
-        """Test get_app_id_from_token with token containing no app claims."""
-        token = self.create_test_jwt({"sub": "user123", "iss": "issuer"})
-        result = Utility.get_app_id_from_token(token)
-        self.assertEqual(result, "")
-
-    def test_get_app_id_from_token_with_invalid_token(self):
-        """Test get_app_id_from_token with invalid token formats."""
-        # Invalid token format
-        result = Utility.get_app_id_from_token("invalid.token")
-        self.assertEqual(result, "")
-
-        # Token with only two parts
-        result = Utility.get_app_id_from_token("header.payload")
-        self.assertEqual(result, "")
-
-        # Token with invalid base64
-        result = Utility.get_app_id_from_token("invalid.!!!invalid!!!.signature")
-        self.assertEqual(result, "")
-
-
-class MockActivity:
-    """Mock activity class for testing."""
-
-    def __init__(self, is_agentic: bool = False, agentic_id: str = ""):
-        self._is_agentic = is_agentic
-        self._agentic_id = agentic_id
-
-    def is_agentic_request(self) -> bool:
-        return self._is_agentic
-
-    def get_agentic_instance_id(self) -> str:
-        return self._agentic_id
-
-
-class MockContext:
-    """Mock context class for testing."""
-
-    def __init__(self, activity=None):
-        self.activity = activity
-
-
-class TestUtilityResolveAgentIdentity(unittest.TestCase):
-    """Test cases for the resolve_agent_identity method."""
-
-    def setUp(self):
-        """Set up test fixtures."""
-        self.test_app_id = "token-app-id-123"
-        self.agentic_id = "agentic-id-456"
-
-        # Create a test token with PyJWT
-        claims = {"appid": self.test_app_id}
-        self.test_token = jwt.encode(claims, key="", algorithm="none")
-
-    def test_resolve_agent_identity_with_agentic_request(self):
-        """Test resolve_agent_identity with agentic request."""
-        activity = MockActivity(is_agentic=True, agentic_id=self.agentic_id)
-        context = MockContext(activity)
-
-        result = Utility.resolve_agent_identity(context, self.test_token)
-        self.assertEqual(result, self.agentic_id)
-
-    def test_resolve_agent_identity_with_non_agentic_request(self):
-        """Test resolve_agent_identity with non-agentic request."""
-        activity = MockActivity(is_agentic=False)
-        context = MockContext(activity)
-
-        result = Utility.resolve_agent_identity(context, self.test_token)
-        self.assertEqual(result, self.test_app_id)
-
-    def test_resolve_agent_identity_with_context_without_activity(self):
-        """Test resolve_agent_identity with context that has no activity."""
-        context = MockContext()
-
-        result = Utility.resolve_agent_identity(context, self.test_token)
-        self.assertEqual(result, self.test_app_id)
-
-    def test_resolve_agent_identity_with_none_context(self):
-        """Test resolve_agent_identity with None context."""
-        result = Utility.resolve_agent_identity(None, self.test_token)
-        self.assertEqual(result, self.test_app_id)
-
-    def test_resolve_agent_identity_with_agentic_but_empty_id(self):
-        """Test resolve_agent_identity with agentic request but empty agentic ID."""
-        activity = MockActivity(is_agentic=True, agentic_id="")
-        context = MockContext(activity)
-
-        result = Utility.resolve_agent_identity(context, self.test_token)
-        self.assertEqual(result, "")
-
-    def test_resolve_agent_identity_fallback_on_exception(self):
-        """Test resolve_agent_identity falls back to token when context access fails."""
-
-        # Create a context that will raise an exception when accessed
-        class FaultyContext:
-            @property
-            def activity(self):
-                raise RuntimeError("Context access failed")
-
-        context = FaultyContext()
-        result = Utility.resolve_agent_identity(context, self.test_token)
-        self.assertEqual(result, self.test_app_id)
-
-
-if __name__ == "__main__":
-    unittest.main()
+    return _create
+
+
+@pytest.fixture
+def mock_activity():
+    """Fixture to create mock activity."""
+
+    def _create(is_agentic=False, agentic_id=""):
+        activity = Mock()
+        activity.is_agentic_request.return_value = is_agentic
+        activity.get_agentic_instance_id.return_value = agentic_id
+        return activity
+
+    return _create
+
+
+@pytest.fixture
+def mock_context():
+    """Fixture to create mock context."""
+
+    def _create(activity=None):
+        context = Mock()
+        context.activity = activity
+        return context
+
+    return _create
+
+
+# Tests for get_app_id_from_token
+@pytest.mark.parametrize(
+    "token,expected",
+    [
+        (None, str(uuid.UUID(int=0))),
+        ("", str(uuid.UUID(int=0))),
+        ("   ", str(uuid.UUID(int=0))),
+        ("invalid.token", ""),
+    ],
+)
+def test_get_app_id_from_token_invalid(token, expected):
+    """Test get_app_id_from_token handles invalid tokens correctly."""
+    result = Utility.get_app_id_from_token(token)
+    assert result == expected
+
+
+@pytest.mark.parametrize(
+    "claims,expected",
+    [
+        ({"appid": "test-app-id"}, "test-app-id"),
+        ({"azp": "azp-app-id"}, "azp-app-id"),
+        ({"appid": "appid-value", "azp": "azp-value"}, "appid-value"),
+        ({"sub": "user123"}, ""),
+    ],
+)
+def test_get_app_id_from_token_valid_tokens(create_test_jwt, claims, expected):
+    """Test get_app_id_from_token with valid tokens and various claims."""
+    token = create_test_jwt(claims)
+    result = Utility.get_app_id_from_token(token)
+    assert result == expected
+
+
+# Tests for resolve_agent_identity
+@pytest.mark.parametrize(
+    "is_agentic,agentic_id,expected",
+    [
+        (True, "agentic-id", "agentic-id"),
+        (True, "", ""),
+        (False, "", "token-app-id"),
+        (False, "ignored-id", "token-app-id"),
+    ],
+)
+def test_resolve_agent_identity_with_context(
+    create_test_jwt, mock_activity, mock_context, is_agentic, agentic_id, expected
+):
+    """Test resolve_agent_identity returns correct ID based on context."""
+    token = create_test_jwt({"appid": "token-app-id"})
+    activity = mock_activity(is_agentic=is_agentic, agentic_id=agentic_id)
+    context = mock_context(activity)
+
+    result = Utility.resolve_agent_identity(context, token)
+    assert result == expected
+
+
+@pytest.mark.parametrize(
+    "context",
+    [
+        None,
+        Mock(activity=None),
+    ],
+)
+def test_resolve_agent_identity_fallback(create_test_jwt, context):
+    """Test resolve_agent_identity falls back to token when context is invalid."""
+    token = create_test_jwt({"appid": "token-app-id"})
+    result = Utility.resolve_agent_identity(context, token)
+    assert result == "token-app-id"
+
+
+def test_resolve_agent_identity_exception_handling(create_test_jwt, mock_context):
+    """Test resolve_agent_identity falls back to token when activity methods raise exceptions."""
+    token = create_test_jwt({"appid": "token-app-id"})
+    activity = Mock()
+    activity.is_agentic_request.side_effect = AttributeError("Method not available")
+    context = mock_context(activity)
+
+    result = Utility.resolve_agent_identity(context, token)
+    assert result == "token-app-id"
