500 lines
13 KiB
Go
500 lines
13 KiB
Go
package selector
|
|
|
|
import (
|
|
"fmt"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/ipld/go-ipld-prime"
|
|
"github.com/ipld/go-ipld-prime/codec/dagjson"
|
|
"github.com/ipld/go-ipld-prime/must"
|
|
basicnode "github.com/ipld/go-ipld-prime/node/basic"
|
|
"github.com/ipld/go-ipld-prime/node/bindnode"
|
|
"github.com/ipld/go-ipld-prime/printer"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
func TestParse(t *testing.T) {
|
|
t.Run("identity", func(t *testing.T) {
|
|
sel, err := Parse(".")
|
|
require.NoError(t, err)
|
|
require.Equal(t, 1, len(sel))
|
|
require.True(t, sel[0].Identity())
|
|
require.False(t, sel[0].Optional())
|
|
require.False(t, sel[0].Iterator())
|
|
require.Empty(t, sel[0].Slice())
|
|
require.Empty(t, sel[0].Field())
|
|
require.Empty(t, sel[0].Index())
|
|
})
|
|
|
|
t.Run("field", func(t *testing.T) {
|
|
sel, err := Parse(".foo")
|
|
require.NoError(t, err)
|
|
require.Equal(t, 1, len(sel))
|
|
require.False(t, sel[0].Identity())
|
|
require.False(t, sel[0].Optional())
|
|
require.False(t, sel[0].Iterator())
|
|
require.Empty(t, sel[0].Slice())
|
|
require.Equal(t, sel[0].Field(), "foo")
|
|
require.Empty(t, sel[0].Index())
|
|
})
|
|
|
|
t.Run("explicit field", func(t *testing.T) {
|
|
sel, err := Parse(`.["foo"]`)
|
|
require.NoError(t, err)
|
|
require.Equal(t, 2, len(sel))
|
|
require.True(t, sel[0].Identity())
|
|
require.False(t, sel[0].Optional())
|
|
require.False(t, sel[0].Iterator())
|
|
require.Empty(t, sel[0].Slice())
|
|
require.Empty(t, sel[0].Field())
|
|
require.Empty(t, sel[0].Index())
|
|
require.False(t, sel[1].Identity())
|
|
require.False(t, sel[1].Optional())
|
|
require.False(t, sel[1].Iterator())
|
|
require.Empty(t, sel[1].Slice())
|
|
require.Equal(t, sel[1].Field(), "foo")
|
|
require.Empty(t, sel[1].Index())
|
|
})
|
|
|
|
t.Run("index", func(t *testing.T) {
|
|
sel, err := Parse(".[138]")
|
|
require.NoError(t, err)
|
|
require.Equal(t, 2, len(sel))
|
|
require.True(t, sel[0].Identity())
|
|
require.False(t, sel[0].Optional())
|
|
require.False(t, sel[0].Iterator())
|
|
require.Empty(t, sel[0].Slice())
|
|
require.Empty(t, sel[0].Field())
|
|
require.Empty(t, sel[0].Index())
|
|
require.False(t, sel[1].Identity())
|
|
require.False(t, sel[1].Optional())
|
|
require.False(t, sel[1].Iterator())
|
|
require.Empty(t, sel[1].Slice())
|
|
require.Empty(t, sel[1].Field())
|
|
require.Equal(t, sel[1].Index(), 138)
|
|
})
|
|
|
|
t.Run("negative index", func(t *testing.T) {
|
|
sel, err := Parse(".[-138]")
|
|
require.NoError(t, err)
|
|
require.Equal(t, 2, len(sel))
|
|
require.True(t, sel[0].Identity())
|
|
require.False(t, sel[0].Optional())
|
|
require.False(t, sel[0].Iterator())
|
|
require.Empty(t, sel[0].Slice())
|
|
require.Empty(t, sel[0].Field())
|
|
require.Empty(t, sel[0].Index())
|
|
require.False(t, sel[1].Identity())
|
|
require.False(t, sel[1].Optional())
|
|
require.False(t, sel[1].Iterator())
|
|
require.Empty(t, sel[1].Slice())
|
|
require.Empty(t, sel[1].Field())
|
|
require.Equal(t, sel[1].Index(), -138)
|
|
})
|
|
|
|
t.Run("iterator", func(t *testing.T) {
|
|
sel, err := Parse(".[]")
|
|
require.NoError(t, err)
|
|
require.Equal(t, 2, len(sel))
|
|
require.True(t, sel[0].Identity())
|
|
require.False(t, sel[0].Optional())
|
|
require.False(t, sel[0].Iterator())
|
|
require.Empty(t, sel[0].Slice())
|
|
require.Empty(t, sel[0].Field())
|
|
require.Empty(t, sel[0].Index())
|
|
require.False(t, sel[1].Identity())
|
|
require.False(t, sel[1].Optional())
|
|
require.True(t, sel[1].Iterator())
|
|
require.Empty(t, sel[1].Slice())
|
|
require.Empty(t, sel[1].Field())
|
|
require.Empty(t, sel[1].Index())
|
|
})
|
|
|
|
t.Run("optional field", func(t *testing.T) {
|
|
sel, err := Parse(".foo?")
|
|
require.NoError(t, err)
|
|
require.Equal(t, 1, len(sel))
|
|
require.False(t, sel[0].Identity())
|
|
require.True(t, sel[0].Optional())
|
|
require.False(t, sel[0].Iterator())
|
|
require.Empty(t, sel[0].Slice())
|
|
require.Equal(t, sel[0].Field(), "foo")
|
|
require.Empty(t, sel[0].Index())
|
|
})
|
|
|
|
t.Run("optional explicit field", func(t *testing.T) {
|
|
sel, err := Parse(`.["foo"]?`)
|
|
require.NoError(t, err)
|
|
require.Equal(t, 2, len(sel))
|
|
require.True(t, sel[0].Identity())
|
|
require.False(t, sel[0].Optional())
|
|
require.False(t, sel[0].Iterator())
|
|
require.Empty(t, sel[0].Slice())
|
|
require.Empty(t, sel[0].Field())
|
|
require.Empty(t, sel[0].Index())
|
|
require.False(t, sel[1].Identity())
|
|
require.True(t, sel[1].Optional())
|
|
require.False(t, sel[1].Iterator())
|
|
require.Empty(t, sel[1].Slice())
|
|
require.Equal(t, sel[1].Field(), "foo")
|
|
require.Empty(t, sel[1].Index())
|
|
})
|
|
|
|
t.Run("optional index", func(t *testing.T) {
|
|
sel, err := Parse(".[138]?")
|
|
require.NoError(t, err)
|
|
require.Equal(t, 2, len(sel))
|
|
require.True(t, sel[0].Identity())
|
|
require.False(t, sel[0].Optional())
|
|
require.False(t, sel[0].Iterator())
|
|
require.Empty(t, sel[0].Slice())
|
|
require.Empty(t, sel[0].Field())
|
|
require.Empty(t, sel[0].Index())
|
|
require.False(t, sel[1].Identity())
|
|
require.True(t, sel[1].Optional())
|
|
require.False(t, sel[1].Iterator())
|
|
require.Empty(t, sel[1].Slice())
|
|
require.Empty(t, sel[1].Field())
|
|
require.Equal(t, sel[1].Index(), 138)
|
|
})
|
|
|
|
t.Run("optional iterator", func(t *testing.T) {
|
|
sel, err := Parse(".[]?")
|
|
require.NoError(t, err)
|
|
require.Equal(t, 2, len(sel))
|
|
require.True(t, sel[0].Identity())
|
|
require.False(t, sel[0].Optional())
|
|
require.False(t, sel[0].Iterator())
|
|
require.Empty(t, sel[0].Slice())
|
|
require.Empty(t, sel[0].Field())
|
|
require.Empty(t, sel[0].Index())
|
|
require.False(t, sel[1].Identity())
|
|
require.True(t, sel[1].Optional())
|
|
require.True(t, sel[1].Iterator())
|
|
require.Empty(t, sel[1].Slice())
|
|
require.Empty(t, sel[1].Field())
|
|
require.Empty(t, sel[1].Index())
|
|
})
|
|
|
|
t.Run("nesting", func(t *testing.T) {
|
|
str := `.foo.["bar"].[138]?.baz[1:]`
|
|
sel, err := Parse(str)
|
|
require.NoError(t, err)
|
|
printSegments(sel)
|
|
require.Equal(t, str, sel.String())
|
|
require.Equal(t, 7, len(sel))
|
|
require.False(t, sel[0].Identity())
|
|
require.False(t, sel[0].Optional())
|
|
require.False(t, sel[0].Iterator())
|
|
require.Empty(t, sel[0].Slice())
|
|
require.Equal(t, sel[0].Field(), "foo")
|
|
require.Empty(t, sel[0].Index())
|
|
require.True(t, sel[1].Identity())
|
|
require.False(t, sel[1].Optional())
|
|
require.False(t, sel[1].Iterator())
|
|
require.Empty(t, sel[1].Slice())
|
|
require.Empty(t, sel[1].Field())
|
|
require.Empty(t, sel[1].Index())
|
|
require.False(t, sel[2].Identity())
|
|
require.False(t, sel[2].Optional())
|
|
require.False(t, sel[2].Iterator())
|
|
require.Empty(t, sel[2].Slice())
|
|
require.Equal(t, sel[2].Field(), "bar")
|
|
require.Empty(t, sel[2].Index())
|
|
require.True(t, sel[3].Identity())
|
|
require.False(t, sel[3].Optional())
|
|
require.False(t, sel[3].Iterator())
|
|
require.Empty(t, sel[3].Slice())
|
|
require.Empty(t, sel[3].Field())
|
|
require.Empty(t, sel[3].Index())
|
|
require.False(t, sel[4].Identity())
|
|
require.True(t, sel[4].Optional())
|
|
require.False(t, sel[4].Iterator())
|
|
require.Empty(t, sel[4].Slice())
|
|
require.Empty(t, sel[4].Field())
|
|
require.Equal(t, sel[4].Index(), 138)
|
|
require.False(t, sel[5].Identity())
|
|
require.False(t, sel[5].Optional())
|
|
require.False(t, sel[5].Iterator())
|
|
require.Empty(t, sel[5].Slice())
|
|
require.Equal(t, sel[5].Field(), "baz")
|
|
require.Empty(t, sel[5].Index())
|
|
require.False(t, sel[6].Identity())
|
|
require.False(t, sel[6].Optional())
|
|
require.False(t, sel[6].Iterator())
|
|
require.Equal(t, sel[6].Slice(), []int{1})
|
|
require.Empty(t, sel[6].Field())
|
|
require.Empty(t, sel[6].Index())
|
|
})
|
|
|
|
t.Run("non dotted", func(t *testing.T) {
|
|
_, err := Parse("foo")
|
|
require.NotNil(t, err)
|
|
fmt.Println(err)
|
|
})
|
|
|
|
t.Run("non quoted", func(t *testing.T) {
|
|
_, err := Parse(".[foo]")
|
|
require.NotNil(t, err)
|
|
fmt.Println(err)
|
|
})
|
|
}
|
|
|
|
func printSegments(s Selector) {
|
|
for i, seg := range s {
|
|
fmt.Printf("%d: %s\n", i, seg.String())
|
|
}
|
|
}
|
|
|
|
func TestSelect(t *testing.T) {
|
|
type name struct {
|
|
First string
|
|
Middle *string
|
|
Last string
|
|
}
|
|
type interest struct {
|
|
Name string
|
|
Outdoor bool
|
|
Experience int
|
|
}
|
|
type user struct {
|
|
Name name
|
|
Age int
|
|
Nationalities []string
|
|
Interests []interest
|
|
}
|
|
|
|
ts, err := ipld.LoadSchemaBytes([]byte(`
|
|
type User struct {
|
|
name Name
|
|
age Int
|
|
nationalities [String]
|
|
interests [Interest]
|
|
}
|
|
type Name struct {
|
|
first String
|
|
middle optional String
|
|
last String
|
|
}
|
|
type Interest struct {
|
|
name String
|
|
outdoor Bool
|
|
experience Int
|
|
}
|
|
`))
|
|
require.NoError(t, err)
|
|
typ := ts.TypeByName("User")
|
|
|
|
am := "Joan"
|
|
alice := user{
|
|
Name: name{First: "Alice", Middle: &am, Last: "Wonderland"},
|
|
Age: 24,
|
|
Nationalities: []string{"British"},
|
|
Interests: []interest{
|
|
{Name: "Cycling", Outdoor: true, Experience: 4},
|
|
{Name: "Chess", Outdoor: false, Experience: 2},
|
|
},
|
|
}
|
|
bob := user{
|
|
Name: name{First: "Bob", Last: "Builder"},
|
|
Age: 35,
|
|
Nationalities: []string{"Canadian", "South African"},
|
|
Interests: []interest{
|
|
{Name: "Snowboarding", Outdoor: true, Experience: 8},
|
|
{Name: "Reading", Outdoor: false, Experience: 25},
|
|
},
|
|
}
|
|
|
|
anode := bindnode.Wrap(&alice, typ)
|
|
bnode := bindnode.Wrap(&bob, typ)
|
|
|
|
t.Run("identity", func(t *testing.T) {
|
|
sel, err := Parse(".")
|
|
require.NoError(t, err)
|
|
|
|
one, many, err := Select(sel, anode)
|
|
require.NoError(t, err)
|
|
require.NotEmpty(t, one)
|
|
require.Empty(t, many)
|
|
|
|
fmt.Println(printer.Sprint(one))
|
|
|
|
age := must.Int(must.Node(one.LookupByString("age")))
|
|
require.Equal(t, int64(alice.Age), age)
|
|
})
|
|
|
|
t.Run("nested property", func(t *testing.T) {
|
|
sel, err := Parse(".name.first")
|
|
require.NoError(t, err)
|
|
|
|
one, many, err := Select(sel, anode)
|
|
require.NoError(t, err)
|
|
require.NotEmpty(t, one)
|
|
require.Empty(t, many)
|
|
|
|
fmt.Println(printer.Sprint(one))
|
|
|
|
name := must.String(one)
|
|
require.Equal(t, alice.Name.First, name)
|
|
|
|
one, many, err = Select(sel, bnode)
|
|
require.NoError(t, err)
|
|
require.NotEmpty(t, one)
|
|
require.Empty(t, many)
|
|
|
|
fmt.Println(printer.Sprint(one))
|
|
|
|
name = must.String(one)
|
|
require.Equal(t, bob.Name.First, name)
|
|
})
|
|
|
|
t.Run("optional nested property", func(t *testing.T) {
|
|
sel, err := Parse(".name.middle?")
|
|
require.NoError(t, err)
|
|
|
|
one, many, err := Select(sel, anode)
|
|
require.NoError(t, err)
|
|
require.NotEmpty(t, one)
|
|
require.Empty(t, many)
|
|
|
|
fmt.Println(printer.Sprint(one))
|
|
|
|
name := must.String(one)
|
|
require.Equal(t, *alice.Name.Middle, name)
|
|
|
|
one, many, err = Select(sel, bnode)
|
|
require.NoError(t, err)
|
|
require.Empty(t, one)
|
|
require.Empty(t, many)
|
|
})
|
|
|
|
t.Run("not exists", func(t *testing.T) {
|
|
sel, err := Parse(".name.foo")
|
|
require.NoError(t, err)
|
|
|
|
one, many, err := Select(sel, anode)
|
|
require.Error(t, err)
|
|
require.Empty(t, one)
|
|
require.Empty(t, many)
|
|
|
|
fmt.Println(err)
|
|
|
|
require.ErrorAs(t, err, &resolutionerr{}, "error was not a resolution error")
|
|
})
|
|
|
|
t.Run("optional not exists", func(t *testing.T) {
|
|
sel, err := Parse(".name.foo?")
|
|
require.NoError(t, err)
|
|
|
|
one, many, err := Select(sel, anode)
|
|
require.NoError(t, err)
|
|
require.Empty(t, one)
|
|
require.Empty(t, many)
|
|
})
|
|
|
|
t.Run("iterator", func(t *testing.T) {
|
|
sel, err := Parse(".interests[]")
|
|
require.NoError(t, err)
|
|
|
|
one, many, err := Select(sel, anode)
|
|
require.NoError(t, err)
|
|
require.Empty(t, one)
|
|
require.NotEmpty(t, many)
|
|
|
|
for _, n := range many {
|
|
fmt.Println(printer.Sprint(n))
|
|
}
|
|
|
|
iname := must.String(must.Node(many[0].LookupByString("name")))
|
|
require.Equal(t, alice.Interests[0].Name, iname)
|
|
|
|
iname = must.String(must.Node(many[1].LookupByString("name")))
|
|
require.Equal(t, alice.Interests[1].Name, iname)
|
|
})
|
|
|
|
t.Run("map iterator", func(t *testing.T) {
|
|
sel, err := Parse(".interests[0][]")
|
|
require.NoError(t, err)
|
|
|
|
one, many, err := Select(sel, anode)
|
|
require.NoError(t, err)
|
|
require.Empty(t, one)
|
|
require.NotEmpty(t, many)
|
|
|
|
for _, n := range many {
|
|
fmt.Println(printer.Sprint(n))
|
|
}
|
|
|
|
require.Equal(t, alice.Interests[0].Name, must.String(many[0]))
|
|
require.Equal(t, alice.Interests[0].Experience, int(must.Int(many[2])))
|
|
})
|
|
}
|
|
|
|
func FuzzParse(f *testing.F) {
|
|
selectorCorpus := []string{
|
|
`.`, `.[]`, `.[]?`, `.[][]?`, `.x`, `.["x"]`, `.[0]`, `.[-1]`, `.[0]`,
|
|
`.[0]`, `.[0:2]`, `.[1:]`, `.[:2]`, `.[0:2]`, `.[1:]`, `.x?`, `.x?`,
|
|
`.x?`, `.["x"]?`, `.length?`, `.[4]?`, `.[]`, `.[][]`, `.x`, `.x`, `.x`,
|
|
`.length`, `.[4]`,
|
|
}
|
|
for _, selector := range selectorCorpus {
|
|
f.Add(selector)
|
|
}
|
|
f.Fuzz(func(t *testing.T, selector string) {
|
|
// only look for panic()
|
|
_, _ = Parse(selector)
|
|
})
|
|
}
|
|
|
|
func FuzzParseAndSelect(f *testing.F) {
|
|
selectorCorpus := []string{
|
|
`.`, `.[]`, `.[]?`, `.[][]?`, `.x`, `.["x"]`, `.[0]`, `.[-1]`, `.[0]`,
|
|
`.[0]`, `.[0:2]`, `.[1:]`, `.[:2]`, `.[0:2]`, `.[1:]`, `.x?`, `.x?`,
|
|
`.x?`, `.["x"]?`, `.length?`, `.[4]?`, `.[]`, `.[][]`, `.x`, `.x`, `.x`,
|
|
`.length`, `.[4]`,
|
|
}
|
|
subjectCorpus := []string{
|
|
`{"x":1}`, `[1, 2]`, `null`, `[[1], 2, [3]]`, `{"x": 1 }`, `{"x": 1}`,
|
|
`[1, 2]`, `[1, 2]`, `"Hi"`, `{"/":{"bytes":"AAE"}`, `[0, 1, 2]`,
|
|
`[0, 1, 2]`, `[0, 1, 2]`, `"hello"`, `{"/":{"bytes":"AAEC"}}`, `{}`,
|
|
`null`, `[]`, `{}`, `[1, 2]`, `[0, 1]`, `null`, `[[1], 2, [3]]`, `{}`,
|
|
`null`, `[]`, `[1, 2]`, `[0, 1]`,
|
|
}
|
|
for i := 0; ; i++ {
|
|
switch {
|
|
case i < len(selectorCorpus) && i < len(subjectCorpus):
|
|
f.Add(selectorCorpus[i], subjectCorpus[i])
|
|
continue
|
|
case i > len(selectorCorpus):
|
|
f.Add("", subjectCorpus[i])
|
|
continue
|
|
case i > len(subjectCorpus):
|
|
f.Add(selectorCorpus[i], "")
|
|
continue
|
|
}
|
|
break
|
|
}
|
|
|
|
f.Fuzz(func(t *testing.T, selector, subject string) {
|
|
sel, err := Parse(selector)
|
|
if err != nil {
|
|
t.Skip()
|
|
}
|
|
|
|
np := basicnode.Prototype.Any
|
|
nb := np.NewBuilder()
|
|
err = dagjson.Decode(nb, strings.NewReader(subject))
|
|
if err != nil {
|
|
t.Skip()
|
|
}
|
|
node := nb.Build()
|
|
if node == nil {
|
|
t.Skip()
|
|
}
|
|
|
|
// look for panic()
|
|
_, _, _ = Select(sel, node)
|
|
})
|
|
}
|