From 417b2a9ebaa5ac2f4aea6d1043d70b766b1f5e53 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Charles-Edouard=20Br=C3=A9t=C3=A9ch=C3=A9?= Date: Mon, 6 Feb 2023 07:27:27 +0100 Subject: [PATCH] chore: add a few unit tests for jp functions (#6219) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * chore: add a few unit tests for jp functions Signed-off-by: Charles-Edouard Brétéché * refactor Signed-off-by: Charles-Edouard Brétéché --------- Signed-off-by: Charles-Edouard Brétéché Co-authored-by: shuting --- .../kubectl-kyverno/jp/function/function.go | 7 +- pkg/engine/jmespath/functionentry.go | 52 ++ pkg/engine/jmespath/functionentry_test.go | 64 ++ pkg/engine/jmespath/functions.go | 855 ++++++++---------- pkg/engine/jmespath/functions_test.go | 434 ++++++--- pkg/engine/jmespath/new.go | 2 +- pkg/engine/jmespath/utils.go | 14 + 7 files changed, 800 insertions(+), 628 deletions(-) create mode 100644 pkg/engine/jmespath/functionentry.go create mode 100644 pkg/engine/jmespath/functionentry_test.go create mode 100644 pkg/engine/jmespath/utils.go diff --git a/cmd/cli/kubectl-kyverno/jp/function/function.go b/cmd/cli/kubectl-kyverno/jp/function/function.go index c2eb6c78d2..92b22e9848 100644 --- a/cmd/cli/kubectl-kyverno/jp/function/function.go +++ b/cmd/cli/kubectl-kyverno/jp/function/function.go @@ -35,16 +35,15 @@ func Command() *cobra.Command { func printFunctions(names ...string) { functions := jmespath.GetFunctions() - slices.SortFunc(functions, func(a, b *jmespath.FunctionEntry) bool { + slices.SortFunc(functions, func(a, b jmespath.FunctionEntry) bool { return a.String() < b.String() }) namesSet := sets.New(names...) for _, function := range functions { - if len(namesSet) == 0 || namesSet.Has(function.Entry.Name) { - function := *function + if len(namesSet) == 0 || namesSet.Has(function.Name) { note := function.Note function.Note = "" - fmt.Println("Name:", function.Entry.Name) + fmt.Println("Name:", function.Name) fmt.Println(" Signature:", function.String()) if note != "" { fmt.Println(" Note: ", note) diff --git a/pkg/engine/jmespath/functionentry.go b/pkg/engine/jmespath/functionentry.go new file mode 100644 index 0000000000..27eea74d29 --- /dev/null +++ b/pkg/engine/jmespath/functionentry.go @@ -0,0 +1,52 @@ +package jmespath + +import ( + "fmt" + "strings" + + gojmespath "github.com/jmespath/go-jmespath" +) + +var ( + jpObject = gojmespath.JpObject + jpString = gojmespath.JpString + jpNumber = gojmespath.JpNumber + jpArray = gojmespath.JpArray + jpArrayString = gojmespath.JpArrayString + jpAny = gojmespath.JpAny + jpBool = gojmespath.JpType("bool") +) + +type ( + jpType = gojmespath.JpType + argSpec = gojmespath.ArgSpec +) + +type FunctionEntry struct { + gojmespath.FunctionEntry + Note string + ReturnType []jpType +} + +func (f FunctionEntry) String() string { + if f.Name == "" { + return "" + } + var args []string + for _, a := range f.Arguments { + var aTypes []string + for _, t := range a.Types { + aTypes = append(aTypes, string(t)) + } + args = append(args, strings.Join(aTypes, "|")) + } + var returnArgs []string + for _, ra := range f.ReturnType { + returnArgs = append(returnArgs, string(ra)) + } + output := fmt.Sprintf("%s(%s) %s", f.Name, strings.Join(args, ", "), strings.Join(returnArgs, ",")) + if f.Note != "" { + output += fmt.Sprintf(" (%s)", f.Note) + } + return output +} diff --git a/pkg/engine/jmespath/functionentry_test.go b/pkg/engine/jmespath/functionentry_test.go new file mode 100644 index 0000000000..364aff6bcb --- /dev/null +++ b/pkg/engine/jmespath/functionentry_test.go @@ -0,0 +1,64 @@ +package jmespath + +import ( + "testing" + + gojmespath "github.com/jmespath/go-jmespath" +) + +func TestFunctionEntry_String(t *testing.T) { + type fields struct { + FunctionEntry gojmespath.FunctionEntry + Note string + ReturnType []jpType + } + tests := []struct { + name string + fields fields + want string + }{{ + fields: fields{ + FunctionEntry: gojmespath.FunctionEntry{ + Name: compare, + Arguments: []argSpec{ + {Types: []jpType{jpString}}, + {Types: []jpType{jpString}}, + }, + Handler: jpfCompare, + }, + ReturnType: []jpType{jpNumber}, + Note: "compares two strings lexicographically", + }, + want: "compare(string, string) number (compares two strings lexicographically)", + }, { + fields: fields{ + Note: "compares two strings lexicographically", + }, + want: "", + }, { + fields: fields{ + FunctionEntry: gojmespath.FunctionEntry{ + Name: compare, + Arguments: []argSpec{ + {Types: []jpType{jpString}}, + {Types: []jpType{jpString}}, + }, + Handler: jpfCompare, + }, + ReturnType: []jpType{jpNumber}, + }, + want: "compare(string, string) number", + }} + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + f := FunctionEntry{ + FunctionEntry: tt.fields.FunctionEntry, + Note: tt.fields.Note, + ReturnType: tt.fields.ReturnType, + } + if got := f.String(); got != tt.want { + t.Errorf("FunctionEntry.String() = %v, want %v", got, tt.want) + } + }) + } +} diff --git a/pkg/engine/jmespath/functions.go b/pkg/engine/jmespath/functions.go index 688b6d91ec..c9a2705576 100644 --- a/pkg/engine/jmespath/functions.go +++ b/pkg/engine/jmespath/functions.go @@ -28,21 +28,6 @@ import ( "sigs.k8s.io/yaml" ) -var ( - JpObject = gojmespath.JpObject - JpString = gojmespath.JpString - JpNumber = gojmespath.JpNumber - JpArray = gojmespath.JpArray - JpArrayString = gojmespath.JpArrayString - JpAny = gojmespath.JpAny - JpBool = gojmespath.JpType("bool") -) - -type ( - JpType = gojmespath.JpType - ArgSpec = gojmespath.ArgSpec -) - type PublicKey struct { N string E int @@ -90,517 +75,449 @@ const ( nonIntModuloError = errorPrefix + "Non-integer argument(s) passed for modulo" ) -type FunctionEntry struct { - Entry *gojmespath.FunctionEntry - Note string - ReturnType []JpType -} - -func (f *FunctionEntry) String() string { - args := []string{} - for _, a := range f.Entry.Arguments { - aTypes := []string{} - for _, t := range a.Types { - aTypes = append(aTypes, string(t)) - } - args = append(args, strings.Join(aTypes, "|")) - } - returnArgs := []string{} - for _, ra := range f.ReturnType { - returnArgs = append(returnArgs, string(ra)) - } - output := fmt.Sprintf("%s(%s) %s", f.Entry.Name, strings.Join(args, ", "), strings.Join(returnArgs, ",")) - if f.Note != "" { - output += fmt.Sprintf(" (%s)", f.Note) - } - return output -} - -func GetFunctions() []*FunctionEntry { - return []*FunctionEntry{ - { - Entry: &gojmespath.FunctionEntry{ - Name: compare, - Arguments: []ArgSpec{ - {Types: []JpType{JpString}}, - {Types: []JpType{JpString}}, - }, - Handler: jpfCompare, +func GetFunctions() []FunctionEntry { + return []FunctionEntry{{ + FunctionEntry: gojmespath.FunctionEntry{ + Name: compare, + Arguments: []argSpec{ + {Types: []jpType{jpString}}, + {Types: []jpType{jpString}}, }, - ReturnType: []JpType{JpNumber}, - Note: "compares two strings lexicographically", + Handler: jpfCompare, }, - { - Entry: &gojmespath.FunctionEntry{ - Name: equalFold, - Arguments: []ArgSpec{ - {Types: []JpType{JpString}}, - {Types: []JpType{JpString}}, - }, - Handler: jpfEqualFold, + ReturnType: []jpType{jpNumber}, + Note: "compares two strings lexicographically", + }, { + FunctionEntry: gojmespath.FunctionEntry{ + Name: equalFold, + Arguments: []argSpec{ + {Types: []jpType{jpString}}, + {Types: []jpType{jpString}}, }, - ReturnType: []JpType{JpBool}, - Note: "allows comparing two strings for equivalency where the only differences are letter cases", + Handler: jpfEqualFold, }, - { - Entry: &gojmespath.FunctionEntry{ - Name: replace, - Arguments: []ArgSpec{ - {Types: []JpType{JpString}}, - {Types: []JpType{JpString}}, - {Types: []JpType{JpString}}, - {Types: []JpType{JpNumber}}, - }, - Handler: jpfReplace, + ReturnType: []jpType{jpBool}, + Note: "allows comparing two strings for equivalency where the only differences are letter cases", + }, { + FunctionEntry: gojmespath.FunctionEntry{ + Name: replace, + Arguments: []argSpec{ + {Types: []jpType{jpString}}, + {Types: []jpType{jpString}}, + {Types: []jpType{jpString}}, + {Types: []jpType{jpNumber}}, }, - ReturnType: []JpType{JpString}, - Note: "replaces a specified number of instances of the source string with the replacement string in a parent ", + Handler: jpfReplace, }, - { - Entry: &gojmespath.FunctionEntry{ - Name: replaceAll, - Arguments: []ArgSpec{ - {Types: []JpType{JpString}}, - {Types: []JpType{JpString}}, - {Types: []JpType{JpString}}, - }, - Handler: jpfReplaceAll, + ReturnType: []jpType{jpString}, + Note: "replaces a specified number of instances of the source string with the replacement string in a parent ", + }, { + FunctionEntry: gojmespath.FunctionEntry{ + Name: replaceAll, + Arguments: []argSpec{ + {Types: []jpType{jpString}}, + {Types: []jpType{jpString}}, + {Types: []jpType{jpString}}, }, - ReturnType: []JpType{JpString}, - Note: "replace all instances of one string with another in an overall parent string", + Handler: jpfReplaceAll, }, - { - Entry: &gojmespath.FunctionEntry{ - Name: toUpper, - Arguments: []ArgSpec{ - {Types: []JpType{JpString}}, - }, - Handler: jpfToUpper, + ReturnType: []jpType{jpString}, + Note: "replace all instances of one string with another in an overall parent string", + }, { + FunctionEntry: gojmespath.FunctionEntry{ + Name: toUpper, + Arguments: []argSpec{ + {Types: []jpType{jpString}}, }, - ReturnType: []JpType{JpString}, - Note: "takes in a string and outputs the same string with all upper-case letters", + Handler: jpfToUpper, }, - { - Entry: &gojmespath.FunctionEntry{ - Name: toLower, - Arguments: []ArgSpec{ - {Types: []JpType{JpString}}, - }, - Handler: jpfToLower, + ReturnType: []jpType{jpString}, + Note: "takes in a string and outputs the same string with all upper-case letters", + }, { + FunctionEntry: gojmespath.FunctionEntry{ + Name: toLower, + Arguments: []argSpec{ + {Types: []jpType{jpString}}, }, - ReturnType: []JpType{JpString}, - Note: "takes in a string and outputs the same string with all lower-case letters", + Handler: jpfToLower, }, - { - Entry: &gojmespath.FunctionEntry{ - Name: trim, - Arguments: []ArgSpec{ - {Types: []JpType{JpString}}, - {Types: []JpType{JpString}}, - }, - Handler: jpfTrim, + ReturnType: []jpType{jpString}, + Note: "takes in a string and outputs the same string with all lower-case letters", + }, { + FunctionEntry: gojmespath.FunctionEntry{ + Name: trim, + Arguments: []argSpec{ + {Types: []jpType{jpString}}, + {Types: []jpType{jpString}}, }, - ReturnType: []JpType{JpString}, - Note: "trims both ends of the source string by characters appearing in the second string", + Handler: jpfTrim, }, - { - Entry: &gojmespath.FunctionEntry{ - Name: split, - Arguments: []ArgSpec{ - {Types: []JpType{JpString}}, - {Types: []JpType{JpString}}, - }, - Handler: jpfSplit, + ReturnType: []jpType{jpString}, + Note: "trims both ends of the source string by characters appearing in the second string", + }, { + FunctionEntry: gojmespath.FunctionEntry{ + Name: split, + Arguments: []argSpec{ + {Types: []jpType{jpString}}, + {Types: []jpType{jpString}}, }, - ReturnType: []JpType{JpArrayString}, - Note: "splits the first string when the second string is found and converts it into an array ", + Handler: jpfSplit, }, - { - Entry: &gojmespath.FunctionEntry{ - Name: regexReplaceAll, - Arguments: []ArgSpec{ - {Types: []JpType{JpString}}, - {Types: []JpType{JpString, JpNumber}}, - {Types: []JpType{JpString, JpNumber}}, - }, - Handler: jpRegexReplaceAll, + ReturnType: []jpType{jpArrayString}, + Note: "splits the first string when the second string is found and converts it into an array ", + }, { + FunctionEntry: gojmespath.FunctionEntry{ + Name: regexReplaceAll, + Arguments: []argSpec{ + {Types: []jpType{jpString}}, + {Types: []jpType{jpString, jpNumber}}, + {Types: []jpType{jpString, jpNumber}}, }, - ReturnType: []JpType{JpString}, - Note: "converts all parameters to string", + Handler: jpRegexReplaceAll, }, - { - Entry: &gojmespath.FunctionEntry{ - Name: regexReplaceAllLiteral, - Arguments: []ArgSpec{ - {Types: []JpType{JpString}}, - {Types: []JpType{JpString, JpNumber}}, - {Types: []JpType{JpString, JpNumber}}, - }, - Handler: jpRegexReplaceAllLiteral, + ReturnType: []jpType{jpString}, + Note: "converts all parameters to string", + }, { + FunctionEntry: gojmespath.FunctionEntry{ + Name: regexReplaceAllLiteral, + Arguments: []argSpec{ + {Types: []jpType{jpString}}, + {Types: []jpType{jpString, jpNumber}}, + {Types: []jpType{jpString, jpNumber}}, }, - ReturnType: []JpType{JpString}, - Note: "converts all parameters to string", + Handler: jpRegexReplaceAllLiteral, }, - { - Entry: &gojmespath.FunctionEntry{ - Name: regexMatch, - Arguments: []ArgSpec{ - {Types: []JpType{JpString}}, - {Types: []JpType{JpString, JpNumber}}, - }, - Handler: jpRegexMatch, + ReturnType: []jpType{jpString}, + Note: "converts all parameters to string", + }, { + FunctionEntry: gojmespath.FunctionEntry{ + Name: regexMatch, + Arguments: []argSpec{ + {Types: []jpType{jpString}}, + {Types: []jpType{jpString, jpNumber}}, }, - ReturnType: []JpType{JpBool}, - Note: "first string is the regular exression which is compared with second input which can be a number or string", + Handler: jpRegexMatch, }, - { - Entry: &gojmespath.FunctionEntry{ - Name: patternMatch, - Arguments: []ArgSpec{ - {Types: []JpType{JpString}}, - {Types: []JpType{JpString, JpNumber}}, - }, - Handler: jpPatternMatch, + ReturnType: []jpType{jpBool}, + Note: "first string is the regular exression which is compared with second input which can be a number or string", + }, { + FunctionEntry: gojmespath.FunctionEntry{ + Name: patternMatch, + Arguments: []argSpec{ + {Types: []jpType{jpString}}, + {Types: []jpType{jpString, jpNumber}}, }, - ReturnType: []JpType{JpBool}, - Note: "'*' matches zero or more alphanumeric characters, '?' matches a single alphanumeric character", + Handler: jpPatternMatch, }, - { - // Validates if label (param1) would match pod/host/etc labels (param2) - Entry: &gojmespath.FunctionEntry{ - Name: labelMatch, - Arguments: []ArgSpec{ - {Types: []JpType{JpObject}}, - {Types: []JpType{JpObject}}, - }, - Handler: jpLabelMatch, + ReturnType: []jpType{jpBool}, + Note: "'*' matches zero or more alphanumeric characters, '?' matches a single alphanumeric character", + }, { + // Validates if label (param1) would match pod/host/etc labels (param2) + FunctionEntry: gojmespath.FunctionEntry{ + Name: labelMatch, + Arguments: []argSpec{ + {Types: []jpType{jpObject}}, + {Types: []jpType{jpObject}}, }, - ReturnType: []JpType{JpBool}, - Note: "object arguments must be enclosed in backticks; ex. `{{request.object.spec.template.metadata.labels}}`", + Handler: jpLabelMatch, }, - { - Entry: &gojmespath.FunctionEntry{ - Name: add, - Arguments: []ArgSpec{ - {Types: []JpType{JpAny}}, - {Types: []JpType{JpAny}}, - }, - Handler: jpAdd, + ReturnType: []jpType{jpBool}, + Note: "object arguments must be enclosed in backticks; ex. `{{request.object.spec.template.metadata.labels}}`", + }, { + FunctionEntry: gojmespath.FunctionEntry{ + Name: add, + Arguments: []argSpec{ + {Types: []jpType{jpAny}}, + {Types: []jpType{jpAny}}, }, - ReturnType: []JpType{JpAny}, - Note: "does arithmetic addition of two specified values of numbers, quantities, and durations", + Handler: jpAdd, }, - { - Entry: &gojmespath.FunctionEntry{ - Name: subtract, - Arguments: []ArgSpec{ - {Types: []JpType{JpAny}}, - {Types: []JpType{JpAny}}, - }, - Handler: jpSubtract, + ReturnType: []jpType{jpAny}, + Note: "does arithmetic addition of two specified values of numbers, quantities, and durations", + }, { + FunctionEntry: gojmespath.FunctionEntry{ + Name: subtract, + Arguments: []argSpec{ + {Types: []jpType{jpAny}}, + {Types: []jpType{jpAny}}, }, - ReturnType: []JpType{JpAny}, - Note: "does arithmetic subtraction of two specified values of numbers, quantities, and durations", + Handler: jpSubtract, }, - { - Entry: &gojmespath.FunctionEntry{ - Name: multiply, - Arguments: []ArgSpec{ - {Types: []JpType{JpAny}}, - {Types: []JpType{JpAny}}, - }, - Handler: jpMultiply, + ReturnType: []jpType{jpAny}, + Note: "does arithmetic subtraction of two specified values of numbers, quantities, and durations", + }, { + FunctionEntry: gojmespath.FunctionEntry{ + Name: multiply, + Arguments: []argSpec{ + {Types: []jpType{jpAny}}, + {Types: []jpType{jpAny}}, }, - ReturnType: []JpType{JpAny}, - Note: "does arithmetic multiplication of two specified values of numbers, quantities, and durations", + Handler: jpMultiply, }, - { - Entry: &gojmespath.FunctionEntry{ - Name: divide, - Arguments: []ArgSpec{ - {Types: []JpType{JpAny}}, - {Types: []JpType{JpAny}}, - }, - Handler: jpDivide, + ReturnType: []jpType{jpAny}, + Note: "does arithmetic multiplication of two specified values of numbers, quantities, and durations", + }, { + FunctionEntry: gojmespath.FunctionEntry{ + Name: divide, + Arguments: []argSpec{ + {Types: []jpType{jpAny}}, + {Types: []jpType{jpAny}}, }, - ReturnType: []JpType{JpAny}, - Note: "divisor must be non zero", + Handler: jpDivide, }, - { - Entry: &gojmespath.FunctionEntry{ - Name: modulo, - Arguments: []ArgSpec{ - {Types: []JpType{JpAny}}, - {Types: []JpType{JpAny}}, - }, - Handler: jpModulo, + ReturnType: []jpType{jpAny}, + Note: "divisor must be non zero", + }, { + FunctionEntry: gojmespath.FunctionEntry{ + Name: modulo, + Arguments: []argSpec{ + {Types: []jpType{jpAny}}, + {Types: []jpType{jpAny}}, }, - ReturnType: []JpType{JpAny}, - Note: "divisor must be non-zero, arguments must be integers", + Handler: jpModulo, }, - { - Entry: &gojmespath.FunctionEntry{ - Name: base64Decode, - Arguments: []ArgSpec{ - {Types: []JpType{JpString}}, - }, - Handler: jpBase64Decode, + ReturnType: []jpType{jpAny}, + Note: "divisor must be non-zero, arguments must be integers", + }, { + FunctionEntry: gojmespath.FunctionEntry{ + Name: base64Decode, + Arguments: []argSpec{ + {Types: []jpType{jpString}}, }, - ReturnType: []JpType{JpString}, - Note: "decodes a base 64 string", + Handler: jpBase64Decode, }, - { - Entry: &gojmespath.FunctionEntry{ - Name: base64Encode, - Arguments: []ArgSpec{ - {Types: []JpType{JpString}}, - }, - Handler: jpBase64Encode, + ReturnType: []jpType{jpString}, + Note: "decodes a base 64 string", + }, { + FunctionEntry: gojmespath.FunctionEntry{ + Name: base64Encode, + Arguments: []argSpec{ + {Types: []jpType{jpString}}, }, - ReturnType: []JpType{JpString}, - Note: "encodes a regular, plaintext and unencoded string to base64", + Handler: jpBase64Encode, }, - { - Entry: &gojmespath.FunctionEntry{ - Name: timeSince, - Arguments: []ArgSpec{ - {Types: []JpType{JpString}}, - {Types: []JpType{JpString}}, - {Types: []JpType{JpString}}, - }, - Handler: jpTimeSince, + ReturnType: []jpType{jpString}, + Note: "encodes a regular, plaintext and unencoded string to base64", + }, { + FunctionEntry: gojmespath.FunctionEntry{ + Name: timeSince, + Arguments: []argSpec{ + {Types: []jpType{jpString}}, + {Types: []jpType{jpString}}, + {Types: []jpType{jpString}}, }, - ReturnType: []JpType{JpString}, - Note: "calculate the difference between a start and end period of time where the end may either be a static definition or the then-current time", + Handler: jpTimeSince, }, - { - Entry: &gojmespath.FunctionEntry{ - Name: timeNow, - Handler: jpTimeNow, + ReturnType: []jpType{jpString}, + Note: "calculate the difference between a start and end period of time where the end may either be a static definition or the then-current time", + }, { + FunctionEntry: gojmespath.FunctionEntry{ + Name: timeNow, + Handler: jpTimeNow, + }, + ReturnType: []jpType{jpString}, + Note: "returns current time in RFC 3339 format", + }, { + FunctionEntry: gojmespath.FunctionEntry{ + Name: timeNowUtc, + Handler: jpTimeNowUtc, + }, + ReturnType: []jpType{jpString}, + Note: "returns current UTC time in RFC 3339 format", + }, { + FunctionEntry: gojmespath.FunctionEntry{ + Name: pathCanonicalize, + Arguments: []argSpec{ + {Types: []jpType{jpString}}, }, - ReturnType: []JpType{JpString}, - Note: "returns current time in RFC 3339 format", + Handler: jpPathCanonicalize, }, - { - Entry: &gojmespath.FunctionEntry{ - Name: timeNowUtc, - Handler: jpTimeNowUtc, + ReturnType: []jpType{jpString}, + Note: "normalizes or canonicalizes a given path by removing excess slashes", + }, { + FunctionEntry: gojmespath.FunctionEntry{ + Name: truncate, + Arguments: []argSpec{ + {Types: []jpType{jpString}}, + {Types: []jpType{jpNumber}}, }, - ReturnType: []JpType{JpString}, - Note: "returns current UTC time in RFC 3339 format", + Handler: jpTruncate, }, - { - Entry: &gojmespath.FunctionEntry{ - Name: pathCanonicalize, - Arguments: []ArgSpec{ - {Types: []JpType{JpString}}, - }, - Handler: jpPathCanonicalize, + ReturnType: []jpType{jpString}, + Note: "length argument must be enclosed in backticks; ex. \"{{request.object.metadata.name | truncate(@, `9`)}}\"", + }, { + FunctionEntry: gojmespath.FunctionEntry{ + Name: semverCompare, + Arguments: []argSpec{ + {Types: []jpType{jpString}}, + {Types: []jpType{jpString}}, }, - ReturnType: []JpType{JpString}, - Note: "normalizes or canonicalizes a given path by removing excess slashes", + Handler: jpSemverCompare, }, - { - Entry: &gojmespath.FunctionEntry{ - Name: truncate, - Arguments: []ArgSpec{ - {Types: []JpType{JpString}}, - {Types: []JpType{JpNumber}}, - }, - Handler: jpTruncate, + ReturnType: []jpType{jpBool}, + Note: "compares two strings which comply with the semantic versioning schema and outputs a boolean response as to the position of the second relative to the first", + }, { + FunctionEntry: gojmespath.FunctionEntry{ + Name: parseJson, + Arguments: []argSpec{ + {Types: []jpType{jpString}}, }, - ReturnType: []JpType{JpString}, - Note: "length argument must be enclosed in backticks; ex. \"{{request.object.metadata.name | truncate(@, `9`)}}\"", + Handler: jpParseJson, }, - { - Entry: &gojmespath.FunctionEntry{ - Name: semverCompare, - Arguments: []ArgSpec{ - {Types: []JpType{JpString}}, - {Types: []JpType{JpString}}, - }, - Handler: jpSemverCompare, + ReturnType: []jpType{jpAny}, + Note: "decodes a valid JSON encoded string to the appropriate type. Opposite of `to_string` function", + }, { + FunctionEntry: gojmespath.FunctionEntry{ + Name: parseYAML, + Arguments: []argSpec{ + {Types: []jpType{jpString}}, }, - ReturnType: []JpType{JpBool}, - Note: "compares two strings which comply with the semantic versioning schema and outputs a boolean response as to the position of the second relative to the first", + Handler: jpParseYAML, }, - { - Entry: &gojmespath.FunctionEntry{ - Name: parseJson, - Arguments: []ArgSpec{ - {Types: []JpType{JpString}}, - }, - Handler: jpParseJson, + ReturnType: []jpType{jpAny}, + Note: "decodes a valid YAML encoded string to the appropriate type provided it can be represented as JSON", + }, { + FunctionEntry: gojmespath.FunctionEntry{ + Name: items, + Arguments: []argSpec{ + {Types: []jpType{jpObject, jpArray}}, + {Types: []jpType{jpString}}, + {Types: []jpType{jpString}}, }, - ReturnType: []JpType{JpAny}, - Note: "decodes a valid JSON encoded string to the appropriate type. Opposite of `to_string` function", + Handler: jpItems, }, - { - Entry: &gojmespath.FunctionEntry{ - Name: parseYAML, - Arguments: []ArgSpec{ - {Types: []JpType{JpString}}, - }, - Handler: jpParseYAML, + ReturnType: []jpType{jpArray}, + Note: "converts a map or array to an array of objects where each key:value is an item in the array", + }, { + FunctionEntry: gojmespath.FunctionEntry{ + Name: objectFromLists, + Arguments: []argSpec{ + {Types: []jpType{jpArray}}, + {Types: []jpType{jpArray}}, }, - ReturnType: []JpType{JpAny}, - Note: "decodes a valid YAML encoded string to the appropriate type provided it can be represented as JSON", + Handler: jpObjectFromLists, }, - { - Entry: &gojmespath.FunctionEntry{ - Name: items, - Arguments: []ArgSpec{ - {Types: []JpType{JpObject, JpArray}}, - {Types: []JpType{JpString}}, - {Types: []JpType{JpString}}, - }, - Handler: jpItems, + ReturnType: []jpType{jpObject}, + Note: "converts a pair of lists containing keys and values to an object", + }, { + FunctionEntry: gojmespath.FunctionEntry{ + Name: random, + Arguments: []argSpec{ + {Types: []jpType{jpString}}, }, - ReturnType: []JpType{JpArray}, - Note: "converts a map or array to an array of objects where each key:value is an item in the array", + Handler: jpRandom, }, - { - Entry: &gojmespath.FunctionEntry{ - Name: objectFromLists, - Arguments: []ArgSpec{ - {Types: []JpType{JpArray}}, - {Types: []JpType{JpArray}}, - }, - Handler: jpObjectFromLists, + ReturnType: []jpType{jpString}, + Note: "Generates a random sequence of characters", + }, { + FunctionEntry: gojmespath.FunctionEntry{ + Name: x509_decode, + Arguments: []argSpec{ + {Types: []jpType{jpString}}, }, - ReturnType: []JpType{JpObject}, - Note: "converts a pair of lists containing keys and values to an object", + Handler: jpX509Decode, }, - { - Entry: &gojmespath.FunctionEntry{ - Name: random, - Arguments: []ArgSpec{ - {Types: []JpType{JpString}}, - }, - Handler: jpRandom, + ReturnType: []jpType{jpObject}, + Note: "decodes an x.509 certificate to an object. you may also use this in conjunction with `base64_decode` jmespath function to decode a base64-encoded certificate", + }, { + FunctionEntry: gojmespath.FunctionEntry{ + Name: timeToCron, + Arguments: []argSpec{ + {Types: []jpType{jpString}}, }, - ReturnType: []JpType{JpString}, - Note: "Generates a random sequence of characters", + Handler: jpTimeToCron, }, - { - Entry: &gojmespath.FunctionEntry{ - Name: x509_decode, - Arguments: []ArgSpec{ - {Types: []JpType{JpString}}, - }, - Handler: jpX509Decode, + ReturnType: []jpType{jpString}, + Note: "converts a time (RFC 3339) to a cron expression (string).", + }, { + FunctionEntry: gojmespath.FunctionEntry{ + Name: timeAdd, + Arguments: []argSpec{ + {Types: []jpType{jpString}}, + {Types: []jpType{jpString}}, }, - ReturnType: []JpType{JpObject}, - Note: "decodes an x.509 certificate to an object. you may also use this in conjunction with `base64_decode` jmespath function to decode a base64-encoded certificate", + Handler: jpTimeAdd, }, - { - Entry: &gojmespath.FunctionEntry{ - Name: timeToCron, - Arguments: []ArgSpec{ - {Types: []JpType{JpString}}, - }, - Handler: jpTimeToCron, + ReturnType: []jpType{jpString}, + Note: "adds duration (second string) to a time value (first string)", + }, { + FunctionEntry: gojmespath.FunctionEntry{ + Name: timeParse, + Arguments: []argSpec{ + {Types: []jpType{jpString}}, + {Types: []jpType{jpString}}, }, - ReturnType: []JpType{JpString}, - Note: "converts a time (RFC 3339) to a cron expression (string).", + Handler: jpTimeParse, }, - { - Entry: &gojmespath.FunctionEntry{ - Name: timeAdd, - Arguments: []ArgSpec{ - {Types: []JpType{JpString}}, - {Types: []JpType{JpString}}, - }, - Handler: jpTimeAdd, + ReturnType: []jpType{jpString}, + Note: "changes a time value of a given layout to RFC 3339", + }, { + FunctionEntry: gojmespath.FunctionEntry{ + Name: timeUtc, + Arguments: []argSpec{ + {Types: []jpType{jpString}}, }, - ReturnType: []JpType{JpString}, - Note: "adds duration (second string) to a time value (first string)", + Handler: jpTimeUtc, }, - { - Entry: &gojmespath.FunctionEntry{ - Name: timeParse, - Arguments: []ArgSpec{ - {Types: []JpType{JpString}}, - {Types: []JpType{JpString}}, - }, - Handler: jpTimeParse, + ReturnType: []jpType{jpString}, + Note: "calcutes time in UTC from a given time in RFC 3339 format", + }, { + FunctionEntry: gojmespath.FunctionEntry{ + Name: timeDiff, + Arguments: []argSpec{ + {Types: []jpType{jpString}}, + {Types: []jpType{jpString}}, }, - ReturnType: []JpType{JpString}, - Note: "changes a time value of a given layout to RFC 3339", + Handler: jpTimeDiff, }, - { - Entry: &gojmespath.FunctionEntry{ - Name: timeUtc, - Arguments: []ArgSpec{ - {Types: []JpType{JpString}}, - }, - Handler: jpTimeUtc, + ReturnType: []jpType{jpString}, + Note: "calculate the difference between a start and end date in RFC3339 format", + }, { + FunctionEntry: gojmespath.FunctionEntry{ + Name: timeBefore, + Arguments: []argSpec{ + {Types: []jpType{jpString}}, + {Types: []jpType{jpString}}, }, - ReturnType: []JpType{JpString}, - Note: "calcutes time in UTC from a given time in RFC 3339 format", + Handler: jpTimeBefore, }, - { - Entry: &gojmespath.FunctionEntry{ - Name: timeDiff, - Arguments: []ArgSpec{ - {Types: []JpType{JpString}}, - {Types: []JpType{JpString}}, - }, - Handler: jpTimeDiff, + ReturnType: []jpType{jpBool}, + Note: "checks if a time is before another time, both in RFC3339 format", + }, { + FunctionEntry: gojmespath.FunctionEntry{ + Name: timeAfter, + Arguments: []argSpec{ + {Types: []jpType{jpString}}, + {Types: []jpType{jpString}}, }, - ReturnType: []JpType{JpString}, - Note: "calculate the difference between a start and end date in RFC3339 format", + Handler: jpTimeAfter, }, - { - Entry: &gojmespath.FunctionEntry{ - Name: timeBefore, - Arguments: []ArgSpec{ - {Types: []JpType{JpString}}, - {Types: []JpType{JpString}}, - }, - Handler: jpTimeBefore, + ReturnType: []jpType{jpBool}, + Note: "checks if a time is after another time, both in RFC3339 format", + }, { + FunctionEntry: gojmespath.FunctionEntry{ + Name: timeBetween, + Arguments: []argSpec{ + {Types: []jpType{jpString}}, + {Types: []jpType{jpString}}, + {Types: []jpType{jpString}}, }, - ReturnType: []JpType{JpBool}, - Note: "checks if a time is before another time, both in RFC3339 format", + Handler: jpTimeBetween, }, - { - Entry: &gojmespath.FunctionEntry{ - Name: timeAfter, - Arguments: []ArgSpec{ - {Types: []JpType{JpString}}, - {Types: []JpType{JpString}}, - }, - Handler: jpTimeAfter, + ReturnType: []jpType{jpBool}, + Note: "checks if a time is between a start and end time, all in RFC3339 format", + }, { + FunctionEntry: gojmespath.FunctionEntry{ + Name: timeTruncate, + Arguments: []argSpec{ + {Types: []jpType{jpString}}, + {Types: []jpType{jpString}}, }, - ReturnType: []JpType{JpBool}, - Note: "checks if a time is after another time, both in RFC3339 format", + Handler: jpTimeTruncate, }, - { - Entry: &gojmespath.FunctionEntry{ - Name: timeBetween, - Arguments: []ArgSpec{ - {Types: []JpType{JpString}}, - {Types: []JpType{JpString}}, - {Types: []JpType{JpString}}, - }, - Handler: jpTimeBetween, - }, - ReturnType: []JpType{JpBool}, - Note: "checks if a time is between a start and end time, all in RFC3339 format", - }, - { - Entry: &gojmespath.FunctionEntry{ - Name: timeTruncate, - Arguments: []ArgSpec{ - {Types: []JpType{JpString}}, - {Types: []JpType{JpString}}, - }, - Handler: jpTimeTruncate, - }, - ReturnType: []JpType{JpString}, - Note: "returns the result of rounding time down to a multiple of duration", - }, - } + ReturnType: []jpType{jpString}, + Note: "returns the result of rounding time down to a multiple of duration", + }} } func jpfCompare(arguments []interface{}) (interface{}, error) { @@ -638,43 +555,31 @@ func jpfReplace(arguments []interface{}) (interface{}, error) { } func jpfReplaceAll(arguments []interface{}) (interface{}, error) { - var err error - str, err := validateArg(replaceAll, arguments, 0, reflect.String) - if err != nil { + if str, err := validateArg(replaceAll, arguments, 0, reflect.String); err != nil { return nil, err - } - - old, err := validateArg(replaceAll, arguments, 1, reflect.String) - if err != nil { + } else if old, err := validateArg(replaceAll, arguments, 1, reflect.String); err != nil { return nil, err - } - - new, err := validateArg(replaceAll, arguments, 2, reflect.String) - if err != nil { + } else if new, err := validateArg(replaceAll, arguments, 2, reflect.String); err != nil { return nil, err + } else { + return strings.ReplaceAll(str.String(), old.String(), new.String()), nil } - - return strings.ReplaceAll(str.String(), old.String(), new.String()), nil } func jpfToUpper(arguments []interface{}) (interface{}, error) { - var err error - str, err := validateArg(toUpper, arguments, 0, reflect.String) - if err != nil { + if str, err := validateArg(toUpper, arguments, 0, reflect.String); err != nil { return nil, err + } else { + return strings.ToUpper(str.String()), nil } - - return strings.ToUpper(str.String()), nil } func jpfToLower(arguments []interface{}) (interface{}, error) { - var err error - str, err := validateArg(toLower, arguments, 0, reflect.String) - if err != nil { + if str, err := validateArg(toLower, arguments, 0, reflect.String); err != nil { return nil, err + } else { + return strings.ToLower(str.String()), nil } - - return strings.ToLower(str.String()), nil } func jpfTrim(arguments []interface{}) (interface{}, error) { @@ -1046,14 +951,6 @@ func ifaceToString(iface interface{}) (string, error) { } } -func validateArg(f string, arguments []interface{}, index int, expectedType reflect.Kind) (reflect.Value, error) { - arg := reflect.ValueOf(arguments[index]) - if arg.Type().Kind() != expectedType { - return reflect.Value{}, fmt.Errorf(invalidArgumentTypeError, f, index+1, expectedType.String()) - } - return arg, nil -} - func jpRandom(arguments []interface{}) (interface{}, error) { pattern := arguments[0].(string) if pattern == "" { diff --git a/pkg/engine/jmespath/functions_test.go b/pkg/engine/jmespath/functions_test.go index a8c2f3a0b6..9769ada5cd 100644 --- a/pkg/engine/jmespath/functions_test.go +++ b/pkg/engine/jmespath/functions_test.go @@ -1480,36 +1480,28 @@ UFOZZVoELaasWS559wy8og39Eq21dDMynb8Bndn/ testCases := []struct { jmesPath string expectedResult map[string]interface{} - }{ - { - jmesPath: "x509_decode(base64_decode('" + certs[0] + "'))", - expectedResult: resExpected[0], - }, - { - jmesPath: "x509_decode(base64_decode('" + certs[1] + "'))", - expectedResult: resExpected[1], - }, - { - jmesPath: "x509_decode('" + certs[2] + "')", - expectedResult: resExpected[0], - }, - { - jmesPath: "x509_decode('" + certs[3] + "')", - expectedResult: resExpected[1], - }, - { - jmesPath: "x509_decode('" + certs[4] + "')", - expectedResult: resExpected[0], - }, - { - jmesPath: "x509_decode('" + certs[5] + "')", - expectedResult: resExpected[1], - }, - { - jmesPath: "x509_decode('xyz')", - expectedResult: map[string]interface{}{}, - }, - } + }{{ + jmesPath: "x509_decode(base64_decode('" + certs[0] + "'))", + expectedResult: resExpected[0], + }, { + jmesPath: "x509_decode(base64_decode('" + certs[1] + "'))", + expectedResult: resExpected[1], + }, { + jmesPath: "x509_decode('" + certs[2] + "')", + expectedResult: resExpected[0], + }, { + jmesPath: "x509_decode('" + certs[3] + "')", + expectedResult: resExpected[1], + }, { + jmesPath: "x509_decode('" + certs[4] + "')", + expectedResult: resExpected[0], + }, { + jmesPath: "x509_decode('" + certs[5] + "')", + expectedResult: resExpected[1], + }, { + jmesPath: "x509_decode('xyz')", + expectedResult: map[string]interface{}{}, + }} for _, tc := range testCases { t.Run(tc.jmesPath, func(t *testing.T) { jp, err := New(tc.jmesPath) @@ -1536,38 +1528,32 @@ func Test_jpfCompare(t *testing.T) { args args want interface{} wantErr bool - }{ - { - args: args{ - arguments: []interface{}{"a", "b"}, - }, - want: -1, + }{{ + args: args{ + arguments: []interface{}{"a", "b"}, }, - { - args: args{ - arguments: []interface{}{"b", "a"}, - }, - want: 1, + want: -1, + }, { + args: args{ + arguments: []interface{}{"b", "a"}, }, - { - args: args{ - arguments: []interface{}{"b", "b"}, - }, - want: 0, + want: 1, + }, { + args: args{ + arguments: []interface{}{"b", "b"}, }, - { - args: args{ - arguments: []interface{}{1, "b"}, - }, - wantErr: true, + want: 0, + }, { + args: args{ + arguments: []interface{}{1, "b"}, }, - { - args: args{ - arguments: []interface{}{"a", 1}, - }, - wantErr: true, + wantErr: true, + }, { + args: args{ + arguments: []interface{}{"a", 1}, }, - } + wantErr: true, + }} for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { got, err := jpfCompare(tt.args.arguments) @@ -1591,32 +1577,27 @@ func Test_jpfEqualFold(t *testing.T) { args args want interface{} wantErr bool - }{ - { - args: args{ - arguments: []interface{}{"Go", "go"}, - }, - want: true, + }{{ + args: args{ + arguments: []interface{}{"Go", "go"}, }, - { - args: args{ - arguments: []interface{}{"a", "b"}, - }, - want: false, + want: true, + }, { + args: args{ + arguments: []interface{}{"a", "b"}, }, - { - args: args{ - arguments: []interface{}{1, "b"}, - }, - wantErr: true, + want: false, + }, { + args: args{ + arguments: []interface{}{1, "b"}, }, - { - args: args{ - arguments: []interface{}{"a", 1}, - }, - wantErr: true, + wantErr: true, + }, { + args: args{ + arguments: []interface{}{"a", 1}, }, - } + wantErr: true, + }} for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { got, err := jpfEqualFold(tt.args.arguments) @@ -1640,85 +1621,77 @@ func Test_jpfReplace(t *testing.T) { args args want interface{} wantErr bool - }{ - { - args: args{ - arguments: []interface{}{ - "Lorem ipsum dolor sit amet", - "ipsum", - "muspi", - -1.0, - }, + }{{ + args: args{ + arguments: []interface{}{ + "Lorem ipsum dolor sit amet", + "ipsum", + "muspi", + -1.0, }, - want: "Lorem muspi dolor sit amet", }, - { - args: args{ - arguments: []interface{}{ - "Lorem ipsum ipsum ipsum dolor sit amet", - "ipsum", - "muspi", - -1.0, - }, + want: "Lorem muspi dolor sit amet", + }, { + args: args{ + arguments: []interface{}{ + "Lorem ipsum ipsum ipsum dolor sit amet", + "ipsum", + "muspi", + -1.0, }, - want: "Lorem muspi muspi muspi dolor sit amet", }, - { - args: args{ - arguments: []interface{}{ - "Lorem ipsum ipsum ipsum dolor sit amet", - "ipsum", - "muspi", - 1.0, - }, + want: "Lorem muspi muspi muspi dolor sit amet", + }, { + args: args{ + arguments: []interface{}{ + "Lorem ipsum ipsum ipsum dolor sit amet", + "ipsum", + "muspi", + 1.0, }, - want: "Lorem muspi ipsum ipsum dolor sit amet", }, - { - args: args{ - arguments: []interface{}{ - 1.0, - "ipsum", - "muspi", - 1.0, - }, + want: "Lorem muspi ipsum ipsum dolor sit amet", + }, { + args: args{ + arguments: []interface{}{ + 1.0, + "ipsum", + "muspi", + 1.0, }, - wantErr: true, }, - { - args: args{ - arguments: []interface{}{ - "Lorem ipsum ipsum ipsum dolor sit amet", - 1.0, - "muspi", - 1.0, - }, + wantErr: true, + }, { + args: args{ + arguments: []interface{}{ + "Lorem ipsum ipsum ipsum dolor sit amet", + 1.0, + "muspi", + 1.0, }, - wantErr: true, }, - { - args: args{ - arguments: []interface{}{ - "Lorem ipsum ipsum ipsum dolor sit amet", - "ipsum", - false, - 1.0, - }, + wantErr: true, + }, { + args: args{ + arguments: []interface{}{ + "Lorem ipsum ipsum ipsum dolor sit amet", + "ipsum", + false, + 1.0, }, - wantErr: true, }, - { - args: args{ - arguments: []interface{}{ - "Lorem ipsum ipsum ipsum dolor sit amet", - "ipsum", - "muspi", - true, - }, + wantErr: true, + }, { + args: args{ + arguments: []interface{}{ + "Lorem ipsum ipsum ipsum dolor sit amet", + "ipsum", + "muspi", + true, }, - wantErr: true, }, - } + wantErr: true, + }} for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { got, err := jpfReplace(tt.args.arguments) @@ -1732,3 +1705,176 @@ func Test_jpfReplace(t *testing.T) { }) } } + +func Test_jpfReplaceAll(t *testing.T) { + type args struct { + arguments []interface{} + } + tests := []struct { + name string + args args + want interface{} + wantErr bool + }{{ + args: args{ + arguments: []interface{}{ + "Lorem ipsum dolor sit amet", + "ipsum", + "muspi", + }, + }, + want: "Lorem muspi dolor sit amet", + }, { + args: args{ + arguments: []interface{}{ + "Lorem ipsum ipsum ipsum dolor sit amet", + "ipsum", + "muspi", + }, + }, + want: "Lorem muspi muspi muspi dolor sit amet", + }, { + args: args{ + arguments: []interface{}{ + 1.0, + "ipsum", + "muspi", + }, + }, + wantErr: true, + }, { + args: args{ + arguments: []interface{}{ + "Lorem ipsum ipsum ipsum dolor sit amet", + 1.0, + "muspi", + }, + }, + wantErr: true, + }, { + args: args{ + arguments: []interface{}{ + "Lorem ipsum ipsum ipsum dolor sit amet", + "ipsum", + false, + }, + }, + wantErr: true, + }} + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got, err := jpfReplaceAll(tt.args.arguments) + if (err != nil) != tt.wantErr { + t.Errorf("jpfReplaceAll() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("jpfReplaceAll() = %v, want %v", got, tt.want) + } + }) + } +} + +func Test_jpfToUpper(t *testing.T) { + type args struct { + arguments []interface{} + } + tests := []struct { + name string + args args + want interface{} + wantErr bool + }{{ + args: args{ + arguments: []interface{}{ + "abc", + }, + }, + want: "ABC", + }, { + args: args{ + arguments: []interface{}{ + "123", + }, + }, + want: "123", + }, { + args: args{ + arguments: []interface{}{ + "a#%&123Bc", + }, + }, + want: "A#%&123BC", + }, { + args: args{ + arguments: []interface{}{ + 32.0, + }, + }, + wantErr: true, + }} + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got, err := jpfToUpper(tt.args.arguments) + if (err != nil) != tt.wantErr { + t.Errorf("jpfToUpper() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("jpfToUpper() = %v, want %v", got, tt.want) + } + }) + } +} + +func Test_jpfToLower(t *testing.T) { + type args struct { + arguments []interface{} + } + tests := []struct { + name string + args args + want interface{} + wantErr bool + }{{ + args: args{ + arguments: []interface{}{ + "ABC", + }, + }, + want: "abc", + }, { + args: args{ + arguments: []interface{}{ + "123", + }, + }, + want: "123", + }, { + args: args{ + arguments: []interface{}{ + "A#%&123BC", + }, + }, + want: "a#%&123bc", + }, { + args: args{ + arguments: []interface{}{ + 32.0, + }, + }, + wantErr: true, + }} + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got, err := jpfToLower(tt.args.arguments) + if (err != nil) != tt.wantErr { + t.Errorf("jpfToLower() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("jpfToLower() = %v, want %v", got, tt.want) + } + }) + } +} diff --git a/pkg/engine/jmespath/new.go b/pkg/engine/jmespath/new.go index 96a51225a0..d60c08207d 100644 --- a/pkg/engine/jmespath/new.go +++ b/pkg/engine/jmespath/new.go @@ -10,7 +10,7 @@ func New(query string) (*gojmespath.JMESPath, error) { return nil, err } for _, function := range GetFunctions() { - jp.Register(function.Entry) + jp.Register(&function.FunctionEntry) } return jp, nil } diff --git a/pkg/engine/jmespath/utils.go b/pkg/engine/jmespath/utils.go new file mode 100644 index 0000000000..e28fad7c4a --- /dev/null +++ b/pkg/engine/jmespath/utils.go @@ -0,0 +1,14 @@ +package jmespath + +import ( + "fmt" + "reflect" +) + +func validateArg(f string, arguments []interface{}, index int, expectedType reflect.Kind) (reflect.Value, error) { + arg := reflect.ValueOf(arguments[index]) + if arg.Type().Kind() != expectedType { + return reflect.Value{}, fmt.Errorf(invalidArgumentTypeError, f, index+1, expectedType.String()) + } + return arg, nil +}