| package query |
| |
| import ( |
| "fmt" |
| "net/url" |
| "reflect" |
| "testing" |
| |
| "github.com/stretchr/testify/assert" |
| "go.skia.org/infra/go/paramtools" |
| "go.skia.org/infra/go/testutils/unittest" |
| ) |
| |
| func TestValidateKey(t *testing.T) { |
| unittest.SmallTest(t) |
| testCases := []struct { |
| key string |
| valid bool |
| reason string |
| }{ |
| { |
| key: ",arch=x86,config=565,", |
| valid: true, |
| reason: "", |
| }, |
| { |
| key: "arch=x86,config=565,", |
| valid: false, |
| reason: "No comma at beginning.", |
| }, |
| { |
| key: ",arch=x86,config=565", |
| valid: false, |
| reason: "No comma at end.", |
| }, |
| { |
| key: ",arch=x86,", |
| valid: true, |
| reason: "Short is fine.", |
| }, |
| { |
| key: "", |
| valid: false, |
| reason: "Empty is invalid.", |
| }, |
| { |
| key: ",config=565,arch=x86,", |
| valid: false, |
| reason: "Unsorted.", |
| }, |
| { |
| key: ",config=565,config=8888,", |
| valid: false, |
| reason: "Duplicate param names.", |
| }, |
| { |
| key: ",arch=x85,config=565,config=8888,", |
| valid: false, |
| reason: "Duplicate param names.", |
| }, |
| { |
| key: ",arch=x85,archer=x85,", |
| valid: true, |
| reason: "Param name prefix of another param name.", |
| }, |
| { |
| key: ",,", |
| valid: false, |
| reason: "Degenerate case.", |
| }, |
| } |
| for _, tc := range testCases { |
| if got, want := ValidateKey(tc.key), tc.valid; got != want { |
| t.Errorf("Failed validation for %q. Got %v Want %v. %s", tc.key, got, want, tc.reason) |
| } |
| } |
| } |
| |
| func TestMakeKey(t *testing.T) { |
| unittest.SmallTest(t) |
| testCases := []struct { |
| m map[string]string |
| key string |
| valid bool |
| reason string |
| }{ |
| { |
| m: map[string]string{"arch": "x86", "config": "565"}, |
| key: ",arch=x86,config=565,", |
| valid: true, |
| reason: "", |
| }, |
| { |
| m: map[string]string{"arch": "x86", "archer": "x86"}, |
| key: ",arch=x86,archer=x86,", |
| valid: true, |
| reason: "", |
| }, |
| { |
| m: map[string]string{"bad,key": "x86"}, |
| key: "", |
| valid: false, |
| reason: "Bad key.", |
| }, |
| { |
| m: map[string]string{"key": "bad,value"}, |
| key: "", |
| valid: false, |
| reason: "Bad value.", |
| }, |
| { |
| m: map[string]string{}, |
| key: "", |
| valid: false, |
| reason: "Empty map is invalid.", |
| }, |
| } |
| for _, tc := range testCases { |
| key, err := MakeKey(tc.m) |
| if tc.valid && err != nil { |
| t.Errorf("Failed to make key for %#v: %s", tc.m, err) |
| } |
| if key != tc.key { |
| t.Errorf("Failed to make key for %#v. Got %q Want %q. %s", tc.m, key, tc.key, tc.reason) |
| } |
| } |
| } |
| |
| func TestNew(t *testing.T) { |
| unittest.SmallTest(t) |
| q, err := New(url.Values{"config": []string{"565", "8888"}}) |
| assert.NoError(t, err) |
| assert.Equal(t, 1, len(q.params)) |
| assert.Equal(t, false, q.params[0].isWildCard) |
| |
| q, err = NewFromString("config=565&config=8888") |
| assert.NoError(t, err) |
| assert.Equal(t, 1, len(q.params)) |
| assert.Equal(t, false, q.params[0].isWildCard) |
| |
| q, err = NewFromString("config=%ZZ") |
| assert.Error(t, err, "Invalid query strings are caught.") |
| |
| q, err = New(url.Values{"debug": []string{"false"}, "config": []string{"565", "8888"}}) |
| assert.NoError(t, err) |
| assert.Equal(t, 2, len(q.params)) |
| assert.Equal(t, ",config=", q.params[0].keyMatch) |
| assert.Equal(t, ",debug=", q.params[1].keyMatch) |
| assert.Equal(t, false, q.params[0].isWildCard) |
| assert.Equal(t, false, q.params[1].isWildCard) |
| assert.Equal(t, false, q.params[0].isNegative) |
| assert.Equal(t, false, q.params[1].isNegative) |
| |
| q, err = New(url.Values{"debug": []string{"*"}}) |
| assert.NoError(t, err) |
| assert.Equal(t, 1, len(q.params)) |
| assert.Equal(t, ",debug=", q.params[0].keyMatch) |
| assert.Equal(t, true, q.params[0].isWildCard) |
| assert.Equal(t, false, q.params[0].isNegative) |
| |
| q, err = New(url.Values{"config": []string{"!565"}}) |
| assert.NoError(t, err) |
| assert.Equal(t, 1, len(q.params)) |
| assert.Equal(t, ",config=", q.params[0].keyMatch) |
| assert.Equal(t, false, q.params[0].isWildCard) |
| assert.Equal(t, true, q.params[0].isNegative) |
| |
| q, err = New(url.Values{"config": []string{"!565", "!8888"}, "debug": []string{"*"}}) |
| assert.NoError(t, err) |
| assert.Equal(t, 2, len(q.params)) |
| assert.Equal(t, ",config=", q.params[0].keyMatch) |
| assert.Equal(t, "565", q.params[0].values[0]) |
| assert.Equal(t, "8888", q.params[0].values[1]) |
| assert.Equal(t, ",debug=", q.params[1].keyMatch) |
| assert.Equal(t, false, q.params[0].isWildCard) |
| assert.Equal(t, true, q.params[0].isNegative) |
| assert.Equal(t, true, q.params[1].isWildCard) |
| assert.Equal(t, false, q.params[1].isNegative) |
| |
| q, err = New(url.Values{}) |
| assert.NoError(t, err) |
| assert.Equal(t, 0, len(q.params)) |
| } |
| |
| func TestMatches(t *testing.T) { |
| unittest.SmallTest(t) |
| testCases := []struct { |
| key string |
| query url.Values |
| matches bool |
| reason string |
| }{ |
| { |
| key: ",arch=x86,config=565,debug=true,", |
| query: url.Values{}, |
| matches: true, |
| reason: "Empty query matches everything.", |
| }, |
| { |
| key: ",arch=x86,config=565,debug=true,", |
| query: url.Values{"config": []string{"565"}}, |
| matches: true, |
| reason: "Simple match", |
| }, |
| { |
| key: ",arch=x86,config=565,debug=true,", |
| query: url.Values{"config": []string{"8888"}}, |
| matches: false, |
| reason: "Simple miss", |
| }, |
| { |
| key: ",arch=x86,config=565,debug=true,", |
| query: url.Values{"config": []string{"565", "8888"}}, |
| matches: true, |
| reason: "Simple OR", |
| }, |
| { |
| key: ",arch=x86,config=565,debug=true,", |
| query: url.Values{"config": []string{"8888", "565"}}, |
| matches: true, |
| reason: "Simple OR 2", |
| }, |
| { |
| key: ",arch=x86,config=565,debug=true,", |
| query: url.Values{"config": []string{"565"}, "debug": []string{"true"}}, |
| matches: true, |
| reason: "Simple AND", |
| }, |
| { |
| key: ",arch=x86,config=565,debug=true,", |
| query: url.Values{"config": []string{"565"}, "debug": []string{"false"}}, |
| matches: false, |
| reason: "Simple AND miss", |
| }, |
| { |
| key: ",arch=x86,config=565,debug=true,", |
| query: url.Values{"foo": []string{"bar"}}, |
| matches: false, |
| reason: "Unknown param", |
| }, |
| { |
| key: ",arch=x86,config=565,debug=true,", |
| query: url.Values{"arch": []string{"*"}}, |
| matches: true, |
| reason: "Wildcard param value match", |
| }, |
| { |
| key: ",arch=x86,config=565,debug=true,", |
| query: url.Values{"foo": []string{"*"}}, |
| matches: false, |
| reason: "Wildcard param value missing", |
| }, |
| { |
| key: ",arch=x86,config=565,debug=true,", |
| query: url.Values{"config": []string{"!565"}}, |
| matches: false, |
| reason: "Negative miss", |
| }, |
| { |
| key: ",arch=x86,config=8888,debug=true,", |
| query: url.Values{"config": []string{"!565"}}, |
| matches: true, |
| reason: "Negative match", |
| }, |
| { |
| key: ",arch=x86,config=8888,debug=true,", |
| query: url.Values{"config": []string{"!565", "!8888"}}, |
| matches: false, |
| reason: "Negative multi miss", |
| }, |
| { |
| key: ",arch=x86,config=8888,debug=true,", |
| query: url.Values{"config": []string{"!565"}, "debug": []string{"*"}}, |
| matches: true, |
| reason: "Negative and wildcard", |
| }, |
| { |
| key: ",arch=x86,config=8888,", |
| query: url.Values{"config": []string{"!565"}, "debug": []string{"*"}}, |
| matches: false, |
| reason: "Negative and wildcard, miss wildcard.", |
| }, |
| { |
| key: ",arch=x86,config=565,debug=true,", |
| query: url.Values{"config": []string{"!565"}, "debug": []string{"*"}}, |
| matches: false, |
| reason: "Negative and wildcard, miss negative", |
| }, |
| { |
| key: ",arch=x86,config=565,debug=true,", |
| query: url.Values{}, |
| matches: true, |
| reason: "Empty query matches everything.", |
| }, |
| { |
| key: ",arch=x86,config=565,debug=true,", |
| query: url.Values{"config": []string{"~5.5"}}, |
| matches: true, |
| reason: "Regexp match", |
| }, |
| { |
| key: ",arch=x86,config=565,debug=true,", |
| query: url.Values{"config": []string{"~8+"}}, |
| matches: false, |
| reason: "Regexp match", |
| }, |
| { |
| key: ",arch=x86,config=8888,debug=true,", |
| query: url.Values{"arch": []string{"~^x"}, "config": []string{"!565"}, "debug": []string{"*"}}, |
| matches: true, |
| reason: "Negative, wildcard, and regexp", |
| }, |
| { |
| key: ",arch=x86,config=8888,debug=true,", |
| query: url.Values{"arch": []string{"~^y.*"}, "config": []string{"!565"}, "debug": []string{"*"}}, |
| matches: false, |
| reason: "Negative, wildcard, and miss regexp", |
| }, |
| } |
| ops := ¶mtools.OrderedParamSet{ |
| KeyOrder: []string{"arch", "config", "debug", "foo"}, |
| ParamSet: paramtools.ParamSet{ |
| "config": []string{"8888", "565", "gpu"}, |
| "arch": []string{"x86", "arm"}, |
| "debug": []string{"true", "false"}, |
| "foo": []string{"bar"}, |
| }, |
| } |
| |
| for _, tc := range testCases { |
| q, err := New(tc.query) |
| assert.NoError(t, err) |
| if got, want := q.Matches(tc.key), tc.matches; got != want { |
| t.Errorf("Failed matching %q to %#v. Got %v Want %v. %s", tc.key, tc.query, got, want, tc.reason) |
| } |
| // Now confirm that the query transformed into a Regexp will give the same answer as Matches(). |
| r, err := q.Regexp(ops) |
| if err == QueryWillNeverMatch { |
| assert.False(t, tc.matches) |
| continue |
| } else { |
| assert.NoError(t, err) |
| } |
| parsed, err := ParseKey(tc.key) |
| assert.NoError(t, err) |
| s, err := ops.EncodeParamsAsString(paramtools.Params(parsed)) |
| assert.NoError(t, err) |
| assert.Equal(t, tc.matches, r.MatchString(s), fmt.Sprintf("%#v %s %v\n", tc, s, r)) |
| } |
| } |
| |
| func TestParseKey(t *testing.T) { |
| unittest.SmallTest(t) |
| testCases := []struct { |
| key string |
| parsed map[string]string |
| hasError bool |
| reason string |
| }{ |
| { |
| key: ",arch=x86,config=565,debug=true,", |
| parsed: map[string]string{ |
| "arch": "x86", |
| "config": "565", |
| "debug": "true", |
| }, |
| hasError: false, |
| reason: "Simple parse", |
| }, |
| { |
| key: ",config=565,arch=x86,", |
| parsed: map[string]string{}, |
| hasError: true, |
| reason: "Unsorted", |
| }, |
| { |
| key: ",,", |
| parsed: map[string]string{}, |
| hasError: true, |
| reason: "Invalid regex", |
| }, |
| { |
| key: "x/y", |
| parsed: map[string]string{}, |
| hasError: true, |
| reason: "Invalid", |
| }, |
| { |
| key: "", |
| parsed: map[string]string{}, |
| hasError: true, |
| reason: "Empty string", |
| }, |
| } |
| for _, tc := range testCases { |
| p, err := ParseKey(tc.key) |
| if got, want := (err != nil), tc.hasError; got != want { |
| t.Errorf("Failed error status parsing %q, Got %v Want %v. %s", tc.key, got, want, tc.reason) |
| } |
| if err != nil { |
| continue |
| } |
| if got, want := p, tc.parsed; !reflect.DeepEqual(got, want) { |
| t.Errorf("Failed matching parsed values. Got %v Want %v. %s", got, want, tc.reason) |
| } |
| } |
| } |
| |
| func TestParseKeyFast(t *testing.T) { |
| unittest.SmallTest(t) |
| p, err := ParseKeyFast(",arch=x86,config=565,debug=true,") |
| assert.NoError(t, err) |
| assert.Equal(t, map[string]string{ |
| "arch": "x86", |
| "config": "565", |
| "debug": "true", |
| }, p) |
| } |
| |
| // Test a variety of inputs to make sure the code doesn't panic. |
| func TestParseKeyFastNoPanics(t *testing.T) { |
| unittest.SmallTest(t) |
| |
| testCases := []string{ |
| ",config=565,arch=x86,", // unsorted |
| ",,", |
| "x/y", |
| "", |
| ",", |
| "foo=bar", |
| ",foo=bar", |
| ",foo,", |
| ",foo,bar,baz,", |
| ",foo=,bar=,", |
| ",=,", |
| ",space=spaces ok here,", |
| } |
| |
| for _, tc := range testCases { |
| _, _ = ParseKeyFast(tc) |
| } |
| } |
| |
| func TestForceValue(t *testing.T) { |
| unittest.SmallTest(t) |
| testCases := []struct { |
| input map[string]string |
| want map[string]string |
| }{ |
| { |
| input: map[string]string{"arch": "x86", "config": "565"}, |
| want: map[string]string{"arch": "x86", "config": "565"}, |
| }, |
| { |
| input: map[string]string{"arch::this": "x!~@#$%^&*()86"}, |
| want: map[string]string{"arch__this": "x___________86"}, |
| }, |
| { |
| input: map[string]string{}, |
| want: map[string]string{}, |
| }, |
| } |
| for _, tc := range testCases { |
| if got, want := ForceValid(tc.input), tc.want; !reflect.DeepEqual(got, want) { |
| t.Errorf("Failed to force a map to be valid: Got %#v Want %#v", got, want) |
| } |
| } |
| } |
| |
| func TestQueryPlan(t *testing.T) { |
| unittest.SmallTest(t) |
| |
| ops := ¶mtools.OrderedParamSet{ |
| KeyOrder: []string{"arch", "config", "debug", "foo"}, |
| ParamSet: paramtools.ParamSet{ |
| "config": []string{"8888", "565", "gpu"}, |
| "arch": []string{"x86", "arm"}, |
| "debug": []string{"true", "false"}, |
| "foo": []string{"bar"}, |
| }, |
| } |
| |
| testCases := []struct { |
| query url.Values |
| want paramtools.ParamSet |
| hasError bool |
| reason string |
| }{ |
| { |
| query: url.Values{}, |
| want: paramtools.ParamSet{}, |
| reason: "Empty query matches everything.", |
| }, |
| { |
| query: url.Values{"config": []string{"565"}}, |
| want: paramtools.ParamSet{"config": []string{"565"}}, |
| reason: "Simple", |
| }, |
| { |
| query: url.Values{"config": []string{"565", "8888"}}, |
| want: paramtools.ParamSet{"config": []string{"8888", "565"}}, |
| reason: "Simple OR", |
| }, |
| { |
| query: url.Values{"config": []string{"565"}, "debug": []string{"true"}}, |
| want: paramtools.ParamSet{ |
| "config": []string{"565"}, |
| "debug": []string{"true"}, |
| }, |
| reason: "Simple AND", |
| }, |
| { |
| query: url.Values{"fizz": []string{"buzz"}}, |
| want: paramtools.ParamSet{}, |
| reason: "Unknown param", |
| }, |
| { |
| query: url.Values{"config": []string{"buzz"}}, |
| want: paramtools.ParamSet{}, |
| hasError: true, |
| reason: "Unknown value", |
| }, |
| { |
| query: url.Values{"arch": []string{"*"}}, |
| want: paramtools.ParamSet{"arch": []string{"x86", "arm"}}, |
| reason: "Wildcard param value match", |
| }, |
| { |
| query: url.Values{"fizz": []string{"*"}}, |
| want: paramtools.ParamSet{}, |
| reason: "Wildcard param value missing", |
| }, |
| { |
| query: url.Values{"foo": []string{"*"}}, |
| want: paramtools.ParamSet{"foo": []string{"bar"}}, |
| reason: "Wildcard param value missing", |
| }, |
| { |
| query: url.Values{"config": []string{"!565"}}, |
| want: paramtools.ParamSet{"config": []string{"8888", "gpu"}}, |
| reason: "Negative", |
| }, |
| { |
| query: url.Values{"config": []string{"!565", "!8888"}}, |
| want: paramtools.ParamSet{"config": []string{"gpu"}}, |
| reason: "Negative multi miss", |
| }, |
| { |
| query: url.Values{"config": []string{"!565"}, "debug": []string{"*"}}, |
| want: paramtools.ParamSet{ |
| "config": []string{"8888", "gpu"}, |
| "debug": []string{"true", "false"}, |
| }, |
| reason: "Negative and wildcard", |
| }, |
| { |
| query: url.Values{}, |
| want: paramtools.ParamSet{}, |
| reason: "Empty query matches everything.", |
| }, |
| { |
| query: url.Values{"config": []string{"~5.5"}}, |
| want: paramtools.ParamSet{"config": []string{"565"}}, |
| reason: "Regexp match", |
| }, |
| { |
| query: url.Values{"config": []string{"~8+"}}, |
| want: paramtools.ParamSet{"config": []string{"8888"}}, |
| reason: "Regexp match", |
| }, |
| { |
| query: url.Values{"arch": []string{"~^x"}, "config": []string{"!565"}, "debug": []string{"*"}}, |
| want: paramtools.ParamSet{"arch": []string{"x86"}, "config": []string{"8888", "gpu"}, "debug": []string{"true", "false"}}, |
| reason: "Negative, wildcard, and regexp", |
| }, |
| { |
| query: url.Values{"arch": []string{"~^y.*"}, "config": []string{"!565"}, "debug": []string{"*"}}, |
| hasError: true, |
| reason: "Negative, wildcard, and miss regexp", |
| }, |
| } |
| |
| for _, tc := range testCases { |
| q, err := New(tc.query) |
| assert.NoError(t, err, tc.reason) |
| ps, err := q.QueryPlan(ops) |
| if tc.hasError { |
| assert.Error(t, err, tc.reason) |
| } else { |
| assert.NoError(t, err, tc.reason) |
| assert.Equal(t, tc.want, ps, tc.reason) |
| } |
| } |
| } |
| |
| func TestValidateParamSet(t *testing.T) { |
| unittest.SmallTest(t) |
| |
| assert.NoError(t, ValidateParamSet(nil)) |
| assert.NoError(t, ValidateParamSet(paramtools.ParamSet{})) |
| assert.Error(t, ValidateParamSet(paramtools.ParamSet{"": []string{}})) |
| assert.Error(t, ValidateParamSet(paramtools.ParamSet{"); DROP TABLE": []string{}})) |
| assert.Error(t, ValidateParamSet(paramtools.ParamSet{"good": []string{"); DROP TABLE"}})) |
| } |
