add tests for new functionality

nikhilc-microsoft · nikhilc-microsoft · commit 9b2473a1024f · 2025-11-19T12:43:16.000-07:00
diff --git a/tests/observability/core/test_agent365.py b/tests/observability/core/test_agent365.py
@@ -1,36 +1,117 @@
-# Copyright (c) Microsoft. All rights reserved.
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
 
+import unittest
+from unittest.mock import Mock, patch
 
 from microsoft_agents_a365.observability.core import configure
+from microsoft_agents_a365.observability.core.exporters.agent365_exporter_options import (
+    Agent365ExporterOptions,
+)
 from microsoft_agents_a365.observability.core.trace_processor import SpanProcessor
 
 
-def test_basic_functionality():
-    """Test basic Microsoft Agent 365 SDK functionality"""
-    print("Testing Microsoft Agent 365 SDK...")
+class TestAgent365Configure(unittest.TestCase):
+    """Test suite for Agent365 configuration functionality."""
 
-    # Test configure function
-    try:
-        configure(
+    def setUp(self):
+        """Set up test fixtures."""
+        self.mock_token_resolver = Mock()
+        self.mock_token_resolver.return_value = "test_token_123"
+
+    def test_configure_basic_functionality(self):
+        """Test configure function with basic parameters and legacy parameters."""
+        # Test basic configuration without exporter_options
+        result = configure(
+            service_name="test-service",
+            service_namespace="test-namespace",
+        )
+        self.assertTrue(result, "configure() should return True")
+
+        # Test configuration with legacy parameters
+        result = configure(
+            service_name="test-service",
+            service_namespace="test-namespace",
+            token_resolver=self.mock_token_resolver,
+            cluster_category="test",
+        )
+        self.assertTrue(result, "configure() should return True with legacy parameters")
+
+    @patch("microsoft_agents_a365.observability.core.config.is_agent365_exporter_enabled")
+    def test_configure_with_exporter_options_and_parameter_precedence(self, mock_is_enabled):
+        """Test configure function with exporter_options and verify parameter precedence."""
+        # Enable Agent365 exporter for this test
+        mock_is_enabled.return_value = True
+
+        # Test 1: Basic exporter_options functionality
+        exporter_options = Agent365ExporterOptions(
+            cluster_category="dev",
+            token_resolver=self.mock_token_resolver,
+            use_s2s_endpoint=True,
+            max_queue_size=1024,
+            scheduled_delay_ms=2500,
+            exporter_timeout_ms=15000,
+            max_export_batch_size=256,
+        )
+
+        result = configure(
             service_name="test-service",
             service_namespace="test-namespace",
+            exporter_options=exporter_options,
+        )
+        self.assertTrue(result, "configure() should return True with exporter_options")
+
+    @patch("microsoft_agents_a365.observability.core.config.Agent365Exporter")
+    @patch("microsoft_agents_a365.observability.core.config.BatchSpanProcessor")
+    @patch("microsoft_agents_a365.observability.core.config.is_agent365_exporter_enabled")
+    def test_batch_span_processor_and_exporter_called_with_correct_values(
+        self, mock_is_enabled, mock_batch_processor, mock_exporter
+    ):
+        """Test that BatchSpanProcessor and Agent365Exporter are called with correct values from exporter_options."""
+        # Enable Agent365 exporter for this test
+        mock_is_enabled.return_value = True
+
+        # Create exporter options with specific values
+        exporter_options = Agent365ExporterOptions(
+            cluster_category="staging",
+            token_resolver=self.mock_token_resolver,
+            use_s2s_endpoint=True,
+            max_queue_size=512,
+            scheduled_delay_ms=1000,
+            exporter_timeout_ms=10000,
+            max_export_batch_size=128,
+        )
+
+        # Configure with exporter_options
+        result = configure(
+            service_name="test-service",
+            service_namespace="test-namespace",
+            exporter_options=exporter_options,
+        )
+
+        # Verify configuration succeeded
+        self.assertTrue(result, "configure() should return True")
+
+        # Verify Agent365Exporter was called with correct parameters
+        mock_exporter.assert_called_once_with(
+            token_resolver=self.mock_token_resolver,
+            cluster_category="staging",
+            use_s2s_endpoint=True,
         )
-        print("✅ configure() executed successfully")
-    except Exception as e:
-        print(f"❌ configure() failed: {e}")
-        return False
 
-    # Test SpanProcessor class
-    try:
-        SpanProcessor()
-        print("✅ SpanProcessor created successfully")
-    except Exception as e:
-        print(f"❌ SpanProcessor creation failed: {e}")
-        return False
+        # Verify BatchSpanProcessor was called with correct parameters from exporter_options
+        mock_batch_processor.assert_called_once()
+        call_args = mock_batch_processor.call_args
+        self.assertEqual(call_args.kwargs["max_queue_size"], 512)
+        self.assertEqual(call_args.kwargs["schedule_delay_millis"], 1000)
+        self.assertEqual(call_args.kwargs["export_timeout_millis"], 10000)
+        self.assertEqual(call_args.kwargs["max_export_batch_size"], 128)
 
-    print("✅ All tests passed!")
-    return True
+    def test_span_processor_creation(self):
+        """Test SpanProcessor class creation."""
+        processor = SpanProcessor()
+        self.assertIsNotNone(processor, "SpanProcessor should be created successfully")
 
 
 if __name__ == "__main__":
-    test_basic_functionality()
+    unittest.main()
diff --git a/tests/observability/core/test_baggage_builder.py b/tests/observability/core/test_baggage_builder.py
@@ -11,8 +11,12 @@
     GEN_AI_AGENT_ID_KEY,
     GEN_AI_AGENT_UPN_KEY,
     GEN_AI_CALLER_ID_KEY,
+    GEN_AI_EXECUTION_SOURCE_DESCRIPTION_KEY,
+    GEN_AI_EXECUTION_SOURCE_NAME_KEY,
     HIRING_MANAGER_ID_KEY,
     OPERATION_SOURCE_KEY,
+    SESSION_DESCRIPTION_KEY,
+    SESSION_ID_KEY,
     TENANT_ID_KEY,
 )
 from microsoft_agents_a365.observability.core.middleware.baggage_builder import BaggageBuilder
@@ -48,6 +52,9 @@ def setUp(self):
         # Clear any existing context/baggage before each test
         context.detach(context.attach({}))
 
+        # Create a fresh BaggageBuilder for each test
+        self.builder = BaggageBuilder()
+
     def tearDown(self):
         """Clean up after each test."""
         # Clear context
@@ -280,6 +287,79 @@ def fake_from_turn_context(turn_ctx: any):
             # Restore original
             tempBaggageBuilder.from_turn_context = original_fn
 
+    def test_source_metadata_name_method(self):
+        """Test deprecated source_metadata_name method - should delegate to channel_name."""
+        # Should exist and be callable
+        self.assertTrue(hasattr(self.builder, "source_metadata_name"))
+        self.assertTrue(callable(self.builder.source_metadata_name))
+
+        # Should set channel name baggage through delegation
+        with self.builder.source_metadata_name("test-channel").build():
+            current_baggage = baggage.get_all()
+            self.assertEqual(current_baggage.get(GEN_AI_EXECUTION_SOURCE_NAME_KEY), "test-channel")
+
+    def test_source_metadata_description_method(self):
+        """Test deprecated source_metadata_description method - should delegate to channel_links."""
+        # Should exist and be callable
+        self.assertTrue(hasattr(self.builder, "source_metadata_description"))
+        self.assertTrue(callable(self.builder.source_metadata_description))
+
+        # Should set channel description baggage through delegation
+        with self.builder.source_metadata_description("test-description").build():
+            current_baggage = baggage.get_all()
+            self.assertEqual(
+                current_baggage.get(GEN_AI_EXECUTION_SOURCE_DESCRIPTION_KEY), "test-description"
+            )
+
+    def test_session_id_method(self):
+        """Test session_id method sets session ID baggage."""
+        # Should exist and be callable
+        self.assertTrue(hasattr(self.builder, "session_id"))
+        self.assertTrue(callable(self.builder.session_id))
+
+        # Should set session ID baggage
+        with self.builder.session_id("test-session-123").build():
+            current_baggage = baggage.get_all()
+            self.assertEqual(current_baggage.get(SESSION_ID_KEY), "test-session-123")
+
+    def test_session_description_method(self):
+        """Test session_description method sets session description baggage."""
+        # Should exist and be callable
+        self.assertTrue(hasattr(self.builder, "session_description"))
+        self.assertTrue(callable(self.builder.session_description))
+
+        # Should set session description baggage
+        with self.builder.session_description("test session description").build():
+            current_baggage = baggage.get_all()
+            self.assertEqual(
+                current_baggage.get(SESSION_DESCRIPTION_KEY), "test session description"
+            )
+
+    def test_channel_name_method(self):
+        """Test channel_name method sets channel name baggage."""
+        # Should exist and be callable
+        self.assertTrue(hasattr(self.builder, "channel_name"))
+        self.assertTrue(callable(self.builder.channel_name))
+
+        # Should set channel name baggage
+        with self.builder.channel_name("Teams Channel").build():
+            current_baggage = baggage.get_all()
+            self.assertEqual(current_baggage.get(GEN_AI_EXECUTION_SOURCE_NAME_KEY), "Teams Channel")
+
+    def test_channel_links_method(self):
+        """Test channel_links method sets channel description baggage."""
+        # Should exist and be callable
+        self.assertTrue(hasattr(self.builder, "channel_links"))
+        self.assertTrue(callable(self.builder.channel_links))
+
+        # Should set channel description baggage
+        with self.builder.channel_links("https://teams.microsoft.com/channel/123").build():
+            current_baggage = baggage.get_all()
+            self.assertEqual(
+                current_baggage.get(GEN_AI_EXECUTION_SOURCE_DESCRIPTION_KEY),
+                "https://teams.microsoft.com/channel/123",
+            )
+
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/tests/observability/core/test_invoke_agent_scope.py b/tests/observability/core/test_invoke_agent_scope.py
@@ -6,11 +6,25 @@
 
 from microsoft_agents_a365.observability.core import (
     AgentDetails,
+    ExecutionType,
     InvokeAgentDetails,
     InvokeAgentScope,
+    Request,
+    SourceMetadata,
     TenantDetails,
     configure,
 )
+from microsoft_agents_a365.observability.core.models.caller_details import CallerDetails
+from opentelemetry import trace
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.export import SimpleSpanProcessor
+from opentelemetry.sdk.trace.export.in_memory_span_exporter import InMemorySpanExporter
+
+# Constants for span attribute keys
+GEN_AI_EXECUTION_SOURCE_NAME_KEY = "gen_ai.channel.name"
+GEN_AI_EXECUTION_SOURCE_DESCRIPTION_KEY = "gen_ai.channel.link"
+GEN_AI_EXECUTION_TYPE_KEY = "gen_ai.execution.type"
+GEN_AI_INPUT_MESSAGES_KEY = "gen_ai.input.messages"
 
 
 class TestInvokeAgentScope(unittest.TestCase):
@@ -37,6 +51,42 @@ def setUpClass(cls):
             session_id="session-123",
         )
 
+        # Create source metadata for requests
+        cls.source_metadata = SourceMetadata(
+            id="source-agent-456",
+            name="Source Channel",
+            icon_uri="https://example.com/source-icon.png",
+            description="Source channel description",
+        )
+
+        # Create a comprehensive request object
+        cls.test_request = Request(
+            content="Process customer inquiry about order status",
+            execution_type=ExecutionType.AGENT_TO_AGENT,
+            session_id="session-abc123",
+            source_metadata=cls.source_metadata,
+        )
+
+        # Create caller details (non-agentic caller)
+        cls.caller_details = CallerDetails(
+            caller_id="user-123",
+            caller_upn="user@contoso.com",
+            caller_name="John Doe",
+            caller_user_id="user-id-456",
+            tenant_id="tenant-789",
+        )
+
+        # Create caller agent details (agentic caller)
+        cls.caller_agent_details = AgentDetails(
+            agent_id="caller-agent-789",
+            agent_name="Caller Agent",
+            agent_description="The agent that initiated this request",
+            agent_blueprint_id="blueprint-456",
+            agent_auid="auid-123",
+            agent_upn="agent@contoso.com",
+            tenant_id="tenant-789",
+        )
+
     def test_record_response_method_exists(self):
         """Test that record_response method exists on InvokeAgentScope."""
         scope = InvokeAgentScope.start(self.invoke_details, self.tenant_details)
@@ -67,6 +117,62 @@ def test_record_output_messages_method_exists(self):
             self.assertTrue(callable(scope.record_output_messages))
             scope.dispose()
 
+    def test_request_attributes_set_on_span(self):
+        """Test that request parameters from mock data are available on span attributes."""
+        # Set up tracer to capture spans
+        span_exporter = InMemorySpanExporter()
+        tracer_provider = TracerProvider()
+        tracer_provider.add_span_processor(SimpleSpanProcessor(span_exporter))
+        trace.set_tracer_provider(tracer_provider)
+
+        # Create scope with request
+        scope = InvokeAgentScope.start(
+            invoke_agent_details=self.invoke_details,
+            tenant_details=self.tenant_details,
+            request=self.test_request,
+        )
+
+        if scope is not None:
+            scope.dispose()
+
+        # Check if mock data parameters are available in span attributes
+        finished_spans = span_exporter.get_finished_spans()
+
+        if finished_spans:
+            # Get attributes from the span
+            span = finished_spans[-1]
+            span_attributes = getattr(span, "attributes", {}) or {}
+
+            # Verify mock data request parameters are in span attributes
+            # Check source channel name from mock data
+            if GEN_AI_EXECUTION_SOURCE_NAME_KEY in span_attributes:
+                self.assertEqual(
+                    span_attributes[GEN_AI_EXECUTION_SOURCE_NAME_KEY],
+                    self.source_metadata.name,  # From cls.source_metadata.name
+                )
+
+            # Check source channel description from mock data
+            if GEN_AI_EXECUTION_SOURCE_DESCRIPTION_KEY in span_attributes:
+                self.assertEqual(
+                    span_attributes[GEN_AI_EXECUTION_SOURCE_DESCRIPTION_KEY],
+                    self.source_metadata.description,  # From cls.source_metadata.description
+                )
+
+            # Check execution type from mock data
+            if GEN_AI_EXECUTION_TYPE_KEY in span_attributes:
+                self.assertEqual(
+                    span_attributes[GEN_AI_EXECUTION_TYPE_KEY],
+                    self.test_request.execution_type.value,  # From cls.test_request.execution_type
+                )
+
+            # Check input messages contain request content from mock data
+            if GEN_AI_INPUT_MESSAGES_KEY in span_attributes:
+                input_messages = span_attributes[GEN_AI_INPUT_MESSAGES_KEY]
+                self.assertIn(
+                    self.test_request.content,  # From cls.test_request.content
+                    input_messages,
+                )
+
 
 if __name__ == "__main__":
     unittest.main(verbosity=2)
diff --git a/tests/observability/core/test_span_processor.py b/tests/observability/core/test_span_processor.py
