feat: Add Buildah module tests to Rhai integration tests

- Added comprehensive test suite for Buildah module functionality.
- Included tests for Builder pattern, image operations, and
  container operations.
- Added documentation describing test structure, execution, and
  details.

docs/rhai/buildah_module_tests.md

@@ -0,0 +1,105 @@
+# Buildah Module Tests
+
+This document describes the test scripts for the Buildah module in the SAL library. These tests verify the functionality of the Buildah module's container and image operations.
+
+## Test Structure
+
+The tests are organized into three main scripts:
+
+1. **Builder Pattern** (`01_builder_pattern.rhai`): Tests for the Builder pattern, including creating containers, running commands, and working with container content.
+2. **Image Operations** (`02_image_operations.rhai`): Tests for image-related operations like pulling, tagging, listing, and removing images.
+3. **Container Operations** (`03_container_operations.rhai`): Tests for container-related operations like configuration, isolation, and content management.
+
+Additionally, there's a runner script (`run_all_tests.rhai`) that executes all tests and reports results. The runner script contains simplified versions of the individual tests to avoid dependency issues.
+
+## Running the Tests
+
+To run all tests, execute the following command from the project root:
+
+```bash
+herodo --path src/rhai_tests/buildah/run_all_tests.rhai
+```
+
+To run individual test scripts:
+
+```bash
+herodo --path src/rhai_tests/buildah/01_builder_pattern.rhai
+```
+
+## Test Details
+
+### Builder Pattern Test
+
+The Builder Pattern test (`01_builder_pattern.rhai`) verifies the following functions:
+
+- `bah_new`: Creating a new Builder with a container from a specified image
+- Builder properties: `container_id`, `name`, `image`, `debug_mode`
+- `run`: Running commands in the container
+- `write_content`: Writing content to files in the container
+- `read_content`: Reading content from files in the container
+- `set_entrypoint`: Setting the container's entrypoint
+- `set_cmd`: Setting the container's command
+- `add`: Adding files to the container
+- `copy`: Copying files to the container
+- `commit`: Committing the container to an image
+- `remove`: Removing the container
+- `images`: Listing images
+- `image_remove`: Removing images
+
+### Image Operations Test
+
+The Image Operations test (`02_image_operations.rhai`) verifies the following functions:
+
+- `image_pull`: Pulling images from registries
+- `image_tag`: Tagging images
+- `images`: Listing images
+- `build`: Building images from Dockerfiles
+- `image_remove`: Removing images
+
+The test creates a temporary directory with a Dockerfile for testing the build functionality.
+
+### Container Operations Test
+
+The Container Operations test (`03_container_operations.rhai`) verifies the following functions:
+
+- `reset`: Resetting a Builder by removing its container
+- `config`: Configuring container properties
+- `run_with_isolation`: Running commands with isolation
+- Content operations: Creating and executing scripts in the container
+- `commit` with options: Committing a container with additional configuration
+
+## Test Runner
+
+The test runner script (`run_all_tests.rhai`) provides a framework for executing all tests and reporting results. It:
+
+1. Checks if Buildah is available before running tests
+2. Skips tests if Buildah is not available
+3. Contains simplified versions of each test
+4. Runs each test in a try/catch block to handle errors
+5. Catches and reports any errors
+6. Provides a summary of passed, failed, and skipped tests
+
+## Buildah Requirements
+
+These tests require the Buildah tool to be installed and available in the system's PATH. The tests will check for Buildah's availability and skip the tests if it's not found, rather than failing.
+
+## Adding New Tests
+
+To add a new test:
+
+1. Create a new Rhai script in the `src/rhai_tests/buildah` directory
+2. Add a new test section to the `run_all_tests.rhai` script
+3. Update this documentation to include information about the new test
+
+## Best Practices for Writing Tests
+
+When writing tests for the Buildah module:
+
+1. Always check if Buildah is available before running tests
+2. Use unique names for containers and images to avoid conflicts
+3. Clean up any containers, images, or files created during testing
+4. Use assertions to verify expected behavior
+5. Print clear messages about what's being tested
+6. Handle errors gracefully
+7. Make tests independent of each other
+8. Keep tests focused on specific functionality

docs/rhai/index.md

@@ -35,6 +35,7 @@ SAL includes test scripts for verifying the functionality of its Rhai integratio
 - [Process Module Tests](process_module_tests.md): Tests for command execution and process management
 - [Redis Client Module Tests](redisclient_module_tests.md): Tests for Redis connection and operations
 - [Text Module Tests](text_module_tests.md): Tests for text manipulation, normalization, replacement, and template rendering
+- [Buildah Module Tests](buildah_module_tests.md): Tests for container and image operations
 - [Running Tests](running_tests.md): Instructions for running all Rhai tests
 - [CI Workflow](ci_workflow.md): Continuous integration workflow for Rhai tests
 

src/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;
+}

src/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");
+}

src/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;
+}

src/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;