Niklas Ye
ec5df0449b
Mirrors the server's channels API: add/remove channels per user from the Users section. Requires the matching server release. Claude-Session: https://claude.ai/code/session_016mBLURvJoMuUEr9cB2RpUN
401 lines
13 KiB
Go
401 lines
13 KiB
Go
package tui
|
|
|
|
import (
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"git.ryuvia.com/niklas/terdut-tui/internal/api"
|
|
"git.ryuvia.com/niklas/terdut-tui/internal/theme"
|
|
"github.com/charmbracelet/bubbles/table"
|
|
)
|
|
|
|
func TestNextFilter(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
cycle []string
|
|
current string
|
|
want string
|
|
}{
|
|
{"advances", incidentFilters, "", api.StatusTriggered},
|
|
{"advances again", incidentFilters, api.StatusTriggered, api.StatusAcknowledged},
|
|
{"wraps back to the open queue", incidentFilters, "snoozed", ""},
|
|
{"alerts advance", alertFilters, "firing", "resolved"},
|
|
{"alerts wrap", alertFilters, "archived", "firing"},
|
|
{"unknown current restarts the cycle", incidentFilters, "bogus", ""},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
if got := nextFilter(tt.cycle, tt.current); got != tt.want {
|
|
t.Errorf("expected %q, got %q", tt.want, got)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// "snoozed" is a pseudo-status in the filter cycle: the server has no such
|
|
// status, it is a separate query axis.
|
|
func TestIncidentQuery(t *testing.T) {
|
|
tests := []struct {
|
|
filter string
|
|
wantStatus string
|
|
wantSnoozed bool
|
|
}{
|
|
{"", "", false},
|
|
{api.StatusTriggered, api.StatusTriggered, false},
|
|
{api.StatusResolved, api.StatusResolved, false},
|
|
{"snoozed", "", true},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.filter, func(t *testing.T) {
|
|
status, snoozed := incidentQuery(tt.filter)
|
|
if status != tt.wantStatus || snoozed != tt.wantSnoozed {
|
|
t.Errorf("expected (%q, %v), got (%q, %v)",
|
|
tt.wantStatus, tt.wantSnoozed, status, snoozed)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestFilterLabel(t *testing.T) {
|
|
if got := filterLabel(""); got != "open" {
|
|
t.Errorf("the empty filter is the open queue, got %q", got)
|
|
}
|
|
if got := filterLabel("resolved"); got != "resolved" {
|
|
t.Errorf("expected resolved, got %q", got)
|
|
}
|
|
}
|
|
|
|
func TestNoteEvents(t *testing.T) {
|
|
timeline := []api.IncidentEvent{
|
|
{Type: api.EventTriggered},
|
|
{Type: api.EventNote, Detail: "first"},
|
|
{Type: api.EventAcknowledged},
|
|
{Type: api.EventNote, Detail: "second"},
|
|
}
|
|
notes := noteEvents(timeline)
|
|
if len(notes) != 2 {
|
|
t.Fatalf("expected 2 notes, got %d", len(notes))
|
|
}
|
|
if notes[0].Detail != "first" || notes[1].Detail != "second" {
|
|
t.Errorf("notes out of order: %v", notes)
|
|
}
|
|
if len(noteEvents(nil)) != 0 {
|
|
t.Error("an empty timeline has no notes")
|
|
}
|
|
}
|
|
|
|
func TestHumanDuration(t *testing.T) {
|
|
tests := []struct {
|
|
d time.Duration
|
|
want string
|
|
}{
|
|
{5 * time.Second, "moments"},
|
|
{90 * time.Second, "1m"},
|
|
{45 * time.Minute, "45m"},
|
|
{2 * time.Hour, "2h"},
|
|
{150 * time.Minute, "2h 30m"},
|
|
{48 * time.Hour, "2d"},
|
|
{50 * time.Hour, "2d 2h"},
|
|
}
|
|
for _, tt := range tests {
|
|
if got := humanDuration(tt.d); got != tt.want {
|
|
t.Errorf("humanDuration(%v) = %q, want %q", tt.d, got, tt.want)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestHumanAgo_ClampsFutureToNow(t *testing.T) {
|
|
now := time.Now()
|
|
// Server and client clocks disagree often enough that this must not render
|
|
// as a negative age.
|
|
if got := humanAgo(now, now.Add(time.Hour)); got != "moments ago" {
|
|
t.Errorf("expected a future timestamp to clamp, got %q", got)
|
|
}
|
|
}
|
|
|
|
func TestHumanUntil(t *testing.T) {
|
|
now := time.Now()
|
|
if got := humanUntil(now, now.Add(2*time.Hour)); got != "in 2h" {
|
|
t.Errorf("expected 'in 2h', got %q", got)
|
|
}
|
|
if got := humanUntil(now, now.Add(-time.Minute)); got != "expired" {
|
|
t.Errorf("a deadline in the past has expired, got %q", got)
|
|
}
|
|
}
|
|
|
|
// MTTA and MTTR are nil until something has been acknowledged or resolved, and
|
|
// that has to read as "no data" rather than an instant response.
|
|
func TestHumanSeconds(t *testing.T) {
|
|
if got := humanSeconds(nil); got != "—" {
|
|
t.Errorf("expected an em dash for no data, got %q", got)
|
|
}
|
|
secs := 150.0
|
|
if got := humanSeconds(&secs); got != "2m" {
|
|
t.Errorf("expected 2m, got %q", got)
|
|
}
|
|
}
|
|
|
|
func TestIncidentRows(t *testing.T) {
|
|
future := time.Now().Add(time.Hour)
|
|
rows := incidentRows([]api.Incident{
|
|
{Title: "DiskFull", Status: api.StatusTriggered, Severity: "critical",
|
|
AssignedTo: "admin", TriggeredAt: time.Now()},
|
|
{Title: "Unowned", Status: api.StatusTriggered, TriggeredAt: time.Now()},
|
|
{Title: "Quiet", Status: api.StatusTriggered, Severity: "info",
|
|
AssignedTo: "alice", SnoozedUntil: &future, TriggeredAt: time.Now()},
|
|
}, false)
|
|
if len(rows) != 3 {
|
|
t.Fatalf("expected 3 rows, got %d", len(rows))
|
|
}
|
|
if rows[0][0] != "critical" || rows[0][3] != "admin" {
|
|
t.Errorf("unexpected first row %v", rows[0])
|
|
}
|
|
if rows[1][0] != "—" || rows[1][3] != "—" {
|
|
t.Errorf("missing severity and assignee should show an em dash, got %v", rows[1])
|
|
}
|
|
// bubbles' table renders plain strings, so snooze has to be marked in text.
|
|
if rows[2][2] != "triggered (zzz)" {
|
|
t.Errorf("expected a snooze marker in the status cell, got %q", rows[2][2])
|
|
}
|
|
}
|
|
|
|
// Rows only carry a team cell when the columns have a Team header for it, or
|
|
// every cell after it would sit under the wrong heading.
|
|
func TestRows_TeamCellMatchesTeamColumn(t *testing.T) {
|
|
now := time.Now()
|
|
incRows := incidentRows([]api.Incident{{Title: "DiskFull", TeamName: "Ops", Status: api.StatusTriggered, TriggeredAt: now}}, true)
|
|
if got, want := len(incRows[0]), len(incidentColumns(120, true)); got != want {
|
|
t.Errorf("incident row has %d cells for %d columns", got, want)
|
|
}
|
|
if incRows[0][2] != "Ops" {
|
|
t.Errorf("expected the team after the title, got %v", incRows[0])
|
|
}
|
|
alRows := alertRows([]api.Alert{{Name: "DiskFull", StartsAt: now, ReceivedAt: now}}, true)
|
|
if got, want := len(alRows[0]), len(alertColumns(120, true)); got != want {
|
|
t.Errorf("alert row has %d cells for %d columns", got, want)
|
|
}
|
|
if alRows[0][1] != "—" {
|
|
t.Errorf("a missing team name should show an em dash, got %v", alRows[0])
|
|
}
|
|
if got, want := len(incidentRows([]api.Incident{{}}, false)[0]), len(incidentColumns(120, false)); got != want {
|
|
t.Errorf("incident row has %d cells for %d columns without teams", got, want)
|
|
}
|
|
}
|
|
|
|
func TestAlertRows_ShowIncidentLink(t *testing.T) {
|
|
id := int64(7)
|
|
rows := alertRows([]api.Alert{
|
|
{Name: "DiskFull", Status: "firing", IncidentID: &id},
|
|
{Name: "Orphan", Status: "resolved"},
|
|
}, false)
|
|
if rows[0][4] != "#7" {
|
|
t.Errorf("expected #7, got %q", rows[0][4])
|
|
}
|
|
if rows[1][4] != "—" {
|
|
t.Errorf("an alert with no incident shows an em dash, got %q", rows[1][4])
|
|
}
|
|
}
|
|
|
|
// A user with no channel gets no pages of their own — the row has to say so
|
|
// rather than leaving a blank that reads as "not loaded yet".
|
|
func TestUserManageRows_ShowMissingChannels(t *testing.T) {
|
|
m := NewModel(nil, "http://test", time.Minute, theme.GruvboxDark)
|
|
m.width, m.height = 120, 40
|
|
m.users = []api.User{
|
|
{ID: 1, Username: "niklas", Channels: []api.NotificationChannel{
|
|
{ID: 1, Type: "ntfy", Address: "terdut-niklas", Enabled: true}}},
|
|
{ID: 2, Username: "alex"},
|
|
{ID: 3, Username: "sam", Channels: []api.NotificationChannel{
|
|
{ID: 2, Type: "ntfy", Enabled: false}}},
|
|
}
|
|
m.rebuildUserManageTable()
|
|
|
|
rows := m.userManageTable.Rows()
|
|
if rows[0][2] != "ntfy" {
|
|
t.Errorf("expected the channel kind in the row, got %q", rows[0][2])
|
|
}
|
|
if strings.Contains(rows[0][2], "terdut-niklas") {
|
|
t.Errorf("the row must not carry an address, got %q", rows[0][2])
|
|
}
|
|
if rows[1][2] != "—" {
|
|
t.Errorf("expected an em dash for a user with no channel, got %q", rows[1][2])
|
|
}
|
|
if rows[2][2] != "ntfy (off)" {
|
|
t.Errorf("expected a switched-off channel to say so, got %q", rows[2][2])
|
|
}
|
|
}
|
|
|
|
// A previous release overflowed the terminal by two columns because the padding
|
|
// budget was wrong. Columns plus bubbles' per-cell padding must land exactly on
|
|
// the window width.
|
|
func TestColumnWidthsFitTheTerminal(t *testing.T) {
|
|
for _, width := range []int{100, 110, 140, 200} {
|
|
// Five cells each, or six once a Team column is added. userManageColumns
|
|
// is five cells as well: username, email, channels, flags, created.
|
|
for name, tc := range map[string]struct {
|
|
cols []table.Column
|
|
cells int
|
|
}{
|
|
"incident": {incidentColumns(width, false), 5},
|
|
"incident with team": {incidentColumns(width, true), 6},
|
|
"alert": {alertColumns(width, false), 5},
|
|
"alert with team": {alertColumns(width, true), 6},
|
|
"user": {userManageColumns(width), 5},
|
|
} {
|
|
sum := 0
|
|
for _, w := range widths(tc.cols) {
|
|
sum += w
|
|
}
|
|
padding := 2 * tc.cells // bubbles applies Padding(0, 1) to each cell
|
|
if len(tc.cols) != tc.cells {
|
|
t.Errorf("%s has %d columns, expected %d", name, len(tc.cols), tc.cells)
|
|
}
|
|
if sum+padding != width {
|
|
t.Errorf("%s columns at width %d sum to %d+%d = %d",
|
|
name, width, sum, padding, sum+padding)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Narrow terminals fall back to minimum widths, which legitimately overflow;
|
|
// what must not happen is a negative or zero column.
|
|
func TestColumnWidthsStayPositiveWhenNarrow(t *testing.T) {
|
|
for _, width := range []int{20, 40, 60} {
|
|
cols := append(widths(incidentColumns(width, true)), widths(alertColumns(width, true))...)
|
|
cols = append(cols, widths(userManageColumns(width))...)
|
|
for _, w := range cols {
|
|
if w < 1 {
|
|
t.Errorf("width %d produced a non-positive column %d", width, w)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func widths(cols []table.Column) []int {
|
|
out := make([]int, len(cols))
|
|
for i, c := range cols {
|
|
out[i] = c.Width
|
|
}
|
|
return out
|
|
}
|
|
|
|
func TestTableHeight_NeverGoesBelowOne(t *testing.T) {
|
|
if got := tableHeight(3, 10); got != 1 {
|
|
t.Errorf("expected a floor of 1, got %d", got)
|
|
}
|
|
if got := tableHeight(40, 8); got != 32 {
|
|
t.Errorf("expected 32, got %d", got)
|
|
}
|
|
}
|
|
|
|
func TestBuildScheduleDays(t *testing.T) {
|
|
monday := time.Date(2026, 7, 27, 0, 0, 0, 0, time.UTC)
|
|
days := buildScheduleDays(monday, []api.ScheduleEntry{
|
|
{Date: "2026-07-29", Username: "alice"},
|
|
})
|
|
if len(days) != 7 {
|
|
t.Fatalf("expected a 7-day window, got %d", len(days))
|
|
}
|
|
if days[2].entry == nil || days[2].entry.Username != "alice" {
|
|
t.Errorf("expected alice on the third day, got %+v", days[2].entry)
|
|
}
|
|
if days[0].entry != nil {
|
|
t.Error("expected unassigned days to have no entry")
|
|
}
|
|
}
|
|
|
|
// ── Schedule reassignment ─────────────────────────────────────────────────
|
|
|
|
// scheduledWeek builds a model showing the week of 2026-07-27 with the given
|
|
// entries already on the rota.
|
|
func scheduledWeek(entries []api.ScheduleEntry) Model {
|
|
m := NewModel(nil, "http://test", time.Minute, theme.GruvboxDark)
|
|
m.width, m.height = 120, 40
|
|
m.connected = true
|
|
m.teams = []api.Team{{ID: 1, Name: "Ops", Role: api.RoleOwner}}
|
|
m.activeSection = sectionSchedule
|
|
m.scheduleWindow = time.Date(2026, 7, 27, 0, 0, 0, 0, time.UTC)
|
|
m.scheduleEntries = entries
|
|
m.scheduleDays = buildScheduleDays(m.scheduleWindow, entries)
|
|
m.rebuildScheduleTable()
|
|
return m
|
|
}
|
|
|
|
func TestScheduleConflicts(t *testing.T) {
|
|
m := scheduledWeek([]api.ScheduleEntry{
|
|
{ID: 1, Date: "2026-07-27", UserID: 1, Username: "niklas"},
|
|
{ID: 2, Date: "2026-07-28", UserID: 3, Username: "sam"},
|
|
{ID: 3, Date: "2026-07-29", UserID: 2, Username: "alex"},
|
|
})
|
|
week := []string{"2026-07-27", "2026-07-28", "2026-07-29", "2026-07-30"}
|
|
|
|
// Assigning alex: the days niklas and sam hold are conflicts, the day alex
|
|
// already holds is not, and the free day is not.
|
|
taken, holders := m.scheduleConflicts(week, 2)
|
|
if len(taken) != 2 || taken[0] != "2026-07-27" || taken[1] != "2026-07-28" {
|
|
t.Errorf("expected the two other people's days, got %v", taken)
|
|
}
|
|
if len(holders) != 2 || holders[0] != "niklas" || holders[1] != "sam" {
|
|
t.Errorf("expected both holders named once, got %v", holders)
|
|
}
|
|
}
|
|
|
|
// Reassigning somebody to a day they already hold takes nothing from anyone, so
|
|
// it must not raise a prompt — but it still needs replace, because the server
|
|
// rejects any date that already exists.
|
|
func TestScheduleConflicts_OwnDayIsNotAConflict(t *testing.T) {
|
|
m := scheduledWeek([]api.ScheduleEntry{
|
|
{ID: 1, Date: "2026-07-27", UserID: 2, Username: "alex"},
|
|
})
|
|
dates := []string{"2026-07-27"}
|
|
|
|
if taken, _ := m.scheduleConflicts(dates, 2); len(taken) != 0 {
|
|
t.Errorf("expected no conflict on the user's own day, got %v", taken)
|
|
}
|
|
if !m.scheduleOccupied(dates) {
|
|
t.Error("expected the day to still count as occupied, so replace is sent")
|
|
}
|
|
}
|
|
|
|
func TestScheduleOccupied_FreeDays(t *testing.T) {
|
|
m := scheduledWeek(nil)
|
|
if m.scheduleOccupied([]string{"2026-07-27", "2026-07-28"}) {
|
|
t.Error("expected an empty rota to need no replace")
|
|
}
|
|
}
|
|
|
|
func TestDayCount(t *testing.T) {
|
|
tests := []struct {
|
|
taken, total int
|
|
want string
|
|
}{
|
|
{1, 1, "This day is"},
|
|
{7, 7, "All 7 days are"},
|
|
{3, 7, "3 of 7 days are"},
|
|
}
|
|
for _, tt := range tests {
|
|
if got := dayCount(tt.taken, tt.total); got != tt.want {
|
|
t.Errorf("dayCount(%d, %d) = %q, want %q", tt.taken, tt.total, got, tt.want)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestJoinNames(t *testing.T) {
|
|
tests := []struct {
|
|
names []string
|
|
want string
|
|
}{
|
|
{nil, "somebody else"},
|
|
{[]string{"niklas"}, "niklas"},
|
|
{[]string{"niklas", "alex"}, "niklas and alex"},
|
|
{[]string{"niklas", "alex", "sam"}, "niklas, alex and sam"},
|
|
}
|
|
for _, tt := range tests {
|
|
if got := joinNames(tt.names); got != tt.want {
|
|
t.Errorf("joinNames(%v) = %q, want %q", tt.names, got, tt.want)
|
|
}
|
|
}
|
|
}
|