mirrors/kyverno
mirrors/kyverno
1
0
Fork 0
mirror of https://github.com/kyverno/kyverno.git synced 2025-03-30 19:35:06 +00:00
Code Activity

test: add a couple unit tests (#6202)

Browse source 
* test: add a couple unit tests

Signed-off-by: Charles-Edouard Brétéché <charles.edouard@nirmata.com>

* more

Signed-off-by: Charles-Edouard Brétéché <charles.edouard@nirmata.com>

---------

Signed-off-by: Charles-Edouard Brétéché <charles.edouard@nirmata.com>
This commit is contained in:
Charles-Edouard Brétéché 2023-02-03 06:37:31 +01:00 • committed by GitHub
parent 6c0549febe
commit 376378fd09
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
4 changed files with 256 additions and 37 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

49
pkg/engine/jmespath/functions.go
View file

@ -604,58 +604,37 @@ func GetFunctions() []*FunctionEntry {
}
func jpfCompare(arguments []interface{}) (interface{}, error) {
var err error
a, err := validateArg(compare, arguments, 0, reflect.String)
if err != nil {
if a, err := validateArg(compare, arguments, 0, reflect.String); err != nil {
return nil, err
}
b, err := validateArg(compare, arguments, 1, reflect.String)
if err != nil {
} else if b, err := validateArg(compare, arguments, 1, reflect.String); err != nil {
return nil, err
} else {
return strings.Compare(a.String(), b.String()), nil
}
return strings.Compare(a.String(), b.String()), nil
}
func jpfEqualFold(arguments []interface{}) (interface{}, error) {
var err error
a, err := validateArg(equalFold, arguments, 0, reflect.String)
if err != nil {
if a, err := validateArg(equalFold, arguments, 0, reflect.String); err != nil {
return nil, err
}
b, err := validateArg(equalFold, arguments, 1, reflect.String)
if err != nil {
} else if b, err := validateArg(equalFold, arguments, 1, reflect.String); err != nil {
return nil, err
} else {
return strings.EqualFold(a.String(), b.String()), nil
}
return strings.EqualFold(a.String(), b.String()), nil
}
func jpfReplace(arguments []interface{}) (interface{}, error) {
var err error
str, err := validateArg(replace, arguments, 0, reflect.String)
if err != nil {
if str, err := validateArg(replace, arguments, 0, reflect.String); err != nil {
return nil, err
}
old, err := validateArg(replace, arguments, 1, reflect.String)
if err != nil {
} else if old, err := validateArg(replace, arguments, 1, reflect.String); err != nil {
return nil, err
}
new, err := validateArg(replace, arguments, 2, reflect.String)
if err != nil {
} else if new, err := validateArg(replace, arguments, 2, reflect.String); err != nil {
return nil, err
}
n, err := validateArg(replace, arguments, 3, reflect.Float64)
if err != nil {
} else if n, err := validateArg(replace, arguments, 3, reflect.Float64); err != nil {
return nil, err
} else {
return strings.Replace(str.String(), old.String(), new.String(), int(n.Float())), nil
}
return strings.Replace(str.String(), old.String(), new.String(), int(n.Float())), nil
}
func jpfReplaceAll(arguments []interface{}) (interface{}, error) {

207
pkg/engine/jmespath/functions_test.go
View file

@ -3,6 +3,7 @@ package jmespath
import (
"encoding/json"
"fmt"
"reflect"
"runtime"
"testing"
@ -1525,3 +1526,209 @@ UFOZZVoELaasWS559wy8og39Eq21dDMynb8Bndn/
})
}
}
func Test_jpfCompare(t *testing.T) {
type args struct {
arguments []interface{}
}
tests := []struct {
name string
args args
want interface{}
wantErr bool
}{
{
args: args{
arguments: []interface{}{"a", "b"},
},
want: -1,
},
{
args: args{
arguments: []interface{}{"b", "a"},
},
want: 1,
},
{
args: args{
arguments: []interface{}{"b", "b"},
},
want: 0,
},
{
args: args{
arguments: []interface{}{1, "b"},
},
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)
if (err != nil) != tt.wantErr {
t.Errorf("jpfCompare() error = %v, wantErr %v", err, tt.wantErr)
return
}
if !reflect.DeepEqual(got, tt.want) {
t.Errorf("jpfCompare() = %v, want %v", got, tt.want)
}
})
}
}
func Test_jpfEqualFold(t *testing.T) {
type args struct {
arguments []interface{}
}
tests := []struct {
name string
args args
want interface{}
wantErr bool
}{
{
args: args{
arguments: []interface{}{"Go", "go"},
},
want: true,
},
{
args: args{
arguments: []interface{}{"a", "b"},
},
want: false,
},
{
args: args{
arguments: []interface{}{1, "b"},
},
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)
if (err != nil) != tt.wantErr {
t.Errorf("jpfEqualFold() error = %v, wantErr %v", err, tt.wantErr)
return
}
if !reflect.DeepEqual(got, tt.want) {
t.Errorf("jpfEqualFold() = %v, want %v", got, tt.want)
}
})
}
}
func Test_jpfReplace(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",
-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 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",
"ipsum",
false,
1.0,
},
},
wantErr: true,
},
{
args: args{
arguments: []interface{}{
"Lorem ipsum ipsum ipsum dolor sit amet",
"ipsum",
"muspi",
true,
},
},
wantErr: true,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got, err := jpfReplace(tt.args.arguments)
if (err != nil) != tt.wantErr {
t.Errorf("jpfReplace() error = %v, wantErr %v", err, tt.wantErr)
return
}
if !reflect.DeepEqual(got, tt.want) {
t.Errorf("jpfReplace() = %v, want %v", got, tt.want)
}
})
}
}

2
pkg/engine/jmespath/new.go
View file

@ -9,10 +9,8 @@ func New(query string) (*gojmespath.JMESPath, error) {
if err != nil {
return nil, err
}
for _, function := range GetFunctions() {
jp.Register(function.Entry)
}
return jp, nil
}

35
pkg/engine/jmespath/new_test.go Normal file
View file

@ -0,0 +1,35 @@
package jmespath
import (
"testing"
)
func TestNew(t *testing.T) {
type args struct {
query string
}
tests := []struct {
name string
args args
wantErr bool
}{
{
wantErr: true,
},
{
args: args{
query: "object.something",
},
wantErr: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
_, err := New(tt.args.query)
if (err != nil) != tt.wantErr {
t.Errorf("New() error = %v, wantErr %v", err, tt.wantErr)
return
}
})
}
}