func AddK8STestsToImage()

in pkg/testing/kubernetes/image.go [50:167]
95 lines of code
17 McCabe index (conditional complexity)

func AddK8STestsToImage(ctx context.Context, logger common.Logger, baseImage string, arch string) (string, error) {
	// compile k8s test with tag kubernetes_inner
	buildBase, err := filepath.Abs("build")
	if err != nil {
		return "", err
	}

	testBinary := filepath.Join(buildBase, "k8s-inner-tests")

	params := devtools.GoTestArgs{
		LogName:    "k8s-inner-tests",
		Race:       false,
		Packages:   []string{"./testing/kubernetes_inner/..."},
		Tags:       []string{"kubernetes_inner"},
		OutputFile: testBinary,
		Env: map[string]string{
			"GOOS":        "linux",
			"GOARCH":      arch,
			"CGO_ENABLED": "0",
		},
	}

	if err := devtools.GoTestBuild(ctx, params); err != nil {
		return "", err
	}

	cli, err := getDockerClient()
	if err != nil {
		return "", err
	}

	// dockerfile to just copy the tests binary
	dockerfile := fmt.Sprintf(`
	FROM %s
	COPY testsBinary /usr/share/elastic-agent/k8s-inner-tests
	`, baseImage)

	// Create a tar archive with the Dockerfile and the binary
	var buf bytes.Buffer
	tw := tar.NewWriter(&buf)

	// Add Dockerfile to tar
	err = tw.WriteHeader(&tar.Header{
		Name: "Dockerfile",
		Size: int64(len(dockerfile)),
	})
	if err != nil {
		return "", err
	}
	_, err = tw.Write([]byte(dockerfile))
	if err != nil {
		return "", err
	}

	// Add binary to tar
	binaryFile, err := os.Open(testBinary)
	if err != nil {
		return "", err
	}
	defer binaryFile.Close()

	info, err := binaryFile.Stat()
	if err != nil {
		return "", err
	}

	err = tw.WriteHeader(&tar.Header{
		Name: "testsBinary",
		Mode: 0777,
		Size: info.Size(),
	})
	if err != nil {
		return "", err
	}
	_, err = io.Copy(tw, binaryFile)
	if err != nil {
		return "", err
	}

	err = tw.Close()
	if err != nil {
		return "", err
	}

	outputImage := baseImage + "-tests"

	// Build the image
	imageBuildResponse, err := cli.ImageBuild(ctx, &buf, types.ImageBuildOptions{
		Tags:       []string{outputImage},
		Dockerfile: "Dockerfile",
		Remove:     true,
	})
	if err != nil {
		return "", err
	}
	defer imageBuildResponse.Body.Close()

	scanner := bufio.NewScanner(imageBuildResponse.Body)
	for scanner.Scan() {
		line := scanner.Text()
		var output DockerBuildOutput
		if err := json.Unmarshal([]byte(line), &output); err != nil {
			return "", fmt.Errorf("error at parsing JSON: %w", err)
		}

		if output.Stream != "" {
			if out := strings.TrimRight(output.Stream, "\n"); out != "" {
				logger.Logf(out)
			}
		}
	}

	if err := scanner.Err(); err != nil {
		return "", err
	}

	return outputImage, nil
}