1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
|
# Bug Report: Template Rendering Error in Notes Tab
## Description
The application logs an error when rendering the Notes tab:
`Error rendering notes tab: template: error-banner.html:2:5: executing "error-banner" at <.Errors>: can't evaluate field Errors in type struct { Notes []models.Note }`
This occurs because the `notes-tab` template (which includes `error-banner`) expects a data structure with an `Errors` field, but `HandleNotes` in `internal/handlers/tabs.go` passes an anonymous struct with only `Notes`.
## Reproduction
1. Run the application.
2. Navigate to the Notes tab (or trigger a request to `/tabs/notes`).
3. Observe the error in the server logs.
## Fix Instructions
### 1. Create a Reproduction Test
Create a new test file `internal/handlers/tabs_test.go` to reproduce the issue.
```go
package handlers
import (
"html/template"
"net/http"
"net/http/httptest"
"testing"
"task-dashboard/internal/models"
"task-dashboard/internal/store"
)
func TestHandleNotes_RenderError(t *testing.T) {
// Setup
// Note: You might need to mock the store or use a temporary SQLite DB
// For this specific template error, we can test the template execution directly
// or mock the store to return empty notes.
// Since setting up the full store with DB is complex for a unit test,
// let's focus on the data structure passed to the template.
// However, the handler is coupled to the store.
// A better approach for this specific bug is to verify the fix by ensuring
// the data struct has the Errors field.
}
```
**Better Approach:**
Modify `internal/handlers/tabs.go` to use a consistent data structure that includes `Errors`.
### 2. Modify `internal/handlers/tabs.go`
Update the `HandleNotes` function (and others if necessary) to pass a struct that includes `Errors`.
```go
// Define a shared data structure or use an anonymous one with Errors
data := struct {
Notes []models.Note
Errors []string
}{
Notes: notes,
Errors: nil, // Or populate if there are errors
}
```
### 3. Verify
Run the application and check the logs. The error should disappear.
## Automated Test for Verification
Since we don't have a full test suite set up yet, we can create a simple test that parses the templates and attempts to execute them with the corrected data structure to ensure compatibility.
Create `internal/handlers/template_test.go`:
```go
package handlers_test
import (
"html/template"
"testing"
"task-dashboard/internal/models"
)
func TestNotesTemplateRendering(t *testing.T) {
// Parse templates
tmpl, err := template.ParseGlob("../../web/templates/*.html")
if err != nil {
t.Fatalf("Failed to parse templates: %v", err)
}
tmpl, err = tmpl.ParseGlob("../../web/templates/partials/*.html")
if err != nil {
t.Fatalf("Failed to parse partials: %v", err)
}
// Define the data structure we EXPECT to use
data := struct {
Notes []models.Note
Errors []string
}{
Notes: []models.Note{},
Errors: []string{},
}
// Execute
err = tmpl.ExecuteTemplate(io.Discard, "notes-tab", data)
if err != nil {
t.Errorf("Failed to render notes-tab with corrected data: %v", err)
}
}
```
(Note: You'll need to import `io` and adjust paths).
|
