Add some preconditions

Author: srbarrios

tests/e2e/mgradm_test.go

@@ -5,51 +5,154 @@
 package e2e_test
 
 import (
+	"bufio"
 	"bytes"
 	"fmt"
+	"io"
+	"os"
 	"os/exec"
+	"strings"
+	"sync"
 
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
 )
 
-// Define the mgradm binary path
-const mgradmPath = "/workspace/bin/mgradm"
+const mgradmPath = "./../../bin/mgradm"
+const backend = "podman"
 
-// runMgradmCommand is a helper function to execute mgradm and capture its output.
-// It returns the combined stdout+stderr and an error if the command fails to run.
-func runMgradmCommand(args []string) (string, error) {
+// interaction defines a prompt to look for and the corresponding response to send.
+type interaction struct {
+	Prompt   string
+	Response string
+}
+
+// runMgradmCommand executes mgradm, handling an ordered sequence of interactive prompts.
+func runMgradmCommand(args []string, interactions []interaction) (string, error) {
 	cmd := exec.Command(mgradmPath, args...)
 
-	var stdoutBuffer bytes.Buffer
-	var stderrBuffer bytes.Buffer
-	cmd.Stdout = &stdoutBuffer
-	cmd.Stderr = &stderrBuffer
+	var combinedOutputBuffer bytes.Buffer
+	var wg sync.WaitGroup
+
+	stdoutPipe, err := cmd.StdoutPipe()
+	if err != nil {
+		return "", fmt.Errorf("error creating stdout pipe: %w", err)
+	}
+
+	stderrPipe, err := cmd.StderrPipe()
+	if err != nil {
+		return "", fmt.Errorf("error creating stderr pipe: %w", err)
+	}
+
+	stdinPipe, err := cmd.StdinPipe()
+	if err != nil {
+		return "", fmt.Errorf("error creating stdin pipe: %w", err)
+	}
+
+	interactionReader, interactionWriter := io.Pipe()
+	mainWriter := io.MultiWriter(&combinedOutputBuffer, GinkgoWriter, interactionWriter)
 
 	By(fmt.Sprintf("Running command: %s %v", mgradmPath, args))
+	if err := cmd.Start(); err != nil {
+		err := interactionWriter.Close()
+		if err != nil {
+			return "", err
+		}
+		return "", fmt.Errorf("error starting command: %w", err)
+	}
+
+	// This goroutine handles the ordered sequence of interactions.
+	wg.Add(1)
+	go func() {
+		defer wg.Done()
+		defer stdinPipe.Close()
 
-	err := cmd.Run()
-	output := stdoutBuffer.String() + stderrBuffer.String()
+		interactionIndex := 0
+		scanner := bufio.NewScanner(interactionReader)
+		for scanner.Scan() {
+			line := scanner.Text()
+			// Check if there are still interactions left to perform.
+			if interactionIndex < len(interactions) {
+				currentInteraction := interactions[interactionIndex]
+				if strings.Contains(line, currentInteraction.Prompt) {
+					By(fmt.Sprintf("Answering prompt '%s' with '%s'", currentInteraction.Prompt, currentInteraction.Response))
+					_, err := io.WriteString(stdinPipe, currentInteraction.Response+"\n")
+					if err != nil {
+						GinkgoWriter.Printf("Error writing to stdin: %v", err)
+					}
+					// Move to the next expected interaction.
+					interactionIndex++
+				}
+			}
+		}
+	}()
 
-	return output, err
+	// Goroutines to copy stdout and stderr to the main writer.
+	wg.Add(2)
+	go func() {
+		defer wg.Done()
+		_, err := io.Copy(mainWriter, stdoutPipe)
+		if err != nil {
+			return
+		}
+	}()
+	go func() {
+		defer wg.Done()
+		_, err := io.Copy(mainWriter, stderrPipe)
+		if err != nil {
+			return
+		}
+	}()
+
+	err = cmd.Wait()
+	interactionWriter.Close()
+	wg.Wait()
+
+	return combinedOutputBuffer.String(), err
 }
 
+var _ = BeforeSuite(func() {
+	_, err := os.Stat(mgradmPath)
+	Expect(err).To(Succeed(), "mgradm binary not found at %s. Error: %v", mgradmPath, err)
+
+	GinkgoWriter.Printf("Using mgradm: %s\n", mgradmPath)
+})
+
 var _ = Describe("mgradm tests", func() {
+	// Ensure that the environment is clean before each test.
+	BeforeEach(func() {
+		By(fmt.Sprintf("Running mgradm cleanup: uninstall --backend %s --force --purge-volumes --purge-images", backend))
+		cleanupArgs := []string{"uninstall", "--backend", backend, "--force", "--purge-volumes", "--purge-images"}
+		output, err := runMgradmCommand(cleanupArgs, nil)
+		Expect(err).To(Succeed(), "Failed to run mgradm cleanup command. Error: %v\nOutput: %s", err, output)
+	})
 
 	Context("install command", func() {
-		It("should run without error with default options", func() {
-			args := []string{"install", "podman", "--logLevel", "debug"}
-			output, err := runMgradmCommand(args)
+		It("should run without error and handle repeated prompts", func() {
+			args := []string{"install", backend, "--logLevel", "debug"}
+			// Define the ordered sequence of interactions.
+			interactions := []interaction{
+				{Prompt: "Password for the CA key to generate:", Response: "uyuni"},
+				{Prompt: "Confirm the password:", Response: "uyuni"},
+				{Prompt: "Administrator password:", Response: "admin"},
+				{Prompt: "Confirm the password:", Response: "admin"},
+			}
+			output, err := runMgradmCommand(args, interactions)
 
 			Expect(err).To(Succeed(), "Command failed with error: %v\nOutput: %s", err, output)
-			Expect(output).To(ContainSubstring("Starting /workspace/bin/mgradm install podman --logLevel debug"))
-			Expect(output).To(ContainSubstring("Use of this software implies acceptance of the End User License Agreement."))
-			Expect(output).To(ContainSubstring("application log level=debug"))
+			Expect(output).Should(ContainSubstring("mgradm install %s --logLevel debug", backend))
+			Expect(output).Should(ContainSubstring("Setting up uyuni network"))
+			Expect(output).Should(ContainSubstring("Enabling system service"))
+			Expect(output).Should(ContainSubstring("Waiting for the server to start"))
+			Expect(output).Should(ContainSubstring("Run setup command in the container"))
+			Expect(output).Should(ContainSubstring("Populating the database"))
+			Expect(output).ShouldNot(MatchRegexp(`(?i)\berr(or)?\b`))
+			Expect(output).Should(ContainSubstring("Server configuration finished"))
 		})
 
 		It("should show help for install command", func() {
 			args := []string{"install", "--help"}
-			output, err := runMgradmCommand(args)
+			output, err := runMgradmCommand(args, nil)
 			Expect(err).To(Succeed())
 			Expect(output).To(ContainSubstring("Install a new server"))
 		})