Debugging the integration testing.

It seems to be consistently failing (also fix a typo in the file/leg name).

I'm disabling `-v` for `go test` because it interleaves the test output in ways that make it painful to read a single failing test's output when `t.Parallel` is involved.

.github/workflows/integration_k8_tests.yaml

@@ -1,6 +1,6 @@
-name: Intergration tests (K8s)
+name: Integration tests (K8s)
 
-# Triggers the workflow on push or pull request events
+# Triggers the workflow on pull request events
 on: [pull_request]
 
 concurrency:

integration/benchmark_test.go

@@ -59,7 +59,7 @@ func TestSnapshotBenchmark(t *testing.T) {
 				kanikoImage := fmt.Sprintf("%s_%d", GetKanikoImage(config.imageRepo, dockerfile), num)
 				buildArgs := []string{"--build-arg", fmt.Sprintf("NUM=%d", num)}
 				var benchmarkDir string
-				benchmarkDir, *err = buildKanikoImage("", dockerfile,
+				benchmarkDir, *err = buildKanikoImage(t.Logf, "", dockerfile,
 					buildArgs, []string{}, kanikoImage, contextDir, config.gcsBucket,
 					config.serviceAccount, false)
 				if *err != nil {

integration/images.go

@@ -177,16 +177,22 @@ func FindDockerFiles(dockerfilesPath string) ([]string, error) {
 // DockerFileBuilder knows how to build docker files using both Kaniko and Docker and
 // keeps track of which files have been built.
 type DockerFileBuilder struct {
+	logf Logger
 	// Holds all available docker files and whether or not they've been built
 	filesBuilt           map[string]struct{}
 	DockerfilesToIgnore  map[string]struct{}
 	TestCacheDockerfiles map[string]struct{}
 }
 
+type Logger func(string, ...interface{})
+
 // NewDockerFileBuilder will create a DockerFileBuilder initialized with dockerfiles, which
 // it will assume are all as yet unbuilt.
-func NewDockerFileBuilder() *DockerFileBuilder {
-	d := DockerFileBuilder{filesBuilt: map[string]struct{}{}}
+func NewDockerFileBuilder(logf Logger) *DockerFileBuilder {
+	d := DockerFileBuilder{
+		logf:       logf,
+		filesBuilt: map[string]struct{}{},
+	}
 	d.DockerfilesToIgnore = map[string]struct{}{
 		"Dockerfile_test_add_404": {},
 		// TODO: remove test_user_run from this when https://github.com/GoogleContainerTools/container-diff/issues/237 is fixed
@@ -219,7 +225,7 @@ func addServiceAccountFlags(flags []string, serviceAccount string) []string {
 }
 
 func (d *DockerFileBuilder) BuildDockerImage(imageRepo, dockerfilesPath, dockerfile, contextDir string) error {
-	fmt.Printf("Building image for Dockerfile %s\n", dockerfile)
+	d.logf("Building image for Dockerfile %s\n", dockerfile)
 
 	var buildArgs []string
 	buildArgFlag := "--build-arg"
@@ -252,7 +258,7 @@ func (d *DockerFileBuilder) BuildDockerImage(imageRepo, dockerfilesPath, dockerf
 	if err != nil {
 		return fmt.Errorf("Failed to build image %s with docker command \"%s\": %s %s", dockerImage, dockerCmd.Args, err, string(out))
 	}
-	fmt.Printf("Build image for Dockerfile %s as %s. docker build output: %s \n", dockerfile, dockerImage, out)
+	d.logf("Build image for Dockerfile %s as %s. docker build output: %s \n", dockerfile, dockerImage, out)
 	return nil
 }
 
@@ -302,7 +308,7 @@ func (d *DockerFileBuilder) BuildImageWithContext(config *integrationTestConfig,
 
 	kanikoImage := GetKanikoImage(imageRepo, dockerfile)
 	timer = timing.Start(dockerfile + "_kaniko")
-	if _, err := buildKanikoImage(dockerfilesPath, dockerfile, buildArgs, additionalKanikoFlags, kanikoImage,
+	if _, err := buildKanikoImage(d.logf, dockerfilesPath, dockerfile, buildArgs, additionalKanikoFlags, kanikoImage,
 		contextDir, gcsBucket, serviceAccount, true); err != nil {
 		return err
 	}
@@ -420,6 +426,7 @@ func (d *DockerFileBuilder) buildRelativePathsImage(imageRepo, dockerfile, servi
 }
 
 func buildKanikoImage(
+	logf Logger,
 	dockerfilesPath string,
 	dockerfile string,
 	buildArgs []string,
@@ -447,7 +454,7 @@ func buildKanikoImage(
 
 	// build kaniko image
 	additionalFlags := append(buildArgs, kanikoArgs...)
-	fmt.Printf("Going to build image with kaniko: %s, flags: %s \n", kanikoImage, additionalFlags)
+	logf("Going to build image with kaniko: %s, flags: %s \n", kanikoImage, additionalFlags)
 
 	dockerRunFlags := []string{"run", "--net=host",
 		"-e", benchmarkEnv,

integration/integration_test.go

@@ -87,8 +87,8 @@ func getDockerMajorVersion() int {
 	}
 	return ver
 }
-func launchTests(m *testing.M) (int, error) {
 
+func launchTests(m *testing.M) (int, error) {
 	if config.isGcrRepository() {
 		contextFile, err := CreateIntegrationTarball()
 		if err != nil {
@@ -111,7 +111,7 @@ func launchTests(m *testing.M) (int, error) {
 		return 1, errors.Wrap(err, "Error while building images")
 	}
 
-	imageBuilder = NewDockerFileBuilder()
+	imageBuilder = NewDockerFileBuilder(log.Printf)
 
 	return m.Run(), nil
 }

integration/integration_with_context_test.go

@@ -37,7 +37,7 @@ func TestWithContext(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	builder := NewDockerFileBuilder()
+	builder := NewDockerFileBuilder(t.Logf)
 
 	for _, tdInfo := range testDirs {
 		name := tdInfo.Name()

integration/k8s_test.go

@@ -46,7 +46,7 @@ func TestK8s(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	builder := NewDockerFileBuilder()
+	builder := NewDockerFileBuilder(t.Logf)
 
 	for _, tdInfo := range testDirs {
 		name := tdInfo.Name()
@@ -75,21 +75,21 @@ func TestK8s(t *testing.T) {
 				t.Fatal(err)
 			}
 
-			fmt.Printf("Testing K8s based Kaniko building of dockerfile %s and push to %s \n",
+			t.Logf("Testing K8s based Kaniko building of dockerfile %s and push to %s \n",
 				testDir, kanikoImage)
 			content, err := ioutil.ReadFile(tmpfile.Name())
 			if err != nil {
 				log.Fatal(err)
 			}
-			fmt.Printf("K8s template %s:\n%s\n", tmpfile.Name(), content)
+			t.Logf("K8s template %s:\n%s\n", tmpfile.Name(), content)
 
 			kubeCmd := exec.Command("kubectl", "apply", "-f", tmpfile.Name())
 			RunCommand(kubeCmd, t)
 
-			fmt.Printf("Waiting for K8s kaniko build job to finish: %s\n",
+			t.Logf("Waiting for K8s kaniko build job to finish: %s\n",
 				"job/kaniko-test-"+job.Name)
 
-			kubeWaitCmd := exec.Command("kubectl", "wait", "--for=condition=complete", "--timeout=120s",
+			kubeWaitCmd := exec.Command("kubectl", "wait", "--for=condition=complete", "--timeout=5m",
 				"job/kaniko-test-"+job.Name)
 			if out, errR := RunCommandWithoutTest(kubeWaitCmd); errR != nil {
 				t.Log(kubeWaitCmd.Args)

scripts/integration-test.sh

@@ -24,4 +24,4 @@ docker version
 echo "Running integration tests..."
 make out/executor
 make out/warmer
-go test ./integration/... -v --bucket "${GCS_BUCKET}" --repo "${IMAGE_REPO}" --timeout 50m "$@"
+go test ./integration/... --bucket "${GCS_BUCKET}" --repo "${IMAGE_REPO}" --timeout 50m "$@"