vendor/github.com/hashicorp/hcl/hcl/ast/ast_test.go

   1 package ast
   2
   3 import (
   4         "reflect"
   5         "strings"
   6         "testing"
   7
   8         "github.com/hashicorp/hcl/hcl/token"
   9 )
  10
  11 func TestObjectListFilter(t *testing.T) {
  12         var cases = []struct {
  13                 Filter []string
  14                 Input  []*ObjectItem
  15                 Output []*ObjectItem
  16         }{
  17                 {
  18                         []string{"foo"},
  19                         []*ObjectItem{
  20                                 &ObjectItem{
  21                                         Keys: []*ObjectKey{
  22                                                 &ObjectKey{
  23                                                         Token: token.Token{Type: token.STRING, Text: `"foo"`},
  24                                                 },
  25                                         },
  26                                 },
  27                         },
  28                         []*ObjectItem{
  29                                 &ObjectItem{
  30                                         Keys: []*ObjectKey{},
  31                                 },
  32                         },
  33                 },
  34
  35                 {
  36                         []string{"foo"},
  37                         []*ObjectItem{
  38                                 &ObjectItem{
  39                                         Keys: []*ObjectKey{
  40                                                 &ObjectKey{Token: token.Token{Type: token.STRING, Text: `"foo"`}},
  41                                                 &ObjectKey{Token: token.Token{Type: token.STRING, Text: `"bar"`}},
  42                                         },
  43                                 },
  44                                 &ObjectItem{
  45                                         Keys: []*ObjectKey{
  46                                                 &ObjectKey{Token: token.Token{Type: token.STRING, Text: `"baz"`}},
  47                                         },
  48                                 },
  49                         },
  50                         []*ObjectItem{
  51                                 &ObjectItem{
  52                                         Keys: []*ObjectKey{
  53                                                 &ObjectKey{Token: token.Token{Type: token.STRING, Text: `"bar"`}},
  54                                         },
  55                                 },
  56                         },
  57                 },
  58         }
  59
  60         for _, tc := range cases {
  61                 input := &ObjectList{Items: tc.Input}
  62                 expected := &ObjectList{Items: tc.Output}
  63                 if actual := input.Filter(tc.Filter...); !reflect.DeepEqual(actual, expected) {
  64                         t.Fatalf("in order: input, expected, actual\n\n%#v\n\n%#v\n\n%#v", input, expected, actual)
  65                 }
  66         }
  67 }
  68
  69 func TestWalk(t *testing.T) {
  70         items := []*ObjectItem{
  71                 &ObjectItem{
  72                         Keys: []*ObjectKey{
  73                                 &ObjectKey{Token: token.Token{Type: token.STRING, Text: `"foo"`}},
  74                                 &ObjectKey{Token: token.Token{Type: token.STRING, Text: `"bar"`}},
  75                         },
  76                         Val: &LiteralType{Token: token.Token{Type: token.STRING, Text: `"example"`}},
  77                 },
  78                 &ObjectItem{
  79                         Keys: []*ObjectKey{
  80                                 &ObjectKey{Token: token.Token{Type: token.STRING, Text: `"baz"`}},
  81                         },
  82                 },
  83         }
  84
  85         node := &ObjectList{Items: items}
  86
  87         order := []string{
  88                 "*ast.ObjectList",
  89                 "*ast.ObjectItem",
  90                 "*ast.ObjectKey",
  91                 "*ast.ObjectKey",
  92                 "*ast.LiteralType",
  93                 "*ast.ObjectItem",
  94                 "*ast.ObjectKey",
  95         }
  96         count := 0
  97
  98         Walk(node, func(n Node) (Node, bool) {
  99                 if n == nil {
 100                         return n, false
 101                 }
 102
 103                 typeName := reflect.TypeOf(n).String()
 104                 if order[count] != typeName {
 105                         t.Errorf("expected '%s' got: '%s'", order[count], typeName)
 106                 }
 107                 count++
 108                 return n, true
 109         })
 110 }
 111
 112 func TestWalkEquality(t *testing.T) {
 113         items := []*ObjectItem{
 114                 &ObjectItem{
 115                         Keys: []*ObjectKey{
 116                                 &ObjectKey{Token: token.Token{Type: token.STRING, Text: `"foo"`}},
 117                         },
 118                 },
 119                 &ObjectItem{
 120                         Keys: []*ObjectKey{
 121                                 &ObjectKey{Token: token.Token{Type: token.STRING, Text: `"bar"`}},
 122                         },
 123                 },
 124         }
 125
 126         node := &ObjectList{Items: items}
 127
 128         rewritten := Walk(node, func(n Node) (Node, bool) { return n, true })
 129
 130         newNode, ok := rewritten.(*ObjectList)
 131         if !ok {
 132                 t.Fatalf("expected Objectlist, got %T", rewritten)
 133         }
 134
 135         if !reflect.DeepEqual(node, newNode) {
 136                 t.Fatal("rewritten node is not equal to the given node")
 137         }
 138
 139         if len(newNode.Items) != 2 {
 140                 t.Error("expected newNode length 2, got: %d", len(newNode.Items))
 141         }
 142
 143         expected := []string{
 144                 `"foo"`,
 145                 `"bar"`,
 146         }
 147
 148         for i, item := range newNode.Items {
 149                 if len(item.Keys) != 1 {
 150                         t.Error("expected keys newNode length 1, got: %d", len(item.Keys))
 151                 }
 152
 153                 if item.Keys[0].Token.Text != expected[i] {
 154                         t.Errorf("expected key %s, got %s", expected[i], item.Keys[0].Token.Text)
 155                 }
 156
 157                 if item.Val != nil {
 158                         t.Errorf("expected item value should be nil")
 159                 }
 160         }
 161 }
 162
 163 func TestWalkRewrite(t *testing.T) {
 164         items := []*ObjectItem{
 165                 &ObjectItem{
 166                         Keys: []*ObjectKey{
 167                                 &ObjectKey{Token: token.Token{Type: token.STRING, Text: `"foo"`}},
 168                                 &ObjectKey{Token: token.Token{Type: token.STRING, Text: `"bar"`}},
 169                         },
 170                 },
 171                 &ObjectItem{
 172                         Keys: []*ObjectKey{
 173                                 &ObjectKey{Token: token.Token{Type: token.STRING, Text: `"baz"`}},
 174                         },
 175                 },
 176         }
 177
 178         node := &ObjectList{Items: items}
 179
 180         suffix := "_example"
 181         node = Walk(node, func(n Node) (Node, bool) {
 182                 switch i := n.(type) {
 183                 case *ObjectKey:
 184                         i.Token.Text = i.Token.Text + suffix
 185                         n = i
 186                 }
 187                 return n, true
 188         }).(*ObjectList)
 189
 190         Walk(node, func(n Node) (Node, bool) {
 191                 switch i := n.(type) {
 192                 case *ObjectKey:
 193                         if !strings.HasSuffix(i.Token.Text, suffix) {
 194                                 t.Errorf("Token '%s' should have suffix: %s", i.Token.Text, suffix)
 195                         }
 196                 }
 197                 return n, true
 198         })
 199
 200 }