492 lines
21 KiB
Python
492 lines
21 KiB
Python
"""
|
|
Real Services Integration Test for 12-Step Prompt Chaining Framework
|
|
|
|
This script tests the complete integration using real AI services and database connections.
|
|
This test should be run from the backend/services directory or with proper PYTHONPATH setup.
|
|
"""
|
|
|
|
import asyncio
|
|
import sys
|
|
import os
|
|
import json
|
|
from datetime import datetime
|
|
from typing import Dict, Any, Optional
|
|
|
|
# Add the backend directory to Python path for proper imports
|
|
backend_dir = os.path.dirname(os.path.dirname(__file__))
|
|
if backend_dir not in sys.path:
|
|
sys.path.insert(0, backend_dir)
|
|
|
|
services_dir = os.path.dirname(__file__)
|
|
if services_dir not in sys.path:
|
|
sys.path.insert(0, services_dir)
|
|
|
|
|
|
async def test_real_ai_engine_service():
|
|
"""Test real AI Engine Service with proper error handling."""
|
|
print("🤖 Testing Real AI Engine Service")
|
|
print("=" * 40)
|
|
|
|
try:
|
|
from content_gap_analyzer.ai_engine_service import AIEngineService
|
|
ai_engine = AIEngineService()
|
|
|
|
# Test strategic insights generation
|
|
print("🎯 Testing strategic insights generation...")
|
|
try:
|
|
result = await ai_engine.generate_strategic_insights(
|
|
strategy_data={
|
|
"content_pillars": ["AI", "Technology", "Innovation"],
|
|
"target_audience": {"demographics": {"age": "25-35", "industry": "technology"}},
|
|
"business_goals": ["Increase brand awareness", "Generate leads"]
|
|
},
|
|
onboarding_data={
|
|
"website_analysis": {
|
|
"industry": "technology",
|
|
"target_audience": ["developers", "tech enthusiasts"],
|
|
"content_focus": ["tutorials", "industry insights"]
|
|
}
|
|
},
|
|
industry="technology",
|
|
business_size="sme"
|
|
)
|
|
|
|
if result and isinstance(result, dict):
|
|
print(f"✅ Strategic insights generation: SUCCESS")
|
|
print(f" - Result keys: {list(result.keys())}")
|
|
if "strategic_insights" in result:
|
|
print(f" - Insights count: {len(result['strategic_insights'])}")
|
|
return True, result
|
|
else:
|
|
print(f"⚠️ Strategic insights generation: Empty result")
|
|
return False, None
|
|
|
|
except Exception as e:
|
|
print(f"❌ Strategic insights generation failed: {str(e)}")
|
|
return False, None
|
|
|
|
except ImportError as e:
|
|
print(f"❌ AI Engine Service not available: {e}")
|
|
return False, None
|
|
|
|
|
|
async def test_real_keyword_researcher():
|
|
"""Test real Keyword Researcher service."""
|
|
print("\n🔍 Testing Real Keyword Researcher")
|
|
print("=" * 40)
|
|
|
|
try:
|
|
from content_gap_analyzer.keyword_researcher import KeywordResearcher
|
|
keyword_researcher = KeywordResearcher()
|
|
|
|
# Test keyword analysis
|
|
print("🎯 Testing keyword analysis...")
|
|
try:
|
|
result = await keyword_researcher.analyze_keywords(
|
|
target_keywords=["artificial intelligence", "machine learning", "automation", "AI tools"],
|
|
industry="technology"
|
|
)
|
|
|
|
if result and isinstance(result, dict):
|
|
print(f"✅ Keyword analysis: SUCCESS")
|
|
print(f" - Result keys: {list(result.keys())}")
|
|
if "high_value_keywords" in result:
|
|
print(f" - High-value keywords: {len(result['high_value_keywords'])}")
|
|
return True, result
|
|
else:
|
|
print(f"⚠️ Keyword analysis: Empty result")
|
|
return False, None
|
|
|
|
except Exception as e:
|
|
print(f"❌ Keyword analysis failed: {str(e)}")
|
|
return False, None
|
|
|
|
except ImportError as e:
|
|
print(f"❌ Keyword Researcher not available: {e}")
|
|
return False, None
|
|
|
|
|
|
async def test_real_onboarding_service():
|
|
"""Test real Onboarding Data Service."""
|
|
print("\n👤 Testing Real Onboarding Data Service")
|
|
print("=" * 40)
|
|
|
|
try:
|
|
from onboarding_data_service import OnboardingDataService
|
|
onboarding_service = OnboardingDataService()
|
|
|
|
# Test get personalized inputs
|
|
print("🎯 Testing get personalized AI inputs...")
|
|
try:
|
|
result = onboarding_service.get_personalized_ai_inputs(1)
|
|
|
|
if result and isinstance(result, dict):
|
|
print(f"✅ Get personalized AI inputs: SUCCESS")
|
|
print(f" - Result keys: {list(result.keys())}")
|
|
if "website_analysis" in result:
|
|
print(f" - Website analysis available")
|
|
if "keyword_analysis" in result:
|
|
print(f" - Keyword analysis available")
|
|
return True, result
|
|
else:
|
|
print(f"⚠️ Get personalized AI inputs: Empty result")
|
|
return False, None
|
|
|
|
except Exception as e:
|
|
print(f"❌ Get personalized AI inputs failed: {str(e)}")
|
|
return False, None
|
|
|
|
except ImportError as e:
|
|
print(f"❌ Onboarding Data Service not available: {e}")
|
|
return False, None
|
|
|
|
|
|
async def test_real_data_processing():
|
|
"""Test real data processing modules."""
|
|
print("\n💾 Testing Real Data Processing Modules")
|
|
print("=" * 40)
|
|
|
|
try:
|
|
from calendar_generation_datasource_framework.data_processing import (
|
|
ComprehensiveUserDataProcessor,
|
|
StrategyDataProcessor,
|
|
GapAnalysisDataProcessor
|
|
)
|
|
|
|
# Test comprehensive user data processor
|
|
print("🎯 Testing ComprehensiveUserDataProcessor...")
|
|
try:
|
|
processor = ComprehensiveUserDataProcessor()
|
|
result = await processor.get_comprehensive_user_data(1, 1)
|
|
|
|
if result and isinstance(result, dict):
|
|
print(f"✅ ComprehensiveUserDataProcessor: SUCCESS")
|
|
print(f" - Result keys: {list(result.keys())}")
|
|
return True, result
|
|
else:
|
|
print(f"⚠️ ComprehensiveUserDataProcessor: Empty result")
|
|
return False, None
|
|
|
|
except Exception as e:
|
|
print(f"❌ ComprehensiveUserDataProcessor failed: {str(e)}")
|
|
return False, None
|
|
|
|
except ImportError as e:
|
|
print(f"❌ Data Processing modules not available: {e}")
|
|
return False, None
|
|
|
|
|
|
async def test_phase1_with_real_services():
|
|
"""Test Phase 1 steps with real service integration."""
|
|
print("\n🎯 Testing Phase 1 Steps with Real Services")
|
|
print("=" * 50)
|
|
|
|
try:
|
|
from calendar_generation_datasource_framework.prompt_chaining.steps.phase1_steps import (
|
|
ContentStrategyAnalysisStep,
|
|
GapAnalysisStep,
|
|
AudiencePlatformStrategyStep
|
|
)
|
|
|
|
# Get real data
|
|
real_context = {
|
|
"user_id": 1,
|
|
"strategy_id": 1,
|
|
"calendar_type": "monthly",
|
|
"industry": "technology",
|
|
"business_size": "sme",
|
|
"user_data": {
|
|
"strategy_data": {
|
|
"content_pillars": ["AI", "Technology", "Innovation", "Tutorials"],
|
|
"target_audience": {
|
|
"demographics": {"age": "25-35", "location": "US", "industry": "technology"},
|
|
"interests": ["AI", "machine learning", "programming", "tech trends"]
|
|
},
|
|
"business_goals": ["Increase brand awareness", "Generate leads", "Establish thought leadership"],
|
|
"success_metrics": ["Website traffic", "Social engagement", "Lead generation"]
|
|
},
|
|
"onboarding_data": {
|
|
"website_analysis": {
|
|
"industry": "technology",
|
|
"target_audience": ["developers", "tech enthusiasts", "AI researchers"],
|
|
"content_focus": ["tutorials", "industry insights", "product reviews"],
|
|
"competitive_landscape": ["competitor1.com", "competitor2.com"]
|
|
},
|
|
"competitor_analysis": {
|
|
"top_performers": ["OpenAI Blog", "Google AI Blog", "MIT Technology Review"],
|
|
"content_types": ["research papers", "tutorials", "industry news"]
|
|
},
|
|
"keyword_analysis": {
|
|
"high_value_keywords": ["artificial intelligence", "machine learning", "AI tools", "automation"],
|
|
"search_volume": {"artificial intelligence": 100000, "machine learning": 80000}
|
|
}
|
|
},
|
|
"gap_analysis": {
|
|
"content_gaps": ["Video tutorials", "Interactive demos", "Case studies", "Beginner guides"],
|
|
"keyword_opportunities": ["AI for beginners", "machine learning tutorial", "AI tools comparison"],
|
|
"implementation_priority": {"high": ["Video tutorials"], "medium": ["Case studies"]}
|
|
},
|
|
"performance_data": {
|
|
"engagement_metrics": {"average_engagement": 0.05, "peak_engagement_time": "9am-11am"},
|
|
"best_performing_content": ["How-to guides", "Industry insights", "Product comparisons"],
|
|
"platform_performance": {"linkedin": 0.08, "twitter": 0.03, "blog": 0.12}
|
|
},
|
|
"competitor_data": {
|
|
"competitor_urls": ["https://openai.com/blog", "https://ai.googleblog.com"],
|
|
"analysis_date": datetime.now().isoformat()
|
|
}
|
|
},
|
|
"step_results": {},
|
|
"quality_scores": {},
|
|
"current_step": 0,
|
|
"phase": "initialization"
|
|
}
|
|
|
|
phase1_results = {}
|
|
total_execution_time = 0
|
|
|
|
# Test Step 1: Content Strategy Analysis with real services
|
|
print("🎯 Testing Step 1: Content Strategy Analysis with Real Services")
|
|
try:
|
|
step1 = ContentStrategyAnalysisStep()
|
|
result1 = await step1.run(real_context)
|
|
phase1_results["step_01"] = result1
|
|
total_execution_time += result1.get('execution_time', 0.0)
|
|
|
|
print(f"✅ Step 1 Status: {result1.get('status', 'unknown')}")
|
|
print(f"📊 Step 1 Quality: {result1.get('quality_score', 0.0):.2f}")
|
|
print(f"⏱️ Step 1 Time: {result1.get('execution_time', 0.0):.2f}s")
|
|
|
|
# Check if real services were used
|
|
step_result = result1.get('result', {})
|
|
strategy_summary = step_result.get('content_strategy_summary', {})
|
|
if strategy_summary.get('content_pillars'):
|
|
print(f" ✅ Real strategy data processed: {len(strategy_summary['content_pillars'])} pillars")
|
|
|
|
except Exception as e:
|
|
print(f"❌ Step 1 failed: {str(e)}")
|
|
|
|
# Test Step 2: Gap Analysis with real services
|
|
print("\n🎯 Testing Step 2: Gap Analysis & Opportunity Identification with Real Services")
|
|
try:
|
|
step2 = GapAnalysisStep()
|
|
result2 = await step2.run(real_context)
|
|
phase1_results["step_02"] = result2
|
|
total_execution_time += result2.get('execution_time', 0.0)
|
|
|
|
print(f"✅ Step 2 Status: {result2.get('status', 'unknown')}")
|
|
print(f"📊 Step 2 Quality: {result2.get('quality_score', 0.0):.2f}")
|
|
print(f"⏱️ Step 2 Time: {result2.get('execution_time', 0.0):.2f}s")
|
|
|
|
# Check if real services were used
|
|
step_result = result2.get('result', {})
|
|
gap_analysis = step_result.get('prioritized_gaps', {})
|
|
if gap_analysis.get('content_gaps'):
|
|
print(f" ✅ Real gap data processed: {len(gap_analysis['content_gaps'])} gaps")
|
|
|
|
except Exception as e:
|
|
print(f"❌ Step 2 failed: {str(e)}")
|
|
|
|
# Test Step 3: Audience & Platform Strategy with real services
|
|
print("\n🎯 Testing Step 3: Audience & Platform Strategy with Real Services")
|
|
try:
|
|
step3 = AudiencePlatformStrategyStep()
|
|
result3 = await step3.run(real_context)
|
|
phase1_results["step_03"] = result3
|
|
total_execution_time += result3.get('execution_time', 0.0)
|
|
|
|
print(f"✅ Step 3 Status: {result3.get('status', 'unknown')}")
|
|
print(f"📊 Step 3 Quality: {result3.get('quality_score', 0.0):.2f}")
|
|
print(f"⏱️ Step 3 Time: {result3.get('execution_time', 0.0):.2f}s")
|
|
|
|
# Check if real services were used
|
|
step_result = result3.get('result', {})
|
|
audience_personas = step_result.get('audience_personas', {})
|
|
if audience_personas.get('demographics'):
|
|
print(f" ✅ Real audience data processed")
|
|
|
|
except Exception as e:
|
|
print(f"❌ Step 3 failed: {str(e)}")
|
|
|
|
# Calculate overall metrics
|
|
completed_steps = len([r for r in phase1_results.values() if r.get('status') == 'completed'])
|
|
total_quality = sum(r.get('quality_score', 0.0) for r in phase1_results.values())
|
|
avg_quality = total_quality / len(phase1_results) if phase1_results else 0.0
|
|
|
|
print(f"\n📋 Phase 1 Real Services Integration Summary")
|
|
print("=" * 50)
|
|
print(f"✅ Completed Steps: {completed_steps}/3")
|
|
print(f"📊 Average Quality: {avg_quality:.2f}")
|
|
print(f"⏱️ Total Time: {total_execution_time:.2f}s")
|
|
|
|
return completed_steps == 3, phase1_results
|
|
|
|
except ImportError as e:
|
|
print(f"❌ Phase 1 steps not available: {e}")
|
|
return False, {}
|
|
|
|
|
|
async def test_end_to_end_calendar_generation():
|
|
"""Test complete end-to-end calendar generation with real services."""
|
|
print("\n🚀 Testing End-to-End Calendar Generation with Real Services")
|
|
print("=" * 60)
|
|
|
|
try:
|
|
from calendar_generation_datasource_framework.prompt_chaining import PromptChainOrchestrator
|
|
|
|
# Initialize orchestrator
|
|
print("📋 Initializing Prompt Chain Orchestrator...")
|
|
orchestrator = PromptChainOrchestrator()
|
|
|
|
# Test full calendar generation
|
|
print("🎯 Testing complete calendar generation...")
|
|
|
|
try:
|
|
result = await orchestrator.generate_calendar(
|
|
user_id=1,
|
|
strategy_id=1,
|
|
calendar_type="monthly",
|
|
industry="technology",
|
|
business_size="sme"
|
|
)
|
|
|
|
print("✅ End-to-end calendar generation completed!")
|
|
|
|
# Analyze result quality
|
|
quality_score = result.get('quality_score', 0.0)
|
|
ai_confidence = result.get('ai_confidence', 0.0)
|
|
processing_time = result.get('processing_time', 0.0)
|
|
|
|
print(f"📊 Quality Score: {quality_score:.2f}")
|
|
print(f"🤖 AI Confidence: {ai_confidence:.2f}")
|
|
print(f"⏱️ Processing Time: {processing_time:.2f}s")
|
|
print(f"🎯 Framework Version: {result.get('framework_version', 'unknown')}")
|
|
|
|
# Check calendar content completeness
|
|
calendar_fields = [
|
|
'daily_schedule', 'weekly_themes', 'content_recommendations',
|
|
'optimal_timing', 'performance_predictions', 'trending_topics',
|
|
'content_pillars', 'platform_strategies', 'gap_analysis_insights'
|
|
]
|
|
|
|
present_fields = [field for field in calendar_fields if field in result and result[field]]
|
|
completeness_score = len(present_fields) / len(calendar_fields) * 100
|
|
|
|
print(f"📋 Content Completeness: {completeness_score:.1f}% ({len(present_fields)}/{len(calendar_fields)} fields)")
|
|
|
|
# Check step results
|
|
step_results = result.get('step_results_summary', {})
|
|
completed_steps = len([s for s in step_results.values() if s.get('status') == 'completed'])
|
|
|
|
print(f"🎯 Steps Completed: {completed_steps}/12")
|
|
|
|
return True, {
|
|
'quality_score': quality_score,
|
|
'ai_confidence': ai_confidence,
|
|
'processing_time': processing_time,
|
|
'completeness_score': completeness_score,
|
|
'completed_steps': completed_steps
|
|
}
|
|
|
|
except Exception as e:
|
|
print(f"❌ End-to-end calendar generation failed: {str(e)}")
|
|
return False, None
|
|
|
|
except ImportError as e:
|
|
print(f"❌ Prompt Chain Orchestrator not available: {e}")
|
|
return False, None
|
|
|
|
|
|
async def generate_real_services_report(test_results: Dict[str, Any]):
|
|
"""Generate comprehensive real services integration report."""
|
|
print("\n📋 Real Services Integration Report")
|
|
print("=" * 60)
|
|
|
|
# Service connectivity
|
|
services_tested = 0
|
|
services_working = 0
|
|
|
|
for test_name, (success, data) in test_results.items():
|
|
services_tested += 1
|
|
if success:
|
|
services_working += 1
|
|
print(f"✅ {test_name}: SUCCESS")
|
|
else:
|
|
print(f"❌ {test_name}: FAILED")
|
|
|
|
connectivity_score = services_working / services_tested * 100 if services_tested > 0 else 0
|
|
print(f"\n🔧 Service Connectivity: {services_working}/{services_tested} ({connectivity_score:.1f}%)")
|
|
|
|
# Phase 1 integration analysis
|
|
if 'phase1_real_services' in test_results:
|
|
phase1_success, phase1_data = test_results['phase1_real_services']
|
|
if phase1_success:
|
|
avg_quality = sum(r.get('quality_score', 0.0) for r in phase1_data.values()) / len(phase1_data)
|
|
total_time = sum(r.get('execution_time', 0.0) for r in phase1_data.values())
|
|
print(f"🎯 Phase 1 Quality: {avg_quality:.2f}")
|
|
print(f"⏱️ Phase 1 Time: {total_time:.2f}s")
|
|
|
|
# End-to-end analysis
|
|
if 'e2e_calendar_generation' in test_results:
|
|
e2e_success, e2e_data = test_results['e2e_calendar_generation']
|
|
if e2e_success and e2e_data:
|
|
print(f"🚀 E2E Quality: {e2e_data['quality_score']:.2f}")
|
|
print(f"🤖 E2E Confidence: {e2e_data['ai_confidence']:.2f}")
|
|
print(f"📋 E2E Completeness: {e2e_data['completeness_score']:.1f}%")
|
|
|
|
# Overall assessment
|
|
if connectivity_score >= 80:
|
|
print(f"\n🎉 EXCELLENT: Real services integration ready for production!")
|
|
elif connectivity_score >= 60:
|
|
print(f"\n✅ GOOD: Most services working, minor issues to resolve")
|
|
elif connectivity_score >= 40:
|
|
print(f"\n⚠️ FAIR: Some services working, significant improvements needed")
|
|
else:
|
|
print(f"\n❌ POOR: Major service integration issues, requires attention")
|
|
|
|
# Save detailed report
|
|
report = {
|
|
"timestamp": datetime.now().isoformat(),
|
|
"service_connectivity": {
|
|
"working": services_working,
|
|
"tested": services_tested,
|
|
"percentage": connectivity_score
|
|
},
|
|
"test_results": test_results,
|
|
"overall_status": "excellent" if connectivity_score >= 80 else "good" if connectivity_score >= 60 else "fair" if connectivity_score >= 40 else "poor"
|
|
}
|
|
|
|
with open("real_services_integration_report.json", "w") as f:
|
|
json.dump(report, f, indent=2, default=str)
|
|
|
|
print(f"\n💾 Detailed report saved to: real_services_integration_report.json")
|
|
|
|
|
|
async def main():
|
|
"""Main real services integration test function."""
|
|
print("🧪 Real Services Integration Test Suite")
|
|
print("=" * 60)
|
|
print(f"🕒 Started at: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
|
|
|
|
test_results = {}
|
|
|
|
# Test individual real services
|
|
test_results['ai_engine'] = await test_real_ai_engine_service()
|
|
test_results['keyword_researcher'] = await test_real_keyword_researcher()
|
|
test_results['onboarding_service'] = await test_real_onboarding_service()
|
|
test_results['data_processing'] = await test_real_data_processing()
|
|
|
|
# Test Phase 1 with real services
|
|
test_results['phase1_real_services'] = await test_phase1_with_real_services()
|
|
|
|
# Test end-to-end calendar generation
|
|
test_results['e2e_calendar_generation'] = await test_end_to_end_calendar_generation()
|
|
|
|
# Generate comprehensive report
|
|
await generate_real_services_report(test_results)
|
|
|
|
print(f"\n🏁 Real services integration test completed at: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
|
|
|
|
if __name__ == "__main__":
|
|
asyncio.run(main())
|