mirror of
https://github.com/VictoriaMetrics/VictoriaMetrics.git
synced 2024-12-29 23:30:04 +01:00
392 lines
9.9 KiB
Go
392 lines
9.9 KiB
Go
package searchutils
|
||
|
||
import (
|
||
"fmt"
|
||
"net/http"
|
||
"net/url"
|
||
"reflect"
|
||
"strconv"
|
||
"testing"
|
||
|
||
"github.com/VictoriaMetrics/VictoriaMetrics/lib/storage"
|
||
)
|
||
|
||
func TestGetDurationSuccess(t *testing.T) {
|
||
f := func(s string, dExpected int64) {
|
||
t.Helper()
|
||
urlStr := fmt.Sprintf("http://foo.bar/baz?s=%s", url.QueryEscape(s))
|
||
r, err := http.NewRequest(http.MethodGet, urlStr, nil)
|
||
if err != nil {
|
||
t.Fatalf("unexpected error in NewRequest: %s", err)
|
||
}
|
||
|
||
// Verify defaultValue
|
||
d, err := GetDuration(r, "foo", 123456)
|
||
if err != nil {
|
||
t.Fatalf("unexpected error when obtaining default time from GetDuration(%q): %s", s, err)
|
||
}
|
||
if d != 123456 {
|
||
t.Fatalf("unexpected default value for GetDuration(%q); got %d; want %d", s, d, 123456)
|
||
}
|
||
|
||
// Verify dExpected
|
||
d, err = GetDuration(r, "s", 123)
|
||
if err != nil {
|
||
t.Fatalf("unexpected error in GetDuration(%q): %s", s, err)
|
||
}
|
||
if d != dExpected {
|
||
t.Fatalf("unexpected timestamp for GetDuration(%q); got %d; want %d", s, d, dExpected)
|
||
}
|
||
}
|
||
|
||
f("1.234", 1234)
|
||
f("1.23ms", 1)
|
||
f("1.23s", 1230)
|
||
f("2s56ms", 2056)
|
||
f("2s-5ms", 1995)
|
||
f("5m3.5s", 303500)
|
||
f("2h", 7200000)
|
||
f("1d", 24*3600*1000)
|
||
f("7d5h4m3s534ms", 623043534)
|
||
}
|
||
|
||
func TestGetDurationError(t *testing.T) {
|
||
f := func(s string) {
|
||
t.Helper()
|
||
urlStr := fmt.Sprintf("http://foo.bar/baz?s=%s", url.QueryEscape(s))
|
||
r, err := http.NewRequest(http.MethodGet, urlStr, nil)
|
||
if err != nil {
|
||
t.Fatalf("unexpected error in NewRequest: %s", err)
|
||
}
|
||
|
||
if _, err := GetDuration(r, "s", 123); err == nil {
|
||
t.Fatalf("expecting non-nil error in GetDuration(%q)", s)
|
||
}
|
||
}
|
||
|
||
// Negative durations aren't supported
|
||
f("-1.234")
|
||
|
||
// Invalid duration
|
||
f("foo")
|
||
|
||
// Invalid suffix
|
||
f("1md")
|
||
}
|
||
|
||
func TestGetTimeSuccess(t *testing.T) {
|
||
f := func(s string, timestampExpected int64) {
|
||
t.Helper()
|
||
urlStr := fmt.Sprintf("http://foo.bar/baz?s=%s", url.QueryEscape(s))
|
||
r, err := http.NewRequest(http.MethodGet, urlStr, nil)
|
||
if err != nil {
|
||
t.Fatalf("unexpected error in NewRequest: %s", err)
|
||
}
|
||
|
||
// Verify defaultValue
|
||
ts, err := GetTime(r, "foo", 123456)
|
||
if err != nil {
|
||
t.Fatalf("unexpected error when obtaining default time from GetTime(%q): %s", s, err)
|
||
}
|
||
if ts != 123000 {
|
||
t.Fatalf("unexpected default value for GetTime(%q); got %d; want %d", s, ts, 123000)
|
||
}
|
||
|
||
// Verify timestampExpected
|
||
ts, err = GetTime(r, "s", 123)
|
||
if err != nil {
|
||
t.Fatalf("unexpected error in GetTime(%q): %s", s, err)
|
||
}
|
||
if ts != timestampExpected {
|
||
t.Fatalf("unexpected timestamp for GetTime(%q); got %d; want %d", s, ts, timestampExpected)
|
||
}
|
||
}
|
||
|
||
f("2019", 1546300800000)
|
||
f("2019-01", 1546300800000)
|
||
f("2019-02", 1548979200000)
|
||
f("2019-02-01", 1548979200000)
|
||
f("2019-02-02", 1549065600000)
|
||
f("2019-02-02T00", 1549065600000)
|
||
f("2019-02-02T01", 1549069200000)
|
||
f("2019-02-02T01:00", 1549069200000)
|
||
f("2019-02-02T01:01", 1549069260000)
|
||
f("2019-02-02T01:01:00", 1549069260000)
|
||
f("2019-02-02T01:01:01", 1549069261000)
|
||
f("2019-07-07T20:01:02Z", 1562529662000)
|
||
f("2019-07-07T20:47:40+03:00", 1562521660000)
|
||
f("-292273086-05-16T16:47:06Z", minTimeMsecs)
|
||
f("292277025-08-18T07:12:54.999999999Z", maxTimeMsecs)
|
||
f("1562529662.324", 1562529662324)
|
||
f("-9223372036.854", minTimeMsecs)
|
||
f("-9223372036.855", minTimeMsecs)
|
||
f("9223372036.855", maxTimeMsecs)
|
||
}
|
||
|
||
func TestGetTimeError(t *testing.T) {
|
||
f := func(s string) {
|
||
t.Helper()
|
||
urlStr := fmt.Sprintf("http://foo.bar/baz?s=%s", url.QueryEscape(s))
|
||
r, err := http.NewRequest(http.MethodGet, urlStr, nil)
|
||
if err != nil {
|
||
t.Fatalf("unexpected error in NewRequest: %s", err)
|
||
}
|
||
|
||
if _, err := GetTime(r, "s", 123); err == nil {
|
||
t.Fatalf("expecting non-nil error in GetTime(%q)", s)
|
||
}
|
||
}
|
||
|
||
f("foo")
|
||
f("foo1")
|
||
f("1245-5")
|
||
f("2022-x7")
|
||
f("2022-02-x7")
|
||
f("2022-02-02Tx7")
|
||
f("2022-02-02T00:x7")
|
||
f("2022-02-02T00:00:x7")
|
||
f("2022-02-02T00:00:00a")
|
||
f("2019-07-07T20:01:02Zisdf")
|
||
f("2019-07-07T20:47:40+03:00123")
|
||
f("-292273086-05-16T16:47:07Z")
|
||
f("292277025-08-18T07:12:54.999999998Z")
|
||
f("123md")
|
||
f("-12.3md")
|
||
}
|
||
|
||
func TestGetExtraTagFilters(t *testing.T) {
|
||
httpReqWithForm := func(qs string) *http.Request {
|
||
q, err := url.ParseQuery(qs)
|
||
if err != nil {
|
||
t.Fatalf("unexpected error: %s", err)
|
||
}
|
||
return &http.Request{
|
||
Form: q,
|
||
}
|
||
}
|
||
f := func(t *testing.T, r *http.Request, want []string, wantErr bool) {
|
||
t.Helper()
|
||
result, err := GetExtraTagFilters(r)
|
||
if (err != nil) != wantErr {
|
||
t.Fatalf("unexpected error: %v", err)
|
||
}
|
||
got := tagFilterssToStrings(result)
|
||
if !reflect.DeepEqual(got, want) {
|
||
t.Fatalf("unxpected result for GetExtraTagFilters\ngot: %s\nwant: %s", got, want)
|
||
}
|
||
}
|
||
f(t, httpReqWithForm("extra_label=label=value"),
|
||
[]string{`{label="value"}`},
|
||
false,
|
||
)
|
||
f(t, httpReqWithForm("extra_label=job=vmagent&extra_label=dc=gce"),
|
||
[]string{`{job="vmagent",dc="gce"}`},
|
||
false,
|
||
)
|
||
f(t, httpReqWithForm(`extra_filters={foo="bar"}`),
|
||
[]string{`{foo="bar"}`},
|
||
false,
|
||
)
|
||
f(t, httpReqWithForm(`extra_filters={foo="bar"}&extra_filters[]={baz!~"aa",x=~"y"}`),
|
||
[]string{
|
||
`{foo="bar"}`,
|
||
`{baz!~"aa",x=~"y"}`,
|
||
},
|
||
false,
|
||
)
|
||
f(t, httpReqWithForm(`extra_label=job=vmagent&extra_label=dc=gce&extra_filters={foo="bar"}`),
|
||
[]string{`{foo="bar",job="vmagent",dc="gce"}`},
|
||
false,
|
||
)
|
||
f(t, httpReqWithForm(`extra_label=job=vmagent&extra_label=dc=gce&extra_filters[]={foo="bar"}&extra_filters[]={x=~"y|z",a="b"}`),
|
||
[]string{
|
||
`{foo="bar",job="vmagent",dc="gce"}`,
|
||
`{x=~"y|z",a="b",job="vmagent",dc="gce"}`,
|
||
},
|
||
false,
|
||
)
|
||
f(t, httpReqWithForm("extra_label=bad_filter"),
|
||
nil,
|
||
true,
|
||
)
|
||
f(t, httpReqWithForm(`extra_filters={bad_filter}`),
|
||
nil,
|
||
true,
|
||
)
|
||
f(t, httpReqWithForm(`extra_filters[]={bad_filter}`),
|
||
nil,
|
||
true,
|
||
)
|
||
f(t, httpReqWithForm(""),
|
||
nil,
|
||
false,
|
||
)
|
||
}
|
||
|
||
func TestParseMetricSelectorSuccess(t *testing.T) {
|
||
f := func(s string) {
|
||
t.Helper()
|
||
tfs, err := ParseMetricSelector(s)
|
||
if err != nil {
|
||
t.Fatalf("unexpected error when parsing %q: %s", s, err)
|
||
}
|
||
if tfs == nil {
|
||
t.Fatalf("expecting non-nil tfs when parsing %q", s)
|
||
}
|
||
}
|
||
f("foo")
|
||
f(":foo")
|
||
f(" :fo:bar.baz")
|
||
f(`a{}`)
|
||
f(`{foo="bar"}`)
|
||
f(`{:f:oo=~"bar.+"}`)
|
||
f(`foo {bar != "baz"}`)
|
||
f(` foo { bar !~ "^ddd(x+)$", a="ss", __name__="sffd"} `)
|
||
f(`(foo)`)
|
||
f(`\п\р\и\в\е\т{\ы="111"}`)
|
||
}
|
||
|
||
func TestParseMetricSelectorError(t *testing.T) {
|
||
f := func(s string) {
|
||
t.Helper()
|
||
tfs, err := ParseMetricSelector(s)
|
||
if err == nil {
|
||
t.Fatalf("expecting non-nil error when parsing %q", s)
|
||
}
|
||
if tfs != nil {
|
||
t.Fatalf("expecting nil tfs when parsing %q", s)
|
||
}
|
||
}
|
||
f("")
|
||
f(`{}`)
|
||
f(`foo bar`)
|
||
f(`foo+bar`)
|
||
f(`sum(bar)`)
|
||
f(`x{y}`)
|
||
f(`x{y+z}`)
|
||
f(`foo[5m]`)
|
||
f(`foo offset 5m`)
|
||
}
|
||
|
||
func TestJoinTagFilterss(t *testing.T) {
|
||
f := func(t *testing.T, src, etfs [][]storage.TagFilter, want []string) {
|
||
t.Helper()
|
||
result := JoinTagFilterss(src, etfs)
|
||
got := tagFilterssToStrings(result)
|
||
if !reflect.DeepEqual(got, want) {
|
||
t.Fatalf("unxpected result for JoinTagFilterss\ngot: %s\nwant: %v", got, want)
|
||
}
|
||
}
|
||
// Single tag filter
|
||
f(t, [][]storage.TagFilter{
|
||
mustParseMetricSelector(`{k1="v1",k2=~"v2",k3!="v3",k4!~"v4"}`),
|
||
}, nil, []string{
|
||
`{k1="v1",k2=~"v2",k3!="v3",k4!~"v4"}`,
|
||
})
|
||
// Miltiple tag filters
|
||
f(t, [][]storage.TagFilter{
|
||
mustParseMetricSelector(`{k1="v1",k2=~"v2",k3!="v3",k4!~"v4"}`),
|
||
mustParseMetricSelector(`{k5=~"v5"}`),
|
||
}, nil, []string{
|
||
`{k1="v1",k2=~"v2",k3!="v3",k4!~"v4"}`,
|
||
`{k5=~"v5"}`,
|
||
})
|
||
// Single extra filter
|
||
f(t, nil, [][]storage.TagFilter{
|
||
mustParseMetricSelector(`{k1="v1",k2=~"v2",k3!="v3",k4!~"v4"}`),
|
||
}, []string{
|
||
`{k1="v1",k2=~"v2",k3!="v3",k4!~"v4"}`,
|
||
})
|
||
// Multiple extra filters
|
||
f(t, nil, [][]storage.TagFilter{
|
||
mustParseMetricSelector(`{k1="v1",k2=~"v2",k3!="v3",k4!~"v4"}`),
|
||
mustParseMetricSelector(`{k5=~"v5"}`),
|
||
}, []string{
|
||
`{k1="v1",k2=~"v2",k3!="v3",k4!~"v4"}`,
|
||
`{k5=~"v5"}`,
|
||
})
|
||
// Single tag filter and a single extra filter
|
||
f(t, [][]storage.TagFilter{
|
||
mustParseMetricSelector(`{k1="v1",k2=~"v2",k3!="v3",k4!~"v4"}`),
|
||
}, [][]storage.TagFilter{
|
||
mustParseMetricSelector(`{k5=~"v5"}`),
|
||
}, []string{
|
||
`{k1="v1",k2=~"v2",k3!="v3",k4!~"v4",k5=~"v5"}`,
|
||
})
|
||
// Multiple tag filters and a single extra filter
|
||
f(t, [][]storage.TagFilter{
|
||
mustParseMetricSelector(`{k1="v1",k2=~"v2",k3!="v3",k4!~"v4"}`),
|
||
mustParseMetricSelector(`{k5=~"v5"}`),
|
||
}, [][]storage.TagFilter{
|
||
mustParseMetricSelector(`{k6=~"v6"}`),
|
||
}, []string{
|
||
`{k1="v1",k2=~"v2",k3!="v3",k4!~"v4",k6=~"v6"}`,
|
||
`{k5=~"v5",k6=~"v6"}`,
|
||
})
|
||
// Single tag filter and multiple extra filters
|
||
f(t, [][]storage.TagFilter{
|
||
mustParseMetricSelector(`{k1="v1",k2=~"v2",k3!="v3",k4!~"v4"}`),
|
||
}, [][]storage.TagFilter{
|
||
mustParseMetricSelector(`{k5=~"v5"}`),
|
||
mustParseMetricSelector(`{k6=~"v6"}`),
|
||
}, []string{
|
||
`{k1="v1",k2=~"v2",k3!="v3",k4!~"v4",k5=~"v5"}`,
|
||
`{k1="v1",k2=~"v2",k3!="v3",k4!~"v4",k6=~"v6"}`,
|
||
})
|
||
// Multiple tag filters and multiple extra filters
|
||
f(t, [][]storage.TagFilter{
|
||
mustParseMetricSelector(`{k1="v1",k2=~"v2",k3!="v3",k4!~"v4"}`),
|
||
mustParseMetricSelector(`{k5=~"v5"}`),
|
||
}, [][]storage.TagFilter{
|
||
mustParseMetricSelector(`{k6=~"v6"}`),
|
||
mustParseMetricSelector(`{k7=~"v7"}`),
|
||
}, []string{
|
||
`{k1="v1",k2=~"v2",k3!="v3",k4!~"v4",k6=~"v6"}`,
|
||
`{k1="v1",k2=~"v2",k3!="v3",k4!~"v4",k7=~"v7"}`,
|
||
`{k5=~"v5",k6=~"v6"}`,
|
||
`{k5=~"v5",k7=~"v7"}`,
|
||
})
|
||
}
|
||
|
||
func mustParseMetricSelector(s string) []storage.TagFilter {
|
||
tf, err := ParseMetricSelector(s)
|
||
if err != nil {
|
||
panic(fmt.Errorf("cannot parse %q: %w", s, err))
|
||
}
|
||
return tf
|
||
}
|
||
|
||
func tagFilterssToStrings(tfss [][]storage.TagFilter) []string {
|
||
var a []string
|
||
for _, tfs := range tfss {
|
||
a = append(a, tagFiltersToString(tfs))
|
||
}
|
||
return a
|
||
}
|
||
|
||
func tagFiltersToString(tfs []storage.TagFilter) string {
|
||
b := []byte("{")
|
||
for i, tf := range tfs {
|
||
b = append(b, tf.Key...)
|
||
if tf.IsNegative {
|
||
if tf.IsRegexp {
|
||
b = append(b, "!~"...)
|
||
} else {
|
||
b = append(b, "!="...)
|
||
}
|
||
} else {
|
||
if tf.IsRegexp {
|
||
b = append(b, "=~"...)
|
||
} else {
|
||
b = append(b, "="...)
|
||
}
|
||
}
|
||
b = strconv.AppendQuote(b, string(tf.Value))
|
||
if i+1 < len(tfs) {
|
||
b = append(b, ',')
|
||
}
|
||
}
|
||
b = append(b, '}')
|
||
return string(b)
|
||
}
|