...

rhai_tests/buildah/01_builder_pattern.rhai

@@ -0,0 +1,172 @@
+// 01_builder_pattern.rhai
+// Tests for Buildah Builder pattern
+
+// Custom assert function
+fn assert_true(condition, message) {
+    if !condition {
+        print(`ASSERTION FAILED: ${message}`);
+        throw message;
+    }
+}
+
+// Custom assert_eq function
+fn assert_eq(actual, expected, message) {
+    if actual != expected {
+        print(`ASSERTION FAILED: ${message}`);
+        print(`Expected: "${expected}"`);
+        print(`Actual: "${actual}"`);
+        throw message;
+    }
+}
+
+// Helper function to check if buildah is available
+fn is_buildah_available() {
+    try {
+        let result = run("which buildah");
+        return result.success;
+    } catch(err) {
+        return false;
+    }
+}
+
+print("=== Testing Buildah Builder Pattern ===");
+
+// Check if buildah is available
+let buildah_available = is_buildah_available();
+if !buildah_available {
+    print("Buildah is not available. Skipping Buildah tests.");
+    // Exit gracefully without error
+    return;
+}
+
+print("✓ Buildah is available");
+
+// Test creating a new Builder
+print("Testing bah_new()...");
+try {
+    let builder = bah_new("rhai_test_container", "alpine:latest");
+    
+    // Test Builder properties
+    print("Testing Builder properties...");
+    assert_true(builder.container_id != "", "Container ID should not be empty");
+    assert_eq(builder.name, "rhai_test_container", "Container name should match");
+    assert_eq(builder.image, "alpine:latest", "Image name should match");
+    
+    // Test debug mode
+    print("Testing debug mode...");
+    assert_true(!builder.debug_mode, "Debug mode should be off by default");
+    builder.debug_mode = true;
+    assert_true(builder.debug_mode, "Debug mode should be on after setting");
+    
+    // Test running a command
+    print("Testing run()...");
+    let result = builder.run("echo 'Hello from container'");
+    assert_true(result.success, "Command should succeed");
+    assert_true(result.stdout.contains("Hello from container"), "Command output should contain expected text");
+    print("✓ run(): Command executed successfully");
+    
+    // Test writing content to a file in the container
+    print("Testing write_content()...");
+    let content = "Hello from a file";
+    builder.write_content(content, "/test_file.txt");
+    
+    // Verify the content was written
+    let read_result = builder.run("cat /test_file.txt");
+    assert_true(read_result.success, "Command should succeed");
+    assert_true(read_result.stdout.contains(content), "File content should match what was written");
+    print("✓ write_content(): Content written successfully");
+    
+    // Test reading content from a file in the container
+    print("Testing read_content()...");
+    let read_content = builder.read_content("/test_file.txt");
+    assert_true(read_content.contains(content), "Read content should match what was written");
+    print("✓ read_content(): Content read successfully");
+    
+    // Test setting entrypoint
+    print("Testing set_entrypoint()...");
+    let entrypoint = ["/bin/sh", "-c"];
+    builder.set_entrypoint(entrypoint);
+    print("✓ set_entrypoint(): Entrypoint set successfully");
+    
+    // Test setting cmd
+    print("Testing set_cmd()...");
+    let cmd = ["echo", "Hello from CMD"];
+    builder.set_cmd(cmd);
+    print("✓ set_cmd(): CMD set successfully");
+    
+    // Test adding a file
+    print("Testing add()...");
+    // Create a test file
+    file_write("test_add_file.txt", "Test content for add");
+    builder.add("test_add_file.txt", "/");
+    
+    // Verify the file was added
+    let add_result = builder.run("cat /test_add_file.txt");
+    assert_true(add_result.success, "Command should succeed");
+    assert_true(add_result.stdout.contains("Test content for add"), "Added file content should match");
+    print("✓ add(): File added successfully");
+    
+    // Test copying a file
+    print("Testing copy()...");
+    // Create a test file
+    file_write("test_copy_file.txt", "Test content for copy");
+    builder.copy("test_copy_file.txt", "/");
+    
+    // Verify the file was copied
+    let copy_result = builder.run("cat /test_copy_file.txt");
+    assert_true(copy_result.success, "Command should succeed");
+    assert_true(copy_result.stdout.contains("Test content for copy"), "Copied file content should match");
+    print("✓ copy(): File copied successfully");
+    
+    // Test committing to an image
+    print("Testing commit()...");
+    let image_name = "rhai_test_image:latest";
+    builder.commit(image_name);
+    print("✓ commit(): Container committed to image successfully");
+    
+    // Test removing the container
+    print("Testing remove()...");
+    builder.remove();
+    print("✓ remove(): Container removed successfully");
+    
+    // Clean up test files
+    delete("test_add_file.txt");
+    delete("test_copy_file.txt");
+    
+    // Test image operations
+    print("Testing image operations...");
+    
+    // Test listing images
+    print("Testing images()...");
+    let images = builder.images();
+    assert_true(images.len() > 0, "There should be at least one image");
+    print("✓ images(): Images listed successfully");
+    
+    // Test removing the image
+    print("Testing image_remove()...");
+    builder.image_remove(image_name);
+    print("✓ image_remove(): Image removed successfully");
+    
+    print("All Builder pattern tests completed successfully!");
+} catch(err) {
+    print(`Error: ${err}`);
+    
+    // Clean up in case of error
+    try {
+        // Remove test container if it exists
+        run("buildah rm rhai_test_container");
+    } catch(_) {}
+    
+    try {
+        // Remove test image if it exists
+        run("buildah rmi rhai_test_image:latest");
+    } catch(_) {}
+    
+    try {
+        // Remove test files if they exist
+        delete("test_add_file.txt");
+        delete("test_copy_file.txt");
+    } catch(_) {}
+    
+    throw err;
+}

rhai_tests/buildah/02_image_operations.rhai

@@ -0,0 +1,150 @@
+// 02_image_operations.rhai
+// Tests for Buildah image operations
+
+// Custom assert function
+fn assert_true(condition, message) {
+    if !condition {
+        print(`ASSERTION FAILED: ${message}`);
+        throw message;
+    }
+}
+
+// Custom assert_eq function
+fn assert_eq(actual, expected, message) {
+    if actual != expected {
+        print(`ASSERTION FAILED: ${message}`);
+        print(`Expected: "${expected}"`);
+        print(`Actual: "${actual}"`);
+        throw message;
+    }
+}
+
+// Helper function to check if buildah is available
+fn is_buildah_available() {
+    try {
+        let result = run("which buildah");
+        return result.success;
+    } catch(err) {
+        return false;
+    }
+}
+
+// Helper function to check if an image exists
+fn image_exists(image_name) {
+    try {
+        let result = run(`buildah images -q ${image_name}`);
+        return result.success && result.stdout.trim() != "";
+    } catch(err) {
+        return false;
+    }
+}
+
+print("=== Testing Buildah Image Operations ===");
+
+// Check if buildah is available
+let buildah_available = is_buildah_available();
+if !buildah_available {
+    print("Buildah is not available. Skipping Buildah tests.");
+    // Exit gracefully without error
+    return;
+}
+
+print("✓ Buildah is available");
+
+// Create a temporary directory for testing
+let test_dir = "rhai_test_buildah";
+mkdir(test_dir);
+
+try {
+    // Create a builder for testing
+    let builder = bah_new("rhai_test_container", "alpine:latest");
+    
+    // Enable debug mode
+    builder.debug_mode = true;
+    
+    // Test image_pull
+    print("Testing image_pull()...");
+    // Use a small image for testing
+    let pull_result = builder.image_pull("alpine:3.14", true);
+    assert_true(pull_result.success, "Image pull should succeed");
+    print("✓ image_pull(): Image pulled successfully");
+    
+    // Test image_tag
+    print("Testing image_tag()...");
+    let tag_result = builder.image_tag("alpine:3.14", "rhai_test_tag:latest");
+    assert_true(tag_result.success, "Image tag should succeed");
+    print("✓ image_tag(): Image tagged successfully");
+    
+    // Test images (list)
+    print("Testing images()...");
+    let images = builder.images();
+    assert_true(images.len() > 0, "There should be at least one image");
+    
+    // Find our tagged image
+    let found_tag = false;
+    for image in images {
+        if image.names.contains("rhai_test_tag:latest") {
+            found_tag = true;
+            break;
+        }
+    }
+    assert_true(found_tag, "Tagged image should be in the list");
+    print("✓ images(): Images listed successfully");
+    
+    // Test build
+    print("Testing build()...");
+    
+    // Create a simple Dockerfile
+    let dockerfile_content = `FROM alpine:latest
+RUN echo "Hello from Dockerfile" > /hello.txt
+CMD ["cat", "/hello.txt"]
+`;
+    file_write(`${test_dir}/Dockerfile`, dockerfile_content);
+    
+    // Build the image
+    let build_result = builder.build("rhai_test_build:latest", test_dir, "Dockerfile", "oci");
+    assert_true(build_result.success, "Image build should succeed");
+    print("✓ build(): Image built successfully");
+    
+    // Verify the built image exists
+    assert_true(image_exists("rhai_test_build:latest"), "Built image should exist");
+    
+    // Test image_remove
+    print("Testing image_remove()...");
+    
+    // Remove the tagged image
+    let remove_tag_result = builder.image_remove("rhai_test_tag:latest");
+    assert_true(remove_tag_result.success, "Image removal should succeed");
+    print("✓ image_remove(): Tagged image removed successfully");
+    
+    // Remove the built image
+    let remove_build_result = builder.image_remove("rhai_test_build:latest");
+    assert_true(remove_build_result.success, "Image removal should succeed");
+    print("✓ image_remove(): Built image removed successfully");
+    
+    // Clean up
+    builder.remove();
+    print("✓ Cleanup: Container removed");
+    
+    print("All image operations tests completed successfully!");
+} catch(err) {
+    print(`Error: ${err}`);
+    
+    // Clean up in case of error
+    try {
+        // Remove test container if it exists
+        run("buildah rm rhai_test_container");
+    } catch(_) {}
+    
+    try {
+        // Remove test images if they exist
+        run("buildah rmi rhai_test_tag:latest");
+        run("buildah rmi rhai_test_build:latest");
+    } catch(_) {}
+    
+    throw err;
+} finally {
+    // Clean up test directory
+    delete(test_dir);
+    print("✓ Cleanup: Test directory removed");
+}

rhai_tests/buildah/03_container_operations.rhai

@@ -0,0 +1,127 @@
+// 03_container_operations.rhai
+// Tests for Buildah container operations
+
+// Custom assert function
+fn assert_true(condition, message) {
+    if !condition {
+        print(`ASSERTION FAILED: ${message}`);
+        throw message;
+    }
+}
+
+// Custom assert_eq function
+fn assert_eq(actual, expected, message) {
+    if actual != expected {
+        print(`ASSERTION FAILED: ${message}`);
+        print(`Expected: "${expected}"`);
+        print(`Actual: "${actual}"`);
+        throw message;
+    }
+}
+
+// Helper function to check if buildah is available
+fn is_buildah_available() {
+    try {
+        let result = run("which buildah");
+        return result.success;
+    } catch(err) {
+        return false;
+    }
+}
+
+print("=== Testing Buildah Container Operations ===");
+
+// Check if buildah is available
+let buildah_available = is_buildah_available();
+if !buildah_available {
+    print("Buildah is not available. Skipping Buildah tests.");
+    // Exit gracefully without error
+    return;
+}
+
+print("✓ Buildah is available");
+
+try {
+    // Test creating a new Builder
+    print("Testing bah_new() and reset()...");
+    let builder = bah_new("rhai_test_container", "alpine:latest");
+    
+    // Enable debug mode
+    builder.debug_mode = true;
+    
+    // Test reset
+    print("Testing reset()...");
+    builder.reset();
+    print("✓ reset(): Container reset successfully");
+    
+    // Create a new container
+    builder = bah_new("rhai_test_container", "alpine:latest");
+    
+    // Test config
+    print("Testing config()...");
+    let config_options = #{
+        "LABEL": "rhai_test=true",
+        "ENV": "TEST_VAR=test_value"
+    };
+    builder.config(config_options);
+    print("✓ config(): Container configured successfully");
+    
+    // Test run with isolation
+    print("Testing run_with_isolation()...");
+    let isolation_result = builder.run_with_isolation("echo 'Hello with isolation'", "oci");
+    assert_true(isolation_result.success, "Command with isolation should succeed");
+    assert_true(isolation_result.stdout.contains("Hello with isolation"), "Command output should contain expected text");
+    print("✓ run_with_isolation(): Command executed successfully");
+    
+    // Test content operations
+    print("Testing content operations...");
+    
+    // Write content to a file
+    let script_content = `#!/bin/sh
+echo "Hello from script"
+`;
+    builder.write_content(script_content, "/script.sh");
+    
+    // Make the script executable
+    builder.run("chmod +x /script.sh");
+    
+    // Run the script
+    let script_result = builder.run("/script.sh");
+    assert_true(script_result.success, "Script should execute successfully");
+    assert_true(script_result.stdout.contains("Hello from script"), "Script output should contain expected text");
+    print("✓ Content operations: Script created and executed successfully");
+    
+    // Test commit with config
+    print("Testing commit with config...");
+    let commit_options = #{
+        "author": "Rhai Test",
+        "message": "Test commit"
+    };
+    builder.commit("rhai_test_commit:latest", commit_options);
+    print("✓ commit(): Container committed with config successfully");
+    
+    // Clean up
+    builder.remove();
+    print("✓ Cleanup: Container removed");
+    
+    // Remove the committed image
+    builder.image_remove("rhai_test_commit:latest");
+    print("✓ Cleanup: Committed image removed");
+    
+    print("All container operations tests completed successfully!");
+} catch(err) {
+    print(`Error: ${err}`);
+    
+    // Clean up in case of error
+    try {
+        // Remove test container if it exists
+        run("buildah rm rhai_test_container");
+    } catch(_) {}
+    
+    try {
+        // Remove test image if it exists
+        run("buildah rmi rhai_test_commit:latest");
+    } catch(_) {}
+    
+    throw err;
+}

rhai_tests/buildah/run_all_tests.rhai

@@ -0,0 +1,155 @@
+// run_all_tests.rhai
+// Runs all Buildah module tests
+
+print("=== Running Buildah Module Tests ===");
+
+// Custom assert function
+fn assert_true(condition, message) {
+    if !condition {
+        print(`ASSERTION FAILED: ${message}`);
+        throw message;
+    }
+}
+
+// Helper function to check if buildah is available
+fn is_buildah_available() {
+    try {
+        let result = run("which buildah");
+        return result.success;
+    } catch(e) {
+        return false;
+    }
+}
+
+// Run each test directly
+let passed = 0;
+let failed = 0;
+let skipped = 0;
+let total = 0;
+
+// Check if buildah is available
+let buildah_available = is_buildah_available();
+if !buildah_available {
+    print("Buildah is not available. Skipping all Buildah tests.");
+    skipped = 3; // Skip all three tests
+    total = 3;
+} else {
+    // Test 1: Builder Pattern
+    print("\n--- Running Builder Pattern Tests ---");
+    try {
+        // Create a builder
+        let builder = bah_new("rhai_test_container", "alpine:latest");
+        
+        // Test basic properties
+        assert_true(builder.container_id != "", "Container ID should not be empty");
+        assert_true(builder.name == "rhai_test_container", "Container name should match");
+        
+        // Run a simple command
+        let result = builder.run("echo 'Hello from container'");
+        assert_true(result.success, "Command should succeed");
+        
+        // Clean up
+        builder.remove();
+        
+        print("--- Builder Pattern Tests completed successfully ---");
+        passed += 1;
+    } catch(err) {
+        print(`!!! Error in Builder Pattern Tests: ${err}`);
+        failed += 1;
+        
+        // Clean up in case of error
+        try {
+            run("buildah rm rhai_test_container");
+        } catch(e) {
+            // Ignore errors during cleanup
+        }
+    }
+    total += 1;
+    
+    // Test 2: Image Operations
+    print("\n--- Running Image Operations Tests ---");
+    try {
+        // Create a temporary directory for testing
+        let test_dir = "rhai_test_buildah";
+        mkdir(test_dir);
+        
+        // Create a builder
+        let builder = bah_new("rhai_test_container", "alpine:latest");
+        
+        // List images
+        let images = builder.images();
+        assert_true(images.len() > 0, "There should be at least one image");
+        
+        // Clean up
+        builder.remove();
+        delete(test_dir);
+        
+        print("--- Image Operations Tests completed successfully ---");
+        passed += 1;
+    } catch(err) {
+        print(`!!! Error in Image Operations Tests: ${err}`);
+        failed += 1;
+        
+        // Clean up in case of error
+        try {
+            run("buildah rm rhai_test_container");
+            delete("rhai_test_buildah");
+        } catch(e) {
+            // Ignore errors during cleanup
+        }
+    }
+    total += 1;
+    
+    // Test 3: Container Operations
+    print("\n--- Running Container Operations Tests ---");
+    try {
+        // Create a builder
+        let builder = bah_new("rhai_test_container", "alpine:latest");
+        
+        // Test reset
+        builder.reset();
+        
+        // Create a new container
+        builder = bah_new("rhai_test_container", "alpine:latest");
+        
+        // Run a command
+        let result = builder.run("echo 'Hello from container'");
+        assert_true(result.success, "Command should succeed");
+        
+        // Clean up
+        builder.remove();
+        
+        print("--- Container Operations Tests completed successfully ---");
+        passed += 1;
+    } catch(err) {
+        print(`!!! Error in Container Operations Tests: ${err}`);
+        failed += 1;
+        
+        // Clean up in case of error
+        try {
+            run("buildah rm rhai_test_container");
+        } catch(e) {
+            // Ignore errors during cleanup
+        }
+    }
+    total += 1;
+}
+
+print("\n=== Test Summary ===");
+print(`Passed: ${passed}`);
+print(`Failed: ${failed}`);
+print(`Skipped: ${skipped}`);
+print(`Total: ${total}`);
+
+if failed == 0 {
+    if skipped > 0 {
+        print("\n⚠️ All tests skipped or passed!");
+    } else {
+        print("\n✅ All tests passed!");
+    }
+} else {
+    print("\n❌ Some tests failed!");
+}
+
+// Return the number of failed tests (0 means success)
+failed;