move to event pkg and add test

internal/api/promote_to_stage_v1alpha1.go

@@ -13,6 +13,7 @@ import (
 	kargoapi "github.com/akuity/kargo/api/v1alpha1"
 	"github.com/akuity/kargo/internal/api/user"
 	"github.com/akuity/kargo/internal/kargo"
+	libEvent "github.com/akuity/kargo/internal/kubernetes/event"
 	svcv1alpha1 "github.com/akuity/kargo/pkg/api/service/v1alpha1"
 )
 
@@ -138,7 +139,7 @@ func (s *server) recordPromotionCreatedEvent(
 
 	s.recorder.AnnotatedEventf(
 		p,
-		NewPromotionEventAnnotations(ctx, actor, p, f),
+		libEvent.NewPromotionEventAnnotations(ctx, actor, p, f),
 		corev1.EventTypeNormal,
 		kargoapi.EventReasonPromotionCreated,
 		msg,

internal/controller/promotions/promotions.go

@@ -23,7 +23,6 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/source"
 
 	kargoapi "github.com/akuity/kargo/api/v1alpha1"
-	"github.com/akuity/kargo/internal/api"
 	"github.com/akuity/kargo/internal/controller"
 	argocd "github.com/akuity/kargo/internal/controller/argocd/api/v1alpha1"
 	"github.com/akuity/kargo/internal/directives"
@@ -394,7 +393,7 @@ func (r *reconciler) Reconcile(
 			msg += fmt.Sprintf(": %s", newStatus.Message)
 		}
 
-		eventAnnotations := api.NewPromotionEventAnnotations(ctx,
+		eventAnnotations := libEvent.NewPromotionEventAnnotations(ctx,
 			kargoapi.FormatEventControllerActor(r.cfg.Name()),
 			promo, freight)
 
@@ -622,7 +621,7 @@ func (r *reconciler) terminatePromotion(
 		return err
 	}
 
-	eventMeta := api.NewPromotionEventAnnotations(ctx, "", promo, freight)
+	eventMeta := libEvent.NewPromotionEventAnnotations(ctx, "", promo, freight)
 	eventMeta[kargoapi.AnnotationKeyEventActor] = actor
 
 	r.recorder.AnnotatedEventf(

internal/controller/stages/stages.go

@@ -25,7 +25,6 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/source"
 
 	kargoapi "github.com/akuity/kargo/api/v1alpha1"
-	"github.com/akuity/kargo/internal/api"
 	"github.com/akuity/kargo/internal/controller"
 	argocd "github.com/akuity/kargo/internal/controller/argocd/api/v1alpha1"
 	rollouts "github.com/akuity/kargo/internal/controller/rollouts/api/v1alpha1"
@@ -983,7 +982,7 @@ func (r *reconciler) syncNormalStage(
 
 		r.recorder.AnnotatedEventf(
 			&promo,
-			api.NewPromotionEventAnnotations(
+			libEvent.NewPromotionEventAnnotations(
 				ctx,
 				kargoapi.FormatEventControllerActor(r.cfg.Name()),
 				&promo,

internal/kubernetes/event/event.go

@@ -2,7 +2,9 @@ package event
 
 import (
 	"context"
+	"encoding/json"
 	"errors"
+	"time"
 
 	corev1 "k8s.io/api/core/v1"
 	apierrors "k8s.io/apimachinery/pkg/api/errors"
@@ -13,6 +15,8 @@ import (
 	"k8s.io/client-go/util/retry"
 	libClient "sigs.k8s.io/controller-runtime/pkg/client"
 
+	kargoapi "github.com/akuity/kargo/api/v1alpha1"
+	"github.com/akuity/kargo/internal/directives"
 	"github.com/akuity/kargo/internal/logging"
 )
 
@@ -140,3 +144,93 @@ func (e *sink) Patch(event *corev1.Event, data []byte) (*corev1.Event, error) {
 	err := e.client.Patch(e.ctx, event, libClient.RawPatch(types.StrategicMergePatchType, data))
 	return event, err
 }
+
+type AppReference struct {
+	Name      string `json:"name"`
+	Namespace string `json:"namespace,omitempty"`
+}
+
+// NewPromotionEventAnnotations returns annotations for a Promotion related event.
+// It may skip some fields when error occurred during serialization, to record event with best-effort.
+func NewPromotionEventAnnotations(
+	ctx context.Context,
+	actor string,
+	p *kargoapi.Promotion,
+	f *kargoapi.Freight,
+) map[string]string {
+	logger := logging.LoggerFromContext(ctx)
+
+	annotations := map[string]string{
+		kargoapi.AnnotationKeyEventProject:             p.GetNamespace(),
+		kargoapi.AnnotationKeyEventPromotionName:       p.GetName(),
+		kargoapi.AnnotationKeyEventFreightName:         p.Spec.Freight,
+		kargoapi.AnnotationKeyEventStageName:           p.Spec.Stage,
+		kargoapi.AnnotationKeyEventPromotionCreateTime: p.GetCreationTimestamp().Format(time.RFC3339),
+	}
+
+	if actor != "" {
+		annotations[kargoapi.AnnotationKeyEventActor] = actor
+	}
+	// All Promotion-related events are emitted after the promotion was created.
+	// Therefore, if the promotion knows who triggered it, set them as an actor.
+	if promoteActor, ok := p.Annotations[kargoapi.AnnotationKeyCreateActor]; ok {
+		annotations[kargoapi.AnnotationKeyEventActor] = promoteActor
+	}
+
+	if f != nil {
+		annotations[kargoapi.AnnotationKeyEventFreightCreateTime] = f.CreationTimestamp.Format(time.RFC3339)
+		annotations[kargoapi.AnnotationKeyEventFreightAlias] = f.Alias
+		if len(f.Commits) > 0 {
+			data, err := json.Marshal(f.Commits)
+			if err != nil {
+				logger.Error(err, "marshal freight commits in JSON")
+			} else {
+				annotations[kargoapi.AnnotationKeyEventFreightCommits] = string(data)
+			}
+		}
+		if len(f.Images) > 0 {
+			data, err := json.Marshal(f.Images)
+			if err != nil {
+				logger.Error(err, "marshal freight images in JSON")
+			} else {
+				annotations[kargoapi.AnnotationKeyEventFreightImages] = string(data)
+			}
+		}
+		if len(f.Charts) > 0 {
+			data, err := json.Marshal(f.Charts)
+			if err != nil {
+				logger.Error(err, "marshal freight charts in JSON")
+			} else {
+				annotations[kargoapi.AnnotationKeyEventFreightCharts] = string(data)
+			}
+		}
+	}
+
+	var apps []AppReference
+	for _, step := range p.Spec.Steps {
+		if step.Uses != "argocd-update" || step.Config == nil {
+			continue
+		}
+		var cfg directives.ArgoCDUpdateConfig
+		if err := json.Unmarshal(step.Config.Raw, &cfg); err != nil {
+			logger.Error(err, "unmarshal ArgoCD update config")
+			continue
+		}
+		for _, app := range cfg.Apps {
+			apps = append(apps, AppReference{
+				Name:      app.Name,
+				Namespace: app.Namespace,
+			})
+		}
+	}
+	if len(apps) > 0 {
+		data, err := json.Marshal(apps)
+		if err != nil {
+			logger.Error(err, "marshal ArgoCD apps in JSON")
+		} else {
+			annotations[kargoapi.AnnotationKeyEventApplications] = string(data)
+		}
+	}
+
+	return annotations
+}

internal/kubernetes/event/event_test.go

@@ -5,15 +5,18 @@ import (
 	"errors"
 	"net/http"
 	"testing"
+	"time"
 
 	"github.com/go-logr/logr"
 	"github.com/stretchr/testify/require"
 	corev1 "k8s.io/api/core/v1"
+	v1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1"
 	apierrors "k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	"sigs.k8s.io/controller-runtime/pkg/client/fake"
 
+	"github.com/akuity/kargo/api/v1alpha1"
 	"github.com/akuity/kargo/internal/logging"
 )
 
@@ -81,3 +84,86 @@ func Test_newSink(t *testing.T) {
 	require.NotNil(t, s.client)
 	require.NotNil(t, s.ctx)
 }
+
+func TestNewPromotionEventAnnotations(t *testing.T) {
+	testCases := map[string]struct {
+		actor     string
+		promotion *v1alpha1.Promotion
+		freight   *v1alpha1.Freight
+		expected  map[string]string
+	}{
+		"promotion with freight and argocd apps": {
+			actor: "test-user",
+			promotion: &v1alpha1.Promotion{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:      "test-promotion",
+					Namespace: "test-namespace",
+					CreationTimestamp: metav1.Time{
+						Time: time.Date(2024, 10, 22, 0, 0, 0, 0, time.UTC),
+					},
+					Annotations: map[string]string{
+						v1alpha1.AnnotationKeyCreateActor: "promotion-creator",
+					},
+				},
+				Spec: v1alpha1.PromotionSpec{
+					Freight: "test-freight",
+					Stage:   "test-stage",
+					Steps: []v1alpha1.PromotionStep{
+						{
+							Uses: "argocd-update",
+							Config: &v1.JSON{Raw: []byte(`{
+  "apps": [
+    {
+      "name": "test-app-1"
+    },
+    {
+      "name": "test-app-2",
+      "namespace": "test-namespace"
+    }
+  ]
+}`)},
+						},
+					},
+				},
+			},
+			freight: &v1alpha1.Freight{
+				ObjectMeta: metav1.ObjectMeta{
+					CreationTimestamp: metav1.Time{
+						Time: time.Date(2024, 10, 22, 0, 0, 0, 0, time.UTC),
+					},
+				},
+				Alias:   "test-alias",
+				Commits: []v1alpha1.GitCommit{{Tag: "test-tag"}},
+				Images:  []v1alpha1.Image{{Tag: "test-tag"}},
+				Charts:  []v1alpha1.Chart{{Name: "test-chart"}},
+			},
+			expected: map[string]string{
+				v1alpha1.AnnotationKeyEventProject:             "test-namespace",
+				v1alpha1.AnnotationKeyEventPromotionName:       "test-promotion",
+				v1alpha1.AnnotationKeyEventFreightName:         "test-freight",
+				v1alpha1.AnnotationKeyEventStageName:           "test-stage",
+				v1alpha1.AnnotationKeyEventPromotionCreateTime: "2024-10-22T00:00:00Z",
+				v1alpha1.AnnotationKeyEventActor:               "promotion-creator",
+				v1alpha1.AnnotationKeyEventFreightCreateTime:   "2024-10-22T00:00:00Z",
+				v1alpha1.AnnotationKeyEventFreightAlias:        "test-alias",
+				v1alpha1.AnnotationKeyEventFreightCommits:      `[{"tag":"test-tag"}]`,
+				v1alpha1.AnnotationKeyEventFreightImages:       `[{"tag":"test-tag"}]`,
+				v1alpha1.AnnotationKeyEventFreightCharts:       `[{"name":"test-chart"}]`,
+				v1alpha1.AnnotationKeyEventApplications:        `[{"name":"test-app-1"},{"name":"test-app-2","namespace":"test-namespace"}]`,
+			},
+		},
+	}
+
+	for name, tc := range testCases {
+		t.Run(name, func(t *testing.T) {
+			result := NewPromotionEventAnnotations(context.TODO(), tc.actor, tc.promotion, tc.freight)
+
+			require.Equal(t, len(tc.expected), len(result), "Number of annotations doesn't match")
+			for key, expectedValue := range tc.expected {
+				actualValue, exists := result[key]
+				require.True(t, exists, "Expected annotation %s not found", key)
+				require.Equal(t, expectedValue, actualValue, "Annotation %s value mismatch", key)
+			}
+		})
+	}
+}

internal/webhook/promotion/webhook.go

@@ -20,7 +20,6 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/webhook/admission"
 
 	kargoapi "github.com/akuity/kargo/api/v1alpha1"
-	"github.com/akuity/kargo/internal/api"
 	libEvent "github.com/akuity/kargo/internal/kubernetes/event"
 	"github.com/akuity/kargo/internal/logging"
 	libWebhook "github.com/akuity/kargo/internal/webhook"
@@ -373,7 +372,7 @@ func (w *webhook) recordPromotionCreatedEvent(
 	actor := kargoapi.FormatEventKubernetesUserActor(req.UserInfo)
 	w.recorder.AnnotatedEventf(
 		p,
-		api.NewPromotionEventAnnotations(ctx, actor, p, f),
+		libEvent.NewPromotionEventAnnotations(ctx, actor, p, f),
 		corev1.EventTypeNormal,
 		kargoapi.EventReasonPromotionCreated,
 		"Promotion created for Stage %q by %q",