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 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 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 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 TestIsFalseWithNilInterface(t *testing.T) {
assert := assert.New(t)
var a *int = nil
var nilInterface interface{}
nilInterface = a
assert.True(isFalse(nilInterface))
}
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 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 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 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 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 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 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 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 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 TestLogstashFormatter(t *testing.T) {
assert := assert.New(t)
lf := LogstashFormatter{Type: "abc"}
fields := logrus.Fields{
"message": "def",
"level": "ijk",
"type": "lmn",
"one": 1,
"pi": 3.14,
"bool": true,
}
entry := logrus.WithFields(fields)
entry.Message = "msg"
entry.Level = logrus.InfoLevel
b, _ := lf.Format(entry)
var data map[string]interface{}
dec := json.NewDecoder(bytes.NewReader(b))
dec.UseNumber()
dec.Decode(&data)
// base fields
assert.Equal(json.Number("1"), data["@version"])
assert.NotEmpty(data["@timestamp"])
assert.Equal("abc", data["type"])
assert.Equal("msg", data["message"])
assert.Equal("info", data["level"])
// substituted fields
assert.Equal("def", data["fields.message"])
assert.Equal("ijk", data["fields.level"])
assert.Equal("lmn", data["fields.type"])
// formats
assert.Equal(json.Number("1"), data["one"])
assert.Equal(json.Number("3.14"), data["pi"])
assert.Equal(true, data["bool"])
}
func TestEntryWithError(t *testing.T) {
assert := assert.New(t)
defer func() {
ErrorKey = "error"
}()
err := fmt.Errorf("kaboom at layer %d", 4711)
assert.Equal(err, WithError(err).Data["error"])
logger := New()
logger.Out = &bytes.Buffer{}
entry := NewEntry(logger)
assert.Equal(err, entry.WithError(err).Data["error"])
ErrorKey = "err"
assert.Equal(err, entry.WithError(err).Data["err"])
}
func TestBasicAuth(t *testing.T) {
assert := assert.New(t)
aws := test.StubAws(test.DescribeConvoxStackCycle("convox-test"))
defer aws.Close()
defer os.Setenv("PASSWORD", os.Getenv("PASSWORD"))
defer os.Setenv("RACK", os.Getenv("RACK"))
os.Setenv("PASSWORD", "keymaster")
os.Setenv("RACK", "convox-test")
req, _ := http.NewRequest("GET", "http://convox/system", nil)
w := httptest.NewRecorder()
controllers.HandlerFunc(w, req)
if !assert.Equal(401, w.Code) {
return
}
w = httptest.NewRecorder()
req.SetBasicAuth("", "keymaster")
controllers.HandlerFunc(w, req)
assert.Equal(200, w.Code)
}
func TestPrettyPrintedAST(t *testing.T) {
assert := assert.New(t)
parser := NewParser()
parsed, _ := parser.Parse("foo[*].bar.baz.qux")
assert.Equal(parsed.PrettyPrint(0), prettyPrinted)
}
func TestPrettyPrintedCompNode(t *testing.T) {
assert := assert.New(t)
parser := NewParser()
parsed, _ := parser.Parse("a[?b<=c]")
assert.Equal(parsed.PrettyPrint(0), prettyPrintedCompNode)
}
func TestInvalidPrecompileErrors(t *testing.T) {
assert := assert.New(t)
_, err := Compile("not a valid expression")
assert.NotNil(err)
}