Add some preconditions

Author: srbarrios

README.md

@@ -160,8 +160,8 @@ zypper -n install curl git tar gzip make gcc podman
 Install Go and Ginkgo
 ```bash
 curl -LO https://go.dev/dl/go1.21.13.linux-amd64.tar.gz
-tar -C /root -xzf go1.21.13.linux-amd64.tar.gz
-export PATH="/root/go/bin:$PATH"
+tar -C $HOME -xzf go1.21.13.linux-amd64.tar.gz
+export PATH="$HOME/go/bin:$PATH"
 go install github.com/onsi/ginkgo/v2/ginkgo@v2.20.1
 ```
 

tests/e2e/mgradm_test.go

@@ -5,49 +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 mgradmConfigPath = "./../../utils/mgradm.yaml"
+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 func(stdinPipe io.WriteCloser) {
+			err := stdinPipe.Close()
+			if err != nil {
+				GinkgoWriter.Printf("Error closing stdin pipe: %v", err)
+			}
+		}(stdinPipe)
 
-	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()
+	err = interactionWriter.Close()
+	if err != nil {
+		return "", err
+	}
+	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)
+		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"}
+		It("should run without error and handle repeated prompts", func() {
+			args := []string{"install", backend, "--config", mgradmConfigPath, "--logLevel", "debug"}
 			output, err := runMgradmCommand(args)
-
 			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() {
+			Skip("Skipping until we fix the previous test case")
 			args := []string{"install", "--help"}
 			output, err := runMgradmCommand(args)
 			Expect(err).To(Succeed())

tests/e2e/utils/mgradm.yaml

@@ -0,0 +1,26 @@
+db:
+  password: spacewalk
+ssl:
+  password: spacewalk
+
+email: galaxy-noise@suse.de
+emailFrom: root@suse.de
+registry: registry.opensuse.org/systemsmanagement/uyuni/master/containerfile
+
+tag: latest
+
+mirror: /srv/mirror
+debug:
+  java: true
+
+
+
+organization: SUSE Test
+admin:
+  password: admin
+  login: admin
+  firstName: Admin
+  lastName: Admin
+  email: galaxy-noise@suse.de
+tz:
+  Europe/Berlin