deb-bootc-image-builder/bib/test-container-extraction.go

package main

import (
	"fmt"
	"log"
	"os"
	"path/filepath"

	"github.com/particle-os/debian-bootc-image-builder/bib/internal/debos_integration"
)

func main() {
	fmt.Println("🧪 Testing Real Container Extraction")
	fmt.Println("====================================")

	// Create work directory
	workDir := "./test-container-extraction"
	os.RemoveAll(workDir) // Clean up previous test
	os.MkdirAll(workDir, 0755) // Create directory

	// Create container processor
	processor := debos_integration.NewContainerProcessor(workDir)

	// Test container extraction
	containerImage := "debian:trixie-slim" // Use a small image for testing
	
	fmt.Printf("📦 Extracting container: %s\n", containerImage)
	fmt.Printf("   Work directory: %s\n", workDir)
	
	// Extract container
	containerInfo, err := processor.ExtractContainer(containerImage)
	if err != nil {
		log.Fatalf("❌ Container extraction failed: %v", err)
	}

	fmt.Println("✅ Container extraction successful!")
	fmt.Printf("   Working directory: %s\n", containerInfo.WorkingDir)
	
	if containerInfo.OSRelease != nil {
		fmt.Printf("   OS: %s %s\n", containerInfo.OSRelease.ID, containerInfo.OSRelease.VersionID)
	}
	
	if len(containerInfo.PackageList) > 0 {
		fmt.Printf("   Packages found: %d\n", len(containerInfo.PackageList))
		// Show first few packages
		if len(containerInfo.PackageList) > 5 {
			fmt.Printf("   Sample packages: %v\n", containerInfo.PackageList[:5])
		} else {
			fmt.Printf("   Packages: %v\n", containerInfo.PackageList)
		}
	}
	
	if containerInfo.Size > 0 {
		fmt.Printf("   Container size: %d bytes (%.2f MB)\n", containerInfo.Size, float64(containerInfo.Size)/1024/1024)
	}
	
	if len(containerInfo.Layers) > 0 {
		fmt.Printf("   Container layers: %d\n", len(containerInfo.Layers))
		fmt.Printf("   Sample layers: %v\n", containerInfo.Layers[:min(3, len(containerInfo.Layers))])
	}

	// List extracted files
	fmt.Println("\n📁 Extracted files:")
	if entries, err := os.ReadDir(containerInfo.WorkingDir); err == nil {
		for _, entry := range entries {
			if entry.IsDir() {
				fmt.Printf("   📁 %s/\n", entry.Name())
			} else {
				fmt.Printf("   📄 %s\n", entry.Name())
			}
		}
	}

	// Test specific file extraction
	fmt.Println("\n🔍 Testing specific file extraction:")
	
	// Check for os-release
	osReleasePath := filepath.Join(containerInfo.WorkingDir, "etc/os-release")
	if data, err := os.ReadFile(osReleasePath); err == nil {
		fmt.Printf("   ✅ os-release found: %s\n", string(data[:min(100, len(data))]))
	} else {
		fmt.Printf("   ❌ os-release not found: %v\n", err)
	}

	// Check for package list
	dpkgStatusPath := filepath.Join(containerInfo.WorkingDir, "var/lib/dpkg/status")
	if data, err := os.ReadFile(dpkgStatusPath); err == nil {
		fmt.Printf("   ✅ dpkg status found: %d bytes\n", len(data))
	} else {
		fmt.Printf("   ❌ dpkg status not found: %v\n", err)
	}

	fmt.Println("\n🎉 Container extraction test completed successfully!")
	fmt.Println("\n💡 Next steps:")
	fmt.Println("   1. Test with different container images")
	fmt.Println("   2. Integrate with manifest generation")
	fmt.Println("   3. Test end-to-end image building")
	
	// Cleanup
	if err := processor.Cleanup(containerInfo); err != nil {
		fmt.Printf("⚠️  Cleanup warning: %v\n", err)
	}
}

func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}