desertthunder.dev
cli + tui to publish to leaflet (wip) & manage tasks, notes & watch/read lists 🍃
charm
leaflet
readability
golang
feat: generic data list & tables
+2866
+473
internal/ui/data_list.go
+473
internal/ui/data_list.go
···
1
+
package ui
2
+
3
+
import (
4
+
"context"
5
+
"fmt"
6
+
"io"
7
+
"os"
8
+
"strings"
9
+
10
+
"github.com/charmbracelet/bubbles/help"
11
+
"github.com/charmbracelet/bubbles/key"
12
+
tea "github.com/charmbracelet/bubbletea"
13
+
"github.com/charmbracelet/lipgloss"
14
+
"github.com/stormlightlabs/noteleaf/internal/models"
15
+
)
16
+
17
+
// ListItem represents a single item in a list
18
+
type ListItem interface {
19
+
models.Model
20
+
GetTitle() string
21
+
GetDescription() string
22
+
GetFilterValue() string
23
+
}
24
+
25
+
// ListSource provides data for the list
26
+
type ListSource interface {
27
+
Load(ctx context.Context, opts ListOptions) ([]ListItem, error)
28
+
Count(ctx context.Context, opts ListOptions) (int, error)
29
+
Search(ctx context.Context, query string, opts ListOptions) ([]ListItem, error)
30
+
}
31
+
32
+
// ListOptions configures data loading for lists
33
+
type ListOptions struct {
34
+
Filters map[string]any
35
+
SortBy string
36
+
SortOrder string
37
+
Limit int
38
+
Offset int
39
+
Search string
40
+
}
41
+
42
+
// ListAction defines an action that can be performed on a list item
43
+
type ListAction struct {
44
+
Key string
45
+
Description string
46
+
Handler func(item ListItem) tea.Cmd
47
+
}
48
+
49
+
// DataListKeyMap defines key bindings for list navigation
50
+
type DataListKeyMap struct {
51
+
Up key.Binding
52
+
Down key.Binding
53
+
Enter key.Binding
54
+
View key.Binding
55
+
Search key.Binding
56
+
Refresh key.Binding
57
+
Quit key.Binding
58
+
Back key.Binding
59
+
Help key.Binding
60
+
Numbers []key.Binding
61
+
Actions map[string]key.Binding
62
+
}
63
+
64
+
func (k DataListKeyMap) ShortHelp() []key.Binding {
65
+
return []key.Binding{k.Up, k.Down, k.Enter, k.Search, k.Help, k.Quit}
66
+
}
67
+
68
+
func (k DataListKeyMap) FullHelp() [][]key.Binding {
69
+
bindings := [][]key.Binding{
70
+
{k.Up, k.Down, k.Enter, k.View},
71
+
{k.Search, k.Refresh, k.Help, k.Quit, k.Back},
72
+
}
73
+
74
+
if len(k.Actions) > 0 {
75
+
actionBindings := make([]key.Binding, 0, len(k.Actions))
76
+
for _, binding := range k.Actions {
77
+
actionBindings = append(actionBindings, binding)
78
+
}
79
+
bindings = append(bindings, actionBindings)
80
+
}
81
+
82
+
return bindings
83
+
}
84
+
85
+
// DefaultDataListKeys returns the default key bindings for lists
86
+
func DefaultDataListKeys() DataListKeyMap {
87
+
return DataListKeyMap{
88
+
Up: key.NewBinding(key.WithKeys("up", "k"), key.WithHelp("↑/k", "move up")),
89
+
Down: key.NewBinding(key.WithKeys("down", "j"), key.WithHelp("↓/j", "move down")),
90
+
Enter: key.NewBinding(key.WithKeys("enter"), key.WithHelp("enter", "select")),
91
+
View: key.NewBinding(key.WithKeys("v"), key.WithHelp("v", "view")),
92
+
Search: key.NewBinding(key.WithKeys("/"), key.WithHelp("/", "search")),
93
+
Refresh: key.NewBinding(key.WithKeys("r"), key.WithHelp("r", "refresh")),
94
+
Quit: key.NewBinding(key.WithKeys("q", "ctrl+c"), key.WithHelp("q", "quit")),
95
+
Back: key.NewBinding(key.WithKeys("esc", "backspace"), key.WithHelp("esc", "back")),
96
+
Help: key.NewBinding(key.WithKeys("?"), key.WithHelp("?", "help")),
97
+
Numbers: []key.Binding{
98
+
key.NewBinding(key.WithKeys("1"), key.WithHelp("1", "jump to 1")),
99
+
key.NewBinding(key.WithKeys("2"), key.WithHelp("2", "jump to 2")),
100
+
key.NewBinding(key.WithKeys("3"), key.WithHelp("3", "jump to 3")),
101
+
key.NewBinding(key.WithKeys("4"), key.WithHelp("4", "jump to 4")),
102
+
key.NewBinding(key.WithKeys("5"), key.WithHelp("5", "jump to 5")),
103
+
key.NewBinding(key.WithKeys("6"), key.WithHelp("6", "jump to 6")),
104
+
key.NewBinding(key.WithKeys("7"), key.WithHelp("7", "jump to 7")),
105
+
key.NewBinding(key.WithKeys("8"), key.WithHelp("8", "jump to 8")),
106
+
key.NewBinding(key.WithKeys("9"), key.WithHelp("9", "jump to 9")),
107
+
},
108
+
Actions: make(map[string]key.Binding),
109
+
}
110
+
}
111
+
112
+
// DataListOptions configures list behavior
113
+
type DataListOptions struct {
114
+
Output io.Writer
115
+
Input io.Reader
116
+
Static bool
117
+
Title string
118
+
Actions []ListAction
119
+
ViewHandler func(item ListItem) string
120
+
ItemRenderer func(item ListItem, selected bool) string
121
+
ShowSearch bool
122
+
Searchable bool
123
+
}
124
+
125
+
// DataList handles list display and interaction
126
+
type DataList struct {
127
+
source ListSource
128
+
opts DataListOptions
129
+
}
130
+
131
+
// NewDataList creates a new data list
132
+
func NewDataList(source ListSource, opts DataListOptions) *DataList {
133
+
if opts.Output == nil {
134
+
opts.Output = os.Stdout
135
+
}
136
+
if opts.Input == nil {
137
+
opts.Input = os.Stdin
138
+
}
139
+
if opts.Title == "" {
140
+
opts.Title = "Items"
141
+
}
142
+
if opts.ItemRenderer == nil {
143
+
opts.ItemRenderer = defaultItemRenderer
144
+
}
145
+
146
+
return &DataList{
147
+
source: source,
148
+
opts: opts,
149
+
}
150
+
}
151
+
152
+
type (
153
+
listLoadedMsg []ListItem
154
+
listViewMsg string
155
+
listErrorMsg error
156
+
listCountMsg int
157
+
searchModeMsg bool
158
+
)
159
+
160
+
type dataListModel struct {
161
+
items []ListItem
162
+
selected int
163
+
viewing bool
164
+
viewContent string
165
+
searching bool
166
+
searchQuery string
167
+
err error
168
+
loading bool
169
+
source ListSource
170
+
opts DataListOptions
171
+
keys DataListKeyMap
172
+
help help.Model
173
+
showingHelp bool
174
+
totalCount int
175
+
currentPage int
176
+
listOpts ListOptions
177
+
}
178
+
179
+
func (m dataListModel) Init() tea.Cmd {
180
+
return tea.Batch(m.loadItems(), m.loadCount())
181
+
}
182
+
183
+
func (m dataListModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
184
+
switch msg := msg.(type) {
185
+
case tea.KeyMsg:
186
+
if m.showingHelp {
187
+
switch {
188
+
case key.Matches(msg, m.keys.Back) || key.Matches(msg, m.keys.Quit) || key.Matches(msg, m.keys.Help):
189
+
m.showingHelp = false
190
+
return m, nil
191
+
}
192
+
return m, nil
193
+
}
194
+
195
+
if m.viewing {
196
+
switch {
197
+
case key.Matches(msg, m.keys.Back) || key.Matches(msg, m.keys.Quit):
198
+
m.viewing = false
199
+
m.viewContent = ""
200
+
return m, nil
201
+
case key.Matches(msg, m.keys.Help):
202
+
m.showingHelp = true
203
+
return m, nil
204
+
}
205
+
return m, nil
206
+
}
207
+
208
+
if m.searching {
209
+
switch msg.String() {
210
+
case "esc", "enter":
211
+
m.searching = false
212
+
if msg.String() == "enter" && m.opts.Searchable {
213
+
m.loading = true
214
+
return m, m.searchItems(m.searchQuery)
215
+
}
216
+
return m, nil
217
+
case "backspace", "ctrl+h":
218
+
if len(m.searchQuery) > 0 {
219
+
m.searchQuery = m.searchQuery[:len(m.searchQuery)-1]
220
+
}
221
+
return m, nil
222
+
default:
223
+
if len(msg.Runes) > 0 && msg.Runes[0] >= 32 {
224
+
m.searchQuery += string(msg.Runes)
225
+
}
226
+
return m, nil
227
+
}
228
+
}
229
+
230
+
switch {
231
+
case key.Matches(msg, m.keys.Quit):
232
+
return m, tea.Quit
233
+
case key.Matches(msg, m.keys.Up):
234
+
if m.selected > 0 {
235
+
m.selected--
236
+
}
237
+
case key.Matches(msg, m.keys.Down):
238
+
if m.selected < len(m.items)-1 {
239
+
m.selected++
240
+
}
241
+
case key.Matches(msg, m.keys.Enter) || key.Matches(msg, m.keys.View):
242
+
if len(m.items) > 0 && m.selected < len(m.items) && m.opts.ViewHandler != nil {
243
+
return m, m.viewItem(m.items[m.selected])
244
+
}
245
+
case key.Matches(msg, m.keys.Search):
246
+
if m.opts.ShowSearch {
247
+
m.searching = true
248
+
m.searchQuery = ""
249
+
return m, nil
250
+
}
251
+
case key.Matches(msg, m.keys.Refresh):
252
+
m.loading = true
253
+
return m, tea.Batch(m.loadItems(), m.loadCount())
254
+
case key.Matches(msg, m.keys.Help):
255
+
m.showingHelp = true
256
+
return m, nil
257
+
default:
258
+
for i, numKey := range m.keys.Numbers {
259
+
if key.Matches(msg, numKey) && i < len(m.items) {
260
+
m.selected = i
261
+
break
262
+
}
263
+
}
264
+
265
+
for actionKey, binding := range m.keys.Actions {
266
+
if key.Matches(msg, binding) && len(m.items) > 0 && m.selected < len(m.items) {
267
+
for _, action := range m.opts.Actions {
268
+
if action.Key == actionKey {
269
+
return m, action.Handler(m.items[m.selected])
270
+
}
271
+
}
272
+
}
273
+
}
274
+
}
275
+
case listLoadedMsg:
276
+
m.items = []ListItem(msg)
277
+
m.loading = false
278
+
if m.selected >= len(m.items) && len(m.items) > 0 {
279
+
m.selected = len(m.items) - 1
280
+
}
281
+
case listViewMsg:
282
+
m.viewContent = string(msg)
283
+
m.viewing = true
284
+
case listErrorMsg:
285
+
m.err = error(msg)
286
+
m.loading = false
287
+
case listCountMsg:
288
+
m.totalCount = int(msg)
289
+
}
290
+
return m, nil
291
+
}
292
+
293
+
func (m dataListModel) View() string {
294
+
var s strings.Builder
295
+
296
+
style := lipgloss.NewStyle().Foreground(lipgloss.Color(Squid.Hex()))
297
+
298
+
if m.showingHelp {
299
+
return m.help.View(m.keys)
300
+
}
301
+
302
+
if m.viewing {
303
+
s.WriteString(m.viewContent)
304
+
s.WriteString("\n\n")
305
+
s.WriteString(style.Render("Press q/esc/backspace to return to list, ? for help"))
306
+
return s.String()
307
+
}
308
+
309
+
s.WriteString(TitleColorStyle.Render(m.opts.Title))
310
+
if m.totalCount > 0 {
311
+
s.WriteString(fmt.Sprintf(" (%d total)", m.totalCount))
312
+
}
313
+
if m.searchQuery != "" {
314
+
s.WriteString(fmt.Sprintf(" - Search: %s", m.searchQuery))
315
+
}
316
+
s.WriteString("\n\n")
317
+
318
+
if m.searching {
319
+
s.WriteString("Search: " + m.searchQuery + "▎")
320
+
s.WriteString("\n")
321
+
s.WriteString(style.Render("Press Enter to search, Esc to cancel"))
322
+
return s.String()
323
+
}
324
+
325
+
if m.loading {
326
+
s.WriteString("Loading...")
327
+
return s.String()
328
+
}
329
+
330
+
if m.err != nil {
331
+
s.WriteString(fmt.Sprintf("Error: %s", m.err))
332
+
return s.String()
333
+
}
334
+
335
+
if len(m.items) == 0 {
336
+
message := "No items found"
337
+
if m.searchQuery != "" {
338
+
message = "No items found for search: " + m.searchQuery
339
+
}
340
+
s.WriteString(message)
341
+
s.WriteString("\n\n")
342
+
s.WriteString(style.Render("Press r to refresh, q to quit"))
343
+
if m.opts.ShowSearch {
344
+
s.WriteString(style.Render(", / to search"))
345
+
}
346
+
return s.String()
347
+
}
348
+
349
+
for i, item := range m.items {
350
+
selected := i == m.selected
351
+
itemView := m.opts.ItemRenderer(item, selected)
352
+
s.WriteString(itemView)
353
+
s.WriteString("\n")
354
+
}
355
+
356
+
s.WriteString("\n")
357
+
s.WriteString(m.help.View(m.keys))
358
+
359
+
return s.String()
360
+
}
361
+
362
+
func (m dataListModel) loadItems() tea.Cmd {
363
+
return func() tea.Msg {
364
+
items, err := m.source.Load(context.Background(), m.listOpts)
365
+
if err != nil {
366
+
return listErrorMsg(err)
367
+
}
368
+
return listLoadedMsg(items)
369
+
}
370
+
}
371
+
372
+
func (m dataListModel) loadCount() tea.Cmd {
373
+
return func() tea.Msg {
374
+
count, err := m.source.Count(context.Background(), m.listOpts)
375
+
if err != nil {
376
+
return listCountMsg(0)
377
+
}
378
+
return listCountMsg(count)
379
+
}
380
+
}
381
+
382
+
func (m dataListModel) searchItems(query string) tea.Cmd {
383
+
return func() tea.Msg {
384
+
items, err := m.source.Search(context.Background(), query, m.listOpts)
385
+
if err != nil {
386
+
return listErrorMsg(err)
387
+
}
388
+
return listLoadedMsg(items)
389
+
}
390
+
}
391
+
392
+
func (m dataListModel) viewItem(item ListItem) tea.Cmd {
393
+
return func() tea.Msg {
394
+
content := m.opts.ViewHandler(item)
395
+
return listViewMsg(content)
396
+
}
397
+
}
398
+
399
+
// defaultItemRenderer provides a default rendering for list items
400
+
func defaultItemRenderer(item ListItem, selected bool) string {
401
+
prefix := " "
402
+
if selected {
403
+
prefix = "> "
404
+
}
405
+
406
+
title := item.GetTitle()
407
+
description := item.GetDescription()
408
+
409
+
line := fmt.Sprintf("%s%s", prefix, title)
410
+
if description != "" {
411
+
line += fmt.Sprintf(" - %s", description)
412
+
}
413
+
414
+
if selected {
415
+
return SelectedColorStyle.Render(line)
416
+
}
417
+
return line
418
+
}
419
+
420
+
// Browse opens an interactive list interface
421
+
func (dl *DataList) Browse(ctx context.Context) error {
422
+
return dl.BrowseWithOptions(ctx, ListOptions{})
423
+
}
424
+
425
+
// BrowseWithOptions opens an interactive list with custom options
426
+
func (dl *DataList) BrowseWithOptions(ctx context.Context, listOpts ListOptions) error {
427
+
if dl.opts.Static {
428
+
return dl.staticDisplay(ctx, listOpts)
429
+
}
430
+
431
+
keys := DefaultDataListKeys()
432
+
for _, action := range dl.opts.Actions {
433
+
keys.Actions[action.Key] = key.NewBinding(
434
+
key.WithKeys(action.Key),
435
+
key.WithHelp(action.Key, action.Description),
436
+
)
437
+
}
438
+
439
+
model := dataListModel{
440
+
source: dl.source,
441
+
opts: dl.opts,
442
+
keys: keys,
443
+
help: help.New(),
444
+
listOpts: listOpts,
445
+
loading: true,
446
+
}
447
+
448
+
program := tea.NewProgram(model, tea.WithInput(dl.opts.Input), tea.WithOutput(dl.opts.Output))
449
+
_, err := program.Run()
450
+
return err
451
+
}
452
+
453
+
func (dl *DataList) staticDisplay(ctx context.Context, listOpts ListOptions) error {
454
+
items, err := dl.source.Load(ctx, listOpts)
455
+
if err != nil {
456
+
fmt.Fprintf(dl.opts.Output, "Error: %s\n", err)
457
+
return err
458
+
}
459
+
460
+
fmt.Fprintf(dl.opts.Output, "%s\n\n", dl.opts.Title)
461
+
462
+
if len(items) == 0 {
463
+
fmt.Fprintf(dl.opts.Output, "No items found\n")
464
+
return nil
465
+
}
466
+
467
+
for _, item := range items {
468
+
itemView := dl.opts.ItemRenderer(item, false)
469
+
fmt.Fprintf(dl.opts.Output, "%s\n", itemView)
470
+
}
471
+
472
+
return nil
473
+
}
+978
internal/ui/data_list_test.go
+978
internal/ui/data_list_test.go
···
1
+
package ui
2
+
3
+
import (
4
+
"bytes"
5
+
"context"
6
+
"errors"
7
+
"fmt"
8
+
"strings"
9
+
"testing"
10
+
"time"
11
+
12
+
"github.com/charmbracelet/bubbles/help"
13
+
"github.com/charmbracelet/bubbles/key"
14
+
tea "github.com/charmbracelet/bubbletea"
15
+
)
16
+
17
+
type MockListItem struct {
18
+
id int64
19
+
title string
20
+
description string
21
+
filterValue string
22
+
created time.Time
23
+
modified time.Time
24
+
}
25
+
26
+
func (m MockListItem) GetID() int64 {
27
+
return m.id
28
+
}
29
+
30
+
func (m MockListItem) SetID(id int64) {
31
+
m.id = id
32
+
}
33
+
34
+
func (m MockListItem) GetTableName() string {
35
+
return "mock_items"
36
+
}
37
+
38
+
func (m MockListItem) GetCreatedAt() time.Time {
39
+
return m.created
40
+
}
41
+
42
+
func (m MockListItem) SetCreatedAt(t time.Time) {
43
+
m.created = t
44
+
}
45
+
46
+
func (m MockListItem) GetUpdatedAt() time.Time {
47
+
return m.modified
48
+
}
49
+
50
+
func (m MockListItem) SetUpdatedAt(t time.Time) {
51
+
m.modified = t
52
+
}
53
+
54
+
func (m MockListItem) GetTitle() string {
55
+
return m.title
56
+
}
57
+
58
+
func (m MockListItem) GetDescription() string {
59
+
return m.description
60
+
}
61
+
62
+
func (m MockListItem) GetFilterValue() string {
63
+
return m.filterValue
64
+
}
65
+
66
+
func NewMockItem(id int64, title, description, filterValue string) MockListItem {
67
+
now := time.Now()
68
+
return MockListItem{
69
+
id: id,
70
+
title: title,
71
+
description: description,
72
+
filterValue: filterValue,
73
+
created: now,
74
+
modified: now,
75
+
}
76
+
}
77
+
78
+
type MockListSource struct {
79
+
items []ListItem
80
+
loadError error
81
+
countError error
82
+
searchError error
83
+
}
84
+
85
+
func (m *MockListSource) Load(ctx context.Context, opts ListOptions) ([]ListItem, error) {
86
+
if m.loadError != nil {
87
+
return nil, m.loadError
88
+
}
89
+
90
+
filtered := make([]ListItem, 0)
91
+
for _, item := range m.items {
92
+
include := true
93
+
for filterField, filterValue := range opts.Filters {
94
+
if filterField == "title" && item.GetTitle() != filterValue {
95
+
include = false
96
+
break
97
+
}
98
+
}
99
+
if include {
100
+
filtered = append(filtered, item)
101
+
}
102
+
}
103
+
104
+
if opts.Limit > 0 && len(filtered) > opts.Limit {
105
+
filtered = filtered[:opts.Limit]
106
+
}
107
+
108
+
return filtered, nil
109
+
}
110
+
111
+
func (m *MockListSource) Count(ctx context.Context, opts ListOptions) (int, error) {
112
+
if m.countError != nil {
113
+
return 0, m.countError
114
+
}
115
+
116
+
count := 0
117
+
for _, item := range m.items {
118
+
include := true
119
+
for filterField, filterValue := range opts.Filters {
120
+
if filterField == "title" && item.GetTitle() != filterValue {
121
+
include = false
122
+
break
123
+
}
124
+
}
125
+
if include {
126
+
count++
127
+
}
128
+
}
129
+
130
+
return count, nil
131
+
}
132
+
133
+
func (m *MockListSource) Search(ctx context.Context, query string, opts ListOptions) ([]ListItem, error) {
134
+
if m.searchError != nil {
135
+
return nil, m.searchError
136
+
}
137
+
138
+
results := make([]ListItem, 0)
139
+
for _, item := range m.items {
140
+
if strings.Contains(strings.ToLower(item.GetTitle()), strings.ToLower(query)) ||
141
+
strings.Contains(strings.ToLower(item.GetDescription()), strings.ToLower(query)) ||
142
+
strings.Contains(strings.ToLower(item.GetFilterValue()), strings.ToLower(query)) {
143
+
results = append(results, item)
144
+
}
145
+
}
146
+
147
+
return results, nil
148
+
}
149
+
150
+
func createMockItems() []ListItem {
151
+
return []ListItem{
152
+
NewMockItem(1, "First Item", "Description of first item", "item1 tag1"),
153
+
NewMockItem(2, "Second Item", "Description of second item", "item2 tag2"),
154
+
NewMockItem(3, "Third Item", "Description of third item", "item3 tag1"),
155
+
}
156
+
}
157
+
158
+
func TestDataList(t *testing.T) {
159
+
t.Run("Options", func(t *testing.T) {
160
+
t.Run("default options", func(t *testing.T) {
161
+
source := &MockListSource{items: createMockItems()}
162
+
opts := DataListOptions{}
163
+
164
+
list := NewDataList(source, opts)
165
+
if list.opts.Output == nil {
166
+
t.Error("Output should default to os.Stdout")
167
+
}
168
+
if list.opts.Input == nil {
169
+
t.Error("Input should default to os.Stdin")
170
+
}
171
+
if list.opts.Title != "Items" {
172
+
t.Error("Title should default to 'Items'")
173
+
}
174
+
if list.opts.ItemRenderer == nil {
175
+
t.Error("ItemRenderer should have a default")
176
+
}
177
+
})
178
+
179
+
t.Run("custom options", func(t *testing.T) {
180
+
var buf bytes.Buffer
181
+
source := &MockListSource{items: createMockItems()}
182
+
opts := DataListOptions{
183
+
Output: &buf,
184
+
Static: true,
185
+
Title: "Test List",
186
+
ShowSearch: true,
187
+
Searchable: true,
188
+
ViewHandler: func(item ListItem) string {
189
+
return fmt.Sprintf("Viewing: %s", item.GetTitle())
190
+
},
191
+
ItemRenderer: func(item ListItem, selected bool) string {
192
+
prefix := " "
193
+
if selected {
194
+
prefix = "> "
195
+
}
196
+
return fmt.Sprintf("%s%s", prefix, item.GetTitle())
197
+
},
198
+
}
199
+
200
+
list := NewDataList(source, opts)
201
+
if list.opts.Output != &buf {
202
+
t.Error("Custom output not set")
203
+
}
204
+
if !list.opts.Static {
205
+
t.Error("Static mode not set")
206
+
}
207
+
if list.opts.Title != "Test List" {
208
+
t.Error("Custom title not set")
209
+
}
210
+
if !list.opts.ShowSearch {
211
+
t.Error("ShowSearch not set")
212
+
}
213
+
if !list.opts.Searchable {
214
+
t.Error("Searchable not set")
215
+
}
216
+
})
217
+
})
218
+
219
+
t.Run("Static Mode", func(t *testing.T) {
220
+
t.Run("successful static display", func(t *testing.T) {
221
+
var buf bytes.Buffer
222
+
source := &MockListSource{items: createMockItems()}
223
+
224
+
list := NewDataList(source, DataListOptions{
225
+
Output: &buf,
226
+
Static: true,
227
+
Title: "Test List",
228
+
})
229
+
230
+
err := list.Browse(context.Background())
231
+
if err != nil {
232
+
t.Fatalf("Browse failed: %v", err)
233
+
}
234
+
235
+
output := buf.String()
236
+
if !strings.Contains(output, "Test List") {
237
+
t.Error("Title not displayed")
238
+
}
239
+
if !strings.Contains(output, "First Item") {
240
+
t.Error("First item not displayed")
241
+
}
242
+
if !strings.Contains(output, "Second Item") {
243
+
t.Error("Second item not displayed")
244
+
}
245
+
})
246
+
247
+
t.Run("static display with no items", func(t *testing.T) {
248
+
var buf bytes.Buffer
249
+
source := &MockListSource{items: []ListItem{}}
250
+
251
+
list := NewDataList(source, DataListOptions{
252
+
Output: &buf,
253
+
Static: true,
254
+
})
255
+
256
+
err := list.Browse(context.Background())
257
+
if err != nil {
258
+
t.Fatalf("Browse failed: %v", err)
259
+
}
260
+
261
+
output := buf.String()
262
+
if !strings.Contains(output, "No items found") {
263
+
t.Error("No items message not displayed")
264
+
}
265
+
})
266
+
267
+
t.Run("static display with load error", func(t *testing.T) {
268
+
var buf bytes.Buffer
269
+
source := &MockListSource{
270
+
loadError: errors.New("connection failed"),
271
+
}
272
+
273
+
list := NewDataList(source, DataListOptions{
274
+
Output: &buf,
275
+
Static: true,
276
+
})
277
+
278
+
err := list.Browse(context.Background())
279
+
if err == nil {
280
+
t.Fatal("Expected error, got nil")
281
+
}
282
+
283
+
output := buf.String()
284
+
if !strings.Contains(output, "Error: connection failed") {
285
+
t.Error("Error message not displayed")
286
+
}
287
+
})
288
+
289
+
t.Run("static display with filters", func(t *testing.T) {
290
+
var buf bytes.Buffer
291
+
source := &MockListSource{items: createMockItems()}
292
+
293
+
list := NewDataList(source, DataListOptions{
294
+
Output: &buf,
295
+
Static: true,
296
+
})
297
+
298
+
opts := ListOptions{
299
+
Filters: map[string]any{
300
+
"title": "First Item",
301
+
},
302
+
}
303
+
304
+
err := list.BrowseWithOptions(context.Background(), opts)
305
+
if err != nil {
306
+
t.Fatalf("Browse failed: %v", err)
307
+
}
308
+
309
+
output := buf.String()
310
+
if !strings.Contains(output, "First Item") {
311
+
t.Error("Filtered item not displayed")
312
+
}
313
+
if strings.Contains(output, "Second Item") {
314
+
t.Error("Non-matching item should be filtered out")
315
+
}
316
+
})
317
+
})
318
+
319
+
t.Run("Model", func(t *testing.T) {
320
+
t.Run("initial model state", func(t *testing.T) {
321
+
source := &MockListSource{items: createMockItems()}
322
+
keys := DefaultDataListKeys()
323
+
324
+
model := dataListModel{
325
+
source: source,
326
+
opts: DataListOptions{
327
+
Title: "Test",
328
+
},
329
+
keys: keys,
330
+
help: help.New(),
331
+
loading: true,
332
+
}
333
+
334
+
if model.selected != 0 {
335
+
t.Error("Initial selected should be 0")
336
+
}
337
+
if model.viewing {
338
+
t.Error("Initial viewing should be false")
339
+
}
340
+
if model.searching {
341
+
t.Error("Initial searching should be false")
342
+
}
343
+
if !model.loading {
344
+
t.Error("Initial loading should be true")
345
+
}
346
+
})
347
+
348
+
t.Run("load items command", func(t *testing.T) {
349
+
source := &MockListSource{items: createMockItems()}
350
+
351
+
model := dataListModel{
352
+
source: source,
353
+
keys: DefaultDataListKeys(),
354
+
listOpts: ListOptions{},
355
+
}
356
+
357
+
cmd := model.loadItems()
358
+
if cmd == nil {
359
+
t.Fatal("loadItems should return a command")
360
+
}
361
+
362
+
msg := cmd()
363
+
switch msg := msg.(type) {
364
+
case listLoadedMsg:
365
+
items := []ListItem(msg)
366
+
if len(items) != 3 {
367
+
t.Errorf("Expected 3 items, got %d", len(items))
368
+
}
369
+
case listErrorMsg:
370
+
t.Fatalf("Unexpected error: %v", error(msg))
371
+
default:
372
+
t.Fatalf("Unexpected message type: %T", msg)
373
+
}
374
+
})
375
+
376
+
t.Run("load items with error", func(t *testing.T) {
377
+
source := &MockListSource{
378
+
loadError: errors.New("load failed"),
379
+
}
380
+
381
+
model := dataListModel{
382
+
source: source,
383
+
listOpts: ListOptions{},
384
+
}
385
+
386
+
cmd := model.loadItems()
387
+
msg := cmd()
388
+
389
+
switch msg := msg.(type) {
390
+
case listErrorMsg:
391
+
err := error(msg)
392
+
if !strings.Contains(err.Error(), "load failed") {
393
+
t.Errorf("Expected load error, got: %v", err)
394
+
}
395
+
default:
396
+
t.Fatalf("Expected listErrorMsg, got: %T", msg)
397
+
}
398
+
})
399
+
400
+
t.Run("search items command", func(t *testing.T) {
401
+
source := &MockListSource{items: createMockItems()}
402
+
403
+
model := dataListModel{
404
+
source: source,
405
+
listOpts: ListOptions{},
406
+
}
407
+
408
+
cmd := model.searchItems("First")
409
+
if cmd == nil {
410
+
t.Fatal("searchItems should return a command")
411
+
}
412
+
413
+
msg := cmd()
414
+
switch msg := msg.(type) {
415
+
case listLoadedMsg:
416
+
items := []ListItem(msg)
417
+
if len(items) != 1 {
418
+
t.Errorf("Expected 1 search result, got %d", len(items))
419
+
}
420
+
if items[0].GetTitle() != "First Item" {
421
+
t.Error("Search should return matching item")
422
+
}
423
+
case listErrorMsg:
424
+
t.Fatalf("Unexpected error: %v", error(msg))
425
+
default:
426
+
t.Fatalf("Unexpected message type: %T", msg)
427
+
}
428
+
})
429
+
430
+
t.Run("search items with error", func(t *testing.T) {
431
+
source := &MockListSource{
432
+
items: createMockItems(),
433
+
searchError: errors.New("search failed"),
434
+
}
435
+
436
+
model := dataListModel{
437
+
source: source,
438
+
listOpts: ListOptions{},
439
+
}
440
+
441
+
cmd := model.searchItems("test")
442
+
msg := cmd()
443
+
444
+
switch msg := msg.(type) {
445
+
case listErrorMsg:
446
+
err := error(msg)
447
+
if !strings.Contains(err.Error(), "search failed") {
448
+
t.Errorf("Expected search error, got: %v", err)
449
+
}
450
+
default:
451
+
t.Fatalf("Expected listErrorMsg, got: %T", msg)
452
+
}
453
+
})
454
+
455
+
t.Run("view item command", func(t *testing.T) {
456
+
viewHandler := func(item ListItem) string {
457
+
return fmt.Sprintf("Viewing: %s", item.GetTitle())
458
+
}
459
+
460
+
model := dataListModel{
461
+
opts: DataListOptions{
462
+
ViewHandler: viewHandler,
463
+
},
464
+
}
465
+
466
+
item := createMockItems()[0]
467
+
cmd := model.viewItem(item)
468
+
msg := cmd()
469
+
470
+
switch msg := msg.(type) {
471
+
case listViewMsg:
472
+
content := string(msg)
473
+
if !strings.Contains(content, "Viewing: First Item") {
474
+
t.Error("View content not formatted correctly")
475
+
}
476
+
default:
477
+
t.Fatalf("Expected listViewMsg, got: %T", msg)
478
+
}
479
+
})
480
+
})
481
+
482
+
t.Run("Key Handling", func(t *testing.T) {
483
+
source := &MockListSource{items: createMockItems()}
484
+
485
+
t.Run("navigation keys", func(t *testing.T) {
486
+
model := dataListModel{
487
+
source: source,
488
+
items: createMockItems(),
489
+
selected: 1,
490
+
keys: DefaultDataListKeys(),
491
+
opts: DataListOptions{},
492
+
}
493
+
494
+
newModel, _ := model.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("k")})
495
+
if m, ok := newModel.(dataListModel); ok {
496
+
if m.selected != 0 {
497
+
t.Errorf("Up key should move selection to 0, got %d", m.selected)
498
+
}
499
+
}
500
+
501
+
model.selected = 1
502
+
newModel, _ = model.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("j")})
503
+
if m, ok := newModel.(dataListModel); ok {
504
+
if m.selected != 2 {
505
+
t.Errorf("Down key should move selection to 2, got %d", m.selected)
506
+
}
507
+
}
508
+
})
509
+
510
+
t.Run("boundary conditions", func(t *testing.T) {
511
+
model := dataListModel{
512
+
source: source,
513
+
items: createMockItems(),
514
+
selected: 0,
515
+
keys: DefaultDataListKeys(),
516
+
opts: DataListOptions{},
517
+
}
518
+
519
+
newModel, _ := model.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("k")})
520
+
if m, ok := newModel.(dataListModel); ok {
521
+
if m.selected != 0 {
522
+
t.Error("Up key at top should not change selection")
523
+
}
524
+
}
525
+
526
+
model.selected = 2
527
+
newModel, _ = model.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("j")})
528
+
if m, ok := newModel.(dataListModel); ok {
529
+
if m.selected != 2 {
530
+
t.Error("Down key at bottom should not change selection")
531
+
}
532
+
}
533
+
})
534
+
535
+
t.Run("search key", func(t *testing.T) {
536
+
model := dataListModel{
537
+
source: source,
538
+
keys: DefaultDataListKeys(),
539
+
opts: DataListOptions{
540
+
ShowSearch: true,
541
+
},
542
+
}
543
+
544
+
newModel, _ := model.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("/")})
545
+
if m, ok := newModel.(dataListModel); ok {
546
+
if !m.searching {
547
+
t.Error("Search key should enable search mode")
548
+
}
549
+
if m.searchQuery != "" {
550
+
t.Error("Search query should be empty initially")
551
+
}
552
+
}
553
+
})
554
+
555
+
t.Run("search mode input", func(t *testing.T) {
556
+
model := dataListModel{
557
+
source: source,
558
+
keys: DefaultDataListKeys(),
559
+
searching: true,
560
+
opts: DataListOptions{
561
+
Searchable: true,
562
+
},
563
+
}
564
+
565
+
newModel, _ := model.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("a")})
566
+
if m, ok := newModel.(dataListModel); ok {
567
+
if m.searchQuery != "a" {
568
+
t.Errorf("Expected search query 'a', got '%s'", m.searchQuery)
569
+
}
570
+
}
571
+
572
+
model.searchQuery = "ab"
573
+
newModel, _ = model.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("backspace")})
574
+
if m, ok := newModel.(dataListModel); ok {
575
+
if m.searchQuery != "a" {
576
+
t.Errorf("Backspace should remove last character, got '%s'", m.searchQuery)
577
+
}
578
+
}
579
+
580
+
newModel, _ = model.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("esc")})
581
+
if m, ok := newModel.(dataListModel); ok {
582
+
if m.searching {
583
+
t.Error("Escape should exit search mode")
584
+
}
585
+
}
586
+
})
587
+
588
+
t.Run("view key with handler", func(t *testing.T) {
589
+
viewHandler := func(item ListItem) string {
590
+
return "test view"
591
+
}
592
+
593
+
model := dataListModel{
594
+
source: source,
595
+
items: createMockItems(),
596
+
keys: DefaultDataListKeys(),
597
+
opts: DataListOptions{
598
+
ViewHandler: viewHandler,
599
+
},
600
+
}
601
+
602
+
_, cmd := model.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("v")})
603
+
if cmd == nil {
604
+
t.Error("View key should return command when handler is set")
605
+
}
606
+
})
607
+
608
+
t.Run("refresh key", func(t *testing.T) {
609
+
model := dataListModel{
610
+
source: source,
611
+
keys: DefaultDataListKeys(),
612
+
opts: DataListOptions{},
613
+
}
614
+
615
+
newModel, cmd := model.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("r")})
616
+
if cmd == nil {
617
+
t.Error("Refresh key should return command")
618
+
}
619
+
if m, ok := newModel.(dataListModel); ok {
620
+
if !m.loading {
621
+
t.Error("Refresh should set loading to true")
622
+
}
623
+
}
624
+
})
625
+
626
+
t.Run("help mode", func(t *testing.T) {
627
+
model := dataListModel{
628
+
keys: DefaultDataListKeys(),
629
+
showingHelp: true,
630
+
opts: DataListOptions{},
631
+
}
632
+
633
+
newModel, _ := model.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("j")})
634
+
if m, ok := newModel.(dataListModel); ok {
635
+
if m.selected != 0 {
636
+
t.Error("Navigation should be ignored in help mode")
637
+
}
638
+
}
639
+
640
+
newModel, _ = model.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("?")})
641
+
if m, ok := newModel.(dataListModel); ok {
642
+
if m.showingHelp {
643
+
t.Error("Help key should exit help mode")
644
+
}
645
+
}
646
+
})
647
+
648
+
t.Run("viewing mode", func(t *testing.T) {
649
+
model := dataListModel{
650
+
keys: DefaultDataListKeys(),
651
+
viewing: true,
652
+
viewContent: "test content",
653
+
opts: DataListOptions{},
654
+
}
655
+
656
+
newModel, _ := model.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("q")})
657
+
if m, ok := newModel.(dataListModel); ok {
658
+
if m.viewing {
659
+
t.Error("Quit should exit viewing mode")
660
+
}
661
+
if m.viewContent != "" {
662
+
t.Error("Quit should clear view content")
663
+
}
664
+
}
665
+
})
666
+
})
667
+
668
+
t.Run("View", func(t *testing.T) {
669
+
source := &MockListSource{items: createMockItems()}
670
+
671
+
t.Run("normal view", func(t *testing.T) {
672
+
model := dataListModel{
673
+
source: source,
674
+
items: createMockItems(),
675
+
keys: DefaultDataListKeys(),
676
+
help: help.New(),
677
+
opts: DataListOptions{
678
+
Title: "Test List",
679
+
ItemRenderer: defaultItemRenderer,
680
+
},
681
+
}
682
+
683
+
view := model.View()
684
+
if !strings.Contains(view, "Test List") {
685
+
t.Error("Title not displayed")
686
+
}
687
+
if !strings.Contains(view, "First Item") {
688
+
t.Error("Item data not displayed")
689
+
}
690
+
if !strings.Contains(view, "> ") {
691
+
t.Error("Selection indicator not displayed")
692
+
}
693
+
})
694
+
695
+
t.Run("loading view", func(t *testing.T) {
696
+
model := dataListModel{
697
+
loading: true,
698
+
opts: DataListOptions{Title: "Test"},
699
+
}
700
+
701
+
view := model.View()
702
+
if !strings.Contains(view, "Loading...") {
703
+
t.Error("Loading message not displayed")
704
+
}
705
+
})
706
+
707
+
t.Run("error view", func(t *testing.T) {
708
+
model := dataListModel{
709
+
err: errors.New("test error"),
710
+
opts: DataListOptions{Title: "Test"},
711
+
}
712
+
713
+
view := model.View()
714
+
if !strings.Contains(view, "Error: test error") {
715
+
t.Error("Error message not displayed")
716
+
}
717
+
})
718
+
719
+
t.Run("empty items view", func(t *testing.T) {
720
+
model := dataListModel{
721
+
items: []ListItem{},
722
+
opts: DataListOptions{Title: "Test"},
723
+
}
724
+
725
+
view := model.View()
726
+
if !strings.Contains(view, "No items found") {
727
+
t.Error("Empty message not displayed")
728
+
}
729
+
})
730
+
731
+
t.Run("search mode view", func(t *testing.T) {
732
+
model := dataListModel{
733
+
searching: true,
734
+
searchQuery: "test",
735
+
opts: DataListOptions{Title: "Test"},
736
+
}
737
+
738
+
view := model.View()
739
+
if !strings.Contains(view, "Search: test") {
740
+
t.Error("Search query not displayed")
741
+
}
742
+
if !strings.Contains(view, "Press Enter to search") {
743
+
t.Error("Search instructions not displayed")
744
+
}
745
+
})
746
+
747
+
t.Run("viewing mode", func(t *testing.T) {
748
+
model := dataListModel{
749
+
viewing: true,
750
+
viewContent: "# Test Content\nDetails here",
751
+
opts: DataListOptions{},
752
+
}
753
+
754
+
view := model.View()
755
+
if !strings.Contains(view, "# Test Content") {
756
+
t.Error("View content not displayed")
757
+
}
758
+
if !strings.Contains(view, "Press q/esc/backspace to return") {
759
+
t.Error("Return instructions not displayed")
760
+
}
761
+
})
762
+
763
+
t.Run("search in title", func(t *testing.T) {
764
+
model := dataListModel{
765
+
items: createMockItems(),
766
+
searchQuery: "First",
767
+
keys: DefaultDataListKeys(),
768
+
help: help.New(),
769
+
opts: DataListOptions{
770
+
Title: "Test",
771
+
ItemRenderer: defaultItemRenderer,
772
+
},
773
+
}
774
+
775
+
view := model.View()
776
+
if !strings.Contains(view, "Search: First") {
777
+
t.Error("Search query should be displayed in title")
778
+
}
779
+
})
780
+
781
+
t.Run("custom item renderer", func(t *testing.T) {
782
+
customRenderer := func(item ListItem, selected bool) string {
783
+
if selected {
784
+
return fmt.Sprintf("*** %s ***", item.GetTitle())
785
+
}
786
+
return fmt.Sprintf(" %s", item.GetTitle())
787
+
}
788
+
789
+
model := dataListModel{
790
+
items: createMockItems(),
791
+
keys: DefaultDataListKeys(),
792
+
help: help.New(),
793
+
opts: DataListOptions{
794
+
ItemRenderer: customRenderer,
795
+
},
796
+
}
797
+
798
+
view := model.View()
799
+
if !strings.Contains(view, "*** First Item ***") {
800
+
t.Error("Custom renderer not applied for selected item")
801
+
}
802
+
})
803
+
})
804
+
805
+
t.Run("Update", func(t *testing.T) {
806
+
source := &MockListSource{items: createMockItems()}
807
+
808
+
t.Run("list loaded message", func(t *testing.T) {
809
+
model := dataListModel{
810
+
source: source,
811
+
loading: true,
812
+
opts: DataListOptions{},
813
+
}
814
+
815
+
items := createMockItems()[:2]
816
+
newModel, _ := model.Update(listLoadedMsg(items))
817
+
818
+
if m, ok := newModel.(dataListModel); ok {
819
+
if len(m.items) != 2 {
820
+
t.Errorf("Expected 2 items, got %d", len(m.items))
821
+
}
822
+
if m.loading {
823
+
t.Error("Loading should be set to false")
824
+
}
825
+
}
826
+
})
827
+
828
+
t.Run("selected index adjustment", func(t *testing.T) {
829
+
model := dataListModel{
830
+
selected: 5,
831
+
opts: DataListOptions{},
832
+
}
833
+
834
+
items := createMockItems()[:2]
835
+
newModel, _ := model.Update(listLoadedMsg(items))
836
+
837
+
if m, ok := newModel.(dataListModel); ok {
838
+
if m.selected != 1 {
839
+
t.Errorf("Selected should be adjusted to 1, got %d", m.selected)
840
+
}
841
+
}
842
+
})
843
+
844
+
t.Run("list view message", func(t *testing.T) {
845
+
model := dataListModel{
846
+
opts: DataListOptions{},
847
+
}
848
+
849
+
content := "Test view content"
850
+
newModel, _ := model.Update(listViewMsg(content))
851
+
852
+
if m, ok := newModel.(dataListModel); ok {
853
+
if !m.viewing {
854
+
t.Error("Viewing mode should be activated")
855
+
}
856
+
if m.viewContent != content {
857
+
t.Error("View content not set correctly")
858
+
}
859
+
}
860
+
})
861
+
862
+
t.Run("list error message", func(t *testing.T) {
863
+
model := dataListModel{
864
+
loading: true,
865
+
opts: DataListOptions{},
866
+
}
867
+
868
+
testErr := errors.New("test error")
869
+
newModel, _ := model.Update(listErrorMsg(testErr))
870
+
871
+
if m, ok := newModel.(dataListModel); ok {
872
+
if m.err == nil {
873
+
t.Error("Error should be set")
874
+
}
875
+
if m.err.Error() != "test error" {
876
+
t.Errorf("Expected 'test error', got %v", m.err)
877
+
}
878
+
if m.loading {
879
+
t.Error("Loading should be set to false on error")
880
+
}
881
+
}
882
+
})
883
+
884
+
t.Run("list count message", func(t *testing.T) {
885
+
model := dataListModel{
886
+
opts: DataListOptions{},
887
+
}
888
+
889
+
count := 42
890
+
newModel, _ := model.Update(listCountMsg(count))
891
+
892
+
if m, ok := newModel.(dataListModel); ok {
893
+
if m.totalCount != count {
894
+
t.Errorf("Expected count %d, got %d", count, m.totalCount)
895
+
}
896
+
}
897
+
})
898
+
})
899
+
900
+
t.Run("Default Keys", func(t *testing.T) {
901
+
keys := DefaultDataListKeys()
902
+
903
+
if len(keys.Numbers) != 9 {
904
+
t.Errorf("Expected 9 number bindings, got %d", len(keys.Numbers))
905
+
}
906
+
907
+
if keys.Actions == nil {
908
+
t.Error("Actions map should be initialized")
909
+
}
910
+
})
911
+
912
+
t.Run("Actions", func(t *testing.T) {
913
+
t.Run("action key handling", func(t *testing.T) {
914
+
actionCalled := false
915
+
action := ListAction{
916
+
Key: "d",
917
+
Description: "delete",
918
+
Handler: func(item ListItem) tea.Cmd {
919
+
actionCalled = true
920
+
return nil
921
+
},
922
+
}
923
+
924
+
keys := DefaultDataListKeys()
925
+
keys.Actions["d"] = key.NewBinding(key.WithKeys("d"), key.WithHelp("d", "delete"))
926
+
927
+
model := dataListModel{
928
+
source: &MockListSource{items: createMockItems()},
929
+
items: createMockItems(),
930
+
keys: keys,
931
+
opts: DataListOptions{
932
+
Actions: []ListAction{action},
933
+
},
934
+
}
935
+
936
+
_, cmd := model.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("d")})
937
+
if cmd != nil {
938
+
cmd()
939
+
}
940
+
941
+
if !actionCalled {
942
+
t.Error("Action handler should be called")
943
+
}
944
+
})
945
+
})
946
+
947
+
t.Run("Default Item Renderer", func(t *testing.T) {
948
+
item := createMockItems()[0]
949
+
950
+
t.Run("unselected item", func(t *testing.T) {
951
+
result := defaultItemRenderer(item, false)
952
+
if !strings.HasPrefix(result, " ") {
953
+
t.Error("Unselected item should have ' ' prefix")
954
+
}
955
+
if !strings.Contains(result, "First Item") {
956
+
t.Error("Item title should be displayed")
957
+
}
958
+
if !strings.Contains(result, "Description of first item") {
959
+
t.Error("Item description should be displayed")
960
+
}
961
+
})
962
+
963
+
t.Run("selected item", func(t *testing.T) {
964
+
result := defaultItemRenderer(item, true)
965
+
if !strings.HasPrefix(result, "> ") {
966
+
t.Error("Selected item should have '> ' prefix")
967
+
}
968
+
})
969
+
970
+
t.Run("item without description", func(t *testing.T) {
971
+
itemWithoutDesc := NewMockItem(1, "Test", "", "filter")
972
+
result := defaultItemRenderer(itemWithoutDesc, false)
973
+
if strings.Contains(result, " - ") {
974
+
t.Error("Item without description should not have separator")
975
+
}
976
+
})
977
+
})
978
+
}
+461
internal/ui/data_table.go
+461
internal/ui/data_table.go
···
1
+
package ui
2
+
3
+
import (
4
+
"context"
5
+
"fmt"
6
+
"io"
7
+
"os"
8
+
"strings"
9
+
10
+
"github.com/charmbracelet/bubbles/help"
11
+
"github.com/charmbracelet/bubbles/key"
12
+
tea "github.com/charmbracelet/bubbletea"
13
+
"github.com/charmbracelet/lipgloss"
14
+
"github.com/stormlightlabs/noteleaf/internal/models"
15
+
)
16
+
17
+
// DataRecord represents a single row of data in a table
18
+
type DataRecord interface {
19
+
models.Model
20
+
GetField(name string) any
21
+
}
22
+
23
+
// DataSource provides data for the table
24
+
type DataSource interface {
25
+
Load(ctx context.Context, opts DataOptions) ([]DataRecord, error)
26
+
Count(ctx context.Context, opts DataOptions) (int, error)
27
+
}
28
+
29
+
// Field defines a column in the table
30
+
type Field struct {
31
+
Name string
32
+
Title string
33
+
Width int
34
+
Formatter func(value any) string
35
+
}
36
+
37
+
// DataOptions configures data loading
38
+
type DataOptions struct {
39
+
Filters map[string]any
40
+
SortBy string
41
+
SortOrder string
42
+
Limit int
43
+
Offset int
44
+
}
45
+
46
+
// Action defines an action that can be performed on a record
47
+
type Action struct {
48
+
Key string
49
+
Description string
50
+
Handler func(record DataRecord) tea.Cmd
51
+
}
52
+
53
+
// DataTableKeyMap defines key bindings for table navigation
54
+
type DataTableKeyMap struct {
55
+
Up key.Binding
56
+
Down key.Binding
57
+
Enter key.Binding
58
+
View key.Binding
59
+
Refresh key.Binding
60
+
Quit key.Binding
61
+
Back key.Binding
62
+
Help key.Binding
63
+
Numbers []key.Binding
64
+
Actions map[string]key.Binding
65
+
}
66
+
67
+
func (k DataTableKeyMap) ShortHelp() []key.Binding {
68
+
return []key.Binding{k.Up, k.Down, k.Enter, k.Help, k.Quit}
69
+
}
70
+
71
+
func (k DataTableKeyMap) FullHelp() [][]key.Binding {
72
+
bindings := [][]key.Binding{
73
+
{k.Up, k.Down, k.Enter, k.View},
74
+
{k.Refresh, k.Help, k.Quit, k.Back},
75
+
}
76
+
77
+
if len(k.Actions) > 0 {
78
+
actionBindings := make([]key.Binding, 0, len(k.Actions))
79
+
for _, binding := range k.Actions {
80
+
actionBindings = append(actionBindings, binding)
81
+
}
82
+
bindings = append(bindings, actionBindings)
83
+
}
84
+
85
+
return bindings
86
+
}
87
+
88
+
// DefaultDataTableKeys returns the default key bindings
89
+
func DefaultDataTableKeys() DataTableKeyMap {
90
+
return DataTableKeyMap{
91
+
Up: key.NewBinding(key.WithKeys("up", "k"), key.WithHelp("↑/k", "move up")),
92
+
Down: key.NewBinding(key.WithKeys("down", "j"), key.WithHelp("↓/j", "move down")),
93
+
Enter: key.NewBinding(key.WithKeys("enter"), key.WithHelp("enter", "select")),
94
+
View: key.NewBinding(key.WithKeys("v"), key.WithHelp("v", "view")),
95
+
Refresh: key.NewBinding(key.WithKeys("r"), key.WithHelp("r", "refresh")),
96
+
Quit: key.NewBinding(key.WithKeys("q", "ctrl+c"), key.WithHelp("q", "quit")),
97
+
Back: key.NewBinding(key.WithKeys("esc", "backspace"), key.WithHelp("esc", "back")),
98
+
Help: key.NewBinding(key.WithKeys("?"), key.WithHelp("?", "help")),
99
+
Numbers: []key.Binding{
100
+
key.NewBinding(key.WithKeys("1"), key.WithHelp("1", "jump to 1")),
101
+
key.NewBinding(key.WithKeys("2"), key.WithHelp("2", "jump to 2")),
102
+
key.NewBinding(key.WithKeys("3"), key.WithHelp("3", "jump to 3")),
103
+
key.NewBinding(key.WithKeys("4"), key.WithHelp("4", "jump to 4")),
104
+
key.NewBinding(key.WithKeys("5"), key.WithHelp("5", "jump to 5")),
105
+
key.NewBinding(key.WithKeys("6"), key.WithHelp("6", "jump to 6")),
106
+
key.NewBinding(key.WithKeys("7"), key.WithHelp("7", "jump to 7")),
107
+
key.NewBinding(key.WithKeys("8"), key.WithHelp("8", "jump to 8")),
108
+
key.NewBinding(key.WithKeys("9"), key.WithHelp("9", "jump to 9")),
109
+
},
110
+
Actions: make(map[string]key.Binding),
111
+
}
112
+
}
113
+
114
+
// DataTableOptions configures table behavior
115
+
type DataTableOptions struct {
116
+
Output io.Writer
117
+
Input io.Reader
118
+
Static bool
119
+
Title string
120
+
Fields []Field
121
+
Actions []Action
122
+
ViewHandler func(record DataRecord) string
123
+
}
124
+
125
+
// DataTable handles table display and interaction
126
+
type DataTable struct {
127
+
source DataSource
128
+
opts DataTableOptions
129
+
}
130
+
131
+
// NewDataTable creates a new data table
132
+
func NewDataTable(source DataSource, opts DataTableOptions) *DataTable {
133
+
if opts.Output == nil {
134
+
opts.Output = os.Stdout
135
+
}
136
+
if opts.Input == nil {
137
+
opts.Input = os.Stdin
138
+
}
139
+
if opts.Title == "" {
140
+
opts.Title = "Data"
141
+
}
142
+
143
+
return &DataTable{
144
+
source: source,
145
+
opts: opts,
146
+
}
147
+
}
148
+
149
+
type (
150
+
dataLoadedMsg []DataRecord
151
+
dataViewMsg string
152
+
dataErrorMsg error
153
+
dataCountMsg int
154
+
)
155
+
156
+
type dataTableModel struct {
157
+
records []DataRecord
158
+
selected int
159
+
viewing bool
160
+
viewContent string
161
+
err error
162
+
loading bool
163
+
source DataSource
164
+
opts DataTableOptions
165
+
keys DataTableKeyMap
166
+
help help.Model
167
+
showingHelp bool
168
+
totalCount int
169
+
currentPage int
170
+
dataOpts DataOptions
171
+
}
172
+
173
+
func (m dataTableModel) Init() tea.Cmd {
174
+
return tea.Batch(m.loadData(), m.loadCount())
175
+
}
176
+
177
+
func (m dataTableModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
178
+
switch msg := msg.(type) {
179
+
case tea.KeyMsg:
180
+
if m.showingHelp {
181
+
switch {
182
+
case key.Matches(msg, m.keys.Back) || key.Matches(msg, m.keys.Quit) || key.Matches(msg, m.keys.Help):
183
+
m.showingHelp = false
184
+
return m, nil
185
+
}
186
+
return m, nil
187
+
}
188
+
189
+
if m.viewing {
190
+
switch {
191
+
case key.Matches(msg, m.keys.Back) || key.Matches(msg, m.keys.Quit):
192
+
m.viewing = false
193
+
m.viewContent = ""
194
+
return m, nil
195
+
case key.Matches(msg, m.keys.Help):
196
+
m.showingHelp = true
197
+
return m, nil
198
+
}
199
+
return m, nil
200
+
}
201
+
202
+
switch {
203
+
case key.Matches(msg, m.keys.Quit):
204
+
return m, tea.Quit
205
+
case key.Matches(msg, m.keys.Up):
206
+
if m.selected > 0 {
207
+
m.selected--
208
+
}
209
+
case key.Matches(msg, m.keys.Down):
210
+
if m.selected < len(m.records)-1 {
211
+
m.selected++
212
+
}
213
+
case key.Matches(msg, m.keys.Enter) || key.Matches(msg, m.keys.View):
214
+
if len(m.records) > 0 && m.selected < len(m.records) && m.opts.ViewHandler != nil {
215
+
return m, m.viewRecord(m.records[m.selected])
216
+
}
217
+
case key.Matches(msg, m.keys.Refresh):
218
+
m.loading = true
219
+
return m, tea.Batch(m.loadData(), m.loadCount())
220
+
case key.Matches(msg, m.keys.Help):
221
+
m.showingHelp = true
222
+
return m, nil
223
+
default:
224
+
for i, numKey := range m.keys.Numbers {
225
+
if key.Matches(msg, numKey) && i < len(m.records) {
226
+
m.selected = i
227
+
break
228
+
}
229
+
}
230
+
231
+
for actionKey, binding := range m.keys.Actions {
232
+
if key.Matches(msg, binding) && len(m.records) > 0 && m.selected < len(m.records) {
233
+
for _, action := range m.opts.Actions {
234
+
if action.Key == actionKey {
235
+
return m, action.Handler(m.records[m.selected])
236
+
}
237
+
}
238
+
}
239
+
}
240
+
}
241
+
case dataLoadedMsg:
242
+
m.records = []DataRecord(msg)
243
+
m.loading = false
244
+
if m.selected >= len(m.records) && len(m.records) > 0 {
245
+
m.selected = len(m.records) - 1
246
+
}
247
+
case dataViewMsg:
248
+
m.viewContent = string(msg)
249
+
m.viewing = true
250
+
case dataErrorMsg:
251
+
m.err = error(msg)
252
+
m.loading = false
253
+
case dataCountMsg:
254
+
m.totalCount = int(msg)
255
+
}
256
+
return m, nil
257
+
}
258
+
259
+
func (m dataTableModel) View() string {
260
+
var s strings.Builder
261
+
262
+
style := lipgloss.NewStyle().Foreground(lipgloss.Color(Squid.Hex()))
263
+
264
+
if m.showingHelp {
265
+
return m.help.View(m.keys)
266
+
}
267
+
268
+
if m.viewing {
269
+
s.WriteString(m.viewContent)
270
+
s.WriteString("\n\n")
271
+
s.WriteString(style.Render("Press q/esc/backspace to return to list, ? for help"))
272
+
return s.String()
273
+
}
274
+
275
+
s.WriteString(TitleColorStyle.Render(m.opts.Title))
276
+
if m.totalCount > 0 {
277
+
s.WriteString(fmt.Sprintf(" (%d total)", m.totalCount))
278
+
}
279
+
s.WriteString("\n\n")
280
+
281
+
if m.loading {
282
+
s.WriteString("Loading...")
283
+
return s.String()
284
+
}
285
+
286
+
if m.err != nil {
287
+
s.WriteString(fmt.Sprintf("Error: %s", m.err))
288
+
return s.String()
289
+
}
290
+
291
+
if len(m.records) == 0 {
292
+
s.WriteString("No records found")
293
+
s.WriteString("\n\n")
294
+
s.WriteString(style.Render("Press r to refresh, q to quit"))
295
+
return s.String()
296
+
}
297
+
298
+
headerParts := make([]string, len(m.opts.Fields))
299
+
for i, field := range m.opts.Fields {
300
+
format := fmt.Sprintf("%%-%ds", field.Width)
301
+
headerParts[i] = fmt.Sprintf(format, field.Title)
302
+
}
303
+
headerLine := fmt.Sprintf(" %s", strings.Join(headerParts, " "))
304
+
s.WriteString(HeaderColorStyle.Render(headerLine))
305
+
s.WriteString("\n")
306
+
307
+
totalWidth := 3 + len(strings.Join(headerParts, " "))
308
+
s.WriteString(HeaderColorStyle.Render(strings.Repeat("─", totalWidth)))
309
+
s.WriteString("\n")
310
+
311
+
for i, record := range m.records {
312
+
prefix := " "
313
+
if i == m.selected {
314
+
prefix = " > "
315
+
}
316
+
317
+
rowParts := make([]string, len(m.opts.Fields))
318
+
for j, field := range m.opts.Fields {
319
+
value := record.GetField(field.Name)
320
+
321
+
var displayValue string
322
+
if field.Formatter != nil {
323
+
displayValue = field.Formatter(value)
324
+
} else {
325
+
displayValue = fmt.Sprintf("%v", value)
326
+
}
327
+
328
+
if len(displayValue) > field.Width-1 {
329
+
displayValue = displayValue[:field.Width-4] + "..."
330
+
}
331
+
332
+
format := fmt.Sprintf("%%-%ds", field.Width)
333
+
rowParts[j] = fmt.Sprintf(format, displayValue)
334
+
}
335
+
336
+
line := fmt.Sprintf("%s%s", prefix, strings.Join(rowParts, " "))
337
+
338
+
if i == m.selected {
339
+
s.WriteString(SelectedColorStyle.Render(line))
340
+
} else {
341
+
s.WriteString(style.Render(line))
342
+
}
343
+
344
+
s.WriteString("\n")
345
+
}
346
+
347
+
s.WriteString("\n")
348
+
s.WriteString(m.help.View(m.keys))
349
+
350
+
return s.String()
351
+
}
352
+
353
+
func (m dataTableModel) loadData() tea.Cmd {
354
+
return func() tea.Msg {
355
+
records, err := m.source.Load(context.Background(), m.dataOpts)
356
+
if err != nil {
357
+
return dataErrorMsg(err)
358
+
}
359
+
return dataLoadedMsg(records)
360
+
}
361
+
}
362
+
363
+
func (m dataTableModel) loadCount() tea.Cmd {
364
+
return func() tea.Msg {
365
+
count, err := m.source.Count(context.Background(), m.dataOpts)
366
+
if err != nil {
367
+
return dataCountMsg(0)
368
+
}
369
+
return dataCountMsg(count)
370
+
}
371
+
}
372
+
373
+
func (m dataTableModel) viewRecord(record DataRecord) tea.Cmd {
374
+
return func() tea.Msg {
375
+
content := m.opts.ViewHandler(record)
376
+
return dataViewMsg(content)
377
+
}
378
+
}
379
+
380
+
// Browse opens an interactive table interface
381
+
func (dt *DataTable) Browse(ctx context.Context) error {
382
+
return dt.BrowseWithOptions(ctx, DataOptions{})
383
+
}
384
+
385
+
// BrowseWithOptions opens an interactive table with custom data options
386
+
func (dt *DataTable) BrowseWithOptions(ctx context.Context, dataOpts DataOptions) error {
387
+
if dt.opts.Static {
388
+
return dt.staticDisplay(ctx, dataOpts)
389
+
}
390
+
391
+
keys := DefaultDataTableKeys()
392
+
for _, action := range dt.opts.Actions {
393
+
keys.Actions[action.Key] = key.NewBinding(
394
+
key.WithKeys(action.Key),
395
+
key.WithHelp(action.Key, action.Description),
396
+
)
397
+
}
398
+
399
+
model := dataTableModel{
400
+
source: dt.source,
401
+
opts: dt.opts,
402
+
keys: keys,
403
+
help: help.New(),
404
+
dataOpts: dataOpts,
405
+
loading: true,
406
+
}
407
+
408
+
program := tea.NewProgram(model, tea.WithInput(dt.opts.Input), tea.WithOutput(dt.opts.Output))
409
+
_, err := program.Run()
410
+
return err
411
+
}
412
+
413
+
func (dt *DataTable) staticDisplay(ctx context.Context, dataOpts DataOptions) error {
414
+
records, err := dt.source.Load(ctx, dataOpts)
415
+
if err != nil {
416
+
fmt.Fprintf(dt.opts.Output, "Error: %s\n", err)
417
+
return err
418
+
}
419
+
420
+
fmt.Fprintf(dt.opts.Output, "%s\n\n", dt.opts.Title)
421
+
422
+
if len(records) == 0 {
423
+
fmt.Fprintf(dt.opts.Output, "No records found\n")
424
+
return nil
425
+
}
426
+
427
+
headerParts := make([]string, len(dt.opts.Fields))
428
+
for i, field := range dt.opts.Fields {
429
+
format := fmt.Sprintf("%%-%ds", field.Width)
430
+
headerParts[i] = fmt.Sprintf(format, field.Title)
431
+
}
432
+
fmt.Fprintf(dt.opts.Output, "%s\n", strings.Join(headerParts, " "))
433
+
434
+
totalWidth := len(strings.Join(headerParts, " "))
435
+
fmt.Fprintf(dt.opts.Output, "%s\n", strings.Repeat("─", totalWidth))
436
+
437
+
for _, record := range records {
438
+
rowParts := make([]string, len(dt.opts.Fields))
439
+
for i, field := range dt.opts.Fields {
440
+
value := record.GetField(field.Name)
441
+
442
+
var displayValue string
443
+
if field.Formatter != nil {
444
+
displayValue = field.Formatter(value)
445
+
} else {
446
+
displayValue = fmt.Sprintf("%v", value)
447
+
}
448
+
449
+
if len(displayValue) > field.Width-1 {
450
+
displayValue = displayValue[:field.Width-4] + "..."
451
+
}
452
+
453
+
format := fmt.Sprintf("%%-%ds", field.Width)
454
+
rowParts[i] = fmt.Sprintf(format, displayValue)
455
+
}
456
+
457
+
fmt.Fprintf(dt.opts.Output, "%s\n", strings.Join(rowParts, " "))
458
+
}
459
+
460
+
return nil
461
+
}
+954
internal/ui/data_table_test.go
+954
internal/ui/data_table_test.go
···
1
+
package ui
2
+
3
+
import (
4
+
"bytes"
5
+
"context"
6
+
"errors"
7
+
"fmt"
8
+
"strings"
9
+
"testing"
10
+
"time"
11
+
12
+
"github.com/charmbracelet/bubbles/help"
13
+
"github.com/charmbracelet/bubbles/key"
14
+
tea "github.com/charmbracelet/bubbletea"
15
+
)
16
+
17
+
type MockDataRecord struct {
18
+
id int64
19
+
fields map[string]any
20
+
created time.Time
21
+
modified time.Time
22
+
}
23
+
24
+
func (m MockDataRecord) GetID() int64 {
25
+
return m.id
26
+
}
27
+
28
+
func (m MockDataRecord) SetID(id int64) {
29
+
m.id = id
30
+
}
31
+
32
+
func (m MockDataRecord) GetTableName() string {
33
+
return "mock_records"
34
+
}
35
+
36
+
func (m MockDataRecord) GetCreatedAt() time.Time {
37
+
return m.created
38
+
}
39
+
40
+
func (m MockDataRecord) SetCreatedAt(t time.Time) {
41
+
m.created = t
42
+
}
43
+
44
+
func (m MockDataRecord) GetUpdatedAt() time.Time {
45
+
return m.modified
46
+
}
47
+
48
+
func (m MockDataRecord) SetUpdatedAt(t time.Time) {
49
+
m.modified = t
50
+
}
51
+
52
+
func (m MockDataRecord) GetField(name string) any {
53
+
return m.fields[name]
54
+
}
55
+
56
+
func NewMockRecord(id int64, fields map[string]any) MockDataRecord {
57
+
now := time.Now()
58
+
return MockDataRecord{
59
+
id: id,
60
+
fields: fields,
61
+
created: now,
62
+
modified: now,
63
+
}
64
+
}
65
+
66
+
type MockDataSource struct {
67
+
records []DataRecord
68
+
loadError error
69
+
countError error
70
+
loadDelay bool
71
+
}
72
+
73
+
func (m *MockDataSource) Load(ctx context.Context, opts DataOptions) ([]DataRecord, error) {
74
+
if m.loadError != nil {
75
+
return nil, m.loadError
76
+
}
77
+
78
+
filtered := make([]DataRecord, 0)
79
+
for _, record := range m.records {
80
+
include := true
81
+
for filterField, filterValue := range opts.Filters {
82
+
if record.GetField(filterField) != filterValue {
83
+
include = false
84
+
break
85
+
}
86
+
}
87
+
if include {
88
+
filtered = append(filtered, record)
89
+
}
90
+
}
91
+
92
+
if opts.Limit > 0 && len(filtered) > opts.Limit {
93
+
filtered = filtered[:opts.Limit]
94
+
}
95
+
96
+
return filtered, nil
97
+
}
98
+
99
+
func (m *MockDataSource) Count(ctx context.Context, opts DataOptions) (int, error) {
100
+
if m.countError != nil {
101
+
return 0, m.countError
102
+
}
103
+
104
+
count := 0
105
+
for _, record := range m.records {
106
+
include := true
107
+
for filterField, filterValue := range opts.Filters {
108
+
if record.GetField(filterField) != filterValue {
109
+
include = false
110
+
break
111
+
}
112
+
}
113
+
if include {
114
+
count++
115
+
}
116
+
}
117
+
118
+
return count, nil
119
+
}
120
+
121
+
func createMockRecords() []DataRecord {
122
+
return []DataRecord{
123
+
NewMockRecord(1, map[string]any{
124
+
"name": "John Doe",
125
+
"status": "active",
126
+
"priority": "high",
127
+
"project": "alpha",
128
+
}),
129
+
NewMockRecord(2, map[string]any{
130
+
"name": "Jane Smith",
131
+
"status": "pending",
132
+
"priority": "medium",
133
+
"project": "beta",
134
+
}),
135
+
NewMockRecord(3, map[string]any{
136
+
"name": "Bob Johnson",
137
+
"status": "completed",
138
+
"priority": "low",
139
+
"project": "alpha",
140
+
}),
141
+
}
142
+
}
143
+
144
+
func createTestFields() []Field {
145
+
return []Field{
146
+
{Name: "name", Title: "Name", Width: 20},
147
+
{Name: "status", Title: "Status", Width: 12},
148
+
{Name: "priority", Title: "Priority", Width: 10, Formatter: func(v interface{}) string {
149
+
return strings.ToUpper(fmt.Sprintf("%v", v))
150
+
}},
151
+
{Name: "project", Title: "Project", Width: 15},
152
+
}
153
+
}
154
+
155
+
func TestDataTable(t *testing.T) {
156
+
t.Run("TestDataTableOptions", func(t *testing.T) {
157
+
t.Run("default options", func(t *testing.T) {
158
+
source := &MockDataSource{records: createMockRecords()}
159
+
opts := DataTableOptions{
160
+
Fields: createTestFields(),
161
+
}
162
+
163
+
table := NewDataTable(source, opts)
164
+
if table.opts.Output == nil {
165
+
t.Error("Output should default to os.Stdout")
166
+
}
167
+
if table.opts.Input == nil {
168
+
t.Error("Input should default to os.Stdin")
169
+
}
170
+
if table.opts.Title != "Data" {
171
+
t.Error("Title should default to 'Data'")
172
+
}
173
+
})
174
+
175
+
t.Run("custom options", func(t *testing.T) {
176
+
var buf bytes.Buffer
177
+
source := &MockDataSource{records: createMockRecords()}
178
+
opts := DataTableOptions{
179
+
Output: &buf,
180
+
Static: true,
181
+
Title: "Test Table",
182
+
Fields: createTestFields(),
183
+
ViewHandler: func(record DataRecord) string {
184
+
return fmt.Sprintf("Viewing: %v", record.GetField("name"))
185
+
},
186
+
}
187
+
188
+
table := NewDataTable(source, opts)
189
+
if table.opts.Output != &buf {
190
+
t.Error("Custom output not set")
191
+
}
192
+
if !table.opts.Static {
193
+
t.Error("Static mode not set")
194
+
}
195
+
if table.opts.Title != "Test Table" {
196
+
t.Error("Custom title not set")
197
+
}
198
+
})
199
+
})
200
+
201
+
t.Run("Static Mode", func(t *testing.T) {
202
+
t.Run("successful static display", func(t *testing.T) {
203
+
var buf bytes.Buffer
204
+
source := &MockDataSource{records: createMockRecords()}
205
+
206
+
table := NewDataTable(source, DataTableOptions{
207
+
Output: &buf,
208
+
Static: true,
209
+
Title: "Test Table",
210
+
Fields: createTestFields(),
211
+
})
212
+
213
+
err := table.Browse(context.Background())
214
+
if err != nil {
215
+
t.Fatalf("Browse failed: %v", err)
216
+
}
217
+
218
+
output := buf.String()
219
+
if !strings.Contains(output, "Test Table") {
220
+
t.Error("Title not displayed")
221
+
}
222
+
if !strings.Contains(output, "John Doe") {
223
+
t.Error("First record not displayed")
224
+
}
225
+
if !strings.Contains(output, "Jane Smith") {
226
+
t.Error("Second record not displayed")
227
+
}
228
+
if !strings.Contains(output, "Name") {
229
+
t.Error("Header not displayed")
230
+
}
231
+
})
232
+
233
+
t.Run("static display with no records", func(t *testing.T) {
234
+
var buf bytes.Buffer
235
+
source := &MockDataSource{records: []DataRecord{}}
236
+
237
+
table := NewDataTable(source, DataTableOptions{
238
+
Output: &buf,
239
+
Static: true,
240
+
Fields: createTestFields(),
241
+
})
242
+
243
+
err := table.Browse(context.Background())
244
+
if err != nil {
245
+
t.Fatalf("Browse failed: %v", err)
246
+
}
247
+
248
+
output := buf.String()
249
+
if !strings.Contains(output, "No records found") {
250
+
t.Error("No records message not displayed")
251
+
}
252
+
})
253
+
254
+
t.Run("static display with load error", func(t *testing.T) {
255
+
var buf bytes.Buffer
256
+
source := &MockDataSource{
257
+
loadError: errors.New("database error"),
258
+
}
259
+
260
+
table := NewDataTable(source, DataTableOptions{
261
+
Output: &buf,
262
+
Static: true,
263
+
Fields: createTestFields(),
264
+
})
265
+
266
+
err := table.Browse(context.Background())
267
+
if err == nil {
268
+
t.Fatal("Expected error, got nil")
269
+
}
270
+
271
+
output := buf.String()
272
+
if !strings.Contains(output, "Error: database error") {
273
+
t.Error("Error message not displayed")
274
+
}
275
+
})
276
+
277
+
t.Run("static display with filters", func(t *testing.T) {
278
+
var buf bytes.Buffer
279
+
source := &MockDataSource{records: createMockRecords()}
280
+
281
+
table := NewDataTable(source, DataTableOptions{
282
+
Output: &buf,
283
+
Static: true,
284
+
Fields: createTestFields(),
285
+
})
286
+
287
+
opts := DataOptions{
288
+
Filters: map[string]interface{}{
289
+
"status": "active",
290
+
},
291
+
}
292
+
293
+
err := table.BrowseWithOptions(context.Background(), opts)
294
+
if err != nil {
295
+
t.Fatalf("Browse failed: %v", err)
296
+
}
297
+
298
+
output := buf.String()
299
+
if !strings.Contains(output, "John Doe") {
300
+
t.Error("Active record not displayed")
301
+
}
302
+
if strings.Contains(output, "Jane Smith") {
303
+
t.Error("Pending record should be filtered out")
304
+
}
305
+
})
306
+
})
307
+
308
+
t.Run("Model", func(t *testing.T) {
309
+
t.Run("initial model state", func(t *testing.T) {
310
+
source := &MockDataSource{records: createMockRecords()}
311
+
keys := DefaultDataTableKeys()
312
+
313
+
model := dataTableModel{
314
+
source: source,
315
+
opts: DataTableOptions{
316
+
Fields: createTestFields(),
317
+
},
318
+
keys: keys,
319
+
help: help.New(),
320
+
loading: true,
321
+
}
322
+
323
+
if model.selected != 0 {
324
+
t.Error("Initial selected should be 0")
325
+
}
326
+
if model.viewing {
327
+
t.Error("Initial viewing should be false")
328
+
}
329
+
if !model.loading {
330
+
t.Error("Initial loading should be true")
331
+
}
332
+
})
333
+
334
+
t.Run("load data command", func(t *testing.T) {
335
+
source := &MockDataSource{records: createMockRecords()}
336
+
337
+
model := dataTableModel{
338
+
source: source,
339
+
keys: DefaultDataTableKeys(),
340
+
dataOpts: DataOptions{},
341
+
}
342
+
343
+
cmd := model.loadData()
344
+
if cmd == nil {
345
+
t.Fatal("loadData should return a command")
346
+
}
347
+
348
+
msg := cmd()
349
+
switch msg := msg.(type) {
350
+
case dataLoadedMsg:
351
+
records := []DataRecord(msg)
352
+
if len(records) != 3 {
353
+
t.Errorf("Expected 3 records, got %d", len(records))
354
+
}
355
+
case dataErrorMsg:
356
+
t.Fatalf("Unexpected error: %v", error(msg))
357
+
default:
358
+
t.Fatalf("Unexpected message type: %T", msg)
359
+
}
360
+
})
361
+
362
+
t.Run("load data with error", func(t *testing.T) {
363
+
source := &MockDataSource{
364
+
loadError: errors.New("connection failed"),
365
+
}
366
+
367
+
model := dataTableModel{
368
+
source: source,
369
+
dataOpts: DataOptions{},
370
+
}
371
+
372
+
cmd := model.loadData()
373
+
msg := cmd()
374
+
375
+
switch msg := msg.(type) {
376
+
case dataErrorMsg:
377
+
err := error(msg)
378
+
if !strings.Contains(err.Error(), "connection failed") {
379
+
t.Errorf("Expected connection error, got: %v", err)
380
+
}
381
+
default:
382
+
t.Fatalf("Expected dataErrorMsg, got: %T", msg)
383
+
}
384
+
})
385
+
386
+
t.Run("load count command", func(t *testing.T) {
387
+
source := &MockDataSource{records: createMockRecords()}
388
+
389
+
model := dataTableModel{
390
+
source: source,
391
+
dataOpts: DataOptions{},
392
+
}
393
+
394
+
cmd := model.loadCount()
395
+
msg := cmd()
396
+
397
+
switch msg := msg.(type) {
398
+
case dataCountMsg:
399
+
count := int(msg)
400
+
if count != 3 {
401
+
t.Errorf("Expected count 3, got %d", count)
402
+
}
403
+
default:
404
+
t.Fatalf("Expected dataCountMsg, got: %T", msg)
405
+
}
406
+
})
407
+
408
+
t.Run("load count with error", func(t *testing.T) {
409
+
source := &MockDataSource{
410
+
records: createMockRecords(),
411
+
countError: errors.New("count failed"),
412
+
}
413
+
414
+
model := dataTableModel{
415
+
source: source,
416
+
dataOpts: DataOptions{},
417
+
}
418
+
419
+
cmd := model.loadCount()
420
+
msg := cmd()
421
+
422
+
switch msg := msg.(type) {
423
+
case dataCountMsg:
424
+
count := int(msg)
425
+
if count != 0 {
426
+
t.Errorf("Expected count 0 on error, got %d", count)
427
+
}
428
+
default:
429
+
t.Fatalf("Expected dataCountMsg even on error, got: %T", msg)
430
+
}
431
+
})
432
+
433
+
t.Run("view record command", func(t *testing.T) {
434
+
viewHandler := func(record DataRecord) string {
435
+
return fmt.Sprintf("Viewing: %v", record.GetField("name"))
436
+
}
437
+
438
+
model := dataTableModel{
439
+
opts: DataTableOptions{
440
+
ViewHandler: viewHandler,
441
+
Fields: createTestFields(),
442
+
},
443
+
}
444
+
445
+
record := createMockRecords()[0]
446
+
cmd := model.viewRecord(record)
447
+
msg := cmd()
448
+
449
+
switch msg := msg.(type) {
450
+
case dataViewMsg:
451
+
content := string(msg)
452
+
if !strings.Contains(content, "Viewing: John Doe") {
453
+
t.Error("View content not formatted correctly")
454
+
}
455
+
default:
456
+
t.Fatalf("Expected dataViewMsg, got: %T", msg)
457
+
}
458
+
})
459
+
})
460
+
461
+
t.Run("Key Handling", func(t *testing.T) {
462
+
source := &MockDataSource{records: createMockRecords()}
463
+
464
+
t.Run("navigation keys", func(t *testing.T) {
465
+
model := dataTableModel{
466
+
source: source,
467
+
records: createMockRecords(),
468
+
selected: 1,
469
+
keys: DefaultDataTableKeys(),
470
+
opts: DataTableOptions{Fields: createTestFields()},
471
+
}
472
+
473
+
newModel, _ := model.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("k")})
474
+
if m, ok := newModel.(dataTableModel); ok {
475
+
if m.selected != 0 {
476
+
t.Errorf("Up key should move selection to 0, got %d", m.selected)
477
+
}
478
+
}
479
+
480
+
model.selected = 1
481
+
newModel, _ = model.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("j")})
482
+
if m, ok := newModel.(dataTableModel); ok {
483
+
if m.selected != 2 {
484
+
t.Errorf("Down key should move selection to 2, got %d", m.selected)
485
+
}
486
+
}
487
+
})
488
+
489
+
t.Run("boundary conditions", func(t *testing.T) {
490
+
model := dataTableModel{
491
+
source: source,
492
+
records: createMockRecords(),
493
+
selected: 0,
494
+
keys: DefaultDataTableKeys(),
495
+
opts: DataTableOptions{Fields: createTestFields()},
496
+
}
497
+
498
+
newModel, _ := model.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("k")})
499
+
if m, ok := newModel.(dataTableModel); ok {
500
+
if m.selected != 0 {
501
+
t.Error("Up key at top should not change selection")
502
+
}
503
+
}
504
+
505
+
model.selected = 2
506
+
newModel, _ = model.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("j")})
507
+
if m, ok := newModel.(dataTableModel); ok {
508
+
if m.selected != 2 {
509
+
t.Error("Down key at bottom should not change selection")
510
+
}
511
+
}
512
+
})
513
+
514
+
t.Run("number shortcuts", func(t *testing.T) {
515
+
model := dataTableModel{
516
+
source: source,
517
+
records: createMockRecords(),
518
+
keys: DefaultDataTableKeys(),
519
+
opts: DataTableOptions{Fields: createTestFields()},
520
+
}
521
+
522
+
for i := 1; i <= 3; i++ {
523
+
key := fmt.Sprintf("%d", i)
524
+
newModel, _ := model.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune(key)})
525
+
if m, ok := newModel.(dataTableModel); ok {
526
+
expectedIndex := i - 1
527
+
if m.selected != expectedIndex {
528
+
t.Errorf("Number key %s should select index %d, got %d", key, expectedIndex, m.selected)
529
+
}
530
+
}
531
+
}
532
+
})
533
+
534
+
t.Run("view key with handler", func(t *testing.T) {
535
+
viewHandler := func(record DataRecord) string {
536
+
return "test view"
537
+
}
538
+
539
+
model := dataTableModel{
540
+
source: source,
541
+
records: createMockRecords(),
542
+
keys: DefaultDataTableKeys(),
543
+
opts: DataTableOptions{
544
+
Fields: createTestFields(),
545
+
ViewHandler: viewHandler,
546
+
},
547
+
}
548
+
549
+
_, cmd := model.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("v")})
550
+
if cmd == nil {
551
+
t.Error("View key should return command when handler is set")
552
+
}
553
+
})
554
+
555
+
t.Run("view key without handler", func(t *testing.T) {
556
+
model := dataTableModel{
557
+
source: source,
558
+
records: createMockRecords(),
559
+
keys: DefaultDataTableKeys(),
560
+
opts: DataTableOptions{Fields: createTestFields()},
561
+
}
562
+
563
+
_, cmd := model.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("v")})
564
+
if cmd != nil {
565
+
t.Error("View key should not return command when no handler is set")
566
+
}
567
+
})
568
+
569
+
t.Run("quit key", func(t *testing.T) {
570
+
model := dataTableModel{
571
+
keys: DefaultDataTableKeys(),
572
+
opts: DataTableOptions{Fields: createTestFields()},
573
+
}
574
+
575
+
_, cmd := model.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("q")})
576
+
if cmd == nil {
577
+
t.Error("Quit key should return quit command")
578
+
}
579
+
})
580
+
581
+
t.Run("refresh key", func(t *testing.T) {
582
+
model := dataTableModel{
583
+
source: source,
584
+
keys: DefaultDataTableKeys(),
585
+
opts: DataTableOptions{Fields: createTestFields()},
586
+
}
587
+
588
+
newModel, cmd := model.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("r")})
589
+
if cmd == nil {
590
+
t.Error("Refresh key should return command")
591
+
}
592
+
if m, ok := newModel.(dataTableModel); ok {
593
+
if !m.loading {
594
+
t.Error("Refresh should set loading to true")
595
+
}
596
+
}
597
+
})
598
+
599
+
t.Run("help mode", func(t *testing.T) {
600
+
model := dataTableModel{
601
+
keys: DefaultDataTableKeys(),
602
+
showingHelp: true,
603
+
opts: DataTableOptions{Fields: createTestFields()},
604
+
}
605
+
606
+
newModel, _ := model.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("j")})
607
+
if m, ok := newModel.(dataTableModel); ok {
608
+
if m.selected != 0 {
609
+
t.Error("Navigation should be ignored in help mode")
610
+
}
611
+
}
612
+
613
+
newModel, _ = model.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("?")})
614
+
if m, ok := newModel.(dataTableModel); ok {
615
+
if m.showingHelp {
616
+
t.Error("Help key should exit help mode")
617
+
}
618
+
}
619
+
})
620
+
621
+
t.Run("viewing mode", func(t *testing.T) {
622
+
model := dataTableModel{
623
+
keys: DefaultDataTableKeys(),
624
+
viewing: true,
625
+
viewContent: "test content",
626
+
opts: DataTableOptions{Fields: createTestFields()},
627
+
}
628
+
629
+
newModel, _ := model.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("q")})
630
+
if m, ok := newModel.(dataTableModel); ok {
631
+
if m.viewing {
632
+
t.Error("Quit should exit viewing mode")
633
+
}
634
+
if m.viewContent != "" {
635
+
t.Error("Quit should clear view content")
636
+
}
637
+
}
638
+
})
639
+
})
640
+
641
+
t.Run("View", func(t *testing.T) {
642
+
source := &MockDataSource{records: createMockRecords()}
643
+
644
+
t.Run("normal view", func(t *testing.T) {
645
+
model := dataTableModel{
646
+
source: source,
647
+
records: createMockRecords(),
648
+
keys: DefaultDataTableKeys(),
649
+
help: help.New(),
650
+
opts: DataTableOptions{Title: "Test", Fields: createTestFields()},
651
+
}
652
+
653
+
view := model.View()
654
+
if !strings.Contains(view, "Test") {
655
+
t.Error("Title not displayed")
656
+
}
657
+
if !strings.Contains(view, "John Doe") {
658
+
t.Error("Record data not displayed")
659
+
}
660
+
if !strings.Contains(view, "Name") {
661
+
t.Error("Headers not displayed")
662
+
}
663
+
if !strings.Contains(view, " > ") {
664
+
t.Error("Selection indicator not displayed")
665
+
}
666
+
})
667
+
668
+
t.Run("loading view", func(t *testing.T) {
669
+
model := dataTableModel{
670
+
loading: true,
671
+
opts: DataTableOptions{Title: "Test", Fields: createTestFields()},
672
+
}
673
+
674
+
view := model.View()
675
+
if !strings.Contains(view, "Loading...") {
676
+
t.Error("Loading message not displayed")
677
+
}
678
+
})
679
+
680
+
t.Run("error view", func(t *testing.T) {
681
+
model := dataTableModel{
682
+
err: errors.New("test error"),
683
+
opts: DataTableOptions{Title: "Test", Fields: createTestFields()},
684
+
}
685
+
686
+
view := model.View()
687
+
if !strings.Contains(view, "Error: test error") {
688
+
t.Error("Error message not displayed")
689
+
}
690
+
})
691
+
692
+
t.Run("empty records view", func(t *testing.T) {
693
+
model := dataTableModel{
694
+
records: []DataRecord{},
695
+
opts: DataTableOptions{Title: "Test", Fields: createTestFields()},
696
+
}
697
+
698
+
view := model.View()
699
+
if !strings.Contains(view, "No records found") {
700
+
t.Error("Empty message not displayed")
701
+
}
702
+
})
703
+
704
+
t.Run("viewing mode", func(t *testing.T) {
705
+
model := dataTableModel{
706
+
viewing: true,
707
+
viewContent: "# Test Content\nDetails here",
708
+
opts: DataTableOptions{Fields: createTestFields()},
709
+
}
710
+
711
+
view := model.View()
712
+
if !strings.Contains(view, "# Test Content") {
713
+
t.Error("View content not displayed")
714
+
}
715
+
if !strings.Contains(view, "Press q/esc/backspace to return") {
716
+
t.Error("Return instructions not displayed")
717
+
}
718
+
})
719
+
720
+
t.Run("help mode", func(t *testing.T) {
721
+
model := dataTableModel{
722
+
showingHelp: true,
723
+
keys: DefaultDataTableKeys(),
724
+
help: help.New(),
725
+
opts: DataTableOptions{Fields: createTestFields()},
726
+
}
727
+
728
+
view := model.View()
729
+
if view == "" {
730
+
t.Error("Help view should not be empty")
731
+
}
732
+
})
733
+
734
+
t.Run("field formatters", func(t *testing.T) {
735
+
fields := []Field{
736
+
{Name: "priority", Title: "Priority", Width: 10, Formatter: func(v interface{}) string {
737
+
return strings.ToUpper(fmt.Sprintf("%v", v))
738
+
}},
739
+
}
740
+
741
+
model := dataTableModel{
742
+
records: createMockRecords(),
743
+
opts: DataTableOptions{Fields: fields},
744
+
}
745
+
746
+
view := model.View()
747
+
if !strings.Contains(view, "HIGH") {
748
+
t.Error("Field formatter not applied")
749
+
}
750
+
})
751
+
752
+
t.Run("long field truncation", func(t *testing.T) {
753
+
longRecord := NewMockRecord(1, map[string]any{
754
+
"name": "This is a very long name that should be truncated",
755
+
})
756
+
757
+
fields := []Field{
758
+
{Name: "name", Title: "Name", Width: 10},
759
+
}
760
+
761
+
model := dataTableModel{
762
+
records: []DataRecord{longRecord},
763
+
opts: DataTableOptions{Fields: fields},
764
+
}
765
+
766
+
view := model.View()
767
+
if !strings.Contains(view, "...") {
768
+
t.Error("Long field should be truncated with ellipsis")
769
+
}
770
+
})
771
+
})
772
+
773
+
t.Run("Update", func(t *testing.T) {
774
+
source := &MockDataSource{records: createMockRecords()}
775
+
776
+
t.Run("data loaded message", func(t *testing.T) {
777
+
model := dataTableModel{
778
+
source: source,
779
+
loading: true,
780
+
opts: DataTableOptions{Fields: createTestFields()},
781
+
}
782
+
783
+
records := createMockRecords()[:2]
784
+
newModel, _ := model.Update(dataLoadedMsg(records))
785
+
786
+
if m, ok := newModel.(dataTableModel); ok {
787
+
if len(m.records) != 2 {
788
+
t.Errorf("Expected 2 records, got %d", len(m.records))
789
+
}
790
+
if m.loading {
791
+
t.Error("Loading should be set to false")
792
+
}
793
+
}
794
+
})
795
+
796
+
t.Run("selected index adjustment", func(t *testing.T) {
797
+
model := dataTableModel{
798
+
selected: 5,
799
+
opts: DataTableOptions{Fields: createTestFields()},
800
+
}
801
+
802
+
records := createMockRecords()[:2]
803
+
newModel, _ := model.Update(dataLoadedMsg(records))
804
+
805
+
if m, ok := newModel.(dataTableModel); ok {
806
+
if m.selected != 1 {
807
+
t.Errorf("Selected should be adjusted to 1, got %d", m.selected)
808
+
}
809
+
}
810
+
})
811
+
812
+
t.Run("data view message", func(t *testing.T) {
813
+
model := dataTableModel{
814
+
opts: DataTableOptions{Fields: createTestFields()},
815
+
}
816
+
817
+
content := "Test view content"
818
+
newModel, _ := model.Update(dataViewMsg(content))
819
+
820
+
if m, ok := newModel.(dataTableModel); ok {
821
+
if !m.viewing {
822
+
t.Error("Viewing mode should be activated")
823
+
}
824
+
if m.viewContent != content {
825
+
t.Error("View content not set correctly")
826
+
}
827
+
}
828
+
})
829
+
830
+
t.Run("data error message", func(t *testing.T) {
831
+
model := dataTableModel{
832
+
loading: true,
833
+
opts: DataTableOptions{Fields: createTestFields()},
834
+
}
835
+
836
+
testErr := errors.New("test error")
837
+
newModel, _ := model.Update(dataErrorMsg(testErr))
838
+
839
+
if m, ok := newModel.(dataTableModel); ok {
840
+
if m.err == nil {
841
+
t.Error("Error should be set")
842
+
}
843
+
if m.err.Error() != "test error" {
844
+
t.Errorf("Expected 'test error', got %v", m.err)
845
+
}
846
+
if m.loading {
847
+
t.Error("Loading should be set to false on error")
848
+
}
849
+
}
850
+
})
851
+
852
+
t.Run("data count message", func(t *testing.T) {
853
+
model := dataTableModel{
854
+
opts: DataTableOptions{Fields: createTestFields()},
855
+
}
856
+
857
+
count := 42
858
+
newModel, _ := model.Update(dataCountMsg(count))
859
+
860
+
if m, ok := newModel.(dataTableModel); ok {
861
+
if m.totalCount != count {
862
+
t.Errorf("Expected count %d, got %d", count, m.totalCount)
863
+
}
864
+
}
865
+
})
866
+
})
867
+
868
+
t.Run("Default Keys", func(t *testing.T) {
869
+
keys := DefaultDataTableKeys()
870
+
871
+
if len(keys.Numbers) != 9 {
872
+
t.Errorf("Expected 9 number bindings, got %d", len(keys.Numbers))
873
+
}
874
+
875
+
if keys.Actions == nil {
876
+
t.Error("Actions map should be initialized")
877
+
}
878
+
})
879
+
880
+
t.Run("Actions", func(t *testing.T) {
881
+
t.Run("action key handling", func(t *testing.T) {
882
+
actionCalled := false
883
+
action := Action{
884
+
Key: "d",
885
+
Description: "delete",
886
+
Handler: func(record DataRecord) tea.Cmd {
887
+
actionCalled = true
888
+
return nil
889
+
},
890
+
}
891
+
892
+
keys := DefaultDataTableKeys()
893
+
keys.Actions["d"] = key.NewBinding(key.WithKeys("d"), key.WithHelp("d", "delete"))
894
+
895
+
model := dataTableModel{
896
+
source: &MockDataSource{records: createMockRecords()},
897
+
records: createMockRecords(),
898
+
keys: keys,
899
+
opts: DataTableOptions{
900
+
Fields: createTestFields(),
901
+
Actions: []Action{action},
902
+
},
903
+
}
904
+
905
+
_, cmd := model.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("d")})
906
+
if cmd != nil {
907
+
cmd()
908
+
}
909
+
910
+
if !actionCalled {
911
+
t.Error("Action handler should be called")
912
+
}
913
+
})
914
+
})
915
+
916
+
t.Run("Field", func(t *testing.T) {
917
+
t.Run("field without formatter", func(t *testing.T) {
918
+
field := Field{Name: "test", Title: "Test", Width: 10}
919
+
920
+
record := NewMockRecord(1, map[string]interface{}{
921
+
"test": "value",
922
+
})
923
+
924
+
value := record.GetField(field.Name)
925
+
displayValue := fmt.Sprintf("%v", value)
926
+
927
+
if displayValue != "value" {
928
+
t.Errorf("Expected 'value', got '%s'", displayValue)
929
+
}
930
+
})
931
+
932
+
t.Run("field with formatter", func(t *testing.T) {
933
+
field := Field{
934
+
Name: "test",
935
+
Title: "Test",
936
+
Width: 10,
937
+
Formatter: func(v interface{}) string {
938
+
return strings.ToUpper(fmt.Sprintf("%v", v))
939
+
},
940
+
}
941
+
942
+
record := NewMockRecord(1, map[string]interface{}{
943
+
"test": "value",
944
+
})
945
+
946
+
value := record.GetField(field.Name)
947
+
displayValue := field.Formatter(value)
948
+
949
+
if displayValue != "VALUE" {
950
+
t.Errorf("Expected 'VALUE', got '%s'", displayValue)
951
+
}
952
+
})
953
+
})
954
+
}