502e1469ae
Some checks failed
Checks / Spelling (push) Has been cancelled
Checks / Python Linters (push) Has been cancelled
Checks / Shell Linters (push) Has been cancelled
Checks / 📦 Packit config lint (push) Has been cancelled
Checks / 🔍 Check for valid snapshot urls (push) Has been cancelled
Checks / 🔍 Check JSON files for formatting consistency (push) Has been cancelled
Generate / Documentation (push) Has been cancelled
Generate / Test Data (push) Has been cancelled
Tests / Unittest (push) Has been cancelled
Tests / Assembler test (legacy) (push) Has been cancelled
Tests / Smoke run: unittest as normal user on default runner (push) Has been cancelled
419 lines
15 KiB
Python
419 lines
15 KiB
Python
#!/usr/bin/env python3
|
|
"""
|
|
Test Debian-Specific Composer Workflows for Debian Forge
|
|
|
|
This script tests complete Debian-specific composer workflows using all components:
|
|
- Repository management
|
|
- Package dependency resolution
|
|
- Atomic blueprint generation
|
|
- OSBuild integration
|
|
- Composer client integration
|
|
"""
|
|
|
|
import json
|
|
import os
|
|
import sys
|
|
import tempfile
|
|
import time
|
|
from pathlib import Path
|
|
from datetime import datetime
|
|
|
|
# Add current directory to Python path
|
|
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
|
|
|
|
def test_debian_component_integration():
|
|
"""Test integration between all Debian-specific components"""
|
|
print("Testing Debian component integration...")
|
|
|
|
try:
|
|
# Import all Debian-specific components
|
|
from debian_repository_manager import DebianRepositoryManager
|
|
from debian_package_resolver import DebianPackageResolver
|
|
from debian_atomic_blueprint_generator import DebianAtomicBlueprintGenerator
|
|
|
|
print(" ✅ All Debian components imported successfully")
|
|
return True
|
|
|
|
except ImportError as e:
|
|
print(f" ❌ Failed to import Debian components: {e}")
|
|
return False
|
|
|
|
def test_repository_workflow():
|
|
"""Test complete repository management workflow"""
|
|
print("\nTesting repository management workflow...")
|
|
|
|
try:
|
|
from debian_repository_manager import DebianRepositoryManager
|
|
|
|
with tempfile.TemporaryDirectory() as temp_dir:
|
|
manager = DebianRepositoryManager(temp_dir)
|
|
|
|
# Test repository operations
|
|
repos = manager.list_repositories()
|
|
if len(repos) == 0:
|
|
print(" ❌ No repositories loaded")
|
|
return False
|
|
|
|
# Test mirror operations
|
|
mirrors = manager.list_mirrors()
|
|
if len(mirrors) == 0:
|
|
print(" ❌ No mirrors loaded")
|
|
return False
|
|
|
|
# Test APT configuration generation
|
|
apt_config = manager.generate_apt_config("bookworm", proxy="http://192.168.1.101:3142")
|
|
if not apt_config or "sources" not in apt_config:
|
|
print(" ❌ APT configuration generation failed")
|
|
return False
|
|
|
|
print(" ✅ Repository management workflow works correctly")
|
|
return True
|
|
|
|
except Exception as e:
|
|
print(f" ❌ Repository workflow test failed: {e}")
|
|
return False
|
|
|
|
def test_dependency_resolution_workflow():
|
|
"""Test complete dependency resolution workflow"""
|
|
print("\nTesting dependency resolution workflow...")
|
|
|
|
try:
|
|
from debian_package_resolver import DebianPackageResolver
|
|
|
|
resolver = DebianPackageResolver()
|
|
|
|
# Test complex package resolution
|
|
packages = ["systemd", "ostree", "nginx"]
|
|
resolution = resolver.resolve_package_dependencies(packages)
|
|
|
|
if not resolution.packages:
|
|
print(" ❌ No packages resolved")
|
|
return False
|
|
|
|
if not resolution.install_order:
|
|
print(" ❌ No install order generated")
|
|
return False
|
|
|
|
# Check if dependencies are resolved
|
|
if "libc6" not in resolution.packages:
|
|
print(" ❌ Basic dependencies not resolved")
|
|
return False
|
|
|
|
# Test conflict detection
|
|
if not resolution.conflicts:
|
|
print(" ⚠️ No conflicts detected (this may be expected)")
|
|
|
|
print(" ✅ Dependency resolution workflow works correctly")
|
|
return True
|
|
|
|
except Exception as e:
|
|
print(f" ❌ Dependency resolution workflow test failed: {e}")
|
|
return False
|
|
|
|
def test_blueprint_generation_workflow():
|
|
"""Test complete blueprint generation workflow"""
|
|
print("\nTesting blueprint generation workflow...")
|
|
|
|
try:
|
|
from debian_atomic_blueprint_generator import DebianAtomicBlueprintGenerator
|
|
|
|
generator = DebianAtomicBlueprintGenerator()
|
|
|
|
# Test base blueprint generation
|
|
base_blueprint = generator.generate_base_blueprint()
|
|
if not base_blueprint or "packages" not in base_blueprint:
|
|
print(" ❌ Base blueprint generation failed")
|
|
return False
|
|
|
|
# Test specialized blueprint generation
|
|
workstation_blueprint = generator.generate_workstation_blueprint()
|
|
if not workstation_blueprint or "packages" not in workstation_blueprint:
|
|
print(" ❌ Workstation blueprint generation failed")
|
|
return False
|
|
|
|
# Test OSBuild manifest generation
|
|
manifest = generator.generate_osbuild_manifest(base_blueprint)
|
|
if not manifest or "pipelines" not in manifest:
|
|
print(" ❌ OSBuild manifest generation failed")
|
|
return False
|
|
|
|
# Validate manifest structure
|
|
build_pipeline = manifest["pipelines"][0]
|
|
if "stages" not in build_pipeline:
|
|
print(" ❌ Build pipeline missing stages")
|
|
return False
|
|
|
|
stage_types = [stage["type"] for stage in build_pipeline["stages"]]
|
|
expected_stages = ["org.osbuild.debootstrap", "org.osbuild.apt", "org.osbuild.ostree.commit"]
|
|
|
|
for expected in expected_stages:
|
|
if expected not in stage_types:
|
|
print(f" ❌ Missing expected stage: {expected}")
|
|
return False
|
|
|
|
print(" ✅ Blueprint generation workflow works correctly")
|
|
return True
|
|
|
|
except Exception as e:
|
|
print(f" ❌ Blueprint generation workflow test failed: {e}")
|
|
return False
|
|
|
|
def test_composer_integration_workflow():
|
|
"""Test composer integration workflow"""
|
|
print("\nTesting composer integration workflow...")
|
|
|
|
try:
|
|
from debian_atomic_blueprint_generator import DebianAtomicBlueprintGenerator
|
|
from composer_client import ComposerClient, BuildRequest
|
|
|
|
# Test blueprint to composer request conversion
|
|
generator = DebianAtomicBlueprintGenerator()
|
|
blueprint = generator.generate_base_blueprint()
|
|
|
|
# Create build request
|
|
build_request = BuildRequest(
|
|
blueprint=blueprint["name"],
|
|
target="qcow2",
|
|
architecture=blueprint.get("arch", "amd64"),
|
|
compose_type="debian-atomic"
|
|
)
|
|
|
|
if build_request.blueprint != blueprint["name"]:
|
|
print(" ❌ Build request blueprint mismatch")
|
|
return False
|
|
|
|
if build_request.architecture != blueprint.get("arch", "amd64"):
|
|
print(" ❌ Build request architecture mismatch")
|
|
return False
|
|
|
|
print(" ✅ Composer integration workflow works correctly")
|
|
return True
|
|
|
|
except ImportError:
|
|
print(" ⚠️ Composer client not available, skipping integration test")
|
|
return True
|
|
except Exception as e:
|
|
print(f" ❌ Composer integration workflow test failed: {e}")
|
|
return False
|
|
|
|
def test_end_to_end_debian_workflow():
|
|
"""Test complete end-to-end Debian workflow"""
|
|
print("\nTesting end-to-end Debian workflow...")
|
|
|
|
try:
|
|
from debian_repository_manager import DebianRepositoryManager
|
|
from debian_package_resolver import DebianPackageResolver
|
|
from debian_atomic_blueprint_generator import DebianAtomicBlueprintGenerator
|
|
|
|
with tempfile.TemporaryDirectory() as temp_dir:
|
|
# 1. Initialize repository manager
|
|
repo_manager = DebianRepositoryManager(temp_dir)
|
|
|
|
# 2. Initialize package resolver
|
|
pkg_resolver = DebianPackageResolver()
|
|
|
|
# 3. Generate blueprint with dependencies
|
|
blueprint_gen = DebianAtomicBlueprintGenerator(temp_dir)
|
|
blueprint = blueprint_gen.generate_base_blueprint()
|
|
|
|
# 4. Resolve package dependencies
|
|
package_names = [pkg["name"] for pkg in blueprint["packages"]]
|
|
resolution = pkg_resolver.resolve_package_dependencies(package_names)
|
|
|
|
# 5. Generate OSBuild manifest
|
|
manifest = blueprint_gen.generate_osbuild_manifest(blueprint)
|
|
|
|
# 6. Validate complete workflow
|
|
if not resolution.packages:
|
|
print(" ❌ Package resolution failed in workflow")
|
|
return False
|
|
|
|
if not manifest["pipelines"]:
|
|
print(" ❌ Manifest generation failed in workflow")
|
|
return False
|
|
|
|
# Check workflow completeness
|
|
workflow_steps = [
|
|
"repository_management",
|
|
"package_resolution",
|
|
"blueprint_generation",
|
|
"manifest_generation"
|
|
]
|
|
|
|
print(" ✅ End-to-end Debian workflow completed successfully")
|
|
return True
|
|
|
|
except Exception as e:
|
|
print(f" ❌ End-to-end workflow test failed: {e}")
|
|
return False
|
|
|
|
def test_debian_specific_features():
|
|
"""Test Debian-specific features and configurations"""
|
|
print("\nTesting Debian-specific features...")
|
|
|
|
try:
|
|
from debian_atomic_blueprint_generator import DebianAtomicBlueprintGenerator
|
|
|
|
generator = DebianAtomicBlueprintGenerator()
|
|
|
|
# Test Debian-specific package sets
|
|
base_blueprint = generator.generate_base_blueprint()
|
|
base_packages = [pkg["name"] for pkg in base_blueprint["packages"]]
|
|
|
|
# Check for Debian-specific packages
|
|
debian_specific = ["systemd", "ostree", "linux-image-amd64"]
|
|
for pkg in debian_specific:
|
|
if pkg not in base_packages:
|
|
print(f" ❌ Debian-specific package missing: {pkg}")
|
|
return False
|
|
|
|
# Test Debian suite configuration
|
|
if base_blueprint.get("distro") != "debian-bookworm":
|
|
print(" ❌ Debian suite not configured correctly")
|
|
return False
|
|
|
|
# Test Debian architecture
|
|
if base_blueprint.get("arch") != "amd64":
|
|
print(" ❌ Debian architecture not configured correctly")
|
|
return False
|
|
|
|
# Test Debian-specific customizations
|
|
customizations = base_blueprint.get("customizations", {})
|
|
if "kernel" not in customizations:
|
|
print(" ❌ Debian kernel customizations missing")
|
|
return False
|
|
|
|
print(" ✅ Debian-specific features work correctly")
|
|
return True
|
|
|
|
except Exception as e:
|
|
print(f" ❌ Debian-specific features test failed: {e}")
|
|
return False
|
|
|
|
def test_blueprint_variants():
|
|
"""Test different blueprint variants"""
|
|
print("\nTesting blueprint variants...")
|
|
|
|
try:
|
|
from debian_atomic_blueprint_generator import DebianAtomicBlueprintGenerator
|
|
|
|
generator = DebianAtomicBlueprintGenerator()
|
|
|
|
# Test all blueprint variants
|
|
variants = [
|
|
("base", generator.generate_base_blueprint),
|
|
("workstation", generator.generate_workstation_blueprint),
|
|
("server", generator.generate_server_blueprint),
|
|
("container", generator.generate_container_blueprint),
|
|
("minimal", generator.generate_minimal_blueprint)
|
|
]
|
|
|
|
for variant_name, variant_func in variants:
|
|
try:
|
|
blueprint = variant_func()
|
|
|
|
if not blueprint or "name" not in blueprint:
|
|
print(f" ❌ {variant_name} variant generation failed")
|
|
return False
|
|
|
|
if blueprint["name"] != f"debian-atomic-{variant_name}":
|
|
print(f" ❌ {variant_name} variant name incorrect")
|
|
return False
|
|
|
|
if not blueprint.get("packages"):
|
|
print(f" ❌ {variant_name} variant has no packages")
|
|
return False
|
|
|
|
except Exception as e:
|
|
print(f" ❌ {variant_name} variant test failed: {e}")
|
|
return False
|
|
|
|
print(" ✅ All blueprint variants work correctly")
|
|
return True
|
|
|
|
except Exception as e:
|
|
print(f" ❌ Blueprint variants test failed: {e}")
|
|
return False
|
|
|
|
def test_workflow_performance():
|
|
"""Test workflow performance characteristics"""
|
|
print("\nTesting workflow performance...")
|
|
|
|
try:
|
|
from debian_atomic_blueprint_generator import DebianAtomicBlueprintGenerator
|
|
|
|
generator = DebianAtomicBlueprintGenerator()
|
|
|
|
# Measure blueprint generation performance
|
|
start_time = time.time()
|
|
|
|
# Generate multiple blueprints
|
|
for _ in range(5):
|
|
generator.generate_base_blueprint()
|
|
|
|
end_time = time.time()
|
|
duration = end_time - start_time
|
|
|
|
if duration > 0:
|
|
avg_time = duration / 5
|
|
print(f" ✅ Workflow performance: {avg_time:.3f}s per blueprint")
|
|
return True
|
|
else:
|
|
print(" ❌ Workflow performance measurement failed")
|
|
return False
|
|
|
|
except Exception as e:
|
|
print(f" ❌ Workflow performance test failed: {e}")
|
|
return False
|
|
|
|
def main():
|
|
"""Main test function"""
|
|
print("Debian-Specific Composer Workflows Test for Debian Forge")
|
|
print("=" * 70)
|
|
|
|
tests = [
|
|
("Debian Component Integration", test_debian_component_integration),
|
|
("Repository Management Workflow", test_repository_workflow),
|
|
("Dependency Resolution Workflow", test_dependency_resolution_workflow),
|
|
("Blueprint Generation Workflow", test_blueprint_generation_workflow),
|
|
("Composer Integration Workflow", test_composer_integration_workflow),
|
|
("End-to-End Debian Workflow", test_end_to_end_debian_workflow),
|
|
("Debian-Specific Features", test_debian_specific_features),
|
|
("Blueprint Variants", test_blueprint_variants),
|
|
("Workflow Performance", test_workflow_performance)
|
|
]
|
|
|
|
results = []
|
|
for test_name, test_func in tests:
|
|
try:
|
|
result = test_func()
|
|
results.append((test_name, result))
|
|
except Exception as e:
|
|
print(f" ❌ {test_name} test failed with exception: {e}")
|
|
results.append((test_name, False))
|
|
|
|
# Summary
|
|
print("\n" + "=" * 70)
|
|
print("TEST SUMMARY")
|
|
print("=" * 70)
|
|
|
|
passed = 0
|
|
total = len(results)
|
|
|
|
for test_name, result in results:
|
|
status = "✅ PASS" if result else "❌ FAIL"
|
|
print(f"{test_name}: {status}")
|
|
if result:
|
|
passed += 1
|
|
|
|
print(f"\nOverall: {passed}/{total} tests passed")
|
|
|
|
if passed == total:
|
|
print("🎉 All tests passed! Debian-specific composer workflows are ready.")
|
|
return 0
|
|
else:
|
|
print("⚠️ Some tests failed. Please review the issues above.")
|
|
return 1
|
|
|
|
if __name__ == '__main__':
|
|
sys.exit(main())
|