snowchive-server/tests/tmplcheck_test.go
2026-11-19 04:40:59 +02:00

464 lines
12 KiB
Go

package main
import (
"fmt"
"io/fs"
"reflect"
"sort"
"strings"
"testing"
"text/template/parse"
)
// Every template is checked against the struct it is executed with, without
// executing it: each field or method it reads must exist on the type it is
// read from - in every branch, including the ones no test request takes.
// html/template only finds a wrong name when the action runs.
//
// The checker follows the data through range, with, variables and template
// calls. Where a type is not known statically it does not guess: a value
// behind an interface{} (a dict's missing key, the argument of a partial
// called with a literal) is accepted whatever is read from it.
func TestTemplatesMatchPages(t *testing.T) {
buildFixture(t)
for _, p := range pageTypes {
name := p.templateName()
set, err := parsePage(name) // a fresh parse: executing rewrites the trees
if err != nil {
t.Fatalf("%s: %v", name, err)
}
c := &tmplCheck{seen: map[string]bool{}, records: map[reflect.Type]bool{}}
c.lookup = func(n string) *parse.Tree {
if tt := set.Lookup(n); tt != nil {
return tt.Tree
}
return nil
}
c.call(name, reflect.TypeOf(p), 0)
sort.Strings(c.errs)
for _, e := range c.errs {
t.Errorf("%s (%T): %s", name, p, e)
}
}
}
// Each template file is some page's, and each page's template exists.
func TestEveryTemplateHasAPage(t *testing.T) {
buildFixture(t)
files, err := fs.Glob(templateFS, "*.html")
if err != nil {
t.Fatal(err)
}
byName := map[string]bool{}
for _, p := range pageTypes {
if byName[p.templateName()] {
t.Errorf("%s is the template of two page types", p.templateName())
}
byName[p.templateName()] = true
}
for _, f := range files {
if f == "base.html" || f == "partials.html" {
continue
}
if !byName[f] {
t.Errorf("%s has no page type in pageTypes", f)
}
delete(byName, f)
}
for n := range byName {
t.Errorf("page type for %s, which is not a template file", n)
}
}
// The checker itself: a misspelled field is found in a branch that would
// not run, behind a range, a variable and a partial; a dict's keys carry
// their types into the partial they are passed to.
func TestTemplateCheckerFindsWrongNames(t *testing.T) {
type row struct{ Name string }
type page struct {
Rows []row
Doc *Document
M map[string]int
}
for src, want := range map[string]string{
`{{ if .Nope }}x{{ end }}`: "Nope",
`{{ if false }}{{ range .Rows }}{{ .Nmae }}{{ end }}{{ end }}`: "Nmae",
`{{ range $i, $r := .Rows }}{{ $r.Name }}{{ $.Rowz }}{{ end }}`: "Rowz",
`{{ with .Doc }}{{ .Title }}{{ .DocMeta.Creatr }}{{ end }}`: "Creatr",
`{{ $d := .Doc }}{{ $d.Titel }}`: "Titel",
`{{ template "p" .Doc }}{{ define "p" }}{{ .ID }}{{ .Idd }}{{ end }}`: "Idd",
`{{ template "p" (dict "D" .Doc) }}{{ define "p" }}{{ .D.Idd }}{{ end }}`: "Idd",
`{{ index .M "a" }}{{ (index .Rows 0).Nmae }}`: "Nmae",
`{{ .Rows.Name }}`: "Name",
`{{ range .Rows }}{{ .Name }}{{ else }}{{ .Name }}{{ end }}`: "Name",
`{{ template "p" (dict "D" .Doc) }}{{ define "p" }}{{ .Missing.X }}{{ end }}`: "",
`{{ range .Rows }}{{ .Name }}{{ end }}{{ .Doc.Title }}{{ len .M }}`: "",
`{{ $x := "" }}{{ if .Doc }}{{ $x = .Doc }}{{ end }}{{ $x.Anything }}`: "",
} {
trees, err := parse.Parse("t", src, "", "", checkerFuncs())
if err != nil {
t.Fatalf("%s: %v", src, err)
}
c := &tmplCheck{seen: map[string]bool{}, records: map[reflect.Type]bool{}}
c.lookup = func(n string) *parse.Tree { return trees[n] }
c.call("t", reflect.TypeOf(page{}), 0)
got := strings.Join(c.errs, "; ")
if (want == "") != (got == "") || !strings.Contains(got, want) {
t.Errorf("%s\n errors: %q, want one naming %q", src, got, want)
}
}
}
// checkerFuncs is funcMap as the parser wants it, with the builtins the
// templates use.
func checkerFuncs() map[string]any {
m := map[string]any{}
for k, v := range funcMap {
m[k] = v
}
for _, b := range []string{"and", "or", "not", "eq", "ne", "lt", "le", "gt", "ge", "len", "index",
"slice", "print", "printf", "println", "html", "js", "urlquery", "call"} {
m[b] = true
}
return m
}
type tmplCheck struct {
lookup func(name string) *parse.Tree
seen map[string]bool // template name + argument type, already walked
records map[reflect.Type]bool // types made from a dict call: a missing key is nil, not an error
errs []string
where string // the template being walked
}
type tmplVar struct {
name string
typ reflect.Type // nil: not known
}
var (
stringType = reflect.TypeOf("")
intType = reflect.TypeOf(0)
boolType = reflect.TypeOf(false)
floatType = reflect.TypeOf(0.0)
anyType = reflect.TypeOf((*any)(nil)).Elem()
)
func (c *tmplCheck) errorf(n parse.Node, format string, a ...any) {
loc := c.where
if tree := c.lookup(c.where); tree != nil {
loc, _ = tree.ErrorContext(n)
}
c.errs = append(c.errs, fmt.Sprintf("%s (in %q): %s", loc, c.where, fmt.Sprintf(format, a...)))
}
// call walks the named template with dot of type arg.
func (c *tmplCheck) call(name string, arg reflect.Type, depth int) {
key := name + "|"
if arg != nil {
key += arg.String()
if c.records[arg] {
key += fmt.Sprintf("|%p", arg) // records print alike only when they are alike; keep them apart anyway
}
}
if c.seen[key] || depth > 20 {
return
}
c.seen[key] = true
tree := c.lookup(name)
if tree == nil || tree.Root == nil {
c.errs = append(c.errs, fmt.Sprintf("template %q is not defined", name))
return
}
prev := c.where
c.where = name
vars := []tmplVar{{"$", arg}}
c.walk(tree.Root, arg, &vars, depth)
c.where = prev
}
func (c *tmplCheck) walk(n parse.Node, dot reflect.Type, vars *[]tmplVar, depth int) {
switch n := n.(type) {
case *parse.ListNode:
if n == nil {
return
}
for _, x := range n.Nodes {
c.walk(x, dot, vars, depth)
}
case *parse.ActionNode:
c.pipe(n.Pipe, dot, vars)
case *parse.IfNode:
mark := len(*vars)
c.pipe(n.Pipe, dot, vars)
c.walk(n.List, dot, vars, depth)
c.walk(n.ElseList, dot, vars, depth)
*vars = (*vars)[:mark]
case *parse.WithNode:
mark := len(*vars)
t := c.pipe(n.Pipe, dot, vars)
c.walk(n.List, t, vars, depth)
c.walk(n.ElseList, dot, vars, depth)
*vars = (*vars)[:mark]
case *parse.RangeNode:
mark := len(*vars)
t := c.cmds(n.Pipe, dot, vars)
key, elem := rangeTypes(t)
switch len(n.Pipe.Decl) {
case 1:
*vars = append(*vars, tmplVar{n.Pipe.Decl[0].Ident[0], elem})
case 2:
*vars = append(*vars, tmplVar{n.Pipe.Decl[0].Ident[0], key}, tmplVar{n.Pipe.Decl[1].Ident[0], elem})
}
c.walk(n.List, elem, vars, depth)
*vars = (*vars)[:mark]
c.walk(n.ElseList, dot, vars, depth)
case *parse.TemplateNode:
var arg reflect.Type
if n.Pipe != nil {
arg = c.pipe(n.Pipe, dot, vars)
}
c.call(n.Name, arg, depth+1)
}
}
func rangeTypes(t reflect.Type) (key, elem reflect.Type) {
t = indirectType(t)
if t == nil {
return nil, nil
}
switch t.Kind() {
case reflect.Slice, reflect.Array:
return intType, known(t.Elem())
case reflect.Map:
return known(t.Key()), known(t.Elem())
case reflect.Int:
return intType, intType
}
return nil, nil
}
// known is t, or nil when t says nothing about the value (an interface).
func known(t reflect.Type) reflect.Type {
if t != nil && t.Kind() == reflect.Interface {
return nil
}
return t
}
func indirectType(t reflect.Type) reflect.Type {
for t != nil && t.Kind() == reflect.Pointer {
t = t.Elem()
}
return known(t)
}
// pipe is the type a pipeline yields, declaring or assigning its variable.
func (c *tmplCheck) pipe(p *parse.PipeNode, dot reflect.Type, vars *[]tmplVar) reflect.Type {
if p == nil {
return nil
}
t := c.cmds(p, dot, vars)
for _, d := range p.Decl {
name := d.Ident[0]
if !p.IsAssign {
*vars = append(*vars, tmplVar{name, t})
continue
}
for i := len(*vars) - 1; i >= 0; i-- {
if (*vars)[i].name == name {
if (*vars)[i].typ != t {
(*vars)[i].typ = nil // assigned two types: whichever branch ran decides
}
break
}
}
}
return t
}
func (c *tmplCheck) cmds(p *parse.PipeNode, dot reflect.Type, vars *[]tmplVar) reflect.Type {
var t reflect.Type
for i, cmd := range p.Cmds {
t = c.cmd(cmd, dot, vars, i > 0, t)
}
return t
}
func (c *tmplCheck) cmd(cmd *parse.CommandNode, dot reflect.Type, vars *[]tmplVar, piped bool, prev reflect.Type) reflect.Type {
first := cmd.Args[0]
if id, ok := first.(*parse.IdentifierNode); ok {
if id.Ident == "dict" {
return c.dict(cmd, dot, vars)
}
args := make([]reflect.Type, 0, len(cmd.Args))
for _, a := range cmd.Args[1:] {
args = append(args, c.arg(a, dot, vars))
}
if piped {
args = append(args, prev)
}
return c.fn(id, args)
}
for _, a := range cmd.Args[1:] { // a method's arguments
c.arg(a, dot, vars)
}
return c.arg(first, dot, vars)
}
func (c *tmplCheck) arg(n parse.Node, dot reflect.Type, vars *[]tmplVar) reflect.Type {
switch n := n.(type) {
case *parse.DotNode:
return dot
case *parse.FieldNode:
return c.fields(n, dot, n.Ident)
case *parse.VariableNode:
for i := len(*vars) - 1; i >= 0; i-- {
if (*vars)[i].name == n.Ident[0] {
return c.fields(n, (*vars)[i].typ, n.Ident[1:])
}
}
c.errorf(n, "undefined variable %s", n.Ident[0])
case *parse.ChainNode:
return c.fields(n, c.arg(n.Node, dot, vars), n.Field)
case *parse.PipeNode:
return c.pipe(n, dot, vars)
case *parse.IdentifierNode:
return c.fn(n, nil)
case *parse.StringNode:
return stringType
case *parse.BoolNode:
return boolType
case *parse.NumberNode:
if n.IsInt {
return intType
}
return floatType
}
return nil
}
// fields follows a chain of names from t.
func (c *tmplCheck) fields(n parse.Node, t reflect.Type, names []string) reflect.Type {
for _, name := range names {
if t == nil {
return nil
}
// A method, on the value or on its address.
recv := t
if recv.Kind() != reflect.Pointer && recv.Kind() != reflect.Interface {
recv = reflect.PointerTo(recv)
}
if m, ok := recv.MethodByName(name); ok {
t = nil
if m.Type.NumOut() > 0 {
t = known(m.Type.Out(0))
}
continue
}
s := indirectType(t)
if s == nil {
return nil
}
switch s.Kind() {
case reflect.Struct:
f, ok := s.FieldByName(name)
if !ok || !f.IsExported() {
if c.records[s] {
return nil // a key this dict call did not pass
}
c.errorf(n, "no field or method %s in %s", name, s)
return nil
}
t = known(f.Type)
case reflect.Map:
if s.Key().Kind() != reflect.String {
c.errorf(n, "%s read from %s, a map without string keys", name, s)
return nil
}
t = known(s.Elem())
default:
c.errorf(n, "%s read from %s, which has no fields", name, s)
return nil
}
}
return t
}
// dict is the record a dict call builds: each literal key with the type of
// the value passed for it.
func (c *tmplCheck) dict(cmd *parse.CommandNode, dot reflect.Type, vars *[]tmplVar) reflect.Type {
var fs []reflect.StructField
args := cmd.Args[1:]
for i := 0; i+1 < len(args); i += 2 {
k, ok := args[i].(*parse.StringNode)
t := c.arg(args[i+1], dot, vars)
if !ok {
return nil // a computed key: nothing is known about the record
}
if t == nil {
t = anyType
}
fs = append(fs, reflect.StructField{Name: k.Text, Type: t})
}
defer func() { recover() }() // a key that is not a Go identifier: no record
rt := reflect.StructOf(fs)
c.records[rt] = true
return rt
}
// fn is the type a function call yields.
func (c *tmplCheck) fn(id *parse.IdentifierNode, args []reflect.Type) reflect.Type {
switch id.Ident {
case "not", "eq", "ne", "lt", "le", "gt", "ge":
return boolType
case "len":
return intType
case "print", "printf", "println", "html", "js", "urlquery":
return stringType
case "and", "or":
for _, a := range args {
if a == nil || a != args[0] {
return nil
}
}
if len(args) > 0 {
return args[0]
}
return nil
case "slice":
if len(args) > 0 {
return args[0]
}
return nil
case "index":
if len(args) == 0 {
return nil
}
t := args[0]
for range args[1:] {
t = indirectType(t)
if t == nil {
return nil
}
switch t.Kind() {
case reflect.Map, reflect.Slice, reflect.Array:
t = known(t.Elem())
default:
return nil
}
}
return t
case "call":
return nil
}
f, ok := funcMap[id.Ident]
if !ok {
return nil // the parser has already refused an unknown function
}
ft := reflect.TypeOf(f)
if ft.NumOut() == 0 {
return nil
}
return known(ft.Out(0))
}