blob: 3b4236d8e2ce6d9118586f2fa4fa62a1c4a2ee8e [file] [log] [blame]
// Copyright 2024 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 main
import (
"bytes"
"errors"
"fmt"
"io"
"slices"
"strings"
"testing"
"github.com/google/safehtml"
"github.com/google/safehtml/template"
"golang.org/x/net/html"
"golang.org/x/net/html/atom"
"golang.org/x/oscar/internal/actions"
"golang.org/x/oscar/internal/github"
"golang.org/x/oscar/internal/llmapp"
"golang.org/x/oscar/internal/search"
)
func TestTemplates(t *testing.T) {
for _, test := range []struct {
name string
tmpl *template.Template
value any
}{
{"search", searchPageTmpl, searchPage{Results: []search.Result{{Kind: "k", Title: "t"}}}},
{"actionlog", actionLogPageTmpl, actionLogPage{
StartTime: "t",
Entries: []*actions.Entry{{Kind: "k"}},
}},
{"overview-initial", overviewPageTmpl, overviewPage{}},
{"overview", overviewPageTmpl, overviewPage{
overviewForm: overviewForm{Query: "12"},
Result: &overviewResult{
IssueOverviewResult: github.IssueOverviewResult{
Issue: &github.Issue{
User: github.User{Login: "abc"},
CreatedAt: "2023-01-01T0",
HTMLURL: "https://example.com",
},
NumComments: 2,
Overview: &llmapp.OverviewResult{
Overview: "an overview",
Cached: true,
Prompt: []string{"a prompt"},
},
},
OverviewHTML: safehtml.HTMLEscaped("an overview"),
}}},
} {
t.Run(test.name, func(t *testing.T) {
var buf bytes.Buffer
if err := test.tmpl.Execute(&buf, test.value); err != nil {
t.Fatal(err)
}
html := buf.String()
if err := validateHTML(html); err != nil {
printNumbered(html)
t.Fatalf("\n%s", err)
}
})
}
}
func printNumbered(s string) {
for i, line := range strings.Split(s, "\n") {
fmt.Printf("%3d %s\n", i+1, line)
}
}
// validateHTML performs basic HTML validation.
// It checks that every start tag has a matching end tag.
func validateHTML(s string) error {
type tag struct {
line int
a atom.Atom
}
var errs []error
var stack []tag
r := newLineReader(strings.NewReader(s))
tizer := html.NewTokenizer(r)
for tizer.Err() == nil {
tt := tizer.Next()
switch tt {
case html.ErrorToken:
if tizer.Err() != io.EOF {
errs = append(errs, tizer.Err())
}
case html.StartTagToken:
stack = append(stack, tag{r.line, tizer.Token().DataAtom})
case html.EndTagToken:
end := tizer.Token().DataAtom
n := len(stack)
if n == 0 {
errs = append(errs, fmt.Errorf("no start tag matching end tag </%s> on line %d", end, r.line))
} else {
top := stack[n-1]
if top.a != end {
errs = append(errs, fmt.Errorf("end tag </%s> on line %d does not match start tag <%s> on line %d",
end, r.line, top.a, top.line))
// don't pop the stack
} else {
stack = stack[:n-1]
}
}
default:
// ignore
}
}
return errors.Join(errs...)
}
// A lineReader is an io.Reader that tracks line numbers.
type lineReader struct {
line int
rest []byte
r io.Reader
}
func newLineReader(r io.Reader) *lineReader {
return &lineReader{line: 1, r: r}
}
func (r *lineReader) Read(buf []byte) (n int, err error) {
if len(r.rest) == 0 {
n, err = r.r.Read(buf)
r.rest = slices.Clone(buf[:n])
}
i := bytes.IndexByte(r.rest, '\n')
if i < 0 {
i = len(r.rest) - 1
} else {
r.line++
}
n = copy(buf, r.rest[:i+1])
r.rest = r.rest[i+1:]
return n, err
}