particle-os-tools/test-composefs-integration.sh

#!/bin/bash

# Test script for apt-layer ComposeFS integration
# Validates the Phase 2.2 implementation: Basic ComposeFS Integration

set -e

# Colors for output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color

# Test counters
TOTAL_TESTS=0
PASSED_TESTS=0
FAILED_TESTS=0

# Test logging functions
log_test() {
    echo -e "${BLUE}[TEST]${NC} $1"
}

log_pass() {
    echo -e "${GREEN}[PASS]${NC} $1"
    ((PASSED_TESTS++))
}

log_fail() {
    echo -e "${RED}[FAIL]${NC} $1"
    ((FAILED_TESTS++))
}

log_info() {
    echo -e "${YELLOW}[INFO]${NC} $1"
}

# Test summary
print_summary() {
    echo ""
    echo "=========================================="
    echo "COMPOSEFS INTEGRATION TEST SUMMARY"
    echo "=========================================="
    echo "Total Tests: $TOTAL_TESTS"
    echo "Passed: $PASSED_TESTS"
    echo "Failed: $FAILED_TESTS"
    echo "Success Rate: $((PASSED_TESTS * 100 / TOTAL_TESTS))%"
    echo "=========================================="
    
    if [[ $FAILED_TESTS -eq 0 ]]; then
        echo -e "${GREEN}All tests passed! ComposeFS integration is working correctly.${NC}"
        exit 0
    else
        echo -e "${RED}Some tests failed. Please review the output above.${NC}"
        exit 1
    fi
}

# Cleanup function
cleanup() {
    log_info "Cleaning up test artifacts..."
    
    # Unmount any test mounts
    for mount_point in /tmp/apt-layer-composefs-test-*; do
        if [[ -d "$mount_point" ]] && mountpoint -q "$mount_point" 2>/dev/null; then
            umount "$mount_point" 2>/dev/null || true
            rmdir "$mount_point" 2>/dev/null || true
        fi
    done
    
    # Remove test files
    rm -rf /tmp/apt-layer-composefs-test-*
}

# Setup test environment
setup_test_env() {
    log_info "Setting up test environment..."
    
    # Create test directories
    mkdir -p /tmp/apt-layer-composefs-test-source
    mkdir -p /tmp/apt-layer-composefs-test-layers
    mkdir -p /tmp/apt-layer-composefs-test-mounts
    
    # Create test source content
    echo "Test file 1" > /tmp/apt-layer-composefs-test-source/file1.txt
    echo "Test file 2" > /tmp/apt-layer-composefs-test-source/file2.txt
    mkdir -p /tmp/apt-layer-composefs-test-source/subdir
    echo "Test file 3" > /tmp/apt-layer-composefs-test-source/subdir/file3.txt
    
    # Set permissions for testing
    chmod 644 /tmp/apt-layer-composefs-test-source/file1.txt
    chmod 755 /tmp/apt-layer-composefs-test-source/subdir
    
    log_info "Test environment setup completed"
}

# Test 1: Basic ComposeFS layer creation
test_basic_layer_creation() {
    ((TOTAL_TESTS++))
    log_test "Testing basic ComposeFS layer creation..."
    
    local source_dir="/tmp/apt-layer-composefs-test-source"
    local layer_path="/tmp/apt-layer-composefs-test-layers/test-layer.composefs"
    
    if ! apt-layer composefs create "$source_dir" "$layer_path" "test-layer"; then
        log_fail "Basic layer creation failed"
        return 1
    fi
    
    # Check if layer file exists
    if [[ ! -f "$layer_path" ]]; then
        log_fail "Layer file not created"
        return 1
    fi
    
    # Check if layer file has content
    local file_size
    file_size=$(stat -c%s "$layer_path" 2>/dev/null || echo "0")
    if [[ $file_size -eq 0 ]]; then
        log_fail "Layer file is empty"
        return 1
    fi
    
    log_pass "Basic layer creation test passed"
    return 0
}

# Test 2: Atomic layer creation
test_atomic_layer_creation() {
    ((TOTAL_TESTS++))
    log_test "Testing atomic ComposeFS layer creation..."
    
    local source_dir="/tmp/apt-layer-composefs-test-source"
    local layer_path="/tmp/apt-layer-composefs-test-layers/atomic-layer.composefs"
    
    if ! apt-layer composefs atomic-create "$source_dir" "$layer_path" "atomic-layer" "true" "keep-latest"; then
        log_fail "Atomic layer creation failed"
        return 1
    fi
    
    # Check if layer file exists
    if [[ ! -f "$layer_path" ]]; then
        log_fail "Atomic layer file not created"
        return 1
    fi
    
    # Check if metadata file exists
    if [[ ! -f "${layer_path}.metadata" ]]; then
        log_fail "Metadata file not created"
        return 1
    fi
    
    log_pass "Atomic layer creation test passed"
    return 0
}

# Test 3: Layer mounting and unmounting
test_layer_mounting() {
    ((TOTAL_TESTS++))
    log_test "Testing ComposeFS layer mounting and unmounting..."
    
    local layer_path="/tmp/apt-layer-composefs-test-layers/test-layer.composefs"
    local mount_point="/tmp/apt-layer-composefs-test-mounts/test-mount"
    
    # Create layer if it doesn't exist
    if [[ ! -f "$layer_path" ]]; then
        local source_dir="/tmp/apt-layer-composefs-test-source"
        if ! apt-layer composefs create "$source_dir" "$layer_path" "test-layer"; then
            log_fail "Failed to create layer for mounting test"
            return 1
        fi
    fi
    
    # Mount layer
    if ! apt-layer composefs mount "$layer_path" "$mount_point"; then
        log_fail "Layer mounting failed"
        return 1
    fi
    
    # Check if mount point is mounted
    if ! mountpoint -q "$mount_point"; then
        log_fail "Mount point is not mounted"
        return 1
    fi
    
    # Check if files are accessible
    if [[ ! -f "$mount_point/file1.txt" ]]; then
        log_fail "Mounted files not accessible"
        return 1
    fi
    
    # Unmount layer
    if ! apt-layer composefs unmount "$mount_point"; then
        log_fail "Layer unmounting failed"
        return 1
    fi
    
    # Check if mount point is unmounted
    if mountpoint -q "$mount_point"; then
        log_fail "Mount point is still mounted"
        return 1
    fi
    
    log_pass "Layer mounting and unmounting test passed"
    return 0
}

# Test 4: Layer validation
test_layer_validation() {
    ((TOTAL_TESTS++))
    log_test "Testing ComposeFS layer validation..."
    
    local layer_path="/tmp/apt-layer-composefs-test-layers/test-layer.composefs"
    
    # Create layer if it doesn't exist
    if [[ ! -f "$layer_path" ]]; then
        local source_dir="/tmp/apt-layer-composefs-test-source"
        if ! apt-layer composefs create "$source_dir" "$layer_path" "test-layer"; then
            log_fail "Failed to create layer for validation test"
            return 1
        fi
    fi
    
    # Validate layer
    if ! apt-layer composefs validate "$layer_path"; then
        log_fail "Layer validation failed"
        return 1
    fi
    
    log_pass "Layer validation test passed"
    return 0
}

# Test 5: Layer testing
test_layer_testing() {
    ((TOTAL_TESTS++))
    log_test "Testing ComposeFS layer testing functionality..."
    
    local layer_path="/tmp/apt-layer-composefs-test-layers/test-layer.composefs"
    local test_mount_point="/tmp/apt-layer-composefs-test-mounts/test-layer-test"
    
    # Create layer if it doesn't exist
    if [[ ! -f "$layer_path" ]]; then
        local source_dir="/tmp/apt-layer-composefs-test-source"
        if ! apt-layer composefs create "$source_dir" "$layer_path" "test-layer"; then
            log_fail "Failed to create layer for testing"
            return 1
        fi
    fi
    
    # Test layer
    if ! apt-layer composefs test "$layer_path" "$test_mount_point"; then
        log_fail "Layer testing failed"
        return 1
    fi
    
    log_pass "Layer testing functionality test passed"
    return 0
}

# Test 6: Layer composition
test_layer_composition() {
    ((TOTAL_TESTS++))
    log_test "Testing ComposeFS layer composition..."
    
    # Create base layer
    local source_dir1="/tmp/apt-layer-composefs-test-source"
    local base_layer="/tmp/apt-layer-composefs-test-layers/base-layer.composefs"
    
    if ! apt-layer composefs create "$source_dir1" "$base_layer" "base-layer"; then
        log_fail "Failed to create base layer for composition test"
        return 1
    fi
    
    # Create overlay source
    local overlay_source="/tmp/apt-layer-composefs-test-overlay"
    mkdir -p "$overlay_source"
    echo "Overlay file" > "$overlay_source/overlay.txt"
    
    # Create overlay layer
    local overlay_layer="/tmp/apt-layer-composefs-test-layers/overlay-layer.composefs"
    if ! apt-layer composefs create "$overlay_source" "$overlay_layer" "overlay-layer"; then
        log_fail "Failed to create overlay layer for composition test"
        return 1
    fi
    
    # Compose layers
    local composed_layer="/tmp/apt-layer-composefs-test-layers/composed-layer.composefs"
    if ! apt-layer composefs compose "$base_layer" "$overlay_layer" "$composed_layer" "keep-latest"; then
        log_fail "Layer composition failed"
        return 1
    fi
    
    # Check if composed layer exists
    if [[ ! -f "$composed_layer" ]]; then
        log_fail "Composed layer not created"
        return 1
    fi
    
    log_pass "Layer composition test passed"
    return 0
}

# Test 7: Layer rollback
test_layer_rollback() {
    ((TOTAL_TESTS++))
    log_test "Testing ComposeFS layer rollback..."
    
    local current_layer="/tmp/apt-layer-composefs-test-layers/current-layer.composefs"
    local backup_layer="/tmp/apt-layer-composefs-test-layers/backup-layer.composefs"
    
    # Create backup layer
    local source_dir="/tmp/apt-layer-composefs-test-source"
    if ! apt-layer composefs create "$source_dir" "$backup_layer" "backup-layer"; then
        log_fail "Failed to create backup layer for rollback test"
        return 1
    fi
    
    # Create current layer (different content)
    local current_source="/tmp/apt-layer-composefs-test-current"
    mkdir -p "$current_source"
    echo "Current content" > "$current_source/current.txt"
    
    if ! apt-layer composefs create "$current_source" "$current_layer" "current-layer"; then
        log_fail "Failed to create current layer for rollback test"
        return 1
    fi
    
    # Perform rollback
    if ! apt-layer composefs rollback "$current_layer" "$backup_layer"; then
        log_fail "Layer rollback failed"
        return 1
    fi
    
    # Verify rollback (current layer should now match backup)
    if ! apt-layer composefs validate "$current_layer"; then
        log_fail "Rolled back layer validation failed"
        return 1
    fi
    
    log_pass "Layer rollback test passed"
    return 0
}

# Test 8: ComposeFS status
test_composefs_status() {
    ((TOTAL_TESTS++))
    log_test "Testing ComposeFS status functionality..."
    
    if ! apt-layer composefs status; then
        log_fail "ComposeFS status failed"
        return 1
    fi
    
    log_pass "ComposeFS status test passed"
    return 0
}

# Test 9: ComposeFS tools availability
test_composefs_tools() {
    ((TOTAL_TESTS++))
    log_test "Testing ComposeFS tools availability..."
    
    local tools_missing=0
    
    # Check for mkcomposefs
    if ! command -v mkcomposefs &> /dev/null; then
        log_fail "mkcomposefs not found"
        ((tools_missing++))
    fi
    
    # Check for composefs-info
    if ! command -v composefs-info &> /dev/null; then
        log_warning "composefs-info not found (optional)"
    fi
    
    # Check for mount.composefs
    if ! command -v mount.composefs &> /dev/null; then
        log_fail "mount.composefs not found"
        ((tools_missing++))
    fi
    
    if [[ $tools_missing -eq 0 ]]; then
        log_pass "ComposeFS tools availability test passed"
        return 0
    else
        log_fail "Some ComposeFS tools are missing"
        return 1
    fi
}

# Test 10: Metadata handling
test_metadata_handling() {
    ((TOTAL_TESTS++))
    log_test "Testing ComposeFS metadata handling..."
    
    local source_dir="/tmp/apt-layer-composefs-test-source"
    local layer_path="/tmp/apt-layer-composefs-test-layers/metadata-layer.composefs"
    
    # Create layer with metadata preservation
    if ! apt-layer composefs atomic-create "$source_dir" "$layer_path" "metadata-layer" "true" "keep-latest"; then
        log_fail "Failed to create layer with metadata"
        return 1
    fi
    
    # Check if metadata file exists
    local metadata_file="${layer_path}.metadata"
    if [[ ! -f "$metadata_file" ]]; then
        log_fail "Metadata file not created"
        return 1
    fi
    
    # Check if metadata file has content
    local metadata_size
    metadata_size=$(stat -c%s "$metadata_file" 2>/dev/null || echo "0")
    if [[ $metadata_size -eq 0 ]]; then
        log_fail "Metadata file is empty"
        return 1
    fi
    
    # Check for required metadata fields
    if ! grep -q "timestamp:" "$metadata_file"; then
        log_fail "Timestamp not found in metadata"
        return 1
    fi
    
    if ! grep -q "file_count:" "$metadata_file"; then
        log_fail "File count not found in metadata"
        return 1
    fi
    
    log_pass "Metadata handling test passed"
    return 0
}

# Main test execution
main() {
    echo "=========================================="
    echo "apt-layer COMPOSEFS INTEGRATION TEST SUITE"
    echo "=========================================="
    echo "Testing Phase 2.2: Basic ComposeFS Integration"
    echo "=========================================="
    echo ""
    
    # Setup test environment
    setup_test_env
    
    # Run tests
    test_composefs_tools
    test_basic_layer_creation
    test_atomic_layer_creation
    test_layer_validation
    test_layer_mounting
    test_layer_testing
    test_layer_composition
    test_layer_rollback
    test_metadata_handling
    test_composefs_status
    
    # Print summary
    print_summary
}

# Cleanup on exit
trap cleanup EXIT

# Run main function
main "$@"