multi_test.go

Documentation: html/template

		 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  
		 5  // Tests for multiple-template execution, copied from text/template.
		 6  
		 7  package template
		 8  
		 9  import (
		10  	"archive/zip"
		11  	"bytes"
		12  	"os"
		13  	"testing"
		14  	"text/template/parse"
		15  )
		16  
		17  var multiExecTests = []execTest{
		18  	{"empty", "", "", nil, true},
		19  	{"text", "some text", "some text", nil, true},
		20  	{"invoke x", `{{template "x" .SI}}`, "TEXT", tVal, true},
		21  	{"invoke x no args", `{{template "x"}}`, "TEXT", tVal, true},
		22  	{"invoke dot int", `{{template "dot" .I}}`, "17", tVal, true},
		23  	{"invoke dot []int", `{{template "dot" .SI}}`, "[3 4 5]", tVal, true},
		24  	{"invoke dotV", `{{template "dotV" .U}}`, "v", tVal, true},
		25  	{"invoke nested int", `{{template "nested" .I}}`, "17", tVal, true},
		26  	{"variable declared by template", `{{template "nested" $x:=.SI}},{{index $x 1}}`, "[3 4 5],4", tVal, true},
		27  
		28  	// User-defined function: test argument evaluator.
		29  	{"testFunc literal", `{{oneArg "joe"}}`, "oneArg=joe", tVal, true},
		30  	{"testFunc .", `{{oneArg .}}`, "oneArg=joe", "joe", true},
		31  }
		32  
		33  // These strings are also in testdata/*.
		34  const multiText1 = `
		35  	{{define "x"}}TEXT{{end}}
		36  	{{define "dotV"}}{{.V}}{{end}}
		37  `
		38  
		39  const multiText2 = `
		40  	{{define "dot"}}{{.}}{{end}}
		41  	{{define "nested"}}{{template "dot" .}}{{end}}
		42  `
		43  
		44  func TestMultiExecute(t *testing.T) {
		45  	// Declare a couple of templates first.
		46  	template, err := New("root").Parse(multiText1)
		47  	if err != nil {
		48  		t.Fatalf("parse error for 1: %s", err)
		49  	}
		50  	_, err = template.Parse(multiText2)
		51  	if err != nil {
		52  		t.Fatalf("parse error for 2: %s", err)
		53  	}
		54  	testExecute(multiExecTests, template, t)
		55  }
		56  
		57  func TestParseFiles(t *testing.T) {
		58  	_, err := ParseFiles("DOES NOT EXIST")
		59  	if err == nil {
		60  		t.Error("expected error for non-existent file; got none")
		61  	}
		62  	template := New("root")
		63  	_, err = template.ParseFiles("testdata/file1.tmpl", "testdata/file2.tmpl")
		64  	if err != nil {
		65  		t.Fatalf("error parsing files: %v", err)
		66  	}
		67  	testExecute(multiExecTests, template, t)
		68  }
		69  
		70  func TestParseGlob(t *testing.T) {
		71  	_, err := ParseGlob("DOES NOT EXIST")
		72  	if err == nil {
		73  		t.Error("expected error for non-existent file; got none")
		74  	}
		75  	_, err = New("error").ParseGlob("[x")
		76  	if err == nil {
		77  		t.Error("expected error for bad pattern; got none")
		78  	}
		79  	template := New("root")
		80  	_, err = template.ParseGlob("testdata/file*.tmpl")
		81  	if err != nil {
		82  		t.Fatalf("error parsing files: %v", err)
		83  	}
		84  	testExecute(multiExecTests, template, t)
		85  }
		86  
		87  func TestParseFS(t *testing.T) {
		88  	fs := os.DirFS("testdata")
		89  
		90  	{
		91  		_, err := ParseFS(fs, "DOES NOT EXIST")
		92  		if err == nil {
		93  			t.Error("expected error for non-existent file; got none")
		94  		}
		95  	}
		96  
		97  	{
		98  		template := New("root")
		99  		_, err := template.ParseFS(fs, "file1.tmpl", "file2.tmpl")
	 100  		if err != nil {
	 101  			t.Fatalf("error parsing files: %v", err)
	 102  		}
	 103  		testExecute(multiExecTests, template, t)
	 104  	}
	 105  
	 106  	{
	 107  		template := New("root")
	 108  		_, err := template.ParseFS(fs, "file*.tmpl")
	 109  		if err != nil {
	 110  			t.Fatalf("error parsing files: %v", err)
	 111  		}
	 112  		testExecute(multiExecTests, template, t)
	 113  	}
	 114  }
	 115  
	 116  // In these tests, actual content (not just template definitions) comes from the parsed files.
	 117  
	 118  var templateFileExecTests = []execTest{
	 119  	{"test", `{{template "tmpl1.tmpl"}}{{template "tmpl2.tmpl"}}`, "template1\n\ny\ntemplate2\n\nx\n", 0, true},
	 120  }
	 121  
	 122  func TestParseFilesWithData(t *testing.T) {
	 123  	template, err := New("root").ParseFiles("testdata/tmpl1.tmpl", "testdata/tmpl2.tmpl")
	 124  	if err != nil {
	 125  		t.Fatalf("error parsing files: %v", err)
	 126  	}
	 127  	testExecute(templateFileExecTests, template, t)
	 128  }
	 129  
	 130  func TestParseGlobWithData(t *testing.T) {
	 131  	template, err := New("root").ParseGlob("testdata/tmpl*.tmpl")
	 132  	if err != nil {
	 133  		t.Fatalf("error parsing files: %v", err)
	 134  	}
	 135  	testExecute(templateFileExecTests, template, t)
	 136  }
	 137  
	 138  func TestParseZipFS(t *testing.T) {
	 139  	z, err := zip.OpenReader("testdata/fs.zip")
	 140  	if err != nil {
	 141  		t.Fatalf("error parsing zip: %v", err)
	 142  	}
	 143  	template, err := New("root").ParseFS(z, "tmpl*.tmpl")
	 144  	if err != nil {
	 145  		t.Fatalf("error parsing files: %v", err)
	 146  	}
	 147  	testExecute(templateFileExecTests, template, t)
	 148  }
	 149  
	 150  const (
	 151  	cloneText1 = `{{define "a"}}{{template "b"}}{{template "c"}}{{end}}`
	 152  	cloneText2 = `{{define "b"}}b{{end}}`
	 153  	cloneText3 = `{{define "c"}}root{{end}}`
	 154  	cloneText4 = `{{define "c"}}clone{{end}}`
	 155  )
	 156  
	 157  // Issue 7032
	 158  func TestAddParseTreeToUnparsedTemplate(t *testing.T) {
	 159  	master := "{{define \"master\"}}{{end}}"
	 160  	tmpl := New("master")
	 161  	tree, err := parse.Parse("master", master, "", "", nil)
	 162  	if err != nil {
	 163  		t.Fatalf("unexpected parse err: %v", err)
	 164  	}
	 165  	masterTree := tree["master"]
	 166  	tmpl.AddParseTree("master", masterTree) // used to panic
	 167  }
	 168  
	 169  func TestRedefinition(t *testing.T) {
	 170  	var tmpl *Template
	 171  	var err error
	 172  	if tmpl, err = New("tmpl1").Parse(`{{define "test"}}foo{{end}}`); err != nil {
	 173  		t.Fatalf("parse 1: %v", err)
	 174  	}
	 175  	if _, err = tmpl.Parse(`{{define "test"}}bar{{end}}`); err != nil {
	 176  		t.Fatalf("got error %v, expected nil", err)
	 177  	}
	 178  	if _, err = tmpl.New("tmpl2").Parse(`{{define "test"}}bar{{end}}`); err != nil {
	 179  		t.Fatalf("got error %v, expected nil", err)
	 180  	}
	 181  }
	 182  
	 183  // Issue 10879
	 184  func TestEmptyTemplateCloneCrash(t *testing.T) {
	 185  	t1 := New("base")
	 186  	t1.Clone() // used to panic
	 187  }
	 188  
	 189  // Issue 10910, 10926
	 190  func TestTemplateLookUp(t *testing.T) {
	 191  	t.Skip("broken on html/template") // TODO
	 192  	t1 := New("foo")
	 193  	if t1.Lookup("foo") != nil {
	 194  		t.Error("Lookup returned non-nil value for undefined template foo")
	 195  	}
	 196  	t1.New("bar")
	 197  	if t1.Lookup("bar") != nil {
	 198  		t.Error("Lookup returned non-nil value for undefined template bar")
	 199  	}
	 200  	t1.Parse(`{{define "foo"}}test{{end}}`)
	 201  	if t1.Lookup("foo") == nil {
	 202  		t.Error("Lookup returned nil value for defined template")
	 203  	}
	 204  }
	 205  
	 206  func TestParse(t *testing.T) {
	 207  	// In multiple calls to Parse with the same receiver template, only one call
	 208  	// can contain text other than space, comments, and template definitions
	 209  	t1 := New("test")
	 210  	if _, err := t1.Parse(`{{define "test"}}{{end}}`); err != nil {
	 211  		t.Fatalf("parsing test: %s", err)
	 212  	}
	 213  	if _, err := t1.Parse(`{{define "test"}}{{/* this is a comment */}}{{end}}`); err != nil {
	 214  		t.Fatalf("parsing test: %s", err)
	 215  	}
	 216  	if _, err := t1.Parse(`{{define "test"}}foo{{end}}`); err != nil {
	 217  		t.Fatalf("parsing test: %s", err)
	 218  	}
	 219  }
	 220  
	 221  func TestEmptyTemplate(t *testing.T) {
	 222  	cases := []struct {
	 223  		defn []string
	 224  		in	 string
	 225  		want string
	 226  	}{
	 227  		{[]string{"x", "y"}, "", "y"},
	 228  		{[]string{""}, "once", ""},
	 229  		{[]string{"", ""}, "twice", ""},
	 230  		{[]string{"{{.}}", "{{.}}"}, "twice", "twice"},
	 231  		{[]string{"{{/* a comment */}}", "{{/* a comment */}}"}, "comment", ""},
	 232  		{[]string{"{{.}}", ""}, "twice", "twice"}, // TODO: should want "" not "twice"
	 233  	}
	 234  
	 235  	for i, c := range cases {
	 236  		root := New("root")
	 237  
	 238  		var (
	 239  			m	 *Template
	 240  			err error
	 241  		)
	 242  		for _, d := range c.defn {
	 243  			m, err = root.New(c.in).Parse(d)
	 244  			if err != nil {
	 245  				t.Fatal(err)
	 246  			}
	 247  		}
	 248  		buf := &bytes.Buffer{}
	 249  		if err := m.Execute(buf, c.in); err != nil {
	 250  			t.Error(i, err)
	 251  			continue
	 252  		}
	 253  		if buf.String() != c.want {
	 254  			t.Errorf("expected string %q: got %q", c.want, buf.String())
	 255  		}
	 256  	}
	 257  }
	 258  
	 259  // Issue 19249 was a regression in 1.8 caused by the handling of empty
	 260  // templates added in that release, which got different answers depending
	 261  // on the order templates appeared in the internal map.
	 262  func TestIssue19294(t *testing.T) {
	 263  	// The empty block in "xhtml" should be replaced during execution
	 264  	// by the contents of "stylesheet", but if the internal map associating
	 265  	// names with templates is built in the wrong order, the empty block
	 266  	// looks non-empty and this doesn't happen.
	 267  	var inlined = map[string]string{
	 268  		"stylesheet": `{{define "stylesheet"}}stylesheet{{end}}`,
	 269  		"xhtml":			`{{block "stylesheet" .}}{{end}}`,
	 270  	}
	 271  	all := []string{"stylesheet", "xhtml"}
	 272  	for i := 0; i < 100; i++ {
	 273  		res, err := New("title.xhtml").Parse(`{{template "xhtml" .}}`)
	 274  		if err != nil {
	 275  			t.Fatal(err)
	 276  		}
	 277  		for _, name := range all {
	 278  			_, err := res.New(name).Parse(inlined[name])
	 279  			if err != nil {
	 280  				t.Fatal(err)
	 281  			}
	 282  		}
	 283  		var buf bytes.Buffer
	 284  		res.Execute(&buf, 0)
	 285  		if buf.String() != "stylesheet" {
	 286  			t.Fatalf("iteration %d: got %q; expected %q", i, buf.String(), "stylesheet")
	 287  		}
	 288  	}
	 289  }
	 290
View as plain text