/
schema_test.go
123 lines (111 loc) · 2.8 KB
/
schema_test.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
package schema_test
import (
"encoding/json"
"fmt"
"os"
"path/filepath"
"strings"
"testing"
"github.com/lestrrat-go/jsschema"
"github.com/lestrrat-go/jsschema/validator"
"github.com/stretchr/testify/assert"
)
func TestReadSchema(t *testing.T) {
files := []string{"schema.json", "qiita.json"}
for _, f := range files {
file := filepath.Join("test", f)
_, err := readSchema(file)
if !assert.NoError(t, err, "readSchema(%s) should succeed", file) {
return
}
}
}
func readSchema(f string) (*schema.Schema, error) {
in, err := os.Open(f)
if err != nil {
return nil, err
}
return schema.Read(in)
}
func TestValidate(t *testing.T) {
tests := []string{
"allof",
"anyof",
"array",
"arraylength",
"arraytuple",
"arraytuple_disallow_additional",
"arrayunique",
"boolean",
"business",
"integer",
"not",
"null",
"numrange",
"numrange_exclmax",
"objectpatterns",
"objectpropdepend",
"objectpropsize",
"objectproprequired",
"oneof",
"strlen",
"strpattern",
}
for _, name := range tests {
schemaf := filepath.Join("test", name+".json")
t.Logf("Reading schema file %s", schemaf)
schema, err := readSchema(schemaf)
if !assert.NoError(t, err, "reading schema file %s should succeed", schemaf) {
return
}
valid := validator.New(schema)
pat := filepath.Join("test", fmt.Sprintf("%s_pass*.json", name))
files, _ := filepath.Glob(pat)
for _, passf := range files {
t.Logf("Testing schema against %s (expect to PASS)", passf)
passin, err := os.Open(passf)
if !assert.NoError(t, err, "os.Open(%s) should succeed", passf) {
return
}
var m map[string]interface{} // XXX should test against structs
if !assert.NoError(t, json.NewDecoder(passin).Decode(&m), "json.Decode should succeed") {
return
}
if !assert.NoError(t, valid.Validate(m), "schema.Validate should succeed") {
return
}
}
pat = filepath.Join("test", fmt.Sprintf("%s_fail*.json", name))
files, _ = filepath.Glob(pat)
for _, failf := range files {
t.Logf("Testing schema against %s (expect to FAIL)", failf)
failin, err := os.Open(failf)
if !assert.NoError(t, err, "os.Open(%s) should succeed", failf) {
return
}
var m map[string]interface{} // XXX should test against structs
if !assert.NoError(t, json.NewDecoder(failin).Decode(&m), "json.Decode should succeed") {
return
}
if !assert.Error(t, valid.Validate(m), "schema.Validate should fail") {
return
}
}
}
}
func TestExtras(t *testing.T) {
const src = `{
"extra1": "foo",
"extra2": ["bar", "baz"]
}`
s, err := schema.Read(strings.NewReader(src))
if !assert.NoError(t, err, "schema.Read should succeed") {
return
}
for _, ek := range []string{"extra1", "extra2"} {
_, ok := s.Extras[ek]
if !assert.True(t, ok, "Extra item '%s' should exist", ek) {
return
}
}
}