fix: projecting over inexistent fields

pkg/engine/assert/expression.go

@@ -23,7 +23,7 @@ type expression struct {
 	engine      string
 }
 
-func parseExpressionRegex(ctx context.Context, in string) *expression {
+func parseExpressionRegex(_ context.Context, in string) *expression {
 	expression := &expression{}
 	// 1. match foreach
 	if match := foreachRegex.FindStringSubmatch(in); match != nil {

pkg/engine/assert/parse.go

@@ -51,6 +51,8 @@
 		projection, err := project(ctx, k, value, bindings, opts...)
 		if err != nil {
 			return nil, field.InternalError(path.Child(fmt.Sprint(k)), err)
+		} else if projection == nil {
+			errs = append(errs, field.Required(path.Child(fmt.Sprint(k)), "projection is not valid"))
 		} else {
 			if projection.binding != "" {
 				bindings = bindings.Register("$"+projection.binding, jpbinding.NewBinding(projection.result))

pkg/engine/assert/project.go

@@ -2,6 +2,7 @@ package assert
 
 import (
 	"context"
+	"errors"
 	"reflect"
 
 	"github.com/jmespath-community/go-jmespath/pkg/binding"
@@ -33,31 +34,26 @@ func project(ctx context.Context, key any, value any, bindings binding.Bindings,
 		} else {
 			if reflectutils.GetKind(value) == reflect.Map {
 				mapValue := reflect.ValueOf(value).MapIndex(reflect.ValueOf(expression.statement))
-				var value any
-				if mapValue.IsValid() {
-					value = mapValue.Interface()
+				if !mapValue.IsValid() {
+					return nil, nil
 				}
 				return &projection{
 					foreach:     expression.foreach,
 					foreachName: expression.foreachName,
 					binding:     expression.binding,
-					result:      value,
+					result:      mapValue.Interface(),
 				}, nil
 			}
 		}
 	}
 	if reflectutils.GetKind(value) == reflect.Map {
 		mapValue := reflect.ValueOf(value).MapIndex(reflect.ValueOf(key))
-		var value any
-		if mapValue.IsValid() {
-			value = mapValue.Interface()
+		if !mapValue.IsValid() {
+			return nil, nil
 		}
 		return &projection{
-			result: value,
+			result: mapValue.Interface(),
 		}, nil
 	}
-	// TODO is this an error ?
-	return &projection{
-		result: value,
-	}, nil
+	return nil, errors.New("projection not recognized")
 }

pkg/engine/assert/project_test.go

@@ -25,16 +25,76 @@ func Test_project(t *testing.T) {
 		bindings: nil,
 		want:     nil,
 		wantErr:  false,
+	}, {
+		name: "map index found",
+		key:  "bar",
+		value: map[string]any{
+			"bar": 42,
+		},
+		bindings: nil,
+		want: &projection{
+			result: 42,
+		},
+		wantErr: false,
+	}, {
+		name: "map index found (and nil)",
+		key:  "bar",
+		value: map[string]any{
+			"bar": nil,
+		},
+		bindings: nil,
+		want: &projection{
+			result: nil,
+		},
+		wantErr: false,
+	}, {
+		name: "non string key (not found)",
+		key:  3,
+		value: map[int]any{
+			2: "foo",
+		},
+		bindings: nil,
+		want:     nil,
+		wantErr:  false,
+	}, {
+		name: "non string key (found)",
+		key:  2,
+		value: map[int]any{
+			2: "foo",
+		},
+		bindings: nil,
+		want: &projection{
+			result: "foo",
+		},
+		wantErr: false,
+	}, {
+		name: "non string key (found and nil)",
+		key:  2,
+		value: map[int]any{
+			2: nil,
+		},
+		bindings: nil,
+		want: &projection{
+			result: nil,
+		},
+		wantErr: false,
+	}, {
+		name:     "nil value",
+		key:      "foo",
+		value:    nil,
+		bindings: nil,
+		want:     nil,
+		wantErr:  true,
 	}}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			got, err := project(context.TODO(), tt.key, tt.value, tt.bindings)
 			if tt.wantErr {
 				tassert.Error(t, err)
-				tassert.Equal(t, tt.want, got)
 			} else {
 				tassert.NoError(t, err)
 			}
+			tassert.Equal(t, tt.want, got)
 		})
 	}
 }