github/hugo
1
0
Fork 0
mirror of https://github.com/gohugoio/hugo.git synced 2024-11-30 02:03:25 -05:00
Code Issues Projects Releases Packages Wiki Activity
hugo/tpl/tplimpl/template_test.go

350 lines
8.2 KiB
Go
Raw Normal View History

Add readFile template func This also includes a refactor of the hugofs package and its usage. The motivation for that is: The Afero filesystems are brilliant. Hugo's way of adding a dozen of global variables for the different filesystems was a mistake. In readFile (and also in some other places in Hugo today) we need a way to restrict the access inside the working dir. We could use ioutil.ReadFile and implement the path checking, checking the base path and the dots ("..") etc. But it is obviously better to use an Afero BasePathFs combined witha ReadOnlyFs. We could create a use-once-filesystem and handle the initialization ourselves, but since this is also useful to others and the initialization depends on some other global state (which would mean to create a new file system on every invocation), we might as well do it properly and encapsulate the predefined set of filesystems. This change also leads the way, if needed, to encapsulate the file systems in a struct, making it possible to have several file system sets in action at once (parallel multilanguage site building? With Moore's law and all...) Fixes #1551
2016-03-21 19:28:42 -04:00
// Copyright 2016 The Hugo Authors. All rights reserved.
Add copyright header to that source files that don’t have one. See #1646
2015-12-10 17:19:38 -05:00
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
tpl: Refactor package Now: * The template API lives in /tpl * The rest lives in /tpl/tplimpl This is bound te be more improved in the future. Updates #2701
2017-02-17 07:30:50 -05:00
package tplimpl
Truncated; .Site.Params; First function * Add `.Truncated` bool to each page; will be set true if the `.Summary` is truncated and it's worth showing a "more" link of some kind. * Add `Params` to the site config, defining `.Site.Params` accessible to each page; this lets the site maintainer associate arbitrary data with names, on a site-wide basis. * Provide a `First` function to templates: * Use-case: `{{range First 5 .Site.Recent}}` or anything else which is a simple iterable provided by hugolib * Tests by me for `.Truncated` and `First` Also @noahcampbell contributed towards this: * Add UnitTest for `.Site.Params`: > Digging into this test case a bit more, I'm realizing that we need > to create a param test case to ensure that for each type we render > (page, index, homepage, rss, etc.) that the proper fields are > represented. This will help us refactor without fear in the > future. Sample config.yaml: ```yaml title: "Test site" params: Subtitle: "More tests always good" AuthorName: "John Doe" SidebarRecentLimit: 5 ``` Signed-off-by: Noah Campbell <noahcampbell@gmail.com>
2013-11-10 15:04:51 -05:00
tpl: avoid panic on too few args to apply Fixes #1089
2015-04-30 04:51:01 -04:00
import (
Revert "tpl: Rework to handle both text and HTML templates" Will have to take another stab at this ... This reverts commit 5c5efa03d2512749950b0d05a7d4bde35ecbdc37. Closes #3260
2017-04-02 08:20:34 -04:00
"bytes"
tpl: avoid panic on too few args to apply Fixes #1089
2015-04-30 04:51:01 -04:00
"errors"
Revert "tpl: Rework to handle both text and HTML templates" Will have to take another stab at this ... This reverts commit 5c5efa03d2512749950b0d05a7d4bde35ecbdc37. Closes #3260
2017-04-02 08:20:34 -04:00
"html/template"
tpl: avoid panic on too few args to apply Fixes #1089
2015-04-30 04:51:01 -04:00
"io/ioutil"
Revert "tpl: Rework to handle both text and HTML templates" Will have to take another stab at this ... This reverts commit 5c5efa03d2512749950b0d05a7d4bde35ecbdc37. Closes #3260
2017-04-02 08:20:34 -04:00
"os"
"path/filepath"
"runtime"
"strings"
tpl: avoid panic on too few args to apply Fixes #1089
2015-04-30 04:51:01 -04:00
"testing"
tpl: Add missing printf param in t.Errorf call
2016-03-16 15:54:06 -04:00
Revert "tpl: Rework to handle both text and HTML templates" Will have to take another stab at this ... This reverts commit 5c5efa03d2512749950b0d05a7d4bde35ecbdc37. Closes #3260
2017-04-02 08:20:34 -04:00
"github.com/spf13/afero"
all: Refactor to nonglobal file systems Updates #2701 Fixes #2951
2017-01-10 04:55:03 -05:00
"github.com/spf13/hugo/deps"
all: Refactor to nonglobal Viper, i18n etc. This is a final rewrite that removes all the global state in Hugo, which also enables the use if `t.Parallel` in tests. Updates #2701 Fixes #3016
2017-02-04 22:20:06 -05:00
tpl: Refactor package Now: * The template API lives in /tpl * The rest lives in /tpl/tplimpl This is bound te be more improved in the future. Updates #2701
2017-02-17 07:30:50 -05:00
"github.com/spf13/hugo/tpl"
all: Refactor to nonglobal file systems Updates #2701 Fixes #2951
2017-01-10 04:55:03 -05:00
"github.com/spf13/viper"
"github.com/stretchr/testify/require"
tpl: avoid panic on too few args to apply Fixes #1089
2015-04-30 04:51:01 -04:00
)
Revert "tpl: Rework to handle both text and HTML templates" Will have to take another stab at this ... This reverts commit 5c5efa03d2512749950b0d05a7d4bde35ecbdc37. Closes #3260
2017-04-02 08:20:34 -04:00
// Some tests for Issue #1178 -- Ace
func TestAceTemplates(t *testing.T) {
t.Parallel()
for i, this := range []struct {
basePath string
innerPath string
baseContent string
innerContent string
expect string
expectErr int
}{
{"", filepath.FromSlash("_default/single.ace"), "", "{{ . }}", "DATA", 0},
{filepath.FromSlash("_default/baseof.ace"), filepath.FromSlash("_default/single.ace"),
`= content main
h2 This is a content named "main" of an inner template. {{ . }}`,
`= doctype html
html lang=en
head
meta charset=utf-8
title Base and Inner Template
body
h1 This is a base template {{ . }}
= yield main`, `<!DOCTYPE html><html lang="en"><head><meta charset="utf-8"><title>Base and Inner Template</title></head><body><h1>This is a base template DATA</h1></body></html>`, 0},
} {
for _, root := range []string{"", os.TempDir()} {
basePath := this.basePath
innerPath := this.innerPath
if basePath != "" && root != "" {
basePath = filepath.Join(root, basePath)
}
if innerPath != "" && root != "" {
innerPath = filepath.Join(root, innerPath)
}
d := "DATA"
config := newDepsConfig(viper.New())
config.WithTemplate = func(templ tpl.Template) error {
return templ.AddAceTemplate("mytemplate.ace", basePath, innerPath,
[]byte(this.baseContent), []byte(this.innerContent))
}
a, err := deps.New(config)
require.NoError(t, err)
if err := a.LoadResources(); err != nil {
t.Fatal(err)
}
templ := a.Tmpl.(*GoHTMLTemplate)
if len(templ.errors) > 0 && this.expectErr == 0 {
t.Errorf("Test %d with root '%s' errored: %v", i, root, templ.errors)
} else if len(templ.errors) == 0 && this.expectErr == 1 {
t.Errorf("#1 Test %d with root '%s' should have errored", i, root)
}
var buff bytes.Buffer
err = a.Tmpl.ExecuteTemplate(&buff, "mytemplate.html", d)
if err != nil && this.expectErr == 0 {
t.Errorf("Test %d with root '%s' errored: %s", i, root, err)
} else if err == nil && this.expectErr == 2 {
t.Errorf("#2 Test with root '%s' %d should have errored", root, i)
} else {
result := buff.String()
if result != this.expect {
t.Errorf("Test %d with root '%s' got\n%s\nexpected\n%s", i, root, result, this.expect)
}
}
}
}
}
func isAtLeastGo16() bool {
version := runtime.Version()
return strings.Contains(version, "1.6") || strings.Contains(version, "1.7")
}
func TestAddTemplateFileWithMaster(t *testing.T) {
t.Parallel()
if !isAtLeastGo16() {
t.Skip("This test only runs on Go >= 1.6")
}
for i, this := range []struct {
masterTplContent string
overlayTplContent string
writeSkipper int
expect interface{}
}{
{`A{{block "main" .}}C{{end}}C`, `{{define "main"}}B{{end}}`, 0, "ABC"},
{`A{{block "main" .}}C{{end}}C{{block "sub" .}}D{{end}}E`, `{{define "main"}}B{{end}}`, 0, "ABCDE"},
{`A{{block "main" .}}C{{end}}C{{block "sub" .}}D{{end}}E`, `{{define "main"}}B{{end}}{{define "sub"}}Z{{end}}`, 0, "ABCZE"},
{`tpl`, `tpl`, 1, false},
{`tpl`, `tpl`, 2, false},
{`{{.0.E}}`, `tpl`, 0, false},
{`tpl`, `{{.0.E}}`, 0, false},
} {
overlayTplName := "ot"
masterTplName := "mt"
finalTplName := "tp"
config := newDepsConfig(viper.New())
config.WithTemplate = func(templ tpl.Template) error {
err := templ.AddTemplateFileWithMaster(finalTplName, overlayTplName, masterTplName)
if b, ok := this.expect.(bool); ok && !b {
if err == nil {
t.Errorf("[%d] AddTemplateFileWithMaster didn't return an expected error", i)
}
} else {
if err != nil {
t.Errorf("[%d] AddTemplateFileWithMaster failed: %s", i, err)
return nil
}
resultTpl := templ.Lookup(finalTplName)
if resultTpl == nil {
t.Errorf("[%d] AddTemplateFileWithMaster: Result template not found", i)
return nil
}
var b bytes.Buffer
err := resultTpl.Execute(&b, nil)
if err != nil {
t.Errorf("[%d] AddTemplateFileWithMaster execute failed: %s", i, err)
return nil
}
resultContent := b.String()
if resultContent != this.expect {
t.Errorf("[%d] AddTemplateFileWithMaster got \n%s but expected \n%v", i, resultContent, this.expect)
}
}
return nil
}
if this.writeSkipper != 1 {
afero.WriteFile(config.Fs.Source, masterTplName, []byte(this.masterTplContent), 0644)
}
if this.writeSkipper != 2 {
afero.WriteFile(config.Fs.Source, overlayTplName, []byte(this.overlayTplContent), 0644)
}
deps.New(config)
}
}
// A Go stdlib test for linux/arm. Will remove later.
// See #1771
func TestBigIntegerFunc(t *testing.T) {
t.Parallel()
var func1 = func(v int64) error {
return nil
}
var funcs = map[string]interface{}{
"A": func1,
}
tpl, err := template.New("foo").Funcs(funcs).Parse("{{ A 3e80 }}")
if err != nil {
t.Fatal("Parse failed:", err)
}
err = tpl.Execute(ioutil.Discard, "foo")
if err == nil {
t.Fatal("Execute should have failed")
}
t.Log("Got expected error:", err)
}
// A Go stdlib test for linux/arm. Will remove later.
// See #1771
type BI struct {
}
func (b BI) A(v int64) error {
return nil
}
func TestBigIntegerMethod(t *testing.T) {
t.Parallel()
data := &BI{}
tpl, err := template.New("foo2").Parse("{{ .A 3e80 }}")
if err != nil {
t.Fatal("Parse failed:", err)
}
err = tpl.ExecuteTemplate(ioutil.Discard, "foo2", data)
if err == nil {
t.Fatal("Execute should have failed")
}
t.Log("Got expected error:", err)
}
tpl: avoid panic on too few args to apply Fixes #1089
2015-04-30 04:51:01 -04:00
// Test for bugs discovered by https://github.com/dvyukov/go-fuzz
func TestTplGoFuzzReports(t *testing.T) {
all: Refactor to nonglobal Viper, i18n etc. This is a final rewrite that removes all the global state in Hugo, which also enables the use if `t.Parallel` in tests. Updates #2701 Fixes #3016
2017-02-04 22:20:06 -05:00
t.Parallel()
tpl: add sanity check to prevent panic in seq on big nums Fixes #1092
2015-04-30 07:25:45 -04:00
// The following test case(s) also fail
// See https://github.com/golang/go/issues/10634
//{"{{ seq 433937734937734969526500969526500 }}", 2}}
tpl: avoid panic on too few args to apply Fixes #1089
2015-04-30 04:51:01 -04:00
for i, this := range []struct {
data string
expectErr int
tpl: check slice bounds in slicestr Fixes #1090
2015-04-30 05:26:34 -04:00
}{
// Issue #1089
Disable faulty range validation in apply Fixed #1098
2015-05-02 05:32:38 -04:00
//{"{{apply .C \"first\" }}", 2},
tpl: check slice bounds in slicestr Fixes #1090
2015-04-30 05:26:34 -04:00
// Issue #1090
tpl: check for too many arguments in apply Fixes #1091
2015-04-30 05:41:25 -04:00
{"{{ slicestr \"000000\" 10}}", 2},
// Issue #1091
Disable faulty range validation in apply Fixed #1098
2015-05-02 05:32:38 -04:00
//{"{{apply .C \"first\" 0 0 0}}", 2},
tpl: check that types in args match the target func's type Fixes #1095
2015-05-01 11:00:22 -04:00
{"{{seq 3e80}}", 2},
// Issue #1095
{"{{apply .C \"urlize\" " +
"\".\"}}", 2}} {
tpl: avoid panic on too few args to apply Fixes #1089
2015-04-30 04:51:01 -04:00
d := &Data{
A: 42,
B: "foo",
C: []int{1, 2, 3},
D: map[int]string{1: "foo", 2: "bar"},
E: Data1{42, "foo"},
tpl: add sanity check to prevent panic in seq on big nums Fixes #1092
2015-04-30 07:25:45 -04:00
F: []string{"a", "b", "c"},
G: []string{"a", "b", "c", "d", "e"},
H: "a,b,c,d,e,f",
tpl: avoid panic on too few args to apply Fixes #1089
2015-04-30 04:51:01 -04:00
}
all: Refactor to nonglobal Viper, i18n etc. This is a final rewrite that removes all the global state in Hugo, which also enables the use if `t.Parallel` in tests. Updates #2701 Fixes #3016
2017-02-04 22:20:06 -05:00
config := newDepsConfig(viper.New())
Revert "tpl: Rework to handle both text and HTML templates" Will have to take another stab at this ... This reverts commit 5c5efa03d2512749950b0d05a7d4bde35ecbdc37. Closes #3260
2017-04-02 08:20:34 -04:00
config.WithTemplate = func(templ tpl.Template) error {
all: Refactor to nonglobal template handling Updates #2701
2017-01-09 19:36:59 -05:00
return templ.AddTemplate("fuzz", this.data)
all: Refactor to nonglobal file systems Updates #2701 Fixes #2951
2017-01-10 04:55:03 -05:00
}
all: Propagate baseURL error to the callers
2017-03-25 09:37:04 -04:00
de, err := deps.New(config)
require.NoError(t, err)
all: Refactor to nonglobal Viper, i18n etc. This is a final rewrite that removes all the global state in Hugo, which also enables the use if `t.Parallel` in tests. Updates #2701 Fixes #3016
2017-02-04 22:20:06 -05:00
require.NoError(t, de.LoadResources())
tpl: avoid panic on too few args to apply Fixes #1089
2015-04-30 04:51:01 -04:00
Revert "tpl: Rework to handle both text and HTML templates" Will have to take another stab at this ... This reverts commit 5c5efa03d2512749950b0d05a7d4bde35ecbdc37. Closes #3260
2017-04-02 08:20:34 -04:00
templ := de.Tmpl.(*GoHTMLTemplate)
tpl: avoid panic on too few args to apply Fixes #1089
2015-04-30 04:51:01 -04:00
all: Refactor to nonglobal template handling Updates #2701
2017-01-09 19:36:59 -05:00
if len(templ.errors) > 0 && this.expectErr == 0 {
t.Errorf("Test %d errored: %v", i, templ.errors)
} else if len(templ.errors) == 0 && this.expectErr == 1 {
t.Errorf("#1 Test %d should have errored", i)
}
all: Refactor to nonglobal file systems Updates #2701 Fixes #2951
2017-01-10 04:55:03 -05:00
Revert "tpl: Rework to handle both text and HTML templates" Will have to take another stab at this ... This reverts commit 5c5efa03d2512749950b0d05a7d4bde35ecbdc37. Closes #3260
2017-04-02 08:20:34 -04:00
err = de.Tmpl.ExecuteTemplate(ioutil.Discard, "fuzz", d)
tpl: avoid panic on too few args to apply Fixes #1089
2015-04-30 04:51:01 -04:00
if err != nil && this.expectErr == 0 {
t.Fatalf("Test %d errored: %s", i, err)
} else if err == nil && this.expectErr == 2 {
t.Fatalf("#2 Test %d should have errored", i)
}
all: Refactor to nonglobal file systems Updates #2701 Fixes #2951
2017-01-10 04:55:03 -05:00
tpl: avoid panic on too few args to apply Fixes #1089
2015-04-30 04:51:01 -04:00
}
}
type Data struct {
A int
B string
C []int
D map[int]string
E Data1
tpl: add sanity check to prevent panic in seq on big nums Fixes #1092
2015-04-30 07:25:45 -04:00
F []string
G []string
H string
tpl: avoid panic on too few args to apply Fixes #1089
2015-04-30 04:51:01 -04:00
}
type Data1 struct {
A int
B string
}
func (Data1) Q() string {
return "foo"
}
func (Data1) W() (string, error) {
return "foo", nil
}
func (Data1) E() (string, error) {
return "foo", errors.New("Data.E error")
}
func (Data1) R(v int) (string, error) {
return "foo", nil
}
func (Data1) T(s string) (string, error) {
return s, nil
}
Reference in a new issue Copy permalink