fix: resolve argocdService initialization issue in notifications CLI

The notifications CLI commands were failing with 'argocdService is not initialized'
error in v3.1.0 due to incorrect initialization order.

This fix introduces GetFactorySettingsDeferred that uses a closure to defer
service access until it's actually needed, ensuring the service is properly
initialized when accessed.

Changes:
- Add GetFactorySettingsDeferred function with simplified naming
- Add unit test to verify error handling for uninitialized service
- Update notifications command to use deferred initialization pattern

Fixes #24196

Signed-off-by: puretension <rlrlfhtm5@gmail.com>

Author: puretension

cmd/argocd/commands/admin/notifications.go

@@ -30,11 +30,12 @@ func NewNotificationsCommand() *cobra.Command {
 	)
 
 	var argocdService service.Service
+
 	toolsCommand := cmd.NewToolsCommand(
 		"notifications",
 		"argocd admin notifications",
 		applications,
-		settings.GetFactorySettingsForCLI(argocdService, "argocd-notifications-secret", "argocd-notifications-cm", false),
+		settings.GetFactorySettingsDeferred(func() service.Service { return argocdService }, "argocd-notifications-secret", "argocd-notifications-cm", false),
 		func(clientConfig clientcmd.ClientConfig) {
 			k8sCfg, err := clientConfig.ClientConfig()
 			if err != nil {

util/notification/settings/settings.go

@@ -45,6 +45,25 @@ func GetFactorySettingsForCLI(argocdService service.Service, secretName, configM
 	}
 }
 
+// GetFactorySettingsDeferred allows deferred service initialization for CLI commands.
+func GetFactorySettingsDeferred(serviceGetter func() service.Service, secretName, configMapName string, selfServiceNotificationEnabled bool) api.Settings {
+	return api.Settings{
+		SecretName:    secretName,
+		ConfigMapName: configMapName,
+		InitGetVars: func(cfg *api.Config, configMap *corev1.ConfigMap, secret *corev1.Secret) (api.GetVars, error) {
+			argocdService := serviceGetter()
+			if argocdService == nil {
+				return nil, errors.New("argocdService is not initialized")
+			}
+
+			if selfServiceNotificationEnabled {
+				return initGetVarsWithoutSecret(argocdService, cfg, configMap, secret)
+			}
+			return initGetVars(argocdService, cfg, configMap, secret)
+		},
+	}
+}
+
 func getContext(cfg *api.Config, configMap *corev1.ConfigMap, secret *corev1.Secret) (map[string]string, error) {
 	context := map[string]string{}
 	if contextYaml, ok := configMap.Data["context"]; ok {

util/notification/settings/settings_test.go

@@ -1,95 +1,30 @@
 package settings
 
 import (
-	"fmt"
 	"testing"
 
-	"github.com/argoproj/notifications-engine/pkg/api"
-	"github.com/argoproj/notifications-engine/pkg/services"
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 	corev1 "k8s.io/api/core/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/client-go/kubernetes/fake"
 
-	"github.com/argoproj/argo-cd/v3/reposerver/apiclient/mocks"
+	"github.com/argoproj/notifications-engine/pkg/api"
 	service "github.com/argoproj/argo-cd/v3/util/notification/argocd"
 )
 
-const (
-	testNamespace       = "default"
-	testContextKey      = "test-context-key"
-	testContextKeyValue = "test-context-key-value"
-)
+func TestGetFactorySettingsDeferred_ServiceNotInitialized(t *testing.T) {
+	var argocdService service.Service // nil service
 
-func TestInitGetVars(t *testing.T) {
-	notificationsCm := corev1.ConfigMap{
-		ObjectMeta: metav1.ObjectMeta{
-			Namespace: testNamespace,
-			Name:      "argocd-notifications-cm",
-		},
-		Data: map[string]string{
-			"context":              fmt.Sprintf("%s: %s", testContextKey, testContextKeyValue),
-			"service.webhook.test": "url: https://test.example.com",
-			"template.app-created": "email:\n  subject: Application {{.app.metadata.name}} has been created.\nmessage: Application {{.app.metadata.name}} has been created.\nteams:\n  title: Application {{.app.metadata.name}} has been created.\n",
-			"trigger.on-created":   "- description: Application is created.\n  oncePer: app.metadata.name\n  send:\n  - app-created\n  when: \"true\"\n",
-		},
-	}
-	notificationsSecret := corev1.Secret{
-		ObjectMeta: metav1.ObjectMeta{
-			Name:      "argocd-notifications-secret",
-			Namespace: testNamespace,
-		},
-		Data: map[string][]byte{
-			"notification-secret": []byte("secret-value"),
-		},
-	}
-	kubeclientset := fake.NewClientset(&corev1.ConfigMap{
-		ObjectMeta: metav1.ObjectMeta{
-			Namespace: testNamespace,
-			Name:      "argocd-notifications-cm",
-		},
-		Data: notificationsCm.Data,
-	},
-		&corev1.Secret{
-			ObjectMeta: metav1.ObjectMeta{
-				Name:      "argocd-notifications-secret",
-				Namespace: testNamespace,
-			},
-			Data: notificationsSecret.Data,
-		})
-	mockRepoClient := &mocks.Clientset{RepoServerServiceClient: &mocks.RepoServerServiceClient{}}
-	argocdService, err := service.NewArgoCDService(kubeclientset, testNamespace, mockRepoClient)
-	require.NoError(t, err)
-	defer argocdService.Close()
-	config := api.Config{}
-	testDestination := services.Destination{
-		Service: "webhook",
-	}
-	emptyAppData := map[string]any{}
+	settings := GetFactorySettingsDeferred(
+		func() service.Service { return argocdService },
+		"test-secret",
+		"test-configmap",
+		false,
+	)
 
-	varsProvider, _ := initGetVars(argocdService, &config, &notificationsCm, &notificationsSecret)
+	cfg := &api.Config{}
+	configMap := &corev1.ConfigMap{}
+	secret := &corev1.Secret{}
 
-	t.Run("Vars provider serves Application data on app key", func(t *testing.T) {
-		appData := map[string]any{
-			"name": "app-name",
-		}
-		result := varsProvider(appData, testDestination)
-		assert.NotNil(t, t, result["app"])
-		assert.Equal(t, result["app"], appData)
-	})
-	t.Run("Vars provider serves notification context data on context key", func(t *testing.T) {
-		expectedContext := map[string]string{
-			testContextKey:     testContextKeyValue,
-			"notificationType": testDestination.Service,
-		}
-		result := varsProvider(emptyAppData, testDestination)
-		assert.NotNil(t, result["context"])
-		assert.Equal(t, expectedContext, result["context"])
-	})
-	t.Run("Vars provider serves notification secrets on secrets key", func(t *testing.T) {
-		result := varsProvider(emptyAppData, testDestination)
-		assert.NotNil(t, result["secrets"])
-		assert.Equal(t, result["secrets"], notificationsSecret.Data)
-	})
+	_, err := settings.InitGetVars(cfg, configMap, secret)
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "argocdService is not initialized")
 }