kunthawat/moreminimore-marketing
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Base code

Browse Source
This commit is contained in:
Kunthawat Greethong
2026-01-08 22:39:53 +07:00
parent 697115c61a
commit c35fa52117
2169 changed files with 626670 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

258
backend/api/content_planning/tests/README.md Normal file
View File

@@ -0,0 +1,258 @@
# Content Planning Module - Testing Foundation
This directory contains comprehensive testing infrastructure for the content planning module refactoring project.
## 📋 Overview
The testing foundation ensures that all functionality is preserved during the refactoring process by:
1. **Establishing Baseline**: Comprehensive functionality tests before refactoring
2. **Continuous Validation**: Testing at each refactoring step
3. **Before/After Comparison**: Automated response comparison
4. **Performance Monitoring**: Tracking response times and performance metrics
## 🧪 Test Scripts
### 1. `functionality_test.py`
**Purpose**: Comprehensive functionality test suite that tests all existing endpoints and functionality.
**Features**:
- Tests all strategy endpoints (CRUD operations)
- Tests all calendar event endpoints
- Tests gap analysis functionality
- Tests AI analytics endpoints
- Tests calendar generation
- Tests content optimization
- Tests error scenarios and validation
- Tests performance metrics
- Tests response format consistency
**Usage**:
```bash
cd backend/content_planning/tests
python functionality_test.py
```
### 2. `before_after_test.py`
**Purpose**: Automated comparison of API responses before and after refactoring.
**Features**:
- Loads baseline data from functionality test results
- Captures responses from refactored API
- Compares response structure and content
- Compares performance metrics
- Generates detailed comparison reports
**Usage**:
```bash
cd backend/content_planning/tests
python before_after_test.py
```
### 3. `test_data.py`
**Purpose**: Centralized test data and fixtures for consistent testing.
**Features**:
- Sample strategy data for different industries
- Sample calendar event data
- Sample gap analysis data
- Sample AI analytics data
- Sample error scenarios
- Performance baseline data
- Validation functions
**Usage**:
```python
from test_data import TestData, create_test_strategy
# Get sample strategy data
strategy_data = TestData.get_strategy_data("technology")
# Create test strategy with custom parameters
custom_strategy = create_test_strategy("healthcare", user_id=2)
```
### 4. `run_tests.py`
**Purpose**: Simple test runner to execute all tests and establish baseline.
**Features**:
- Runs baseline functionality test
- Runs before/after comparison test
- Provides summary reports
- Handles test execution flow
**Usage**:
```bash
cd backend/content_planning/tests
python run_tests.py
```
## 🚀 Quick Start
### Step 1: Establish Baseline
```bash
cd backend/content_planning/tests
python run_tests.py
```
This will:
1. Run comprehensive functionality tests
2. Save baseline results to `functionality_test_results.json`
3. Print summary of test results
### Step 2: Run During Refactoring
After each refactoring step, run:
```bash
python run_tests.py
```
This will:
1. Load existing baseline data
2. Test refactored functionality
3. Compare responses with baseline
4. Report any differences
### Step 3: Validate Final Refactoring
After completing the refactoring:
```bash
python run_tests.py
```
This will confirm that all functionality is preserved.
## 📊 Test Coverage
### Endpoint Coverage
- ✅ **Health Endpoints**: All health check endpoints
- ✅ **Strategy Endpoints**: CRUD operations, analytics, optimization
- ✅ **Calendar Endpoints**: Event management, scheduling, conflicts
- ✅ **Gap Analysis**: Analysis execution, competitor analysis, keyword research
- ✅ **AI Analytics**: Performance prediction, strategic intelligence
- ✅ **Calendar Generation**: AI-powered calendar creation
- ✅ **Content Optimization**: Platform-specific optimization
- ✅ **Performance Prediction**: Content performance forecasting
- ✅ **Content Repurposing**: Cross-platform content adaptation
- ✅ **Trending Topics**: Industry-specific trending topics
- ✅ **Comprehensive User Data**: All user data aggregation
### Test Scenarios
- ✅ **Happy Path**: Normal successful operations
- ✅ **Error Handling**: Invalid inputs, missing data, server errors
- ✅ **Data Validation**: Input validation and sanitization
- ✅ **Response Format**: Consistent API response structure
- ✅ **Performance**: Response times and throughput
- ✅ **Edge Cases**: Boundary conditions and unusual scenarios
## 📈 Performance Monitoring
### Baseline Metrics
- **Response Time Threshold**: 0.5 seconds
- **Status Code**: 200 for successful operations
- **Error Rate**: < 1%
### Performance Tracking
- Response times for each endpoint
- Status code consistency
- Error rate monitoring
- Memory usage tracking
## 🔧 Configuration
### Test Environment
- **Base URL**: `http://localhost:8000` (configurable)
- **Test Data**: Centralized in `test_data.py`
- **Results**: Saved as JSON files
### Customization
You can customize test parameters by modifying:
- `base_url` in test classes
- Test data in `test_data.py`
- Performance thresholds
- Error scenarios
## 📋 Test Results
### Output Files
- `functionality_test_results.json`: Baseline test results
- `before_after_comparison_results.json`: Comparison results
- Console output: Real-time test progress and summaries
### Result Format
```json
{
"test_name": {
"status": "passed|failed",
"status_code": 200,
"response_time": 0.12,
"response_data": {...},
"error": "error message if failed"
}
}
```
## 🎯 Success Criteria
### Functionality Preservation
- ✅ **100% Feature Compatibility**: All existing features work identically
- ✅ **Response Consistency**: Identical API responses before and after
- ✅ **Error Handling**: Consistent error scenarios and messages
- ✅ **Performance**: Maintained or improved performance metrics
### Quality Assurance
- ✅ **Automated Testing**: Comprehensive test suite
- ✅ **Continuous Validation**: Testing at each refactoring step
- ✅ **Risk Mitigation**: Prevents regressions and functionality loss
- ✅ **Confidence Building**: Ensures no features are lost during refactoring
## 🚨 Troubleshooting
### Common Issues
1. **Connection Errors**
- Ensure the backend server is running on `http://localhost:8000`
- Check network connectivity
- Verify API endpoints are accessible
2. **Test Failures**
- Review error messages in test results
- Check if baseline data exists
- Verify test data is valid
3. **Performance Issues**
- Monitor server performance
- Check database connectivity
- Review AI service availability
### Debug Mode
Enable debug logging by setting:
```python
import logging
logging.basicConfig(level=logging.DEBUG)
```
## 📚 Next Steps
After establishing the testing foundation:
1. **Day 1**: Extract utilities and test each extraction
2. **Day 2**: Extract services and validate functionality
3. **Day 3**: Extract routes and verify endpoints
4. **Day 4**: Comprehensive testing and validation
Each day should include running the test suite to ensure functionality preservation.
## 🤝 Contributing
When adding new tests:
1. Add test data to `test_data.py`
2. Add test methods to `functionality_test.py`
3. Update comparison logic in `before_after_test.py`
4. Document new test scenarios
## 📞 Support
For issues with the testing foundation:
1. Check the troubleshooting section
2. Review test logs and error messages
3. Verify test data and configuration
4. Ensure backend services are running correctly

0
backend/api/content_planning/tests/__init__.py Normal file
View File

6475
backend/api/content_planning/tests/before_after_comparison_results.json Normal file
View File

File diff suppressed because it is too large Load Diff

535
backend/api/content_planning/tests/before_after_test.py Normal file
View File

@@ -0,0 +1,535 @@
"""
Before/After Comparison Test for Content Planning Module
Automated comparison of API responses before and after refactoring.
"""
import asyncio
import json
import time
from typing import Dict, Any, List, Optional
from datetime import datetime
import requests
from loguru import logger
import difflib
class BeforeAfterComparisonTest:
"""Automated comparison of API responses before and after refactoring."""
def __init__(self, base_url: str = "http://localhost:8000"):
self.base_url = base_url
self.baseline_responses = {}
self.refactored_responses = {}
self.comparison_results = {}
self.session = requests.Session()
def load_baseline_data(self, baseline_file: str = "functionality_test_results.json"):
"""Load baseline data from functionality test results."""
try:
with open(baseline_file, 'r') as f:
baseline_data = json.load(f)
# Extract response data from baseline
for test_name, result in baseline_data.items():
if result.get("status") == "passed" and result.get("response_data"):
self.baseline_responses[test_name] = result["response_data"]
logger.info(f"✅ Loaded baseline data with {len(self.baseline_responses)} responses")
return True
except FileNotFoundError:
logger.error(f"❌ Baseline file {baseline_file} not found")
return False
except Exception as e:
logger.error(f"❌ Error loading baseline data: {str(e)}")
return False
async def capture_refactored_responses(self) -> Dict[str, Any]:
"""Capture responses from refactored API."""
logger.info("🔍 Capturing responses from refactored API")
# Define test scenarios
test_scenarios = [
{
"name": "health_check",
"method": "GET",
"endpoint": "/api/content-planning/health",
"data": None
},
{
"name": "strategies_get",
"method": "GET",
"endpoint": "/api/content-planning/strategies/?user_id=1",
"data": None
},
{
"name": "calendar_events_get",
"method": "GET",
"endpoint": "/api/content-planning/calendar-events/?strategy_id=1",
"data": None
},
{
"name": "gap_analysis_get",
"method": "GET",
"endpoint": "/api/content-planning/gap-analysis/?user_id=1",
"data": None
},
{
"name": "ai_analytics_get",
"method": "GET",
"endpoint": "/api/content-planning/ai-analytics/?user_id=1",
"data": None
},
{
"name": "comprehensive_user_data",
"method": "GET",
"endpoint": "/api/content-planning/calendar-generation/comprehensive-user-data?user_id=1",
"data": None
},
{
"name": "strategy_create",
"method": "POST",
"endpoint": "/api/content-planning/strategies/",
"data": {
"user_id": 1,
"name": "Comparison Test Strategy",
"industry": "technology",
"target_audience": {
"age_range": "25-45",
"interests": ["technology", "innovation"],
"location": "global"
},
"content_pillars": [
{"name": "Educational Content", "percentage": 40},
{"name": "Thought Leadership", "percentage": 30},
{"name": "Product Updates", "percentage": 30}
],
"ai_recommendations": {
"priority_topics": ["AI", "Machine Learning"],
"content_frequency": "daily",
"platform_focus": ["LinkedIn", "Website"]
}
}
},
{
"name": "calendar_generation",
"method": "POST",
"endpoint": "/api/content-planning/calendar-generation/generate-calendar",
"data": {
"user_id": 1,
"strategy_id": 1,
"calendar_type": "monthly",
"industry": "technology",
"business_size": "sme",
"force_refresh": False
}
},
{
"name": "content_optimization",
"method": "POST",
"endpoint": "/api/content-planning/calendar-generation/optimize-content",
"data": {
"user_id": 1,
"title": "Test Content Title",
"description": "This is test content for optimization",
"content_type": "blog_post",
"target_platform": "linkedin",
"original_content": {
"title": "Original Title",
"content": "Original content text"
}
}
},
{
"name": "trending_topics",
"method": "GET",
"endpoint": "/api/content-planning/calendar-generation/trending-topics?user_id=1&industry=technology&limit=5",
"data": None
}
]
for scenario in test_scenarios:
try:
if scenario["method"] == "GET":
response = self.session.get(f"{self.base_url}{scenario['endpoint']}")
elif scenario["method"] == "POST":
response = self.session.post(
f"{self.base_url}{scenario['endpoint']}",
json=scenario["data"]
)
self.refactored_responses[scenario["name"]] = {
"status_code": response.status_code,
"response_time": response.elapsed.total_seconds(),
"response_data": response.json() if response.status_code == 200 else None,
"headers": dict(response.headers)
}
logger.info(f"✅ Captured {scenario['name']}: {response.status_code}")
except Exception as e:
logger.error(f"❌ Failed to capture {scenario['name']}: {str(e)}")
self.refactored_responses[scenario["name"]] = {
"error": str(e),
"status_code": None,
"response_data": None
}
return self.refactored_responses
def compare_responses(self) -> Dict[str, Any]:
"""Compare baseline and refactored responses."""
logger.info("🔍 Comparing baseline and refactored responses")
comparison_results = {}
for test_name in self.baseline_responses.keys():
if test_name in self.refactored_responses:
baseline = self.baseline_responses[test_name]
refactored = self.refactored_responses[test_name]
comparison = self._compare_single_response(test_name, baseline, refactored)
comparison_results[test_name] = comparison
if comparison["status"] == "passed":
logger.info(f"✅ {test_name}: Responses match")
else:
logger.warning(f"⚠️ {test_name}: Responses differ")
else:
logger.warning(f"⚠️ {test_name}: No refactored response found")
comparison_results[test_name] = {
"status": "failed",
"reason": "No refactored response found"
}
return comparison_results
def _compare_single_response(self, test_name: str, baseline: Any, refactored: Any) -> Dict[str, Any]:
"""Compare a single response pair."""
try:
# Check if refactored response has error
if isinstance(refactored, dict) and refactored.get("error"):
return {
"status": "failed",
"reason": f"Refactored API error: {refactored['error']}",
"baseline": baseline,
"refactored": refactored
}
# Get response data
baseline_data = baseline if isinstance(baseline, dict) else baseline
refactored_data = refactored.get("response_data") if isinstance(refactored, dict) else refactored
# Compare status codes
baseline_status = 200 # Assume success for baseline
refactored_status = refactored.get("status_code", 200) if isinstance(refactored, dict) else 200
if baseline_status != refactored_status:
return {
"status": "failed",
"reason": f"Status code mismatch: baseline={baseline_status}, refactored={refactored_status}",
"baseline_status": baseline_status,
"refactored_status": refactored_status,
"baseline": baseline_data,
"refactored": refactored_data
}
# Compare response structure
structure_match = self._compare_structure(baseline_data, refactored_data)
if not structure_match["match"]:
return {
"status": "failed",
"reason": "Response structure mismatch",
"structure_diff": structure_match["differences"],
"baseline": baseline_data,
"refactored": refactored_data
}
# Compare response content
content_match = self._compare_content(baseline_data, refactored_data)
if not content_match["match"]:
return {
"status": "failed",
"reason": "Response content mismatch",
"content_diff": content_match["differences"],
"baseline": baseline_data,
"refactored": refactored_data
}
# Compare performance
performance_match = self._compare_performance(baseline, refactored)
return {
"status": "passed",
"structure_match": structure_match,
"content_match": content_match,
"performance_match": performance_match,
"baseline": baseline_data,
"refactored": refactored_data
}
except Exception as e:
return {
"status": "failed",
"reason": f"Comparison error: {str(e)}",
"baseline": baseline,
"refactored": refactored
}
def _compare_structure(self, baseline: Any, refactored: Any) -> Dict[str, Any]:
"""Compare the structure of two responses."""
try:
if type(baseline) != type(refactored):
return {
"match": False,
"differences": f"Type mismatch: baseline={type(baseline)}, refactored={type(refactored)}"
}
if isinstance(baseline, dict):
baseline_keys = set(baseline.keys())
refactored_keys = set(refactored.keys())
missing_keys = baseline_keys - refactored_keys
extra_keys = refactored_keys - baseline_keys
if missing_keys or extra_keys:
return {
"match": False,
"differences": {
"missing_keys": list(missing_keys),
"extra_keys": list(extra_keys)
}
}
# Recursively compare nested structures
for key in baseline_keys:
nested_comparison = self._compare_structure(baseline[key], refactored[key])
if not nested_comparison["match"]:
return {
"match": False,
"differences": f"Nested structure mismatch at key '{key}': {nested_comparison['differences']}"
}
elif isinstance(baseline, list):
if len(baseline) != len(refactored):
return {
"match": False,
"differences": f"List length mismatch: baseline={len(baseline)}, refactored={len(refactored)}"
}
# Compare list items (assuming order matters)
for i, (baseline_item, refactored_item) in enumerate(zip(baseline, refactored)):
nested_comparison = self._compare_structure(baseline_item, refactored_item)
if not nested_comparison["match"]:
return {
"match": False,
"differences": f"List item mismatch at index {i}: {nested_comparison['differences']}"
}
return {"match": True, "differences": None}
except Exception as e:
return {
"match": False,
"differences": f"Structure comparison error: {str(e)}"
}
def _compare_content(self, baseline: Any, refactored: Any) -> Dict[str, Any]:
"""Compare the content of two responses."""
try:
if baseline == refactored:
return {"match": True, "differences": None}
# For dictionaries, compare key values
if isinstance(baseline, dict) and isinstance(refactored, dict):
differences = {}
for key in baseline.keys():
if key in refactored:
if baseline[key] != refactored[key]:
differences[key] = {
"baseline": baseline[key],
"refactored": refactored[key]
}
else:
differences[key] = {
"baseline": baseline[key],
"refactored": "missing"
}
if differences:
return {
"match": False,
"differences": differences
}
else:
return {"match": True, "differences": None}
# For lists, compare items
elif isinstance(baseline, list) and isinstance(refactored, list):
if len(baseline) != len(refactored):
return {
"match": False,
"differences": f"List length mismatch: baseline={len(baseline)}, refactored={len(refactored)}"
}
differences = []
for i, (baseline_item, refactored_item) in enumerate(zip(baseline, refactored)):
if baseline_item != refactored_item:
differences.append({
"index": i,
"baseline": baseline_item,
"refactored": refactored_item
})
if differences:
return {
"match": False,
"differences": differences
}
else:
return {"match": True, "differences": None}
# For other types, direct comparison
else:
return {
"match": baseline == refactored,
"differences": {
"baseline": baseline,
"refactored": refactored
} if baseline != refactored else None
}
except Exception as e:
return {
"match": False,
"differences": f"Content comparison error: {str(e)}"
}
def _compare_performance(self, baseline: Any, refactored: Any) -> Dict[str, Any]:
"""Compare performance metrics."""
try:
baseline_time = baseline.get("response_time", 0) if isinstance(baseline, dict) else 0
refactored_time = refactored.get("response_time", 0) if isinstance(refactored, dict) else 0
time_diff = abs(refactored_time - baseline_time)
time_diff_percentage = (time_diff / baseline_time * 100) if baseline_time > 0 else 0
# Consider performance acceptable if within 50% of baseline
is_acceptable = time_diff_percentage <= 50
return {
"baseline_time": baseline_time,
"refactored_time": refactored_time,
"time_difference": time_diff,
"time_difference_percentage": time_diff_percentage,
"is_acceptable": is_acceptable
}
except Exception as e:
return {
"error": f"Performance comparison error: {str(e)}",
"is_acceptable": False
}
def generate_comparison_report(self) -> str:
"""Generate a detailed comparison report."""
report = []
report.append("=" * 80)
report.append("BEFORE/AFTER COMPARISON REPORT")
report.append("=" * 80)
report.append(f"Generated: {datetime.now().isoformat()}")
report.append("")
total_tests = len(self.comparison_results)
passed_tests = sum(1 for r in self.comparison_results.values() if r.get("status") == "passed")
failed_tests = total_tests - passed_tests
report.append(f"SUMMARY:")
report.append(f" Total Tests: {total_tests}")
report.append(f" Passed: {passed_tests}")
report.append(f" Failed: {failed_tests}")
report.append(f" Success Rate: {(passed_tests/total_tests)*100:.1f}%")
report.append("")
if failed_tests > 0:
report.append("FAILED TESTS:")
report.append("-" * 40)
for test_name, result in self.comparison_results.items():
if result.get("status") == "failed":
report.append(f" {test_name}:")
report.append(f" Reason: {result.get('reason', 'Unknown')}")
if "structure_diff" in result:
report.append(f" Structure Differences: {result['structure_diff']}")
if "content_diff" in result:
report.append(f" Content Differences: {result['content_diff']}")
report.append("")
report.append("DETAILED RESULTS:")
report.append("-" * 40)
for test_name, result in self.comparison_results.items():
report.append(f" {test_name}: {result.get('status', 'unknown')}")
if result.get("status") == "passed":
performance = result.get("performance_match", {})
if performance.get("is_acceptable"):
report.append(f" Performance: ✅ Acceptable")
else:
report.append(f" Performance: ⚠️ Degraded")
report.append(f" Response Time: {performance.get('refactored_time', 0):.3f}s")
report.append("")
return "\n".join(report)
async def run_comparison(self, baseline_file: str = "functionality_test_results.json") -> Dict[str, Any]:
"""Run the complete before/after comparison."""
logger.info("🧪 Starting before/after comparison test")
# Load baseline data
if not self.load_baseline_data(baseline_file):
logger.error("❌ Failed to load baseline data")
return {"status": "failed", "reason": "Baseline data not available"}
# Capture refactored responses
await self.capture_refactored_responses()
# Compare responses
self.comparison_results = self.compare_responses()
# Generate report
report = self.generate_comparison_report()
print(report)
# Save detailed results
with open("before_after_comparison_results.json", "w") as f:
json.dump({
"comparison_results": self.comparison_results,
"baseline_responses": self.baseline_responses,
"refactored_responses": self.refactored_responses,
"report": report
}, f, indent=2, default=str)
logger.info("✅ Before/after comparison completed")
return self.comparison_results
def run_before_after_comparison():
"""Run the before/after comparison test."""
test = BeforeAfterComparisonTest()
results = asyncio.run(test.run_comparison())
# Print summary
total_tests = len(results)
passed_tests = sum(1 for r in results.values() if r.get("status") == "passed")
failed_tests = total_tests - passed_tests
print(f"\nComparison Summary:")
print(f" Total Tests: {total_tests}")
print(f" Passed: {passed_tests}")
print(f" Failed: {failed_tests}")
print(f" Success Rate: {(passed_tests/total_tests)*100:.1f}%")
if failed_tests == 0:
print("🎉 All tests passed! Refactoring maintains functionality.")
else:
print(f"⚠️ {failed_tests} tests failed. Review differences carefully.")
return results
if __name__ == "__main__":
run_before_after_comparison()

641
backend/api/content_planning/tests/content_strategy_analysis.py Normal file
View File

@@ -0,0 +1,641 @@
"""
Content Strategy Analysis Test
Comprehensive analysis of content strategy data flow, AI prompts, and generated data points.
"""
import asyncio
import json
import time
from typing import Dict, Any, List
from datetime import datetime
from loguru import logger
# Import test utilities - using absolute import
try:
from test_data import TestData
except ImportError:
# Fallback for when running as standalone script
class TestData:
def __init__(self):
pass
class ContentStrategyAnalysis:
"""Comprehensive analysis of content strategy functionality."""
def __init__(self):
self.test_data = TestData()
self.analysis_results = {}
async def analyze_content_strategy_flow(self) -> Dict[str, Any]:
"""Analyze the complete content strategy data flow."""
logger.info("🔍 Starting Content Strategy Analysis")
analysis = {
"timestamp": datetime.utcnow().isoformat(),
"phase": "content_strategy",
"analysis": {}
}
# 1. Input Analysis
analysis["analysis"]["inputs"] = await self._analyze_inputs()
# 2. AI Prompt Analysis
analysis["analysis"]["ai_prompts"] = await self._analyze_ai_prompts()
# 3. Data Points Analysis
analysis["analysis"]["data_points"] = await self._analyze_data_points()
# 4. Frontend Mapping Analysis
analysis["analysis"]["frontend_mapping"] = await self._analyze_frontend_mapping()
# 5. Test Results
analysis["analysis"]["test_results"] = await self._run_comprehensive_tests()
logger.info("✅ Content Strategy Analysis Completed")
return analysis
async def _analyze_inputs(self) -> Dict[str, Any]:
"""Analyze the inputs required for content strategy generation."""
logger.info("📊 Analyzing Content Strategy Inputs")
inputs_analysis = {
"required_inputs": {
"user_id": {
"type": "integer",
"description": "User identifier for personalization",
"required": True,
"example": 1
},
"name": {
"type": "string",
"description": "Strategy name for identification",
"required": True,
"example": "Digital Marketing Strategy"
},
"industry": {
"type": "string",
"description": "Business industry for context",
"required": True,
"example": "technology"
},
"target_audience": {
"type": "object",
"description": "Target audience demographics and preferences",
"required": True,
"example": {
"demographics": ["professionals", "business_owners"],
"interests": ["digital_marketing", "content_creation"],
"age_range": "25-45",
"location": "global"
}
},
"content_pillars": {
"type": "array",
"description": "Content pillars and themes",
"required": False,
"example": [
{
"name": "Educational Content",
"description": "How-to guides and tutorials",
"content_types": ["blog", "video", "webinar"]
}
]
}
},
"optional_inputs": {
"ai_recommendations": {
"type": "object",
"description": "AI-generated recommendations",
"required": False
},
"strategy_id": {
"type": "integer",
"description": "Existing strategy ID for updates",
"required": False
}
},
"data_sources": [
"User onboarding data",
"Industry benchmarks",
"Competitor analysis",
"Historical performance data",
"Market trends"
]
}
logger.info(f"📋 Input Analysis: {len(inputs_analysis['required_inputs'])} required inputs identified")
return inputs_analysis
async def _analyze_ai_prompts(self) -> Dict[str, Any]:
"""Analyze the AI prompts used in content strategy generation."""
logger.info("🤖 Analyzing AI Prompts for Content Strategy")
prompts_analysis = {
"strategic_intelligence_prompt": {
"purpose": "Generate strategic intelligence for content planning",
"components": [
"Strategy data analysis",
"Market positioning assessment",
"Competitive advantage identification",
"Strategic score calculation",
"Risk assessment",
"Opportunity analysis"
],
"input_data": [
"strategy_id",
"market_data (optional)",
"historical performance",
"competitor analysis",
"industry trends"
],
"output_structure": {
"strategy_id": "integer",
"market_positioning": "object",
"competitive_advantages": "array",
"strategic_scores": "object",
"risk_assessment": "array",
"opportunity_analysis": "array",
"analysis_date": "datetime"
}
},
"performance_trends_prompt": {
"purpose": "Analyze performance trends for content strategy",
"components": [
"Metric trend analysis",
"Predictive insights generation",
"Performance score calculation",
"Recommendation generation"
],
"metrics_analyzed": [
"engagement_rate",
"reach",
"conversion_rate",
"click_through_rate"
]
},
"content_evolution_prompt": {
"purpose": "Analyze content evolution over time",
"components": [
"Content type evolution analysis",
"Engagement pattern analysis",
"Performance trend analysis",
"Evolution recommendation generation"
]
}
}
logger.info(f"🤖 AI Prompt Analysis: {len(prompts_analysis)} prompt types identified")
return prompts_analysis
async def _analyze_data_points(self) -> Dict[str, Any]:
"""Analyze the data points generated by content strategy."""
logger.info("📊 Analyzing Generated Data Points")
data_points_analysis = {
"strategic_insights": {
"description": "AI-generated strategic insights for content planning",
"structure": [
{
"id": "string",
"type": "string",
"title": "string",
"description": "string",
"priority": "string",
"estimated_impact": "string",
"created_at": "datetime"
}
],
"example": {
"id": "market_position_1",
"type": "warning",
"title": "Market Positioning Needs Improvement",
"description": "Your market positioning score is 4/10. Consider strategic adjustments.",
"priority": "high",
"estimated_impact": "significant",
"created_at": "2024-08-01T10:00:00Z"
}
},
"market_positioning": {
"description": "Market positioning analysis and scores",
"structure": {
"industry_position": "string",
"competitive_advantage": "string",
"market_share": "string",
"positioning_score": "integer"
},
"example": {
"industry_position": "emerging",
"competitive_advantage": "AI-powered content",
"market_share": "2.5%",
"positioning_score": 4
}
},
"strategic_scores": {
"description": "Strategic performance scores",
"structure": {
"overall_score": "float",
"content_quality_score": "float",
"engagement_score": "float",
"conversion_score": "float",
"innovation_score": "float"
},
"example": {
"overall_score": 7.2,
"content_quality_score": 8.1,
"engagement_score": 6.8,
"conversion_score": 7.5,
"innovation_score": 8.3
}
},
"risk_assessment": {
"description": "Strategic risk assessment",
"structure": [
{
"type": "string",
"severity": "string",
"description": "string",
"mitigation_strategy": "string"
}
],
"example": [
{
"type": "market_competition",
"severity": "medium",
"description": "Increasing competition in AI content space",
"mitigation_strategy": "Focus on unique value propositions"
}
]
},
"opportunity_analysis": {
"description": "Strategic opportunity analysis",
"structure": [
{
"title": "string",
"description": "string",
"estimated_impact": "string",
"implementation_difficulty": "string",
"timeline": "string"
}
],
"example": [
{
"title": "Video Content Expansion",
"description": "Expand into video content to capture growing demand",
"estimated_impact": "high",
"implementation_difficulty": "medium",
"timeline": "3-6 months"
}
]
},
"recommendations": {
"description": "AI-generated strategic recommendations",
"structure": [
{
"id": "string",
"type": "string",
"title": "string",
"description": "string",
"priority": "string",
"estimated_impact": "string",
"action_items": "array"
}
],
"example": [
{
"id": "rec_001",
"type": "content_strategy",
"title": "Implement AI-Powered Content Personalization",
"description": "Use AI to personalize content for different audience segments",
"priority": "high",
"estimated_impact": "significant",
"action_items": [
"Implement AI content recommendation engine",
"Create audience segmentation strategy",
"Develop personalized content templates"
]
}
]
}
}
logger.info(f"📊 Data Points Analysis: {len(data_points_analysis)} data point types identified")
return data_points_analysis
async def _analyze_frontend_mapping(self) -> Dict[str, Any]:
"""Analyze how backend data maps to frontend components."""
logger.info("🖥️ Analyzing Frontend-Backend Data Mapping")
frontend_mapping = {
"dashboard_components": {
"strategy_overview": {
"backend_data": "strategic_scores",
"frontend_component": "StrategyOverviewCard",
"data_mapping": {
"overall_score": "score",
"content_quality_score": "qualityScore",
"engagement_score": "engagementScore",
"conversion_score": "conversionScore"
}
},
"strategic_insights": {
"backend_data": "strategic_insights",
"frontend_component": "InsightsList",
"data_mapping": {
"title": "title",
"description": "description",
"priority": "priority",
"type": "type"
}
},
"market_positioning": {
"backend_data": "market_positioning",
"frontend_component": "MarketPositioningChart",
"data_mapping": {
"positioning_score": "score",
"industry_position": "position",
"competitive_advantage": "advantage"
}
},
"risk_assessment": {
"backend_data": "risk_assessment",
"frontend_component": "RiskAssessmentPanel",
"data_mapping": {
"type": "riskType",
"severity": "severity",
"description": "description",
"mitigation_strategy": "mitigation"
}
},
"opportunities": {
"backend_data": "opportunity_analysis",
"frontend_component": "OpportunitiesList",
"data_mapping": {
"title": "title",
"description": "description",
"estimated_impact": "impact",
"implementation_difficulty": "difficulty"
}
},
"recommendations": {
"backend_data": "recommendations",
"frontend_component": "RecommendationsPanel",
"data_mapping": {
"title": "title",
"description": "description",
"priority": "priority",
"action_items": "actions"
}
}
},
"data_flow": {
"api_endpoints": {
"get_strategies": "/api/content-planning/strategies/",
"get_strategy_by_id": "/api/content-planning/strategies/{id}",
"create_strategy": "/api/content-planning/strategies/",
"update_strategy": "/api/content-planning/strategies/{id}",
"delete_strategy": "/api/content-planning/strategies/{id}"
},
"response_structure": {
"status": "success/error",
"data": "strategy_data",
"message": "user_message",
"timestamp": "iso_datetime"
}
}
}
logger.info(f"🖥️ Frontend Mapping Analysis: {len(frontend_mapping['dashboard_components'])} components mapped")
return frontend_mapping
async def _run_comprehensive_tests(self) -> Dict[str, Any]:
"""Run comprehensive tests for content strategy functionality."""
logger.info("🧪 Running Comprehensive Content Strategy Tests")
test_results = {
"test_cases": [],
"summary": {
"total_tests": 0,
"passed": 0,
"failed": 0,
"success_rate": 0.0
}
}
# Test Case 1: Strategy Creation
test_case_1 = await self._test_strategy_creation()
test_results["test_cases"].append(test_case_1)
# Test Case 2: Strategy Retrieval
test_case_2 = await self._test_strategy_retrieval()
test_results["test_cases"].append(test_case_2)
# Test Case 3: Strategic Intelligence Generation
test_case_3 = await self._test_strategic_intelligence()
test_results["test_cases"].append(test_case_3)
# Test Case 4: Data Structure Validation
test_case_4 = await self._test_data_structure_validation()
test_results["test_cases"].append(test_case_4)
# Calculate summary
total_tests = len(test_results["test_cases"])
passed_tests = sum(1 for test in test_results["test_cases"] if test["status"] == "passed")
test_results["summary"] = {
"total_tests": total_tests,
"passed": passed_tests,
"failed": total_tests - passed_tests,
"success_rate": (passed_tests / total_tests * 100) if total_tests > 0 else 0.0
}
logger.info(f"🧪 Test Results: {passed_tests}/{total_tests} tests passed ({test_results['summary']['success_rate']:.1f}%)")
return test_results
async def _test_strategy_creation(self) -> Dict[str, Any]:
"""Test strategy creation functionality."""
try:
logger.info("Testing strategy creation...")
# Simulate strategy creation
strategy_data = {
"user_id": 1,
"name": "Test Digital Marketing Strategy",
"industry": "technology",
"target_audience": {
"demographics": ["professionals"],
"interests": ["digital_marketing"]
},
"content_pillars": [
{
"name": "Educational Content",
"description": "How-to guides and tutorials"
}
]
}
# Validate required fields
required_fields = ["user_id", "name", "industry", "target_audience"]
missing_fields = [field for field in required_fields if field not in strategy_data]
if missing_fields:
return {
"name": "Strategy Creation - Required Fields",
"status": "failed",
"error": f"Missing required fields: {missing_fields}"
}
return {
"name": "Strategy Creation - Required Fields",
"status": "passed",
"message": "All required fields present"
}
except Exception as e:
return {
"name": "Strategy Creation",
"status": "failed",
"error": str(e)
}
async def _test_strategy_retrieval(self) -> Dict[str, Any]:
"""Test strategy retrieval functionality."""
try:
logger.info("Testing strategy retrieval...")
# Simulate strategy retrieval
user_id = 1
strategy_id = 1
# Validate query parameters
if not isinstance(user_id, int) or user_id <= 0:
return {
"name": "Strategy Retrieval - User ID Validation",
"status": "failed",
"error": "Invalid user_id"
}
return {
"name": "Strategy Retrieval - User ID Validation",
"status": "passed",
"message": "User ID validation passed"
}
except Exception as e:
return {
"name": "Strategy Retrieval",
"status": "failed",
"error": str(e)
}
async def _test_strategic_intelligence(self) -> Dict[str, Any]:
"""Test strategic intelligence generation."""
try:
logger.info("Testing strategic intelligence generation...")
# Expected strategic intelligence structure
expected_structure = {
"strategy_id": "integer",
"market_positioning": "object",
"competitive_advantages": "array",
"strategic_scores": "object",
"risk_assessment": "array",
"opportunity_analysis": "array"
}
# Validate structure
required_keys = list(expected_structure.keys())
return {
"name": "Strategic Intelligence - Structure Validation",
"status": "passed",
"message": f"Expected structure contains {len(required_keys)} required keys"
}
except Exception as e:
return {
"name": "Strategic Intelligence",
"status": "failed",
"error": str(e)
}
async def _test_data_structure_validation(self) -> Dict[str, Any]:
"""Test data structure validation."""
try:
logger.info("Testing data structure validation...")
# Test strategic insights structure
strategic_insight_structure = {
"id": "string",
"type": "string",
"title": "string",
"description": "string",
"priority": "string",
"created_at": "datetime"
}
# Test market positioning structure
market_positioning_structure = {
"industry_position": "string",
"competitive_advantage": "string",
"positioning_score": "integer"
}
# Validate both structures
insight_keys = list(strategic_insight_structure.keys())
positioning_keys = list(market_positioning_structure.keys())
if len(insight_keys) >= 5 and len(positioning_keys) >= 3:
return {
"name": "Data Structure Validation",
"status": "passed",
"message": "Data structures properly defined"
}
else:
return {
"name": "Data Structure Validation",
"status": "failed",
"error": "Insufficient data structure definition"
}
except Exception as e:
return {
"name": "Data Structure Validation",
"status": "failed",
"error": str(e)
}
async def main():
"""Main function to run content strategy analysis."""
logger.info("🚀 Starting Content Strategy Analysis")
analyzer = ContentStrategyAnalysis()
results = await analyzer.analyze_content_strategy_flow()
# Save results to file
with open("content_strategy_analysis_results.json", "w") as f:
json.dump(results, f, indent=2, default=str)
logger.info("✅ Content Strategy Analysis completed and saved to content_strategy_analysis_results.json")
# Print summary
print("\n" + "="*60)
print("📊 CONTENT STRATEGY ANALYSIS SUMMARY")
print("="*60)
test_results = results["analysis"]["test_results"]["summary"]
print(f"🧪 Test Results: {test_results['passed']}/{test_results['total_tests']} passed ({test_results['success_rate']:.1f}%)")
inputs_count = len(results["analysis"]["inputs"]["required_inputs"])
data_points_count = len(results["analysis"]["data_points"])
components_count = len(results["analysis"]["frontend_mapping"]["dashboard_components"])
print(f"📋 Inputs Analyzed: {inputs_count} required inputs")
print(f"📊 Data Points: {data_points_count} data point types")
print(f"🖥️ Frontend Components: {components_count} components mapped")
print("\n" + "="*60)
print("✅ Content Strategy Phase Analysis Complete!")
print("="*60)
if __name__ == "__main__":
asyncio.run(main())

367
backend/api/content_planning/tests/content_strategy_analysis_results.json Normal file
View File

@@ -0,0 +1,367 @@
{
"timestamp": "2025-08-04T16:20:52.349838",
"phase": "content_strategy",
"analysis": {
"inputs": {
"required_inputs": {
"user_id": {
"type": "integer",
"description": "User identifier for personalization",
"required": true,
"example": 1
},
"name": {
"type": "string",
"description": "Strategy name for identification",
"required": true,
"example": "Digital Marketing Strategy"
},
"industry": {
"type": "string",
"description": "Business industry for context",
"required": true,
"example": "technology"
},
"target_audience": {
"type": "object",
"description": "Target audience demographics and preferences",
"required": true,
"example": {
"demographics": [
"professionals",
"business_owners"
],
"interests": [
"digital_marketing",
"content_creation"
],
"age_range": "25-45",
"location": "global"
}
},
"content_pillars": {
"type": "array",
"description": "Content pillars and themes",
"required": false,
"example": [
{
"name": "Educational Content",
"description": "How-to guides and tutorials",
"content_types": [
"blog",
"video",
"webinar"
]
}
]
}
},
"optional_inputs": {
"ai_recommendations": {
"type": "object",
"description": "AI-generated recommendations",
"required": false
},
"strategy_id": {
"type": "integer",
"description": "Existing strategy ID for updates",
"required": false
}
},
"data_sources": [
"User onboarding data",
"Industry benchmarks",
"Competitor analysis",
"Historical performance data",
"Market trends"
]
},
"ai_prompts": {
"strategic_intelligence_prompt": {
"purpose": "Generate strategic intelligence for content planning",
"components": [
"Strategy data analysis",
"Market positioning assessment",
"Competitive advantage identification",
"Strategic score calculation",
"Risk assessment",
"Opportunity analysis"
],
"input_data": [
"strategy_id",
"market_data (optional)",
"historical performance",
"competitor analysis",
"industry trends"
],
"output_structure": {
"strategy_id": "integer",
"market_positioning": "object",
"competitive_advantages": "array",
"strategic_scores": "object",
"risk_assessment": "array",
"opportunity_analysis": "array",
"analysis_date": "datetime"
}
},
"performance_trends_prompt": {
"purpose": "Analyze performance trends for content strategy",
"components": [
"Metric trend analysis",
"Predictive insights generation",
"Performance score calculation",
"Recommendation generation"
],
"metrics_analyzed": [
"engagement_rate",
"reach",
"conversion_rate",
"click_through_rate"
]
},
"content_evolution_prompt": {
"purpose": "Analyze content evolution over time",
"components": [
"Content type evolution analysis",
"Engagement pattern analysis",
"Performance trend analysis",
"Evolution recommendation generation"
]
}
},
"data_points": {
"strategic_insights": {
"description": "AI-generated strategic insights for content planning",
"structure": [
{
"id": "string",
"type": "string",
"title": "string",
"description": "string",
"priority": "string",
"estimated_impact": "string",
"created_at": "datetime"
}
],
"example": {
"id": "market_position_1",
"type": "warning",
"title": "Market Positioning Needs Improvement",
"description": "Your market positioning score is 4/10. Consider strategic adjustments.",
"priority": "high",
"estimated_impact": "significant",
"created_at": "2024-08-01T10:00:00Z"
}
},
"market_positioning": {
"description": "Market positioning analysis and scores",
"structure": {
"industry_position": "string",
"competitive_advantage": "string",
"market_share": "string",
"positioning_score": "integer"
},
"example": {
"industry_position": "emerging",
"competitive_advantage": "AI-powered content",
"market_share": "2.5%",
"positioning_score": 4
}
},
"strategic_scores": {
"description": "Strategic performance scores",
"structure": {
"overall_score": "float",
"content_quality_score": "float",
"engagement_score": "float",
"conversion_score": "float",
"innovation_score": "float"
},
"example": {
"overall_score": 7.2,
"content_quality_score": 8.1,
"engagement_score": 6.8,
"conversion_score": 7.5,
"innovation_score": 8.3
}
},
"risk_assessment": {
"description": "Strategic risk assessment",
"structure": [
{
"type": "string",
"severity": "string",
"description": "string",
"mitigation_strategy": "string"
}
],
"example": [
{
"type": "market_competition",
"severity": "medium",
"description": "Increasing competition in AI content space",
"mitigation_strategy": "Focus on unique value propositions"
}
]
},
"opportunity_analysis": {
"description": "Strategic opportunity analysis",
"structure": [
{
"title": "string",
"description": "string",
"estimated_impact": "string",
"implementation_difficulty": "string",
"timeline": "string"
}
],
"example": [
{
"title": "Video Content Expansion",
"description": "Expand into video content to capture growing demand",
"estimated_impact": "high",
"implementation_difficulty": "medium",
"timeline": "3-6 months"
}
]
},
"recommendations": {
"description": "AI-generated strategic recommendations",
"structure": [
{
"id": "string",
"type": "string",
"title": "string",
"description": "string",
"priority": "string",
"estimated_impact": "string",
"action_items": "array"
}
],
"example": [
{
"id": "rec_001",
"type": "content_strategy",
"title": "Implement AI-Powered Content Personalization",
"description": "Use AI to personalize content for different audience segments",
"priority": "high",
"estimated_impact": "significant",
"action_items": [
"Implement AI content recommendation engine",
"Create audience segmentation strategy",
"Develop personalized content templates"
]
}
]
}
},
"frontend_mapping": {
"dashboard_components": {
"strategy_overview": {
"backend_data": "strategic_scores",
"frontend_component": "StrategyOverviewCard",
"data_mapping": {
"overall_score": "score",
"content_quality_score": "qualityScore",
"engagement_score": "engagementScore",
"conversion_score": "conversionScore"
}
},
"strategic_insights": {
"backend_data": "strategic_insights",
"frontend_component": "InsightsList",
"data_mapping": {
"title": "title",
"description": "description",
"priority": "priority",
"type": "type"
}
},
"market_positioning": {
"backend_data": "market_positioning",
"frontend_component": "MarketPositioningChart",
"data_mapping": {
"positioning_score": "score",
"industry_position": "position",
"competitive_advantage": "advantage"
}
},
"risk_assessment": {
"backend_data": "risk_assessment",
"frontend_component": "RiskAssessmentPanel",
"data_mapping": {
"type": "riskType",
"severity": "severity",
"description": "description",
"mitigation_strategy": "mitigation"
}
},
"opportunities": {
"backend_data": "opportunity_analysis",
"frontend_component": "OpportunitiesList",
"data_mapping": {
"title": "title",
"description": "description",
"estimated_impact": "impact",
"implementation_difficulty": "difficulty"
}
},
"recommendations": {
"backend_data": "recommendations",
"frontend_component": "RecommendationsPanel",
"data_mapping": {
"title": "title",
"description": "description",
"priority": "priority",
"action_items": "actions"
}
}
},
"data_flow": {
"api_endpoints": {
"get_strategies": "/api/content-planning/strategies/",
"get_strategy_by_id": "/api/content-planning/strategies/{id}",
"create_strategy": "/api/content-planning/strategies/",
"update_strategy": "/api/content-planning/strategies/{id}",
"delete_strategy": "/api/content-planning/strategies/{id}"
},
"response_structure": {
"status": "success/error",
"data": "strategy_data",
"message": "user_message",
"timestamp": "iso_datetime"
}
}
},
"test_results": {
"test_cases": [
{
"name": "Strategy Creation - Required Fields",
"status": "passed",
"message": "All required fields present"
},
{
"name": "Strategy Retrieval - User ID Validation",
"status": "passed",
"message": "User ID validation passed"
},
{
"name": "Strategic Intelligence - Structure Validation",
"status": "passed",
"message": "Expected structure contains 6 required keys"
},
{
"name": "Data Structure Validation",
"status": "passed",
"message": "Data structures properly defined"
}
],
"summary": {
"total_tests": 4,
"passed": 4,
"failed": 0,
"success_rate": 100.0
}
}
}
}

721
backend/api/content_planning/tests/functionality_test.py Normal file
View File

@@ -0,0 +1,721 @@
"""
Comprehensive Functionality Test for Content Planning Module
Tests all existing endpoints and functionality to establish baseline before refactoring.
"""
import asyncio
import json
import time
from typing import Dict, Any, List
from datetime import datetime, timedelta
import requests
from loguru import logger
class ContentPlanningFunctionalityTest:
"""Comprehensive test suite for content planning functionality."""
def __init__(self, base_url: str = "http://localhost:8000"):
self.base_url = base_url
self.test_results = {}
self.baseline_data = {}
self.session = requests.Session()
async def run_all_tests(self) -> Dict[str, Any]:
"""Run all functionality tests and return results."""
logger.info("🧪 Starting comprehensive functionality test suite")
test_suites = [
self.test_health_endpoints,
self.test_strategy_endpoints,
self.test_calendar_endpoints,
self.test_gap_analysis_endpoints,
self.test_ai_analytics_endpoints,
self.test_calendar_generation_endpoints,
self.test_content_optimization_endpoints,
self.test_performance_prediction_endpoints,
self.test_content_repurposing_endpoints,
self.test_trending_topics_endpoints,
self.test_comprehensive_user_data_endpoints,
self.test_error_scenarios,
self.test_data_validation,
self.test_response_formats,
self.test_performance_metrics
]
for test_suite in test_suites:
try:
await test_suite()
except Exception as e:
logger.error(f"❌ Test suite {test_suite.__name__} failed: {str(e)}")
self.test_results[test_suite.__name__] = {
"status": "failed",
"error": str(e)
}
logger.info("✅ Functionality test suite completed")
return self.test_results
async def test_health_endpoints(self):
"""Test health check endpoints."""
logger.info("🔍 Testing health endpoints")
endpoints = [
"/api/content-planning/health",
"/api/content-planning/database/health",
"/api/content-planning/health/backend",
"/api/content-planning/health/ai",
"/api/content-planning/ai-analytics/health",
"/api/content-planning/calendar-generation/health"
]
for endpoint in endpoints:
try:
response = self.session.get(f"{self.base_url}{endpoint}")
self.test_results[f"health_{endpoint.split('/')[-1]}"] = {
"status": "passed" if response.status_code == 200 else "failed",
"status_code": response.status_code,
"response_time": response.elapsed.total_seconds(),
"response_data": response.json() if response.status_code == 200 else None
}
logger.info(f"✅ Health endpoint {endpoint}: {response.status_code}")
except Exception as e:
logger.error(f"❌ Health endpoint {endpoint} failed: {str(e)}")
self.test_results[f"health_{endpoint.split('/')[-1]}"] = {
"status": "failed",
"error": str(e)
}
async def test_strategy_endpoints(self):
"""Test strategy CRUD endpoints."""
logger.info("🔍 Testing strategy endpoints")
# Test data
strategy_data = {
"user_id": 1,
"name": "Test Strategy",
"industry": "technology",
"target_audience": {
"age_range": "25-45",
"interests": ["technology", "innovation"],
"location": "global"
},
"content_pillars": [
{"name": "Educational Content", "percentage": 40},
{"name": "Thought Leadership", "percentage": 30},
{"name": "Product Updates", "percentage": 30}
],
"ai_recommendations": {
"priority_topics": ["AI", "Machine Learning"],
"content_frequency": "daily",
"platform_focus": ["LinkedIn", "Website"]
}
}
# Test CREATE strategy
try:
response = self.session.post(
f"{self.base_url}/api/content-planning/strategies/",
json=strategy_data
)
self.test_results["strategy_create"] = {
"status": "passed" if response.status_code == 200 else "failed",
"status_code": response.status_code,
"response_time": response.elapsed.total_seconds(),
"response_data": response.json() if response.status_code == 200 else None
}
if response.status_code == 200:
strategy_id = response.json().get("id")
self.baseline_data["strategy_id"] = strategy_id
logger.info(f"✅ Strategy created with ID: {strategy_id}")
else:
logger.warning(f"⚠️ Strategy creation failed: {response.status_code}")
except Exception as e:
logger.error(f"❌ Strategy creation failed: {str(e)}")
self.test_results["strategy_create"] = {
"status": "failed",
"error": str(e)
}
# Test GET strategies
try:
response = self.session.get(
f"{self.base_url}/api/content-planning/strategies/?user_id=1"
)
self.test_results["strategy_get_all"] = {
"status": "passed" if response.status_code == 200 else "failed",
"status_code": response.status_code,
"response_time": response.elapsed.total_seconds(),
"response_data": response.json() if response.status_code == 200 else None
}
logger.info(f"✅ Get strategies: {response.status_code}")
except Exception as e:
logger.error(f"❌ Get strategies failed: {str(e)}")
self.test_results["strategy_get_all"] = {
"status": "failed",
"error": str(e)
}
# Test GET specific strategy
if self.baseline_data.get("strategy_id"):
try:
response = self.session.get(
f"{self.base_url}/api/content-planning/strategies/{self.baseline_data['strategy_id']}"
)
self.test_results["strategy_get_specific"] = {
"status": "passed" if response.status_code == 200 else "failed",
"status_code": response.status_code,
"response_time": response.elapsed.total_seconds(),
"response_data": response.json() if response.status_code == 200 else None
}
logger.info(f"✅ Get specific strategy: {response.status_code}")
except Exception as e:
logger.error(f"❌ Get specific strategy failed: {str(e)}")
self.test_results["strategy_get_specific"] = {
"status": "failed",
"error": str(e)
}
async def test_calendar_endpoints(self):
"""Test calendar event endpoints."""
logger.info("🔍 Testing calendar endpoints")
# Test data
event_data = {
"strategy_id": self.baseline_data.get("strategy_id", 1),
"title": "Test Calendar Event",
"description": "This is a test calendar event for functionality testing",
"content_type": "blog_post",
"platform": "website",
"scheduled_date": (datetime.now() + timedelta(days=7)).isoformat(),
"ai_recommendations": {
"optimal_time": "09:00",
"hashtags": ["#test", "#content"],
"tone": "professional"
}
}
# Test CREATE calendar event
try:
response = self.session.post(
f"{self.base_url}/api/content-planning/calendar-events/",
json=event_data
)
self.test_results["calendar_create"] = {
"status": "passed" if response.status_code == 200 else "failed",
"status_code": response.status_code,
"response_time": response.elapsed.total_seconds(),
"response_data": response.json() if response.status_code == 200 else None
}
if response.status_code == 200:
event_id = response.json().get("id")
self.baseline_data["event_id"] = event_id
logger.info(f"✅ Calendar event created with ID: {event_id}")
else:
logger.warning(f"⚠️ Calendar event creation failed: {response.status_code}")
except Exception as e:
logger.error(f"❌ Calendar event creation failed: {str(e)}")
self.test_results["calendar_create"] = {
"status": "failed",
"error": str(e)
}
# Test GET calendar events
try:
response = self.session.get(
f"{self.base_url}/api/content-planning/calendar-events/?strategy_id={self.baseline_data.get('strategy_id', 1)}"
)
self.test_results["calendar_get_all"] = {
"status": "passed" if response.status_code == 200 else "failed",
"status_code": response.status_code,
"response_time": response.elapsed.total_seconds(),
"response_data": response.json() if response.status_code == 200 else None
}
logger.info(f"✅ Get calendar events: {response.status_code}")
except Exception as e:
logger.error(f"❌ Get calendar events failed: {str(e)}")
self.test_results["calendar_get_all"] = {
"status": "failed",
"error": str(e)
}
async def test_gap_analysis_endpoints(self):
"""Test gap analysis endpoints."""
logger.info("🔍 Testing gap analysis endpoints")
# Test data
gap_analysis_data = {
"user_id": 1,
"website_url": "https://example.com",
"competitor_urls": ["https://competitor1.com", "https://competitor2.com"],
"target_keywords": ["content marketing", "digital strategy"],
"industry": "technology"
}
# Test CREATE gap analysis
try:
response = self.session.post(
f"{self.base_url}/api/content-planning/gap-analysis/",
json=gap_analysis_data
)
self.test_results["gap_analysis_create"] = {
"status": "passed" if response.status_code == 200 else "failed",
"status_code": response.status_code,
"response_time": response.elapsed.total_seconds(),
"response_data": response.json() if response.status_code == 200 else None
}
if response.status_code == 200:
analysis_id = response.json().get("id")
self.baseline_data["analysis_id"] = analysis_id
logger.info(f"✅ Gap analysis created with ID: {analysis_id}")
else:
logger.warning(f"⚠️ Gap analysis creation failed: {response.status_code}")
except Exception as e:
logger.error(f"❌ Gap analysis creation failed: {str(e)}")
self.test_results["gap_analysis_create"] = {
"status": "failed",
"error": str(e)
}
# Test GET gap analyses
try:
response = self.session.get(
f"{self.base_url}/api/content-planning/gap-analysis/?user_id=1"
)
self.test_results["gap_analysis_get_all"] = {
"status": "passed" if response.status_code == 200 else "failed",
"status_code": response.status_code,
"response_time": response.elapsed.total_seconds(),
"response_data": response.json() if response.status_code == 200 else None
}
logger.info(f"✅ Get gap analyses: {response.status_code}")
except Exception as e:
logger.error(f"❌ Get gap analyses failed: {str(e)}")
self.test_results["gap_analysis_get_all"] = {
"status": "failed",
"error": str(e)
}
async def test_ai_analytics_endpoints(self):
"""Test AI analytics endpoints."""
logger.info("🔍 Testing AI analytics endpoints")
# Test GET AI analytics
try:
response = self.session.get(
f"{self.base_url}/api/content-planning/ai-analytics/?user_id=1"
)
self.test_results["ai_analytics_get"] = {
"status": "passed" if response.status_code == 200 else "failed",
"status_code": response.status_code,
"response_time": response.elapsed.total_seconds(),
"response_data": response.json() if response.status_code == 200 else None
}
logger.info(f"✅ Get AI analytics: {response.status_code}")
except Exception as e:
logger.error(f"❌ Get AI analytics failed: {str(e)}")
self.test_results["ai_analytics_get"] = {
"status": "failed",
"error": str(e)
}
# Test content evolution analysis
evolution_data = {
"strategy_id": self.baseline_data.get("strategy_id", 1),
"time_period": "30d"
}
try:
response = self.session.post(
f"{self.base_url}/api/content-planning/ai-analytics/content-evolution",
json=evolution_data
)
self.test_results["ai_analytics_evolution"] = {
"status": "passed" if response.status_code == 200 else "failed",
"status_code": response.status_code,
"response_time": response.elapsed.total_seconds(),
"response_data": response.json() if response.status_code == 200 else None
}
logger.info(f"✅ Content evolution analysis: {response.status_code}")
except Exception as e:
logger.error(f"❌ Content evolution analysis failed: {str(e)}")
self.test_results["ai_analytics_evolution"] = {
"status": "failed",
"error": str(e)
}
async def test_calendar_generation_endpoints(self):
"""Test calendar generation endpoints."""
logger.info("🔍 Testing calendar generation endpoints")
# Test calendar generation
calendar_data = {
"user_id": 1,
"strategy_id": self.baseline_data.get("strategy_id", 1),
"calendar_type": "monthly",
"industry": "technology",
"business_size": "sme",
"force_refresh": False
}
try:
response = self.session.post(
f"{self.base_url}/api/content-planning/generate-calendar",
json=calendar_data
)
self.test_results["calendar_generation"] = {
"status": "passed" if response.status_code == 200 else "failed",
"status_code": response.status_code,
"response_time": response.elapsed.total_seconds(),
"response_data": response.json() if response.status_code == 200 else None
}
logger.info(f"✅ Calendar generation: {response.status_code}")
except Exception as e:
logger.error(f"❌ Calendar generation failed: {str(e)}")
self.test_results["calendar_generation"] = {
"status": "failed",
"error": str(e)
}
async def test_content_optimization_endpoints(self):
"""Test content optimization endpoints."""
logger.info("🔍 Testing content optimization endpoints")
# Test content optimization
optimization_data = {
"user_id": 1,
"title": "Test Content Title",
"description": "This is test content for optimization",
"content_type": "blog_post",
"target_platform": "linkedin",
"original_content": {
"title": "Original Title",
"content": "Original content text"
}
}
try:
response = self.session.post(
f"{self.base_url}/api/content-planning/optimize-content",
json=optimization_data
)
self.test_results["content_optimization"] = {
"status": "passed" if response.status_code == 200 else "failed",
"status_code": response.status_code,
"response_time": response.elapsed.total_seconds(),
"response_data": response.json() if response.status_code == 200 else None
}
logger.info(f"✅ Content optimization: {response.status_code}")
except Exception as e:
logger.error(f"❌ Content optimization failed: {str(e)}")
self.test_results["content_optimization"] = {
"status": "failed",
"error": str(e)
}
async def test_performance_prediction_endpoints(self):
"""Test performance prediction endpoints."""
logger.info("🔍 Testing performance prediction endpoints")
# Test performance prediction
prediction_data = {
"user_id": 1,
"strategy_id": self.baseline_data.get("strategy_id", 1),
"content_type": "blog_post",
"platform": "linkedin",
"content_data": {
"title": "Test Content",
"description": "Test content description",
"hashtags": ["#test", "#content"]
}
}
try:
response = self.session.post(
f"{self.base_url}/api/content-planning/performance-predictions",
json=prediction_data
)
self.test_results["performance_prediction"] = {
"status": "passed" if response.status_code == 200 else "failed",
"status_code": response.status_code,
"response_time": response.elapsed.total_seconds(),
"response_data": response.json() if response.status_code == 200 else None
}
logger.info(f"✅ Performance prediction: {response.status_code}")
except Exception as e:
logger.error(f"❌ Performance prediction failed: {str(e)}")
self.test_results["performance_prediction"] = {
"status": "failed",
"error": str(e)
}
async def test_content_repurposing_endpoints(self):
"""Test content repurposing endpoints."""
logger.info("🔍 Testing content repurposing endpoints")
# Test content repurposing
repurposing_data = {
"user_id": 1,
"strategy_id": self.baseline_data.get("strategy_id", 1),
"original_content": {
"title": "Original Content",
"content": "Original content text",
"platform": "website"
},
"target_platforms": ["linkedin", "twitter", "instagram"]
}
try:
response = self.session.post(
f"{self.base_url}/api/content-planning/repurpose-content",
json=repurposing_data
)
self.test_results["content_repurposing"] = {
"status": "passed" if response.status_code == 200 else "failed",
"status_code": response.status_code,
"response_time": response.elapsed.total_seconds(),
"response_data": response.json() if response.status_code == 200 else None
}
logger.info(f"✅ Content repurposing: {response.status_code}")
except Exception as e:
logger.error(f"❌ Content repurposing failed: {str(e)}")
self.test_results["content_repurposing"] = {
"status": "failed",
"error": str(e)
}
async def test_trending_topics_endpoints(self):
"""Test trending topics endpoints."""
logger.info("🔍 Testing trending topics endpoints")
try:
response = self.session.get(
f"{self.base_url}/api/content-planning/trending-topics?user_id=1&industry=technology&limit=5"
)
self.test_results["trending_topics"] = {
"status": "passed" if response.status_code == 200 else "failed",
"status_code": response.status_code,
"response_time": response.elapsed.total_seconds(),
"response_data": response.json() if response.status_code == 200 else None
}
logger.info(f"✅ Trending topics: {response.status_code}")
except Exception as e:
logger.error(f"❌ Trending topics failed: {str(e)}")
self.test_results["trending_topics"] = {
"status": "failed",
"error": str(e)
}
async def test_comprehensive_user_data_endpoints(self):
"""Test comprehensive user data endpoints."""
logger.info("🔍 Testing comprehensive user data endpoints")
try:
response = self.session.get(
f"{self.base_url}/api/content-planning/comprehensive-user-data?user_id=1"
)
self.test_results["comprehensive_user_data"] = {
"status": "passed" if response.status_code == 200 else "failed",
"status_code": response.status_code,
"response_time": response.elapsed.total_seconds(),
"response_data": response.json() if response.status_code == 200 else None
}
logger.info(f"✅ Comprehensive user data: {response.status_code}")
except Exception as e:
logger.error(f"❌ Comprehensive user data failed: {str(e)}")
self.test_results["comprehensive_user_data"] = {
"status": "failed",
"error": str(e)
}
async def test_error_scenarios(self):
"""Test error handling scenarios."""
logger.info("🔍 Testing error scenarios")
# Test invalid user ID
try:
response = self.session.get(
f"{self.base_url}/api/content-planning/strategies/?user_id=999999"
)
self.test_results["error_invalid_user"] = {
"status": "passed" if response.status_code in [404, 400] else "failed",
"status_code": response.status_code,
"response_time": response.elapsed.total_seconds(),
"response_data": response.json() if response.status_code != 200 else None
}
logger.info(f"✅ Error handling (invalid user): {response.status_code}")
except Exception as e:
logger.error(f"❌ Error handling test failed: {str(e)}")
self.test_results["error_invalid_user"] = {
"status": "failed",
"error": str(e)
}
# Test invalid strategy ID
try:
response = self.session.get(
f"{self.base_url}/api/content-planning/strategies/999999"
)
self.test_results["error_invalid_strategy"] = {
"status": "passed" if response.status_code in [404, 400] else "failed",
"status_code": response.status_code,
"response_time": response.elapsed.total_seconds(),
"response_data": response.json() if response.status_code != 200 else None
}
logger.info(f"✅ Error handling (invalid strategy): {response.status_code}")
except Exception as e:
logger.error(f"❌ Error handling test failed: {str(e)}")
self.test_results["error_invalid_strategy"] = {
"status": "failed",
"error": str(e)
}
async def test_data_validation(self):
"""Test data validation scenarios."""
logger.info("🔍 Testing data validation")
# Test invalid strategy data
invalid_strategy_data = {
"user_id": "invalid", # Should be int
"name": "", # Should not be empty
"industry": "invalid_industry" # Should be valid industry
}
try:
response = self.session.post(
f"{self.base_url}/api/content-planning/strategies/",
json=invalid_strategy_data
)
self.test_results["validation_invalid_strategy"] = {
"status": "passed" if response.status_code in [422, 400] else "failed",
"status_code": response.status_code,
"response_time": response.elapsed.total_seconds(),
"response_data": response.json() if response.status_code != 200 else None
}
logger.info(f"✅ Data validation (invalid strategy): {response.status_code}")
except Exception as e:
logger.error(f"❌ Data validation test failed: {str(e)}")
self.test_results["validation_invalid_strategy"] = {
"status": "failed",
"error": str(e)
}
async def test_response_formats(self):
"""Test response format consistency."""
logger.info("🔍 Testing response formats")
# Test strategy response format
try:
response = self.session.get(
f"{self.base_url}/api/content-planning/strategies/?user_id=1"
)
if response.status_code == 200:
data = response.json()
has_required_fields = all(
field in data for field in ["strategies", "total_strategies"]
)
self.test_results["response_format_strategies"] = {
"status": "passed" if has_required_fields else "failed",
"has_required_fields": has_required_fields,
"response_structure": list(data.keys()) if isinstance(data, dict) else None
}
logger.info(f"✅ Response format (strategies): {has_required_fields}")
else:
self.test_results["response_format_strategies"] = {
"status": "failed",
"status_code": response.status_code
}
except Exception as e:
logger.error(f"❌ Response format test failed: {str(e)}")
self.test_results["response_format_strategies"] = {
"status": "failed",
"error": str(e)
}
async def test_performance_metrics(self):
"""Test performance metrics."""
logger.info("🔍 Testing performance metrics")
# Test response times for key endpoints
endpoints_to_test = [
"/api/content-planning/health",
"/api/content-planning/strategies/?user_id=1",
"/api/content-planning/calendar-events/?strategy_id=1",
"/api/content-planning/gap-analysis/?user_id=1"
]
performance_results = {}
for endpoint in endpoints_to_test:
try:
start_time = time.time()
response = self.session.get(f"{self.base_url}{endpoint}")
end_time = time.time()
response_time = end_time - start_time
performance_results[endpoint] = {
"response_time": response_time,
"status_code": response.status_code,
"is_successful": response.status_code == 200
}
logger.info(f"✅ Performance test {endpoint}: {response_time:.3f}s")
except Exception as e:
logger.error(f"❌ Performance test failed for {endpoint}: {str(e)}")
performance_results[endpoint] = {
"error": str(e),
"is_successful": False
}
self.test_results["performance_metrics"] = {
"status": "completed",
"results": performance_results,
"summary": {
"total_endpoints": len(endpoints_to_test),
"successful_requests": sum(1 for r in performance_results.values() if r.get("is_successful")),
"average_response_time": sum(r.get("response_time", 0) for r in performance_results.values()) / len(endpoints_to_test)
}
}
def run_functionality_test():
"""Run the comprehensive functionality test."""
test = ContentPlanningFunctionalityTest()
results = asyncio.run(test.run_all_tests())
# Print summary
print("\n" + "="*60)
print("FUNCTIONALITY TEST RESULTS SUMMARY")
print("="*60)
total_tests = len(results)
passed_tests = sum(1 for r in results.values() if r.get("status") == "passed")
failed_tests = total_tests - passed_tests
print(f"Total Tests: {total_tests}")
print(f"Passed: {passed_tests}")
print(f"Failed: {failed_tests}")
print(f"Success Rate: {(passed_tests/total_tests)*100:.1f}%")
if failed_tests > 0:
print("\nFailed Tests:")
for test_name, result in results.items():
if result.get("status") == "failed":
print(f" - {test_name}: {result.get('error', 'Unknown error')}")
# Save results to file
with open("functionality_test_results.json", "w") as f:
json.dump(results, f, indent=2, default=str)
print(f"\nDetailed results saved to: functionality_test_results.json")
print("="*60)
return results
if __name__ == "__main__":
run_functionality_test()

1789
backend/api/content_planning/tests/functionality_test_results.json Normal file
View File

File diff suppressed because it is too large Load Diff

109
backend/api/content_planning/tests/run_tests.py Normal file
View File

@@ -0,0 +1,109 @@
"""
Test Runner for Content Planning Module
Simple script to run functionality tests and establish baseline.
"""
import asyncio
import sys
import os
from pathlib import Path
# Add the parent directory to the path so we can import the test modules
sys.path.append(str(Path(__file__).parent.parent.parent))
from functionality_test import run_functionality_test
from before_after_test import run_before_after_comparison
from test_data import TestData
def run_baseline_test():
"""Run the baseline functionality test to establish current state."""
print("🧪 Running baseline functionality test...")
print("=" * 60)
try:
results = run_functionality_test()
# Print summary
total_tests = len(results)
passed_tests = sum(1 for r in results.values() if r.get("status") == "passed")
failed_tests = total_tests - passed_tests
print(f"\nBaseline Test Summary:")
print(f" Total Tests: {total_tests}")
print(f" Passed: {passed_tests}")
print(f" Failed: {failed_tests}")
print(f" Success Rate: {(passed_tests/total_tests)*100:.1f}%")
if failed_tests == 0:
print("🎉 All baseline tests passed!")
return True
else:
print(f"⚠️ {failed_tests} baseline tests failed.")
return False
except Exception as e:
print(f"❌ Baseline test failed: {str(e)}")
return False
def run_comparison_test():
"""Run the before/after comparison test."""
print("\n🔄 Running before/after comparison test...")
print("=" * 60)
try:
results = run_before_after_comparison()
# Print summary
total_tests = len(results)
passed_tests = sum(1 for r in results.values() if r.get("status") == "passed")
failed_tests = total_tests - passed_tests
print(f"\nComparison Test Summary:")
print(f" Total Tests: {total_tests}")
print(f" Passed: {passed_tests}")
print(f" Failed: {failed_tests}")
print(f" Success Rate: {(passed_tests/total_tests)*100:.1f}%")
if failed_tests == 0:
print("🎉 All comparison tests passed! Refactoring maintains functionality.")
return True
else:
print(f"⚠️ {failed_tests} comparison tests failed. Review differences carefully.")
return False
except Exception as e:
print(f"❌ Comparison test failed: {str(e)}")
return False
def main():
"""Main test runner function."""
print("🚀 Content Planning Module Test Runner")
print("=" * 60)
# Check if baseline file exists
baseline_file = "functionality_test_results.json"
baseline_exists = os.path.exists(baseline_file)
if not baseline_exists:
print("📋 No baseline found. Running baseline test first...")
baseline_success = run_baseline_test()
if not baseline_success:
print("❌ Baseline test failed. Cannot proceed with comparison.")
return False
else:
print("✅ Baseline file found. Skipping baseline test.")
# Run comparison test
comparison_success = run_comparison_test()
if comparison_success:
print("\n🎉 All tests completed successfully!")
return True
else:
print("\n❌ Some tests failed. Please review the results.")
return False
if __name__ == "__main__":
success = main()
sys.exit(0 if success else 1)

644
backend/api/content_planning/tests/test_data.py Normal file
View File

@@ -0,0 +1,644 @@
"""
Test Data and Fixtures for Content Planning Module
Centralized test data and fixtures for consistent testing across refactoring.
"""
from typing import Dict, Any, List
from datetime import datetime, timedelta
class TestData:
"""Centralized test data and fixtures for content planning tests."""
# Sample Strategies
SAMPLE_STRATEGIES = {
"technology_strategy": {
"user_id": 1,
"name": "Technology Content Strategy",
"industry": "technology",
"target_audience": {
"age_range": "25-45",
"interests": ["technology", "innovation", "AI", "machine learning"],
"location": "global",
"profession": "tech professionals"
},
"content_pillars": [
{"name": "Educational Content", "percentage": 40, "topics": ["AI", "ML", "Cloud Computing"]},
{"name": "Thought Leadership", "percentage": 30, "topics": ["Industry Trends", "Innovation"]},
{"name": "Product Updates", "percentage": 20, "topics": ["Product Features", "Releases"]},
{"name": "Team Culture", "percentage": 10, "topics": ["Company Culture", "Team Stories"]}
],
"ai_recommendations": {
"priority_topics": ["Artificial Intelligence", "Machine Learning", "Cloud Computing"],
"content_frequency": "daily",
"platform_focus": ["LinkedIn", "Website", "Twitter"],
"optimal_posting_times": {
"linkedin": "09:00-11:00",
"twitter": "12:00-14:00",
"website": "10:00-12:00"
}
}
},
"healthcare_strategy": {
"user_id": 2,
"name": "Healthcare Content Strategy",
"industry": "healthcare",
"target_audience": {
"age_range": "30-60",
"interests": ["health", "medicine", "wellness", "medical technology"],
"location": "US",
"profession": "healthcare professionals"
},
"content_pillars": [
{"name": "Patient Education", "percentage": 35, "topics": ["Health Tips", "Disease Prevention"]},
{"name": "Medical Insights", "percentage": 30, "topics": ["Medical Research", "Treatment Advances"]},
{"name": "Industry News", "percentage": 20, "topics": ["Healthcare Policy", "Industry Updates"]},
{"name": "Expert Opinions", "percentage": 15, "topics": ["Medical Expert Views", "Case Studies"]}
],
"ai_recommendations": {
"priority_topics": ["Telemedicine", "Digital Health", "Patient Care"],
"content_frequency": "weekly",
"platform_focus": ["LinkedIn", "Website", "YouTube"],
"optimal_posting_times": {
"linkedin": "08:00-10:00",
"website": "09:00-11:00",
"youtube": "18:00-20:00"
}
}
},
"finance_strategy": {
"user_id": 3,
"name": "Finance Content Strategy",
"industry": "finance",
"target_audience": {
"age_range": "25-55",
"interests": ["finance", "investment", "banking", "financial planning"],
"location": "global",
"profession": "finance professionals"
},
"content_pillars": [
{"name": "Financial Education", "percentage": 40, "topics": ["Investment Tips", "Financial Planning"]},
{"name": "Market Analysis", "percentage": 30, "topics": ["Market Trends", "Economic Updates"]},
{"name": "Regulatory Updates", "percentage": 20, "topics": ["Compliance", "Regulations"]},
{"name": "Success Stories", "percentage": 10, "topics": ["Case Studies", "Client Success"]}
],
"ai_recommendations": {
"priority_topics": ["Digital Banking", "Fintech", "Investment Strategies"],
"content_frequency": "weekly",
"platform_focus": ["LinkedIn", "Website", "Twitter"],
"optimal_posting_times": {
"linkedin": "07:00-09:00",
"website": "08:00-10:00",
"twitter": "12:00-14:00"
}
}
}
}
# Sample Calendar Events
SAMPLE_CALENDAR_EVENTS = {
"blog_post": {
"strategy_id": 1,
"title": "The Future of AI in 2024",
"description": "A comprehensive analysis of AI trends and their impact on various industries",
"content_type": "blog_post",
"platform": "website",
"scheduled_date": (datetime.now() + timedelta(days=7)).isoformat(),
"ai_recommendations": {
"optimal_time": "09:00",
"hashtags": ["#AI", "#Technology", "#Innovation", "#2024"],
"tone": "professional",
"target_audience": "tech professionals",
"estimated_read_time": "8 minutes"
}
},
"linkedin_post": {
"strategy_id": 1,
"title": "5 Key AI Trends Every Business Should Know",
"description": "Quick insights on AI trends that are reshaping business strategies",
"content_type": "social_post",
"platform": "linkedin",
"scheduled_date": (datetime.now() + timedelta(days=3)).isoformat(),
"ai_recommendations": {
"optimal_time": "08:30",
"hashtags": ["#AI", "#Business", "#Innovation", "#DigitalTransformation"],
"tone": "professional",
"target_audience": "business leaders",
"estimated_read_time": "3 minutes"
}
},
"video_content": {
"strategy_id": 1,
"title": "AI Implementation Guide for SMEs",
"description": "Step-by-step guide for small and medium enterprises to implement AI solutions",
"content_type": "video",
"platform": "youtube",
"scheduled_date": (datetime.now() + timedelta(days=10)).isoformat(),
"ai_recommendations": {
"optimal_time": "18:00",
"hashtags": ["#AI", "#SME", "#Implementation", "#Guide"],
"tone": "educational",
"target_audience": "small business owners",
"estimated_duration": "15 minutes"
}
}
}
# Sample Gap Analysis Data
SAMPLE_GAP_ANALYSIS = {
"technology_analysis": {
"user_id": 1,
"website_url": "https://techcompany.com",
"competitor_urls": [
"https://competitor1.com",
"https://competitor2.com",
"https://competitor3.com"
],
"target_keywords": [
"artificial intelligence",
"machine learning",
"cloud computing",
"digital transformation",
"AI implementation"
],
"industry": "technology",
"analysis_results": {
"content_gaps": [
{
"topic": "AI Ethics and Governance",
"gap_score": 85,
"opportunity_size": "high",
"competitor_coverage": "low"
},
{
"topic": "Edge Computing Solutions",
"gap_score": 78,
"opportunity_size": "medium",
"competitor_coverage": "medium"
},
{
"topic": "Quantum Computing Applications",
"gap_score": 92,
"opportunity_size": "high",
"competitor_coverage": "very_low"
}
],
"keyword_opportunities": [
{
"keyword": "AI ethics framework",
"search_volume": 1200,
"competition": "low",
"opportunity_score": 85
},
{
"keyword": "edge computing benefits",
"search_volume": 2400,
"competition": "medium",
"opportunity_score": 72
},
{
"keyword": "quantum computing use cases",
"search_volume": 1800,
"competition": "low",
"opportunity_score": 88
}
],
"competitor_insights": [
{
"competitor": "competitor1.com",
"strengths": ["Strong technical content", "Regular updates"],
"weaknesses": ["Limited practical guides", "No video content"],
"content_frequency": "weekly"
},
{
"competitor": "competitor2.com",
"strengths": ["Comprehensive guides", "Video content"],
"weaknesses": ["Outdated information", "Poor SEO"],
"content_frequency": "monthly"
}
]
},
"recommendations": [
{
"type": "content_creation",
"priority": "high",
"title": "Create AI Ethics Framework Guide",
"description": "Develop comprehensive guide on AI ethics and governance",
"estimated_impact": "high",
"implementation_time": "2 weeks"
},
{
"type": "content_optimization",
"priority": "medium",
"title": "Optimize for Edge Computing Keywords",
"description": "Update existing content to target edge computing opportunities",
"estimated_impact": "medium",
"implementation_time": "1 week"
}
]
}
}
# Sample AI Analytics Data
SAMPLE_AI_ANALYTICS = {
"content_evolution": {
"strategy_id": 1,
"time_period": "30d",
"results": {
"content_performance": {
"total_posts": 45,
"average_engagement": 78.5,
"top_performing_topics": ["AI", "Machine Learning", "Cloud Computing"],
"engagement_trend": "increasing"
},
"audience_growth": {
"follower_increase": 12.5,
"engagement_rate_change": 8.2,
"new_audience_segments": ["tech executives", "AI researchers"]
},
"content_recommendations": [
{
"topic": "AI Ethics",
"reason": "High engagement potential, low competition",
"priority": "high",
"estimated_impact": "15% engagement increase"
},
{
"topic": "Edge Computing",
"reason": "Growing trend, audience interest",
"priority": "medium",
"estimated_impact": "10% engagement increase"
}
]
}
},
"performance_trends": {
"strategy_id": 1,
"metrics": ["engagement_rate", "reach", "conversions"],
"results": {
"engagement_rate": {
"current": 78.5,
"trend": "increasing",
"change_percentage": 12.3,
"prediction": "85.2 (next 30 days)"
},
"reach": {
"current": 12500,
"trend": "stable",
"change_percentage": 5.1,
"prediction": "13200 (next 30 days)"
},
"conversions": {
"current": 45,
"trend": "increasing",
"change_percentage": 18.7,
"prediction": "52 (next 30 days)"
}
}
},
"strategic_intelligence": {
"strategy_id": 1,
"results": {
"market_positioning": {
"industry_position": "emerging_leader",
"competitive_advantage": "technical_expertise",
"market_share": "growing",
"brand_perception": "innovative"
},
"opportunity_analysis": [
{
"opportunity": "AI Ethics Leadership",
"potential_impact": "high",
"implementation_ease": "medium",
"timeline": "3-6 months"
},
{
"opportunity": "Edge Computing Expertise",
"potential_impact": "medium",
"implementation_ease": "high",
"timeline": "1-2 months"
}
],
"risk_assessment": [
{
"risk": "Competitor AI Content",
"severity": "medium",
"mitigation": "Accelerate AI ethics content creation"
},
{
"risk": "Market Saturation",
"severity": "low",
"mitigation": "Focus on unique technical perspectives"
}
]
}
}
}
# Sample Calendar Generation Data
SAMPLE_CALENDAR_GENERATION = {
"monthly_calendar": {
"user_id": 1,
"strategy_id": 1,
"calendar_type": "monthly",
"industry": "technology",
"business_size": "sme",
"force_refresh": False,
"expected_response": {
"user_id": 1,
"strategy_id": 1,
"calendar_type": "monthly",
"industry": "technology",
"business_size": "sme",
"generated_at": "2024-08-01T10:00:00Z",
"content_pillars": [
"Educational Content",
"Thought Leadership",
"Product Updates",
"Industry Insights",
"Team Culture"
],
"platform_strategies": {
"website": {
"content_types": ["blog_posts", "case_studies", "whitepapers"],
"frequency": "2-3 per week",
"optimal_length": "1500+ words"
},
"linkedin": {
"content_types": ["industry_insights", "professional_tips", "company_updates"],
"frequency": "daily",
"optimal_length": "100-300 words"
},
"twitter": {
"content_types": ["quick_tips", "industry_news", "engagement"],
"frequency": "3-5 per day",
"optimal_length": "280 characters"
}
},
"content_mix": {
"educational": 0.4,
"thought_leadership": 0.3,
"engagement": 0.2,
"promotional": 0.1
},
"daily_schedule": [
{
"day": "Monday",
"theme": "Educational Content",
"content_type": "blog_post",
"platform": "website",
"topic": "AI Implementation Guide"
},
{
"day": "Tuesday",
"theme": "Thought Leadership",
"content_type": "linkedin_post",
"platform": "linkedin",
"topic": "Industry Trends Analysis"
}
],
"weekly_themes": [
{
"week": 1,
"theme": "AI and Machine Learning",
"focus_areas": ["AI Ethics", "ML Implementation", "AI Trends"]
},
{
"week": 2,
"theme": "Cloud Computing",
"focus_areas": ["Cloud Security", "Migration Strategies", "Cost Optimization"]
}
],
"performance_predictions": {
"estimated_engagement": 85.5,
"predicted_reach": 15000,
"expected_conversions": 25
}
}
}
}
# Sample Content Optimization Data
SAMPLE_CONTENT_OPTIMIZATION = {
"blog_post_optimization": {
"user_id": 1,
"title": "The Future of AI in 2024",
"description": "A comprehensive analysis of AI trends and their impact on various industries",
"content_type": "blog_post",
"target_platform": "linkedin",
"original_content": {
"title": "AI Trends 2024",
"content": "Artificial Intelligence is transforming industries across the globe..."
},
"expected_response": {
"user_id": 1,
"original_content": {
"title": "AI Trends 2024",
"content": "Artificial Intelligence is transforming industries across the globe..."
},
"optimized_content": {
"title": "5 AI Trends That Will Dominate 2024",
"content": "Discover the top 5 artificial intelligence trends that are reshaping industries in 2024...",
"length": "optimized for LinkedIn",
"tone": "professional yet engaging"
},
"platform_adaptations": [
"Shortened for LinkedIn character limit",
"Added professional hashtags",
"Optimized for mobile reading"
],
"visual_recommendations": [
"Include infographic on AI trends",
"Add relevant industry statistics",
"Use professional stock images"
],
"hashtag_suggestions": [
"#AI", "#Technology", "#Innovation", "#2024", "#DigitalTransformation"
],
"keyword_optimization": {
"primary_keywords": ["AI trends", "artificial intelligence"],
"secondary_keywords": ["technology", "innovation", "2024"],
"keyword_density": "optimal"
},
"tone_adjustments": {
"original_tone": "technical",
"optimized_tone": "professional yet accessible",
"changes": "Simplified technical jargon, added engaging hooks"
},
"length_optimization": {
"original_length": "1500 words",
"optimized_length": "300 words",
"reason": "LinkedIn post optimization"
},
"performance_prediction": {
"estimated_engagement": 85,
"predicted_reach": 2500,
"confidence_score": 0.78
},
"optimization_score": 0.85
}
}
}
# Sample Error Scenarios
ERROR_SCENARIOS = {
"invalid_user_id": {
"endpoint": "/api/content-planning/strategies/?user_id=999999",
"expected_status": 404,
"expected_error": "User not found"
},
"invalid_strategy_id": {
"endpoint": "/api/content-planning/strategies/999999",
"expected_status": 404,
"expected_error": "Strategy not found"
},
"invalid_request_data": {
"endpoint": "/api/content-planning/strategies/",
"method": "POST",
"data": {
"user_id": "invalid",
"name": "",
"industry": "invalid_industry"
},
"expected_status": 422,
"expected_error": "Validation error"
},
"missing_required_fields": {
"endpoint": "/api/content-planning/strategies/",
"method": "POST",
"data": {
"user_id": 1
# Missing required fields
},
"expected_status": 422,
"expected_error": "Missing required fields"
}
}
# Sample Performance Data
PERFORMANCE_DATA = {
"baseline_metrics": {
"health_endpoint": {"response_time": 0.05, "status_code": 200},
"strategies_endpoint": {"response_time": 0.12, "status_code": 200},
"calendar_endpoint": {"response_time": 0.08, "status_code": 200},
"gap_analysis_endpoint": {"response_time": 0.15, "status_code": 200}
},
"acceptable_thresholds": {
"response_time": 0.5, # seconds
"status_code": 200,
"error_rate": 0.01 # 1%
}
}
@classmethod
def get_strategy_data(cls, industry: str = "technology") -> Dict[str, Any]:
"""Get sample strategy data for specified industry."""
key = f"{industry}_strategy"
return cls.SAMPLE_STRATEGIES.get(key, cls.SAMPLE_STRATEGIES["technology_strategy"])
@classmethod
def get_calendar_event_data(cls, event_type: str = "blog_post") -> Dict[str, Any]:
"""Get sample calendar event data for specified type."""
return cls.SAMPLE_CALENDAR_EVENTS.get(event_type, cls.SAMPLE_CALENDAR_EVENTS["blog_post"])
@classmethod
def get_gap_analysis_data(cls, industry: str = "technology") -> Dict[str, Any]:
"""Get sample gap analysis data for specified industry."""
key = f"{industry}_analysis"
return cls.SAMPLE_GAP_ANALYSIS.get(key, cls.SAMPLE_GAP_ANALYSIS["technology_analysis"])
@classmethod
def get_ai_analytics_data(cls, analysis_type: str = "content_evolution") -> Dict[str, Any]:
"""Get sample AI analytics data for specified type."""
return cls.SAMPLE_AI_ANALYTICS.get(analysis_type, cls.SAMPLE_AI_ANALYTICS["content_evolution"])
@classmethod
def get_calendar_generation_data(cls, calendar_type: str = "monthly") -> Dict[str, Any]:
"""Get sample calendar generation data for specified type."""
key = f"{calendar_type}_calendar"
return cls.SAMPLE_CALENDAR_GENERATION.get(key, cls.SAMPLE_CALENDAR_GENERATION["monthly_calendar"])
@classmethod
def get_content_optimization_data(cls, content_type: str = "blog_post") -> Dict[str, Any]:
"""Get sample content optimization data for specified type."""
key = f"{content_type}_optimization"
return cls.SAMPLE_CONTENT_OPTIMIZATION.get(key, cls.SAMPLE_CONTENT_OPTIMIZATION["blog_post_optimization"])
@classmethod
def get_error_scenario(cls, scenario_name: str) -> Dict[str, Any]:
"""Get sample error scenario data."""
return cls.ERROR_SCENARIOS.get(scenario_name, {})
@classmethod
def get_performance_baseline(cls) -> Dict[str, Any]:
"""Get performance baseline data."""
return cls.PERFORMANCE_DATA["baseline_metrics"]
@classmethod
def get_performance_thresholds(cls) -> Dict[str, Any]:
"""Get performance threshold data."""
return cls.PERFORMANCE_DATA["acceptable_thresholds"]
# Test data factory functions
def create_test_strategy(industry: str = "technology", user_id: int = 1) -> Dict[str, Any]:
"""Create a test strategy with specified parameters."""
strategy_data = TestData.get_strategy_data(industry).copy()
strategy_data["user_id"] = user_id
return strategy_data
def create_test_calendar_event(strategy_id: int = 1, event_type: str = "blog_post") -> Dict[str, Any]:
"""Create a test calendar event with specified parameters."""
event_data = TestData.get_calendar_event_data(event_type).copy()
event_data["strategy_id"] = strategy_id
return event_data
def create_test_gap_analysis(user_id: int = 1, industry: str = "technology") -> Dict[str, Any]:
"""Create a test gap analysis with specified parameters."""
analysis_data = TestData.get_gap_analysis_data(industry).copy()
analysis_data["user_id"] = user_id
return analysis_data
def create_test_ai_analytics(strategy_id: int = 1, analysis_type: str = "content_evolution") -> Dict[str, Any]:
"""Create a test AI analytics request with specified parameters."""
analytics_data = TestData.get_ai_analytics_data(analysis_type).copy()
analytics_data["strategy_id"] = strategy_id
return analytics_data
def create_test_calendar_generation(user_id: int = 1, strategy_id: int = 1, calendar_type: str = "monthly") -> Dict[str, Any]:
"""Create a test calendar generation request with specified parameters."""
generation_data = TestData.get_calendar_generation_data(calendar_type).copy()
generation_data["user_id"] = user_id
generation_data["strategy_id"] = strategy_id
return generation_data
def create_test_content_optimization(user_id: int = 1, content_type: str = "blog_post") -> Dict[str, Any]:
"""Create a test content optimization request with specified parameters."""
optimization_data = TestData.get_content_optimization_data(content_type).copy()
optimization_data["user_id"] = user_id
return optimization_data
# Validation functions
def validate_strategy_data(data: Dict[str, Any]) -> bool:
"""Validate strategy data structure."""
required_fields = ["user_id", "name", "industry", "target_audience"]
return all(field in data for field in required_fields)
def validate_calendar_event_data(data: Dict[str, Any]) -> bool:
"""Validate calendar event data structure."""
required_fields = ["strategy_id", "title", "description", "content_type", "platform", "scheduled_date"]
return all(field in data for field in required_fields)
def validate_gap_analysis_data(data: Dict[str, Any]) -> bool:
"""Validate gap analysis data structure."""
required_fields = ["user_id", "website_url", "competitor_urls"]
return all(field in data for field in required_fields)
def validate_response_structure(response: Dict[str, Any], expected_keys: List[str]) -> bool:
"""Validate response structure has expected keys."""
return all(key in response for key in expected_keys)
def validate_performance_metrics(response_time: float, status_code: int, thresholds: Dict[str, Any]) -> bool:
"""Validate performance metrics against thresholds."""
return (
response_time <= thresholds.get("response_time", 0.5) and
status_code == thresholds.get("status_code", 200)
)