blob: 72aaff48d54f64166c59a9eb294680f8a8079d8e [file] [log] [blame]
package debug_test
// Provide 'static type checking' of the templates. This guards against changes is various
// gopls datastructures causing template execution to fail. The checking is done by
// the github.com/jba/templatecheck pacakge. Before that is run, the test checks that
// its list of templates and their arguments corresponds to the arguments in
// calls to render(). The test assumes that all uses of templates are done through render().
import (
"go/ast"
"html/template"
"log"
"runtime"
"sort"
"strings"
"testing"
"github.com/jba/templatecheck"
"golang.org/x/tools/go/packages"
"golang.org/x/tools/internal/lsp/cache"
"golang.org/x/tools/internal/lsp/debug"
"golang.org/x/tools/internal/lsp/source"
"golang.org/x/tools/internal/span"
)
type tdata struct {
tmpl *template.Template
data interface{} // a value of the needed type
}
var templates = map[string]tdata{
"MainTmpl": {debug.MainTmpl, &debug.Instance{}},
"DebugTmpl": {debug.DebugTmpl, nil},
"RPCTmpl": {debug.RPCTmpl, &debug.Rpcs{}},
"TraceTmpl": {debug.TraceTmpl, debug.TraceResults{}},
"CacheTmpl": {debug.CacheTmpl, &cache.Cache{}},
"SessionTmpl": {debug.SessionTmpl, &cache.Session{}},
"ViewTmpl": {debug.ViewTmpl, &cache.View{}},
"ClientTmpl": {debug.ClientTmpl, &debug.Client{}},
"ServerTmpl": {debug.ServerTmpl, &debug.Server{}},
//"FileTmpl": {FileTmpl, source.Overlay{}}, // need to construct a source.Overlay in init
"InfoTmpl": {debug.InfoTmpl, "something"},
"MemoryTmpl": {debug.MemoryTmpl, runtime.MemStats{}},
}
// construct a source.Overlay for fileTmpl
type fakeOverlay struct{}
func (fakeOverlay) Version() float64 {
return 0
}
func (fakeOverlay) Session() string {
return ""
}
func (fakeOverlay) VersionedFileIdentity() source.VersionedFileIdentity {
return source.VersionedFileIdentity{}
}
func (fakeOverlay) FileIdentity() source.FileIdentity {
return source.FileIdentity{}
}
func (fakeOverlay) Kind() source.FileKind {
return 0
}
func (fakeOverlay) Read() ([]byte, error) {
return nil, nil
}
func (fakeOverlay) Saved() bool {
return true
}
func (fakeOverlay) URI() span.URI {
return ""
}
var _ source.Overlay = fakeOverlay{}
func init() {
log.SetFlags(log.Lshortfile)
var v fakeOverlay
templates["FileTmpl"] = tdata{debug.FileTmpl, v}
}
func TestTemplates(t *testing.T) {
if runtime.GOOS == "android" {
t.Skip("this test is not supported for Android")
}
cfg := &packages.Config{
Mode: packages.NeedTypesInfo | packages.LoadAllSyntax, // figure out what's necessary PJW
}
pkgs, err := packages.Load(cfg, "golang.org/x/tools/internal/lsp/debug")
if err != nil {
t.Fatal(err)
}
if len(pkgs) != 1 {
t.Fatalf("expected a single package, but got %d", len(pkgs))
}
p := pkgs[0]
if len(p.Errors) != 0 {
t.Fatalf("compiler error, e.g. %v", p.Errors[0])
}
// find the calls to render in serve.go
tree := treeOf(p, "serve.go")
if tree == nil {
t.Fatalf("found no syntax tree for %s", "serve.go")
}
renders := callsOf(p, tree, "render")
if len(renders) == 0 {
t.Fatalf("found no calls to render")
}
var found = make(map[string]bool)
for _, r := range renders {
if len(r.Args) != 2 {
// template, func
t.Fatalf("got %d args, expected 2", len(r.Args))
}
t0, ok := p.TypesInfo.Types[r.Args[0]]
if !ok || !t0.IsValue() || t0.Type.String() != "*html/template.Template" {
t.Fatalf("no type info for template")
}
if id, ok := r.Args[0].(*ast.Ident); !ok {
t.Errorf("expected *ast.Ident, got %T", r.Args[0])
} else {
found[id.Name] = true
}
}
// make sure found and templates have the same templates
for k := range found {
if _, ok := templates[k]; !ok {
t.Errorf("code has template %s, but test does not", k)
}
}
for k := range templates {
if _, ok := found[k]; !ok {
t.Errorf("test has template %s, code does not", k)
}
}
// now check all the known templates, in alphabetic order, for determinacy
keys := []string{}
for k := range templates {
keys = append(keys, k)
}
sort.Strings(keys)
for _, k := range keys {
v := templates[k]
// the FuncMap is an annoyance; should not be necessary
if err := templatecheck.CheckHTML(v.tmpl, v.data); err != nil {
t.Errorf("%s: %v", k, err)
}
}
}
func callsOf(p *packages.Package, tree *ast.File, name string) []*ast.CallExpr {
var ans []*ast.CallExpr
f := func(n ast.Node) bool {
x, ok := n.(*ast.CallExpr)
if !ok {
return true
}
if y, ok := x.Fun.(*ast.Ident); ok {
if y.Name == name {
ans = append(ans, x)
}
}
return true
}
ast.Inspect(tree, f)
return ans
}
func treeOf(p *packages.Package, fname string) *ast.File {
for _, tree := range p.Syntax {
loc := tree.Package
pos := p.Fset.PositionFor(loc, false)
if strings.HasSuffix(pos.Filename, fname) {
return tree
}
}
return nil
}