diff options
Diffstat (limited to 'vendor/github.com/hashicorp/hcl/hcl/parser/parser_test.go')
| -rw-r--r-- | vendor/github.com/hashicorp/hcl/hcl/parser/parser_test.go | 575 |
1 files changed, 0 insertions, 575 deletions
diff --git a/vendor/github.com/hashicorp/hcl/hcl/parser/parser_test.go b/vendor/github.com/hashicorp/hcl/hcl/parser/parser_test.go deleted file mode 100644 index 270212207..000000000 --- a/vendor/github.com/hashicorp/hcl/hcl/parser/parser_test.go +++ /dev/null @@ -1,575 +0,0 @@ -package parser - -import ( - "fmt" - "io/ioutil" - "path/filepath" - "reflect" - "runtime" - "strings" - "testing" - - "github.com/hashicorp/hcl/hcl/ast" - "github.com/hashicorp/hcl/hcl/token" -) - -func TestType(t *testing.T) { - var literals = []struct { - typ token.Type - src string - }{ - {token.STRING, `foo = "foo"`}, - {token.NUMBER, `foo = 123`}, - {token.NUMBER, `foo = -29`}, - {token.FLOAT, `foo = 123.12`}, - {token.FLOAT, `foo = -123.12`}, - {token.BOOL, `foo = true`}, - {token.HEREDOC, "foo = <<EOF\nHello\nWorld\nEOF"}, - } - - for _, l := range literals { - p := newParser([]byte(l.src)) - item, err := p.objectItem() - if err != nil { - t.Error(err) - } - - lit, ok := item.Val.(*ast.LiteralType) - if !ok { - t.Errorf("node should be of type LiteralType, got: %T", item.Val) - } - - if lit.Token.Type != l.typ { - t.Errorf("want: %s, got: %s", l.typ, lit.Token.Type) - } - } -} - -func TestListType(t *testing.T) { - var literals = []struct { - src string - tokens []token.Type - }{ - { - `foo = ["123", 123]`, - []token.Type{token.STRING, token.NUMBER}, - }, - { - `foo = [123, "123",]`, - []token.Type{token.NUMBER, token.STRING}, - }, - { - `foo = [false]`, - []token.Type{token.BOOL}, - }, - { - `foo = []`, - []token.Type{}, - }, - { - `foo = [1, -"string", -<<EOF -heredoc contents -EOF -]`, - []token.Type{token.NUMBER, token.STRING, token.HEREDOC}, - }, - } - - for _, l := range literals { - p := newParser([]byte(l.src)) - item, err := p.objectItem() - if err != nil { - t.Error(err) - } - - list, ok := item.Val.(*ast.ListType) - if !ok { - t.Errorf("node should be of type LiteralType, got: %T", item.Val) - } - - tokens := []token.Type{} - for _, li := range list.List { - if tp, ok := li.(*ast.LiteralType); ok { - tokens = append(tokens, tp.Token.Type) - } - } - - equals(t, l.tokens, tokens) - } -} - -func TestListOfMaps(t *testing.T) { - src := `foo = [ - {key = "bar"}, - {key = "baz", key2 = "qux"}, - ]` - p := newParser([]byte(src)) - - file, err := p.Parse() - if err != nil { - t.Fatalf("err: %s", err) - } - - // Here we make all sorts of assumptions about the input structure w/ type - // assertions. The intent is only for this to be a "smoke test" ensuring - // parsing actually performed its duty - giving this test something a bit - // more robust than _just_ "no error occurred". - expected := []string{`"bar"`, `"baz"`, `"qux"`} - actual := make([]string, 0, 3) - ol := file.Node.(*ast.ObjectList) - objItem := ol.Items[0] - list := objItem.Val.(*ast.ListType) - for _, node := range list.List { - obj := node.(*ast.ObjectType) - for _, item := range obj.List.Items { - val := item.Val.(*ast.LiteralType) - actual = append(actual, val.Token.Text) - } - - } - if !reflect.DeepEqual(expected, actual) { - t.Fatalf("Expected: %#v, got %#v", expected, actual) - } -} - -func TestListOfMaps_requiresComma(t *testing.T) { - src := `foo = [ - {key = "bar"} - {key = "baz"} - ]` - p := newParser([]byte(src)) - - _, err := p.Parse() - if err == nil { - t.Fatalf("Expected error, got none!") - } - - expected := "error parsing list, expected comma or list end" - if !strings.Contains(err.Error(), expected) { - t.Fatalf("Expected err:\n %s\nTo contain:\n %s\n", err, expected) - } -} - -func TestListType_leadComment(t *testing.T) { - var literals = []struct { - src string - comment []string - }{ - { - `foo = [ - 1, - # bar - 2, - 3, - ]`, - []string{"", "# bar", ""}, - }, - } - - for _, l := range literals { - p := newParser([]byte(l.src)) - item, err := p.objectItem() - if err != nil { - t.Fatal(err) - } - - list, ok := item.Val.(*ast.ListType) - if !ok { - t.Fatalf("node should be of type LiteralType, got: %T", item.Val) - } - - if len(list.List) != len(l.comment) { - t.Fatalf("bad: %d", len(list.List)) - } - - for i, li := range list.List { - lt := li.(*ast.LiteralType) - comment := l.comment[i] - - if (lt.LeadComment == nil) != (comment == "") { - t.Fatalf("bad: %#v", lt) - } - - if comment == "" { - continue - } - - actual := lt.LeadComment.List[0].Text - if actual != comment { - t.Fatalf("bad: %q %q", actual, comment) - } - } - } -} - -func TestListType_lineComment(t *testing.T) { - var literals = []struct { - src string - comment []string - }{ - { - `foo = [ - 1, - 2, # bar - 3, - ]`, - []string{"", "# bar", ""}, - }, - } - - for _, l := range literals { - p := newParser([]byte(l.src)) - item, err := p.objectItem() - if err != nil { - t.Fatal(err) - } - - list, ok := item.Val.(*ast.ListType) - if !ok { - t.Fatalf("node should be of type LiteralType, got: %T", item.Val) - } - - if len(list.List) != len(l.comment) { - t.Fatalf("bad: %d", len(list.List)) - } - - for i, li := range list.List { - lt := li.(*ast.LiteralType) - comment := l.comment[i] - - if (lt.LineComment == nil) != (comment == "") { - t.Fatalf("bad: %s", lt) - } - - if comment == "" { - continue - } - - actual := lt.LineComment.List[0].Text - if actual != comment { - t.Fatalf("bad: %q %q", actual, comment) - } - } - } -} - -func TestObjectType(t *testing.T) { - var literals = []struct { - src string - nodeType []ast.Node - itemLen int - }{ - { - `foo = {}`, - nil, - 0, - }, - { - `foo = { - bar = "fatih" - }`, - []ast.Node{&ast.LiteralType{}}, - 1, - }, - { - `foo = { - bar = "fatih" - baz = ["arslan"] - }`, - []ast.Node{ - &ast.LiteralType{}, - &ast.ListType{}, - }, - 2, - }, - { - `foo = { - bar {} - }`, - []ast.Node{ - &ast.ObjectType{}, - }, - 1, - }, - { - `foo { - bar {} - foo = true - }`, - []ast.Node{ - &ast.ObjectType{}, - &ast.LiteralType{}, - }, - 2, - }, - } - - for _, l := range literals { - t.Logf("Source: %s", l.src) - - p := newParser([]byte(l.src)) - // p.enableTrace = true - item, err := p.objectItem() - if err != nil { - t.Error(err) - continue - } - - // we know that the ObjectKey name is foo for all cases, what matters - // is the object - obj, ok := item.Val.(*ast.ObjectType) - if !ok { - t.Errorf("node should be of type LiteralType, got: %T", item.Val) - continue - } - - // check if the total length of items are correct - equals(t, l.itemLen, len(obj.List.Items)) - - // check if the types are correct - for i, item := range obj.List.Items { - equals(t, reflect.TypeOf(l.nodeType[i]), reflect.TypeOf(item.Val)) - } - } -} - -func TestObjectKey(t *testing.T) { - keys := []struct { - exp []token.Type - src string - }{ - {[]token.Type{token.IDENT}, `foo {}`}, - {[]token.Type{token.IDENT}, `foo = {}`}, - {[]token.Type{token.IDENT}, `foo = bar`}, - {[]token.Type{token.IDENT}, `foo = 123`}, - {[]token.Type{token.IDENT}, `foo = "${var.bar}`}, - {[]token.Type{token.STRING}, `"foo" {}`}, - {[]token.Type{token.STRING}, `"foo" = {}`}, - {[]token.Type{token.STRING}, `"foo" = "${var.bar}`}, - {[]token.Type{token.IDENT, token.IDENT}, `foo bar {}`}, - {[]token.Type{token.IDENT, token.STRING}, `foo "bar" {}`}, - {[]token.Type{token.STRING, token.IDENT}, `"foo" bar {}`}, - {[]token.Type{token.IDENT, token.IDENT, token.IDENT}, `foo bar baz {}`}, - } - - for _, k := range keys { - p := newParser([]byte(k.src)) - keys, err := p.objectKey() - if err != nil { - t.Fatal(err) - } - - tokens := []token.Type{} - for _, o := range keys { - tokens = append(tokens, o.Token.Type) - } - - equals(t, k.exp, tokens) - } - - errKeys := []struct { - src string - }{ - {`foo 12 {}`}, - {`foo bar = {}`}, - {`foo []`}, - {`12 {}`}, - } - - for _, k := range errKeys { - p := newParser([]byte(k.src)) - _, err := p.objectKey() - if err == nil { - t.Errorf("case '%s' should give an error", k.src) - } - } -} - -func TestCommentGroup(t *testing.T) { - var cases = []struct { - src string - groups int - }{ - {"# Hello\n# World", 1}, - {"# Hello\r\n# Windows", 1}, - } - - for _, tc := range cases { - t.Run(tc.src, func(t *testing.T) { - p := newParser([]byte(tc.src)) - file, err := p.Parse() - if err != nil { - t.Fatalf("parse error: %s", err) - } - - if len(file.Comments) != tc.groups { - t.Fatalf("bad: %#v", file.Comments) - } - }) - } -} - -// Official HCL tests -func TestParse(t *testing.T) { - cases := []struct { - Name string - Err bool - }{ - { - "assign_colon.hcl", - true, - }, - { - "comment.hcl", - false, - }, - { - "comment_crlf.hcl", - false, - }, - { - "comment_lastline.hcl", - false, - }, - { - "comment_single.hcl", - false, - }, - { - "empty.hcl", - false, - }, - { - "list_comma.hcl", - false, - }, - { - "multiple.hcl", - false, - }, - { - "object_list_comma.hcl", - false, - }, - { - "structure.hcl", - false, - }, - { - "structure_basic.hcl", - false, - }, - { - "structure_empty.hcl", - false, - }, - { - "complex.hcl", - false, - }, - { - "complex_crlf.hcl", - false, - }, - { - "types.hcl", - false, - }, - { - "array_comment.hcl", - false, - }, - { - "array_comment_2.hcl", - true, - }, - { - "missing_braces.hcl", - true, - }, - { - "unterminated_object.hcl", - true, - }, - { - "unterminated_object_2.hcl", - true, - }, - { - "key_without_value.hcl", - true, - }, - { - "object_key_without_value.hcl", - true, - }, - { - "object_key_assign_without_value.hcl", - true, - }, - { - "object_key_assign_without_value2.hcl", - true, - }, - { - "object_key_assign_without_value3.hcl", - true, - }, - { - "git_crypt.hcl", - true, - }, - } - - const fixtureDir = "./test-fixtures" - - for _, tc := range cases { - t.Run(tc.Name, func(t *testing.T) { - d, err := ioutil.ReadFile(filepath.Join(fixtureDir, tc.Name)) - if err != nil { - t.Fatalf("err: %s", err) - } - - v, err := Parse(d) - if (err != nil) != tc.Err { - t.Fatalf("Input: %s\n\nError: %s\n\nAST: %#v", tc.Name, err, v) - } - }) - } -} - -func TestParse_inline(t *testing.T) { - cases := []struct { - Value string - Err bool - }{ - {"t t e{{}}", true}, - {"o{{}}", true}, - {"t t e d N{{}}", true}, - {"t t e d{{}}", true}, - {"N{}N{{}}", true}, - {"v\nN{{}}", true}, - {"v=/\n[,", true}, - {"v=10kb", true}, - {"v=/foo", true}, - } - - for _, tc := range cases { - t.Logf("Testing: %q", tc.Value) - ast, err := Parse([]byte(tc.Value)) - if (err != nil) != tc.Err { - t.Fatalf("Input: %q\n\nError: %s\n\nAST: %#v", tc.Value, err, ast) - } - } -} - -// equals fails the test if exp is not equal to act. -func equals(tb testing.TB, exp, act interface{}) { - if !reflect.DeepEqual(exp, act) { - _, file, line, _ := runtime.Caller(1) - fmt.Printf("\033[31m%s:%d:\n\n\texp: %#v\n\n\tgot: %#v\033[39m\n\n", filepath.Base(file), line, exp, act) - tb.FailNow() - } -} |