add entity sort functions

Signed-off-by: perdasilva <[email protected]>

Author: perdasilva

internal/resolution/variable_sources/utils/sort/sort.go

@@ -0,0 +1,80 @@
+package sort
+
+import (
+	"strings"
+
+	"github.com/operator-framework/deppy/pkg/deppy/input"
+
+	"github.com/operator-framework/operator-controller/internal/resolution/variable_sources/entity"
+)
+
+// ByChannelAndVersion is an entity sort function that orders the entities in
+// package, channel (default channel at the head), and inverse version (higher versions on top)
+// if a property does not exist for one of the entities, the one missing the property is pushed down
+// if both entities are missing the same property they are ordered by id
+func ByChannelAndVersion(entity1 *input.Entity, entity2 *input.Entity) bool {
+	e1 := entity.NewBundleEntity(entity1)
+	e2 := entity.NewBundleEntity(entity2)
+
+	// first sort package lexical order
+	pkgOrder := packageOrder(e1, e2)
+	if pkgOrder != 0 {
+		return pkgOrder < 0
+	}
+
+	// todo(perdasilva): handle default channel in ordering once it is being exposed by the entity
+	channelOrder := channelOrder(e1, e2)
+	if channelOrder != 0 {
+		return channelOrder < 0
+	}
+
+	// order version from highest to lowest (favor the latest release)
+	versionOrder := versionOrder(e1, e2)
+	return versionOrder > 0
+}
+
+func compareErrors(err1 error, err2 error) int {
+	if err1 != nil && err2 == nil {
+		return 1
+	}
+
+	if err1 == nil && err2 != nil {
+		return -1
+	}
+	return 0
+}
+
+func packageOrder(e1, e2 *entity.BundleEntity) int {
+	name1, err1 := e1.PackageName()
+	name2, err2 := e2.PackageName()
+	errComp := compareErrors(err1, err2)
+	if errComp != 0 {
+		return errComp
+	}
+	return strings.Compare(name1, name2)
+}
+
+func channelOrder(e1, e2 *entity.BundleEntity) int {
+	channelProperties1, err1 := e1.ChannelProperties()
+	channelProperties2, err2 := e2.ChannelProperties()
+	errComp := compareErrors(err1, err2)
+	if errComp != 0 {
+		return errComp
+	}
+	if channelProperties1.Priority != channelProperties2.Priority {
+		return channelProperties1.Priority - channelProperties2.Priority
+	}
+	return strings.Compare(channelProperties1.ChannelName, channelProperties2.ChannelName)
+}
+
+func versionOrder(e1, e2 *entity.BundleEntity) int {
+	ver1, err1 := e1.Version()
+	ver2, err2 := e2.Version()
+	errComp := compareErrors(err1, err2)
+	if errComp != 0 {
+		// the sign gets inverted because version is sorted
+		// from highest to lowest
+		return -1 * errComp
+	}
+	return ver1.Compare(*ver2)
+}

internal/resolution/variable_sources/utils/sort/sort_test.go

@@ -0,0 +1,147 @@
+package sort_test
+
+import (
+	"sort"
+	"testing"
+
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+	"github.com/operator-framework/deppy/pkg/deppy/input"
+	"github.com/operator-framework/operator-registry/alpha/property"
+
+	sort2 "github.com/operator-framework/operator-controller/internal/resolution/variable_sources/utils/sort"
+)
+
+func TestSort(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Sort Suite")
+}
+
+var _ = Describe("Sort", func() {
+	Describe("ByChannelAndVersion", func() {
+		It("should order entities by package name", func() {
+			e1 := input.NewEntity("test1", map[string]string{
+				property.TypePackage: `{"packageName": "package1", "version": "1.0.0"}`,
+			})
+			e2 := input.NewEntity("test2", map[string]string{
+				property.TypePackage: `{"packageName": "package2", "version": "1.0.0"}`,
+			})
+			e3 := input.NewEntity("test3", map[string]string{
+				property.TypePackage: `{"packageName": "package3", "version": "1.0.0"}`,
+			})
+			entities := []*input.Entity{e2, e3, e1}
+
+			sort.Slice(entities, func(i, j int) bool {
+				return sort2.ByChannelAndVersion(entities[i], entities[j])
+			})
+
+			Expect(entities[0]).To(Equal(e1))
+			Expect(entities[1]).To(Equal(e2))
+			Expect(entities[2]).To(Equal(e3))
+		})
+
+		It("should order entities by channel name", func() {
+			e1 := input.NewEntity("test1", map[string]string{
+				property.TypePackage: `{"packageName": "package", "version": "1.0.0"}`,
+				property.TypeChannel: `{"channelName":"stableA","priority":0}`,
+			})
+			e2 := input.NewEntity("test2", map[string]string{
+				property.TypePackage: `{"packageName": "package", "version": "1.0.0"}`,
+				property.TypeChannel: `{"channelName":"stableB","priority":0}`,
+			})
+			e3 := input.NewEntity("test3", map[string]string{
+				property.TypePackage: `{"packageName": "package", "version": "1.0.0"}`,
+				property.TypeChannel: `{"channelName":"stableC","priority":0}`,
+			})
+			entities := []*input.Entity{e2, e3, e1}
+
+			sort.Slice(entities, func(i, j int) bool {
+				return sort2.ByChannelAndVersion(entities[i], entities[j])
+			})
+
+			Expect(entities[0]).To(Equal(e1))
+			Expect(entities[1]).To(Equal(e2))
+			Expect(entities[2]).To(Equal(e3))
+		})
+
+		It("should order entities by version number (highest first)", func() {
+			e1 := input.NewEntity("test1", map[string]string{
+				property.TypePackage: `{"packageName": "mypackage", "version": "1.0.0"}`,
+				property.TypeChannel: `{"channelName":"stable","priority":0}`,
+			})
+			e2 := input.NewEntity("test2", map[string]string{
+				property.TypePackage: `{"packageName": "mypackage", "version": "2.0.0"}`,
+				property.TypeChannel: `{"channelName":"stable","priority":0}`,
+			})
+			e3 := input.NewEntity("test3", map[string]string{
+				property.TypePackage: `{"packageName": "mypackage", "version": "3.0.0"}`,
+				property.TypeChannel: `{"channelName":"stable","priority":0}`,
+			})
+			entities := []*input.Entity{e2, e3, e1}
+
+			sort.Slice(entities, func(i, j int) bool {
+				return sort2.ByChannelAndVersion(entities[i], entities[j])
+			})
+
+			Expect(entities[0]).To(Equal(e3))
+			Expect(entities[1]).To(Equal(e2))
+			Expect(entities[2]).To(Equal(e1))
+		})
+
+		It("should order entities by version number (highest first) and channel priority (lower value -> higher priority)", func() {
+			e1 := input.NewEntity("test1", map[string]string{
+				property.TypePackage: `{"packageName": "mypackage", "version": "1.0.0"}`,
+				property.TypeChannel: `{"channelName":"beta","priority":1}`,
+			})
+			e2 := input.NewEntity("test2", map[string]string{
+				property.TypePackage: `{"packageName": "mypackage", "version": "1.0.0"}`,
+				property.TypeChannel: `{"channelName":"stable","priority":0}`,
+			})
+			e3 := input.NewEntity("test3", map[string]string{
+				property.TypePackage: `{"packageName": "mypackage", "version": "2.0.0"}`,
+				property.TypeChannel: `{"channelName":"beta","priority":1}`,
+			})
+			e4 := input.NewEntity("test4", map[string]string{
+				property.TypePackage: `{"packageName": "mypackage", "version": "3.0.0"}`,
+				property.TypeChannel: `{"channelName":"beta","priority":1}`,
+			})
+			entities := []*input.Entity{e2, e3, e1, e4}
+
+			sort.Slice(entities, func(i, j int) bool {
+				return sort2.ByChannelAndVersion(entities[i], entities[j])
+			})
+
+			Expect(entities[0]).To(Equal(e2))
+			Expect(entities[1]).To(Equal(e4))
+			Expect(entities[2]).To(Equal(e3))
+			Expect(entities[3]).To(Equal(e1))
+		})
+
+		It("should order entities missing a property after those that have it", func() {
+			e1 := input.NewEntity("test1", map[string]string{
+				property.TypePackage: `{"packageName": "mypackage", "version": "1.0.0"}`,
+				property.TypeChannel: `{"channelName":"stable","priority":0}`,
+			})
+			e2 := input.NewEntity("test2", map[string]string{
+				property.TypePackage: `{"packageName": "mypackage"}`,
+				property.TypeChannel: `{"channelName":"stable","priority":0}`,
+			})
+			e3 := input.NewEntity("test3", map[string]string{
+				property.TypePackage: `{"packageName": "mypackage", "version": "3.0.0"}`,
+				property.TypeChannel: `{"channelName":"stable","priority":0}`,
+			})
+			e4 := input.NewEntity("test4", map[string]string{})
+			entities := []*input.Entity{e2, e3, e1, e4}
+
+			sort.Slice(entities, func(i, j int) bool {
+				return sort2.ByChannelAndVersion(entities[i], entities[j])
+			})
+
+			Expect(entities[0]).To(Equal(e3))
+			Expect(entities[1]).To(Equal(e1))
+			Expect(entities[2]).To(Equal(e2))
+			Expect(entities[3]).To(Equal(e4))
+		})
+	})
+
+})