Added unit test

Author: AryanP123

internal/kube/controller/controller.go

@@ -401,30 +401,17 @@ func (c *Controller) checkListener(key string, listener *skupperv2alpha1.Listene
 	return nil
 }
 
-func (c *Controller) ReconcileListenersForDeletedService(namespace, serviceName string) error {
-	if !c.namespaces.isControlled(namespace) {
-		return nil
-	}
-	for _, listener := range c.listenerWatcher.List() {
-		if listener.Namespace != namespace || listener.Spec.Host != serviceName {
-			continue
-		}
-		listenerKey := namespace + "/" + listener.Name
-		if err := c.checkListener(listenerKey, listener); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
 func (c *Controller) checkListenerService(key string, svc *corev1.Service) error {
 	c.log.Debug("checkListenerService", slog.String("key", key))
 	if svc == nil {
 		namespace, serviceName, err := cache.SplitMetaNamespaceKey(key)
 		if err != nil {
 			return err
 		}
-		return c.ReconcileListenersForDeletedService(namespace, serviceName)
+		if !c.namespaces.isControlled(namespace) {
+			return nil
+		}
+		return c.getSite(namespace).HandleDeletedListenerService(serviceName)
 	}
 	return c.getSite(svc.Namespace).CheckListenerService(svc)
 }

internal/kube/controller/controller_test.go

@@ -624,6 +624,18 @@ func TestUpdate(t *testing.T) {
 				serviceCheck("adifferentsvc", "test").check,
 				negativeServiceCheck("mysvc", "test"),
 			},
+		}, {
+			name: "listener service recreated when deleted",
+			skupperObjects: []runtime.Object{
+				f.site("mysite", "test", "", false, false),
+				f.listener("mylistener", "test", "mysvc", 8080),
+			},
+			functions: []WaitFunction{
+				isListenerStatusConditionTrue("mylistener", "test", skupperv2alpha1.CONDITION_TYPE_CONFIGURED),
+				serviceCheck("mysvc", "test").check,
+				deleteListenerService("mysvc", "test"),
+				waitForService("mysvc", "test"),
+			},
 		}, {
 			name: "exposePodsByName handles pod delete",
 			k8sObjects: []runtime.Object{
@@ -801,6 +813,41 @@ func TestUpdate(t *testing.T) {
 	}
 }
 
+func TestListenerServiceRecreatedWhenDeleted(t *testing.T) {
+	runListenerServiceRecreatedWithFakeClient(t)
+}
+
+func runListenerServiceRecreatedWithFakeClient(t *testing.T) {
+	t.Helper()
+	flags := flag.NewFlagSet("", flag.ContinueOnError)
+	config, err := BoundConfig(flags)
+	assert.NilError(t, err)
+	clients, err := fakeclient.NewFakeClient("test", nil, []runtime.Object{
+		f.site("mysite", "test", "", false, false),
+		f.listener("mylistener", "test", "mysvc", 8080),
+	}, "")
+	assert.NilError(t, err)
+	enableSSA(clients.GetDynamicClient())
+	ctrl, err := NewController(clients, config, func(e *watchers.EventProcessor) { e.SetResyncShort(time.Second) })
+	assert.NilError(t, err)
+	stopCh := make(chan struct{})
+	err = ctrl.init(stopCh)
+	assert.NilError(t, err)
+	for i := 0; i < 2; i++ {
+		ctrl.eventProcessor.TestProcess()
+	}
+	for !isListenerStatusConditionTrue("mylistener", "test", skupperv2alpha1.CONDITION_TYPE_CONFIGURED)(t, clients) {
+		ctrl.eventProcessor.TestProcess()
+	}
+	for !serviceCheck("mysvc", "test").check(t, clients) {
+		ctrl.eventProcessor.TestProcess()
+	}
+	deleteListenerService("mysvc", "test")(t, clients)
+	for !waitForService("mysvc", "test")(t, clients) {
+		ctrl.eventProcessor.TestProcess()
+	}
+}
+
 func deleteAttachedConnector(name string, namespace string) WaitFunction {
 	return func(t *testing.T, clients internalclient.Clients) bool {
 		err := clients.GetSkupperClient().SkupperV2alpha1().AttachedConnectors(namespace).Delete(context.Background(), name, metav1.DeleteOptions{})
@@ -1929,6 +1976,17 @@ func (s *ServiceCheck) checkAbsent(t *testing.T, clients internalclient.Clients)
 	return false
 }
 
+func waitForService(name string, namespace string) WaitFunction {
+	return func(t *testing.T, clients internalclient.Clients) bool {
+		_, err := clients.GetKubeClient().CoreV1().Services(namespace).Get(context.Background(), name, metav1.GetOptions{})
+		if errors.IsNotFound(err) {
+			return false
+		}
+		assert.Assert(t, err)
+		return true
+	}
+}
+
 func updateListener(name string, namespace string, host string, port int) WaitFunction {
 	return func(t *testing.T, clients internalclient.Clients) bool {
 		ctxt := context.Background()
@@ -1951,6 +2009,14 @@ func negativeServiceCheck(name string, namespace string) WaitFunction {
 	}
 }
 
+func deleteListenerService(serviceName string, namespace string) WaitFunction {
+	return func(t *testing.T, clients internalclient.Clients) bool {
+		err := clients.GetKubeClient().CoreV1().Services(namespace).Delete(context.Background(), serviceName, metav1.DeleteOptions{})
+		assert.Assert(t, err)
+		return true
+	}
+}
+
 func deleteTargetPod(name string, namespace string) WaitFunction {
 	return func(t *testing.T, clients internalclient.Clients) bool {
 		ctxt := context.Background()

internal/kube/site/extended_bindings.go

@@ -131,6 +131,13 @@ func (a *ExtendedBindings) ListenerUpdated(listener *skupperv2alpha1.Listener) {
 	}
 }
 
+func (a *ExtendedBindings) GetExposedPortSet(host string) *ExposedPortSet {
+	if existing, ok := a.exposed[host]; ok && !existing.empty() {
+		return existing
+	}
+	return nil
+}
+
 func (a *ExtendedBindings) ListenerDeleted(listener *skupperv2alpha1.Listener) {
 	if exposed := a.exposed.Unexpose(listener.Spec.Host, listener.Name); exposed != nil {
 		a.mapping.ReleasePortForKey(listener.Name)

internal/kube/site/site.go

@@ -936,6 +936,17 @@ func (s *Site) CheckListenerService(svc *corev1.Service) error {
 	return nil
 }
 
+func (s *Site) HandleDeletedListenerService(serviceName string) error {
+	if s.site == nil {
+		return nil
+	}
+	portSet := s.bindings.GetExposedPortSet(serviceName)
+	if portSet == nil {
+		return nil // not exposed anymore (e.g. Listener was deleted); nothing to recreate
+	}
+	return s.Expose(portSet)
+}
+
 func (s *Site) EnsureListenerService(listener *skupperv2alpha1.Listener) {
 	if listener != nil && s.site != nil {
 		s.bindings.ListenerUpdated(listener)