Merge pull request #31579 from redhat-chai-bot/ocpbugs-115153-extension-architectures

OCPBUGS-115153: Make extension test-binary extraction architecture-aware

Author: openshift-merge-bot[bot]

pkg/test/extensions/binary.go

@@ -11,6 +11,7 @@ import (
 	"path"
 	"path/filepath"
 	"regexp"
+	"runtime"
 	"strings"
 	"sync"
 	"syscall"
@@ -166,6 +167,8 @@ type TestBinary struct {
 	imageTag string
 	// The binary path to extract from the image
 	binaryPath string
+	// The architectures where the binary is available. An empty list means all architectures.
+	architectures []string
 
 	// Cache the info after gathering it
 	info *Extension
@@ -342,8 +345,9 @@ var extensionBinaries = []TestBinary{
 		binaryPath: "/usr/bin/service-ca-operator-tests-ext.gz",
 	},
 	{
-		imageTag:   "vsphere-csi-driver-operator",
-		binaryPath: "/usr/bin/vmware-vsphere-csi-driver-operator-tests-ext.gz",
+		imageTag:      "vsphere-csi-driver-operator",
+		binaryPath:    "/usr/bin/vmware-vsphere-csi-driver-operator-tests-ext.gz",
+		architectures: []string{"amd64"},
 	},
 }
 
@@ -640,6 +644,7 @@ func ExtractAllTestBinaries(ctx context.Context, parallelism int) (func(), TestB
 
 	// Filter extension binaries based on environment variables
 	filteredBinaries := filterExtensionBinariesByTags(extensionBinaries)
+	filteredBinaries = filterExtensionBinariesByArchitecture(filteredBinaries, extensionBinaryArchitecture(runtime.GOARCH))
 
 	releaseImage, err := DetermineReleasePayloadImage()
 	if err != nil {
@@ -1064,6 +1069,36 @@ func filterExtensionBinariesByTags(binaries []TestBinary) []TestBinary {
 	return filtered
 }
 
+// filterExtensionBinariesByArchitecture returns binaries available on architecture. Binaries
+// without an architecture allowlist are available on all architectures.
+func filterExtensionBinariesByArchitecture(binaries []TestBinary, architecture string) []TestBinary {
+	filtered := make([]TestBinary, 0, len(binaries))
+	for _, binary := range binaries {
+		if len(binary.architectures) == 0 {
+			filtered = append(filtered, binary)
+			continue
+		}
+		for _, supportedArchitecture := range binary.architectures {
+			if architecture == supportedArchitecture {
+				filtered = append(filtered, binary)
+				break
+			}
+		}
+	}
+	return filtered
+}
+
+// extensionBinaryArchitecture returns the target architecture used to select payload extension
+// binaries. Multi-architecture CI may run a cross-compiled openshift-tests binary, so OCP_ARCH
+// takes precedence over the executable's architecture when it is available. Native and legacy
+// invocations fall back to the supplied runtime architecture.
+func extensionBinaryArchitecture(runtimeArchitecture string) string {
+	if architecture := os.Getenv("OCP_ARCH"); len(architecture) > 0 {
+		return architecture
+	}
+	return runtimeArchitecture
+}
+
 // filterToApplicableEnvironmentFlags filters the provided envFlags to only those that are applicable to the
 // APIVersion of OTE within the external binary.
 func (b *TestBinary) filterToApplicableEnvironmentFlags(envFlags EnvironmentFlags) EnvironmentFlags {

pkg/test/extensions/binary_filter_test.go

@@ -2,6 +2,7 @@ package extensions
 
 import (
 	"os"
+	"runtime"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -97,18 +98,8 @@ func TestFilterExtensionBinariesByTags(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			// Set environment variables
-			if tt.excludeTags != "" {
-				os.Setenv("EXTENSION_BINARY_OVERRIDE_EXCLUDE_TAGS", tt.excludeTags)
-			} else {
-				os.Unsetenv("EXTENSION_BINARY_OVERRIDE_EXCLUDE_TAGS")
-			}
-
-			if tt.includeTags != "" {
-				os.Setenv("EXTENSION_BINARY_OVERRIDE_INCLUDE_TAGS", tt.includeTags)
-			} else {
-				os.Unsetenv("EXTENSION_BINARY_OVERRIDE_INCLUDE_TAGS")
-			}
+			t.Setenv("EXTENSION_BINARY_OVERRIDE_EXCLUDE_TAGS", tt.excludeTags)
+			t.Setenv("EXTENSION_BINARY_OVERRIDE_INCLUDE_TAGS", tt.includeTags)
 
 			// Call the function
 			result := filterExtensionBinariesByTags(testBinaries)
@@ -123,10 +114,123 @@ func TestFilterExtensionBinariesByTags(t *testing.T) {
 			}
 
 			assert.ElementsMatch(t, tt.expectedImageTags, actualImageTags, "Expected image tags %v, got %v", tt.expectedImageTags, actualImageTags)
+		})
+	}
+}
+
+func TestExtensionBinaryArchitecture(t *testing.T) {
+	tests := []struct {
+		name                string
+		setOCPArchitecture  bool
+		ocpArchitecture     string
+		runtimeArchitecture string
+		wantArchitecture    string
+	}{
+		{
+			name:                "arm64 target overrides amd64 runtime",
+			setOCPArchitecture:  true,
+			ocpArchitecture:     "arm64",
+			runtimeArchitecture: "amd64",
+			wantArchitecture:    "arm64",
+		},
+		{
+			name:                "amd64 target is honored",
+			setOCPArchitecture:  true,
+			ocpArchitecture:     "amd64",
+			runtimeArchitecture: "arm64",
+			wantArchitecture:    "amd64",
+		},
+		{
+			name:                "unset target uses runtime architecture",
+			runtimeArchitecture: runtime.GOARCH,
+			wantArchitecture:    runtime.GOARCH,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Setenv("OCP_ARCH", tt.ocpArchitecture)
+			if !tt.setOCPArchitecture {
+				assert.NoError(t, os.Unsetenv("OCP_ARCH"))
+			}
+
+			assert.Equal(t, tt.wantArchitecture, extensionBinaryArchitecture(tt.runtimeArchitecture))
+		})
+	}
+}
+
+func TestFilterExtensionBinariesByArchitecture(t *testing.T) {
+	tests := []struct {
+		name          string
+		architectures []string
+		architecture  string
+		wantIncluded  bool
+	}{
+		{
+			name:         "empty allowlist is available on all architectures",
+			architecture: "arm64",
+			wantIncluded: true,
+		},
+		{
+			name:          "matching architecture is included",
+			architectures: []string{"amd64", "arm64"},
+			architecture:  "arm64",
+			wantIncluded:  true,
+		},
+		{
+			name:          "non-matching architecture is omitted",
+			architectures: []string{"amd64"},
+			architecture:  "arm64",
+			wantIncluded:  false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			binary := TestBinary{
+				imageTag:      "test-extension",
+				binaryPath:    "/usr/bin/test-extension",
+				architectures: tt.architectures,
+			}
+
+			filtered := filterExtensionBinariesByArchitecture([]TestBinary{binary}, tt.architecture)
+
+			assert.Equal(t, tt.wantIncluded, len(filtered) == 1)
+		})
+	}
+}
+
+func TestVSphereExtensionBinaryArchitectures(t *testing.T) {
+	tests := []struct {
+		name         string
+		architecture string
+		wantIncluded bool
+	}{
+		{
+			name:         "included on amd64",
+			architecture: "amd64",
+			wantIncluded: true,
+		},
+		{
+			name:         "omitted on arm64",
+			architecture: "arm64",
+			wantIncluded: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			filtered := filterExtensionBinariesByArchitecture(extensionBinaries, tt.architecture)
+			included := false
+			for _, binary := range filtered {
+				if binary.imageTag == "vsphere-csi-driver-operator" {
+					included = true
+					assert.Equal(t, []string{"amd64"}, binary.architectures)
+					break
+				}
+			}
 
-			// Clean up environment variables
-			os.Unsetenv("EXTENSION_BINARY_OVERRIDE_EXCLUDE_TAGS")
-			os.Unsetenv("EXTENSION_BINARY_OVERRIDE_INCLUDE_TAGS")
+			assert.Equal(t, tt.wantIncluded, included)
 		})
 	}
 }