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) }