tag
`, }, }, { name: "comments can contain tags", input: ``, expected: HTMLComment{ Contents: `
A
A
B
B
C
C
Data
"))), Header: make(http.Header), Request: &http.Request{ URL: &url.URL{ Scheme: "http", Host: "example.com", }, }, } r.Header.Set("Content-Type", "text/html, charset=utf-8") r.Header.Set("Content-Encoding", "weird-encoding") // Act lh := newTestLogHandler(slog.LevelInfo) log := slog.New(lh) h := New(log, "http", "127.0.0.1", 7474, &url.URL{Scheme: "http", Host: "example.com"}) err := h.modifyResponse(r) if err != nil { t.Fatalf("unexpected error: %v", err) } // Assert if len(lh.records) != 1 { var sb strings.Builder for _, record := range lh.records { sb.WriteString(record.Message) sb.WriteString("\n") } t.Fatalf("expected 1 log entry, but got %d: \n%s", len(lh.records), sb.String()) } record := lh.records[0] if record.Message != unsupportedContentEncoding { t.Errorf("expected warning message %q, got %q", unsupportedContentEncoding, record.Message) } if record.Level != slog.LevelWarn { t.Errorf("expected warning, got level %v", record.Level) } }) } func newTestLogHandler(level slog.Level) *testLogHandler { return &testLogHandler{ m: new(sync.Mutex), records: nil, level: level, } } type testLogHandler struct { m *sync.Mutex records []slog.Record level slog.Level } func (h *testLogHandler) Enabled(ctx context.Context, l slog.Level) bool { return l >= h.level } func (h *testLogHandler) Handle(ctx context.Context, r slog.Record) error { h.m.Lock() defer h.m.Unlock() if r.Level < h.level { return nil } h.records = append(h.records, r) return nil } func (h *testLogHandler) WithAttrs(attrs []slog.Attr) slog.Handler { return h } func (h *testLogHandler) WithGroup(name string) slog.Handler { return h } func TestParseNonce(t *testing.T) { for _, tc := range []struct { name string csp string expected string }{ { name: "empty csp", csp: "", expected: "", }, { name: "simple csp", csp: "script-src 'nonce-oLhVst3hTAcxI734qtB0J9Qc7W4qy09C'", expected: "oLhVst3hTAcxI734qtB0J9Qc7W4qy09C", }, { name: "simple csp without single quote", csp: "script-src nonce-oLhVst3hTAcxI734qtB0J9Qc7W4qy09C", expected: "oLhVst3hTAcxI734qtB0J9Qc7W4qy09C", }, { name: "complete csp", csp: "default-src 'self'; frame-ancestors 'self'; form-action 'self'; script-src 'strict-dynamic' 'nonce-4VOtk0Uo1l7pwtC';", expected: "4VOtk0Uo1l7pwtC", }, { name: "mdn example 1", csp: "default-src 'self'", expected: "", }, { name: "mdn example 2", csp: "default-src 'self' *.trusted.com", expected: "", }, { name: "mdn example 3", csp: "default-src 'self'; img-src *; media-src media1.com media2.com; script-src userscripts.example.com", expected: "", }, { name: "mdn example 3 multiple sources", csp: "default-src 'self'; img-src *; media-src media1.com media2.com; script-src userscripts.example.com foo.com 'strict-dynamic' 'nonce-4VOtk0Uo1l7pwtC'", expected: "4VOtk0Uo1l7pwtC", }, } { t.Run(tc.name, func(t *testing.T) { nonce := parseNonce(tc.csp) if nonce != tc.expected { t.Errorf("expected nonce to be %s, but got %s", tc.expected, nonce) } }) } } func TestStreamInsertAfterBodyOpen(t *testing.T) { t.Run("script tags with special characters are not escaped", func(t *testing.T) { input := `Content
` nonce := "test-nonce-123" var output bytes.Buffer err := streamInsertAfterBodyOpen(nonce, strings.NewReader(input), &output) if err != nil { t.Fatalf("unexpected error: %v", err) } result := output.String() if !strings.Contains(result, `nonce="`+nonce+`"`) { t.Errorf("expected nonce attribute to be present with value %s, got: %s", nonce, result) } if !strings.Contains(result, `src="/_templ/reload/script.js"`) { t.Errorf("expected script src to be present, got: %s", result) } }) } ================================================ FILE: cmd/templ/generatecmd/proxy/script.js ================================================ (function() { let templ_reloadSrc = window.templ_reloadSrc || new EventSource("/_templ/reload/events"); templ_reloadSrc.onmessage = (event) => { if (event && event.data === "reload") { window.location.reload(); } }; window.templ_reloadSrc = templ_reloadSrc; window.onbeforeunload = () => window.templ_reloadSrc.close(); })(); ================================================ FILE: cmd/templ/generatecmd/run/run_test.go ================================================ package run_test import ( "context" "embed" "io" "net/http" "os" "path/filepath" "syscall" "testing" "time" "github.com/a-h/templ/cmd/templ/generatecmd/run" ) //go:embed testprogram/* var testprogram embed.FS func TestGoRun(t *testing.T) { if testing.Short() { t.Skip("Skipping test in short mode.") } // Copy testprogram to a temporary directory. dir, err := os.MkdirTemp("", "testprogram") if err != nil { t.Fatalf("failed to make test dir: %v", err) } files, err := testprogram.ReadDir("testprogram") if err != nil { t.Fatalf("failed to read embedded dir: %v", err) } for _, file := range files { srcFileName := "testprogram/" + file.Name() srcData, err := testprogram.ReadFile(srcFileName) if err != nil { t.Fatalf("failed to read src file %q: %v", srcFileName, err) } tgtFileName := filepath.Join(dir, file.Name()) if err = os.WriteFile(tgtFileName, srcData, 0644); err != nil { t.Fatalf("failed to write tgt file %q: %v", tgtFileName, err) } } // Rename the go.mod.embed file to go.mod. if err := os.Rename(filepath.Join(dir, "go.mod.embed"), filepath.Join(dir, "go.mod")); err != nil { t.Fatalf("failed to rename go.mod.embed: %v", err) } tests := []struct { name string cmd string }{ { name: "Well behaved programs get shut down", cmd: "go run .", }, { name: "Badly behaved programs get shut down", cmd: "go run . -badly-behaved", }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { ctx := context.Background() cmd, err := run.Run(ctx, dir, tt.cmd) if err != nil { t.Fatalf("failed to run program: %v", err) } time.Sleep(1 * time.Second) pid := cmd.Process.Pid if err := run.KillAll(); err != nil { t.Fatalf("failed to kill all: %v", err) } // Check the parent process is no longer running. if err := cmd.Process.Signal(os.Signal(syscall.Signal(0))); err == nil { t.Fatalf("process %d is still running", pid) } // Check that the child was stopped. body, err := readResponse("http://localhost:7777") if err == nil { t.Fatalf("child process is still running: %s", body) } }) } } func readResponse(url string) (body string, err error) { resp, err := http.Get(url) if err != nil { return body, err } b, err := io.ReadAll(resp.Body) if err != nil { _ = resp.Body.Close() return body, err } if err = resp.Body.Close(); err != nil { return body, err } return string(b), nil } ================================================ FILE: cmd/templ/generatecmd/run/run_unix.go ================================================ //go:build unix package run import ( "context" "errors" "fmt" "os" "os/exec" "strings" "sync" "syscall" "time" ) var ( m = &sync.Mutex{} running = map[string]*exec.Cmd{} ) func KillAll() (err error) { m.Lock() defer m.Unlock() var errs []error for _, cmd := range running { if err := kill(cmd); err != nil { errs = append(errs, fmt.Errorf("failed to kill process %d: %w", cmd.Process.Pid, err)) } } running = map[string]*exec.Cmd{} return errors.Join(errs...) } func kill(cmd *exec.Cmd) (err error) { errs := make([]error, 4) errs[0] = ignoreExited(cmd.Process.Signal(syscall.SIGINT)) errs[1] = ignoreExited(cmd.Process.Signal(syscall.SIGTERM)) errs[2] = ignoreExited(cmd.Wait()) errs[3] = ignoreExited(syscall.Kill(-cmd.Process.Pid, syscall.SIGKILL)) return errors.Join(errs...) } func ignoreExited(err error) error { if errors.Is(err, syscall.ESRCH) { return nil } // Ignore *exec.ExitError if _, ok := err.(*exec.ExitError); ok { return nil } return err } func Run(ctx context.Context, workingDir string, input string) (cmd *exec.Cmd, err error) { m.Lock() defer m.Unlock() cmd, ok := running[input] if ok { if err := kill(cmd); err != nil { return cmd, fmt.Errorf("failed to kill process %d: %w", cmd.Process.Pid, err) } delete(running, input) } parts := strings.Fields(input) executable := parts[0] args := []string{} if len(parts) > 1 { args = append(args, parts[1:]...) } cmd = exec.CommandContext(ctx, executable, args...) // Wait for the process to finish gracefully before termination. cmd.WaitDelay = time.Second * 3 cmd.Env = os.Environ() cmd.Dir = workingDir cmd.Stdin = os.Stdin cmd.Stdout = os.Stdout cmd.Stderr = os.Stderr cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true} running[input] = cmd err = cmd.Start() return } ================================================ FILE: cmd/templ/generatecmd/run/run_windows.go ================================================ //go:build windows package run import ( "context" "os" "os/exec" "strconv" "strings" "sync" ) var ( m = &sync.Mutex{} running = map[string]*exec.Cmd{} ) func KillAll() (err error) { m.Lock() defer m.Unlock() for _, cmd := range running { kill := exec.Command("TASKKILL", "/T", "/F", "/PID", strconv.Itoa(cmd.Process.Pid)) kill.Stderr = os.Stderr kill.Stdout = os.Stdout err := kill.Run() if err != nil { return err } } running = map[string]*exec.Cmd{} return } func Stop(cmd *exec.Cmd) (err error) { kill := exec.Command("TASKKILL", "/T", "/F", "/PID", strconv.Itoa(cmd.Process.Pid)) kill.Stderr = os.Stderr kill.Stdout = os.Stdout return kill.Run() } func Run(ctx context.Context, workingDir string, input string) (cmd *exec.Cmd, err error) { m.Lock() defer m.Unlock() cmd, ok := running[input] if ok { kill := exec.Command("TASKKILL", "/T", "/F", "/PID", strconv.Itoa(cmd.Process.Pid)) kill.Stderr = os.Stderr kill.Stdout = os.Stdout err := kill.Run() if err != nil { return cmd, err } delete(running, input) } parts := strings.Fields(input) executable := parts[0] args := []string{} if len(parts) > 1 { args = append(args, parts[1:]...) } cmd = exec.Command(executable, args...) cmd.Env = os.Environ() cmd.Dir = workingDir cmd.Stdin = os.Stdin cmd.Stdout = os.Stdout cmd.Stderr = os.Stderr running[input] = cmd err = cmd.Start() return } ================================================ FILE: cmd/templ/generatecmd/run/testprogram/go.mod.embed ================================================ module testprogram go 1.23 ================================================ FILE: cmd/templ/generatecmd/run/testprogram/main.go ================================================ package main import ( "flag" "fmt" "net/http" "os" "os/signal" "syscall" "time" ) // This is a test program. It is used only to test the behaviour of the run package. // The run package is supposed to be able to run and stop programs. Those programs may start // child processes, which should also be stopped when the parent program is stopped. // For example, running `go run .` will compile an executable and run it. // So, this program does nothing. It just waits for a signal to stop. // In "Well behaved" mode, the program will stop when it receives a signal. // In "Badly behaved" mode, the program will ignore the signal and continue running. // The run package should be able to stop the program in both cases. var badlyBehavedFlag = flag.Bool("badly-behaved", false, "If set, the program will ignore the stop signal and continue running.") func main() { flag.Parse() mode := "Well behaved" if *badlyBehavedFlag { mode = "Badly behaved" } fmt.Printf("%s process %d started.\n", mode, os.Getpid()) // Start a web server on a known port so that we can check that this process is // not running, when it's been started as a child process, and we don't know // its pid. go func() { http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) { _, _ = fmt.Fprintf(w, "%d", os.Getpid()) }) err := http.ListenAndServe("127.0.0.1:7777", nil) if err != nil { fmt.Printf("Error running web server: %v\n", err) } }() sigs := make(chan os.Signal, 1) if !*badlyBehavedFlag { signal.Notify(sigs, os.Interrupt, syscall.SIGTERM) } for { select { case <-sigs: fmt.Printf("Process %d received signal. Stopping.\n", os.Getpid()) return case <-time.After(1 * time.Second): fmt.Printf("Process %d still running...\n", os.Getpid()) } } } ================================================ FILE: cmd/templ/generatecmd/sse/server.go ================================================ package sse import ( _ "embed" "fmt" "net/http" "sync" "sync/atomic" "time" ) func New() *Handler { return &Handler{ m: new(sync.Mutex), requests: map[int64]chan event{}, } } type Handler struct { m *sync.Mutex counter int64 requests map[int64]chan event } type event struct { Type string Data string } // Send an event to all connected clients. func (s *Handler) Send(eventType string, data string) { s.m.Lock() defer s.m.Unlock() for _, f := range s.requests { f := f go func(f chan event) { f <- event{ Type: eventType, Data: data, } }(f) } } func (s *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) { w.Header().Set("Access-Control-Allow-Origin", "*") w.Header().Set("Access-Control-Allow-Headers", "Content-Type") w.Header().Set("Content-Type", "text/event-stream") w.Header().Set("Cache-Control", "no-cache") w.Header().Set("Connection", "keep-alive") id := atomic.AddInt64(&s.counter, 1) s.m.Lock() events := make(chan event) s.requests[id] = events s.m.Unlock() defer func() { s.m.Lock() defer s.m.Unlock() delete(s.requests, id) close(events) }() timer := time.NewTimer(0) loop: for { select { case <-timer.C: if _, err := fmt.Fprintf(w, "event: message\ndata: ping\n\n"); err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } timer.Reset(time.Second * 5) case e := <-events: if _, err := fmt.Fprintf(w, "event: %s\ndata: %s\n\n", e.Type, e.Data); err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } case <-r.Context().Done(): break loop } w.(http.Flusher).Flush() } } ================================================ FILE: cmd/templ/generatecmd/symlink/symlink_test.go ================================================ package symlink import ( "context" "io" "os" "path" "testing" "github.com/a-h/templ/cmd/templ/generatecmd" "github.com/a-h/templ/cmd/templ/testproject" ) func TestSymlink(t *testing.T) { t.Run("can generate if root is symlink", func(t *testing.T) { // templ generate -f templates.templ dir, err := testproject.Create("github.com/a-h/templ/cmd/templ/testproject") if err != nil { t.Fatalf("failed to create test project: %v", err) } defer func() { if err := os.RemoveAll(dir); err != nil { t.Errorf("failed to remove test project directory: %v", err) } }() symlinkPath := dir + "-symlink" err = os.Symlink(dir, symlinkPath) if err != nil { t.Fatalf("failed to create dir symlink: %v", err) } defer func() { if err = os.Remove(symlinkPath); err != nil { t.Errorf("failed to remove symlink directory: %v", err) } }() // Delete the templates_templ.go file to ensure it is generated. err = os.Remove(path.Join(symlinkPath, "templates_templ.go")) if err != nil { t.Fatalf("failed to remove templates_templ.go: %v", err) } // Run the generate command. err = generatecmd.Run(context.Background(), io.Discard, io.Discard, []string{"-path", symlinkPath}) if err != nil { t.Fatalf("failed to run generate command: %v", err) } // Check the templates_templ.go file was created. _, err = os.Stat(path.Join(symlinkPath, "templates_templ.go")) if err != nil { t.Fatalf("templates_templ.go was not created: %v", err) } }) } ================================================ FILE: cmd/templ/generatecmd/test-eventhandler/eventhandler_test.go ================================================ package testeventhandler import ( "context" "errors" "fmt" "go/scanner" "go/token" "io" "log/slog" "os" "testing" "github.com/a-h/templ/cmd/templ/generatecmd" "github.com/a-h/templ/generator" "github.com/fsnotify/fsnotify" "github.com/google/go-cmp/cmp" ) // extractErrorList unwraps errors until it finds a scanner.ErrorList func extractErrorList(err error) (scanner.ErrorList, bool) { if err == nil { return nil, false } if list, ok := err.(scanner.ErrorList); ok { return list, true } return extractErrorList(errors.Unwrap(err)) } func TestErrorLocationMapping(t *testing.T) { tests := []struct { name string rawFileName string errorPositions []token.Position }{ { name: "single error outputs location in srcFile", rawFileName: "single_error.templ.error", errorPositions: []token.Position{ {Offset: 46, Line: 3, Column: 20}, }, }, { name: "multiple errors all output locations in srcFile", rawFileName: "multiple_errors.templ.error", errorPositions: []token.Position{ {Offset: 41, Line: 3, Column: 15}, {Offset: 101, Line: 7, Column: 22}, {Offset: 126, Line: 10, Column: 1}, }, }, } slog := slog.New(slog.NewTextHandler(io.Discard, &slog.HandlerOptions{})) var fw generatecmd.FileWriterFunc fseh := generatecmd.NewFSEventHandler(slog, ".", false, []generator.GenerateOpt{}, false, false, fw, false) for _, test := range tests { t.Run(test.name, func(t *testing.T) { // The raw files cannot end in .templ because they will cause the generator to fail. Instead, // we create a tmp file that ends in .templ only for the duration of the test. rawFile, err := os.Open(test.rawFileName) if err != nil { t.Fatalf("Failed to open file %s: %v", test.rawFileName, err) } defer func() { if err = rawFile.Close(); err != nil { t.Fatalf("Failed to close raw file %s: %v", test.rawFileName, err) } }() file, err := os.CreateTemp("", fmt.Sprintf("*%s.templ", test.rawFileName)) if err != nil { t.Fatalf("Failed to create a tmp file at %s: %v", file.Name(), err) } tempFileName := file.Name() defer func() { _ = file.Close() if err := os.Remove(tempFileName); err != nil { t.Logf("Warning: Failed to remove tmp file %s: %v", tempFileName, err) } }() if _, err = io.Copy(file, rawFile); err != nil { t.Fatalf("Failed to copy contents from raw file %s to tmp %s: %v", test.rawFileName, tempFileName, err) } // Ensure file is synced to disk and file pointer is at the beginning if err = file.Sync(); err != nil { t.Fatalf("Failed to sync file: %v", err) } event := fsnotify.Event{Name: tempFileName, Op: fsnotify.Write} _, err = fseh.HandleEvent(context.Background(), event) if err == nil { t.Fatal("Expected an error but none was thrown") } list, ok := extractErrorList(err) if !ok { t.Fatal("Failed to extract ErrorList from error") } if len(list) != len(test.errorPositions) { t.Fatalf("Expected %d errors but got %d", len(test.errorPositions), len(list)) } for i, err := range list { expected := test.errorPositions[i] expected.Filename = tempFileName if diff := cmp.Diff(expected, err.Pos); diff != "" { t.Errorf("Error position mismatch (-expected +actual):\n%s", diff) } } }) } } ================================================ FILE: cmd/templ/generatecmd/test-eventhandler/multiple_errors.templ.error ================================================ package testeventhandler func invalid(a: string) string { return "foo" } templ multipleError(a: string) { } l ================================================ FILE: cmd/templ/generatecmd/test-eventhandler/single_error.templ.error ================================================ package testeventhandler templ singleError(a: string) { } ================================================ FILE: cmd/templ/generatecmd/testwatch/generate_test.go ================================================ package testwatch import ( "bufio" "bytes" "context" "embed" "errors" "fmt" "io" "net" "net/http" "os" "path/filepath" "strconv" "strings" "testing" "time" "github.com/a-h/templ/cmd/templ/generatecmd" "github.com/a-h/templ/cmd/templ/generatecmd/modcheck" "github.com/a-h/templ/internal/htmlfind" "golang.org/x/net/html" "golang.org/x/sync/errgroup" ) //go:embed testdata/* var testdata embed.FS func createTestProject(moduleRoot string) (dir string, err error) { dir, err = os.MkdirTemp("", "templ_watch_test_*") if err != nil { return dir, fmt.Errorf("failed to make test dir: %w", err) } files, err := testdata.ReadDir("testdata") if err != nil { return dir, fmt.Errorf("failed to read embedded dir: %w", err) } for _, file := range files { src := filepath.Join("testdata", file.Name()) data, err := testdata.ReadFile(src) if err != nil { return dir, fmt.Errorf("failed to read file: %w", err) } target := filepath.Join(dir, file.Name()) if file.Name() == "go.mod.embed" { data = bytes.ReplaceAll(data, []byte("{moduleRoot}"), []byte(moduleRoot)) target = filepath.Join(dir, "go.mod") } err = os.WriteFile(target, data, 0660) if err != nil { return dir, fmt.Errorf("failed to copy file: %w", err) } } return dir, nil } func replaceInFile(name, src, tgt string) error { data, err := os.ReadFile(name) if err != nil { return err } updated := strings.ReplaceAll(string(data), src, tgt) return os.WriteFile(name, []byte(updated), 0660) } func getPort() (port int, err error) { var a *net.TCPAddr a, err = net.ResolveTCPAddr("tcp", "localhost:0") if err != nil { return 0, fmt.Errorf("failed to resolve TCP address: %w", err) } l, err := net.ListenTCP("tcp", a) if err != nil { return 0, fmt.Errorf("failed to listen on TCP: %w", err) } return l.Addr().(*net.TCPAddr).Port, l.Close() } func getHTML(url string) (n *html.Node, err error) { resp, err := http.Get(url) if err != nil { return nil, fmt.Errorf("failed to get %q: %w", url, err) } defer func() { _ = resp.Body.Close() }() return html.Parse(resp.Body) } func TestCanAccessDirect(t *testing.T) { if testing.Short() { return } args, teardown, err := Setup(false) if err != nil { t.Fatalf("failed to setup test: %v", err) } defer teardown(t) // Assert. doc, err := getHTML(args.AppURL) if err != nil { t.Fatalf("failed to read HTML: %v", err) } countElements := htmlfind.All(doc, htmlfind.Element("div", htmlfind.Attr("data-testid", "count"))) if len(countElements) != 1 { t.Fatalf("expected 1 count element, got %d", len(countElements)) } countText := countElements[0].FirstChild.Data actualCount, err := strconv.Atoi(countText) if err != nil { t.Fatalf("got count %q instead of integer", countText) } if actualCount < 1 { t.Errorf("expected count >= 1, got %d", actualCount) } } func TestCanAccessViaProxy(t *testing.T) { if testing.Short() { return } args, teardown, err := Setup(false) if err != nil { t.Fatalf("failed to setup test: %v", err) } defer teardown(t) // Assert. doc, err := getHTML(args.ProxyURL) if err != nil { t.Fatalf("failed to read HTML: %v", err) } countElements := htmlfind.All(doc, htmlfind.Element("div", htmlfind.Attr("data-testid", "count"))) if len(countElements) != 1 { t.Fatalf("expected 1 count element, got %d", len(countElements)) } countText := countElements[0].FirstChild.Data actualCount, err := strconv.Atoi(countText) if err != nil { t.Fatalf("got count %q instead of integer", countText) } if actualCount < 1 { t.Errorf("expected count >= 1, got %d", actualCount) } } type Event struct { Type string Data string } func readSSE(ctx context.Context, url string, sse chan<- Event) (err error) { req, err := http.NewRequestWithContext(ctx, "GET", url, nil) if err != nil { return err } req.Header.Set("Cache-Control", "no-cache") req.Header.Set("Accept", "text/event-stream") req.Header.Set("Connection", "keep-alive") client := &http.Client{} resp, err := client.Do(req) if err != nil { return err } var e Event scanner := bufio.NewScanner(resp.Body) for scanner.Scan() { line := scanner.Text() if line == "" { sse <- e e = Event{} continue } if strings.HasPrefix(line, "event: ") { e.Type = line[len("event: "):] } if strings.HasPrefix(line, "data: ") { e.Data = line[len("data: "):] } } return scanner.Err() } func TestFileModificationsResultInSSEWithGzip(t *testing.T) { if testing.Short() { return } args, teardown, err := Setup(false) if err != nil { t.Fatalf("failed to setup test: %v", err) } defer teardown(t) // Start the SSE check. events := make(chan Event) var eventsErr error go func() { eventsErr = readSSE(context.Background(), fmt.Sprintf("%s/_templ/reload/events", args.ProxyURL), events) }() // Assert data is expected. doc, err := getHTML(args.ProxyURL) if err != nil { t.Fatalf("failed to read HTML: %v", err) } modified := htmlfind.All(doc, htmlfind.Element("div", htmlfind.Attr("data-testid", "modification"))) if len(modified) != 1 { t.Fatalf("expected 1 modification element, got %d", len(modified)) } if text := modified[0].FirstChild.Data; text != "Original" { t.Errorf("expected %q, got %q", "Original", text) } // Change file. templFile := filepath.Join(args.AppDir, "templates.templ") err = replaceInFile(templFile, `| File | ||||
|---|---|---|---|---|
| { uri } | Mapping | Source Map | Templ | Go |
| File | ||||
|---|---|---|---|---|
| ") if templ_7745c5c3_Err != nil { return templ_7745c5c3_Err } var templ_7745c5c3_Var2 string templ_7745c5c3_Var2, templ_7745c5c3_Err = templ.JoinStringErrs(uri) if templ_7745c5c3_Err != nil { return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/templ/lspcmd/httpdebug/list.templ`, Line: 14, Col: 13} } _, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var2)) if templ_7745c5c3_Err != nil { return templ_7745c5c3_Err } templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 3, " | Mapping | Source Map | Templ | Go |