Skip to content

V
varnishapi
Commit 8f45f964 authored by Geoff Simmons's avatar Geoff Simmons
Browse files
Options

Refactor the test vectors for log queries (3 tables drive all tests).

parent 2db27759
Hide whitespace changes
Inline Side-by-side
Showing with 161 additions and 195 deletions
pkg/log/query_eval_test.go
View file @ 8f45f964
...@@ -30,113 +30,116 @@ package log ...@@ -30,113 +30,116 @@ package log
import "testing" import "testing"
//import "fmt" type queryTestCase struct {
name string
query string
pass string
fail string
}
func TestTestVXID(t *testing.T) { // Test vectors mostly adapted from l00001.vtc
testTx := Tx{VXID: 1000} var queryRecTestVec = []queryTestCase{
vec := []struct { {"seq", `Begin eq "req 118200423 rxreq"`, "req 118200423 rxreq",
query string "req 118200424 rxreq"},
pass bool {"sneq", `Begin ne "req 118200424 rxreq"`, "req 118200423 rxreq",
}{ "req 118200424 rxreq"},
{"vxid == 1000", true}, {"eqInt", `RespStatus == 200`, "200", "404"},
{"vxid != 1000", false}, {"eqFlt", "RespStatus == 200.", "200", "503"},
{"vxid < 1000", false}, {"neqInt", "RespStatus != 503", "200", "503"},
{"vxid <= 1000", true}, {"neqFlt", "RespStatus != 503.", "200", "503"},
{"vxid > 1000", false}, {"ltInt", "RespStatus < 201", "200", "503"},
{"vxid >= 1000", true}, {"ltFlt", "RespStatus < 201.", "200", "503"},
} {"gtInt", "RespStatus > 199", "200", "100"},
{"gtFlt", "RespStatus > 199.", "200", "100"},
{"leqInt", "RespStatus <= 200", "200", "503"},
{"leqFlt", "RespStatus <= 200.", "200", "503"},
{"geqInt", "RespStatus >= 200", "200", "100"},
{"geqFlt", "RespStatus >= 200.", "200", "100"},
{"match", `RespStatus ~ "^200$"`, "200", " 200 "},
{"nomatch", `RespStatus !~ "^404$"`, "200", "404"},
{"fldInt", "RespHeader[2] == 123", "x-test: 123 321",
"x-test: 321 123"},
{"fldFlt", "RespHeader[2] == 123.", "x-test: 123 321",
"x-test: 321 123"},
{"fldSeq", "RespHeader[2] eq 123", "x-test: 123 321",
"x-test: 321 123"},
{"fldSneq", "RespHeader[2] ne 123", "x-test: 321 123",
"x-test: 123 321"},
}
for _, v := range vec { var queryTxTestVec = []queryTestCase{
expr, err := parseQuery(v.query) {"and", `RespStatus == 200 and RespStatus ~ "^200$"`, "", ""},
if err != nil { {"or", `RespStatus == 404 or RespStatus ~ "^200$"`, "", ""},
t.Fatal("parseQuery():", err) {"not", `RespStatus == 404 or not RespStatus ~ "^404"`, "", ""},
continue {"exprGrp",
} `(RespStatus == 200 or RespStatus == 404) and RespStatus == 200`,
if expr.testVXID(testTx) != v.pass { "", ""},
t.Errorf("testVXID() want=%v got=!want", v.pass) {"andOr",
} `RespStatus == 200 or RespStatus == 503 and RespStatus == 404`,
} "", ""},
{"tagList", `Debug,Resp* == 200`, "", ""},
{"prefix", `Resp*:x-test eq "123 321"`, "", ""},
{"noRHS", `RespStatus`, "", ""},
{"lvlEq", `{1}Begin ~ req`, "", ""},
{"lvlLeq", `{2-}Begin ~ req`, "", ""},
{"lvlGeq", `{0+}Begin ~ req`, "", ""},
} }
// Tests from l00001.vtc var queryVxidTestVec = []queryTestCase{
func TestTestRecord(t *testing.T) { {"vxidEq", "vxid == 118200424", "pass", ""},
vec := []struct { {"vxidNeq", "vxid != 118200424", "", "fail"},
query string {"vxidLt", "vxid < 118200424", "", "fail"},
pass string {"vxidLeq", "vxid <= 118200424", "pass", ""},
fail string {"vxidGt", "vxid > 118200424", "", "fail"},
}{ {"vxidGeq", "vxid >= 118200424", "pass", ""},
{`Begin eq "req 1000 rxreq"`, }
"req 1000 rxreq", "req 1001 rxreq"},
{`ReqProtocol ne "HTTP/1.0"`, "HTTP/1.1", "HTTP/1.0"}, func TestTestVXID(t *testing.T) {
{`RespStatus == 200`, "200", "404"}, testTx := Tx{VXID: 118200424}
{"RespStatus == 200.", "200", "503"}, for _, v := range queryVxidTestVec {
{"RespStatus != 503", "200", "503"}, t.Run(v.name, func(t *testing.T) {
{"RespStatus != 503.", "200", "503"}, expr, err := parseQuery(v.query)
{"RespStatus < 201", "200", "503"}, if err != nil {
{"RespStatus < 201.", "200", "503"}, t.Fatal("parseQuery():", err)
{"RespStatus > 199", "200", "100"}, return
{"RespStatus > 199.", "200", "100"}, }
{"RespStatus <= 200", "200", "503"}, if v.pass != "" && !expr.testVXID(testTx) {
{"RespStatus <= 200.", "200", "503"}, t.Errorf("query='%s' testVXID() not true as "+
{"RespStatus >= 200", "200", "100"}, "expected", v.query)
{"RespStatus >= 200.", "200", "100"}, }
{`RespStatus ~ "^200$"`, "200", " 200 "}, if v.fail != "" && expr.testVXID(testTx) {
{`RespStatus !~ "^404$"`, "200", "404"}, t.Errorf("query='%s' testVXID() not false as "+
{"RespHeader[2] == 123", "x-test: 123 321", "x-test: 321 123"}, "expected", v.query)
{"RespHeader[2] == 123.", "x-test: 123 321", "x-test: 321 123"}, }
{"RespHeader[2] eq 123", "x-test: 123 321", "x-test: 321 123"}, })
{"RespHeader[2] ne 123", "x-test: 321 123", "x-test: 123 321"},
} }
}
for _, v := range vec { func TestTestRecord(t *testing.T) {
expr, err := parseQuery(v.query) for _, v := range queryRecTestVec {
if err != nil { t.Run(v.name, func(t *testing.T) {
t.Fatal("parseQuery():", err) expr, err := parseQuery(v.query)
continue if err != nil {
} t.Fatal("parseQuery():", err)
return
}
passRec := Record{Payload: []byte(v.pass)} passRec := Record{Payload: []byte(v.pass)}
failRec := Record{Payload: []byte(v.fail)} failRec := Record{Payload: []byte(v.fail)}
if !expr.testRecord(passRec) { if !expr.testRecord(passRec) {
t.Errorf("query='%s' testRecord(%s) did not succeed "+ t.Errorf("query='%s' testRecord(%s) did not "+
"as expected", v.query, v.pass) "succeed as expected", v.query, v.pass)
} }
if expr.testRecord(failRec) { if expr.testRecord(failRec) {
t.Errorf("query='%s' testRecord(%s) did not fail as "+ t.Errorf("query='%s' testRecord(%s) did not "+
"expected", v.query, v.fail) "fail as expected", v.query, v.fail)
} }
})
} }
} }
func BenchmarkTestRecord(b *testing.B) { func BenchmarkTestRecord(b *testing.B) {
vec := []struct { for _, v := range queryRecTestVec {
name string
query string
payload string
}{
{"seq", `Begin eq "req 1000 rxreq"`, "req 1000 rxreq"},
{"sneq", `Begin ne "req 1000 rxreq"`, "req 1000 rxreq"},
{"eqInt", `RespStatus == 200`, "200"},
{"eqFlt", "RespStatus == 200.", "200"},
{"neqInt", "RespStatus != 503", "200"},
{"neqFlt", "RespStatus != 503.", "200"},
{"ltInt", "RespStatus < 201", "200"},
{"ltFlt", "RespStatus < 201.", "200"},
{"gtInt", "RespStatus > 199", "200"},
{"gtFlt", "RespStatus > 199.", "200"},
{"leqInt", "RespStatus <= 200", "200"},
{"leqFlt", "RespStatus <= 200.", "200"},
{"geqInt", "RespStatus >= 200", "200"},
{"geqFlt", "RespStatus >= 200.", "200"},
{"match", `RespStatus ~ "^200$"`, "200"},
{"nomatch", `RespStatus !~ "^404$"`, "200"},
{"fldInt", "RespHeader[2] == 123", "x-test: 123 321"},
{"fldFlt", "RespHeader[2] == 123.", "x-test: 123 321"},
{"fldSeq", "RespHeader[2] eq 123", "x-test: 123 321"},
{"fldSneq", "RespHeader[2] ne 123", "x-test: 321 123"},
}
for _, v := range vec {
b.Run(v.name, func(b *testing.B) { b.Run(v.name, func(b *testing.B) {
expr, err := parseQuery(v.query) expr, err := parseQuery(v.query)
if err != nil { if err != nil {
...@@ -144,7 +147,7 @@ func BenchmarkTestRecord(b *testing.B) { ...@@ -144,7 +147,7 @@ func BenchmarkTestRecord(b *testing.B) {
return return
} }
rec := Record{Payload: []byte(v.payload)} rec := Record{Payload: []byte(v.pass)}
b.ReportAllocs() b.ReportAllocs()
b.ResetTimer() b.ResetTimer()
for i := 0; i < b.N; i++ { for i := 0; i < b.N; i++ {
...@@ -155,54 +158,6 @@ func BenchmarkTestRecord(b *testing.B) { ...@@ -155,54 +158,6 @@ func BenchmarkTestRecord(b *testing.B) {
} }
func TestEvalQuery(t *testing.T) { func TestEvalQuery(t *testing.T) {
vec := []struct {
name string
query string
}{
{"seq", `Begin eq "req 118200423 rxreq"`},
{"sneq", `Begin ne "req 1000 rxreq"`},
{"eqInt", `RespStatus == 200`},
{"eqFlt", "RespStatus == 200."},
{"neqInt", "RespStatus != 503"},
{"neqFlt", "RespStatus != 503."},
{"ltInt", "RespStatus < 201"},
{"ltFlt", "RespStatus < 201."},
{"gtInt", "RespStatus > 199"},
{"gtFlt", "RespStatus > 199."},
{"leqInt", "RespStatus <= 200"},
{"leqFlt", "RespStatus <= 200."},
{"geqInt", "RespStatus >= 200"},
{"geqFlt", "RespStatus >= 200."},
{"match", `RespStatus ~ "^200$"`},
{"nomatch", `RespStatus !~ "^404$"`},
{"fldInt", "RespHeader[2] == 123"},
{"fldFlt", "RespHeader[2] == 123."},
{"fldSeq", "RespHeader[2] eq 123"},
{"fldSneq", "RespHeader[2] ne 123"},
{"and", `RespStatus == 200 and RespStatus ~ "^200$"`},
{"or", `RespStatus == 404 or RespStatus ~ "^200$"`},
{"not", `RespStatus == 404 or not RespStatus ~ "^404"`},
{"exprGrp",
`(RespStatus == 200 or RespStatus == 404) and RespStatus == 200`},
{"andOr",
`RespStatus == 200 or RespStatus == 503 and RespStatus == 404`},
{"tagList", `Debug,Resp* == 200`},
{"prefix", `Resp*:x-test eq "123 321"`},
{"noRHS", `RespStatus`},
{"lvlEq", `{1}Begin ~ req`},
{"lvlEq", `{1}Begin ~ req`},
{"lvlLeq", `{2-}Begin ~ req`},
{"lvlGeq", `{0+}Begin ~ req`},
{"vxidEq", "vxid == 118200424"},
{"vxidNeq", "vxid != 1000"},
{"vxidLt", "vxid < 118200425"},
{"vxidLeq", "vxid <= 118200424"},
{"vxidGt", "vxid > 1000"},
{"vxidGeq", "vxid >= 1000"},
}
l := New() l := New()
defer l.Release() defer l.Release()
c, err := l.NewCursorFile(l1Log) c, err := l.NewCursorFile(l1Log)
...@@ -222,7 +177,19 @@ func TestEvalQuery(t *testing.T) { ...@@ -222,7 +177,19 @@ func TestEvalQuery(t *testing.T) {
t.Fatalf("NextTxGrp() status want=Mode got=%v", status) t.Fatalf("NextTxGrp() status want=Mode got=%v", status)
} }
for _, v := range vec { for _, v := range queryRecTestVec {
t.Run(v.name, func(t *testing.T) {
expr, err := parseQuery(v.query)
if err != nil {
t.Fatal("parseQuery():", err)
return
}
if !expr.eval(txGrp) {
t.Error("eval(txGrp) want=true got=false")
}
})
}
for _, v := range queryTxTestVec {
t.Run(v.name, func(t *testing.T) { t.Run(v.name, func(t *testing.T) {
expr, err := parseQuery(v.query) expr, err := parseQuery(v.query)
if err != nil { if err != nil {
...@@ -234,57 +201,26 @@ func TestEvalQuery(t *testing.T) { ...@@ -234,57 +201,26 @@ func TestEvalQuery(t *testing.T) {
} }
}) })
} }
for _, v := range queryVxidTestVec {
t.Run(v.name, func(t *testing.T) {
expr, err := parseQuery(v.query)
if err != nil {
t.Fatal("parseQuery():", err)
return
}
if v.pass != "" && !expr.eval(txGrp) {
t.Errorf("query='%s' eval(txGrp) not true as "+
"expected", v.query)
}
if v.fail != "" && expr.eval(txGrp) {
t.Errorf("query='%s' eval(txGrp) not false as "+
"expected", v.query)
}
})
}
} }
func BenchmarkEvalQuery(b *testing.B) { func BenchmarkEvalQuery(b *testing.B) {
vec := []struct {
name string
query string
}{
{"seq", `Begin eq "req 118200423 rxreq"`},
{"sneq", `Begin ne "req 1000 rxreq"`},
{"eqInt", `RespStatus == 200`},
{"eqFlt", "RespStatus == 200."},
{"neqInt", "RespStatus != 503"},
{"neqFlt", "RespStatus != 503."},
{"ltInt", "RespStatus < 201"},
{"ltFlt", "RespStatus < 201."},
{"gtInt", "RespStatus > 199"},
{"gtFlt", "RespStatus > 199."},
{"leqInt", "RespStatus <= 200"},
{"leqFlt", "RespStatus <= 200."},
{"geqInt", "RespStatus >= 200"},
{"geqFlt", "RespStatus >= 200."},
{"match", `RespStatus ~ "^200$"`},
{"nomatch", `RespStatus !~ "^404$"`},
{"fldInt", "RespHeader[2] == 123"},
{"fldFlt", "RespHeader[2] == 123."},
{"fldSeq", "RespHeader[2] eq 123"},
{"fldSneq", "RespHeader[2] ne 123"},
{"and", `RespStatus == 200 and RespStatus ~ "^200$"`},
{"or", `RespStatus == 404 or RespStatus ~ "^200$"`},
{"not", `RespStatus == 404 or not RespStatus ~ "^404"`},
{"exprGrp",
`(RespStatus == 200 or RespStatus == 404) and RespStatus == 200`},
{"andOr",
`RespStatus == 200 or RespStatus == 503 and RespStatus == 404`},
{"tagList", `Debug,Resp* == 200`},
{"prefix", `Resp*:x-test eq "123 321"`},
{"noRHS", `RespStatus`},
{"lvlEq", `{1}Begin ~ req`},
{"lvlEq", `{1}Begin ~ req`},
{"lvlLeq", `{2-}Begin ~ req`},
{"lvlGeq", `{0+}Begin ~ req`},
{"vxidEq", "vxid == 118200424"},
{"vxidNeq", "vxid != 1000"},
{"vxidLt", "vxid < 118200425"},
{"vxidLeq", "vxid <= 118200424"},
{"vxidGt", "vxid > 1000"},
{"vxidGeq", "vxid >= 1000"},
}
l := New() l := New()
defer l.Release() defer l.Release()
c, err := l.NewCursorFile(l1Log) c, err := l.NewCursorFile(l1Log)
...@@ -304,7 +240,37 @@ func BenchmarkEvalQuery(b *testing.B) { ...@@ -304,7 +240,37 @@ func BenchmarkEvalQuery(b *testing.B) {
b.Fatalf("NextTxGrp() status want=Mode got=%v", status) b.Fatalf("NextTxGrp() status want=Mode got=%v", status)
} }
for _, v := range vec { for _, v := range queryRecTestVec {
b.Run(v.name, func(b *testing.B) {
expr, err := parseQuery(v.query)
if err != nil {
b.Fatal("parseQuery():", err)
return
}
b.ReportAllocs()
b.ResetTimer()
for i := 0; i < b.N; i++ {
expr.eval(txGrp)
}
})
}
for _, v := range queryTxTestVec {
b.Run(v.name, func(b *testing.B) {
expr, err := parseQuery(v.query)
if err != nil {
b.Fatal("parseQuery():", err)
return
}
b.ReportAllocs()
b.ResetTimer()
for i := 0; i < b.N; i++ {
expr.eval(txGrp)
}
})
}
for _, v := range queryVxidTestVec {
b.Run(v.name, func(b *testing.B) { b.Run(v.name, func(b *testing.B) {
expr, err := parseQuery(v.query) expr, err := parseQuery(v.query)
if err != nil { if err != nil {
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment