Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

test(validators): benchmark all the relevant validators #56

Merged
merged 1 commit into from
Nov 6, 2019
Merged

test(validators): benchmark all the relevant validators #56

Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
330 changes: 329 additions & 1 deletion schema_test.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -6,6 +6,9 @@ import (
"fmt"
"github.com/sergi/go-diff/diffmatchpatch"
"io/ioutil"
"strconv"
"strings"

// "net/http"
// "net/http/httptest"
"path/filepath"
Expand Down Expand Up @@ -449,7 +452,7 @@ func runJSONTests(t *testing.T, testFilepaths []string) {
}

func TestDataType(t *testing.T) {
type customObject struct {}
type customObject struct{}
type customNumber float64

cases := []struct {
Expand Down Expand Up @@ -576,3 +579,328 @@ func TestValidateBytes(t *testing.T) {

// }))
// }

func BenchmarkAdditionalItems(b *testing.B) {
runBenchmark(b,
func(sampleSize int) (string, interface{}) {
data := make([]interface{}, sampleSize)
for i := 0; i < sampleSize; i++ {
data[i] = float64(i)
}
return `{
"items": {},
"additionalItems": false
}`, data
},
)
}

func BenchmarkAdditionalProperties(b *testing.B) {
runBenchmark(b,
func(sampleSize int) (string, interface{}) {
data := make(map[string]interface{}, sampleSize)
for i := 0; i < sampleSize; i++ {
p := fmt.Sprintf("p%v", i)
data[p] = struct{}{}
}
d, err := json.Marshal(data)
if err != nil {
b.Errorf("unable to marshal data: %v", err)
return "", nil
}
return `{
"properties": ` + string(d) + `,
"additionalProperties": false
}`, data
},
)
}

func BenchmarkConst(b *testing.B) {
runBenchmark(b,
func(sampleSize int) (string, interface{}) {
data := make(map[string]interface{}, sampleSize)
for i := 0; i < sampleSize; i++ {
data[fmt.Sprintf("p%v", i)] = fmt.Sprintf("p%v", 2*i)
}
d, err := json.Marshal(data)
if err != nil {
b.Errorf("unable to marshal data: %v", err)
return "", nil
}
return `{
"const": ` + string(d) + `
}`, data
},
)
}

func BenchmarkContains(b *testing.B) {
runBenchmark(b,
func(sampleSize int) (string, interface{}) {
data := make([]interface{}, sampleSize)
for i := 0; i < sampleSize; i++ {
data[i] = float64(i)
}
return `{
"contains": { "const": ` + strconv.Itoa(sampleSize-1) + ` }
}`, data
},
)
}

func BenchmarkDependencies(b *testing.B) {
runBenchmark(b,
func(sampleSize int) (string, interface{}) {
data := make(map[string]interface{}, sampleSize)
deps := []string{}
for i := 0; i < sampleSize; i++ {
p := fmt.Sprintf("p%v", i)
data[p] = fmt.Sprintf("p%v", 2*i)
if i != 0 {
deps = append(deps, p)
}
}
d, err := json.Marshal(deps)
if err != nil {
b.Errorf("unable to marshal data: %v", err)
return "", nil
}
return `{
"dependencies": {"p0": ` + string(d) + `}
}`, data
},
)
}

func BenchmarkEnum(b *testing.B) {
runBenchmark(b,
func(sampleSize int) (string, interface{}) {
data := make([]interface{}, sampleSize)
for i := 0; i < sampleSize; i++ {
data[i] = float64(i)
}
d, err := json.Marshal(data)
if err != nil {
b.Errorf("unable to marshal data: %v", err)
return "", nil
}
return `{
"enum": ` + string(d) + `
}`, float64(sampleSize / 2)
},
)
}

func BenchmarkMaximum(b *testing.B) {
runBenchmark(b, func(sampleSize int) (string, interface{}) {
return `{
"maximum": 3
}`, float64(2)
})
}

func BenchmarkMinimum(b *testing.B) {
runBenchmark(b, func(sampleSize int) (string, interface{}) {
return `{
"minimum": 3
}`, float64(4)
})
}

func BenchmarkExclusiveMaximum(b *testing.B) {
runBenchmark(b, func(sampleSize int) (string, interface{}) {
return `{
"exclusiveMaximum": 3
}`, float64(2)
})
}

func BenchmarkExclusiveMinimum(b *testing.B) {
runBenchmark(b, func(sampleSize int) (string, interface{}) {
return `{
"exclusiveMinimum": 3
}`, float64(4)
})
}

func BenchmarkMaxItems(b *testing.B) {
runBenchmark(b,
func(sampleSize int) (string, interface{}) {
data := make([]interface{}, sampleSize)
for i := 0; i < sampleSize; i++ {
data[i] = float64(i)
}
return `{
"maxItems": 10000
}`, data
},
)
}

func BenchmarkMinItems(b *testing.B) {
runBenchmark(b,
func(sampleSize int) (string, interface{}) {
data := make([]interface{}, sampleSize)
for i := 0; i < sampleSize; i++ {
data[i] = float64(i)
}
return `{
"minItems": 1
}`, data
},
)
}

func BenchmarkMaxLength(b *testing.B) {
runBenchmark(b,
func(sampleSize int) (string, interface{}) {
data := make([]rune, sampleSize)
for i := 0; i < sampleSize; i++ {
data[i] = 'a'
}
return `{
"maxLength": ` + strconv.Itoa(sampleSize) + `
}`, string(data)
},
)
}

func BenchmarkMinLength(b *testing.B) {
runBenchmark(b,
func(sampleSize int) (string, interface{}) {
data := make([]rune, sampleSize)
for i := 0; i < sampleSize; i++ {
data[i] = 'a'
}
return `{
"minLength": 1
}`, string(data)
},
)
}

func BenchmarkMaxProperties(b *testing.B) {
runBenchmark(b,
func(sampleSize int) (string, interface{}) {
data := make(map[string]interface{}, sampleSize)
for i := 0; i < sampleSize; i++ {
data[fmt.Sprintf("p%v", i)] = fmt.Sprintf("p%v", 2*i)
}
return `{
"maxProperties": ` + strconv.Itoa(sampleSize) + `
}`, data
},
)
}

func BenchmarkMinProperties(b *testing.B) {
runBenchmark(b,
func(sampleSize int) (string, interface{}) {
data := make(map[string]interface{}, sampleSize)
for i := 0; i < sampleSize; i++ {
data[fmt.Sprintf("p%v", i)] = fmt.Sprintf("p%v", 2*i)
}
return `{
"minProperties": 1
}`, data
},
)
}

func BenchmarkMultipleOf(b *testing.B) {
runBenchmark(b,
func(sampleSize int) (string, interface{}) {
return `{
"multipleOf": 2
}`, float64(42)
},
)
}

func BenchmarkPattern(b *testing.B) {
runBenchmark(b,
func(sampleSize int) (string, interface{}) {
data := make([]rune, sampleSize)
for i := 0; i < sampleSize; i++ {
data[i] = 'a'
}
return `{
"pattern": "^a*$"
}`, string(data)
},
)
}

func BenchmarkType(b *testing.B) {
runBenchmark(b,
func(sampleSize int) (string, interface{}) {
data := make(map[string]interface{}, sampleSize)
var schema strings.Builder

for i := 0; i < sampleSize; i++ {
propNull := fmt.Sprintf("n%v", nil)
propBool := fmt.Sprintf("b%v", i)
propInt := fmt.Sprintf("i%v", i)
propFloat := fmt.Sprintf("f%v", i)
propStr := fmt.Sprintf("s%v", i)
propArr := fmt.Sprintf("a%v", i)
propObj := fmt.Sprintf("o%v", i)

data[propBool] = true
data[propInt] = float64(42)
data[propFloat] = float64(42.5)
data[propStr] = "foobar"
data[propArr] = []interface{}{interface{}(1), interface{}(2), interface{}(3)}
data[propObj] = struct{}{}

schema.WriteString(fmt.Sprintf(`"%v": { "type": "null" },`, propNull))
schema.WriteString(fmt.Sprintf(`"%v": { "type": "boolean" },`, propBool))
schema.WriteString(fmt.Sprintf(`"%v": { "type": "integer" },`, propInt))
schema.WriteString(fmt.Sprintf(`"%v": { "type": "number" },`, propFloat))
schema.WriteString(fmt.Sprintf(`"%v": { "type": "string" },`, propStr))
schema.WriteString(fmt.Sprintf(`"%v": { "type": "array" },`, propArr))
schema.WriteString(fmt.Sprintf(`"%v": { "type": "object" }`, propObj))

if i != sampleSize-1 {
schema.WriteString(",")
}
}

return `{
"type": "object",
"properties": { ` + schema.String() + ` }
}`, data
},
)
}

func runBenchmark(b *testing.B, dataFn func(sampleSize int) (string, interface{})) {
for _, sampleSize := range []int{1, 10, 100, 1000} {
b.Run(fmt.Sprintf("sample size %v", sampleSize), func(b *testing.B) {
schema, data := dataFn(sampleSize)
if data == nil {
b.Skip("data == nil, skipping")
return
}

var validator RootSchema
if err := json.Unmarshal([]byte(schema), &validator); err != nil {
b.Errorf("error parsing schema: %s", err.Error())
return
}

var errs []ValError

b.ResetTimer()
for i := 0; i < b.N; i++ {
validator.Validate("/", data, &errs)
}
b.StopTimer()

if len(errs) > 0 {
b.Errorf("error running benchmark: %s", errs)
}
})
}
}