295 lines
9.6 KiB
Python
295 lines
9.6 KiB
Python
#!/usr/bin/env python3
|
|
"""
|
|
Docker Build and Compose Test Script
|
|
Tests that each service can be built correctly and docker-compose starts without errors
|
|
"""
|
|
|
|
import os
|
|
import sys
|
|
import subprocess
|
|
import time
|
|
import json
|
|
from pathlib import Path
|
|
|
|
def run_command(cmd, cwd=None, timeout=300, capture_output=True):
|
|
"""Run a shell command with timeout and error handling"""
|
|
try:
|
|
print(f"Running: {cmd}")
|
|
if capture_output:
|
|
result = subprocess.run(
|
|
cmd,
|
|
shell=True,
|
|
cwd=cwd,
|
|
timeout=timeout,
|
|
capture_output=True,
|
|
text=True
|
|
)
|
|
else:
|
|
result = subprocess.run(
|
|
cmd,
|
|
shell=True,
|
|
cwd=cwd,
|
|
timeout=timeout
|
|
)
|
|
return result
|
|
except subprocess.TimeoutExpired:
|
|
print(f"Command timed out after {timeout} seconds: {cmd}")
|
|
return None
|
|
except Exception as e:
|
|
print(f"Error running command: {e}")
|
|
return None
|
|
|
|
def check_docker_available():
|
|
"""Check if Docker is available and running"""
|
|
print("🐳 Checking Docker availability...")
|
|
|
|
# Check if docker command exists
|
|
result = run_command("which docker")
|
|
if result.returncode != 0:
|
|
print("❌ Docker command not found. Please install Docker.")
|
|
return False
|
|
|
|
# Check if Docker daemon is running
|
|
result = run_command("docker version")
|
|
if result.returncode != 0:
|
|
print("❌ Docker daemon is not running. Please start Docker.")
|
|
return False
|
|
|
|
# Check if docker-compose is available
|
|
result = run_command("docker compose version")
|
|
if result.returncode != 0:
|
|
# Try legacy docker-compose
|
|
result = run_command("docker-compose version")
|
|
if result.returncode != 0:
|
|
print("❌ docker-compose not found. Please install docker-compose.")
|
|
return False
|
|
else:
|
|
print("✅ Using legacy docker-compose")
|
|
else:
|
|
print("✅ Using Docker Compose v2")
|
|
|
|
print("✅ Docker is available and running")
|
|
return True
|
|
|
|
def test_individual_builds():
|
|
"""Test building each service individually"""
|
|
print("\n🔨 Testing individual service builds...")
|
|
|
|
services = [
|
|
"auth-service",
|
|
"tenant-service",
|
|
"training-service",
|
|
"forecasting-service",
|
|
"data-service",
|
|
"notification-service"
|
|
]
|
|
|
|
build_results = {}
|
|
|
|
for service in services:
|
|
print(f"\n--- Building {service} ---")
|
|
|
|
dockerfile_path = f"./services/{service.replace('-service', '')}/Dockerfile"
|
|
if not os.path.exists(dockerfile_path):
|
|
print(f"❌ Dockerfile not found: {dockerfile_path}")
|
|
build_results[service] = False
|
|
continue
|
|
|
|
# Build the service
|
|
cmd = f"docker build -t bakery/{service}:test -f {dockerfile_path} ."
|
|
result = run_command(cmd, timeout=600)
|
|
|
|
if result and result.returncode == 0:
|
|
print(f"✅ {service} built successfully")
|
|
build_results[service] = True
|
|
else:
|
|
print(f"❌ {service} build failed")
|
|
if result and result.stderr:
|
|
print(f"Error: {result.stderr}")
|
|
build_results[service] = False
|
|
|
|
return build_results
|
|
|
|
def test_docker_compose_config():
|
|
"""Test docker-compose configuration"""
|
|
print("\n📋 Testing docker-compose configuration...")
|
|
|
|
# Check if docker-compose.yml exists
|
|
if not os.path.exists("docker-compose.yml"):
|
|
print("❌ docker-compose.yml not found")
|
|
return False
|
|
|
|
# Check if .env file exists
|
|
if not os.path.exists(".env"):
|
|
print("❌ .env file not found")
|
|
return False
|
|
|
|
# Validate docker-compose configuration
|
|
result = run_command("docker compose config")
|
|
if result.returncode != 0:
|
|
# Try legacy docker-compose
|
|
result = run_command("docker-compose config")
|
|
if result.returncode != 0:
|
|
print("❌ docker-compose configuration validation failed")
|
|
if result.stderr:
|
|
print(f"Error: {result.stderr}")
|
|
return False
|
|
|
|
print("✅ docker-compose configuration is valid")
|
|
return True
|
|
|
|
def test_essential_services_startup():
|
|
"""Test starting essential infrastructure services only"""
|
|
print("\n🚀 Testing essential services startup...")
|
|
|
|
# Start only databases and infrastructure - not the application services
|
|
essential_services = [
|
|
"redis",
|
|
"rabbitmq",
|
|
"auth-db",
|
|
"data-db"
|
|
]
|
|
|
|
try:
|
|
# Stop any running containers first
|
|
print("Stopping any existing containers...")
|
|
run_command("docker compose down", timeout=120)
|
|
|
|
# Start essential services
|
|
services_str = " ".join(essential_services)
|
|
cmd = f"docker compose up -d {services_str}"
|
|
result = run_command(cmd, timeout=300)
|
|
|
|
if result.returncode != 0:
|
|
print("❌ Failed to start essential services")
|
|
if result.stderr:
|
|
print(f"Error: {result.stderr}")
|
|
return False
|
|
|
|
# Wait for services to be ready
|
|
print("Waiting for services to be ready...")
|
|
time.sleep(30)
|
|
|
|
# Check service health
|
|
print("Checking service health...")
|
|
result = run_command("docker compose ps")
|
|
if result.returncode == 0:
|
|
print("Services status:")
|
|
print(result.stdout)
|
|
|
|
print("✅ Essential services started successfully")
|
|
return True
|
|
|
|
except Exception as e:
|
|
print(f"❌ Error during essential services test: {e}")
|
|
return False
|
|
finally:
|
|
# Cleanup
|
|
print("Cleaning up essential services test...")
|
|
run_command("docker compose down", timeout=120)
|
|
|
|
def cleanup_docker_resources():
|
|
"""Clean up Docker resources"""
|
|
print("\n🧹 Cleaning up Docker resources...")
|
|
|
|
# Remove test images
|
|
services = ["auth-service", "tenant-service", "training-service",
|
|
"forecasting-service", "data-service", "notification-service"]
|
|
|
|
for service in services:
|
|
run_command(f"docker rmi bakery/{service}:test", timeout=30)
|
|
|
|
# Remove dangling images
|
|
run_command("docker image prune -f", timeout=60)
|
|
|
|
print("✅ Docker resources cleaned up")
|
|
|
|
def main():
|
|
"""Main test function"""
|
|
print("🔍 DOCKER BUILD AND COMPOSE TESTING")
|
|
print("=" * 50)
|
|
|
|
base_path = Path(__file__).parent
|
|
os.chdir(base_path)
|
|
|
|
# Test results
|
|
test_results = {
|
|
"docker_available": False,
|
|
"compose_config": False,
|
|
"individual_builds": {},
|
|
"essential_services": False
|
|
}
|
|
|
|
# Check Docker availability
|
|
test_results["docker_available"] = check_docker_available()
|
|
if not test_results["docker_available"]:
|
|
print("\n❌ Docker tests cannot proceed without Docker")
|
|
return 1
|
|
|
|
# Test docker-compose configuration
|
|
test_results["compose_config"] = test_docker_compose_config()
|
|
|
|
# Test individual builds (this might take a while)
|
|
print("\n⚠️ Individual builds test can take several minutes...")
|
|
user_input = input("Run individual service builds? (y/N): ").lower()
|
|
|
|
if user_input == 'y':
|
|
test_results["individual_builds"] = test_individual_builds()
|
|
else:
|
|
print("Skipping individual builds test")
|
|
test_results["individual_builds"] = {"skipped": True}
|
|
|
|
# Test essential services startup
|
|
print("\n⚠️ Essential services test will start Docker containers...")
|
|
user_input = input("Test essential services startup? (y/N): ").lower()
|
|
|
|
if user_input == 'y':
|
|
test_results["essential_services"] = test_essential_services_startup()
|
|
else:
|
|
print("Skipping essential services test")
|
|
test_results["essential_services"] = "skipped"
|
|
|
|
# Print final results
|
|
print("\n" + "=" * 50)
|
|
print("📋 TEST RESULTS SUMMARY")
|
|
print("=" * 50)
|
|
|
|
print(f"Docker Available: {'✅' if test_results['docker_available'] else '❌'}")
|
|
print(f"Docker Compose Config: {'✅' if test_results['compose_config'] else '❌'}")
|
|
|
|
if "skipped" in test_results["individual_builds"]:
|
|
print("Individual Builds: ⏭️ Skipped")
|
|
else:
|
|
builds = test_results["individual_builds"]
|
|
success_count = sum(1 for v in builds.values() if v)
|
|
total_count = len(builds)
|
|
print(f"Individual Builds: {success_count}/{total_count} ✅")
|
|
|
|
for service, success in builds.items():
|
|
status = "✅" if success else "❌"
|
|
print(f" - {service}: {status}")
|
|
|
|
if test_results["essential_services"] == "skipped":
|
|
print("Essential Services: ⏭️ Skipped")
|
|
else:
|
|
print(f"Essential Services: {'✅' if test_results['essential_services'] else '❌'}")
|
|
|
|
# Cleanup
|
|
if user_input == 'y' and "skipped" not in test_results["individual_builds"]:
|
|
cleanup_docker_resources()
|
|
|
|
# Determine overall success
|
|
if (test_results["docker_available"] and
|
|
test_results["compose_config"] and
|
|
(test_results["individual_builds"] == {"skipped": True} or
|
|
all(test_results["individual_builds"].values())) and
|
|
(test_results["essential_services"] == "skipped" or test_results["essential_services"])):
|
|
print("\n🎉 ALL TESTS PASSED")
|
|
return 0
|
|
else:
|
|
print("\n❌ SOME TESTS FAILED")
|
|
return 1
|
|
|
|
if __name__ == "__main__":
|
|
exit_code = main()
|
|
sys.exit(exit_code) |