test(metrics): cover reconcile-condition metric across reconcilers

Adds test coverage for the per-resource reconcile-condition gauge flagged
by Codecov as low patch coverage:

- lbc: exercise MockCollector condition set/delete recording
- service: NotFound-delete branch + condition assertions on reconcile
- targetGroupBinding: NotFound, cleanup-success, and deferred branches
- globalAccelerator: NotFound-delete branch (first tests for the package)
- gateway: NotFound-delete branch via the canonical NewMockCollector
- ingress: members-present (condition set) and empty-group (delete) branches

Author: gurpalw

controllers/aga/globalaccelerator_controller_test.go

@@ -0,0 +1,74 @@
+package controllers
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/go-logr/logr"
+	"github.com/stretchr/testify/assert"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/types"
+	agaapi "sigs.k8s.io/aws-load-balancer-controller/v3/apis/aga/v1beta1"
+	testclient "sigs.k8s.io/controller-runtime/pkg/client/fake"
+	"sigs.k8s.io/controller-runtime/pkg/reconcile"
+)
+
+// recordedCondition captures the arguments of a reconcile-condition observation/deletion.
+type recordedCondition struct {
+	controller string
+	namespace  string
+	name       string
+	reconciled bool
+}
+
+// recordingMetricCollector records the reconcile-condition calls so tests can assert on the
+// per-resource condition metric. ObserveControllerReconcileLatency invokes the passed fn so the
+// wrapped reconcile stages actually run.
+type recordingMetricCollector struct {
+	conditions []recordedCondition
+	deletes    []recordedCondition
+}
+
+func (m *recordingMetricCollector) ObservePodReadinessGateReady(_ string, _ string, _ time.Duration) {
+}
+func (m *recordingMetricCollector) ObserveQUICTargetMissingServerId(_ string, _ string) {}
+func (m *recordingMetricCollector) ObserveControllerReconcileError(_ string, _ string)  {}
+func (m *recordingMetricCollector) ObserveControllerReconcileCondition(controller string, namespace string, name string, reconciled bool) {
+	m.conditions = append(m.conditions, recordedCondition{controller, namespace, name, reconciled})
+}
+func (m *recordingMetricCollector) DeleteControllerReconcileCondition(controller string, namespace string, name string) {
+	m.deletes = append(m.deletes, recordedCondition{controller: controller, namespace: namespace, name: name})
+}
+func (m *recordingMetricCollector) ObserveControllerReconcileLatency(_ string, _ string, fn func()) {
+	fn()
+}
+func (m *recordingMetricCollector) ObserveWebhookValidationError(_ string, _ string) {}
+func (m *recordingMetricCollector) ObserveWebhookMutationError(_ string, _ string)   {}
+func (m *recordingMetricCollector) StartCollectTopTalkers(_ context.Context)         {}
+func (m *recordingMetricCollector) StartCollectCacheSize(_ context.Context)          {}
+
+// TestGlobalAcceleratorReconciler_Reconcile_NotFound covers the branch where the GlobalAccelerator
+// has already been deleted: the fetch returns NotFound and the reconcile drops the condition series.
+func TestGlobalAcceleratorReconciler_Reconcile_NotFound(t *testing.T) {
+	scheme := runtime.NewScheme()
+	_ = agaapi.AddToScheme(scheme)
+
+	// no object seeded into the fake client, so the Get returns NotFound
+	k8sClient := testclient.NewClientBuilder().WithScheme(scheme).Build()
+
+	metricsCollector := &recordingMetricCollector{}
+	r := &globalAcceleratorReconciler{
+		k8sClient:        k8sClient,
+		logger:           logr.Discard(),
+		metricsCollector: metricsCollector,
+	}
+
+	err := r.reconcile(context.Background(), reconcile.Request{
+		NamespacedName: types.NamespacedName{Namespace: "default", Name: "gone-aga"},
+	})
+
+	assert.NoError(t, err)
+	assert.Empty(t, metricsCollector.conditions)
+	assert.Equal(t, []recordedCondition{{controller: "globalAccelerator", namespace: "default", name: "gone-aga"}}, metricsCollector.deletes)
+}

controllers/elbv2/targetgroupbinding_controller_test.go

@@ -64,6 +64,30 @@ func (m *mockMetricCollector) ObserveWebhookMutationError(webhookName string, er
 func (m *mockMetricCollector) StartCollectTopTalkers(ctx context.Context)                         {}
 func (m *mockMetricCollector) StartCollectCacheSize(ctx context.Context)                          {}
 
+// recordedCondition captures the arguments of a reconcile-condition observation/deletion.
+type recordedCondition struct {
+	controller string
+	namespace  string
+	name       string
+	reconciled bool
+}
+
+// recordingMetricCollector records the reconcile-condition calls so tests can assert on the
+// per-resource condition metric, delegating every other method to mockMetricCollector.
+type recordingMetricCollector struct {
+	mockMetricCollector
+	conditions []recordedCondition
+	deletes    []recordedCondition
+}
+
+func (m *recordingMetricCollector) ObserveControllerReconcileCondition(controller string, namespace string, name string, reconciled bool) {
+	m.conditions = append(m.conditions, recordedCondition{controller, namespace, name, reconciled})
+}
+
+func (m *recordingMetricCollector) DeleteControllerReconcileCondition(controller string, namespace string, name string) {
+	m.deletes = append(m.deletes, recordedCondition{controller: controller, namespace: namespace, name: name})
+}
+
 // --- Test ---
 
 func TestTargetGroupBindingReconciler_Delete_Stuck(t *testing.T) {
@@ -230,14 +254,15 @@ func TestTargetGroupBindingReconciler_Reconcile_Success(t *testing.T) {
 
 	fakeRecorder := record.NewFakeRecorder(10)
 
+	metricsCollector := &recordingMetricCollector{}
 	reconciler := &targetGroupBindingReconciler{
 		k8sClient:                            k8sClient,
 		eventRecorder:                        fakeRecorder,
 		finalizerManager:                     mockFinalizerManager,
 		tgbResourceManager:                   mockResMgr,
 		deferredTargetGroupBindingReconciler: &mockDeferredReconciler{},
 		logger:                               log.Log.WithName("controllers").WithName("TargetGroupBinding"),
-		metricsCollector:                     &mockMetricCollector{},
+		metricsCollector:                     metricsCollector,
 		reconcileCounters:                    metricsutil.NewReconcileCounters(),
 	}
 
@@ -262,4 +287,148 @@ func TestTargetGroupBindingReconciler_Reconcile_Success(t *testing.T) {
 	default:
 		t.Fatal("expected SuccessfullyReconciled event but none was emitted")
 	}
+
+	// a successful reconcile marks the resource's condition as healthy
+	assert.Equal(t, []recordedCondition{{controller: "targetGroupBinding", namespace: "default", name: "test-tgb", reconciled: true}}, metricsCollector.conditions)
+	assert.Empty(t, metricsCollector.deletes)
+}
+
+// TestTargetGroupBindingReconciler_Reconcile_NotFound covers the branch where the TGB has already
+// been deleted: the fetch returns NotFound and the reconcile drops the condition series.
+func TestTargetGroupBindingReconciler_Reconcile_NotFound(t *testing.T) {
+	scheme := runtime.NewScheme()
+	clientgoscheme.AddToScheme(scheme)
+	elbv2api.AddToScheme(scheme)
+
+	// no TGB seeded into the client, so the Get returns NotFound
+	k8sClient := testclient.NewClientBuilder().WithScheme(scheme).Build()
+
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	metricsCollector := &recordingMetricCollector{}
+	reconciler := &targetGroupBindingReconciler{
+		k8sClient:                            k8sClient,
+		eventRecorder:                        record.NewFakeRecorder(10),
+		finalizerManager:                     k8s.NewMockFinalizerManager(ctrl),
+		tgbResourceManager:                   targetgroupbinding.NewMockResourceManager(ctrl),
+		deferredTargetGroupBindingReconciler: &mockDeferredReconciler{},
+		logger:                               log.Log.WithName("controllers").WithName("TargetGroupBinding"),
+		metricsCollector:                     metricsCollector,
+		reconcileCounters:                    metricsutil.NewReconcileCounters(),
+	}
+
+	req := reconcile.Request{
+		NamespacedName: client.ObjectKey{Namespace: "default", Name: "gone-tgb"},
+	}
+
+	_, err := reconciler.Reconcile(context.Background(), req)
+
+	assert.NoError(t, err)
+	assert.Empty(t, metricsCollector.conditions)
+	assert.Equal(t, []recordedCondition{{controller: "targetGroupBinding", namespace: "default", name: "gone-tgb"}}, metricsCollector.deletes)
+}
+
+// TestTargetGroupBindingReconciler_Reconcile_CleanupSuccess covers a successful delete: after
+// cleanup the condition series must be removed.
+func TestTargetGroupBindingReconciler_Reconcile_CleanupSuccess(t *testing.T) {
+	scheme := runtime.NewScheme()
+	clientgoscheme.AddToScheme(scheme)
+	elbv2api.AddToScheme(scheme)
+
+	tgb := &elbv2api.TargetGroupBinding{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:              "test-tgb",
+			Namespace:         "default",
+			Finalizers:        []string{"elbv2.k8s.aws/resources"},
+			DeletionTimestamp: &metav1.Time{Time: time.Now()},
+		},
+		Spec: elbv2api.TargetGroupBindingSpec{
+			TargetGroupARN: "arn:aws:elasticloadbalancing:us-west-2:123456789012:targetgroup/test/123",
+		},
+	}
+
+	k8sClient := testclient.NewClientBuilder().WithScheme(scheme).WithStatusSubresource(tgb).WithRuntimeObjects(tgb).Build()
+
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	mockFinalizerManager := k8s.NewMockFinalizerManager(ctrl)
+	mockFinalizerManager.EXPECT().RemoveFinalizers(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil)
+
+	mockResMgr := targetgroupbinding.NewMockResourceManager(ctrl)
+	mockResMgr.EXPECT().Cleanup(gomock.Any(), gomock.Any()).Return(nil)
+
+	metricsCollector := &recordingMetricCollector{}
+	reconciler := &targetGroupBindingReconciler{
+		k8sClient:                            k8sClient,
+		eventRecorder:                        record.NewFakeRecorder(10),
+		finalizerManager:                     mockFinalizerManager,
+		tgbResourceManager:                   mockResMgr,
+		deferredTargetGroupBindingReconciler: &mockDeferredReconciler{},
+		logger:                               log.Log.WithName("controllers").WithName("TargetGroupBinding"),
+		metricsCollector:                     metricsCollector,
+		reconcileCounters:                    metricsutil.NewReconcileCounters(),
+	}
+
+	req := reconcile.Request{
+		NamespacedName: client.ObjectKey{Namespace: "default", Name: "test-tgb"},
+	}
+
+	_, err := reconciler.Reconcile(context.Background(), req)
+
+	assert.NoError(t, err)
+	assert.Empty(t, metricsCollector.conditions)
+	assert.Equal(t, []recordedCondition{{controller: "targetGroupBinding", namespace: "default", name: "test-tgb"}}, metricsCollector.deletes)
+}
+
+// TestTargetGroupBindingReconciler_Reconcile_Deferred covers a deferred reconcile: the pass itself
+// did not fail, so the condition must be marked healthy even though the work is enqueued.
+func TestTargetGroupBindingReconciler_Reconcile_Deferred(t *testing.T) {
+	scheme := runtime.NewScheme()
+	clientgoscheme.AddToScheme(scheme)
+	elbv2api.AddToScheme(scheme)
+
+	tgb := &elbv2api.TargetGroupBinding{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      "test-tgb",
+			Namespace: "default",
+		},
+		Spec: elbv2api.TargetGroupBindingSpec{
+			TargetGroupARN: "arn:aws:elasticloadbalancing:us-west-2:123456789012:targetgroup/test/123",
+		},
+	}
+
+	k8sClient := testclient.NewClientBuilder().WithScheme(scheme).WithStatusSubresource(tgb).WithRuntimeObjects(tgb).Build()
+
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	mockFinalizerManager := k8s.NewMockFinalizerManager(ctrl)
+	mockFinalizerManager.EXPECT().AddFinalizers(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil)
+
+	mockResMgr := targetgroupbinding.NewMockResourceManager(ctrl)
+	mockResMgr.EXPECT().Reconcile(gomock.Any(), gomock.Any()).Return(true, nil)
+
+	metricsCollector := &recordingMetricCollector{}
+	reconciler := &targetGroupBindingReconciler{
+		k8sClient:                            k8sClient,
+		eventRecorder:                        record.NewFakeRecorder(10),
+		finalizerManager:                     mockFinalizerManager,
+		tgbResourceManager:                   mockResMgr,
+		deferredTargetGroupBindingReconciler: &mockDeferredReconciler{},
+		logger:                               log.Log.WithName("controllers").WithName("TargetGroupBinding"),
+		metricsCollector:                     metricsCollector,
+		reconcileCounters:                    metricsutil.NewReconcileCounters(),
+	}
+
+	req := reconcile.Request{
+		NamespacedName: client.ObjectKey{Namespace: "default", Name: "test-tgb"},
+	}
+
+	_, err := reconciler.Reconcile(context.Background(), req)
+
+	assert.NoError(t, err)
+	assert.Equal(t, []recordedCondition{{controller: "targetGroupBinding", namespace: "default", name: "test-tgb", reconciled: true}}, metricsCollector.conditions)
+	assert.Empty(t, metricsCollector.deletes)
 }

controllers/gateway/gateway_controller_test.go

@@ -10,13 +10,16 @@ import (
 	"github.com/go-logr/logr"
 	"github.com/stretchr/testify/assert"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/types"
 	"k8s.io/client-go/tools/record"
 	ctrlerrors "sigs.k8s.io/aws-load-balancer-controller/v3/pkg/error"
 	gateway_constants "sigs.k8s.io/aws-load-balancer-controller/v3/pkg/gateway/constants"
 	"sigs.k8s.io/aws-load-balancer-controller/v3/pkg/gateway/routeutils"
 	"sigs.k8s.io/aws-load-balancer-controller/v3/pkg/k8s"
+	lbcmetrics "sigs.k8s.io/aws-load-balancer-controller/v3/pkg/metrics/lbc"
 	elbv2model "sigs.k8s.io/aws-load-balancer-controller/v3/pkg/model/elbv2"
 	"sigs.k8s.io/aws-load-balancer-controller/v3/pkg/testutils"
+	"sigs.k8s.io/controller-runtime/pkg/reconcile"
 	gwv1 "sigs.k8s.io/gateway-api/apis/v1"
 )
 
@@ -182,3 +185,28 @@ func Test_updateGatewayStatusSuccess_normalizesDNSNameToLowercase(t *testing.T)
 	assert.NotNil(t, updatedGW.Status.Addresses[0].Type)
 	assert.Equal(t, gwv1.HostnameAddressType, *updatedGW.Status.Addresses[0].Type)
 }
+
+// Test_reconcileHelper_NotFound covers the branch where the Gateway has already been deleted: the
+// fetch returns NotFound and reconcileHelper drops the condition series without erroring.
+func Test_reconcileHelper_NotFound(t *testing.T) {
+	k8sClient := testutils.GenerateTestClient()
+
+	collector := lbcmetrics.NewMockCollector()
+	reconciler := &gatewayReconciler{
+		k8sClient:        k8sClient,
+		logger:           logr.Discard(),
+		eventRecorder:    record.NewFakeRecorder(10),
+		controllerName:   "gateway.k8s.aws/nlb",
+		metricsCollector: collector,
+	}
+
+	// no Gateway seeded into the client, so the Get returns NotFound
+	err := reconciler.reconcileHelper(context.Background(), reconcile.Request{
+		NamespacedName: types.NamespacedName{Namespace: "test-ns", Name: "gone-gw"},
+	})
+
+	assert.NoError(t, err)
+	// the resource's condition series is removed (a single delete invocation, no set)
+	mc := collector.(*lbcmetrics.MockCollector)
+	assert.Equal(t, 1, len(mc.Invocations[lbcmetrics.MetricControllerReconcileCondition]))
+}