test: add tests for TargetCustomizationMode and AllMatches

- bundlereader: verify targetCustomizationMode is propagated from
  fleet.yaml into bundle.Spec.TargetCustomizationMode
- matcher: direct unit tests for hasMatchingRestriction edge cases
- integration: AllMatches end-to-end test verifying that all matching
  customizations are merged into the final BundleDeployment options

Author: p-se

integrationtests/controller/bundle/bundle_targets_test.go

@@ -588,6 +588,73 @@ var _ = Describe("Bundle targets", Ordered, func() {
 			}
 		})
 	})
+
+	// AllMatches mode: every matching targetCustomization is applied in order,
+	// so a cluster that matches two customizations receives the merged options
+	// from both, whereas FirstMatch would stop at the first.
+	When("TargetCustomizationMode is AllMatches and two customizations match cluster one", func() {
+		BeforeEach(func() {
+			bundleName = "all-matches-mode"
+			bdLabels = map[string]string{
+				"fleet.cattle.io/bundle-name":      bundleName,
+				"fleet.cattle.io/bundle-namespace": namespace,
+			}
+			expectedNumberOfBundleDeployments = 3
+
+			// Customization 1: only cluster group "one" → sets region
+			// Customization 2: all clusters → sets env
+			// GitRepo target: all clusters (no extra values)
+			targetsInGitRepo := []v1alpha1.BundleTarget{
+				{ClusterGroup: "all"},
+			}
+			targets = []v1alpha1.BundleTarget{
+				{
+					BundleDeploymentOptions: v1alpha1.BundleDeploymentOptions{
+						Helm: &v1alpha1.HelmOptions{
+							Values: &v1alpha1.GenericMap{Data: map[string]interface{}{"region": "us-west"}},
+						},
+					},
+					ClusterGroup: "one",
+				},
+				{
+					BundleDeploymentOptions: v1alpha1.BundleDeploymentOptions{
+						Helm: &v1alpha1.HelmOptions{
+							Values: &v1alpha1.GenericMap{Data: map[string]interface{}{"env": "prod"}},
+						},
+					},
+					ClusterGroup: "all",
+				},
+			}
+			targetRestrictions = make([]v1alpha1.BundleTarget, len(targetsInGitRepo))
+			copy(targetRestrictions, targetsInGitRepo)
+			targets = append(targets, targetsInGitRepo...)
+		})
+
+		JustBeforeEach(func() {
+			// The outer JustBeforeEach already created the bundle with FirstMatch
+			// (the default). Patch it to AllMatches so the reconciler re-evaluates.
+			mod := bundle.DeepCopy()
+			mod.Spec.TargetCustomizationMode = v1alpha1.TargetCustomizationModeAllMatches
+			Expect(k8sClient.Patch(ctx, mod, client.MergeFrom(bundle))).ToNot(HaveOccurred())
+			bundle = mod
+		})
+
+		It("merges all matching customizations into cluster one's BundleDeployment", func() {
+			bdList := verifyBundlesDeploymentsAreCreated(expectedNumberOfBundleDeployments, bdLabels, bundleName)
+			for _, bd := range bdList.Items {
+				values, _ := loadValues(bd)
+				if strings.Contains(bd.Namespace, "cluster-one") {
+					// cluster "one" matches both customizations: both keys must be present
+					Expect(values).To(HaveKeyWithValue("region", "us-west"), "cluster-one should have region from cust1")
+					Expect(values).To(HaveKeyWithValue("env", "prod"), "cluster-one should have env from cust2")
+				} else {
+					// other clusters match only cust2
+					Expect(values).ToNot(HaveKey("region"), "non-one clusters should not have region")
+					Expect(values).To(HaveKeyWithValue("env", "prod"), "non-one clusters should have env from cust2")
+				}
+			}
+		})
+	})
 })
 
 func verifyBundlesDeploymentsAreCreated(numBundleDeployments int, bdLabels map[string]string, bundleName string) *v1alpha1.BundleDeploymentList {

internal/bundlereader/read_test.go

@@ -0,0 +1,48 @@
+package bundlereader
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	fleet "github.com/rancher/fleet/pkg/apis/fleet.cattle.io/v1alpha1"
+)
+
+// TestBundleFromDir_TargetCustomizationModePropagate verifies that the
+// targetCustomizationMode field from fleet.yaml is copied into
+// bundle.Spec.TargetCustomizationMode by bundleFromDir.
+func TestBundleFromDir_TargetCustomizationModePropagate(t *testing.T) {
+	dir := t.TempDir()
+
+	tests := []struct {
+		name     string
+		yaml     string
+		wantMode fleet.TargetCustomizationMode
+	}{
+		{
+			name:     "AllMatches is propagated to BundleSpec",
+			yaml:     `targetCustomizationMode: AllMatches`,
+			wantMode: fleet.TargetCustomizationModeAllMatches,
+		},
+		{
+			name:     "FirstMatch is propagated to BundleSpec",
+			yaml:     `targetCustomizationMode: FirstMatch`,
+			wantMode: fleet.TargetCustomizationModeFirstMatch,
+		},
+		{
+			name:     "omitted mode propagates as empty string (controller uses default)",
+			yaml:     `namespace: test`,
+			wantMode: "",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			bundle, _, err := bundleFromDir(context.Background(), "test", dir, []byte(tt.yaml), nil)
+			require.NoError(t, err)
+			assert.Equal(t, tt.wantMode, bundle.Spec.TargetCustomizationMode)
+		})
+	}
+}

internal/cmd/controller/target/matcher/bundlematch_test.go

@@ -10,6 +10,75 @@ import (
 	fleet "github.com/rancher/fleet/pkg/apis/fleet.cattle.io/v1alpha1"
 )
 
+// TestHasMatchingRestriction verifies that the helper correctly distinguishes
+// GitRepo targets (which have a matching restriction) from fleet.yaml
+// targetCustomizations (which do not).
+func TestHasMatchingRestriction(t *testing.T) {
+	sel := func(m map[string]string) *metav1.LabelSelector {
+		return &metav1.LabelSelector{MatchLabels: m}
+	}
+
+	tests := []struct {
+		name         string
+		target       fleet.BundleTarget
+		restrictions []fleet.BundleTargetRestriction
+		want         bool
+	}{
+		{
+			name:         "exact name match",
+			target:       fleet.BundleTarget{Name: "foo"},
+			restrictions: []fleet.BundleTargetRestriction{{Name: "foo"}},
+			want:         true,
+		},
+		{
+			name:   "name matches but ClusterSelector differs — not a restriction match",
+			target: fleet.BundleTarget{Name: "foo", ClusterSelector: sel(map[string]string{"a": "1"})},
+			restrictions: []fleet.BundleTargetRestriction{
+				{Name: "foo", ClusterSelector: sel(map[string]string{"a": "2"})},
+			},
+			want: false,
+		},
+		{
+			name:         "empty restriction list — always a customization",
+			target:       fleet.BundleTarget{Name: "foo"},
+			restrictions: nil,
+			want:         false,
+		},
+		{
+			name:   "name matches but ClusterGroup differs",
+			target: fleet.BundleTarget{Name: "foo", ClusterGroup: "one"},
+			restrictions: []fleet.BundleTargetRestriction{
+				{Name: "foo", ClusterGroup: "two"},
+			},
+			want: false,
+		},
+		{
+			name:   "ClusterName match without name field",
+			target: fleet.BundleTarget{ClusterName: "local"},
+			restrictions: []fleet.BundleTargetRestriction{
+				{ClusterName: "local"},
+			},
+			want: true,
+		},
+		{
+			name:   "second restriction matches",
+			target: fleet.BundleTarget{Name: "bar"},
+			restrictions: []fleet.BundleTargetRestriction{
+				{Name: "foo"},
+				{Name: "bar"},
+			},
+			want: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := hasMatchingRestriction(tt.target, tt.restrictions)
+			assert.Equal(t, tt.want, got)
+		})
+	}
+}
+
 // makeBundle builds a minimal Bundle reflecting the order produced by bundlereader:
 // targetCustomizations come first in Targets, followed by the GitRepo target.
 // The GitRepo target is also added as a TargetRestriction.