Reorganize test files
This commit is contained in:
Urtzi Alfaro
@@ -1,488 +0,0 @@
|
||||
# ================================================================
|
||||
# validate_data_service_fixed.py - FIXED VERSION
|
||||
# ================================================================
|
||||
|
||||
import asyncio
|
||||
import httpx
|
||||
import json
|
||||
import sys
|
||||
import traceback
|
||||
from datetime import datetime
|
||||
from typing import Optional, Dict, Any
|
||||
import uuid
|
||||
|
||||
# Configuración
|
||||
AUTH_URL = "http://localhost:8001"
|
||||
DATA_URL = "http://localhost:8004"
|
||||
GATEWAY_URL = "http://localhost:8000"
|
||||
|
||||
class DataServiceValidator:
|
||||
"""Validador completo para el Data Service - FIXED VERSION"""
|
||||
|
||||
def __init__(self, use_gateway: bool = False):
|
||||
self.auth_token: Optional[str] = None
|
||||
self.use_gateway = use_gateway
|
||||
self.base_url = GATEWAY_URL if use_gateway else DATA_URL
|
||||
self.auth_base_url = GATEWAY_URL if use_gateway else AUTH_URL
|
||||
self.user_data = None
|
||||
|
||||
async def test_service_health(self) -> bool:
|
||||
"""Verificar que los servicios estén funcionando"""
|
||||
print("🔍 Checking service health...")
|
||||
|
||||
try:
|
||||
async with httpx.AsyncClient(timeout=10.0) as client:
|
||||
# Test auth service
|
||||
auth_response = await client.get(f"{AUTH_URL}/health")
|
||||
if auth_response.status_code == 200:
|
||||
print("✅ Auth service is healthy")
|
||||
else:
|
||||
print(f"❌ Auth service unhealthy: {auth_response.status_code}")
|
||||
return False
|
||||
|
||||
# Test data service
|
||||
data_response = await client.get(f"{DATA_URL}/health")
|
||||
if data_response.status_code == 200:
|
||||
print("✅ Data service is healthy")
|
||||
else:
|
||||
print(f"❌ Data service unhealthy: {data_response.status_code}")
|
||||
return False
|
||||
|
||||
# Test gateway if using it
|
||||
if self.use_gateway:
|
||||
gateway_response = await client.get(f"{GATEWAY_URL}/health")
|
||||
if gateway_response.status_code == 200:
|
||||
print("✅ Gateway is healthy")
|
||||
else:
|
||||
print(f"❌ Gateway unhealthy: {gateway_response.status_code}")
|
||||
return False
|
||||
|
||||
return True
|
||||
|
||||
except httpx.ConnectError as e:
|
||||
print(f"❌ Connection error: {e}")
|
||||
print("💡 Make sure services are running with: docker-compose up -d")
|
||||
return False
|
||||
except Exception as e:
|
||||
print(f"❌ Health check failed: {e}")
|
||||
return False
|
||||
|
||||
async def authenticate(self) -> bool:
|
||||
"""Autenticar y obtener token"""
|
||||
print("🔐 Authenticating...")
|
||||
|
||||
try:
|
||||
async with httpx.AsyncClient(timeout=15.0) as client:
|
||||
# Generar tenant_id único para esta prueba
|
||||
tenant_id = str(uuid.uuid4())
|
||||
|
||||
# Datos de usuario de prueba con tenant_id
|
||||
self.user_data = {
|
||||
"email": "test@bakery.es",
|
||||
"password": "TestPass123",
|
||||
"full_name": "Test User",
|
||||
"language": "es",
|
||||
"tenant_id": tenant_id # ✅ AÑADIR TENANT_ID
|
||||
}
|
||||
|
||||
# Intentar registrar usuario (puede fallar si ya existe)
|
||||
register_endpoint = f"{self.auth_base_url}/api/v1/auth/register"
|
||||
register_response = await client.post(register_endpoint, json=self.user_data)
|
||||
|
||||
if register_response.status_code == 200:
|
||||
print("✅ User registered successfully")
|
||||
elif register_response.status_code == 409:
|
||||
print("ℹ️ User already exists, proceeding with login")
|
||||
elif register_response.status_code == 400:
|
||||
print("⚠️ Registration validation error, trying login")
|
||||
else:
|
||||
print(f"⚠️ Registration response: {register_response.status_code}")
|
||||
print(f"Response body: {register_response.text}")
|
||||
|
||||
# Login con credenciales
|
||||
login_data = {
|
||||
"email": self.user_data["email"],
|
||||
"password": self.user_data["password"]
|
||||
}
|
||||
|
||||
login_endpoint = f"{self.auth_base_url}/api/v1/auth/login"
|
||||
login_response = await client.post(login_endpoint, json=login_data)
|
||||
|
||||
if login_response.status_code == 200:
|
||||
response_data = login_response.json()
|
||||
self.auth_token = response_data["access_token"]
|
||||
print("✅ Authentication successful")
|
||||
|
||||
# Verificar que el token tenga los campos necesarios
|
||||
verify_endpoint = f"{self.auth_base_url}/api/v1/auth/verify"
|
||||
verify_response = await client.post(
|
||||
verify_endpoint,
|
||||
headers={"Authorization": f"Bearer {self.auth_token}"}
|
||||
)
|
||||
|
||||
if verify_response.status_code == 200:
|
||||
token_data = verify_response.json()
|
||||
print(f"🔍 Token contains: {list(token_data.keys())}")
|
||||
|
||||
# Verificar campos necesarios
|
||||
required_fields = ["user_id", "email", "tenant_id"]
|
||||
missing_fields = [field for field in required_fields if field not in token_data]
|
||||
|
||||
if missing_fields:
|
||||
print(f"⚠️ Token missing fields: {missing_fields}")
|
||||
else:
|
||||
print("✅ Token has all required fields")
|
||||
|
||||
return True
|
||||
else:
|
||||
print(f"⚠️ Token verification failed: {verify_response.status_code}")
|
||||
return True # Continuar de todas formas
|
||||
else:
|
||||
print(f"❌ Login failed: {login_response.status_code}")
|
||||
print(f"Response: {login_response.text}")
|
||||
return False
|
||||
|
||||
except Exception as e:
|
||||
print(f"❌ Authentication failed: {e}")
|
||||
traceback.print_exc()
|
||||
return False
|
||||
|
||||
def get_headers(self) -> Dict[str, str]:
|
||||
"""Obtener headers con token de autenticación"""
|
||||
if not self.auth_token:
|
||||
raise ValueError("No authentication token available")
|
||||
return {"Authorization": f"Bearer {self.auth_token}"}
|
||||
|
||||
async def test_weather_endpoints(self) -> bool:
|
||||
"""Probar endpoints de clima"""
|
||||
print("🌤️ Testing weather endpoints...")
|
||||
|
||||
try:
|
||||
headers = self.get_headers()
|
||||
madrid_coords = {"latitude": 40.4168, "longitude": -3.7038}
|
||||
|
||||
async with httpx.AsyncClient(timeout=20.0) as client:
|
||||
# Current weather - FIXED URL
|
||||
if self.use_gateway:
|
||||
current_endpoint = f"{self.base_url}/api/v1/data/weather/current"
|
||||
else:
|
||||
current_endpoint = f"{self.base_url}/api/v1/weather/current"
|
||||
|
||||
print(f"🔗 Requesting: {current_endpoint}")
|
||||
current_response = await client.get(
|
||||
current_endpoint,
|
||||
params=madrid_coords,
|
||||
headers=headers
|
||||
)
|
||||
|
||||
if current_response.status_code == 200:
|
||||
weather = current_response.json()
|
||||
print(f"✅ Current weather: {weather.get('temperature')}°C, {weather.get('description')}")
|
||||
else:
|
||||
print(f"❌ Current weather failed: {current_response.status_code}")
|
||||
print(f"Response: {current_response.text}")
|
||||
|
||||
# Si falla, intentar con mock data
|
||||
if current_response.status_code == 503:
|
||||
print("ℹ️ External API unavailable, this is expected in test environment")
|
||||
return True
|
||||
|
||||
return False
|
||||
|
||||
# Weather forecast
|
||||
if self.use_gateway:
|
||||
forecast_endpoint = f"{self.base_url}/api/v1/data/weather/forecast"
|
||||
else:
|
||||
forecast_endpoint = f"{self.base_url}/api/v1/weather/forecast"
|
||||
|
||||
forecast_response = await client.get(
|
||||
forecast_endpoint,
|
||||
params={**madrid_coords, "days": 3},
|
||||
headers=headers
|
||||
)
|
||||
|
||||
if forecast_response.status_code == 200:
|
||||
forecast = forecast_response.json()
|
||||
print(f"✅ Weather forecast: {len(forecast)} days")
|
||||
return True
|
||||
elif forecast_response.status_code == 503:
|
||||
print("ℹ️ Forecast API unavailable, this is expected in test environment")
|
||||
return True
|
||||
else:
|
||||
print(f"❌ Weather forecast failed: {forecast_response.status_code}")
|
||||
return False
|
||||
|
||||
except Exception as e:
|
||||
print(f"❌ Weather tests failed: {e}")
|
||||
traceback.print_exc()
|
||||
return False
|
||||
|
||||
async def test_traffic_endpoints(self) -> bool:
|
||||
"""Probar endpoints de tráfico"""
|
||||
print("🚦 Testing traffic endpoints...")
|
||||
|
||||
try:
|
||||
headers = self.get_headers()
|
||||
madrid_coords = {"latitude": 40.4168, "longitude": -3.7038}
|
||||
|
||||
async with httpx.AsyncClient(timeout=20.0) as client:
|
||||
# Current traffic - FIXED URL
|
||||
if self.use_gateway:
|
||||
current_endpoint = f"{self.base_url}/api/v1/data/traffic/current"
|
||||
else:
|
||||
current_endpoint = f"{self.base_url}/api/v1/traffic/current"
|
||||
|
||||
print(f"🔗 Requesting: {current_endpoint}")
|
||||
current_response = await client.get(
|
||||
current_endpoint,
|
||||
params=madrid_coords,
|
||||
headers=headers
|
||||
)
|
||||
|
||||
if current_response.status_code == 200:
|
||||
traffic = current_response.json()
|
||||
print(f"✅ Current traffic: {traffic.get('traffic_volume')} vehicles, {traffic.get('congestion_level')} congestion")
|
||||
return True
|
||||
elif current_response.status_code == 503:
|
||||
print("ℹ️ Traffic API unavailable, this is expected in test environment")
|
||||
return True
|
||||
else:
|
||||
print(f"❌ Current traffic failed: {current_response.status_code}")
|
||||
print(f"Response: {current_response.text}")
|
||||
return False
|
||||
|
||||
except Exception as e:
|
||||
print(f"❌ Traffic tests failed: {e}")
|
||||
traceback.print_exc()
|
||||
return False
|
||||
|
||||
async def test_sales_endpoints(self) -> bool:
|
||||
"""Probar endpoints de ventas"""
|
||||
print("📊 Testing sales endpoints...")
|
||||
|
||||
try:
|
||||
headers = self.get_headers()
|
||||
|
||||
# Usar tenant_id del usuario autenticado
|
||||
tenant_id = self.user_data.get("tenant_id", str(uuid.uuid4()))
|
||||
|
||||
# Datos de prueba
|
||||
sales_data = {
|
||||
"tenant_id": tenant_id,
|
||||
"date": datetime.now().isoformat(),
|
||||
"product_name": "Pan Integral Test",
|
||||
"quantity_sold": 25,
|
||||
"revenue": 37.50,
|
||||
"location_id": "madrid_centro",
|
||||
"source": "test"
|
||||
}
|
||||
|
||||
async with httpx.AsyncClient(timeout=20.0) as client:
|
||||
# Create sales record - FIXED URL
|
||||
if self.use_gateway:
|
||||
create_endpoint = f"{self.base_url}/api/v1/data/sales/"
|
||||
else:
|
||||
create_endpoint = f"{self.base_url}/api/v1/sales/"
|
||||
|
||||
print(f"🔗 Requesting: {create_endpoint}")
|
||||
create_response = await client.post(
|
||||
create_endpoint,
|
||||
json=sales_data,
|
||||
headers=headers
|
||||
)
|
||||
|
||||
if create_response.status_code == 200:
|
||||
record = create_response.json()
|
||||
print(f"✅ Sales record created: ID {record.get('id')}")
|
||||
else:
|
||||
print(f"❌ Sales creation failed: {create_response.status_code}")
|
||||
print(f"Response: {create_response.text}")
|
||||
return False
|
||||
|
||||
# Test import template
|
||||
if self.use_gateway:
|
||||
template_endpoint = f"{self.base_url}/api/v1/data/sales/import/template/csv"
|
||||
else:
|
||||
template_endpoint = f"{self.base_url}/api/v1/sales/import/template/csv"
|
||||
|
||||
template_response = await client.get(
|
||||
template_endpoint,
|
||||
headers=headers
|
||||
)
|
||||
|
||||
if template_response.status_code == 200:
|
||||
print("✅ Import template generated successfully")
|
||||
return True
|
||||
else:
|
||||
print(f"❌ Template generation failed: {template_response.status_code}")
|
||||
print(f"Response: {template_response.text}")
|
||||
return False
|
||||
|
||||
except Exception as e:
|
||||
print(f"❌ Sales tests failed: {e}")
|
||||
traceback.print_exc()
|
||||
return False
|
||||
|
||||
async def test_import_functionality(self) -> bool:
|
||||
"""Probar funcionalidad de importación"""
|
||||
print("📄 Testing import functionality...")
|
||||
|
||||
try:
|
||||
headers = self.get_headers()
|
||||
|
||||
# Usar tenant_id del usuario autenticado
|
||||
tenant_id = self.user_data.get("tenant_id", str(uuid.uuid4()))
|
||||
|
||||
# Crear CSV de prueba
|
||||
csv_content = """fecha,producto,cantidad,ingresos
|
||||
15/01/2024,Pan Integral,25,37.50
|
||||
15/01/2024,Croissant,15,22.50
|
||||
15/01/2024,Café con Leche,10,20.00"""
|
||||
|
||||
# Test CSV import
|
||||
import_data = {
|
||||
"tenant_id": tenant_id,
|
||||
"data_format": "csv",
|
||||
"data": csv_content
|
||||
}
|
||||
|
||||
async with httpx.AsyncClient(timeout=30.0) as client:
|
||||
if self.use_gateway:
|
||||
import_endpoint = f"{self.base_url}/api/v1/data/sales/import/json"
|
||||
else:
|
||||
import_endpoint = f"{self.base_url}/api/v1/sales/import/json"
|
||||
|
||||
print(f"🔗 Requesting: {import_endpoint}")
|
||||
import_response = await client.post(
|
||||
import_endpoint,
|
||||
json=import_data,
|
||||
headers=headers
|
||||
)
|
||||
|
||||
if import_response.status_code == 200:
|
||||
result = import_response.json()
|
||||
if result.get("success"):
|
||||
print(f"✅ CSV import successful: {result.get('records_created')} records created")
|
||||
return True
|
||||
else:
|
||||
print(f"❌ CSV import failed: {result.get('error')}")
|
||||
return False
|
||||
elif import_response.status_code == 422:
|
||||
print("ℹ️ Import validation error (expected in test environment)")
|
||||
return True
|
||||
else:
|
||||
print(f"❌ Import request failed: {import_response.status_code}")
|
||||
print(f"Response: {import_response.text}")
|
||||
return False
|
||||
|
||||
except Exception as e:
|
||||
print(f"❌ Import tests failed: {e}")
|
||||
traceback.print_exc()
|
||||
return False
|
||||
|
||||
async def main():
|
||||
"""Función principal de validación"""
|
||||
print("🚀 Starting Data Service Validation - FIXED VERSION")
|
||||
print("=" * 60)
|
||||
|
||||
# Preguntar si usar gateway
|
||||
use_gateway_input = input("Use API Gateway? (y/N): ").lower()
|
||||
use_gateway = use_gateway_input == 'y'
|
||||
|
||||
if use_gateway:
|
||||
print("📡 Testing via API Gateway")
|
||||
else:
|
||||
print("🔗 Testing direct service connections")
|
||||
|
||||
validator = DataServiceValidator(use_gateway=use_gateway)
|
||||
|
||||
try:
|
||||
# 1. Health checks
|
||||
print("\n" + "="*20 + " HEALTH CHECKS " + "="*20)
|
||||
if not await validator.test_service_health():
|
||||
print("\n❌ Health checks failed. Ensure services are running.")
|
||||
return False
|
||||
|
||||
# 2. Authentication
|
||||
print("\n" + "="*20 + " AUTHENTICATION " + "="*20)
|
||||
if not await validator.authenticate():
|
||||
print("\n❌ Authentication failed.")
|
||||
return False
|
||||
|
||||
# 3. Weather tests
|
||||
print("\n" + "="*20 + " WEATHER TESTS " + "="*20)
|
||||
if not await validator.test_weather_endpoints():
|
||||
print("\n❌ Weather endpoint tests failed.")
|
||||
return False
|
||||
|
||||
# 4. Traffic tests
|
||||
print("\n" + "="*20 + " TRAFFIC TESTS " + "="*20)
|
||||
if not await validator.test_traffic_endpoints():
|
||||
print("\n❌ Traffic endpoint tests failed.")
|
||||
return False
|
||||
|
||||
# 5. Sales tests
|
||||
print("\n" + "="*20 + " SALES TESTS " + "="*20)
|
||||
if not await validator.test_sales_endpoints():
|
||||
print("\n❌ Sales endpoint tests failed.")
|
||||
return False
|
||||
|
||||
# 6. Import tests
|
||||
print("\n" + "="*20 + " IMPORT TESTS " + "="*20)
|
||||
if not await validator.test_import_functionality():
|
||||
print("\n❌ Import functionality tests failed.")
|
||||
return False
|
||||
|
||||
print("\n" + "=" * 60)
|
||||
print("🎉 ALL TESTS PASSED! Data Service is working correctly!")
|
||||
print("=" * 60)
|
||||
return True
|
||||
|
||||
except KeyboardInterrupt:
|
||||
print("\n⚠️ Tests interrupted by user")
|
||||
return False
|
||||
except Exception as e:
|
||||
print(f"\n❌ Unexpected error: {e}")
|
||||
print("Traceback:")
|
||||
traceback.print_exc()
|
||||
return False
|
||||
|
||||
def check_dependencies():
|
||||
"""Verificar que las dependencias estén instaladas"""
|
||||
try:
|
||||
import httpx
|
||||
print("✅ httpx is available")
|
||||
except ImportError:
|
||||
print("❌ httpx not found. Install with: pip install httpx")
|
||||
return False
|
||||
|
||||
return True
|
||||
|
||||
if __name__ == "__main__":
|
||||
print("🔧 Checking dependencies...")
|
||||
|
||||
if not check_dependencies():
|
||||
print("\n💡 Install dependencies with:")
|
||||
print("pip install httpx")
|
||||
sys.exit(1)
|
||||
|
||||
print("✅ All dependencies available")
|
||||
print()
|
||||
|
||||
# Ejecutar validación
|
||||
success = asyncio.run(main())
|
||||
|
||||
if success:
|
||||
print("\n🎯 Next steps:")
|
||||
print("1. Check logs: docker-compose logs -f data-service")
|
||||
print("2. Connect to DB: docker-compose exec data-db psql -U data_user -d data_db")
|
||||
print("3. Test with real data imports")
|
||||
print("4. Check monitoring: http://localhost:3002")
|
||||
sys.exit(0)
|
||||
else:
|
||||
print("\n🔧 Troubleshooting:")
|
||||
print("1. Check services: docker-compose ps")
|
||||
print("2. Restart services: docker-compose restart")
|
||||
print("3. Check logs: docker-compose logs data-service")
|
||||
print("4. Check gateway logs: docker-compose logs gateway")
|
||||
sys.exit(1)
|
||||
886
tests/test_onboarding_flow.sh
Executable file
886
tests/test_onboarding_flow.sh
Executable file
@@ -0,0 +1,886 @@
|
||||
#!/bin/bash
|
||||
|
||||
# =================================================================
|
||||
# IMPROVED ONBOARDING FLOW SIMULATION TEST SCRIPT
|
||||
# =================================================================
|
||||
# This script simulates the complete onboarding process using the
|
||||
# real CSV data and proper import/validate endpoints
|
||||
|
||||
# Configuration
|
||||
API_BASE="http://localhost:8000"
|
||||
TEST_EMAIL="onboarding.test.$(date +%s)@bakery.com"
|
||||
TEST_PASSWORD="TestPassword123!"
|
||||
TEST_NAME="Test Bakery Owner"
|
||||
REAL_CSV_FILE="bakery_sales_2023_2024.csv"
|
||||
|
||||
# Colors for output
|
||||
RED='\033[0;31m'
|
||||
GREEN='\033[0;32m'
|
||||
YELLOW='\033[1;33m'
|
||||
BLUE='\033[0;34m'
|
||||
PURPLE='\033[0;35m'
|
||||
CYAN='\033[0;36m'
|
||||
NC='\033[0m' # No Color
|
||||
|
||||
# Icons for steps
|
||||
STEP_ICONS=("👤" "🏪" "📊" "🤖" "🎉")
|
||||
|
||||
echo -e "${CYAN}🧪 IMPROVED ONBOARDING FLOW SIMULATION TEST${NC}"
|
||||
echo -e "${CYAN}==============================================${NC}"
|
||||
echo "Testing complete user journey through onboarding process"
|
||||
echo "Using real CSV data: $REAL_CSV_FILE"
|
||||
echo "Test User: $TEST_EMAIL"
|
||||
echo ""
|
||||
|
||||
# Utility functions
|
||||
log_step() {
|
||||
echo -e "${BLUE}📋 $1${NC}"
|
||||
}
|
||||
|
||||
log_success() {
|
||||
echo -e "${GREEN}✅ $1${NC}"
|
||||
}
|
||||
|
||||
log_error() {
|
||||
echo -e "${RED}❌ $1${NC}"
|
||||
}
|
||||
|
||||
log_warning() {
|
||||
echo -e "${YELLOW}⚠️ $1${NC}"
|
||||
}
|
||||
|
||||
check_response() {
|
||||
local response="$1"
|
||||
local step_name="$2"
|
||||
|
||||
# Check for common error patterns
|
||||
if echo "$response" | grep -q '"detail"' && echo "$response" | grep -q '"error"'; then
|
||||
log_error "$step_name FAILED"
|
||||
echo "Error details: $response"
|
||||
return 1
|
||||
elif echo "$response" | grep -q '500 Internal Server Error'; then
|
||||
log_error "$step_name FAILED - Server Error"
|
||||
echo "Response: $response"
|
||||
return 1
|
||||
elif echo "$response" | grep -q '"status".*"error"'; then
|
||||
log_error "$step_name FAILED"
|
||||
echo "Response: $response"
|
||||
return 1
|
||||
elif echo "$response" | grep -q '"detail".*\['; then
|
||||
# This catches Pydantic validation errors (array of error objects)
|
||||
log_error "$step_name FAILED - Validation Error"
|
||||
echo "Response: $response"
|
||||
return 1
|
||||
else
|
||||
log_success "$step_name PASSED"
|
||||
return 0
|
||||
fi
|
||||
}
|
||||
|
||||
# New function specifically for validation responses
|
||||
check_validation_response() {
|
||||
local response="$1"
|
||||
local http_code="$2"
|
||||
local step_name="$3"
|
||||
|
||||
# Check HTTP status first
|
||||
if [ "$http_code" != "200" ]; then
|
||||
log_error "$step_name FAILED - HTTP $http_code"
|
||||
echo "Response: $response"
|
||||
return 1
|
||||
fi
|
||||
|
||||
# Check for validation-specific success indicators
|
||||
if echo "$response" | grep -q '"is_valid".*true'; then
|
||||
log_success "$step_name PASSED"
|
||||
return 0
|
||||
elif echo "$response" | grep -q '"is_valid".*false'; then
|
||||
log_warning "$step_name FAILED - Validation errors found"
|
||||
return 1
|
||||
else
|
||||
# Fall back to generic error checking
|
||||
check_response "$response" "$step_name"
|
||||
return $?
|
||||
fi
|
||||
}
|
||||
|
||||
extract_json_field() {
|
||||
local response="$1"
|
||||
local field="$2"
|
||||
|
||||
# Create a temporary file for the JSON to avoid shell escaping issues
|
||||
local temp_file="/tmp/json_response_$.json"
|
||||
echo "$response" > "$temp_file"
|
||||
|
||||
python3 -c "
|
||||
import json
|
||||
try:
|
||||
with open('$temp_file', 'r') as f:
|
||||
data = json.load(f)
|
||||
value = data.get('$field', '')
|
||||
print(value)
|
||||
except Exception as e:
|
||||
print('')
|
||||
" 2>/dev/null || echo ""
|
||||
|
||||
# Clean up
|
||||
rm -f "$temp_file"
|
||||
}
|
||||
|
||||
# Function to read and prepare CSV data for JSON import
|
||||
prepare_csv_for_import() {
|
||||
local csv_file="$1"
|
||||
local output_file="$2"
|
||||
local max_records="${3:-50}" # Limit records for testing
|
||||
|
||||
if [ ! -f "$csv_file" ]; then
|
||||
log_error "CSV file not found: $csv_file"
|
||||
return 1
|
||||
fi
|
||||
|
||||
log_step "Preparing CSV data for import (first $max_records records)"
|
||||
|
||||
# Get header and first N records
|
||||
head -n 1 "$csv_file" > "$output_file"
|
||||
tail -n +2 "$csv_file" | head -n "$max_records" >> "$output_file"
|
||||
|
||||
log_success "Prepared $(wc -l < "$output_file") lines (including header)"
|
||||
|
||||
# Show sample of the data
|
||||
echo "Sample of prepared data:"
|
||||
head -5 "$output_file"
|
||||
echo "..."
|
||||
|
||||
return 0
|
||||
}
|
||||
|
||||
# Function to escape CSV content for JSON
|
||||
escape_csv_for_json() {
|
||||
local csv_file="$1"
|
||||
# Use Python to properly escape for JSON to avoid sed issues
|
||||
python3 -c "
|
||||
import json
|
||||
import sys
|
||||
|
||||
# Read the CSV file
|
||||
with open('$csv_file', 'r', encoding='utf-8') as f:
|
||||
content = f.read()
|
||||
|
||||
# Escape for JSON (this handles newlines, quotes, and control characters properly)
|
||||
escaped = json.dumps(content)[1:-1] # Remove the surrounding quotes that json.dumps adds
|
||||
print(escaped)
|
||||
"
|
||||
}
|
||||
|
||||
# Function to check for timezone-related errors
|
||||
check_timezone_error() {
|
||||
local response="$1"
|
||||
if echo "$response" | grep -q "Cannot convert tz-naive Timestamp"; then
|
||||
return 0 # Found timezone error
|
||||
fi
|
||||
return 1 # No timezone error
|
||||
}
|
||||
|
||||
# =================================================================
|
||||
# PRE-FLIGHT CHECKS
|
||||
# =================================================================
|
||||
|
||||
echo -e "${PURPLE}🔍 Pre-flight checks...${NC}"
|
||||
|
||||
# Check if services are running
|
||||
if ! curl -s "$API_BASE/health" > /dev/null; then
|
||||
log_error "API Gateway is not responding at $API_BASE"
|
||||
echo "Please ensure services are running: docker-compose up -d"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
log_success "API Gateway is responding"
|
||||
|
||||
# Check if CSV file exists
|
||||
if [ ! -f "$REAL_CSV_FILE" ]; then
|
||||
log_error "Real CSV file not found: $REAL_CSV_FILE"
|
||||
echo "Please ensure the CSV file is in the current directory"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
log_success "Real CSV file found: $REAL_CSV_FILE"
|
||||
|
||||
# Show CSV file info
|
||||
echo "CSV file info:"
|
||||
echo " Lines: $(wc -l < "$REAL_CSV_FILE")"
|
||||
echo " Size: $(du -h "$REAL_CSV_FILE" | cut -f1)"
|
||||
echo " Header: $(head -1 "$REAL_CSV_FILE")"
|
||||
|
||||
# Check individual services
|
||||
services_check() {
|
||||
local service_ports=("8001:Auth" "8002:Training" "8003:Data" "8005:Tenant")
|
||||
for service in "${service_ports[@]}"; do
|
||||
IFS=':' read -r port name <<< "$service"
|
||||
if curl -s "http://localhost:$port/health" > /dev/null; then
|
||||
echo " ✓ $name Service (port $port)"
|
||||
else
|
||||
log_warning "$name Service not responding on port $port"
|
||||
fi
|
||||
done
|
||||
}
|
||||
|
||||
services_check
|
||||
echo ""
|
||||
|
||||
# =================================================================
|
||||
# STEP 1: USER REGISTRATION (ONBOARDING PAGE STEP 1)
|
||||
# =================================================================
|
||||
|
||||
echo -e "${STEP_ICONS[0]} ${PURPLE}STEP 1: USER REGISTRATION${NC}"
|
||||
echo "Simulating onboarding page step 1 - 'Crear Cuenta'"
|
||||
echo ""
|
||||
|
||||
log_step "1.1. Registering new user account"
|
||||
echo "Email: $TEST_EMAIL"
|
||||
echo "Full Name: $TEST_NAME"
|
||||
echo "Password: [HIDDEN]"
|
||||
|
||||
REGISTER_RESPONSE=$(curl -s -X POST "$API_BASE/api/v1/auth/register" \
|
||||
-H "Content-Type: application/json" \
|
||||
-d "{
|
||||
\"email\": \"$TEST_EMAIL\",
|
||||
\"password\": \"$TEST_PASSWORD\",
|
||||
\"full_name\": \"$TEST_NAME\"
|
||||
}")
|
||||
|
||||
echo "Registration Response:"
|
||||
echo "$REGISTER_RESPONSE" | python3 -m json.tool 2>/dev/null || echo "$REGISTER_RESPONSE"
|
||||
|
||||
if check_response "$REGISTER_RESPONSE" "User Registration"; then
|
||||
USER_ID=$(extract_json_field "$REGISTER_RESPONSE" "id")
|
||||
if [ -n "$USER_ID" ]; then
|
||||
log_success "User ID extracted: $USER_ID"
|
||||
fi
|
||||
else
|
||||
echo "Full response: $REGISTER_RESPONSE"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
echo ""
|
||||
|
||||
# =================================================================
|
||||
# STEP 1.5: USER LOGIN (AUTOMATIC AFTER REGISTRATION)
|
||||
# =================================================================
|
||||
|
||||
log_step "1.5. Automatic login after registration"
|
||||
|
||||
LOGIN_RESPONSE=$(curl -s -X POST "$API_BASE/api/v1/auth/login" \
|
||||
-H "Content-Type: application/json" \
|
||||
-d "{
|
||||
\"email\": \"$TEST_EMAIL\",
|
||||
\"password\": \"$TEST_PASSWORD\"
|
||||
}")
|
||||
|
||||
echo "Login Response:"
|
||||
echo "$LOGIN_RESPONSE" | python3 -m json.tool 2>/dev/null || echo "$LOGIN_RESPONSE"
|
||||
|
||||
ACCESS_TOKEN=$(extract_json_field "$LOGIN_RESPONSE" "access_token")
|
||||
|
||||
if [ -z "$ACCESS_TOKEN" ]; then
|
||||
log_error "Failed to extract access token"
|
||||
echo "Login response was: $LOGIN_RESPONSE"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
log_success "Login successful - Token obtained: ${ACCESS_TOKEN:0:30}..."
|
||||
echo ""
|
||||
|
||||
# =================================================================
|
||||
# STEP 2: BAKERY REGISTRATION (ONBOARDING PAGE STEP 2)
|
||||
# =================================================================
|
||||
|
||||
echo -e "${STEP_ICONS[1]} ${PURPLE}STEP 2: BAKERY REGISTRATION${NC}"
|
||||
echo "Simulating onboarding page step 2 - 'Datos de Panadería'"
|
||||
echo ""
|
||||
|
||||
log_step "2.1. Registering bakery/tenant with mock coordinates"
|
||||
|
||||
# Mock coordinates for Madrid locations (since geolocation service is not running)
|
||||
# These are real Madrid coordinates for testing weather and traffic data acquisition
|
||||
MADRID_COORDS=(
|
||||
"40.4168:-3.7038" # Sol (city center)
|
||||
"40.4378:-3.6795" # Retiro area
|
||||
"40.4093:-3.6936" # Atocha area
|
||||
"40.4517:-3.6847" # Chamberí area
|
||||
"40.3897:-3.6774" # Delicias area
|
||||
)
|
||||
|
||||
# Select random coordinates from Madrid locations
|
||||
SELECTED_COORDS=${MADRID_COORDS[$((RANDOM % ${#MADRID_COORDS[@]}))]}
|
||||
IFS=':' read -r MOCK_LATITUDE MOCK_LONGITUDE <<< "$SELECTED_COORDS"
|
||||
|
||||
echo "Using mock coordinates for Madrid:"
|
||||
echo " Latitude: $MOCK_LATITUDE"
|
||||
echo " Longitude: $MOCK_LONGITUDE"
|
||||
echo " (This simulates the address-to-coordinates conversion service)"
|
||||
|
||||
# Using exact schema from BakeryRegistration with added coordinates
|
||||
BAKERY_DATA="{
|
||||
\"name\": \"Panadería Test $(date +%H%M)\",
|
||||
\"business_type\": \"bakery\",
|
||||
\"address\": \"Calle Gran Vía 123\",
|
||||
\"city\": \"Madrid\",
|
||||
\"postal_code\": \"28001\",
|
||||
\"phone\": \"+34600123456\",
|
||||
\"latitude\": $MOCK_LATITUDE,
|
||||
\"longitude\": $MOCK_LONGITUDE
|
||||
}"
|
||||
|
||||
echo "Bakery Data with mock coordinates:"
|
||||
echo "$BAKERY_DATA" | python3 -m json.tool
|
||||
|
||||
BAKERY_RESPONSE=$(curl -s -w "\nHTTP_CODE:%{http_code}" -X POST "$API_BASE/api/v1/tenants/register" \
|
||||
-H "Content-Type: application/json" \
|
||||
-H "Authorization: Bearer $ACCESS_TOKEN" \
|
||||
-d "$BAKERY_DATA")
|
||||
|
||||
# Extract HTTP code and response
|
||||
HTTP_CODE=$(echo "$BAKERY_RESPONSE" | grep "HTTP_CODE:" | cut -d: -f2)
|
||||
BAKERY_RESPONSE=$(echo "$BAKERY_RESPONSE" | sed '/HTTP_CODE:/d')
|
||||
|
||||
echo "HTTP Status Code: $HTTP_CODE"
|
||||
echo "Bakery Registration Response:"
|
||||
echo "$BAKERY_RESPONSE" | python3 -m json.tool 2>/dev/null || echo "$BAKERY_RESPONSE"
|
||||
|
||||
if check_response "$BAKERY_RESPONSE" "Bakery Registration"; then
|
||||
TENANT_ID=$(extract_json_field "$BAKERY_RESPONSE" "id")
|
||||
if [ -n "$TENANT_ID" ]; then
|
||||
log_success "Tenant ID extracted: $TENANT_ID"
|
||||
log_success "Mock coordinates will be used for weather/traffic data: ($MOCK_LATITUDE, $MOCK_LONGITUDE)"
|
||||
|
||||
# Store coordinates for later use in training
|
||||
echo "BAKERY_LATITUDE=$MOCK_LATITUDE" > /tmp/bakery_coords.env
|
||||
echo "BAKERY_LONGITUDE=$MOCK_LONGITUDE" >> /tmp/bakery_coords.env
|
||||
echo "TENANT_ID=$TENANT_ID" >> /tmp/bakery_coords.env
|
||||
|
||||
log_step "2.2. Testing weather data acquisition with mock coordinates"
|
||||
# Test if weather service can use these coordinates
|
||||
WEATHER_TEST_RESPONSE=$(curl -s -X GET "$API_BASE/api/v1/training/$TENANT_ID/weather/current?latitude=$MOCK_LATITUDE&longitude=$MOCK_LONGITUDE" \
|
||||
-H "Authorization: Bearer $ACCESS_TOKEN" \
|
||||
-H "X-Tenant-ID: $TENANT_ID" 2>/dev/null || echo '{"status":"service_unavailable"}')
|
||||
|
||||
if echo "$WEATHER_TEST_RESPONSE" | grep -q '"temperature"\|"weather"'; then
|
||||
log_success "Weather service can use mock coordinates"
|
||||
else
|
||||
log_warning "Weather service test skipped (coordinates stored for training)"
|
||||
fi
|
||||
|
||||
log_step "2.3. Testing traffic data acquisition with mock coordinates"
|
||||
# Test if traffic service can use these coordinates
|
||||
TRAFFIC_TEST_RESPONSE=$(curl -s -X GET "$API_BASE/api/v1/training/$TENANT_ID/traffic/current?latitude=$MOCK_LATITUDE&longitude=$MOCK_LONGITUDE" \
|
||||
-H "Authorization: Bearer $ACCESS_TOKEN" \
|
||||
-H "X-Tenant-ID: $TENANT_ID" 2>/dev/null || echo '{"status":"service_unavailable"}')
|
||||
|
||||
if echo "$TRAFFIC_TEST_RESPONSE" | grep -q '"traffic_volume"\|"intensity"'; then
|
||||
log_success "Traffic service can use mock coordinates"
|
||||
else
|
||||
log_warning "Traffic service test skipped (coordinates stored for training)"
|
||||
fi
|
||||
|
||||
else
|
||||
log_error "Failed to extract tenant ID"
|
||||
exit 1
|
||||
fi
|
||||
else
|
||||
echo "Full response: $BAKERY_RESPONSE"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
echo ""
|
||||
|
||||
# =================================================================
|
||||
# STEP 3: SALES DATA UPLOAD (ONBOARDING PAGE STEP 3)
|
||||
# =================================================================
|
||||
|
||||
echo -e "${STEP_ICONS[2]} ${PURPLE}STEP 3: SALES DATA UPLOAD${NC}"
|
||||
echo "Simulating onboarding page step 3 - 'Historial de Ventas'"
|
||||
echo ""
|
||||
|
||||
# Prepare subset of real CSV data for testing
|
||||
PREPARED_CSV="/tmp/prepared_sales_data.csv"
|
||||
if ! prepare_csv_for_import "$REAL_CSV_FILE" "$PREPARED_CSV" 100; then
|
||||
log_error "Failed to prepare CSV data"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
log_step "3.1. Validating real sales data format"
|
||||
|
||||
# Read and escape CSV content for JSON using Python for reliability
|
||||
log_step "3.1.1. Preparing CSV data for JSON transmission"
|
||||
|
||||
CSV_CONTENT=$(escape_csv_for_json "$PREPARED_CSV")
|
||||
|
||||
if [ $? -ne 0 ] || [ -z "$CSV_CONTENT" ]; then
|
||||
log_error "Failed to escape CSV content for JSON"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
log_success "CSV content escaped successfully (length: ${#CSV_CONTENT} chars)"
|
||||
|
||||
# Create validation request using Python for proper JSON formatting
|
||||
log_step "3.1.2. Creating validation request"
|
||||
|
||||
VALIDATION_DATA_FILE="/tmp/validation_request.json"
|
||||
python3 -c "
|
||||
import json
|
||||
|
||||
# Read the CSV content
|
||||
with open('$PREPARED_CSV', 'r', encoding='utf-8') as f:
|
||||
csv_content = f.read()
|
||||
|
||||
# Create proper JSON request
|
||||
request_data = {
|
||||
'data': csv_content,
|
||||
'data_format': 'csv',
|
||||
'validate_only': True,
|
||||
'source': 'onboarding_upload'
|
||||
}
|
||||
|
||||
# Write to file
|
||||
with open('$VALIDATION_DATA_FILE', 'w', encoding='utf-8') as f:
|
||||
json.dump(request_data, f, ensure_ascii=False, indent=2)
|
||||
|
||||
print('Validation request file created successfully')
|
||||
"
|
||||
|
||||
if [ ! -f "$VALIDATION_DATA_FILE" ]; then
|
||||
log_error "Failed to create validation request file"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
echo "Validation request (first 200 chars):"
|
||||
head -c 200 "$VALIDATION_DATA_FILE"
|
||||
echo "..."
|
||||
|
||||
VALIDATION_RESPONSE=$(curl -s -w "\nHTTP_CODE:%{http_code}" -X POST "$API_BASE/api/v1/tenants/$TENANT_ID/sales/import/validate" \
|
||||
-H "Content-Type: application/json" \
|
||||
-H "Authorization: Bearer $ACCESS_TOKEN" \
|
||||
-d @"$VALIDATION_DATA_FILE")
|
||||
|
||||
# Extract HTTP code and response
|
||||
HTTP_CODE=$(echo "$VALIDATION_RESPONSE" | grep "HTTP_CODE:" | cut -d: -f2)
|
||||
VALIDATION_RESPONSE=$(echo "$VALIDATION_RESPONSE" | sed '/HTTP_CODE:/d')
|
||||
|
||||
echo "HTTP Status Code: $HTTP_CODE"
|
||||
echo "Validation Response:"
|
||||
echo "$VALIDATION_RESPONSE" | python3 -m json.tool 2>/dev/null || echo "$VALIDATION_RESPONSE"
|
||||
|
||||
# Parse validation results using the SalesValidationResult schema
|
||||
IS_VALID=$(extract_json_field "$VALIDATION_RESPONSE" "is_valid")
|
||||
TOTAL_RECORDS=$(extract_json_field "$VALIDATION_RESPONSE" "total_records")
|
||||
VALID_RECORDS=$(extract_json_field "$VALIDATION_RESPONSE" "valid_records")
|
||||
INVALID_RECORDS=$(extract_json_field "$VALIDATION_RESPONSE" "invalid_records")
|
||||
|
||||
if [ "$IS_VALID" = "True" ]; then
|
||||
log_success "Sales data validation passed"
|
||||
echo " Total records: $TOTAL_RECORDS"
|
||||
echo " Valid records: $VALID_RECORDS"
|
||||
echo " Invalid records: $INVALID_RECORDS"
|
||||
elif [ "$IS_VALID" = "False" ]; then
|
||||
log_error "Sales data validation failed"
|
||||
echo " Total records: $TOTAL_RECORDS"
|
||||
echo " Valid records: $VALID_RECORDS"
|
||||
echo " Invalid records: $INVALID_RECORDS"
|
||||
|
||||
# Extract and display errors
|
||||
echo "Validation errors:"
|
||||
echo "$VALIDATION_RESPONSE" | python3 -c "
|
||||
import json, sys
|
||||
try:
|
||||
data = json.load(sys.stdin)
|
||||
errors = data.get('errors', [])
|
||||
for i, err in enumerate(errors[:5]): # Show first 5 errors
|
||||
print(f' {i+1}. {err.get(\"message\", \"Unknown error\")}')
|
||||
if len(errors) > 5:
|
||||
print(f' ... and {len(errors) - 5} more errors')
|
||||
except:
|
||||
print(' Could not parse error details')
|
||||
" 2>/dev/null
|
||||
|
||||
log_warning "Validation failed, but continuing to test import flow..."
|
||||
else
|
||||
log_warning "Validation response format unexpected, but continuing..."
|
||||
fi
|
||||
|
||||
log_step "3.2. Attempting to import real sales data"
|
||||
|
||||
# The validation endpoint only validates, we need the actual import endpoint
|
||||
# Use the file upload endpoint for actual data import
|
||||
echo "Attempting import of real sales data via file upload endpoint..."
|
||||
|
||||
# Try importing via the actual file upload endpoint
|
||||
IMPORT_RESPONSE=$(curl -s -w "\nHTTP_CODE:%{http_code}" -X POST "$API_BASE/api/v1/tenants/$TENANT_ID/sales/import" \
|
||||
-H "Authorization: Bearer $ACCESS_TOKEN" \
|
||||
-F "file=@$PREPARED_CSV" \
|
||||
-F "file_format=csv")
|
||||
|
||||
# Extract HTTP code and response
|
||||
HTTP_CODE=$(echo "$IMPORT_RESPONSE" | grep "HTTP_CODE:" | cut -d: -f2)
|
||||
IMPORT_RESPONSE=$(echo "$IMPORT_RESPONSE" | sed '/HTTP_CODE:/d')
|
||||
|
||||
echo "Import HTTP Status Code: $HTTP_CODE"
|
||||
echo "Import Response:"
|
||||
echo "$IMPORT_RESPONSE" | python3 -m json.tool 2>/dev/null || echo "$IMPORT_RESPONSE"
|
||||
|
||||
# Check for import success using SalesImportResult schema
|
||||
if [ "$HTTP_CODE" = "200" ]; then
|
||||
|
||||
IMPORT_SUCCESS=$(extract_json_field "$IMPORT_RESPONSE" "success")
|
||||
RECORDS_CREATED=$(extract_json_field "$IMPORT_RESPONSE" "records_created")
|
||||
RECORDS_FAILED=$(extract_json_field "$IMPORT_RESPONSE" "records_failed")
|
||||
SUCCESS_RATE=$(extract_json_field "$IMPORT_RESPONSE" "success_rate")
|
||||
|
||||
if [ "$IMPORT_SUCCESS" = "True" ]; then
|
||||
log_success "Sales data import completed successfully"
|
||||
echo " Records processed: $(extract_json_field "$IMPORT_RESPONSE" "records_processed")"
|
||||
echo " Records created: $RECORDS_CREATED"
|
||||
echo " Records failed: $RECORDS_FAILED"
|
||||
echo " Success rate: $SUCCESS_RATE%"
|
||||
echo " Processing time: $(extract_json_field "$IMPORT_RESPONSE" "processing_time_seconds")s"
|
||||
|
||||
if [ "$RECORDS_FAILED" -gt 0 ] 2>/dev/null; then
|
||||
log_warning "$RECORDS_FAILED records failed during import"
|
||||
fi
|
||||
elif [ "$IMPORT_SUCCESS" = "False" ]; then
|
||||
log_error "Import reported failure despite HTTP 200"
|
||||
echo "Import response: $IMPORT_RESPONSE"
|
||||
else
|
||||
log_warning "Could not parse import success field (got: '$IMPORT_SUCCESS')"
|
||||
log_warning "Assuming import succeeded based on HTTP 200 and response content"
|
||||
|
||||
# Fallback: if we got HTTP 200 and JSON response, assume success
|
||||
if echo "$IMPORT_RESPONSE" | grep -q '"records_created"'; then
|
||||
log_success "Import appears successful based on response content"
|
||||
FALLBACK_CREATED=$(echo "$IMPORT_RESPONSE" | grep -o '"records_created":[0-9]*' | cut -d: -f2)
|
||||
echo " Records created: $FALLBACK_CREATED"
|
||||
fi
|
||||
fi
|
||||
fi
|
||||
|
||||
log_step "3.3. Verifying imported sales data"
|
||||
|
||||
SALES_LIST_RESPONSE=$(curl -s -X GET "$API_BASE/api/v1/tenants/$TENANT_ID/sales" \
|
||||
-H "Authorization: Bearer $ACCESS_TOKEN")
|
||||
|
||||
echo "Sales Data Response:"
|
||||
echo "$SALES_LIST_RESPONSE" | python3 -m json.tool 2>/dev/null || echo "$SALES_LIST_RESPONSE"
|
||||
|
||||
# Check if we actually got any sales data
|
||||
SALES_COUNT=$(echo "$SALES_LIST_RESPONSE" | python3 -c "
|
||||
import json, sys
|
||||
try:
|
||||
data = json.load(sys.stdin)
|
||||
if isinstance(data, list):
|
||||
print(len(data))
|
||||
elif isinstance(data, dict) and 'data' in data:
|
||||
print(len(data['data']) if isinstance(data['data'], list) else 0)
|
||||
else:
|
||||
print(0)
|
||||
except:
|
||||
print(0)
|
||||
" 2>/dev/null)
|
||||
|
||||
if [ "$SALES_COUNT" -gt 0 ]; then
|
||||
log_success "Sales data successfully retrieved!"
|
||||
echo " Records found: $SALES_COUNT"
|
||||
|
||||
# Show some sample products found
|
||||
echo " Sample products found:"
|
||||
echo "$SALES_LIST_RESPONSE" | python3 -c "
|
||||
import json, sys
|
||||
try:
|
||||
data = json.load(sys.stdin)
|
||||
records = data if isinstance(data, list) else data.get('data', [])
|
||||
products = set()
|
||||
for record in records[:5]: # First 5 records
|
||||
if isinstance(record, dict) and 'product_name' in record:
|
||||
products.add(record['product_name'])
|
||||
for product in sorted(products):
|
||||
print(f' - {product}')
|
||||
except:
|
||||
pass
|
||||
" 2>/dev/null
|
||||
else
|
||||
log_warning "No sales data found in database"
|
||||
|
||||
if [ -n "$RECORDS_CREATED" ] && [ "$RECORDS_CREATED" -gt 0 ]; then
|
||||
log_error "Inconsistency detected: Import reported $RECORDS_CREATED records created, but none found in database"
|
||||
echo "This could indicate:"
|
||||
echo " 1. Records were created but failed timezone validation and were rolled back"
|
||||
echo " 2. Database transaction was not committed"
|
||||
echo " 3. Records were created in a different tenant/schema"
|
||||
else
|
||||
echo "This is expected if the import failed due to timezone or other errors."
|
||||
fi
|
||||
fi
|
||||
|
||||
echo ""
|
||||
|
||||
# =================================================================
|
||||
# STEP 4: MODEL TRAINING (ONBOARDING PAGE STEP 4)
|
||||
# =================================================================
|
||||
|
||||
echo -e "${STEP_ICONS[3]} ${PURPLE}STEP 4: AI MODEL TRAINING${NC}"
|
||||
echo "Simulating onboarding page step 4 - 'Entrenar Modelos'"
|
||||
echo ""
|
||||
|
||||
log_step "4.1. Starting model training process with real data products"
|
||||
|
||||
# Get unique products from the imported data for training
|
||||
# Extract some real product names from the CSV for training
|
||||
REAL_PRODUCTS=$(tail -n +2 "$PREPARED_CSV" | cut -d',' -f2 | sort | uniq | head -3 | tr '\n' ',' | sed 's/,$//')
|
||||
|
||||
if [ -z "$REAL_PRODUCTS" ]; then
|
||||
# Fallback to default products if extraction fails
|
||||
REAL_PRODUCTS='"Pan de molde","Croissants","Magdalenas"'
|
||||
log_warning "Could not extract real product names, using defaults"
|
||||
else
|
||||
# Format for JSON array
|
||||
REAL_PRODUCTS=$(echo "$REAL_PRODUCTS" | sed 's/,/","/g' | sed 's/^/"/' | sed 's/$/"/')
|
||||
log_success "Extracted real products for training: $REAL_PRODUCTS"
|
||||
fi
|
||||
|
||||
# Training request with real products
|
||||
TRAINING_DATA="{
|
||||
\"tenant_id\": \"$TENANT_ID\",
|
||||
\"selected_products\": [$REAL_PRODUCTS],
|
||||
\"training_parameters\": {
|
||||
\"forecast_horizon\": 7,
|
||||
\"validation_split\": 0.2,
|
||||
\"model_type\": \"lstm\"
|
||||
}
|
||||
}"
|
||||
|
||||
echo "Training Request:"
|
||||
echo "$TRAINING_DATA" | python3 -m json.tool
|
||||
|
||||
TRAINING_RESPONSE=$(curl -s -w "\nHTTP_CODE:%{http_code}" -X POST "$API_BASE/api/v1/tenants/$TENANT_ID/training/jobs" \
|
||||
-H "Content-Type: application/json" \
|
||||
-H "Authorization: Bearer $ACCESS_TOKEN" \
|
||||
-H "X-Tenant-ID: $TENANT_ID" \
|
||||
-d "$TRAINING_DATA")
|
||||
|
||||
# Extract HTTP code and response
|
||||
HTTP_CODE=$(echo "$TRAINING_RESPONSE" | grep "HTTP_CODE:" | cut -d: -f2)
|
||||
TRAINING_RESPONSE=$(echo "$TRAINING_RESPONSE" | sed '/HTTP_CODE:/d')
|
||||
|
||||
echo "Training HTTP Status Code: $HTTP_CODE"
|
||||
echo "Training Response:"
|
||||
echo "$TRAINING_RESPONSE" | python3 -m json.tool 2>/dev/null || echo "$TRAINING_RESPONSE"
|
||||
|
||||
TRAINING_TASK_ID=$(extract_json_field "$TRAINING_RESPONSE" "task_id")
|
||||
if [ -z "$TRAINING_TASK_ID" ]; then
|
||||
TRAINING_TASK_ID=$(extract_json_field "$TRAINING_RESPONSE" "id")
|
||||
fi
|
||||
|
||||
if [ -n "$TRAINING_TASK_ID" ]; then
|
||||
log_success "Training started successfully - Task ID: $TRAINING_TASK_ID"
|
||||
|
||||
log_step "4.2. Monitoring training progress"
|
||||
|
||||
# Poll training status (limited polling for test)
|
||||
MAX_POLLS=5
|
||||
POLL_COUNT=0
|
||||
|
||||
while [ $POLL_COUNT -lt $MAX_POLLS ]; do
|
||||
echo "Polling training status... ($((POLL_COUNT+1))/$MAX_POLLS)"
|
||||
|
||||
STATUS_RESPONSE=$(curl -s -X GET "$API_BASE/api/v1/tenants/$TENANT_ID/training/status/$TRAINING_TASK_ID" \
|
||||
-H "Authorization: Bearer $ACCESS_TOKEN" \
|
||||
-H "X-Tenant-ID: $TENANT_ID")
|
||||
|
||||
echo "Status Response:"
|
||||
echo "$STATUS_RESPONSE" | python3 -m json.tool 2>/dev/null || echo "$STATUS_RESPONSE"
|
||||
|
||||
STATUS=$(extract_json_field "$STATUS_RESPONSE" "status")
|
||||
PROGRESS=$(extract_json_field "$STATUS_RESPONSE" "progress")
|
||||
|
||||
if [ -n "$PROGRESS" ]; then
|
||||
echo " Progress: $PROGRESS%"
|
||||
fi
|
||||
|
||||
case "$STATUS" in
|
||||
"completed"|"success")
|
||||
log_success "Training completed successfully!"
|
||||
break
|
||||
;;
|
||||
"failed"|"error")
|
||||
log_error "Training failed!"
|
||||
echo "Status response: $STATUS_RESPONSE"
|
||||
break
|
||||
;;
|
||||
"running"|"in_progress"|"pending")
|
||||
echo " Status: $STATUS (continuing...)"
|
||||
;;
|
||||
*)
|
||||
log_warning "Unknown status: $STATUS"
|
||||
;;
|
||||
esac
|
||||
|
||||
POLL_COUNT=$((POLL_COUNT+1))
|
||||
sleep 2
|
||||
done
|
||||
|
||||
if [ $POLL_COUNT -eq $MAX_POLLS ]; then
|
||||
log_warning "Training status polling completed - may still be in progress"
|
||||
else
|
||||
log_success "Training monitoring completed"
|
||||
fi
|
||||
else
|
||||
log_warning "Could not start training - task ID not found"
|
||||
fi
|
||||
|
||||
echo ""
|
||||
|
||||
# =================================================================
|
||||
# STEP 5: ONBOARDING COMPLETION (ONBOARDING PAGE STEP 5)
|
||||
# =================================================================
|
||||
|
||||
echo -e "${STEP_ICONS[4]} ${PURPLE}STEP 5: ONBOARDING COMPLETION${NC}"
|
||||
echo "Simulating onboarding page step 5 - '¡Listo!'"
|
||||
echo ""
|
||||
|
||||
log_step "5.1. Verifying complete onboarding state"
|
||||
|
||||
# Check user profile
|
||||
USER_PROFILE_RESPONSE=$(curl -s -X GET "$API_BASE/api/v1/users/me" \
|
||||
-H "Authorization: Bearer $ACCESS_TOKEN")
|
||||
|
||||
if echo "$USER_PROFILE_RESPONSE" | grep -q '"email"'; then
|
||||
log_success "User profile accessible"
|
||||
else
|
||||
log_warning "User profile may have datetime serialization issue (known bug)"
|
||||
fi
|
||||
|
||||
# Check tenant info
|
||||
TENANT_INFO_RESPONSE=$(curl -s -X GET "$API_BASE/api/v1/tenants/$TENANT_ID" \
|
||||
-H "Authorization: Bearer $ACCESS_TOKEN")
|
||||
|
||||
if echo "$TENANT_INFO_RESPONSE" | grep -q '"name"'; then
|
||||
log_success "Tenant information accessible"
|
||||
BAKERY_NAME=$(extract_json_field "$TENANT_INFO_RESPONSE" "name")
|
||||
echo " Bakery Name: $BAKERY_NAME"
|
||||
else
|
||||
log_warning "Tenant information not accessible"
|
||||
fi
|
||||
|
||||
log_step "5.2. Testing basic dashboard functionality"
|
||||
|
||||
# Test basic forecasting capability (if training completed)
|
||||
if [ -n "$TRAINING_TASK_ID" ]; then
|
||||
# Use a real product name from our CSV for forecasting
|
||||
FIRST_PRODUCT=$(echo "$REAL_PRODUCTS" | sed 's/"//g' | cut -d',' -f1)
|
||||
|
||||
FORECAST_RESPONSE=$(curl -s -X POST "$API_BASE/api/v1/forecasting/predict" \
|
||||
-H "Content-Type: application/json" \
|
||||
-H "Authorization: Bearer $ACCESS_TOKEN" \
|
||||
-H "X-Tenant-ID: $TENANT_ID" \
|
||||
-d "{
|
||||
\"products\": [\"$FIRST_PRODUCT\"],
|
||||
\"forecast_days\": 7,
|
||||
\"date\": \"2024-01-15\"
|
||||
}")
|
||||
|
||||
if echo "$FORECAST_RESPONSE" | grep -q '"predictions"\|"forecast"'; then
|
||||
log_success "Forecasting service is accessible"
|
||||
else
|
||||
log_warning "Forecasting may not be ready yet (model training required)"
|
||||
fi
|
||||
else
|
||||
log_warning "Skipping forecast test - no training task ID available"
|
||||
fi
|
||||
|
||||
echo ""
|
||||
|
||||
# =================================================================
|
||||
# SUMMARY AND CLEANUP
|
||||
# =================================================================
|
||||
|
||||
echo -e "${CYAN}📊 IMPROVED ONBOARDING FLOW TEST SUMMARY${NC}"
|
||||
echo -e "${CYAN}=========================================${NC}"
|
||||
|
||||
echo ""
|
||||
echo "✅ Completed Onboarding Steps:"
|
||||
echo " ${STEP_ICONS[0]} Step 1: User Registration ✓"
|
||||
echo " ${STEP_ICONS[1]} Step 2: Bakery Registration ✓"
|
||||
echo " ${STEP_ICONS[2]} Step 3: Real Sales Data Upload ✓"
|
||||
echo " ${STEP_ICONS[3]} Step 4: Model Training with Real Data ✓"
|
||||
echo " ${STEP_ICONS[4]} Step 5: Onboarding Complete ✓"
|
||||
|
||||
echo ""
|
||||
echo "📋 Test Results:"
|
||||
echo " User ID: $USER_ID"
|
||||
echo " Tenant ID: $TENANT_ID"
|
||||
echo " Training Task ID: $TRAINING_TASK_ID"
|
||||
echo " Test Email: $TEST_EMAIL"
|
||||
echo " Real CSV Used: $REAL_CSV_FILE"
|
||||
echo " Prepared Records: $(wc -l < "$PREPARED_CSV" 2>/dev/null || echo "Unknown")"
|
||||
|
||||
echo ""
|
||||
echo "📈 Data Quality:"
|
||||
if [ -n "$TOTAL_RECORDS" ]; then
|
||||
echo " Total Records Processed: $TOTAL_RECORDS"
|
||||
echo " Valid Records: $VALID_RECORDS"
|
||||
echo " Invalid Records: $INVALID_RECORDS"
|
||||
if [ "$TOTAL_RECORDS" -gt 0 ]; then
|
||||
VALID_PERCENTAGE=$(python3 -c "print(round(${VALID_RECORDS:-0} / ${TOTAL_RECORDS} * 100, 1))" 2>/dev/null || echo "N/A")
|
||||
echo " Data Quality: $VALID_PERCENTAGE% valid"
|
||||
fi
|
||||
else
|
||||
echo " Data validation metrics not available"
|
||||
fi
|
||||
|
||||
echo ""
|
||||
echo "🔧 Known Issues Detected:"
|
||||
if echo "$IMPORT_RESPONSE$FILE_UPLOAD_RESPONSE" | grep -q "Cannot convert tz-naive"; then
|
||||
echo " ❌ TIMEZONE ERROR: CSV dates are timezone-naive"
|
||||
echo " Solution: Apply timezone fix patch to data import service"
|
||||
echo " File: services/data/app/services/data_import_service.py"
|
||||
echo " Method: Replace _parse_date() with timezone-aware version"
|
||||
fi
|
||||
|
||||
echo ""
|
||||
echo "🧹 Cleanup:"
|
||||
echo " Prepared CSV file: $PREPARED_CSV"
|
||||
echo " To clean up test data, you may want to remove:"
|
||||
echo " - Test user: $TEST_EMAIL"
|
||||
echo " - Test tenant: $TENANT_ID"
|
||||
|
||||
# Cleanup temporary files
|
||||
rm -f "$PREPARED_CSV" "$VALIDATION_DATA_FILE"
|
||||
|
||||
echo ""
|
||||
log_success "Improved onboarding flow simulation completed successfully!"
|
||||
echo -e "${CYAN}The user journey through all 5 onboarding steps has been tested with real data.${NC}"
|
||||
|
||||
# Final status check
|
||||
if [ -n "$USER_ID" ] && [ -n "$TENANT_ID" ]; then
|
||||
echo ""
|
||||
echo -e "${GREEN}🎉 All critical onboarding functionality is working!${NC}"
|
||||
echo "The user can successfully:"
|
||||
echo " • Register an account"
|
||||
echo " • Set up their bakery"
|
||||
echo " • Upload and validate real sales data"
|
||||
echo " • Start model training with real products"
|
||||
echo " • Access the platform dashboard"
|
||||
|
||||
if [ -n "$VALID_RECORDS" ] && [ "$VALID_RECORDS" -gt 0 ]; then
|
||||
echo ""
|
||||
echo -e "${GREEN}🏆 BONUS: Real data was successfully processed!${NC}"
|
||||
echo " • $VALID_RECORDS valid sales records imported"
|
||||
echo " • Model training initiated with real products"
|
||||
echo " • End-to-end data pipeline verified"
|
||||
fi
|
||||
|
||||
exit 0
|
||||
else
|
||||
echo ""
|
||||
echo -e "${YELLOW}⚠️ Some issues detected in the onboarding flow${NC}"
|
||||
echo "Check the logs above for specific failures"
|
||||
exit 1
|
||||
fi
|
||||
Reference in New Issue
Block a user