jpath/parser_test.go

package jpath

import (
	"fmt"
	. "github.com/pelletier/go-toml"
	"testing"
)

func assertQuery(t *testing.T, toml, query string, ref []interface{}) {
	tree, err := Load(toml)
	if err != nil {
		t.Errorf("Non-nil toml parse error: %v", err)
		return
	}
	results := Compile(query).Execute(tree)
	assertValue(t, results, ref, "(("+query+")) -> ")
}

func assertValue(t *testing.T, result, ref interface{}, location string) {
	switch node := ref.(type) {
	case []interface{}:
		if resultNode, ok := result.([]interface{}); !ok {
			t.Errorf("{%s} result value not of type %T: %T",
				location, node, resultNode)
		} else {
			if len(node) != len(resultNode) {
				t.Errorf("{%s} lengths do not match: %v vs %v",
					location, node, resultNode)
			} else {
				for i, v := range node {
					assertValue(t, resultNode[i], v, fmt.Sprintf("%s[%d]", location, i))
				}
			}
		}
	case map[string]interface{}:
		if resultNode, ok := result.(*TomlTree); !ok {
			t.Errorf("{%s} result value not of type %T: %T",
				location, node, resultNode)
		} else {
			for k, v := range node {
				assertValue(t, resultNode.GetPath([]string{k}), v, location+"."+k)
			}
		}
	case int64:
		if resultNode, ok := result.(int64); !ok {
			t.Errorf("{%s} result value not of type %T: %T",
				location, node, resultNode)
		} else {
			if node != resultNode {
				t.Errorf("{%s} result value does not match", location)
			}
		}
	case string:
		if resultNode, ok := result.(string); !ok {
			t.Errorf("{%s} result value not of type %T: %T",
				location, node, resultNode)
		} else {
			if node != resultNode {
				t.Errorf("{%s} result value does not match", location)
			}
		}
	default:
		if fmt.Sprintf("%v", node) != fmt.Sprintf("%v", ref) {
			t.Errorf("{%s} result value does not match: %v != %v",
				location, node, ref)
		}
	}
}

func TestQueryRoot(t *testing.T) {
	assertQuery(t,
		"a = 42",
		"$",
		[]interface{}{
			map[string]interface{}{
				"a": int64(42),
			},
		})
}

func TestQueryKey(t *testing.T) {
	assertQuery(t,
		"[foo]\na = 42",
		"$.foo.a",
		[]interface{}{
			int64(42),
		})
}

func TestQueryKeyString(t *testing.T) {
	assertQuery(t,
		"[foo]\na = 42",
		"$.foo['a']",
		[]interface{}{
			int64(42),
		})
}

func TestQueryIndex(t *testing.T) {
	assertQuery(t,
		"[foo]\na = [1,2,3,4,5,6,7,8,9,0]",
		"$.foo.a[0]",
		[]interface{}{
			int64(1),
		})
}

func TestQuerySliceRange(t *testing.T) {
	assertQuery(t,
		"[foo]\na = [1,2,3,4,5,6,7,8,9,0]",
		"$.foo.a[0:5]",
		[]interface{}{
			int64(1),
			int64(2),
			int64(3),
			int64(4),
			int64(5),
		})
}

func TestQuerySliceStep(t *testing.T) {
	assertQuery(t,
		"[foo]\na = [1,2,3,4,5,6,7,8,9,0]",
		"$.foo.a[0:5:2]",
		[]interface{}{
			int64(1),
			int64(3),
			int64(5),
		})
}

func TestQueryAny(t *testing.T) {
	assertQuery(t,
		"[foo.bar]\na=1\nb=2\n[foo.baz]\na=3\nb=4",
		"$.foo.*",
		[]interface{}{
			map[string]interface{}{
				"a": int64(1),
				"b": int64(2),
			},
			map[string]interface{}{
				"a": int64(3),
				"b": int64(4),
			},
		})
}
func TestQueryUnionSimple(t *testing.T) {
	assertQuery(t,
		"[foo.bar]\na=1\nb=2\n[baz.foo]\na=3\nb=4\n[gorf.foo]\na=5\nb=6",
		"$.*[bar,foo]",
		[]interface{}{
			map[string]interface{}{
				"a": int64(1),
				"b": int64(2),
			},
			map[string]interface{}{
				"a": int64(3),
				"b": int64(4),
			},
			map[string]interface{}{
				"a": int64(5),
				"b": int64(6),
			},
		})
}

func TestQueryRecursionAll(t *testing.T) {
	assertQuery(t,
		"[foo.bar]\na=1\nb=2\n[baz.foo]\na=3\nb=4\n[gorf.foo]\na=5\nb=6",
		"$..*",
		[]interface{}{
			map[string]interface{}{
				"bar": map[string]interface{}{
					"a": int64(1),
					"b": int64(2),
				},
			},
			map[string]interface{}{
				"a": int64(1),
				"b": int64(2),
			},
			int64(1),
			int64(2),
			map[string]interface{}{
				"foo": map[string]interface{}{
					"a": int64(3),
					"b": int64(4),
				},
			},
			map[string]interface{}{
				"a": int64(3),
				"b": int64(4),
			},
			int64(3),
			int64(4),
			map[string]interface{}{
				"foo": map[string]interface{}{
					"a": int64(5),
					"b": int64(6),
				},
			},
			map[string]interface{}{
				"a": int64(5),
				"b": int64(6),
			},
			int64(5),
			int64(6),
		})
}

func TestQueryRecursionUnionSimple(t *testing.T) {
	assertQuery(t,
		"[foo.bar]\na=1\nb=2\n[baz.foo]\na=3\nb=4\n[gorf.foo]\na=5\nb=6",
		"$..['foo','bar']",
		[]interface{}{
			map[string]interface{}{
				"a": int64(1),
				"b": int64(2),
			},
			map[string]interface{}{
				"a": int64(3),
				"b": int64(4),
			},
			map[string]interface{}{
				"a": int64(5),
				"b": int64(6),
			},
		})
}

func TestQueryScriptFnLast(t *testing.T) {
	assertQuery(t,
		"[foo]\na = [0,1,2,3,4,5,6,7,8,9]",
		"$.foo.a[(last)]",
		[]interface{}{
			int64(9),
		})
}

func TestQueryFilterFnOdd(t *testing.T) {
	assertQuery(t,
		"[foo]\na = [0,1,2,3,4,5,6,7,8,9]",
		"$.foo.a[?(odd)]",
		[]interface{}{
			int64(1),
			int64(3),
			int64(5),
			int64(7),
			int64(9),
		})
}

func TestQueryFilterFnEven(t *testing.T) {
	assertQuery(t,
		"[foo]\na = [0,1,2,3,4,5,6,7,8,9]",
		"$.foo.a[?(even)]",
		[]interface{}{
			int64(0),
			int64(2),
			int64(4),
			int64(6),
			int64(8),
		})
}