Add mock backend and integration tests

Co-authored-by: me <[email protected]>

Author: cursoragent

agents/.env.test

@@ -0,0 +1,30 @@
+# Test configuration for backend integration
+# Copy this file to .env for testing
+
+# Bot Framework Configuration (dummy values for testing)
+MICROSOFT_APP_ID=test-app-id
+MICROSOFT_APP_PASSWORD=test-app-password
+
+# Microsoft 365 Configuration (dummy values for testing)
+AZURE_TENANT_ID=test-tenant-id
+AZURE_CLIENT_ID=test-client-id
+AZURE_CLIENT_SECRET=test-client-secret
+
+# Backend API Configuration
+BACKEND_URL=http://localhost:50505
+
+# Agent Settings
+AGENT_NAME=RAG Assistant
+AGENT_DESCRIPTION=AI-powered document search and chat assistant
+MAX_CONVERSATION_TURNS=20
+ENABLE_TYPING_INDICATOR=true
+
+# Channel Settings
+ENABLE_TEAMS=true
+ENABLE_COPILOT=true
+ENABLE_WEB_CHAT=true
+
+# Server Configuration
+HOST=0.0.0.0
+PORT=8000
+LOG_LEVEL=INFO

agents/mock_backend.py

@@ -0,0 +1,202 @@
+"""
+Mock backend for testing agent integration.
+This simulates the RAG backend responses without requiring Azure services.
+"""
+
+import asyncio
+import json
+import logging
+from quart import Quart, request, jsonify
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+app = Quart(__name__)
+
+# Mock responses for testing
+MOCK_RESPONSES = {
+    "hello": {
+        "answer": "Hello! I'm your AI assistant. I can help you search through documents and answer questions. How can I assist you today?",
+        "data_points": {
+            "text": [],
+            "citations": []
+        },
+        "thoughts": [
+            {
+                "title": "Greeting Response",
+                "description": "Generated a friendly greeting response"
+            }
+        ],
+        "token_usage": {
+            "prompt_tokens": 10,
+            "completion_tokens": 25,
+            "total_tokens": 35
+        },
+        "model_info": {
+            "model": "gpt-4",
+            "temperature": "0.3"
+        }
+    },
+    "benefits": {
+        "answer": "Based on the policy document, the main benefits include comprehensive health coverage, flexible work arrangements, professional development opportunities, and competitive compensation packages. These benefits are designed to support employee well-being and career growth.",
+        "data_points": {
+            "text": [
+                "Policy Document: The company offers comprehensive health coverage including medical, dental, and vision insurance.",
+                "Policy Document: Flexible work arrangements are available including remote work options and flexible hours.",
+                "Policy Document: Professional development opportunities include training programs, conference attendance, and tuition reimbursement."
+            ],
+            "citations": [
+                "Policy Document (Page 1)",
+                "Policy Document (Page 2)",
+                "Policy Document (Page 3)"
+            ]
+        },
+        "thoughts": [
+            {
+                "title": "Document Search",
+                "description": "Searched through policy documents for benefit information"
+            },
+            {
+                "title": "Response Generation",
+                "description": "Generated comprehensive response about benefits"
+            }
+        ],
+        "token_usage": {
+            "prompt_tokens": 150,
+            "completion_tokens": 75,
+            "total_tokens": 225
+        },
+        "model_info": {
+            "model": "gpt-4",
+            "temperature": "0.3"
+        }
+    }
+}
+
+@app.route("/", methods=["GET"])
+async def health():
+    """Health check endpoint."""
+    return jsonify({
+        "status": "healthy",
+        "service": "Mock RAG Backend",
+        "version": "1.0.0"
+    })
+
+@app.route("/chat", methods=["POST"])
+async def chat():
+    """Chat endpoint that simulates RAG responses."""
+    try:
+        data = await request.get_json()
+        messages = data.get("messages", [])
+        
+        if not messages:
+            return jsonify({"error": "No messages provided"}), 400
+        
+        # Get the last user message
+        last_message = None
+        for msg in reversed(messages):
+            if msg.get("role") == "user":
+                last_message = msg.get("content", "").lower()
+                break
+        
+        if not last_message:
+            return jsonify({"error": "No user message found"}), 400
+        
+        # Determine response based on message content
+        if "hello" in last_message or "hi" in last_message:
+            response = MOCK_RESPONSES["hello"]
+        elif "benefit" in last_message or "policy" in last_message:
+            response = MOCK_RESPONSES["benefits"]
+        else:
+            # Default response
+            response = {
+                "answer": f"I understand you're asking about '{last_message}'. I'm a mock backend for testing purposes. In a real implementation, I would search through your documents and provide detailed answers with citations.",
+                "data_points": {
+                    "text": [],
+                    "citations": []
+                },
+                "thoughts": [
+                    {
+                        "title": "Mock Response",
+                        "description": "Generated mock response for testing"
+                    }
+                ],
+                "token_usage": {
+                    "prompt_tokens": 50,
+                    "completion_tokens": 30,
+                    "total_tokens": 80
+                },
+                "model_info": {
+                    "model": "gpt-4",
+                    "temperature": "0.3"
+                }
+            }
+        
+        logger.info(f"Mock backend responding to: {last_message}")
+        return jsonify(response)
+        
+    except Exception as e:
+        logger.error(f"Error in mock chat endpoint: {e}")
+        return jsonify({"error": "Internal server error"}), 500
+
+@app.route("/chat/stream", methods=["POST"])
+async def chat_stream():
+    """Streaming chat endpoint that simulates streaming RAG responses."""
+    try:
+        data = await request.get_json()
+        messages = data.get("messages", [])
+        
+        if not messages:
+            return jsonify({"error": "No messages provided"}), 400
+        
+        # Get the last user message
+        last_message = None
+        for msg in reversed(messages):
+            if msg.get("role") == "user":
+                last_message = msg.get("content", "").lower()
+                break
+        
+        if not last_message:
+            return jsonify({"error": "No user message found"}), 400
+        
+        # Determine response based on message content
+        if "hello" in last_message or "hi" in last_message:
+            response_text = MOCK_RESPONSES["hello"]["answer"]
+        elif "benefit" in last_message or "policy" in last_message:
+            response_text = MOCK_RESPONSES["benefits"]["answer"]
+        else:
+            response_text = f"I understand you're asking about '{last_message}'. I'm a mock backend for testing purposes."
+        
+        # Simulate streaming by sending the response in chunks
+        async def generate_stream():
+            words = response_text.split()
+            for i, word in enumerate(words):
+                chunk = {
+                    "type": "content",
+                    "content": word + " " if i < len(words) - 1 else word
+                }
+                yield json.dumps(chunk) + "\n"
+                await asyncio.sleep(0.1)  # Simulate delay
+            
+            # Send final chunk
+            final_chunk = {
+                "type": "done",
+                "content": ""
+            }
+            yield json.dumps(final_chunk) + "\n"
+        
+        from quart import Response
+        return Response(
+            generate_stream(),
+            mimetype="application/x-ndjson",
+            headers={"Content-Type": "application/x-ndjson"}
+        )
+        
+    except Exception as e:
+        logger.error(f"Error in mock streaming chat endpoint: {e}")
+        return jsonify({"error": "Internal server error"}), 500
+
+if __name__ == "__main__":
+    logger.info("Starting mock backend on http://localhost:50505")
+    app.run(host="0.0.0.0", port=50505, debug=True)

agents/requirements.txt

@@ -1,9 +1,6 @@
-# Microsoft 365 Agents SDK and Bot Framework dependencies
-microsoft-365-agents-sdk
+# Bot Framework dependencies
 botbuilder-core>=4.15.0
 botbuilder-schema>=4.15.0
-botbuilder-adapter-teams>=4.15.0
-botbuilder-adapter-azure>=4.15.0
 
 # Web framework
 quart>=0.18.0

agents/test_backend_integration.py

@@ -0,0 +1,132 @@
+"""
+Test script for backend integration.
+This script tests the agent's ability to call the existing backend API.
+"""
+
+import asyncio
+import logging
+import os
+from typing import Dict, Any
+
+from config.agent_config import AgentConfig
+from services.rag_service import RAGService, RAGRequest
+
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+async def test_backend_integration():
+    """Test the backend integration."""
+    try:
+        # Load configuration
+        config = AgentConfig.from_environment()
+        
+        # Set dummy values for testing
+        config.app_id = "test-app-id"
+        config.app_password = "test-app-password"
+        config.tenant_id = "test-tenant-id"
+        config.client_id = "test-client-id"
+        config.client_secret = "test-client-secret"
+        
+        config.validate()
+        
+        logger.info(f"Testing backend integration with: {config.backend_url}")
+        
+        # Initialize RAG service
+        rag_service = RAGService(config)
+        await rag_service.initialize()
+        
+        # Test 1: Simple chat request
+        logger.info("Test 1: Simple chat request")
+        request = RAGRequest(
+            message="What are the main benefits mentioned in the policy document?",
+            conversation_history=[],
+            user_id="test-user-123",
+            channel_id="test-channel"
+        )
+        
+        response = await rag_service.process_query(request)
+        logger.info(f"Response: {response.answer}")
+        logger.info(f"Sources: {len(response.sources)}")
+        logger.info(f"Citations: {len(response.citations)}")
+        logger.info(f"Thoughts: {len(response.thoughts)}")
+        
+        # Test 2: Chat with conversation history
+        logger.info("\nTest 2: Chat with conversation history")
+        request_with_history = RAGRequest(
+            message="Can you provide more details about the first benefit?",
+            conversation_history=[
+                {"role": "user", "content": "What are the main benefits mentioned in the policy document?"},
+                {"role": "assistant", "content": response.answer}
+            ],
+            user_id="test-user-123",
+            channel_id="test-channel"
+        )
+        
+        response_with_history = await rag_service.process_query(request_with_history)
+        logger.info(f"Response with history: {response_with_history.answer}")
+        
+        # Test 3: Streaming request
+        logger.info("\nTest 3: Streaming request")
+        async for chunk in rag_service.process_query_stream(request):
+            logger.info(f"Stream chunk: {chunk}")
+            if chunk.get("type") == "error":
+                break
+        
+        logger.info("✅ All tests completed successfully!")
+        
+    except Exception as e:
+        logger.error(f"❌ Test failed: {e}")
+        raise
+    finally:
+        # Clean up
+        if 'rag_service' in locals():
+            await rag_service.close()
+
+
+async def test_backend_health():
+    """Test if the backend is healthy."""
+    import aiohttp
+    
+    try:
+        config = AgentConfig.from_environment()
+        
+        async with aiohttp.ClientSession() as session:
+            # Test health endpoint
+            async with session.get(f"{config.backend_url}/") as response:
+                if response.status == 200:
+                    logger.info("✅ Backend health check passed")
+                    return True
+                else:
+                    logger.error(f"❌ Backend health check failed: {response.status}")
+                    return False
+                    
+    except Exception as e:
+        logger.error(f"❌ Backend health check error: {e}")
+        return False
+
+
+async def main():
+    """Main test function."""
+    logger.info("Starting backend integration tests...")
+    
+    # Test 1: Backend health
+    logger.info("Step 1: Testing backend health...")
+    backend_healthy = await test_backend_health()
+    
+    if not backend_healthy:
+        logger.error("Backend is not healthy. Please start the backend first.")
+        logger.info("To start the backend, run: cd /workspace/app/backend && python main.py")
+        return
+    
+    # Test 2: Backend integration
+    logger.info("Step 2: Testing backend integration...")
+    await test_backend_integration()
+    
+    logger.info("🎉 All tests completed!")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())