feat: Add objects inlining and separating utilities (#14)

Many of our objects support two flavors of dependencies, we can either
inline the dependency object OR we can define it as a separate entity
and reuse it freely, referencing it by name.

While this feature gives freedom to the end users it comes with a toil
for implementations as they need to take care of the object reference
resolution.

The goal of this PR is to introduce utility functions which would allow
both inlining of referenced objects and separating inlined objects
definitions.

Author: nieomylnieja

internal/assert/assert.go

@@ -3,6 +3,7 @@ package assert
 import (
 	"fmt"
 	"reflect"
+	"strings"
 	"testing"
 )
 
@@ -19,9 +20,13 @@ func Require(t *testing.T, isPassing bool) {
 }
 
 // Equal fails the test if the expected and actual values are not equal.
-func Equal(t *testing.T, expected, actual interface{}) bool {
+func Equal(t *testing.T, expected, actual any) bool {
 	t.Helper()
 	if !areEqual(expected, actual) {
+		isMultiline := strings.Contains(fmt.Sprint(expected), "\n")
+		if isMultiline {
+			return fail(t, "Expected:\n%v\n%s\nActual:\n%v", expected, strings.Repeat("-", 30), actual)
+		}
 		return fail(t, "Expected: %v, actual: %v", expected, actual)
 	}
 	return true
@@ -46,7 +51,7 @@ func False(t *testing.T, actual bool) bool {
 }
 
 // Len fails the test if the value is not of the expected length.
-func Len(t *testing.T, v interface{}, length int) bool {
+func Len(t *testing.T, v any, length int) bool {
 	t.Helper()
 	actual, err := getLen(v)
 	if err != nil {
@@ -85,7 +90,7 @@ func NotEmpty(t *testing.T, v any) bool {
 	return true
 }
 
-func areEqual(expected, actual interface{}) bool {
+func areEqual(expected, actual any) bool {
 	if expected == nil || actual == nil {
 		return expected == actual
 	}
@@ -95,7 +100,7 @@ func areEqual(expected, actual interface{}) bool {
 	return true
 }
 
-func getLen(v interface{}) (int, error) {
+func getLen(v any) (int, error) {
 	rv := reflect.ValueOf(v)
 	switch rv.Kind() {
 	case reflect.Slice, reflect.Map, reflect.String:
@@ -105,7 +110,7 @@ func getLen(v interface{}) (int, error) {
 	}
 }
 
-func isEmpty(v interface{}) bool {
+func isEmpty(v any) bool {
 	if v == nil {
 		return true
 	}
@@ -125,7 +130,7 @@ func isEmpty(v interface{}) bool {
 	}
 }
 
-func fail(t *testing.T, msg string, a ...interface{}) bool {
+func fail(t *testing.T, msg string, a ...any) bool {
 	t.Helper()
 	t.Errorf(msg, a...)
 	return false

pkg/openslo/v1/alert_policy.go

@@ -51,8 +51,8 @@ type AlertPolicySpec struct {
 	AlertWhenNoData     bool                            `json:"alertWhenNoData,omitempty"`
 	AlertWhenBreaching  bool                            `json:"alertWhenBreaching,omitempty"`
 	AlertWhenResolved   bool                            `json:"alertWhenResolved,omitempty"`
-	Conditions          []AlertPolicyCondition          `json:"conditions"`
-	NotificationTargets []AlertPolicyNotificationTarget `json:"notificationTargets"`
+	Conditions          []AlertPolicyCondition          `json:"conditions,omitempty"`
+	NotificationTargets []AlertPolicyNotificationTarget `json:"notificationTargets,omitempty"`
 }
 
 type AlertPolicyCondition struct {

pkg/openslo/v1/slo.go

@@ -128,7 +128,7 @@ type SLOAlertPolicyInline struct {
 }
 
 type SLOAlertPolicyRef struct {
-	Ref string `json:"alertPolicyRef"`
+	AlertPolicyRef string `json:"alertPolicyRef"`
 }
 
 var sloValidation = govy.New(
@@ -245,7 +245,7 @@ var sloAlertPolicyValidation = govy.New(
 		return a.SLOAlertPolicyRef
 	}).
 		Include(govy.New(
-			govy.For(func(ref SLOAlertPolicyRef) string { return ref.Ref }).
+			govy.For(func(ref SLOAlertPolicyRef) string { return ref.AlertPolicyRef }).
 				WithName("alertPolicyRef").
 				Required().
 				Rules(rules.StringDNSLabel()),

pkg/openslo/v1/slo_test.go

@@ -421,7 +421,7 @@ func TestSLO_Validate_Spec_AlertPolicies(t *testing.T) {
 	t.Run("invalid condition ref", func(t *testing.T) {
 		slo := validSLO()
 		slo.Spec.AlertPolicies[0].SLOAlertPolicyRef = &SLOAlertPolicyRef{
-			Ref: "invalid ref",
+			AlertPolicyRef: "invalid ref",
 		}
 		err := slo.Validate()
 		govytest.AssertError(t, err, govytest.ExpectedRuleError{
@@ -571,7 +571,7 @@ func validSLO() SLO {
 				},
 			},
 			AlertPolicies: []SLOAlertPolicy{
-				{SLOAlertPolicyRef: &SLOAlertPolicyRef{Ref: "alert-policy-1"}},
+				{SLOAlertPolicyRef: &SLOAlertPolicyRef{AlertPolicyRef: "alert-policy-1"}},
 			},
 		},
 	)

pkg/openslo/v2alpha/alert_policy.go

@@ -51,8 +51,8 @@ type AlertPolicySpec struct {
 	AlertWhenNoData     bool                            `json:"alertWhenNoData,omitempty"`
 	AlertWhenBreaching  bool                            `json:"alertWhenBreaching,omitempty"`
 	AlertWhenResolved   bool                            `json:"alertWhenResolved,omitempty"`
-	Conditions          []AlertPolicyCondition          `json:"conditions"`
-	NotificationTargets []AlertPolicyNotificationTarget `json:"notificationTargets"`
+	Conditions          []AlertPolicyCondition          `json:"conditions,omitempty"`
+	NotificationTargets []AlertPolicyNotificationTarget `json:"notificationTargets,omitempty"`
 }
 
 type AlertPolicyCondition struct {

pkg/openslosdk/reference_exporter.go

@@ -0,0 +1,111 @@
+package openslosdk
+
+import (
+	"sync"
+
+	"github.com/OpenSLO/go-sdk/pkg/openslo"
+	v1 "github.com/OpenSLO/go-sdk/pkg/openslo/v1"
+)
+
+func NewReferenceExporter(objects ...openslo.Object) *ReferenceExporter {
+	return &ReferenceExporter{
+		objects:  objects,
+		exported: make([]openslo.Object, 0, len(objects)),
+	}
+}
+
+type ReferenceExporter struct {
+	objects  []openslo.Object
+	exported []openslo.Object
+	once     sync.Once
+}
+
+// Export replaces all the inlined objects with references and returns
+// the original objects along with the exported, previously inlined, objects.
+func (r *ReferenceExporter) Export() []openslo.Object {
+	r.once.Do(func() {
+		r.exported = r.exportObjects()
+	})
+	return r.exported
+}
+
+func (r *ReferenceExporter) exportObjects() []openslo.Object {
+	for _, object := range r.objects {
+		r.exportObject(object)
+	}
+	return r.exported
+}
+
+func (r *ReferenceExporter) exportObject(object openslo.Object) {
+	version := object.GetVersion()
+	switch version {
+	case openslo.VersionV1:
+		r.addResult(r.exportV1Object(object)...)
+	default:
+		r.addResult(object)
+	}
+}
+
+func (r *ReferenceExporter) exportV1Object(object openslo.Object) []openslo.Object {
+	switch v := object.(type) {
+	case v1.AlertPolicy:
+		return r.exportV1AlertPolicy(v)
+	case v1.SLO:
+		return r.exportV1SLO(v)
+	default:
+		return []openslo.Object{object}
+	}
+}
+
+func (r *ReferenceExporter) exportV1AlertPolicy(alertPolicy v1.AlertPolicy) []openslo.Object {
+	exported := make([]openslo.Object, 0)
+	for i, target := range alertPolicy.Spec.NotificationTargets {
+		if target.AlertPolicyNotificationTargetInline == nil {
+			continue
+		}
+		exported = append(exported, v1.NewAlertNotificationTarget(target.Metadata, target.Spec))
+		target.AlertPolicyNotificationTargetRef = &v1.AlertPolicyNotificationTargetRef{
+			TargetRef: target.Metadata.Name,
+		}
+		target.AlertPolicyNotificationTargetInline = nil
+		alertPolicy.Spec.NotificationTargets[i] = target
+	}
+	for i, condition := range alertPolicy.Spec.Conditions {
+		if condition.AlertPolicyConditionInline == nil {
+			continue
+		}
+		exported = append(exported, v1.NewAlertCondition(condition.Metadata, condition.Spec))
+		condition.AlertPolicyConditionRef = &v1.AlertPolicyConditionRef{
+			ConditionRef: condition.Metadata.Name,
+		}
+		condition.AlertPolicyConditionInline = nil
+		alertPolicy.Spec.Conditions[i] = condition
+	}
+	return append([]openslo.Object{alertPolicy}, exported...)
+}
+
+func (r *ReferenceExporter) exportV1SLO(slo v1.SLO) []openslo.Object {
+	exported := make([]openslo.Object, 0)
+	for i, ap := range slo.Spec.AlertPolicies {
+		if ap.SLOAlertPolicyInline == nil {
+			continue
+		}
+		alertPolicy := v1.NewAlertPolicy(ap.Metadata, ap.Spec)
+		exported = append(exported, r.exportV1AlertPolicy(alertPolicy)...)
+		ap.SLOAlertPolicyRef = &v1.SLOAlertPolicyRef{
+			AlertPolicyRef: alertPolicy.Metadata.Name,
+		}
+		ap.SLOAlertPolicyInline = nil
+		slo.Spec.AlertPolicies[i] = ap
+	}
+	if slo.Spec.Indicator != nil {
+		exported = append(exported, v1.NewSLI(slo.Spec.Indicator.Metadata, slo.Spec.Indicator.Spec))
+		slo.Spec.IndicatorRef = &slo.Spec.Indicator.Metadata.Name
+		slo.Spec.Indicator = nil
+	}
+	return append([]openslo.Object{slo}, exported...)
+}
+
+func (r *ReferenceExporter) addResult(objects ...openslo.Object) {
+	r.exported = append(r.exported, objects...)
+}

pkg/openslosdk/reference_exporter_test.go

@@ -0,0 +1,62 @@
+package openslosdk
+
+import (
+	"bytes"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/OpenSLO/go-sdk/internal"
+	"github.com/OpenSLO/go-sdk/internal/assert"
+)
+
+func TestReferenceExporter_Export(t *testing.T) {
+	root := internal.FindModuleRoot()
+	testDataPath := filepath.Join(root, "pkg", "openslosdk", "test_data", "export")
+
+	tests := map[string]struct {
+		filename string
+	}{
+		"v1: Alert Policies": {
+			filename: "v1_alert_policies.yaml",
+		},
+		"v1: SLO": {
+			filename: "v1_slo.yaml",
+		},
+	}
+
+	for name, test := range tests {
+		t.Run(name, func(t *testing.T) {
+			// Read input.
+			inputPath := filepath.Join(testDataPath, "inputs", test.filename)
+			inputFileData, err := os.ReadFile(inputPath)
+			assert.Require(t, assert.NoError(t, err))
+			inputObjects, err := Decode(bytes.NewReader(inputFileData), FormatYAML)
+			assert.Require(t, assert.NoError(t, err))
+			err = Validate(inputObjects...)
+			assert.Require(t, assert.NoError(t, err))
+
+			// Inline objects.
+			exporter := NewReferenceExporter(inputObjects...)
+			inlinedObjects := exporter.Export()
+			assert.Require(t, assert.NotEmpty(t, inlinedObjects))
+
+			// Read output.
+			outputPath := filepath.Join(testDataPath, "outputs", test.filename)
+			outputsFileData, err := os.ReadFile(outputPath)
+			assert.Require(t, assert.NoError(t, err))
+			outputObjects, err := Decode(bytes.NewReader(outputsFileData), FormatYAML)
+			assert.Require(t, assert.NoError(t, err))
+			err = Validate(outputObjects...)
+			assert.Require(t, assert.NoError(t, err))
+
+			// Check.
+			err = Validate(inlinedObjects...)
+			assert.Require(t, assert.NoError(t, err))
+			var buf bytes.Buffer
+			err = Encode(&buf, FormatYAML, inlinedObjects...)
+			assert.Require(t, assert.NoError(t, err))
+			assert.Equal(t, string(outputsFileData), buf.String())
+		})
+	}
+}