mirror of
https://github.com/kyverno/kyverno.git
synced 2024-12-14 11:57:48 +00:00
c92605b7a6
* fix: abort validation if value could be processed Signed-off-by: bakito <github@bakito.ch> * add test to verify compareString is not executed for quantities Signed-off-by: bakito <github@bakito.ch> --------- Signed-off-by: bakito <github@bakito.ch>
918 lines
19 KiB
Go
918 lines
19 KiB
Go
package pattern
|
|
|
|
import (
|
|
"regexp"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/go-logr/logr"
|
|
"github.com/go-logr/logr/funcr"
|
|
"github.com/kyverno/kyverno/pkg/engine/operator"
|
|
"gotest.tools/assert"
|
|
)
|
|
|
|
func TestValidateValueWithFloatPattern_FloatValue(t *testing.T) {
|
|
assert.Assert(t, validateFloatPattern(logr.Discard(), 7.9914, 7.9914))
|
|
}
|
|
|
|
func TestValidateValueWithFloatPattern_FloatValueNotPass(t *testing.T) {
|
|
assert.Assert(t, !validateFloatPattern(logr.Discard(), 7.9914, 7.99141))
|
|
}
|
|
|
|
func TestValidateValueWithFloatPattern_FloatPatternWithoutFractionIntValue(t *testing.T) {
|
|
assert.Assert(t, validateFloatPattern(logr.Discard(), 7, 7.000000))
|
|
}
|
|
|
|
func TestValidateValueWithFloatPattern_FloatPatternWithoutFraction(t *testing.T) {
|
|
assert.Assert(t, validateFloatPattern(logr.Discard(), 7.000000, 7.000000))
|
|
}
|
|
|
|
func TestValidateValueWithIntPattern_FloatValueWithoutFraction(t *testing.T) {
|
|
assert.Assert(t, validateFloatPattern(logr.Discard(), 7.000000, 7))
|
|
}
|
|
|
|
func TestValidateValueWithIntPattern_FloatValueWitFraction(t *testing.T) {
|
|
assert.Assert(t, !validateFloatPattern(logr.Discard(), 7.000001, 7))
|
|
}
|
|
|
|
func TestValidateValueWithIntPattern_NotPass(t *testing.T) {
|
|
assert.Assert(t, !validateFloatPattern(logr.Discard(), 8, 7))
|
|
}
|
|
|
|
func TestValidateValueWithStringPattern_WithSpace(t *testing.T) {
|
|
assert.Assert(t, validateStringPattern(logr.Discard(), 4, ">= 3"))
|
|
}
|
|
|
|
func TestValidateValueWithStringPattern_Ranges(t *testing.T) {
|
|
assert.Assert(t, validateStringPattern(logr.Discard(), 0, "0-2"))
|
|
assert.Assert(t, validateStringPattern(logr.Discard(), 1, "0-2"))
|
|
assert.Assert(t, validateStringPattern(logr.Discard(), 2, "0-2"))
|
|
assert.Assert(t, !validateStringPattern(logr.Discard(), 3, "0-2"))
|
|
|
|
assert.Assert(t, validateStringPattern(logr.Discard(), 0, "10!-20"))
|
|
assert.Assert(t, !validateStringPattern(logr.Discard(), 15, "10!-20"))
|
|
assert.Assert(t, validateStringPattern(logr.Discard(), 25, "10!-20"))
|
|
|
|
assert.Assert(t, !validateStringPattern(logr.Discard(), 0, "0.00001-2.00001"))
|
|
assert.Assert(t, validateStringPattern(logr.Discard(), 1, "0.00001-2.00001"))
|
|
assert.Assert(t, validateStringPattern(logr.Discard(), 2, "0.00001-2.00001"))
|
|
assert.Assert(t, !validateStringPattern(logr.Discard(), 2.0001, "0.00001-2.00001"))
|
|
|
|
assert.Assert(t, validateStringPattern(logr.Discard(), 0, "0.00001!-2.00001"))
|
|
assert.Assert(t, !validateStringPattern(logr.Discard(), 1, "0.00001!-2.00001"))
|
|
assert.Assert(t, !validateStringPattern(logr.Discard(), 2, "0.00001!-2.00001"))
|
|
assert.Assert(t, validateStringPattern(logr.Discard(), 2.0001, "0.00001!-2.00001"))
|
|
|
|
assert.Assert(t, validateStringPattern(logr.Discard(), 2, "2-2"))
|
|
assert.Assert(t, !validateStringPattern(logr.Discard(), 2, "2!-2"))
|
|
|
|
assert.Assert(t, validateStringPattern(logr.Discard(), 2.99999, "2.99998-3"))
|
|
assert.Assert(t, validateStringPattern(logr.Discard(), 2.99997, "2.99998!-3"))
|
|
assert.Assert(t, validateStringPattern(logr.Discard(), 3.00001, "2.99998!-3"))
|
|
|
|
assert.Assert(t, validateStringPattern(logr.Discard(), "256Mi", "128Mi-512Mi"))
|
|
assert.Assert(t, !validateStringPattern(logr.Discard(), "1024Mi", "128Mi-512Mi"))
|
|
assert.Assert(t, !validateStringPattern(logr.Discard(), "64Mi", "128Mi-512Mi"))
|
|
|
|
assert.Assert(t, !validateStringPattern(logr.Discard(), "256Mi", "128Mi!-512Mi"))
|
|
assert.Assert(t, validateStringPattern(logr.Discard(), "1024Mi", "128Mi!-512Mi"))
|
|
assert.Assert(t, validateStringPattern(logr.Discard(), "64Mi", "128Mi!-512Mi"))
|
|
|
|
assert.Assert(t, validateStringPattern(logr.Discard(), -9, "-10-8"))
|
|
assert.Assert(t, !validateStringPattern(logr.Discard(), 9, "-10--8"))
|
|
|
|
assert.Assert(t, validateStringPattern(logr.Discard(), 9, "-10!--8"))
|
|
assert.Assert(t, validateStringPattern(logr.Discard(), "9Mi", "-10Mi!--8Mi"))
|
|
|
|
assert.Assert(t, !validateStringPattern(logr.Discard(), -9, "-10!--8"))
|
|
|
|
assert.Assert(t, validateStringPattern(logr.Discard(), "-9Mi", "-10Mi-8Mi"))
|
|
assert.Assert(t, validateStringPattern(logr.Discard(), "9Mi", "-10Mi!-8Mi"))
|
|
|
|
assert.Assert(t, validateStringPattern(logr.Discard(), 0, "-10-+8"))
|
|
assert.Assert(t, validateStringPattern(logr.Discard(), "7Mi", "-10Mi-+8Mi"))
|
|
|
|
assert.Assert(t, validateStringPattern(logr.Discard(), 10, "-10!-+8"))
|
|
assert.Assert(t, validateStringPattern(logr.Discard(), "10Mi", "-10Mi!-+8Mi"))
|
|
|
|
assert.Assert(t, validateStringPattern(logr.Discard(), 0, "+0-+1"))
|
|
assert.Assert(t, validateStringPattern(logr.Discard(), "10Mi", "+0Mi-+1024Mi"))
|
|
|
|
assert.Assert(t, validateStringPattern(logr.Discard(), 10, "+0!-+1"))
|
|
assert.Assert(t, validateStringPattern(logr.Discard(), "1025Mi", "+0Mi!-+1024Mi"))
|
|
|
|
}
|
|
|
|
func TestValidateNumberWithStr_LessFloatAndInt(t *testing.T) {
|
|
assert.Assert(t, validateString(logr.Discard(), 7.00001, "7.000001", operator.More))
|
|
assert.Assert(t, validateString(logr.Discard(), 7.00001, "7", operator.NotEqual))
|
|
|
|
assert.Assert(t, validateString(logr.Discard(), 7.0000, "7", operator.Equal))
|
|
assert.Assert(t, !validateString(logr.Discard(), 6.000000001, "6", operator.Less))
|
|
}
|
|
|
|
func TestValidateQuantity_InvalidQuantity(t *testing.T) {
|
|
assert.Assert(t, !validateString(logr.Discard(), "1024Gi", "", operator.Equal))
|
|
assert.Assert(t, !validateString(logr.Discard(), "gii", "1024Gi", operator.Equal))
|
|
}
|
|
|
|
func TestValidateDuration(t *testing.T) {
|
|
assert.Assert(t, validateString(logr.Discard(), "12s", "12s", operator.Equal))
|
|
assert.Assert(t, validateString(logr.Discard(), "12s", "15s", operator.NotEqual))
|
|
assert.Assert(t, validateString(logr.Discard(), "12s", "15s", operator.Less))
|
|
assert.Assert(t, validateString(logr.Discard(), "12s", "15s", operator.LessEqual))
|
|
assert.Assert(t, validateString(logr.Discard(), "12s", "12s", operator.LessEqual))
|
|
assert.Assert(t, !validateString(logr.Discard(), "15s", "12s", operator.Less))
|
|
assert.Assert(t, !validateString(logr.Discard(), "15s", "12s", operator.LessEqual))
|
|
assert.Assert(t, validateString(logr.Discard(), "15s", "12s", operator.More))
|
|
assert.Assert(t, validateString(logr.Discard(), "15s", "12s", operator.MoreEqual))
|
|
assert.Assert(t, validateString(logr.Discard(), "12s", "12s", operator.MoreEqual))
|
|
assert.Assert(t, !validateString(logr.Discard(), "12s", "15s", operator.More))
|
|
assert.Assert(t, !validateString(logr.Discard(), "12s", "15s", operator.MoreEqual))
|
|
}
|
|
|
|
func TestValidateQuantity_Equal(t *testing.T) {
|
|
assert.Assert(t, validateString(logr.Discard(), "1024Gi", "1024Gi", operator.Equal))
|
|
assert.Assert(t, validateString(logr.Discard(), "1024Mi", "1Gi", operator.Equal))
|
|
assert.Assert(t, validateString(logr.Discard(), "0.2", "200m", operator.Equal))
|
|
assert.Assert(t, validateString(logr.Discard(), "500", "500", operator.Equal))
|
|
assert.Assert(t, !validateString(logr.Discard(), "2048", "1024", operator.Equal))
|
|
assert.Assert(t, validateString(logr.Discard(), 1024, "1024", operator.Equal))
|
|
}
|
|
|
|
func TestValidateQuantity_Operation(t *testing.T) {
|
|
assert.Assert(t, validateString(logr.Discard(), "1Gi", "1000Mi", operator.More))
|
|
assert.Assert(t, validateString(logr.Discard(), "1G", "1Gi", operator.Less))
|
|
assert.Assert(t, validateString(logr.Discard(), "500m", "0.5", operator.MoreEqual))
|
|
assert.Assert(t, validateString(logr.Discard(), "1", "500m", operator.MoreEqual))
|
|
assert.Assert(t, validateString(logr.Discard(), "0.5", ".5", operator.LessEqual))
|
|
assert.Assert(t, validateString(logr.Discard(), "0.2", ".5", operator.LessEqual))
|
|
assert.Assert(t, validateString(logr.Discard(), "0.2", ".5", operator.NotEqual))
|
|
}
|
|
|
|
func TestValidateQuantity_Operation_No_String_Check(t *testing.T) {
|
|
log := funcr.New(
|
|
func(prefix, args string) {
|
|
assert.Assert(t, !strings.Contains(args, "Operators >, >=, <, <= are not applicable to strings"),
|
|
"the compareString function should not be executed")
|
|
},
|
|
funcr.Options{Verbosity: 2},
|
|
)
|
|
assert.Assert(t, !validateString(log, "500m", "0.6", operator.MoreEqual))
|
|
}
|
|
|
|
func TestGetOperatorFromStringPattern_OneChar(t *testing.T) {
|
|
assert.Equal(t, operator.GetOperatorFromStringPattern("f"), operator.Equal)
|
|
}
|
|
|
|
func TestGetOperatorFromStringPattern_EmptyString(t *testing.T) {
|
|
assert.Equal(t, operator.GetOperatorFromStringPattern(""), operator.Equal)
|
|
}
|
|
|
|
func TestValidate(t *testing.T) {
|
|
type args struct {
|
|
value interface{}
|
|
pattern interface{}
|
|
}
|
|
tests := []struct {
|
|
name string
|
|
args args
|
|
want bool
|
|
}{{
|
|
args: args{
|
|
value: true,
|
|
pattern: true,
|
|
},
|
|
want: true,
|
|
}, {
|
|
args: args{
|
|
value: true,
|
|
pattern: false,
|
|
},
|
|
want: false,
|
|
}, {
|
|
args: args{
|
|
value: false,
|
|
pattern: true,
|
|
},
|
|
want: false,
|
|
}, {
|
|
args: args{
|
|
value: false,
|
|
pattern: false,
|
|
},
|
|
want: true,
|
|
}, {
|
|
args: args{
|
|
value: "value",
|
|
pattern: nil,
|
|
},
|
|
want: false,
|
|
}, {
|
|
args: args{
|
|
value: "",
|
|
pattern: nil,
|
|
},
|
|
want: true,
|
|
}, {
|
|
args: args{
|
|
value: 0.0,
|
|
pattern: nil,
|
|
},
|
|
want: true,
|
|
}, {
|
|
args: args{
|
|
value: 0,
|
|
pattern: nil,
|
|
},
|
|
want: true,
|
|
}, {
|
|
args: args{
|
|
value: false,
|
|
pattern: nil,
|
|
},
|
|
want: true,
|
|
}, {
|
|
args: args{
|
|
value: "10.100.11.54",
|
|
pattern: "192.168.88.1 | 10.100.11.*",
|
|
},
|
|
want: true,
|
|
}, {
|
|
args: args{
|
|
value: "10",
|
|
pattern: ">1 & <20",
|
|
},
|
|
want: true,
|
|
}, {
|
|
args: args{
|
|
value: "10",
|
|
pattern: ">1 & <20 | >31 & <33",
|
|
},
|
|
want: true,
|
|
}, {
|
|
args: args{
|
|
value: "32",
|
|
pattern: ">1 & <20 | >31 & <33",
|
|
},
|
|
want: true,
|
|
}, {
|
|
args: args{
|
|
value: "21",
|
|
pattern: ">1 & <20 | >31 & <33",
|
|
},
|
|
want: false,
|
|
}, {
|
|
args: args{
|
|
value: 7.0,
|
|
pattern: 7.000,
|
|
},
|
|
want: true,
|
|
}, {
|
|
args: args{
|
|
value: 10,
|
|
pattern: 10,
|
|
},
|
|
want: true,
|
|
}, {
|
|
args: args{
|
|
value: 8,
|
|
pattern: 10,
|
|
},
|
|
want: false,
|
|
}, {
|
|
args: args{
|
|
value: int64(10),
|
|
pattern: int64(10),
|
|
},
|
|
want: true,
|
|
}, {
|
|
args: args{
|
|
value: int64(8),
|
|
pattern: int64(10),
|
|
},
|
|
want: false,
|
|
}, {
|
|
args: args{
|
|
value: nil,
|
|
pattern: []interface{}{},
|
|
},
|
|
want: false,
|
|
}, {
|
|
args: args{
|
|
value: nil,
|
|
pattern: []string{},
|
|
},
|
|
want: false,
|
|
}, {
|
|
args: args{
|
|
value: map[string]interface{}{
|
|
"a": true,
|
|
},
|
|
pattern: map[string]interface{}{
|
|
"a": true,
|
|
},
|
|
},
|
|
want: true,
|
|
}, {
|
|
args: args{
|
|
value: map[string]interface{}{
|
|
"a": true,
|
|
},
|
|
pattern: map[string]interface{}{
|
|
"b": false,
|
|
},
|
|
},
|
|
want: true,
|
|
}, {
|
|
args: args{
|
|
value: nil,
|
|
pattern: false,
|
|
},
|
|
want: false,
|
|
}, {
|
|
args: args{
|
|
value: 8.0,
|
|
pattern: 8,
|
|
},
|
|
want: true,
|
|
}, {
|
|
args: args{
|
|
value: 8.1,
|
|
pattern: 8,
|
|
},
|
|
want: false,
|
|
}, {
|
|
args: args{
|
|
value: "8",
|
|
pattern: 8,
|
|
},
|
|
want: true,
|
|
}, {
|
|
args: args{
|
|
value: "8.1",
|
|
pattern: 8,
|
|
},
|
|
want: false,
|
|
}, {
|
|
args: args{
|
|
value: false,
|
|
pattern: 8,
|
|
},
|
|
want: false,
|
|
}, {
|
|
args: args{
|
|
value: 8,
|
|
pattern: 8.0,
|
|
},
|
|
want: true,
|
|
}, {
|
|
args: args{
|
|
value: 8,
|
|
pattern: 8.1,
|
|
},
|
|
want: false,
|
|
}, {
|
|
args: args{
|
|
value: int64(8),
|
|
pattern: 8.0,
|
|
},
|
|
want: true,
|
|
}, {
|
|
args: args{
|
|
value: int64(8),
|
|
pattern: 8.1,
|
|
},
|
|
want: false,
|
|
}, {
|
|
args: args{
|
|
value: "8",
|
|
pattern: 8.0,
|
|
},
|
|
want: true,
|
|
}, {
|
|
args: args{
|
|
value: "8.1",
|
|
pattern: 8.1,
|
|
},
|
|
want: true,
|
|
}, {
|
|
args: args{
|
|
value: "abc",
|
|
pattern: 8.1,
|
|
},
|
|
want: false,
|
|
}, {
|
|
args: args{
|
|
value: false,
|
|
pattern: 8.0,
|
|
},
|
|
want: false,
|
|
}}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
if got := Validate(logr.Discard(), tt.args.value, tt.args.pattern); got != tt.want {
|
|
t.Errorf("Validate() = %v, want %v", got, tt.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func Test_convertNumberToString(t *testing.T) {
|
|
type args struct {
|
|
value interface{}
|
|
}
|
|
tests := []struct {
|
|
name string
|
|
args args
|
|
want string
|
|
wantErr bool
|
|
}{{
|
|
args: args{
|
|
value: nil,
|
|
},
|
|
want: "0",
|
|
}, {
|
|
args: args{
|
|
value: "123",
|
|
},
|
|
want: "123",
|
|
}, {
|
|
args: args{
|
|
value: "",
|
|
},
|
|
want: "",
|
|
}, {
|
|
args: args{
|
|
value: "abc",
|
|
},
|
|
want: "abc",
|
|
}, {
|
|
args: args{
|
|
value: 0.0,
|
|
},
|
|
want: "0.000000",
|
|
}, {
|
|
args: args{
|
|
value: 3.10,
|
|
},
|
|
want: "3.100000",
|
|
}, {
|
|
args: args{
|
|
value: -3.10,
|
|
},
|
|
want: "-3.100000",
|
|
}, {
|
|
args: args{
|
|
value: -3,
|
|
},
|
|
want: "-3",
|
|
}, {
|
|
args: args{
|
|
value: 3,
|
|
},
|
|
want: "3",
|
|
}, {
|
|
args: args{
|
|
value: 0,
|
|
},
|
|
want: "0",
|
|
}, {
|
|
args: args{
|
|
value: int64(-3),
|
|
},
|
|
want: "-3",
|
|
}, {
|
|
args: args{
|
|
value: int64(3),
|
|
},
|
|
want: "3",
|
|
}, {
|
|
args: args{
|
|
value: int64(0),
|
|
},
|
|
want: "0",
|
|
}, {
|
|
args: args{
|
|
value: false,
|
|
},
|
|
wantErr: true,
|
|
},
|
|
// TODO: Add test cases.
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
got, err := convertNumberToString(tt.args.value)
|
|
if (err != nil) != tt.wantErr {
|
|
t.Errorf("convertNumberToString() error = %v, wantErr %v", err, tt.wantErr)
|
|
return
|
|
}
|
|
if got != tt.want {
|
|
t.Errorf("convertNumberToString() = %v, want %v", got, tt.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func Test_validateMapPattern(t *testing.T) {
|
|
type args struct {
|
|
value interface{}
|
|
}
|
|
tests := []struct {
|
|
name string
|
|
args args
|
|
want bool
|
|
}{{
|
|
args: args{
|
|
value: nil,
|
|
},
|
|
want: false,
|
|
}, {
|
|
args: args{
|
|
value: true,
|
|
},
|
|
want: false,
|
|
}, {
|
|
args: args{
|
|
value: 8,
|
|
},
|
|
want: false,
|
|
}, {
|
|
args: args{
|
|
value: "",
|
|
},
|
|
want: false,
|
|
}, {
|
|
args: args{
|
|
value: "abc",
|
|
},
|
|
want: false,
|
|
}, {
|
|
args: args{
|
|
value: map[string]interface{}(nil),
|
|
},
|
|
want: true,
|
|
}, {
|
|
args: args{
|
|
value: map[string]interface{}{},
|
|
},
|
|
want: true,
|
|
}, {
|
|
args: args{
|
|
value: map[string]interface{}{
|
|
"a": true,
|
|
},
|
|
},
|
|
want: true,
|
|
}}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
if got := validateMapPattern(logr.Discard(), tt.args.value, nil); got != tt.want {
|
|
t.Errorf("validateMapPattern() = %v, want %v", got, tt.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func Test_validateNilPattern(t *testing.T) {
|
|
type args struct {
|
|
value interface{}
|
|
}
|
|
tests := []struct {
|
|
name string
|
|
args args
|
|
want bool
|
|
}{{
|
|
args: args{
|
|
value: nil,
|
|
},
|
|
want: true,
|
|
}, {
|
|
args: args{
|
|
value: 0.0,
|
|
},
|
|
want: true,
|
|
}, {
|
|
args: args{
|
|
value: 0,
|
|
},
|
|
want: true,
|
|
}, {
|
|
args: args{
|
|
value: int64(0),
|
|
},
|
|
want: true,
|
|
}, {
|
|
args: args{
|
|
value: "",
|
|
},
|
|
want: true,
|
|
}, {
|
|
args: args{
|
|
value: false,
|
|
},
|
|
want: true,
|
|
}, {
|
|
args: args{
|
|
value: map[string]interface{}{},
|
|
},
|
|
want: false,
|
|
}, {
|
|
args: args{
|
|
value: []interface{}{},
|
|
},
|
|
want: false,
|
|
}, {
|
|
args: args{
|
|
value: map[string]string{},
|
|
},
|
|
want: false,
|
|
}, {
|
|
args: args{
|
|
value: 1.0,
|
|
},
|
|
want: false,
|
|
}, {
|
|
args: args{
|
|
value: 1,
|
|
},
|
|
want: false,
|
|
}, {
|
|
args: args{
|
|
value: int64(1),
|
|
},
|
|
want: false,
|
|
}, {
|
|
args: args{
|
|
value: "abc",
|
|
},
|
|
want: false,
|
|
}, {
|
|
args: args{
|
|
value: true,
|
|
},
|
|
want: false,
|
|
}}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
if got := validateNilPattern(logr.Discard(), tt.args.value); got != tt.want {
|
|
t.Errorf("validateNilPattern() = %v, want %v", got, tt.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func Test_validateStringPatterns(t *testing.T) {
|
|
type args struct {
|
|
value interface{}
|
|
pattern string
|
|
}
|
|
tests := []struct {
|
|
name string
|
|
args args
|
|
want bool
|
|
}{
|
|
{
|
|
args: args{
|
|
value: "5.16.5-arch1-1",
|
|
pattern: "!5.10.84-1",
|
|
},
|
|
want: true,
|
|
},
|
|
{
|
|
args: args{
|
|
value: "5.10.84-1",
|
|
pattern: "5.10.84-1",
|
|
},
|
|
want: true,
|
|
},
|
|
{
|
|
args: args{
|
|
value: "!5.10.84-1",
|
|
pattern: "!5.10.84-1",
|
|
},
|
|
want: true,
|
|
},
|
|
{
|
|
args: args{
|
|
value: "5.10.84-1",
|
|
pattern: "!5.10.84-1",
|
|
},
|
|
want: false,
|
|
},
|
|
{
|
|
args: args{
|
|
value: "5.16.5-arch1-1",
|
|
pattern: "!5.10.84-1 & !5.15.2-1",
|
|
},
|
|
want: true,
|
|
},
|
|
{
|
|
args: args{
|
|
value: "5.10.84-1",
|
|
pattern: "!5.10.84-1 & !5.15.2-1",
|
|
},
|
|
want: false,
|
|
},
|
|
{
|
|
args: args{
|
|
value: "5.15.2-1",
|
|
pattern: "!5.10.84-1 & !5.15.2-1",
|
|
},
|
|
want: false,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
if got := validateStringPatterns(logr.Discard(), tt.args.value, tt.args.pattern); got != tt.want {
|
|
t.Errorf("validateStringPatterns() = %v, want %v", got, tt.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func Test_split(t *testing.T) {
|
|
type args struct {
|
|
pattern string
|
|
r *regexp.Regexp
|
|
}
|
|
tests := []struct {
|
|
name string
|
|
args args
|
|
want string
|
|
want1 string
|
|
want2 bool
|
|
}{{
|
|
args: args{
|
|
pattern: "",
|
|
r: operator.InRangeRegex,
|
|
},
|
|
want: "",
|
|
want1: "",
|
|
want2: false,
|
|
}, {
|
|
args: args{
|
|
pattern: "",
|
|
r: operator.NotInRangeRegex,
|
|
},
|
|
want: "",
|
|
want1: "",
|
|
want2: false,
|
|
}}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
got, got1, got2 := split(tt.args.pattern, tt.args.r)
|
|
if got != tt.want {
|
|
t.Errorf("split() got = %v, want %v", got, tt.want)
|
|
}
|
|
if got1 != tt.want1 {
|
|
t.Errorf("split() got1 = %v, want %v", got1, tt.want1)
|
|
}
|
|
if got2 != tt.want2 {
|
|
t.Errorf("split() got2 = %v, want %v", got2, tt.want2)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func Test_compareString(t *testing.T) {
|
|
type args struct {
|
|
value interface{}
|
|
pattern string
|
|
operatorVariable operator.Operator
|
|
}
|
|
tests := []struct {
|
|
name string
|
|
args args
|
|
want bool
|
|
}{
|
|
{
|
|
args: args{
|
|
value: "anything",
|
|
pattern: "*",
|
|
operatorVariable: operator.Equal,
|
|
},
|
|
want: true,
|
|
}, {
|
|
args: args{
|
|
value: "",
|
|
pattern: "*",
|
|
operatorVariable: operator.Equal,
|
|
},
|
|
want: true,
|
|
}, {
|
|
args: args{
|
|
value: "leftright",
|
|
pattern: "*right",
|
|
operatorVariable: operator.Equal,
|
|
},
|
|
want: true,
|
|
}, {
|
|
args: args{
|
|
value: "right",
|
|
pattern: "*right",
|
|
operatorVariable: operator.Equal,
|
|
},
|
|
want: true,
|
|
}, {
|
|
args: args{
|
|
value: "leftmiddle",
|
|
pattern: "*right",
|
|
operatorVariable: operator.Equal,
|
|
},
|
|
want: false,
|
|
}, {
|
|
args: args{
|
|
value: "middle",
|
|
pattern: "*right",
|
|
operatorVariable: operator.Equal,
|
|
},
|
|
want: false,
|
|
}, {
|
|
args: args{
|
|
value: "abbeba",
|
|
pattern: "ab*ba",
|
|
operatorVariable: operator.Equal,
|
|
},
|
|
want: true,
|
|
}, {
|
|
args: args{
|
|
value: "abbca",
|
|
pattern: "ab*ba",
|
|
operatorVariable: operator.Equal,
|
|
},
|
|
want: false,
|
|
}, {
|
|
args: args{
|
|
value: "abbba",
|
|
pattern: "ab?ba",
|
|
operatorVariable: operator.Equal,
|
|
},
|
|
want: true,
|
|
}, {
|
|
args: args{
|
|
value: "abbbba",
|
|
pattern: "ab?ba",
|
|
operatorVariable: operator.Equal,
|
|
},
|
|
want: false,
|
|
}, {
|
|
args: args{
|
|
value: nil,
|
|
pattern: "ab?ba",
|
|
operatorVariable: operator.Equal,
|
|
},
|
|
want: false,
|
|
}, {
|
|
args: args{
|
|
value: "",
|
|
pattern: "ab?ba",
|
|
operatorVariable: operator.Equal,
|
|
},
|
|
want: false,
|
|
}, {
|
|
args: args{
|
|
value: "",
|
|
pattern: "",
|
|
operatorVariable: operator.Equal,
|
|
},
|
|
want: true,
|
|
}, {
|
|
args: args{
|
|
value: 1,
|
|
pattern: "1",
|
|
operatorVariable: operator.Equal,
|
|
},
|
|
want: true,
|
|
}, {
|
|
args: args{
|
|
value: int64(1),
|
|
pattern: "1",
|
|
operatorVariable: operator.Equal,
|
|
},
|
|
want: true,
|
|
}, {
|
|
args: args{
|
|
value: 1.0,
|
|
pattern: "1E+*",
|
|
operatorVariable: operator.Equal,
|
|
},
|
|
want: true,
|
|
}, {
|
|
args: args{
|
|
value: true,
|
|
pattern: "true",
|
|
operatorVariable: operator.Equal,
|
|
},
|
|
want: true,
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
if got := compareString(logr.Discard(), tt.args.value, tt.args.pattern, tt.args.operatorVariable); got != tt.want {
|
|
t.Errorf("compareString() = %v, want %v", got, tt.want)
|
|
}
|
|
})
|
|
}
|
|
}
|