Add generated file
This PR adds generated files under pkg/client and vendor folder.
This commit is contained in:
573
vendor/github.com/go-openapi/jsonpointer/pointer_test.go
generated
vendored
Normal file
573
vendor/github.com/go-openapi/jsonpointer/pointer_test.go
generated
vendored
Normal file
@@ -0,0 +1,573 @@
|
||||
// Copyright 2013 sigu-399 ( https://github.com/sigu-399 )
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
// author sigu-399
|
||||
// author-github https://github.com/sigu-399
|
||||
// author-mail sigu.399@gmail.com
|
||||
//
|
||||
// repository-name jsonpointer
|
||||
// repository-desc An implementation of JSON Pointer - Go language
|
||||
//
|
||||
// description Automated tests on package.
|
||||
//
|
||||
// created 03-03-2013
|
||||
|
||||
package jsonpointer
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"strconv"
|
||||
"testing"
|
||||
|
||||
"github.com/stretchr/testify/assert"
|
||||
)
|
||||
|
||||
const (
|
||||
TestDocumentNBItems = 11
|
||||
TestNodeObjNBItems = 4
|
||||
TestDocumentString = `{
|
||||
"foo": ["bar", "baz"],
|
||||
"obj": { "a":1, "b":2, "c":[3,4], "d":[ {"e":9}, {"f":[50,51]} ] },
|
||||
"": 0,
|
||||
"a/b": 1,
|
||||
"c%d": 2,
|
||||
"e^f": 3,
|
||||
"g|h": 4,
|
||||
"i\\j": 5,
|
||||
"k\"l": 6,
|
||||
" ": 7,
|
||||
"m~n": 8
|
||||
}`
|
||||
)
|
||||
|
||||
var testDocumentJSON interface{}
|
||||
|
||||
type testStructJSON struct {
|
||||
Foo []string `json:"foo"`
|
||||
Obj struct {
|
||||
A int `json:"a"`
|
||||
B int `json:"b"`
|
||||
C []int `json:"c"`
|
||||
D []struct {
|
||||
E int `json:"e"`
|
||||
F []int `json:"f"`
|
||||
} `json:"d"`
|
||||
} `json:"obj"`
|
||||
}
|
||||
|
||||
type aliasedMap map[string]interface{}
|
||||
|
||||
var testStructJSONDoc testStructJSON
|
||||
var testStructJSONPtr *testStructJSON
|
||||
|
||||
func init() {
|
||||
json.Unmarshal([]byte(TestDocumentString), &testDocumentJSON)
|
||||
json.Unmarshal([]byte(TestDocumentString), &testStructJSONDoc)
|
||||
testStructJSONPtr = &testStructJSONDoc
|
||||
}
|
||||
|
||||
func TestEscaping(t *testing.T) {
|
||||
|
||||
ins := []string{`/`, `/`, `/a~1b`, `/a~1b`, `/c%d`, `/e^f`, `/g|h`, `/i\j`, `/k"l`, `/ `, `/m~0n`}
|
||||
outs := []float64{0, 0, 1, 1, 2, 3, 4, 5, 6, 7, 8}
|
||||
|
||||
for i := range ins {
|
||||
p, err := New(ins[i])
|
||||
if assert.NoError(t, err, "input: %v", ins[i]) {
|
||||
result, _, err := p.Get(testDocumentJSON)
|
||||
if assert.NoError(t, err, "input: %v", ins[i]) {
|
||||
assert.Equal(t, outs[i], result, "input: %v", ins[i])
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
func TestFullDocument(t *testing.T) {
|
||||
|
||||
in := ``
|
||||
|
||||
p, err := New(in)
|
||||
if err != nil {
|
||||
t.Errorf("New(%v) error %v", in, err.Error())
|
||||
}
|
||||
|
||||
result, _, err := p.Get(testDocumentJSON)
|
||||
if err != nil {
|
||||
t.Errorf("Get(%v) error %v", in, err.Error())
|
||||
}
|
||||
|
||||
if len(result.(map[string]interface{})) != TestDocumentNBItems {
|
||||
t.Errorf("Get(%v) = %v, expect full document", in, result)
|
||||
}
|
||||
|
||||
result, _, err = p.get(testDocumentJSON, nil)
|
||||
if err != nil {
|
||||
t.Errorf("Get(%v) error %v", in, err.Error())
|
||||
}
|
||||
|
||||
if len(result.(map[string]interface{})) != TestDocumentNBItems {
|
||||
t.Errorf("Get(%v) = %v, expect full document", in, result)
|
||||
}
|
||||
}
|
||||
|
||||
func TestDecodedTokens(t *testing.T) {
|
||||
p, err := New("/obj/a~1b")
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, []string{"obj", "a/b"}, p.DecodedTokens())
|
||||
}
|
||||
|
||||
func TestIsEmpty(t *testing.T) {
|
||||
p, err := New("")
|
||||
assert.NoError(t, err)
|
||||
assert.True(t, p.IsEmpty())
|
||||
p, err = New("/obj")
|
||||
assert.NoError(t, err)
|
||||
assert.False(t, p.IsEmpty())
|
||||
}
|
||||
|
||||
func TestGetSingle(t *testing.T) {
|
||||
in := `/obj`
|
||||
|
||||
_, err := New(in)
|
||||
assert.NoError(t, err)
|
||||
result, _, err := GetForToken(testDocumentJSON, "obj")
|
||||
assert.NoError(t, err)
|
||||
assert.Len(t, result, TestNodeObjNBItems)
|
||||
|
||||
result, _, err = GetForToken(testStructJSONDoc, "Obj")
|
||||
assert.Error(t, err)
|
||||
assert.Nil(t, result)
|
||||
|
||||
result, _, err = GetForToken(testStructJSONDoc, "Obj2")
|
||||
assert.Error(t, err)
|
||||
assert.Nil(t, result)
|
||||
}
|
||||
|
||||
type pointableImpl struct {
|
||||
a string
|
||||
}
|
||||
|
||||
func (p pointableImpl) JSONLookup(token string) (interface{}, error) {
|
||||
if token == "some" {
|
||||
return p.a, nil
|
||||
}
|
||||
return nil, fmt.Errorf("object has no field %q", token)
|
||||
}
|
||||
|
||||
func TestPointableInterface(t *testing.T) {
|
||||
p := &pointableImpl{"hello"}
|
||||
|
||||
result, _, err := GetForToken(p, "some")
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, p.a, result)
|
||||
|
||||
result, _, err = GetForToken(p, "something")
|
||||
assert.Error(t, err)
|
||||
assert.Nil(t, result)
|
||||
}
|
||||
|
||||
func TestGetNode(t *testing.T) {
|
||||
|
||||
in := `/obj`
|
||||
|
||||
p, err := New(in)
|
||||
assert.NoError(t, err)
|
||||
result, _, err := p.Get(testDocumentJSON)
|
||||
assert.NoError(t, err)
|
||||
assert.Len(t, result, TestNodeObjNBItems)
|
||||
|
||||
result, _, err = p.Get(aliasedMap(testDocumentJSON.(map[string]interface{})))
|
||||
assert.NoError(t, err)
|
||||
assert.Len(t, result, TestNodeObjNBItems)
|
||||
|
||||
result, _, err = p.Get(testStructJSONDoc)
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, testStructJSONDoc.Obj, result)
|
||||
|
||||
result, _, err = p.Get(testStructJSONPtr)
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, testStructJSONDoc.Obj, result)
|
||||
}
|
||||
|
||||
func TestArray(t *testing.T) {
|
||||
|
||||
ins := []string{`/foo/0`, `/foo/0`, `/foo/1`}
|
||||
outs := []string{"bar", "bar", "baz"}
|
||||
|
||||
for i := range ins {
|
||||
p, err := New(ins[i])
|
||||
assert.NoError(t, err)
|
||||
|
||||
result, _, err := p.Get(testStructJSONDoc)
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, outs[i], result)
|
||||
|
||||
result, _, err = p.Get(testStructJSONPtr)
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, outs[i], result)
|
||||
|
||||
result, _, err = p.Get(testDocumentJSON)
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, outs[i], result)
|
||||
}
|
||||
}
|
||||
|
||||
func TestOtherThings(t *testing.T) {
|
||||
_, err := New("abc")
|
||||
assert.Error(t, err)
|
||||
|
||||
p, err := New("")
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, "", p.String())
|
||||
|
||||
p, err = New("/obj/a")
|
||||
assert.Equal(t, "/obj/a", p.String())
|
||||
|
||||
s := Escape("m~n")
|
||||
assert.Equal(t, "m~0n", s)
|
||||
s = Escape("m/n")
|
||||
assert.Equal(t, "m~1n", s)
|
||||
|
||||
p, err = New("/foo/3")
|
||||
assert.NoError(t, err)
|
||||
_, _, err = p.Get(testDocumentJSON)
|
||||
assert.Error(t, err)
|
||||
|
||||
p, err = New("/foo/a")
|
||||
assert.NoError(t, err)
|
||||
_, _, err = p.Get(testDocumentJSON)
|
||||
assert.Error(t, err)
|
||||
|
||||
p, err = New("/notthere")
|
||||
assert.NoError(t, err)
|
||||
_, _, err = p.Get(testDocumentJSON)
|
||||
assert.Error(t, err)
|
||||
|
||||
p, err = New("/invalid")
|
||||
assert.NoError(t, err)
|
||||
_, _, err = p.Get(1234)
|
||||
assert.Error(t, err)
|
||||
|
||||
p, err = New("/foo/1")
|
||||
assert.NoError(t, err)
|
||||
expected := "hello"
|
||||
bbb := testDocumentJSON.(map[string]interface{})["foo"]
|
||||
bbb.([]interface{})[1] = "hello"
|
||||
|
||||
v, _, err := p.Get(testDocumentJSON)
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, expected, v)
|
||||
|
||||
esc := Escape("a/")
|
||||
assert.Equal(t, "a~1", esc)
|
||||
unesc := Unescape(esc)
|
||||
assert.Equal(t, "a/", unesc)
|
||||
|
||||
unesc = Unescape("~01")
|
||||
assert.Equal(t, "~1", unesc)
|
||||
assert.Equal(t, "~0~1", Escape("~/"))
|
||||
assert.Equal(t, "~/", Unescape("~0~1"))
|
||||
}
|
||||
|
||||
func TestObject(t *testing.T) {
|
||||
|
||||
ins := []string{`/obj/a`, `/obj/b`, `/obj/c/0`, `/obj/c/1`, `/obj/c/1`, `/obj/d/1/f/0`}
|
||||
outs := []float64{1, 2, 3, 4, 4, 50}
|
||||
|
||||
for i := range ins {
|
||||
|
||||
p, err := New(ins[i])
|
||||
assert.NoError(t, err)
|
||||
|
||||
result, _, err := p.Get(testDocumentJSON)
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, outs[i], result)
|
||||
|
||||
result, _, err = p.Get(testStructJSONDoc)
|
||||
assert.NoError(t, err)
|
||||
assert.EqualValues(t, outs[i], result)
|
||||
|
||||
result, _, err = p.Get(testStructJSONPtr)
|
||||
assert.NoError(t, err)
|
||||
assert.EqualValues(t, outs[i], result)
|
||||
}
|
||||
}
|
||||
|
||||
type setJsonDocEle struct {
|
||||
B int `json:"b"`
|
||||
C int `json:"c"`
|
||||
}
|
||||
type setJsonDoc struct {
|
||||
A []struct {
|
||||
B int `json:"b"`
|
||||
C int `json:"c"`
|
||||
} `json:"a"`
|
||||
D int `json:"d"`
|
||||
}
|
||||
|
||||
type settableDoc struct {
|
||||
Coll settableColl
|
||||
Int settableInt
|
||||
}
|
||||
|
||||
func (s settableDoc) MarshalJSON() ([]byte, error) {
|
||||
var res struct {
|
||||
A settableColl `json:"a"`
|
||||
D settableInt `json:"d"`
|
||||
}
|
||||
res.A = s.Coll
|
||||
res.D = s.Int
|
||||
return json.Marshal(res)
|
||||
}
|
||||
func (s *settableDoc) UnmarshalJSON(data []byte) error {
|
||||
var res struct {
|
||||
A settableColl `json:"a"`
|
||||
D settableInt `json:"d"`
|
||||
}
|
||||
|
||||
if err := json.Unmarshal(data, &res); err != nil {
|
||||
return err
|
||||
}
|
||||
s.Coll = res.A
|
||||
s.Int = res.D
|
||||
return nil
|
||||
}
|
||||
|
||||
// JSONLookup implements an interface to customize json pointer lookup
|
||||
func (s settableDoc) JSONLookup(token string) (interface{}, error) {
|
||||
switch token {
|
||||
case "a":
|
||||
return &s.Coll, nil
|
||||
case "d":
|
||||
return &s.Int, nil
|
||||
default:
|
||||
return nil, fmt.Errorf("%s is not a known field", token)
|
||||
}
|
||||
}
|
||||
|
||||
// JSONLookup implements an interface to customize json pointer lookup
|
||||
func (s *settableDoc) JSONSet(token string, data interface{}) error {
|
||||
switch token {
|
||||
case "a":
|
||||
switch dt := data.(type) {
|
||||
case settableColl:
|
||||
s.Coll = dt
|
||||
return nil
|
||||
case *settableColl:
|
||||
if dt != nil {
|
||||
s.Coll = *dt
|
||||
} else {
|
||||
s.Coll = settableColl{}
|
||||
}
|
||||
return nil
|
||||
case []settableCollItem:
|
||||
s.Coll.Items = dt
|
||||
return nil
|
||||
}
|
||||
case "d":
|
||||
switch dt := data.(type) {
|
||||
case settableInt:
|
||||
s.Int = dt
|
||||
return nil
|
||||
case int:
|
||||
s.Int.Value = dt
|
||||
return nil
|
||||
case int8:
|
||||
s.Int.Value = int(dt)
|
||||
return nil
|
||||
case int16:
|
||||
s.Int.Value = int(dt)
|
||||
return nil
|
||||
case int32:
|
||||
s.Int.Value = int(dt)
|
||||
return nil
|
||||
case int64:
|
||||
s.Int.Value = int(dt)
|
||||
return nil
|
||||
default:
|
||||
return fmt.Errorf("invalid type %T for %s", data, token)
|
||||
}
|
||||
}
|
||||
return fmt.Errorf("%s is not a known field", token)
|
||||
}
|
||||
|
||||
type settableColl struct {
|
||||
Items []settableCollItem
|
||||
}
|
||||
|
||||
func (s settableColl) MarshalJSON() ([]byte, error) {
|
||||
return json.Marshal(s.Items)
|
||||
}
|
||||
func (s *settableColl) UnmarshalJSON(data []byte) error {
|
||||
return json.Unmarshal(data, &s.Items)
|
||||
}
|
||||
|
||||
// JSONLookup implements an interface to customize json pointer lookup
|
||||
func (s settableColl) JSONLookup(token string) (interface{}, error) {
|
||||
if tok, err := strconv.Atoi(token); err == nil {
|
||||
return &s.Items[tok], nil
|
||||
}
|
||||
return nil, fmt.Errorf("%s is not a valid index", token)
|
||||
}
|
||||
|
||||
// JSONLookup implements an interface to customize json pointer lookup
|
||||
func (s *settableColl) JSONSet(token string, data interface{}) error {
|
||||
if _, err := strconv.Atoi(token); err == nil {
|
||||
_, err := SetForToken(s.Items, token, data)
|
||||
return err
|
||||
}
|
||||
return fmt.Errorf("%s is not a valid index", token)
|
||||
}
|
||||
|
||||
type settableCollItem struct {
|
||||
B int `json:"b"`
|
||||
C int `json:"c"`
|
||||
}
|
||||
|
||||
type settableInt struct {
|
||||
Value int
|
||||
}
|
||||
|
||||
func (s settableInt) MarshalJSON() ([]byte, error) {
|
||||
return json.Marshal(s.Value)
|
||||
}
|
||||
func (s *settableInt) UnmarshalJSON(data []byte) error {
|
||||
return json.Unmarshal(data, &s.Value)
|
||||
}
|
||||
|
||||
func TestSetNode(t *testing.T) {
|
||||
|
||||
jsonText := `{"a":[{"b": 1, "c": 2}], "d": 3}`
|
||||
|
||||
var jsonDocument interface{}
|
||||
if assert.NoError(t, json.Unmarshal([]byte(jsonText), &jsonDocument)) {
|
||||
in := "/a/0/c"
|
||||
p, err := New(in)
|
||||
if assert.NoError(t, err) {
|
||||
|
||||
_, err = p.Set(jsonDocument, 999)
|
||||
assert.NoError(t, err)
|
||||
|
||||
firstNode := jsonDocument.(map[string]interface{})
|
||||
assert.Len(t, firstNode, 2)
|
||||
|
||||
sliceNode := firstNode["a"].([]interface{})
|
||||
assert.Len(t, sliceNode, 1)
|
||||
|
||||
changedNode := sliceNode[0].(map[string]interface{})
|
||||
chNodeVI := changedNode["c"]
|
||||
if assert.IsType(t, 0, chNodeVI) {
|
||||
changedNodeValue := chNodeVI.(int)
|
||||
if assert.Equal(t, 999, changedNodeValue) {
|
||||
assert.Len(t, sliceNode, 1)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
v, err := New("/a/0")
|
||||
if assert.NoError(t, err) {
|
||||
_, err = v.Set(jsonDocument, map[string]interface{}{"b": 3, "c": 8})
|
||||
if assert.NoError(t, err) {
|
||||
firstNode := jsonDocument.(map[string]interface{})
|
||||
assert.Len(t, firstNode, 2)
|
||||
|
||||
sliceNode := firstNode["a"].([]interface{})
|
||||
assert.Len(t, sliceNode, 1)
|
||||
changedNode := sliceNode[0].(map[string]interface{})
|
||||
assert.Equal(t, 3, changedNode["b"])
|
||||
assert.Equal(t, 8, changedNode["c"])
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
var structDoc setJsonDoc
|
||||
if assert.NoError(t, json.Unmarshal([]byte(jsonText), &structDoc)) {
|
||||
g, err := New("/a")
|
||||
if assert.NoError(t, err) {
|
||||
_, err = g.Set(&structDoc, []struct {
|
||||
B int `json:"b"`
|
||||
C int `json:"c"`
|
||||
}{{B: 4, C: 7}})
|
||||
|
||||
if assert.NoError(t, err) {
|
||||
assert.Len(t, structDoc.A, 1)
|
||||
changedNode := structDoc.A[0]
|
||||
assert.Equal(t, 4, changedNode.B)
|
||||
assert.Equal(t, 7, changedNode.C)
|
||||
}
|
||||
}
|
||||
|
||||
v, err := New("/a/0")
|
||||
if assert.NoError(t, err) {
|
||||
_, err = v.Set(structDoc, struct {
|
||||
B int `json:"b"`
|
||||
C int `json:"c"`
|
||||
}{B: 3, C: 8})
|
||||
|
||||
if assert.NoError(t, err) {
|
||||
assert.Len(t, structDoc.A, 1)
|
||||
changedNode := structDoc.A[0]
|
||||
assert.Equal(t, 3, changedNode.B)
|
||||
assert.Equal(t, 8, changedNode.C)
|
||||
}
|
||||
}
|
||||
|
||||
p, err := New("/a/0/c")
|
||||
if assert.NoError(t, err) {
|
||||
_, err = p.Set(&structDoc, 999)
|
||||
assert.NoError(t, err)
|
||||
if assert.Len(t, structDoc.A, 1) {
|
||||
assert.Equal(t, 999, structDoc.A[0].C)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
var setDoc settableDoc
|
||||
if assert.NoError(t, json.Unmarshal([]byte(jsonText), &setDoc)) {
|
||||
g, err := New("/a")
|
||||
if assert.NoError(t, err) {
|
||||
_, err = g.Set(&setDoc, []settableCollItem{{B: 4, C: 7}})
|
||||
|
||||
if assert.NoError(t, err) {
|
||||
assert.Len(t, setDoc.Coll.Items, 1)
|
||||
changedNode := setDoc.Coll.Items[0]
|
||||
assert.Equal(t, 4, changedNode.B)
|
||||
assert.Equal(t, 7, changedNode.C)
|
||||
}
|
||||
}
|
||||
|
||||
v, err := New("/a/0")
|
||||
if assert.NoError(t, err) {
|
||||
_, err = v.Set(setDoc, settableCollItem{B: 3, C: 8})
|
||||
|
||||
if assert.NoError(t, err) {
|
||||
assert.Len(t, setDoc.Coll.Items, 1)
|
||||
changedNode := setDoc.Coll.Items[0]
|
||||
assert.Equal(t, 3, changedNode.B)
|
||||
assert.Equal(t, 8, changedNode.C)
|
||||
}
|
||||
}
|
||||
|
||||
p, err := New("/a/0/c")
|
||||
if assert.NoError(t, err) {
|
||||
_, err = p.Set(setDoc, 999)
|
||||
assert.NoError(t, err)
|
||||
if assert.Len(t, setDoc.Coll.Items, 1) {
|
||||
assert.Equal(t, 999, setDoc.Coll.Items[0].C)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
Reference in New Issue
Block a user