func TestCanSupportStructWithNestedPointers(t *testing.T) {
assert := assert.New(t)
data := struct{ A *struct{ B int } }{}
result, err := Search("A.B", data)
assert.Nil(err)
assert.Nil(result)
}
func TestIsFalseWithNilInterface(t *testing.T) {
assert := assert.New(t)
var a *int = nil
var nilInterface interface{}
nilInterface = a
assert.True(isFalse(nilInterface))
}
func TestCanSupportUserDefinedStructsRef(t *testing.T) {
assert := assert.New(t)
s := scalars{Foo: "one", Bar: "bar"}
result, err := Search("Foo", &s)
assert.Nil(err)
assert.Equal("one", result)
}
func TestCanSupportStructWithFilterProjection(t *testing.T) {
assert := assert.New(t)
data := sliceType{A: "foo", B: []scalars{scalars{"f1", "b1"}, scalars{"correct", "b2"}}}
result, err := Search("B[? `true` ].Foo", data)
assert.Nil(err)
assert.Equal([]interface{}{"f1", "correct"}, result)
}
func TestCanSupportStructWithOrExpressions(t *testing.T) {
assert := assert.New(t)
data := sliceType{A: "foo", C: nil}
result, err := Search("C || A", data)
assert.Nil(err)
assert.Equal("foo", result)
}
func TestCanSupportStructWithSlice(t *testing.T) {
assert := assert.New(t)
data := sliceType{A: "foo", B: []scalars{scalars{"f1", "b1"}, scalars{"correct", "b2"}}}
result, err := Search("B[-1].Foo", data)
assert.Nil(err)
assert.Equal("correct", result)
}
func TestLexingErrors(t *testing.T) {
assert := assert.New(t)
lexer := NewLexer()
for _, tt := range lexingErrorTests {
_, err := lexer.tokenize(tt.expression)
assert.NotNil(err, fmt.Sprintf("Expected lexing error: %s", tt.msg))
}
}
func TestParsingErrors(t *testing.T) {
assert := assert.New(t)
parser := NewParser()
for _, tt := range parsingErrorTests {
_, err := parser.Parse(tt.expression)
assert.NotNil(err, fmt.Sprintf("Expected parsing error: %s, for expression: %s", tt.msg, tt.expression))
}
}
func TestCanSupportEmptyInterface(t *testing.T) {
assert := assert.New(t)
data := make(map[string]interface{})
data["foo"] = "bar"
result, err := Search("foo", data)
assert.Nil(err)
assert.Equal("bar", result)
}
func TestCanSupportProjectionsWithStructs(t *testing.T) {
assert := assert.New(t)
data := nestedSlice{A: []sliceType{
{A: "first"}, {A: "second"}, {A: "third"},
}}
result, err := Search("A[*].A", data)
assert.Nil(err)
assert.Equal([]interface{}{"first", "second", "third"}, result)
}
func TestCanSupportFlattenNestedEmptySlice(t *testing.T) {
assert := assert.New(t)
data := nestedSlice{A: []sliceType{
{}, {B: []scalars{{Foo: "a"}}},
}}
result, err := Search("A[].B[].Foo", data)
assert.Nil(err)
assert.Equal([]interface{}{"a"}, result)
}
func TestIsFalseWithMapOfUserStructs(t *testing.T) {
assert := assert.New(t)
type foo struct {
Bar string
Baz string
}
m := make(map[int]foo)
assert.True(isFalse(m))
}
func TestWillAutomaticallyCapitalizeFieldNames(t *testing.T) {
assert := assert.New(t)
s := scalars{Foo: "one", Bar: "bar"}
// Note that there's a lower cased "foo" instead of "Foo",
// but it should still correspond to the Foo field in the
// scalars struct
result, err := Search("foo", &s)
assert.Nil(err)
assert.Equal("one", result)
}
func TestObjsEqual(t *testing.T) {
assert := assert.New(t)
assert.True(objsEqual("foo", "foo"))
assert.True(objsEqual(20, 20))
assert.True(objsEqual([]int{1, 2, 3}, []int{1, 2, 3}))
assert.True(objsEqual(nil, nil))
assert.True(!objsEqual(nil, "foo"))
assert.True(objsEqual([]int{}, []int{}))
assert.True(!objsEqual([]int{}, nil))
}
func TestValidPrecompiledExpressionSearches(t *testing.T) {
assert := assert.New(t)
data := make(map[string]interface{})
data["foo"] = "bar"
precompiled, err := Compile("foo")
assert.Nil(err)
result, err := precompiled.Search(data)
assert.Nil(err)
assert.Equal("bar", result)
}
func TestIsFalseJSONTypes(t *testing.T) {
assert := assert.New(t)
assert.True(isFalse(false))
assert.True(isFalse(""))
var empty []interface{}
assert.True(isFalse(empty))
m := make(map[string]interface{})
assert.True(isFalse(m))
assert.True(isFalse(nil))
}
func TestIsFalseWithUserDefinedStructs(t *testing.T) {
assert := assert.New(t)
type nilStructType struct {
SliceOfPointers []*string
}
nilStruct := nilStructType{SliceOfPointers: nil}
assert.True(isFalse(nilStruct.SliceOfPointers))
// A user defined struct will never be false though,
// even if it's fields are the zero type.
assert.False(isFalse(nilStruct))
}
func TestSlicePositiveStep(t *testing.T) {
assert := assert.New(t)
input := make([]interface{}, 5)
input[0] = 0
input[1] = 1
input[2] = 2
input[3] = 3
input[4] = 4
result, err := slice(input, []sliceParam{sliceParam{0, true}, sliceParam{3, true}, sliceParam{1, true}})
assert.Nil(err)
assert.Equal(input[:3], result)
}
func TestCompliance(t *testing.T) {
assert := assert.New(t)
var complianceFiles []string
err := filepath.Walk("compliance", func(path string, _ os.FileInfo, _ error) error {
//if strings.HasSuffix(path, ".json") {
if allowed(path) {
complianceFiles = append(complianceFiles, path)
}
return nil
})
if assert.Nil(err) {
for _, filename := range complianceFiles {
runComplianceTest(assert, filename)
}
}
}
func TestCanLexTokens(t *testing.T) {
assert := assert.New(t)
lexer := NewLexer()
for _, tt := range lexingTests {
tokens, err := lexer.tokenize(tt.expression)
if assert.Nil(err) {
errMsg := fmt.Sprintf("Mismatch expected number of tokens: (expected: %s, actual: %s)",
tt.expected, tokens)
tt.expected = append(tt.expected, token{tEOF, "", len(tt.expression), 0})
if assert.Equal(len(tt.expected), len(tokens), errMsg) {
for i, token := range tokens {
expected := tt.expected[i]
assert.Equal(expected, token, "Token not equal")
}
}
}
}
}
func TestInvalidPrecompileErrors(t *testing.T) {
assert := assert.New(t)
_, err := Compile("not a valid expression")
assert.NotNil(err)
}
func TestPrettyPrintedCompNode(t *testing.T) {
assert := assert.New(t)
parser := NewParser()
parsed, _ := parser.Parse("a[?b<=c]")
assert.Equal(parsed.PrettyPrint(0), prettyPrintedCompNode)
}
func TestPrettyPrintedAST(t *testing.T) {
assert := assert.New(t)
parser := NewParser()
parsed, _ := parser.Parse("foo[*].bar.baz.qux")
assert.Equal(parsed.PrettyPrint(0), prettyPrinted)
}