305 lines
13 KiB
Python
305 lines
13 KiB
Python
#!/usr/bin/env python3
|
|
"""
|
|
Real Database Integration Test for Steps 1-8
|
|
|
|
This script tests the calendar generation framework with real database services,
|
|
replacing all mock data with actual database operations.
|
|
"""
|
|
|
|
import asyncio
|
|
import sys
|
|
import os
|
|
from typing import Dict, Any
|
|
from loguru import logger
|
|
|
|
# Add the backend directory to the path
|
|
backend_dir = os.path.dirname(os.path.abspath(__file__))
|
|
if backend_dir not in sys.path:
|
|
sys.path.insert(0, backend_dir)
|
|
|
|
# Add the services directory to the path
|
|
services_dir = os.path.join(backend_dir, "services")
|
|
if services_dir not in sys.path:
|
|
sys.path.insert(0, services_dir)
|
|
|
|
async def test_real_database_integration():
|
|
"""Test Steps 1-8 with real database services."""
|
|
|
|
try:
|
|
logger.info("🚀 Starting real database integration test")
|
|
|
|
# Initialize database
|
|
logger.info("🗄️ Initializing database connection")
|
|
from services.database import init_database, get_db_session
|
|
|
|
try:
|
|
init_database()
|
|
logger.info("✅ Database initialized successfully")
|
|
except Exception as e:
|
|
logger.error(f"❌ Database initialization failed: {str(e)}")
|
|
return False
|
|
|
|
# Get database session
|
|
db_session = get_db_session()
|
|
if not db_session:
|
|
logger.error("❌ Failed to get database session")
|
|
return False
|
|
|
|
logger.info("✅ Database session created successfully")
|
|
|
|
# Test data
|
|
test_context = {
|
|
"user_id": 1,
|
|
"strategy_id": 1,
|
|
"calendar_duration": 7,
|
|
"posting_preferences": {
|
|
"posting_frequency": "daily",
|
|
"preferred_days": ["monday", "wednesday", "friday"],
|
|
"preferred_times": ["09:00", "12:00", "15:00"],
|
|
"content_per_day": 2
|
|
}
|
|
}
|
|
|
|
# Create test data in database
|
|
logger.info("📝 Creating test data in database")
|
|
await create_test_data(db_session, test_context)
|
|
|
|
# Test Step 1: Content Strategy Analysis with Real Database
|
|
logger.info("📋 Testing Step 1: Content Strategy Analysis (Real Database)")
|
|
try:
|
|
from services.calendar_generation_datasource_framework.prompt_chaining.steps.phase1.phase1_steps import ContentStrategyAnalysisStep
|
|
from services.calendar_generation_datasource_framework.data_processing.strategy_data import StrategyDataProcessor
|
|
from services.content_planning_db import ContentPlanningDBService
|
|
|
|
# Create real database service
|
|
content_planning_db = ContentPlanningDBService(db_session)
|
|
|
|
# Create strategy processor with real database service
|
|
strategy_processor = StrategyDataProcessor()
|
|
strategy_processor.content_planning_db_service = content_planning_db
|
|
|
|
step1 = ContentStrategyAnalysisStep()
|
|
step1.strategy_processor = strategy_processor
|
|
|
|
result1 = await step1.execute(test_context)
|
|
logger.info(f"✅ Step 1 completed: {result1.get('status')}")
|
|
logger.info(f" Quality Score: {result1.get('quality_score')}")
|
|
|
|
except Exception as e:
|
|
logger.error(f"❌ Step 1 failed: {str(e)}")
|
|
return False
|
|
|
|
# Test Step 2: Gap Analysis with Real Database
|
|
logger.info("📋 Testing Step 2: Gap Analysis (Real Database)")
|
|
try:
|
|
from services.calendar_generation_datasource_framework.prompt_chaining.steps.phase1.phase1_steps import GapAnalysisStep
|
|
from services.calendar_generation_datasource_framework.data_processing.gap_analysis_data import GapAnalysisDataProcessor
|
|
|
|
# Create gap processor with real database service
|
|
gap_processor = GapAnalysisDataProcessor()
|
|
gap_processor.content_planning_db_service = content_planning_db
|
|
|
|
step2 = GapAnalysisStep()
|
|
step2.gap_processor = gap_processor
|
|
|
|
result2 = await step2.execute(test_context)
|
|
logger.info(f"✅ Step 2 completed: {result2.get('status')}")
|
|
logger.info(f" Quality Score: {result2.get('quality_score')}")
|
|
|
|
except Exception as e:
|
|
logger.error(f"❌ Step 2 failed: {str(e)}")
|
|
return False
|
|
|
|
# Test Step 3: Audience & Platform Strategy with Real Database
|
|
logger.info("📋 Testing Step 3: Audience & Platform Strategy (Real Database)")
|
|
try:
|
|
from services.calendar_generation_datasource_framework.prompt_chaining.steps.phase1.phase1_steps import AudiencePlatformStrategyStep
|
|
from services.calendar_generation_datasource_framework.data_processing.comprehensive_user_data import ComprehensiveUserDataProcessor
|
|
|
|
# Create comprehensive processor with real database service
|
|
comprehensive_processor = ComprehensiveUserDataProcessor(db_session)
|
|
comprehensive_processor.content_planning_db_service = content_planning_db
|
|
|
|
step3 = AudiencePlatformStrategyStep()
|
|
step3.comprehensive_processor = comprehensive_processor
|
|
|
|
result3 = await step3.execute(test_context)
|
|
logger.info(f"✅ Step 3 completed: {result3.get('status')}")
|
|
logger.info(f" Quality Score: {result3.get('quality_score')}")
|
|
|
|
except Exception as e:
|
|
logger.error(f"❌ Step 3 failed: {str(e)}")
|
|
return False
|
|
|
|
# Test Steps 4-8 with Real Database
|
|
logger.info("📋 Testing Steps 4-8: Calendar Framework to Daily Content Planning (Real Database)")
|
|
try:
|
|
# Test Step 4: Calendar Framework
|
|
from services.calendar_generation_datasource_framework.prompt_chaining.steps.phase2.step4_implementation import CalendarFrameworkStep
|
|
step4 = CalendarFrameworkStep()
|
|
result4 = await step4.execute(test_context)
|
|
logger.info(f"✅ Step 4 completed: {result4.get('status')}")
|
|
|
|
# Test Step 5: Content Pillar Distribution
|
|
from services.calendar_generation_datasource_framework.prompt_chaining.steps.phase2.step5_implementation import ContentPillarDistributionStep
|
|
step5 = ContentPillarDistributionStep()
|
|
result5 = await step5.execute(test_context)
|
|
logger.info(f"✅ Step 5 completed: {result5.get('status')}")
|
|
|
|
# Test Step 6: Platform-Specific Strategy
|
|
from services.calendar_generation_datasource_framework.prompt_chaining.steps.phase2.step6_implementation import PlatformSpecificStrategyStep
|
|
step6 = PlatformSpecificStrategyStep()
|
|
result6 = await step6.execute(test_context)
|
|
logger.info(f"✅ Step 6 completed: {result6.get('status')}")
|
|
|
|
# Test Step 7: Weekly Theme Development
|
|
from services.calendar_generation_datasource_framework.prompt_chaining.steps.phase3.step7_implementation import WeeklyThemeDevelopmentStep
|
|
step7 = WeeklyThemeDevelopmentStep()
|
|
result7 = await step7.execute(test_context)
|
|
logger.info(f"✅ Step 7 completed: {result7.get('status')}")
|
|
|
|
# Test Step 8: Daily Content Planning
|
|
from services.calendar_generation_datasource_framework.prompt_chaining.steps.phase3.step8_implementation import DailyContentPlanningStep
|
|
step8 = DailyContentPlanningStep()
|
|
result8 = await step8.execute(test_context)
|
|
logger.info(f"✅ Step 8 completed: {result8.get('status')}")
|
|
|
|
except Exception as e:
|
|
logger.error(f"❌ Steps 4-8 failed: {str(e)}")
|
|
return False
|
|
|
|
# Clean up test data
|
|
logger.info("🧹 Cleaning up test data")
|
|
await cleanup_test_data(db_session, test_context)
|
|
|
|
# Close database session
|
|
db_session.close()
|
|
|
|
logger.info("🎉 All Steps 1-8 completed successfully with real database!")
|
|
logger.info("📝 Real database integration working perfectly!")
|
|
return True
|
|
|
|
except Exception as e:
|
|
logger.error(f"❌ Test failed with error: {str(e)}")
|
|
return False
|
|
|
|
async def create_test_data(db_session, test_context: Dict[str, Any]):
|
|
"""Create test data in the database."""
|
|
try:
|
|
from services.content_planning_db import ContentPlanningDBService
|
|
from models.content_planning import ContentStrategy, ContentGapAnalysis
|
|
|
|
db_service = ContentPlanningDBService(db_session)
|
|
|
|
# Create test content strategy
|
|
strategy_data = {
|
|
"user_id": test_context["user_id"],
|
|
"name": "Test Strategy - Real Database",
|
|
"industry": "technology",
|
|
"target_audience": {
|
|
"primary": "Tech professionals",
|
|
"secondary": "Business leaders",
|
|
"demographics": {"age_range": "25-45", "location": "Global"}
|
|
},
|
|
"content_pillars": [
|
|
"AI and Machine Learning",
|
|
"Digital Transformation",
|
|
"Innovation and Technology Trends",
|
|
"Business Strategy and Growth"
|
|
],
|
|
"ai_recommendations": {
|
|
"strategic_insights": [
|
|
"Focus on deep-dive technical content",
|
|
"Emphasize practical implementation guides",
|
|
"Highlight ROI and business impact"
|
|
]
|
|
}
|
|
}
|
|
|
|
strategy = await db_service.create_content_strategy(strategy_data)
|
|
if strategy:
|
|
logger.info(f"✅ Created test strategy: {strategy.id}")
|
|
test_context["strategy_id"] = strategy.id
|
|
|
|
# Create test gap analysis
|
|
gap_data = {
|
|
"user_id": test_context["user_id"],
|
|
"website_url": "https://example.com",
|
|
"competitor_urls": ["https://competitor1.com", "https://competitor2.com"],
|
|
"target_keywords": [
|
|
{"keyword": "AI ethics in business", "search_volume": 5000, "competition": "low"},
|
|
{"keyword": "digital transformation ROI", "search_volume": 8000, "competition": "medium"}
|
|
],
|
|
"analysis_results": {
|
|
"content_gaps": [
|
|
{"topic": "AI Ethics", "priority": "high", "impact_score": 0.9},
|
|
{"topic": "Digital Transformation ROI", "priority": "medium", "impact_score": 0.7}
|
|
],
|
|
"keyword_opportunities": [
|
|
{"keyword": "AI ethics in business", "search_volume": 5000, "competition": "low"},
|
|
{"keyword": "digital transformation ROI", "search_volume": 8000, "competition": "medium"}
|
|
],
|
|
"competitor_insights": [
|
|
{"competitor": "Competitor A", "strength": "Technical content", "weakness": "Practical guides"},
|
|
{"competitor": "Competitor B", "strength": "Case studies", "weakness": "AI focus"}
|
|
],
|
|
"opportunities": [
|
|
{"type": "content", "topic": "AI Ethics", "priority": "high"},
|
|
{"type": "content", "topic": "ROI Analysis", "priority": "medium"}
|
|
]
|
|
},
|
|
"recommendations": [
|
|
"Create comprehensive AI ethics guide",
|
|
"Develop ROI calculator for digital transformation"
|
|
],
|
|
"opportunities": [
|
|
{"type": "content", "topic": "AI Ethics", "priority": "high"},
|
|
{"type": "content", "topic": "ROI Analysis", "priority": "medium"}
|
|
]
|
|
}
|
|
|
|
gap_analysis = await db_service.create_content_gap_analysis(gap_data)
|
|
if gap_analysis:
|
|
logger.info(f"✅ Created test gap analysis: {gap_analysis.id}")
|
|
|
|
logger.info("✅ Test data created successfully")
|
|
|
|
except Exception as e:
|
|
logger.error(f"❌ Error creating test data: {str(e)}")
|
|
raise
|
|
|
|
async def cleanup_test_data(db_session, test_context: Dict[str, Any]):
|
|
"""Clean up test data from the database."""
|
|
try:
|
|
from services.content_planning_db import ContentPlanningDBService
|
|
|
|
db_service = ContentPlanningDBService(db_session)
|
|
|
|
# Clean up gap analysis (get by user_id and delete)
|
|
gap_analyses = await db_service.get_user_content_gap_analyses(test_context["user_id"])
|
|
for gap_analysis in gap_analyses:
|
|
await db_service.delete_content_gap_analysis(gap_analysis.id)
|
|
|
|
# Clean up strategy
|
|
await db_service.delete_content_strategy(test_context["strategy_id"])
|
|
|
|
logger.info("✅ Test data cleaned up successfully")
|
|
|
|
except Exception as e:
|
|
logger.error(f"❌ Error cleaning up test data: {str(e)}")
|
|
|
|
if __name__ == "__main__":
|
|
# Configure logging
|
|
logger.remove()
|
|
logger.add(sys.stderr, level="INFO", format="<green>{time:HH:mm:ss}</green> | <level>{level: <8}</level> | <cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> - <level>{message}</level>")
|
|
|
|
# Run the test
|
|
success = asyncio.run(test_real_database_integration())
|
|
|
|
if success:
|
|
logger.info("✅ Real database integration test completed successfully!")
|
|
sys.exit(0)
|
|
else:
|
|
logger.error("❌ Real database integration test failed!")
|
|
sys.exit(1)
|