Add unit test for generic constraint and add some context on CEL library

Add unit test cases for generic constraint using CEL to ensure it works
properly in the resolver.

Add some context for the custom library for semver comparison in CEL.

Signed-off-by: Vu Dinh <[email protected]>

Author: dinhxuanvu

Diff for: pkg/controller/registry/resolver/cache/predicates.go

@@ -357,7 +357,7 @@ func (ep *evaluatorPredicate) Test(entry *Entry) bool {
 	return ok
 }
 
-func EvaluatorPredicate(provider constraints.EvaluatorProvider, rule, message string) (Predicate, error) {
+func EvaluatorPredicate(provider constraints.EvaluatorProvider, rule string, message string) (Predicate, error) {
 	eval, err := provider.Evaluator(rule)
 	if err != nil {
 		return nil, err

Diff for: pkg/controller/registry/resolver/constraints/cel.go

@@ -43,9 +43,23 @@ type celEvaluatorProvider struct {
 }
 
 type celEvaluator struct {
-	p cel.Program
+	program cel.Program
 }
 
+/*
+This section of code is for custom library for semver comparison in CEL
+The code is inspired by https://github.com/google/cel-go/blob/master/cel/cel_test.go#L46
+
+The semver_compare is wrriten based on `Compare` function in https://github.com/blang/semver
+particularly in https://github.com/blang/semver/blob/master/semver.go#L125
+
+Example:
+`semver_compare(v1, v2)` is equivalent of `v1.Compare(v2)` in blang/semver library
+
+The result is `semver_compare` is an integer just like `Compare`. So, the CEL
+expression `semver_compare(v1, v2) == 0` is equivalent v1.Compare(v2) == 0. In
+the other words, it checks if v1 is equal to v2 in term of semver comparision.
+*/
 type semverLib struct{}
 
 func (semverLib) CompileOptions() []cel.EnvOption {
@@ -69,8 +83,21 @@ func (semverLib) ProgramOptions() []cel.ProgramOption {
 	}
 }
 
+func semverCompare(val1, val2 ref.Val) ref.Val {
+	v1, err := semver.ParseTolerant(fmt.Sprint(val1.Value()))
+	if err != nil {
+		return types.ValOrErr(val1, "unable to parse '%v' to semver format", val1.Value())
+	}
+
+	v2, err := semver.ParseTolerant(fmt.Sprint(val2.Value()))
+	if err != nil {
+		return types.ValOrErr(val2, "unable to parse '%v' to semver format", val2.Value())
+	}
+	return types.Int(v1.Compare(v2))
+}
+
 func (e celEvaluator) Evaluate(env map[string]interface{}) (bool, error) {
-	result, _, err := e.p.Eval(env)
+	result, _, err := e.program.Eval(env)
 	if err != nil {
 		return false, err
 	}
@@ -92,22 +119,9 @@ func (e *celEvaluatorProvider) Evaluator(rule string) (Evaluator, error) {
 		return nil, fmt.Errorf("cel expressions must have type Bool")
 	}
 
-	p, err := e.env.Program(ast)
+	prog, err := e.env.Program(ast)
 	if err != nil {
 		return nil, err
 	}
-	return celEvaluator{p: p}, nil
-}
-
-func semverCompare(val1, val2 ref.Val) ref.Val {
-	v1, err := semver.ParseTolerant(fmt.Sprint(val1.Value()))
-	if err != nil {
-		return types.ValOrErr(val1, "unable to parse '%v' to semver format", val1.Value())
-	}
-
-	v2, err := semver.ParseTolerant(fmt.Sprint(val2.Value()))
-	if err != nil {
-		return types.ValOrErr(val2, "unable to parse '%v' to semver format", val2.Value())
-	}
-	return types.Int(v1.Compare(v2))
+	return celEvaluator{program: prog}, nil
 }

Diff for: pkg/controller/registry/resolver/resolver_test.go

@@ -18,6 +18,7 @@ import (
 	"github.com/operator-framework/api/pkg/operators/v1alpha1"
 	listersv1alpha1 "github.com/operator-framework/operator-lifecycle-manager/pkg/api/client/listers/operators/v1alpha1"
 	"github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/cache"
+	"github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/constraints"
 	"github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/solver"
 	"github.com/operator-framework/operator-registry/pkg/api"
 	opregistry "github.com/operator-framework/operator-registry/pkg/registry"
@@ -2066,3 +2067,124 @@ func TestNewOperatorFromCSV(t *testing.T) {
 		})
 	}
 }
+
+func TestSolveOperators_GenericConstraint(t *testing.T) {
+	Provides1 := cache.APISet{opregistry.APIKey{"g", "v", "k", "ks"}: struct{}{}}
+	namespace := "olm"
+	catalog := cache.SourceKey{Name: "community", Namespace: namespace}
+
+	deps1 := []*api.Dependency{
+		{
+			Type: "olm.constraint",
+			Value: `{"message":"gvk-constraint",
+				"cel":{"rule":"properties.exists(p, p.type == 'olm.gvk' && p.value == {'group': 'g', 'version': 'v', 'kind': 'k'})"}}`,
+		},
+	}
+	deps2 := []*api.Dependency{
+		{
+			Type: "olm.constraint",
+			Value: `{"message":"gvk2-constraint",
+				"cel":{"rule":"properties.exists(p, p.type == 'olm.gvk' && p.value == {'group': 'g2', 'version': 'v', 'kind': 'k'})"}}`,
+		},
+	}
+	deps3 := []*api.Dependency{
+		{
+			Type: "olm.constraint",
+			Value: `{"message":"package-constraint",
+				"cel":{"rule":"properties.exists(p, p.type == 'olm.package' && p.value.packageName == 'packageB' && (semver_compare(p.value.version, '1.0.1') == 0))"}}`,
+		},
+	}
+
+	tests := []struct {
+		name     string
+		isErr    bool
+		subs     []*v1alpha1.Subscription
+		catalog  cache.Source
+		expected cache.OperatorSet
+		message  string
+	}{
+		{
+			// generic constraint for satisfiable gvk dependency
+			name:  "Generic Constraint/Satisfiable GVK Dependency",
+			isErr: false,
+			subs: []*v1alpha1.Subscription{
+				newSub(namespace, "packageA", "stable", catalog),
+			},
+			catalog: &cache.Snapshot{
+				Entries: []*cache.Entry{
+					genOperator("opA.v1.0.0", "1.0.0", "", "packageA", "stable", catalog.Name, catalog.Namespace, nil, nil, deps1, "", false),
+					genOperator("opB.v1.0.0", "1.0.0", "", "packageB", "stable", catalog.Name, catalog.Namespace, nil, Provides1, nil, "stable", false),
+				},
+			},
+			expected: cache.OperatorSet{
+				"opA.v1.0.0": genOperator("opA.v1.0.0", "1.0.0", "", "packageA", "stable", catalog.Name, catalog.Namespace, nil, nil, deps1, "", false),
+				"opB.v1.0.0": genOperator("opB.v1.0.0", "1.0.0", "", "packageB", "stable", catalog.Name, catalog.Namespace, nil, Provides1, nil, "stable", false),
+			},
+		},
+		{
+			// generic constraint for NotSatisfiable gvk dependency
+			name:  "Generic Constraint/NotSatisfiable GVK Dependency",
+			isErr: true,
+			subs: []*v1alpha1.Subscription{
+				newSub(namespace, "packageA", "stable", catalog),
+			},
+			catalog: &cache.Snapshot{
+				Entries: []*cache.Entry{
+					genOperator("opA.v1.0.0", "1.0.0", "", "packageA", "stable", catalog.Name, catalog.Namespace, nil, nil, deps2, "", false),
+					genOperator("opB.v1.0.0", "1.0.0", "", "packageB", "stable", catalog.Name, catalog.Namespace, nil, Provides1, nil, "", false),
+				},
+			},
+			// unable to find satisfiable gvk dependency
+			// resolve into nothing
+			expected: cache.OperatorSet{},
+			message:  "gvk2-constraint",
+		},
+		{
+			// generic constraint for package constraint
+			name:  "Generic Constraint/Satisfiable Package Dependency",
+			isErr: false,
+			subs: []*v1alpha1.Subscription{
+				newSub(namespace, "packageA", "stable", catalog),
+			},
+			catalog: &cache.Snapshot{
+				Entries: []*cache.Entry{
+					genOperator("opA.v1.0.0", "1.0.0", "", "packageA", "stable", catalog.Name, catalog.Namespace, nil, nil, deps3, "", false),
+					genOperator("opB.v1.0.0", "1.0.0", "", "packageB", "stable", catalog.Name, catalog.Namespace, nil, nil, nil, "", false),
+					genOperator("opB.v1.0.1", "1.0.1", "opB.v1.0.0", "packageB", "stable", catalog.Name, catalog.Namespace, nil, nil, nil, "stable", false),
+					genOperator("opB.v1.0.2", "1.0.2", "opB.v1.0.1", "packageB", "stable", catalog.Name, catalog.Namespace, nil, nil, nil, "stable", false),
+				},
+			},
+			expected: cache.OperatorSet{
+				"opA.v1.0.0": genOperator("opA.v1.0.1", "1.0.1", "", "packageA", "stable", catalog.Name, catalog.Namespace, nil, nil, deps3, "", false),
+				"opB.v1.0.1": genOperator("opB.v1.0.1", "1.0.1", "opB.v1.0.0", "packageB", "stable", catalog.Name, catalog.Namespace, nil, nil, nil, "stable", false),
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			var err error
+			var operators cache.OperatorSet
+			satResolver := SatResolver{
+				cache: cache.New(cache.StaticSourceProvider{
+					catalog: tt.catalog,
+				}),
+				log:               logrus.New(),
+				evaluatorProvider: constraints.NewCelEvaluatorProvider(),
+			}
+
+			operators, err = satResolver.SolveOperators([]string{namespace}, nil, tt.subs)
+			if tt.isErr {
+				assert.Error(t, err)
+				assert.Contains(t, err.Error(), tt.message)
+			} else {
+				assert.NoError(t, err)
+				for k := range tt.expected {
+					require.NotNil(t, operators[k])
+					assert.EqualValues(t, k, operators[k].Name)
+				}
+			}
+			assert.Equal(t, len(tt.expected), len(operators))
+		})
+	}
+}

Diff for: pkg/controller/registry/resolver/source_registry.go

@@ -233,6 +233,11 @@ func legacyDependenciesToProperties(dependencies []*api.Dependency) ([]*api.Prop
 				Type:  "olm.label.required",
 				Value: dependency.Value,
 			})
+		case "olm.constraint":
+			result = append(result, &api.Property{
+				Type:  "olm.constraint",
+				Value: dependency.Value,
+			})
 		}
 	}
 	return result, nil