fix(e2e-523): inital commit - fixing e2e/system tests - WIP

e2e/system/build_from_git_test.go

@@ -1,32 +1,41 @@
 package system
 
 import (
+	"bytes"
 	"context"
 	"strings"
 
 	"github.com/celestiaorg/knuu/pkg/builder"
 )
 
+const (
+	gitRepo   = "https://github.com/celestiaorg/knuu.git"
+	gitBranch = "test/build-from-git" // This branch has a Dockerfile and is protected as to not be deleted
+)
+
 func (s *Suite) TestBuildFromGit() {
 	const namePrefix = "build-from-git"
 	s.T().Parallel()
 
 	// Setup
 	ctx := context.Background()
 
+	s.T().Log("Creating new instance")
 	target, err := s.Knuu.NewInstance(namePrefix)
-	s.Require().NoError(err)
+	if err != nil {
+		s.Require().NoError(err, "Error creating new instance")
+	}
 
 	s.T().Log("Building the image")
 
 	// This is a blocking call which builds the image from git repo
 	err = target.Build().SetGitRepo(ctx, builder.GitContext{
-		Repo:     "https://github.com/celestiaorg/knuu.git",
-		Branch:   "test/build-from-git", // This branch has a Dockerfile and is protected as to not be deleted
+		Repo:     gitRepo,
+		Branch:   gitBranch,
 		Username: "",
 		Password: "",
 	})
-	s.Require().NoError(err)
+	s.Require().NoError(err, "Error setting git repo")
 
 	s.T().Log("Image built")
 
@@ -41,51 +50,88 @@ func (s *Suite) TestBuildFromGit() {
 	s.T().Logf("Starting instance")
 	s.Require().NoError(target.Execution().Start(ctx))
 
-	s.T().Logf("Instance started")
+	s.T().Log("Instance started")
 
+	s.T().Log("Getting file bytes")
 	// The file is created by the dockerfile in the repo,
 	// so to make sure it is built correctly, we check the file
 	data, err := target.Storage().GetFileBytes(ctx, "/test.txt")
 	s.Require().NoError(err)
 
 	data = []byte(strings.TrimSpace(string(data)))
-	s.Assert().Equal([]byte("Hello, World!"), data, "File bytes do not match")
+	if !bytes.Equal([]byte("Hello, World!"), data) {
+		s.Require().NoError(err, "File bytes do not match. Expected 'Hello, World!', got '%s'", string(data))
+	}
+
+	s.T().Log("Test completed successfully")
 }
+
 func (s *Suite) TestBuildFromGitWithModifications() {
-	const namePrefix = "build-from-git-with-modifications"
+	const (
+		namePrefix = "build-from-git-with-modifications"
+		maxRetries = 3
+	)
 	s.T().Parallel()
 
 	// Setup
-	target, err := s.Knuu.NewInstance(namePrefix)
-	s.Require().NoError(err)
-
 	ctx := context.Background()
-	// This is a blocking call which builds the image from git repo
-	err = target.Build().SetGitRepo(ctx, builder.GitContext{
-		Repo:     "https://github.com/celestiaorg/knuu.git",
-		Branch:   "test/build-from-git", // This branch has a Dockerfile and is protected as to not be deleted
-		Username: "",
-		Password: "",
-	})
-	s.Require().NoError(err)
-
-	s.Require().NoError(target.Build().SetStartCommand("sleep", "infinity"))
 
-	err = target.Storage().AddFileBytes([]byte("Hello, world!"), "/home/hello.txt", "root:root")
+	s.T().Log("Creating new instance")
+	target, err := s.Knuu.NewInstance(namePrefix)
+	if err != nil {
+		s.Require().NoError(err, "Error creating new instance")
+	}
+
+	s.T().Log("Setting git repo")
+	err = s.retryOperation(func() error {
+		return target.Build().SetGitRepo(ctx, builder.GitContext{
+			Repo:     gitRepo,
+			Branch:   gitBranch,
+			Username: "",
+			Password: "",
+		})
+	}, maxRetries)
+	s.Require().NoError(err, "Error setting git repo")
+
+	s.T().Log("Setting command")
+	err = s.retryOperation(func() error {
+		return target.Build().SetStartCommand("sleep", "infinity")
+	}, maxRetries)
+	s.Require().NoError(err, "Error setting command")
+
+	s.T().Log("Adding file")
+	err = s.retryOperation(func() error {
+		return target.Storage().AddFileBytes([]byte("Hello, world!"), "/home/hello.txt", "root:root")
+	}, maxRetries)
 	s.Require().NoError(err, "Error adding file")
 
-	s.Require().NoError(target.Build().Commit(ctx))
+	s.T().Log("Committing changes")
+	err = s.retryOperation(func() error {
+		return target.Build().Commit(ctx)
+	}, maxRetries)
+	s.Require().NoError(err, "Error committing changes")
 
 	s.T().Cleanup(func() {
+		s.T().Log("Cleaning up instance")
 		if err := target.Execution().Destroy(ctx); err != nil {
-			s.T().Logf("Error cleaning up knuu: %v", err)
+			s.T().Logf("error destroying instance: %v", err)
 		}
 	})
 
-	s.Require().NoError(target.Execution().Start(ctx))
+	s.T().Log("Starting instance")
+	err = s.retryOperation(func() error {
+		return target.Execution().Start(ctx)
+	}, maxRetries)
+	s.Require().NoError(err, "Error starting instance")
 
-	data, err := target.Storage().GetFileBytes(ctx, "/home/hello.txt")
-	s.Require().NoError(err, "Error getting file bytes")
+	s.T().Log("Getting file bytes")
+	var data []byte
+	err = s.retryOperation(func() error {
+		var err error
+		data, err = target.Storage().GetFileBytes(ctx, "/home/hello.txt")
+		return err
+	}, maxRetries)
 
-	s.Assert().Equal([]byte("Hello, world!"), data, "File bytes do not match")
+	s.Require().NoError(err, "Error getting file bytes")
+	s.Assert().Equal([]byte("Hello, world!"), data, "file bytes do not match.")
 }

e2e/system/file_test.go

@@ -13,44 +13,79 @@ import (
 )
 
 func (s *Suite) TestFile() {
-	const namePrefix = "file"
+	const (
+		namePrefix = "file"
+		maxRetries = 3
+	)
 	s.T().Parallel()
-	// Setup
 
+	// Setup
 	ctx := context.Background()
+
+	s.T().Log("Creating executor instance")
 	executor, err := s.Executor.NewInstance(ctx, namePrefix+"-executor")
-	s.Require().NoError(err)
+	if err != nil {
+		s.Require().NoError(err, "Error creating executor instance")
+	}
 
+	s.T().Log("Creating nginx instance with volume")
 	serverfile := s.createNginxInstanceWithVolume(ctx, namePrefix+"-serverfile")
 
-	err = serverfile.Storage().AddFile(resourcesHTML+"/index.html", nginxHTMLPath+"/index.html", "0:0")
-	s.Require().NoError(err)
+	s.T().Log("Adding file to nginx instance")
+	err = s.retryOperation(func() error {
+		return serverfile.Storage().AddFile(resourcesHTML+"/index.html", nginxHTMLPath+"/index.html", "0:0")
+	}, maxRetries)
+	s.Require().NoError(err, "Error adding file to nginx instance")
 
-	s.Require().NoError(serverfile.Build().Commit(ctx))
+	s.T().Log("Committing changes")
+	err = s.retryOperation(func() error {
+		return serverfile.Build().Commit(ctx)
+	}, maxRetries)
+	s.Require().NoError(err, "Error committing changes")
 
 	s.T().Cleanup(func() {
+		s.T().Log("Cleaning up instances")
 		err := instance.BatchDestroy(ctx, serverfile, executor)
 		if err != nil {
-			s.T().Logf("Error destroying instance: %v", err)
+			s.T().Logf("Error destroying instances: %v", err)
 		}
 	})
 
 	// Test logic
-
-	serverfileIP, err := serverfile.Network().GetIP(ctx)
-	s.Require().NoError(err)
-
-	s.Require().NoError(serverfile.Execution().Start(ctx))
-
-	wget, err := executor.Execution().ExecuteCommand(ctx, "wget", "-q", "-O", "-", serverfileIP)
-	s.Require().NoError(err)
-
+	s.T().Log("Getting server IP")
+	var serverfileIP string
+	err = s.retryOperation(func() error {
+		var err error
+		serverfileIP, err = serverfile.Network().GetIP(ctx)
+		return err
+	}, maxRetries)
+	s.Require().NoError(err, "Error getting server IP")
+
+	s.T().Log("Starting server")
+	err = s.retryOperation(func() error {
+		return serverfile.Execution().Start(ctx)
+	}, maxRetries)
+	s.Require().NoError(err, "Error starting server")
+
+	s.T().Log("Executing wget command")
+	var wget string
+	err = s.retryOperation(func() error {
+		var err error
+		wget, err = executor.Execution().ExecuteCommand(ctx, "wget", "-q", "-O", "-", serverfileIP)
+		return err
+	}, maxRetries)
+	s.Require().NoError(err, "Error executing wget command")
+
+	s.T().Log("Asserting wget output")
 	s.Assert().Contains(wget, "Hello World!")
 }
 
 func (s *Suite) TestDownloadFileFromRunningInstance() {
-	const namePrefix = "download-file-running"
+	const (
+		namePrefix = "download-file-running"
+	)
 	s.T().Parallel()
+
 	// Setup
 
 	target, err := s.Knuu.NewInstance(namePrefix + "-target")

e2e/system/file_test_image_cached_test.go

@@ -9,14 +9,19 @@ import (
 )
 
 func (s *Suite) TestFileCached() {
-	const namePrefix = "file-cached"
+	const (
+		namePrefix        = "file-cached"
+		numberOfInstances = 10
+		maxRetries        = 3
+	)
 	s.T().Parallel()
+
 	// Setup
 	ctx := context.Background()
+
 	executor, err := s.Executor.NewInstance(ctx, namePrefix+"-executor")
 	s.Require().NoError(err)
 
-	const numberOfInstances = 10
 	instances := make([]*instance.Instance, numberOfInstances)
 
 	instanceName := func(i int) string {
@@ -32,8 +37,10 @@ func (s *Suite) TestFileCached() {
 		wgFolders.Add(1)
 		go func(i int, instance *instance.Instance) {
 			defer wgFolders.Done()
+			err := s.retryOperation(func() error {
+				return instance.Storage().AddFile(resourcesHTML+"/index.html", nginxHTMLPath+"/index.html", "0:0")
+			}, maxRetries)
 			// adding the folder after the Commit, it will help us to use a cached image.
-			err = instance.Storage().AddFile(resourcesHTML+"/index.html", nginxHTMLPath+"/index.html", "0:0")
 			s.Require().NoError(err, "adding file to '%v'", instanceName(i))
 		}(i, ins)
 	}
@@ -49,19 +56,37 @@ func (s *Suite) TestFileCached() {
 
 	// Test logic
 	for _, i := range instances {
-		s.Require().NoError(i.Build().Commit(ctx))
-		s.Require().NoError(i.Execution().StartAsync(ctx))
+		err := s.retryOperation(func() error {
+			if err := i.Build().Commit(ctx); err != nil {
+				return fmt.Errorf("committing instance: %w", err)
+			}
+			if err := i.Execution().StartAsync(ctx); err != nil {
+				return fmt.Errorf("starting instance: %w", err)
+			}
+			return nil
+		}, maxRetries)
+		s.Require().NoError(err)
 	}
 
 	for _, i := range instances {
-		webIP, err := i.Network().GetIP(ctx)
-		s.Require().NoError(err)
+		err := s.retryOperation(func() error {
+			webIP, err := i.Network().GetIP(ctx)
+			if err != nil {
+				return fmt.Errorf("getting IP: %w", err)
+			}
 
-		s.Require().NoError(i.Execution().WaitInstanceIsRunning(ctx))
+			if err := i.Execution().WaitInstanceIsRunning(ctx); err != nil {
+				return fmt.Errorf("waiting for instance to run: %w", err)
+			}
 
-		wget, err := executor.Execution().ExecuteCommand(ctx, "wget", "-q", "-O", "-", webIP)
-		s.Require().NoError(err)
+			wget, err := executor.Execution().ExecuteCommand(ctx, "wget", "-q", "-O", "-", webIP)
+			if err != nil {
+				return fmt.Errorf("executing wget: %w", err)
+			}
 
-		s.Assert().Contains(wget, "Hello World!")
+			s.Assert().Contains(wget, "Hello World!")
+			return nil
+		}, maxRetries)
+		s.Require().NoError(err)
 	}
 }