chore: cleanup errchecking in tests

src/test/common.go

@@ -6,7 +6,9 @@ package test
 
 import (
 	"bufio"
+	"errors"
 	"fmt"
+	"log/slog"
 	"os"
 	"regexp"
 	"runtime"
@@ -53,13 +55,16 @@ func GetCLIName() string {
 }
 
 // Zarf executes a Zarf command.
-func (e2e *ZarfE2ETest) Zarf(t *testing.T, args ...string) (string, string, error) {
+func (e2e *ZarfE2ETest) Zarf(t *testing.T, args ...string) (_ string, _ string, err error) {
 	if !slices.Contains(args, "--tmpdir") && !slices.Contains(args, "tools") {
 		tmpdir, err := os.MkdirTemp("", "zarf-")
 		if err != nil {
 			return "", "", err
 		}
-		defer os.RemoveAll(tmpdir)
+		defer func(path string) {
+			errRemove := os.RemoveAll(path)
+			err = errors.Join(err, errRemove)
+		}(tmpdir)
 		args = append(args, "--tmpdir", tmpdir)
 	}
 	if !slices.Contains(args, "--zarf-cache") && !slices.Contains(args, "tools") && os.Getenv("CI") == "true" {
@@ -74,7 +79,10 @@ func (e2e *ZarfE2ETest) Zarf(t *testing.T, args ...string) (string, string, erro
 			return "", "", err
 		}
 		args = append(args, "--zarf-cache", cacheDir)
-		defer os.RemoveAll(cacheDir)
+		defer func(path string) {
+			errRemove := os.RemoveAll(path)
+			err = errors.Join(err, errRemove)
+		}(cacheDir)
 	}
 	return exec.CmdWithTesting(t, exec.PrintCfg(), e2e.ZarfBinPath, args...)
 }
@@ -89,7 +97,10 @@ func (e2e *ZarfE2ETest) Kubectl(t *testing.T, args ...string) (string, string, e
 // CleanFiles removes files and directories that have been created during the test.
 func (e2e *ZarfE2ETest) CleanFiles(files ...string) {
 	for _, file := range files {
-		_ = os.RemoveAll(file)
+		err := os.RemoveAll(file)
+		if err != nil {
+			slog.Debug("Unable to cleanup files", "files", files, "error", err)
+		}
 	}
 }
 

src/test/e2e/00_use_cli_test.go

@@ -110,7 +110,8 @@ func TestUseCLI(t *testing.T) {
 	t.Run("changing log level", func(t *testing.T) {
 		t.Parallel()
 		// Test that changing the log level actually applies the requested level
-		_, stdErr, _ := e2e.Zarf(t, "internal", "crc32", "zarf", "--log-level=debug")
+		_, stdErr, err := e2e.Zarf(t, "internal", "crc32", "zarf", "--log-level=debug")
+		require.NoError(t, err)
 		expectedOutString := "Log level set to debug"
 		require.Contains(t, stdErr, expectedOutString, "The log level should be changed to 'debug'")
 	})

src/test/e2e/12_lint_test.go

@@ -29,9 +29,11 @@ func TestLint(t *testing.T) {
 
 		testPackagePath := filepath.Join("src", "test", "packages", "12-lint")
 		configPath := filepath.Join(testPackagePath, "zarf-config.toml")
-		os.Setenv("ZARF_CONFIG", configPath)
+		osSetErr := os.Setenv("ZARF_CONFIG", configPath)
+		require.NoError(t, osSetErr, "Unable to set ZARF_CONFIG")
 		_, stderr, err := e2e.Zarf(t, "dev", "lint", testPackagePath, "-f", "good-flavor")
-		os.Unsetenv("ZARF_CONFIG")
+		osUnsetErr := os.Unsetenv("ZARF_CONFIG")
+		require.NoError(t, osUnsetErr, "Unable to cleanup ZARF_CONFIG")
 		require.Error(t, err, "Require an exit code since there was warnings / errors")
 		strippedStderr := e2e.StripMessageFormatting(stderr)
 

src/test/e2e/14_oci_compose_test.go

@@ -137,45 +137,54 @@ func (suite *PublishCopySkeletonSuite) Test_2_FilePaths() {
 	}
 
 	for _, pkgTar := range pkgTars {
-		var pkg v1alpha1.ZarfPackage
-
-		unpacked := strings.TrimSuffix(pkgTar, ".tar.zst")
-		defer os.RemoveAll(unpacked)
-		defer os.RemoveAll(pkgTar)
-		_, _, err := e2e.Zarf(suite.T(), "tools", "archiver", "decompress", pkgTar, unpacked, "--unarchive-all")
-		suite.NoError(err)
-		suite.DirExists(unpacked)
-
-		// Verify skeleton contains kustomize-generated manifests.
-		if strings.HasSuffix(pkgTar, "zarf-package-test-compose-package-skeleton-0.0.1.tar.zst") {
-			kustomizeGeneratedManifests := []string{
-				"kustomization-connect-service-0.yaml",
-				"kustomization-connect-service-1.yaml",
-				"kustomization-connect-service-two-0.yaml",
-			}
-			manifestDir := filepath.Join(unpacked, "components", "test-compose-package", "manifests")
-			for _, manifest := range kustomizeGeneratedManifests {
-				manifestPath := filepath.Join(manifestDir, manifest)
-				suite.FileExists(manifestPath, "expected to find kustomize-generated manifest: %q", manifestPath)
-				var configMap corev1.ConfigMap
-				err := utils.ReadYaml(manifestPath, &configMap)
-				suite.NoError(err)
-				suite.Equal("ConfigMap", configMap.Kind, "expected manifest %q to be of kind ConfigMap", manifestPath)
+		// Wrap in a fn to ensure our defers cleanup resources on each iteration
+		func() {
+			var pkg v1alpha1.ZarfPackage
+
+			unpacked := strings.TrimSuffix(pkgTar, ".tar.zst")
+			_, _, err := e2e.Zarf(suite.T(), "tools", "archiver", "decompress", pkgTar, unpacked, "--unarchive-all")
+			suite.NoError(err)
+			suite.DirExists(unpacked)
+
+			// Cleanup resources
+			defer func() {
+				suite.NoError(os.RemoveAll(unpacked))
+			}()
+			defer func() {
+				suite.NoError(os.RemoveAll(pkgTar))
+			}()
+
+			// Verify skeleton contains kustomize-generated manifests.
+			if strings.HasSuffix(pkgTar, "zarf-package-test-compose-package-skeleton-0.0.1.tar.zst") {
+				kustomizeGeneratedManifests := []string{
+					"kustomization-connect-service-0.yaml",
+					"kustomization-connect-service-1.yaml",
+					"kustomization-connect-service-two-0.yaml",
+				}
+				manifestDir := filepath.Join(unpacked, "components", "test-compose-package", "manifests")
+				for _, manifest := range kustomizeGeneratedManifests {
+					manifestPath := filepath.Join(manifestDir, manifest)
+					suite.FileExists(manifestPath, "expected to find kustomize-generated manifest: %q", manifestPath)
+					var configMap corev1.ConfigMap
+					err := utils.ReadYaml(manifestPath, &configMap)
+					suite.NoError(err)
+					suite.Equal("ConfigMap", configMap.Kind, "expected manifest %q to be of kind ConfigMap", manifestPath)
+				}
 			}
-		}
 
-		err = utils.ReadYaml(filepath.Join(unpacked, layout.ZarfYAML), &pkg)
-		suite.NoError(err)
-		suite.NotNil(pkg)
+			err = utils.ReadYaml(filepath.Join(unpacked, layout.ZarfYAML), &pkg)
+			suite.NoError(err)
+			suite.NotNil(pkg)
 
-		components := pkg.Components
-		suite.NotNil(components)
+			components := pkg.Components
+			suite.NotNil(components)
 
-		isSkeleton := false
-		if strings.Contains(pkgTar, "-skeleton-") {
-			isSkeleton = true
-		}
-		suite.verifyComponentPaths(unpacked, components, isSkeleton)
+			isSkeleton := false
+			if strings.Contains(pkgTar, "-skeleton-") {
+				isSkeleton = true
+			}
+			suite.verifyComponentPaths(unpacked, components, isSkeleton)
+		}()
 	}
 }
 

src/test/e2e/20_zarf_init_test.go

@@ -104,8 +104,8 @@ func TestZarfInit(t *testing.T) {
 	verifyZarfServiceLabels(t)
 
 	// Special sizing-hacking for reducing resources where Kind + CI eats a lot of free cycles (ignore errors)
-	_, _, _ = e2e.Kubectl(t, "scale", "deploy", "-n", "kube-system", "coredns", "--replicas=1")
-	_, _, _ = e2e.Kubectl(t, "scale", "deploy", "-n", "zarf", "agent-hook", "--replicas=1")
+	_, _, _ = e2e.Kubectl(t, "scale", "deploy", "-n", "kube-system", "coredns", "--replicas=1") // TODO(mkcp): intentionally ignored, mark nolint
+	_, _, _ = e2e.Kubectl(t, "scale", "deploy", "-n", "zarf", "agent-hook", "--replicas=1")     // TODO(mkcp): intentionally ignored, mark nolint
 }
 
 func checkLogForSensitiveState(t *testing.T, logText string, zarfState types.ZarfState) {

src/test/e2e/21_connect_creds_test.go

@@ -71,10 +71,12 @@ func TestMetrics(t *testing.T) {
 	client := &http.Client{Transport: tr}
 	httpsEndpoint := strings.ReplaceAll(tunnel.HTTPEndpoint(), "http", "https")
 	resp, err := client.Get(httpsEndpoint + "/metrics")
+	defer func() {
+		require.NoError(t, resp.Body.Close())
+	}()
 	if err != nil {
 		t.Fatal(err)
 	}
-	defer resp.Body.Close()
 
 	// Read the response body
 	body, err := io.ReadAll(resp.Body)

src/test/e2e/24_variables_test.go

@@ -43,8 +43,9 @@ func TestVariables(t *testing.T) {
 	require.Contains(t, stdErr, "", expectedOutString)
 
 	// Test that not specifying a prompted variable results in an error
-	_, stdErr, _ = e2e.Zarf(t, "package", "deploy", path, "--confirm")
+	_, stdErr, err = e2e.Zarf(t, "package", "deploy", path, "--confirm")
 	expectedOutString = "variable 'SITE_NAME' must be '--set' when using the '--confirm' flag"
+	require.Error(t, err)
 	require.Contains(t, stdErr, "", expectedOutString)
 
 	// Test that specifying an invalid variable value results in an error
@@ -73,7 +74,8 @@ func TestVariables(t *testing.T) {
 	require.Contains(t, string(outputTF), "unicorn-land")
 
 	// Verify the configmap was properly templated
-	kubectlOut, _, _ := e2e.Kubectl(t, "-n", "nginx", "get", "configmap", "nginx-configmap", "-o", "jsonpath='{.data.index\\.html}' ")
+	kubectlOut, _, err := e2e.Kubectl(t, "-n", "nginx", "get", "configmap", "nginx-configmap", "-o", "jsonpath='{.data.index\\.html}' ")
+	require.NoError(t, err, "unable to get nginx configmap")
 	// OPTIONAL_FOOTER should remain unset because it was not set during deploy
 	require.Contains(t, string(kubectlOut), "</pre>\n    \n  </body>")
 	// STYLE should take the default value

src/test/e2e/25_helm_test.go

@@ -99,7 +99,8 @@ func testHelmEscaping(t *testing.T) {
 	require.NoError(t, err, stdOut, stdErr)
 
 	// Verify the configmap was deployed, escaped, and contains all of its data
-	kubectlOut, _ := exec.Command("kubectl", "-n", "default", "describe", "cm", "dont-template-me").Output()
+	kubectlOut, err := exec.Command("kubectl", "-n", "default", "describe", "cm", "dont-template-me").Output()
+	require.NoError(t, err, "unable to describe configmap")
 	require.Contains(t, string(kubectlOut), `alert: OOMKilled {{ "{{ \"random.Values\" }}" }}`)
 	require.Contains(t, string(kubectlOut), "backtick1: \"content with backticks `some random things`\"")
 	require.Contains(t, string(kubectlOut), "backtick2: \"nested templating with backticks {{` random.Values `}}\"")
@@ -175,8 +176,9 @@ func testHelmAdoption(t *testing.T) {
 	deploymentManifest := "src/test/packages/25-manifest-adoption/deployment.yaml"
 
 	// Deploy dos-games manually into the cluster without Zarf
-	kubectlOut, _, _ := e2e.Kubectl(t, "apply", "-f", deploymentManifest)
-	require.Contains(t, string(kubectlOut), "deployment.apps/game created")
+	kubectlOut, _, err := e2e.Kubectl(t, "apply", "-f", deploymentManifest)
+	require.NoError(t, err, "unable to apply", "deploymentManifest", deploymentManifest)
+	require.Contains(t, kubectlOut, "deployment.apps/game created")
 
 	// Deploy dos-games into the cluster with Zarf
 	stdOut, stdErr, err := e2e.Zarf(t, "package", "deploy", packagePath, "--confirm", "--adopt-existing-resources")

src/test/e2e/28_wait_test.go

@@ -51,7 +51,7 @@ func TestNoWait(t *testing.T) {
 	case <-time.After(30 * time.Second):
 		t.Error("Timeout waiting for zarf deploy (it tried to wait)")
 		t.Log("Removing hanging namespace...")
-		_, _, _ = e2e.Kubectl(t, "delete", "namespace", "no-wait", "--force=true", "--wait=false", "--grace-period=0")
+		_, _, _ = e2e.Kubectl(t, "delete", "namespace", "no-wait", "--force=true", "--wait=false", "--grace-period=0") // TODO(mkcp): intentionally ignored, mark nolint
 	}
 	require.NoError(t, err, stdOut, stdErr)
 

src/test/e2e/29_config_file_test.go

@@ -20,20 +20,24 @@ func TestConfigFile(t *testing.T) {
 		path   = fmt.Sprintf("zarf-package-config-file-%s.tar.zst", e2e.Arch)
 		dir    = "examples/config-file"
 		config = "zarf-config.toml"
+		envKey = "ZARF_CONFIG"
 	)
 
 	e2e.CleanFiles(path)
 
 	// Test the config file environment variable
-	t.Setenv("ZARF_CONFIG", filepath.Join(dir, config))
-	defer os.Unsetenv("ZARF_CONFIG")
+	t.Setenv(envKey, filepath.Join(dir, config))
+	defer func() {
+		require.NoError(t, os.Unsetenv(envKey))
+	}()
 	configFileTests(t, dir, path)
 
 	configFileDefaultTests(t)
 
 	stdOut, stdErr, err := e2e.Zarf(t, "package", "remove", path, "--confirm")
 	require.NoError(t, err, stdOut, stdErr)
 
+	// Cleanup
 	e2e.CleanFiles(path)
 }
 
@@ -139,30 +143,37 @@ func configFileDefaultTests(t *testing.T) {
 	}
 
 	// Test remaining default initializers
-	t.Setenv("ZARF_CONFIG", filepath.Join("src", "test", "zarf-config-test.toml"))
-	defer os.Unsetenv("ZARF_CONFIG")
+	envKey := "ZARF_CONFIG"
+	t.Setenv(envKey, filepath.Join("src", "test", "zarf-config-test.toml"))
+	defer func() {
+		require.NoError(t, os.Unsetenv(envKey))
+	}()
 
 	// Test global flags
-	stdOut, _, _ := e2e.Zarf(t, "--help")
+	stdOut, _, err := e2e.Zarf(t, "--help")
+	require.NoError(t, err)
 	for _, test := range globalFlags {
-		require.Contains(t, string(stdOut), test)
+		require.Contains(t, stdOut, test)
 	}
 
 	// Test init flags
-	stdOut, _, _ = e2e.Zarf(t, "init", "--help")
+	stdOut, _, err = e2e.Zarf(t, "init", "--help")
+	require.NoError(t, err)
 	for _, test := range initFlags {
-		require.Contains(t, string(stdOut), test)
+		require.Contains(t, stdOut, test)
 	}
 
 	// Test package create flags
-	stdOut, _, _ = e2e.Zarf(t, "package", "create", "--help")
+	stdOut, _, err = e2e.Zarf(t, "package", "create", "--help")
+	require.NoError(t, err)
 	for _, test := range packageCreateFlags {
-		require.Contains(t, string(stdOut), test)
+		require.Contains(t, stdOut, test)
 	}
 
 	// Test package deploy flags
-	stdOut, _, _ = e2e.Zarf(t, "package", "deploy", "--help")
+	stdOut, _, err = e2e.Zarf(t, "package", "deploy", "--help")
+	require.NoError(t, err)
 	for _, test := range packageDeployFlags {
-		require.Contains(t, string(stdOut), test)
+		require.Contains(t, stdOut, test)
 	}
 }

src/test/external/common.go

@@ -28,7 +28,8 @@ func createPodInfoPackageWithInsecureSources(t *testing.T, temp string) {
 	require.NoError(t, err, "unable to yq edit helm source")
 	err = exec.CmdWithPrint(zarfBinPath, "tools", "yq", "eval", ".spec.insecure = true", "-i", filepath.Join(temp, "oci", "podinfo-source.yaml"))
 	require.NoError(t, err, "unable to yq edit oci source")
-	exec.CmdWithPrint(zarfBinPath, "package", "create", temp, "--confirm", "--output", temp)
+	err = exec.CmdWithPrint(zarfBinPath, "package", "create", temp, "--confirm", "--output", temp)
+	require.NoError(t, err, "unable to create package")
 }
 
 func verifyWaitSuccess(t *testing.T, timeoutMinutes time.Duration, cmd string, args []string, condition string, onTimeout string) bool {

src/test/external/ext_in_cluster_test.go

@@ -154,10 +154,14 @@ func (suite *ExtInClusterTestSuite) Test_1_Deploy() {
 	// Use Zarf to initialize the cluster
 	initArgs := []string{"init", "--confirm"}
 	initArgs = append(initArgs, inClusterInitCredentialArgs...)
+
 	err := exec.CmdWithPrint(zarfBinPath, initArgs...)
 	suite.NoError(err, "unable to initialize the k8s server with zarf")
+
 	temp := suite.T().TempDir()
-	defer os.Remove(temp)
+	defer func() {
+		suite.NoError(os.RemoveAll(temp), "failed to clean up tempdir")
+	}()
 	createPodInfoPackageWithInsecureSources(suite.T(), temp)
 
 	// Deploy the flux example package