update tests

Signed-off-by: Kexin2000 <3299133282@qq.com>

Author: Kexin2000

pkg/dependenciesdistributor/dependencies_distributor_test.go

@@ -3436,16 +3436,26 @@ func Test_deleteBindingFromSnapshot(t *testing.T) {
 	}
 }
 
-func TestCreateOrUpdateAttachedBinding_EmitsDependencyEvents(t *testing.T) {
-	testScheme := runtime.NewScheme()
-	utilruntime.Must(workv1alpha2.AddToScheme(testScheme))
+type dependencyPolicyTestEnv struct {
+	distributor *DependenciesDistributor
+	client      client.Client
+	recorder    *record.FakeRecorder
+	existing    *workv1alpha2.ResourceBinding
+	dependent   *unstructured.Unstructured
+}
+
+func newDependencyPolicyTestEnv(t *testing.T) *dependencyPolicyTestEnv {
+	t.Helper()
+
+	scheme := runtime.NewScheme()
+	utilruntime.Must(workv1alpha2.Install(scheme))
 
-	dependentObj := &unstructured.Unstructured{}
-	dependentObj.SetAPIVersion("v1")
-	dependentObj.SetKind("ConfigMap")
-	dependentObj.SetNamespace("default")
-	dependentObj.SetName("app-config")
-	dependentObj.SetUID(types.UID("cm-uid"))
+	dependent := &unstructured.Unstructured{}
+	dependent.SetAPIVersion("v1")
+	dependent.SetKind("ConfigMap")
+	dependent.SetNamespace("default")
+	dependent.SetName("app-config")
+	dependent.SetUID(types.UID("cm-uid"))
 
 	parentOne := &workv1alpha2.ResourceBinding{
 		ObjectMeta: metav1.ObjectMeta{
@@ -3461,17 +3471,68 @@ func TestCreateOrUpdateAttachedBinding_EmitsDependencyEvents(t *testing.T) {
 			PreserveResourcesOnDeletion: ptr.To(true),
 		},
 	}
-	attachedFromParentOne := buildAttachedBinding(parentOne, dependentObj)
-	// Simulate existing dependency binding already persisted in the cluster.
+
+	attachedFromParentOne := buildAttachedBinding(parentOne, dependent)
 	existing := attachedFromParentOne.DeepCopy()
 
-	fakeClient := fake.NewClientBuilder().WithScheme(testScheme).WithObjects(existing).Build()
+	fakeClient := fake.NewClientBuilder().WithScheme(scheme).WithObjects(existing).Build()
 	recorder := record.NewFakeRecorder(10)
-	d := &DependenciesDistributor{
+
+	distributor := &DependenciesDistributor{
 		Client:        fakeClient,
 		EventRecorder: recorder,
 	}
 
+	return &dependencyPolicyTestEnv{
+		distributor: distributor,
+		client:      fakeClient,
+		recorder:    recorder,
+		existing:    existing,
+		dependent:   dependent,
+	}
+}
+
+func waitForEvents(t *testing.T, recorder *record.FakeRecorder, want int, timeout time.Duration) []string {
+	t.Helper()
+
+	eventList := make([]string, 0, want)
+	timeoutCh := time.After(timeout)
+	for len(eventList) < want {
+		select {
+		case evt := <-recorder.Events:
+			eventList = append(eventList, evt)
+		case <-timeoutCh:
+			t.Fatalf("timed out waiting for %d events, got %v", want, eventList)
+		}
+	}
+	return eventList
+}
+
+func findEventByReason(t *testing.T, eventList []string, reason string) string {
+	t.Helper()
+
+	for _, evt := range eventList {
+		if strings.Contains(evt, reason) {
+			return evt
+		}
+	}
+	t.Fatalf("expected event reason %s in %v", reason, eventList)
+	return ""
+}
+
+func assertEventMessageContains(t *testing.T, event string, substrings ...string) {
+	t.Helper()
+
+	for _, substring := range substrings {
+		if !strings.Contains(event, substring) {
+			t.Errorf("event %q missing substring %q", event, substring)
+		}
+	}
+}
+
+func TestCreateOrUpdateAttachedBinding_RecordsConflictEvent(t *testing.T) {
+	env := newDependencyPolicyTestEnv(t)
+
 	parentTwo := &workv1alpha2.ResourceBinding{
 		ObjectMeta: metav1.ObjectMeta{
 			Name:      "workload-b",
@@ -3486,66 +3547,84 @@ func TestCreateOrUpdateAttachedBinding_EmitsDependencyEvents(t *testing.T) {
 			PreserveResourcesOnDeletion: ptr.To(false),
 		},
 	}
-	attachedFromParentTwo := buildAttachedBinding(parentTwo, dependentObj)
+	attachedFromParentTwo := buildAttachedBinding(parentTwo, env.dependent)
 
-	if err := d.createOrUpdateAttachedBinding(attachedFromParentTwo); err != nil {
+	if err := env.distributor.createOrUpdateAttachedBinding(attachedFromParentTwo); err != nil {
 		t.Fatalf("createOrUpdateAttachedBinding() error = %v", err)
 	}
 
 	updated := &workv1alpha2.ResourceBinding{}
-	if err := fakeClient.Get(context.TODO(), client.ObjectKeyFromObject(existing), updated); err != nil {
+	if err := env.client.Get(context.TODO(), client.ObjectKeyFromObject(env.existing), updated); err != nil {
 		t.Fatalf("failed to fetch updated binding: %v", err)
 	}
 	if len(updated.Spec.RequiredBy) != 2 {
 		t.Fatalf("expected 2 parents after aggregation, got %d", len(updated.Spec.RequiredBy))
 	}
 
-	eventsReceived := make([]string, 0, 2)
-	for len(eventsReceived) < 2 {
-		select {
-		case evt := <-recorder.Events:
-			eventsReceived = append(eventsReceived, evt)
-		case <-time.After(time.Second):
-			t.Fatalf("timed out waiting for dependency aggregation events, got %v", eventsReceived)
-		}
-	}
+	eventList := waitForEvents(t, env.recorder, 2, time.Second)
 
-	var conflictEvent, aggregatedEvent string
-	for _, evt := range eventsReceived {
-		if strings.Contains(evt, events.EventReasonDependencyPolicyConflict) {
-			conflictEvent = evt
-		}
-		if strings.Contains(evt, events.EventReasonDependencyPolicyAggregated) {
-			aggregatedEvent = evt
-		}
-	}
+	conflictEvent := findEventByReason(t, eventList, events.EventReasonDependencyPolicyConflict)
+	assertEventMessageContains(t, conflictEvent,
+		"[dep-agg] conflict",
+		"conflictResolution existing=Overwrite incoming=Abort",
+		"preserveResourcesOnDeletion existing=true incoming=false",
+	)
 
-	if conflictEvent == "" {
-		t.Fatalf("expected conflict event in %v", eventsReceived)
-	}
-	if !strings.Contains(conflictEvent, "[dep-agg] conflict") {
-		t.Errorf("unexpected conflict event message: %s", conflictEvent)
-	}
-	if !strings.Contains(conflictEvent, "conflictResolution existing=Overwrite incoming=Abort") {
-		t.Errorf("conflict event missing conflictResolution details: %s", conflictEvent)
-	}
-	if !strings.Contains(conflictEvent, "preserveResourcesOnDeletion existing=true incoming=false") {
-		t.Errorf("conflict event missing preserveResourcesOnDeletion details: %s", conflictEvent)
-	}
+	aggregatedEvent := findEventByReason(t, eventList, events.EventReasonDependencyPolicyAggregated)
+	assertEventMessageContains(t, aggregatedEvent,
+		"[dep-agg] aggregated policy",
+		"conflictResolution=Abort",
+		"preserveResourcesOnDeletion=false",
+		"default/workload-a",
+		"default/workload-b",
+	)
+}
 
-	if aggregatedEvent == "" {
-		t.Fatalf("expected aggregation event in %v", eventsReceived)
+func TestCreateOrUpdateAttachedBinding_RecordsAggregationEvent(t *testing.T) {
+	env := newDependencyPolicyTestEnv(t)
+
+	parentTwo := &workv1alpha2.ResourceBinding{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      "workload-b",
+			Namespace: "default",
+			Labels: map[string]string{
+				workv1alpha2.ResourceBindingPermanentIDLabel: "rb-uid-b",
+			},
+		},
+		Spec: workv1alpha2.ResourceBindingSpec{
+			Clusters:                    []workv1alpha2.TargetCluster{{Name: "member2"}},
+			ConflictResolution:          policyv1alpha1.ConflictOverwrite,
+			PreserveResourcesOnDeletion: ptr.To(true),
+		},
 	}
-	if !strings.Contains(aggregatedEvent, "[dep-agg] aggregated policy") {
-		t.Errorf("unexpected aggregation event message: %s", aggregatedEvent)
+	attachedFromParentTwo := buildAttachedBinding(parentTwo, env.dependent)
+
+	if err := env.distributor.createOrUpdateAttachedBinding(attachedFromParentTwo); err != nil {
+		t.Fatalf("createOrUpdateAttachedBinding() error = %v", err)
 	}
-	if !strings.Contains(aggregatedEvent, "conflictResolution=Abort") {
-		t.Errorf("aggregation event missing conflictResolution result: %s", aggregatedEvent)
+
+	updated := &workv1alpha2.ResourceBinding{}
+	if err := env.client.Get(context.TODO(), client.ObjectKeyFromObject(env.existing), updated); err != nil {
+		t.Fatalf("failed to fetch updated binding: %v", err)
 	}
-	if !strings.Contains(aggregatedEvent, "preserveResourcesOnDeletion=false") {
-		t.Errorf("aggregation event missing preserveResourcesOnDeletion result: %s", aggregatedEvent)
+	if len(updated.Spec.RequiredBy) != 2 {
+		t.Fatalf("expected 2 parents after aggregation, got %d", len(updated.Spec.RequiredBy))
 	}
-	if !strings.Contains(aggregatedEvent, "default/workload-a") || !strings.Contains(aggregatedEvent, "default/workload-b") {
-		t.Errorf("aggregation event missing parent list: %s", aggregatedEvent)
+
+	eventList := waitForEvents(t, env.recorder, 1, time.Second)
+
+	aggregatedEvent := findEventByReason(t, eventList, events.EventReasonDependencyPolicyAggregated)
+	assertEventMessageContains(t, aggregatedEvent,
+		"[dep-agg] aggregated policy",
+		"conflictResolution=Overwrite",
+		"preserveResourcesOnDeletion=true",
+		"default/workload-a",
+		"default/workload-b",
+	)
+
+	for _, evt := range eventList {
+		if strings.Contains(evt, events.EventReasonDependencyPolicyConflict) {
+			t.Fatalf("unexpected conflict event: %s", evt)
+		}
 	}
 }