1// Copyright 2011 The Go Authors. All rights reserved. 2// Use of this source code is governed by a BSD-style 3// license that can be found in the LICENSE file. 4 5package template 6 7// Tests for mulitple-template parsing and execution. 8 9import ( 10 "bytes" 11 "fmt" 12 "strings" 13 "testing" 14 15 "github.com/alecthomas/template/parse" 16) 17 18const ( 19 noError = true 20 hasError = false 21) 22 23type multiParseTest struct { 24 name string 25 input string 26 ok bool 27 names []string 28 results []string 29} 30 31var multiParseTests = []multiParseTest{ 32 {"empty", "", noError, 33 nil, 34 nil}, 35 {"one", `{{define "foo"}} FOO {{end}}`, noError, 36 []string{"foo"}, 37 []string{" FOO "}}, 38 {"two", `{{define "foo"}} FOO {{end}}{{define "bar"}} BAR {{end}}`, noError, 39 []string{"foo", "bar"}, 40 []string{" FOO ", " BAR "}}, 41 // errors 42 {"missing end", `{{define "foo"}} FOO `, hasError, 43 nil, 44 nil}, 45 {"malformed name", `{{define "foo}} FOO `, hasError, 46 nil, 47 nil}, 48} 49 50func TestMultiParse(t *testing.T) { 51 for _, test := range multiParseTests { 52 template, err := New("root").Parse(test.input) 53 switch { 54 case err == nil && !test.ok: 55 t.Errorf("%q: expected error; got none", test.name) 56 continue 57 case err != nil && test.ok: 58 t.Errorf("%q: unexpected error: %v", test.name, err) 59 continue 60 case err != nil && !test.ok: 61 // expected error, got one 62 if *debug { 63 fmt.Printf("%s: %s\n\t%s\n", test.name, test.input, err) 64 } 65 continue 66 } 67 if template == nil { 68 continue 69 } 70 if len(template.tmpl) != len(test.names)+1 { // +1 for root 71 t.Errorf("%s: wrong number of templates; wanted %d got %d", test.name, len(test.names), len(template.tmpl)) 72 continue 73 } 74 for i, name := range test.names { 75 tmpl, ok := template.tmpl[name] 76 if !ok { 77 t.Errorf("%s: can't find template %q", test.name, name) 78 continue 79 } 80 result := tmpl.Root.String() 81 if result != test.results[i] { 82 t.Errorf("%s=(%q): got\n\t%v\nexpected\n\t%v", test.name, test.input, result, test.results[i]) 83 } 84 } 85 } 86} 87 88var multiExecTests = []execTest{ 89 {"empty", "", "", nil, true}, 90 {"text", "some text", "some text", nil, true}, 91 {"invoke x", `{{template "x" .SI}}`, "TEXT", tVal, true}, 92 {"invoke x no args", `{{template "x"}}`, "TEXT", tVal, true}, 93 {"invoke dot int", `{{template "dot" .I}}`, "17", tVal, true}, 94 {"invoke dot []int", `{{template "dot" .SI}}`, "[3 4 5]", tVal, true}, 95 {"invoke dotV", `{{template "dotV" .U}}`, "v", tVal, true}, 96 {"invoke nested int", `{{template "nested" .I}}`, "17", tVal, true}, 97 {"variable declared by template", `{{template "nested" $x:=.SI}},{{index $x 1}}`, "[3 4 5],4", tVal, true}, 98 99 // User-defined function: test argument evaluator. 100 {"testFunc literal", `{{oneArg "joe"}}`, "oneArg=joe", tVal, true}, 101 {"testFunc .", `{{oneArg .}}`, "oneArg=joe", "joe", true}, 102} 103 104// These strings are also in testdata/*. 105const multiText1 = ` 106 {{define "x"}}TEXT{{end}} 107 {{define "dotV"}}{{.V}}{{end}} 108` 109 110const multiText2 = ` 111 {{define "dot"}}{{.}}{{end}} 112 {{define "nested"}}{{template "dot" .}}{{end}} 113` 114 115func TestMultiExecute(t *testing.T) { 116 // Declare a couple of templates first. 117 template, err := New("root").Parse(multiText1) 118 if err != nil { 119 t.Fatalf("parse error for 1: %s", err) 120 } 121 _, err = template.Parse(multiText2) 122 if err != nil { 123 t.Fatalf("parse error for 2: %s", err) 124 } 125 testExecute(multiExecTests, template, t) 126} 127 128func TestParseFiles(t *testing.T) { 129 _, err := ParseFiles("DOES NOT EXIST") 130 if err == nil { 131 t.Error("expected error for non-existent file; got none") 132 } 133 template := New("root") 134 _, err = template.ParseFiles("testdata/file1.tmpl", "testdata/file2.tmpl") 135 if err != nil { 136 t.Fatalf("error parsing files: %v", err) 137 } 138 testExecute(multiExecTests, template, t) 139} 140 141func TestParseGlob(t *testing.T) { 142 _, err := ParseGlob("DOES NOT EXIST") 143 if err == nil { 144 t.Error("expected error for non-existent file; got none") 145 } 146 _, err = New("error").ParseGlob("[x") 147 if err == nil { 148 t.Error("expected error for bad pattern; got none") 149 } 150 template := New("root") 151 _, err = template.ParseGlob("testdata/file*.tmpl") 152 if err != nil { 153 t.Fatalf("error parsing files: %v", err) 154 } 155 testExecute(multiExecTests, template, t) 156} 157 158// In these tests, actual content (not just template definitions) comes from the parsed files. 159 160var templateFileExecTests = []execTest{ 161 {"test", `{{template "tmpl1.tmpl"}}{{template "tmpl2.tmpl"}}`, "template1\n\ny\ntemplate2\n\nx\n", 0, true}, 162} 163 164func TestParseFilesWithData(t *testing.T) { 165 template, err := New("root").ParseFiles("testdata/tmpl1.tmpl", "testdata/tmpl2.tmpl") 166 if err != nil { 167 t.Fatalf("error parsing files: %v", err) 168 } 169 testExecute(templateFileExecTests, template, t) 170} 171 172func TestParseGlobWithData(t *testing.T) { 173 template, err := New("root").ParseGlob("testdata/tmpl*.tmpl") 174 if err != nil { 175 t.Fatalf("error parsing files: %v", err) 176 } 177 testExecute(templateFileExecTests, template, t) 178} 179 180const ( 181 cloneText1 = `{{define "a"}}{{template "b"}}{{template "c"}}{{end}}` 182 cloneText2 = `{{define "b"}}b{{end}}` 183 cloneText3 = `{{define "c"}}root{{end}}` 184 cloneText4 = `{{define "c"}}clone{{end}}` 185) 186 187func TestClone(t *testing.T) { 188 // Create some templates and clone the root. 189 root, err := New("root").Parse(cloneText1) 190 if err != nil { 191 t.Fatal(err) 192 } 193 _, err = root.Parse(cloneText2) 194 if err != nil { 195 t.Fatal(err) 196 } 197 clone := Must(root.Clone()) 198 // Add variants to both. 199 _, err = root.Parse(cloneText3) 200 if err != nil { 201 t.Fatal(err) 202 } 203 _, err = clone.Parse(cloneText4) 204 if err != nil { 205 t.Fatal(err) 206 } 207 // Verify that the clone is self-consistent. 208 for k, v := range clone.tmpl { 209 if k == clone.name && v.tmpl[k] != clone { 210 t.Error("clone does not contain root") 211 } 212 if v != v.tmpl[v.name] { 213 t.Errorf("clone does not contain self for %q", k) 214 } 215 } 216 // Execute root. 217 var b bytes.Buffer 218 err = root.ExecuteTemplate(&b, "a", 0) 219 if err != nil { 220 t.Fatal(err) 221 } 222 if b.String() != "broot" { 223 t.Errorf("expected %q got %q", "broot", b.String()) 224 } 225 // Execute copy. 226 b.Reset() 227 err = clone.ExecuteTemplate(&b, "a", 0) 228 if err != nil { 229 t.Fatal(err) 230 } 231 if b.String() != "bclone" { 232 t.Errorf("expected %q got %q", "bclone", b.String()) 233 } 234} 235 236func TestAddParseTree(t *testing.T) { 237 // Create some templates. 238 root, err := New("root").Parse(cloneText1) 239 if err != nil { 240 t.Fatal(err) 241 } 242 _, err = root.Parse(cloneText2) 243 if err != nil { 244 t.Fatal(err) 245 } 246 // Add a new parse tree. 247 tree, err := parse.Parse("cloneText3", cloneText3, "", "", nil, builtins) 248 if err != nil { 249 t.Fatal(err) 250 } 251 added, err := root.AddParseTree("c", tree["c"]) 252 // Execute. 253 var b bytes.Buffer 254 err = added.ExecuteTemplate(&b, "a", 0) 255 if err != nil { 256 t.Fatal(err) 257 } 258 if b.String() != "broot" { 259 t.Errorf("expected %q got %q", "broot", b.String()) 260 } 261} 262 263// Issue 7032 264func TestAddParseTreeToUnparsedTemplate(t *testing.T) { 265 master := "{{define \"master\"}}{{end}}" 266 tmpl := New("master") 267 tree, err := parse.Parse("master", master, "", "", nil) 268 if err != nil { 269 t.Fatalf("unexpected parse err: %v", err) 270 } 271 masterTree := tree["master"] 272 tmpl.AddParseTree("master", masterTree) // used to panic 273} 274 275func TestRedefinition(t *testing.T) { 276 var tmpl *Template 277 var err error 278 if tmpl, err = New("tmpl1").Parse(`{{define "test"}}foo{{end}}`); err != nil { 279 t.Fatalf("parse 1: %v", err) 280 } 281 if _, err = tmpl.Parse(`{{define "test"}}bar{{end}}`); err == nil { 282 t.Fatal("expected error") 283 } 284 if !strings.Contains(err.Error(), "redefinition") { 285 t.Fatalf("expected redefinition error; got %v", err) 286 } 287 if _, err = tmpl.New("tmpl2").Parse(`{{define "test"}}bar{{end}}`); err == nil { 288 t.Fatal("expected error") 289 } 290 if !strings.Contains(err.Error(), "redefinition") { 291 t.Fatalf("expected redefinition error; got %v", err) 292 } 293} 294