352 lines
9.1 KiB
Go
352 lines
9.1 KiB
Go
// Copyright 2011 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package template
|
|
|
|
// Tests for multiple-template parsing and execution.
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"testing"
|
|
"text/template/parse"
|
|
)
|
|
|
|
const (
|
|
noError = true
|
|
hasError = false
|
|
)
|
|
|
|
type multiParseTest struct {
|
|
name string
|
|
input string
|
|
ok bool
|
|
names []string
|
|
results []string
|
|
}
|
|
|
|
var multiParseTests = []multiParseTest{
|
|
{"empty", "", noError,
|
|
nil,
|
|
nil},
|
|
{"one", `{{define "foo"}} FOO {{end}}`, noError,
|
|
[]string{"foo"},
|
|
[]string{" FOO "}},
|
|
{"two", `{{define "foo"}} FOO {{end}}{{define "bar"}} BAR {{end}}`, noError,
|
|
[]string{"foo", "bar"},
|
|
[]string{" FOO ", " BAR "}},
|
|
// errors
|
|
{"missing end", `{{define "foo"}} FOO `, hasError,
|
|
nil,
|
|
nil},
|
|
{"malformed name", `{{define "foo}} FOO `, hasError,
|
|
nil,
|
|
nil},
|
|
}
|
|
|
|
func TestMultiParse(t *testing.T) {
|
|
for _, test := range multiParseTests {
|
|
template, err := New("root").Parse(test.input)
|
|
switch {
|
|
case err == nil && !test.ok:
|
|
t.Errorf("%q: expected error; got none", test.name)
|
|
continue
|
|
case err != nil && test.ok:
|
|
t.Errorf("%q: unexpected error: %v", test.name, err)
|
|
continue
|
|
case err != nil && !test.ok:
|
|
// expected error, got one
|
|
if *debug {
|
|
fmt.Printf("%s: %s\n\t%s\n", test.name, test.input, err)
|
|
}
|
|
continue
|
|
}
|
|
if template == nil {
|
|
continue
|
|
}
|
|
if len(template.tmpl) != len(test.names)+1 { // +1 for root
|
|
t.Errorf("%s: wrong number of templates; wanted %d got %d", test.name, len(test.names), len(template.tmpl))
|
|
continue
|
|
}
|
|
for i, name := range test.names {
|
|
tmpl, ok := template.tmpl[name]
|
|
if !ok {
|
|
t.Errorf("%s: can't find template %q", test.name, name)
|
|
continue
|
|
}
|
|
result := tmpl.Root.String()
|
|
if result != test.results[i] {
|
|
t.Errorf("%s=(%q): got\n\t%v\nexpected\n\t%v", test.name, test.input, result, test.results[i])
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
var multiExecTests = []execTest{
|
|
{"empty", "", "", nil, true},
|
|
{"text", "some text", "some text", nil, true},
|
|
{"invoke x", `{{template "x" .SI}}`, "TEXT", tVal, true},
|
|
{"invoke x no args", `{{template "x"}}`, "TEXT", tVal, true},
|
|
{"invoke dot int", `{{template "dot" .I}}`, "17", tVal, true},
|
|
{"invoke dot []int", `{{template "dot" .SI}}`, "[3 4 5]", tVal, true},
|
|
{"invoke dotV", `{{template "dotV" .U}}`, "v", tVal, true},
|
|
{"invoke nested int", `{{template "nested" .I}}`, "17", tVal, true},
|
|
{"variable declared by template", `{{template "nested" $x:=.SI}},{{index $x 1}}`, "[3 4 5],4", tVal, true},
|
|
|
|
// User-defined function: test argument evaluator.
|
|
{"testFunc literal", `{{oneArg "joe"}}`, "oneArg=joe", tVal, true},
|
|
{"testFunc .", `{{oneArg .}}`, "oneArg=joe", "joe", true},
|
|
}
|
|
|
|
// These strings are also in testdata/*.
|
|
const multiText1 = `
|
|
{{define "x"}}TEXT{{end}}
|
|
{{define "dotV"}}{{.V}}{{end}}
|
|
`
|
|
|
|
const multiText2 = `
|
|
{{define "dot"}}{{.}}{{end}}
|
|
{{define "nested"}}{{template "dot" .}}{{end}}
|
|
`
|
|
|
|
func TestMultiExecute(t *testing.T) {
|
|
// Declare a couple of templates first.
|
|
template, err := New("root").Parse(multiText1)
|
|
if err != nil {
|
|
t.Fatalf("parse error for 1: %s", err)
|
|
}
|
|
_, err = template.Parse(multiText2)
|
|
if err != nil {
|
|
t.Fatalf("parse error for 2: %s", err)
|
|
}
|
|
testExecute(multiExecTests, template, t)
|
|
}
|
|
|
|
func TestParseFiles(t *testing.T) {
|
|
_, err := ParseFiles("DOES NOT EXIST")
|
|
if err == nil {
|
|
t.Error("expected error for non-existent file; got none")
|
|
}
|
|
template := New("root")
|
|
_, err = template.ParseFiles("testdata/file1.tmpl", "testdata/file2.tmpl")
|
|
if err != nil {
|
|
t.Fatalf("error parsing files: %v", err)
|
|
}
|
|
testExecute(multiExecTests, template, t)
|
|
}
|
|
|
|
func TestParseGlob(t *testing.T) {
|
|
_, err := ParseGlob("DOES NOT EXIST")
|
|
if err == nil {
|
|
t.Error("expected error for non-existent file; got none")
|
|
}
|
|
_, err = New("error").ParseGlob("[x")
|
|
if err == nil {
|
|
t.Error("expected error for bad pattern; got none")
|
|
}
|
|
template := New("root")
|
|
_, err = template.ParseGlob("testdata/file*.tmpl")
|
|
if err != nil {
|
|
t.Fatalf("error parsing files: %v", err)
|
|
}
|
|
testExecute(multiExecTests, template, t)
|
|
}
|
|
|
|
// In these tests, actual content (not just template definitions) comes from the parsed files.
|
|
|
|
var templateFileExecTests = []execTest{
|
|
{"test", `{{template "tmpl1.tmpl"}}{{template "tmpl2.tmpl"}}`, "template1\n\ny\ntemplate2\n\nx\n", 0, true},
|
|
}
|
|
|
|
func TestParseFilesWithData(t *testing.T) {
|
|
template, err := New("root").ParseFiles("testdata/tmpl1.tmpl", "testdata/tmpl2.tmpl")
|
|
if err != nil {
|
|
t.Fatalf("error parsing files: %v", err)
|
|
}
|
|
testExecute(templateFileExecTests, template, t)
|
|
}
|
|
|
|
func TestParseGlobWithData(t *testing.T) {
|
|
template, err := New("root").ParseGlob("testdata/tmpl*.tmpl")
|
|
if err != nil {
|
|
t.Fatalf("error parsing files: %v", err)
|
|
}
|
|
testExecute(templateFileExecTests, template, t)
|
|
}
|
|
|
|
const (
|
|
cloneText1 = `{{define "a"}}{{template "b"}}{{template "c"}}{{end}}`
|
|
cloneText2 = `{{define "b"}}b{{end}}`
|
|
cloneText3 = `{{define "c"}}root{{end}}`
|
|
cloneText4 = `{{define "c"}}clone{{end}}`
|
|
)
|
|
|
|
func TestClone(t *testing.T) {
|
|
// Create some templates and clone the root.
|
|
root, err := New("root").Parse(cloneText1)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
_, err = root.Parse(cloneText2)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
clone := Must(root.Clone())
|
|
// Add variants to both.
|
|
_, err = root.Parse(cloneText3)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
_, err = clone.Parse(cloneText4)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
// Verify that the clone is self-consistent.
|
|
for k, v := range clone.tmpl {
|
|
if k == clone.name && v.tmpl[k] != clone {
|
|
t.Error("clone does not contain root")
|
|
}
|
|
if v != v.tmpl[v.name] {
|
|
t.Errorf("clone does not contain self for %q", k)
|
|
}
|
|
}
|
|
// Execute root.
|
|
var b bytes.Buffer
|
|
err = root.ExecuteTemplate(&b, "a", 0)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if b.String() != "broot" {
|
|
t.Errorf("expected %q got %q", "broot", b.String())
|
|
}
|
|
// Execute copy.
|
|
b.Reset()
|
|
err = clone.ExecuteTemplate(&b, "a", 0)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if b.String() != "bclone" {
|
|
t.Errorf("expected %q got %q", "bclone", b.String())
|
|
}
|
|
}
|
|
|
|
func TestAddParseTree(t *testing.T) {
|
|
// Create some templates.
|
|
root, err := New("root").Parse(cloneText1)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
_, err = root.Parse(cloneText2)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
// Add a new parse tree.
|
|
tree, err := parse.Parse("cloneText3", cloneText3, "", "", nil, builtins)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
added, err := root.AddParseTree("c", tree["c"])
|
|
// Execute.
|
|
var b bytes.Buffer
|
|
err = added.ExecuteTemplate(&b, "a", 0)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if b.String() != "broot" {
|
|
t.Errorf("expected %q got %q", "broot", b.String())
|
|
}
|
|
}
|
|
|
|
// Issue 7032
|
|
func TestAddParseTreeToUnparsedTemplate(t *testing.T) {
|
|
master := "{{define \"master\"}}{{end}}"
|
|
tmpl := New("master")
|
|
tree, err := parse.Parse("master", master, "", "", nil)
|
|
if err != nil {
|
|
t.Fatalf("unexpected parse err: %v", err)
|
|
}
|
|
masterTree := tree["master"]
|
|
tmpl.AddParseTree("master", masterTree) // used to panic
|
|
}
|
|
|
|
func TestRedefinition(t *testing.T) {
|
|
var tmpl *Template
|
|
var err error
|
|
if tmpl, err = New("tmpl1").Parse(`{{define "test"}}foo{{end}}`); err != nil {
|
|
t.Fatalf("parse 1: %v", err)
|
|
}
|
|
if _, err = tmpl.Parse(`{{define "test"}}bar{{end}}`); err != nil {
|
|
t.Fatalf("got error %v, expected nil", err)
|
|
}
|
|
if _, err = tmpl.New("tmpl2").Parse(`{{define "test"}}bar{{end}}`); err != nil {
|
|
t.Fatalf("got error %v, expected nil", err)
|
|
}
|
|
}
|
|
|
|
// Issue 10879
|
|
func TestEmptyTemplateCloneCrash(t *testing.T) {
|
|
t1 := New("base")
|
|
t1.Clone() // used to panic
|
|
}
|
|
|
|
// Issue 10910, 10926
|
|
func TestTemplateLookUp(t *testing.T) {
|
|
t1 := New("foo")
|
|
if t1.Lookup("foo") != nil {
|
|
t.Error("Lookup returned non-nil value for undefined template foo")
|
|
}
|
|
t1.New("bar")
|
|
if t1.Lookup("bar") != nil {
|
|
t.Error("Lookup returned non-nil value for undefined template bar")
|
|
}
|
|
t1.Parse(`{{define "foo"}}test{{end}}`)
|
|
if t1.Lookup("foo") == nil {
|
|
t.Error("Lookup returned nil value for defined template")
|
|
}
|
|
}
|
|
|
|
func TestNew(t *testing.T) {
|
|
// template with same name already exists
|
|
t1, _ := New("test").Parse(`{{define "test"}}foo{{end}}`)
|
|
t2 := t1.New("test")
|
|
|
|
if t1.common != t2.common {
|
|
t.Errorf("t1 & t2 didn't share common struct; got %v != %v", t1.common, t2.common)
|
|
}
|
|
if t1.Tree == nil {
|
|
t.Error("defined template got nil Tree")
|
|
}
|
|
if t2.Tree != nil {
|
|
t.Error("undefined template got non-nil Tree")
|
|
}
|
|
|
|
containsT1 := false
|
|
for _, tmpl := range t1.Templates() {
|
|
if tmpl == t2 {
|
|
t.Error("Templates included undefined template")
|
|
}
|
|
if tmpl == t1 {
|
|
containsT1 = true
|
|
}
|
|
}
|
|
if !containsT1 {
|
|
t.Error("Templates didn't include defined template")
|
|
}
|
|
}
|
|
|
|
func TestParse(t *testing.T) {
|
|
// In multiple calls to Parse with the same receiver template, only one call
|
|
// can contain text other than space, comments, and template definitions
|
|
t1 := New("test")
|
|
if _, err := t1.Parse(`{{define "test"}}{{end}}`); err != nil {
|
|
t.Fatalf("parsing test: %s", err)
|
|
}
|
|
if _, err := t1.Parse(`{{define "test"}}{{/* this is a comment */}}{{end}}`); err != nil {
|
|
t.Fatalf("parsing test: %s", err)
|
|
}
|
|
if _, err := t1.Parse(`{{define "test"}}foo{{end}}`); err != nil {
|
|
t.Fatalf("parsing test: %s", err)
|
|
}
|
|
}
|