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
import "testing"
//import "fmt"
type queryTestCase struct {
name string
query string
pass string
fail string
}
func TestTestVXID(t *testing.T) {
testTx := Tx{VXID: 1000}
vec := []struct {
query string
pass bool
}{
{"vxid == 1000", true},
{"vxid != 1000", false},
{"vxid < 1000", false},
{"vxid <= 1000", true},
{"vxid > 1000", false},
{"vxid >= 1000", true},
}
// Test vectors mostly adapted from l00001.vtc
var queryRecTestVec = []queryTestCase{
{"seq", `Begin eq "req 118200423 rxreq"`, "req 118200423 rxreq",
"req 118200424 rxreq"},
{"sneq", `Begin ne "req 118200424 rxreq"`, "req 118200423 rxreq",
"req 118200424 rxreq"},
{"eqInt", `RespStatus == 200`, "200", "404"},
{"eqFlt", "RespStatus == 200.", "200", "503"},
{"neqInt", "RespStatus != 503", "200", "503"},
{"neqFlt", "RespStatus != 503.", "200", "503"},
{"ltInt", "RespStatus < 201", "200", "503"},
{"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 {
expr, err := parseQuery(v.query)
if err != nil {
t.Fatal("parseQuery():", err)
continue
}
if expr.testVXID(testTx) != v.pass {
t.Errorf("testVXID() want=%v got=!want", v.pass)
}
}
var queryTxTestVec = []queryTestCase{
{"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`, "", ""},
{"lvlLeq", `{2-}Begin ~ req`, "", ""},
{"lvlGeq", `{0+}Begin ~ req`, "", ""},
}
// Tests from l00001.vtc
func TestTestRecord(t *testing.T) {
vec := []struct {
query string
pass string
fail string
}{
{`Begin eq "req 1000 rxreq"`,
"req 1000 rxreq", "req 1001 rxreq"},
{`ReqProtocol ne "HTTP/1.0"`, "HTTP/1.1", "HTTP/1.0"},
{`RespStatus == 200`, "200", "404"},
{"RespStatus == 200.", "200", "503"},
{"RespStatus != 503", "200", "503"},
{"RespStatus != 503.", "200", "503"},
{"RespStatus < 201", "200", "503"},
{"RespStatus < 201.", "200", "503"},
{"RespStatus > 199", "200", "100"},
{"RespStatus > 199.", "200", "100"},
{"RespStatus <= 200", "200", "503"},
{"RespStatus <= 200.", "200", "503"},
{"RespStatus >= 200", "200", "100"},
{"RespStatus >= 200.", "200", "100"},
{`RespStatus ~ "^200$"`, "200", " 200 "},
{`RespStatus !~ "^404$"`, "200", "404"},
{"RespHeader[2] == 123", "x-test: 123 321", "x-test: 321 123"},
{"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"},
var queryVxidTestVec = []queryTestCase{
{"vxidEq", "vxid == 118200424", "pass", ""},
{"vxidNeq", "vxid != 118200424", "", "fail"},
{"vxidLt", "vxid < 118200424", "", "fail"},
{"vxidLeq", "vxid <= 118200424", "pass", ""},
{"vxidGt", "vxid > 118200424", "", "fail"},
{"vxidGeq", "vxid >= 118200424", "pass", ""},
}
func TestTestVXID(t *testing.T) {
testTx := Tx{VXID: 118200424}
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.testVXID(testTx) {
t.Errorf("query='%s' testVXID() not true as "+
"expected", v.query)
}
if v.fail != "" && expr.testVXID(testTx) {
t.Errorf("query='%s' testVXID() not false as "+
"expected", v.query)
}
})
}
}
for _, v := range vec {
expr, err := parseQuery(v.query)
if err != nil {
t.Fatal("parseQuery():", err)
continue
}
func TestTestRecord(t *testing.T) {
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
}
passRec := Record{Payload: []byte(v.pass)}
failRec := Record{Payload: []byte(v.fail)}
if !expr.testRecord(passRec) {
t.Errorf("query='%s' testRecord(%s) did not succeed "+
"as expected", v.query, v.pass)
}
if expr.testRecord(failRec) {
t.Errorf("query='%s' testRecord(%s) did not fail as "+
"expected", v.query, v.fail)
}
passRec := Record{Payload: []byte(v.pass)}
failRec := Record{Payload: []byte(v.fail)}
if !expr.testRecord(passRec) {
t.Errorf("query='%s' testRecord(%s) did not "+
"succeed as expected", v.query, v.pass)
}
if expr.testRecord(failRec) {
t.Errorf("query='%s' testRecord(%s) did not "+
"fail as expected", v.query, v.fail)
}
})
}
}
func BenchmarkTestRecord(b *testing.B) {
vec := []struct {
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 {
for _, v := range queryRecTestVec {
b.Run(v.name, func(b *testing.B) {
expr, err := parseQuery(v.query)
if err != nil {
......@@ -144,7 +147,7 @@ func BenchmarkTestRecord(b *testing.B) {
return
}
rec := Record{Payload: []byte(v.payload)}
rec := Record{Payload: []byte(v.pass)}
b.ReportAllocs()
b.ResetTimer()
for i := 0; i < b.N; i++ {
......@@ -155,54 +158,6 @@ func BenchmarkTestRecord(b *testing.B) {
}
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()
defer l.Release()
c, err := l.NewCursorFile(l1Log)
......@@ -222,7 +177,19 @@ func TestEvalQuery(t *testing.T) {
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) {
expr, err := parseQuery(v.query)
if err != nil {
......@@ -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) {
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()
defer l.Release()
c, err := l.NewCursorFile(l1Log)
......@@ -304,7 +240,37 @@ func BenchmarkEvalQuery(b *testing.B) {
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) {
expr, err := parseQuery(v.query)
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