feat(dev): add Docker development CLI (#6495)

This commit is contained in:
Thomas authored and GitHub committed 2026-08-03 14:38:56 +02:00
1 parent d58a47b776
commit 018f84f80d
27 files changed
+4048 -7

No files matched your search

+122
View File
@@ -0,0 +1,122 @@
package tui
import (
"charm.land/bubbles/v2/spinner"
tea "charm.land/bubbletea/v2"
)
type appModel struct {
dev prsModel
dashboard dashModel
showDashboard bool
width int
height int
}
func newAppModel(showDashboard bool) appModel {
return appModel{dev: newPRsModel(), dashboard: newDashModel(), showDashboard: showDashboard}
}
func (m appModel) Init() tea.Cmd {
if m.showDashboard {
return m.dashboard.Init()
}
return m.dev.Init()
}
func (m appModel) canSwitch() bool {
if m.showDashboard {
return !m.dashboard.filtering
}
return !m.dev.filtering && !m.dev.pulling
}
func (m appModel) switchScreen() (tea.Model, tea.Cmd) {
m.showDashboard = !m.showDashboard
commands := make([]tea.Cmd, 0, 2)
if m.width > 0 && m.height > 0 {
resize := tea.WindowSizeMsg{Width: m.width, Height: m.height}
if m.showDashboard {
updated, command := m.dashboard.Update(resize)
m.dashboard = updated.(dashModel)
commands = append(commands, command)
} else {
updated, command := m.dev.Update(resize)
m.dev = updated.(prsModel)
commands = append(commands, command)
}
}
if m.showDashboard {
commands = append(commands, m.dashboard.Init())
} else {
commands = append(commands, m.dev.Init())
}
return m, tea.Batch(commands...)
}
func (m appModel) updateDev(msg tea.Msg) (appModel, tea.Cmd) {
updated, command := m.dev.Update(msg)
m.dev = updated.(prsModel)
return m, command
}
func (m appModel) updateDashboard(msg tea.Msg) (appModel, tea.Cmd) {
updated, command := m.dashboard.Update(msg)
m.dashboard = updated.(dashModel)
return m, command
}
func (m appModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
if window, ok := msg.(tea.WindowSizeMsg); ok {
m.width = window.Width
m.height = window.Height
m, devCommand := m.updateDev(msg)
m, dashboardCommand := m.updateDashboard(msg)
return m, tea.Batch(devCommand, dashboardCommand)
}
if key, ok := msg.(tea.KeyPressMsg); ok {
if key.String() == "d" && m.canSwitch() {
return m.switchScreen()
}
if m.showDashboard {
return m.updateDashboard(msg)
}
return m.updateDev(msg)
}
switch msg.(type) {
case prsLoadedMsg, imageCheckedMsg, prActionMsg, rebuildDoneMsg, runningRefreshedMsg, pullReadyMsg, pullEvent, spinner.TickMsg:
return m.updateDev(msg)
case tickMsg, actionMsg, rowsMsg:
if m.showDashboard {
return m.updateDashboard(msg)
}
return m, nil
case prLogTickMsg:
if !m.showDashboard {
return m.updateDev(msg)
}
return m, nil
case logsMsg:
m, devCommand := m.updateDev(msg)
m, dashboardCommand := m.updateDashboard(msg)
return m, tea.Batch(devCommand, dashboardCommand)
}
if m.showDashboard {
return m.updateDashboard(msg)
}
return m.updateDev(msg)
}
func (m appModel) View() tea.View {
if m.showDashboard {
return m.dashboard.View()
}
return m.dev.View()
}
func runApp(showDashboard bool) error {
program := tea.NewProgram(newAppModel(showDashboard))
_, err := program.Run()
return err
}
+47
View File
@@ -0,0 +1,47 @@
package tui
import (
"testing"
tea "charm.land/bubbletea/v2"
"github.com/homarr-labs/homarr/tools/homarr-dev/internal/gh"
)
func TestAppTogglePreservesDevelopmentState(t *testing.T) {
m := newAppModel(false)
m.dev.rows = []prRow{{kind: "remote", pr: gh.PR{Number: 6502}}}
updated, _ := m.Update(tea.KeyPressMsg(tea.Key{Code: 'd', Text: "d"}))
dashboard := updated.(appModel)
if !dashboard.showDashboard {
t.Fatal("d did not open the instance dashboard")
}
updated, _ = dashboard.Update(tea.KeyPressMsg(tea.Key{Code: 'd', Text: "d"}))
development := updated.(appModel)
if development.showDashboard || len(development.dev.rows) != 1 || development.dev.rows[0].pr.Number != 6502 {
t.Fatalf("development state was not preserved: %#v", development.dev.rows)
}
}
func TestAppToggleDoesNotInterceptFilterInput(t *testing.T) {
m := newAppModel(false)
m.dev.filtering = true
m.dev.filter.Focus()
updated, _ := m.Update(tea.KeyPressMsg(tea.Key{Code: 'd', Text: "d"}))
got := updated.(appModel)
if got.showDashboard || got.dev.filter.Value() != "d" {
t.Fatalf("filter input was intercepted: dashboard=%v filter=%q", got.showDashboard, got.dev.filter.Value())
}
}
func TestAppCanOpenInstancesDuringBuild(t *testing.T) {
m := newAppModel(false)
m.dev.rebuilding = true
updated, _ := m.Update(tea.KeyPressMsg(tea.Key{Code: 'd', Text: "d"}))
if !updated.(appModel).showDashboard {
t.Fatal("background build blocked dashboard navigation")
}
}
+415
View File
@@ -0,0 +1,415 @@
package tui
import (
"context"
"fmt"
"os/exec"
"strings"
"time"
"charm.land/bubbles/v2/table"
"charm.land/bubbles/v2/textinput"
"charm.land/bubbles/v2/viewport"
tea "charm.land/bubbletea/v2"
"charm.land/lipgloss/v2"
"github.com/homarr-labs/homarr/tools/homarr-dev/internal/docker"
"github.com/homarr-labs/homarr/tools/homarr-dev/internal/platform"
)
var (
titleStyle = lipgloss.NewStyle().Bold(true).Foreground(lipgloss.Color("212"))
helpStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("241"))
logHeadSt = lipgloss.NewStyle().Foreground(lipgloss.Color("241"))
runningLegend = lipgloss.NewStyle().Foreground(lipgloss.Color("42")).Render("● running")
stoppedLegend = lipgloss.NewStyle().Foreground(lipgloss.Color("240")).Render("○ stopped")
)
type dashModel struct {
table table.Model
allRows []table.Row
filter textinput.Model
filtering bool
logs viewport.Model
showLogs bool
follow bool
status string
confirmRemove string
width int
height int
}
type tickMsg time.Time
type actionMsg string
type rowsMsg []table.Row
type logsMsg struct {
name string
content string
}
func tick() tea.Cmd {
return tea.Tick(3*time.Second, func(t time.Time) tea.Msg { return tickMsg(t) })
}
func fetchLogs(name string) tea.Cmd {
return func() tea.Msg {
if name == "" {
return logsMsg{}
}
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
out, err := exec.CommandContext(ctx, "docker", "logs", "--tail", "200", name).CombinedOutput()
if err != nil {
return logsMsg{name: name, content: "logs unavailable: " + err.Error()}
}
return logsMsg{name: name, content: string(out)}
}
}
func loadRows() tea.Cmd {
return func() tea.Msg { return rowsMsg(refreshRows()) }
}
func refreshRows() []table.Row {
containers, _ := docker.List()
rows := make([]table.Row, 0, len(containers))
for _, c := range containers {
port := c.HostPort()
url := ""
if port != "" && c.Running() {
url = "http://localhost:" + port
}
state := "● " + c.State
if !c.Running() {
state = "○ " + c.State
}
img := strings.TrimPrefix(c.Image, "ghcr.io/homarr-labs/")
rows = append(rows, table.Row{c.Name, state, img, port, url, c.Status})
}
return rows
}
func dashboardColumns(width int) []table.Column {
nameWidth := 26
imageWidth := 30
urlWidth := 24
if width < 100 {
nameWidth = 22
imageWidth = max(width-54, 18)
urlWidth = 0
}
return []table.Column{
{Title: "NAME", Width: nameWidth},
{Title: "STATE", Width: 14},
{Title: "IMAGE", Width: imageWidth},
{Title: "PORT", Width: 6},
{Title: "URL", Width: urlWidth},
{Title: "STATUS", Width: 0},
}
}
func newDashModel() dashModel {
t := table.New(
table.WithColumns(dashboardColumns(104)),
table.WithFocused(true),
table.WithHeight(10),
table.WithWidth(104),
)
s := table.DefaultStyles()
s.Header = s.Header.Bold(true)
s.Selected = lipgloss.NewStyle().Bold(true).Foreground(lipgloss.Color("230")).Background(lipgloss.Color("57"))
t.SetStyles(s)
logs := viewport.New(viewport.WithWidth(104), viewport.WithHeight(12))
logs.SoftWrap = true
filter := textinput.New()
filter.Prompt = "/ "
filter.Placeholder = "filter name, image, port, state…"
filter.SetWidth(50)
styles := textinput.DefaultDarkStyles()
styles.Focused.Prompt = styles.Focused.Prompt.Foreground(lipgloss.Color("212")).Bold(true)
styles.Focused.Text = styles.Focused.Text.Foreground(lipgloss.Color("229"))
filter.SetStyles(styles)
return dashModel{table: t, filter: filter, logs: logs, showLogs: true, follow: true, width: 104, height: 30}
}
func (m *dashModel) applyFilter() {
query := strings.ToLower(strings.TrimSpace(m.filter.Value()))
if query == "" {
m.table.SetRows(m.allRows)
return
}
rows := make([]table.Row, 0, len(m.allRows))
for _, row := range m.allRows {
if strings.Contains(strings.ToLower(strings.Join(row, " ")), query) {
rows = append(rows, row)
}
}
m.table.SetRows(rows)
}
func (m dashModel) selected() string {
row := m.table.SelectedRow()
if len(row) == 0 {
return ""
}
return row[0]
}
func (m dashModel) selectedPort() string {
row := m.table.SelectedRow()
if len(row) < 4 {
return ""
}
return row[3]
}
func (m dashModel) Init() tea.Cmd {
return tea.Batch(tick(), loadRows(), fetchLogs(m.selected()))
}
func (m dashModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
switch msg := msg.(type) {
case tea.WindowSizeMsg:
m.width = msg.Width
m.height = msg.Height
m.table.SetColumns(dashboardColumns(msg.Width))
m.table.SetWidth(msg.Width)
m.logs.SetWidth(msg.Width)
m.filter.SetWidth(max(min(msg.Width-4, 60), 10))
m.layout()
return m, nil
case tickMsg:
return m, tea.Batch(tick(), loadRows())
case rowsMsg:
m.allRows = []table.Row(msg)
m.applyFilter()
return m, fetchLogs(m.selected())
case logsMsg:
if msg.name != "" && msg.name != m.selected() {
return m, nil
}
m.logs.SetContent(strings.TrimRight(msg.content, "\n"))
if m.follow {
m.logs.GotoBottom()
}
return m, nil
case actionMsg:
m.status = string(msg)
m.confirmRemove = ""
return m, loadRows()
case tea.KeyPressMsg:
if m.filtering {
switch msg.Key().Code {
case tea.KeyEscape:
m.filtering = false
m.filter.Reset()
m.filter.Blur()
m.applyFilter()
return m, fetchLogs(m.selected())
case tea.KeyEnter:
m.filtering = false
m.filter.Blur()
return m, fetchLogs(m.selected())
}
var cmd tea.Cmd
m.filter, cmd = m.filter.Update(msg)
m.applyFilter()
return m, tea.Batch(cmd, fetchLogs(m.selected()))
}
name := m.selected()
switch msg.Key().Code {
case tea.KeyUp, tea.KeyKpUp:
m.table.MoveUp(1)
return m, fetchLogs(m.selected())
case tea.KeyDown, tea.KeyKpDown:
m.table.MoveDown(1)
return m, fetchLogs(m.selected())
case tea.KeyPgUp, tea.KeyKpPgUp:
m.follow = false
m.logs.PageUp()
return m, nil
case tea.KeyPgDown, tea.KeyKpPgDown:
m.logs.PageDown()
m.follow = m.logs.AtBottom()
return m, nil
}
switch msg.String() {
case "q", "ctrl+c", "esc":
return m, tea.Quit
case "l":
m.showLogs = !m.showLogs
m.layout()
if m.showLogs {
return m, fetchLogs(name)
}
return m, nil
case "/":
m.filtering = true
return m, m.filter.Focus()
case "f":
m.follow = !m.follow
if m.follow {
m.logs.GotoBottom()
}
return m, nil
case "s":
if name != "" {
m.status = "stopping " + name + "…"
return m, func() tea.Msg {
if err := docker.Stop(name); err != nil {
return actionMsg("stop failed: " + err.Error())
}
return actionMsg("stopped " + name)
}
}
case "x":
if name != "" {
if m.confirmRemove != name {
m.confirmRemove = name
m.status = "press x again to remove " + name
return m, nil
}
m.status = "removing " + name + "…"
return m, func() tea.Msg {
if err := docker.Remove(name); err != nil {
return actionMsg("remove failed: " + err.Error())
}
return actionMsg("removed " + name)
}
}
case "R":
if name != "" {
m.status = "restarting " + name + "…"
return m, func() tea.Msg {
if err := docker.Restart(name); err != nil {
return actionMsg("restart failed: " + err.Error())
}
return actionMsg("restarted " + name)
}
}
case "o":
if name != "" {
if port := m.selectedPort(); port != "" {
if err := platform.OpenURL("http://localhost:" + port); err != nil {
m.status = "open failed: " + err.Error()
}
}
}
case "c":
if name != "" {
if port := m.selectedPort(); port != "" {
url := "http://localhost:" + port
if err := platform.CopyText(url); err != nil {
m.status = "copy failed: " + err.Error()
} else {
m.status = "copied " + url
}
}
}
case "r":
return m, loadRows()
case "k":
m.table.MoveUp(1)
return m, fetchLogs(m.selected())
case "j":
m.table.MoveDown(1)
return m, fetchLogs(m.selected())
}
}
var cmd tea.Cmd
m.table, cmd = m.table.Update(msg)
return m, cmd
}
func (m *dashModel) layout() {
available := m.height - 11
if m.filtering || m.filter.Value() != "" {
available -= 2
}
if !m.showLogs {
m.table.SetHeight(max(available, 5))
return
}
tableH := min(12, max(available/2, 5))
m.table.SetHeight(tableH)
logsH := available - tableH
if logsH < 3 {
logsH = 3
}
m.logs.SetHeight(logsH)
}
func (m dashModel) selectedDetailView() string {
row := m.table.SelectedRow()
if len(row) < 6 {
return ""
}
title := lipgloss.NewStyle().Bold(true).Foreground(lipgloss.Color("229")).Render(row[0])
meta := row[2] + " · " + row[1]
if row[3] != "" {
meta += " · port " + row[3]
}
if row[4] != "" {
meta += " · " + row[4]
}
if row[5] != "" {
meta += " · " + row[5]
}
return title + "\n" + helpStyle.Render(meta)
}
func (m dashModel) View() tea.View {
var b strings.Builder
running := 0
for _, row := range m.allRows {
if len(row) > 1 && strings.Contains(row[1], "running") {
running++
}
}
b.WriteString(titleStyle.Render("🦞 homarr instances") + " " + helpStyle.Render(fmt.Sprintf("%d total · %d running · %d shown", len(m.allRows), running, len(m.table.Rows()))))
b.WriteString("\n\n")
if m.filtering || m.filter.Value() != "" {
b.WriteString(m.filter.View() + "\n\n")
}
if len(m.table.Rows()) == 0 {
message := "no homarr containers — start one with `homarr run <tag>` or `homarr run --pr N`"
if len(m.allRows) > 0 {
message = "no instances match " + m.filter.Value()
}
b.WriteString(helpStyle.Render(" " + message + "\n"))
} else {
b.WriteString(m.table.View())
b.WriteString("\n")
}
if detail := m.selectedDetailView(); detail != "" {
b.WriteString("\n" + detail + "\n")
}
if m.showLogs && len(m.table.Rows()) > 0 {
mode := "paused"
if m.follow {
mode = "following"
}
b.WriteString("\n" + logHeadSt.Render("── logs: "+m.selected()+" ("+mode+") ──") + "\n")
b.WriteString(m.logs.View())
}
if m.status != "" {
statusStyle := lipgloss.NewStyle().Foreground(lipgloss.Color("42"))
lower := strings.ToLower(m.status)
if strings.Contains(lower, "fail") || strings.Contains(lower, "error") {
statusStyle = statusStyle.Foreground(lipgloss.Color("196"))
} else if strings.Contains(lower, "press x") {
statusStyle = statusStyle.Foreground(lipgloss.Color("214"))
}
b.WriteString("\n" + statusStyle.Render(m.status))
}
b.WriteString("\n\n" + helpStyle.Render("/ filter · ↑/↓ select · l logs · f follow · pgup/pgdn scroll · s stop · R restart · x remove · o open · c copy URL · r refresh · d development · q quit"))
b.WriteString("\n" + helpStyle.Render(runningLegend+" · "+stoppedLegend))
v := tea.NewView(b.String())
v.AltScreen = true
v.WindowTitle = "🦞 Homarr instances"
return v
}
func RunDashboard() error {
return runApp(true)
}
@@ -0,0 +1,62 @@
package tui
import (
"strings"
"testing"
"charm.land/bubbles/v2/table"
tea "charm.land/bubbletea/v2"
)
func TestDashboardRendersRowsAndLogs(t *testing.T) {
m := newDashModel()
m.table.SetRows([]table.Row{{
"homarr_pr_6441",
"running",
"homarr-test:pr-6441",
"7575",
"http://localhost:7575",
"Up 2 minutes",
}})
m.logs.SetWidth(104)
m.logs.SetHeight(5)
m.logs.SetContent("server ready")
got := m.View().Content
for _, want := range []string{"homarr_pr_6441", "server ready"} {
if !strings.Contains(got, want) {
t.Fatalf("dashboard omitted %q: %q", want, got)
}
}
if !m.View().AltScreen {
t.Fatal("dashboard must use the alternate screen")
}
}
func TestDashboardArrowNavigation(t *testing.T) {
m := newDashModel()
m.table.SetRows([]table.Row{
{"homarr_first", "running", "homarr:first", "7575", "", "Up 1 minute"},
{"homarr_second", "running", "homarr:second", "7576", "", "Up 1 minute"},
})
updated, _ := m.Update(tea.KeyPressMsg(tea.Key{Code: tea.KeyDown}))
got := updated.(dashModel).selected()
if got != "homarr_second" {
t.Fatalf("down arrow selected %q, want homarr_second", got)
}
}
func TestDashboardIgnoresStaleLogs(t *testing.T) {
m := newDashModel()
m.table.SetRows([]table.Row{{"homarr_current", "running", "homarr:current", "7575", "", "Up 1 minute"}})
m.logs.SetWidth(104)
m.logs.SetHeight(5)
m.logs.SetContent("current logs")
updated, _ := m.Update(logsMsg{name: "homarr_old", content: "stale logs"})
got := updated.(dashModel).View().Content
if strings.Contains(got, "stale logs") || !strings.Contains(got, "current logs") {
t.Fatalf("stale log result replaced current content: %q", got)
}
}
File diff suppressed because it is too large. Load diff
+228
View File
@@ -0,0 +1,228 @@
package tui
import (
"errors"
"strings"
"testing"
tea "charm.land/bubbletea/v2"
"github.com/homarr-labs/homarr/tools/homarr-dev/internal/docker"
"github.com/homarr-labs/homarr/tools/homarr-dev/internal/gh"
)
func TestPRTableRendersRows(t *testing.T) {
m := newPRsModel()
m.rows = []prRow{{
kind: "remote",
pr: gh.PR{Number: 6441, Title: "Human PR", Author: "ajnart", CIState: "SUCCESS"},
imageState: "yes",
}}
m.table.SetRows(buildTableRows(m.rows))
if got := m.View().Content; !strings.Contains(got, "Human PR") {
t.Fatalf("table view omitted rows: %q", got)
}
if !m.View().AltScreen {
t.Fatal("development browser must use the alternate screen")
}
}
func TestPRTableArrowNavigation(t *testing.T) {
m := newPRsModel()
m.rows = []prRow{
{kind: "remote", pr: gh.PR{Number: 1, Title: "First"}},
{kind: "remote", pr: gh.PR{Number: 2, Title: "Second"}},
}
m.table.SetRows(buildTableRows(m.rows))
updated, _ := m.Update(tea.KeyPressMsg(tea.Key{Code: tea.KeyDown}))
got := updated.(prsModel).table.SelectedRow()
if len(got) < 3 || got[2] != "2" {
t.Fatalf("down arrow selected %v, want PR 2", got)
}
}
func TestPRImageChecksAreBounded(t *testing.T) {
m := newPRsModel()
prs := make([]gh.PR, 20)
for i := range prs {
prs[i] = gh.PR{Number: i + 1, Title: "PR"}
}
updated, cmd := m.Update(prsLoadedMsg{prs: prs})
got := updated.(prsModel)
if cmd == nil {
t.Fatal("expected image check commands")
}
if got.imageActive != 6 || len(got.imageQueue) != 14 {
t.Fatalf("active=%d queued=%d, want active=6 queued=14", got.imageActive, len(got.imageQueue))
}
}
func TestPRLoadedReusesImageChecksUnlessRefreshIsForced(t *testing.T) {
m := newPRsModel()
m.rows = []prRow{{kind: "remote", pr: gh.PR{Number: 1}, imageState: "yes"}}
updated, _ := m.Update(prsLoadedMsg{prs: []gh.PR{{Number: 1}, {Number: 2}}})
cached := updated.(prsModel)
if cached.rows[0].imageState != "yes" || len(cached.imageQueue) != 0 || cached.imageActive != 1 {
t.Fatalf("cached states were not reused: rows=%#v queue=%v active=%d", cached.rows, cached.imageQueue, cached.imageActive)
}
updated, _ = cached.Update(prsLoadedMsg{prs: []gh.PR{{Number: 1}, {Number: 2}}, refresh: true})
refreshed := updated.(prsModel)
if refreshed.rows[0].imageState != "checking" || refreshed.imageActive != 2 {
t.Fatalf("forced refresh reused image states: rows=%#v active=%d", refreshed.rows, refreshed.imageActive)
}
}
func TestDevelopmentRowsFoldCurrentLocalPRImage(t *testing.T) {
prs := []gh.PR{{Number: 6502, HeadSHA: "current"}}
images := []docker.Image{
{Tag: "pr-6502", PRNumber: 6502, Revision: "current"},
{Tag: "pr-6502-stale", PRNumber: 6502, Revision: "stale"},
}
rows, queue := developmentRows(prs, images, nil)
if len(rows) != 2 || !rows[0].hasCurrentLocalImage() || rows[0].local.Tag != "pr-6502" {
t.Fatalf("current image was not folded into PR row: %#v", rows)
}
if rows[1].kind != "local" || rows[1].local.Tag != "pr-6502-stale" {
t.Fatalf("stale image should remain separate: %#v", rows[1])
}
if got := buildTableRows(rows)[0][6]; got != imgLocal {
t.Fatalf("image marker = %q, want %q", got, imgLocal)
}
if len(queue) != 0 {
t.Fatalf("current local image queued unnecessary registry checks: %v", queue)
}
}
func TestLocalPRPlanUsesPRContainerIdentity(t *testing.T) {
row := prRow{
kind: "remote",
pr: gh.PR{Number: 6502, HeadSHA: "abcdef1234567890"},
local: docker.Image{Tag: "pr-6502", PRNumber: 6502, Revision: "abcdef1234567890"},
}
plan, err := localPRPlan(row, false, func(int) int { return 7575 })
if err != nil {
t.Fatal(err)
}
if plan.Image != "homarr:pr-6502" || plan.Name != "homarr_pr_6502" || plan.Volume != "homarr_pr_6502_data" || plan.Pull || plan.PRNumber != 6502 {
t.Fatalf("unexpected local PR plan: %#v", plan)
}
}
func TestRemotePRBuildUsesTemporaryPRWorkflow(t *testing.T) {
image, action, status := localBuildForRow(prRow{kind: "remote", pr: gh.PR{Number: 6441}})
if image.Tag != "pr-6441" || image.PRNumber != 6441 || action != "built" || !strings.Contains(status, "building PR #6441 locally") {
t.Fatalf("image=%#v action=%q status=%q", image, action, status)
}
}
func TestPRImageCheckInProgressDoesNotLaunch(t *testing.T) {
m := newPRsModel()
m.rows = []prRow{{kind: "remote", pr: gh.PR{Number: 6441, Title: "Pending image"}, imageState: "checking"}}
m.table.SetRows(buildTableRows(m.rows))
updated, cmd := m.Update(tea.KeyPressMsg(tea.Key{Code: tea.KeyEnter}))
got := updated.(prsModel)
if cmd != nil {
t.Fatal("unavailable image returned a launch command")
}
if !strings.Contains(got.status, "still in progress") {
t.Fatalf("status = %q, want launch rejection", got.status)
}
}
func TestPullErrorIncludesLastDockerMessage(t *testing.T) {
err := commandErrorWithDetail(errors.New("exit status 1"), "manifest unknown")
if !strings.Contains(err.Error(), "manifest unknown") {
t.Fatalf("pull error = %v", err)
}
}
func TestOutputTailRetainsBuildFailure(t *testing.T) {
tail := &outputTail{}
_, _ = tail.Write([]byte("building\r\nERROR: Dockerfile not found\n"))
if got := tail.lastLine(); got != "ERROR: Dockerfile not found" {
t.Fatalf("last line = %q", got)
}
}
func TestDevTableRendersLocalImageSource(t *testing.T) {
m := newPRsModel()
m.rows = []prRow{{
kind: "local",
local: docker.Image{Tag: "feature", Source: "/tmp/homarr", Revision: "abcdef1234567890"},
imageState: "yes",
}}
m.table.SetRows(buildTableRows(m.rows))
content := m.View().Content
for _, want := range []string{"local", "homarr:feature", "/tmp/homarr", "abcdef123456"} {
if !strings.Contains(content, want) {
t.Fatalf("development view omitted %q: %q", want, content)
}
}
}
func TestRebuildCompletionRestoresLoadingState(t *testing.T) {
m := newPRsModel()
m.rebuilding = true
image := docker.Image{Tag: "feature"}
updated, cmd := m.Update(rebuildDoneMsg{image: image})
got := updated.(prsModel)
if got.rebuilding || !got.loading || got.status != "rebuilt homarr:feature" || cmd == nil {
t.Fatalf("unexpected rebuild state: rebuilding=%v loading=%v status=%q", got.rebuilding, got.loading, got.status)
}
}
func TestRebuildCanBeCanceled(t *testing.T) {
m := newPRsModel()
canceled := false
m.rebuilding = true
m.rebuildCancel = func() { canceled = true }
updated, cmd := m.Update(tea.KeyPressMsg(tea.Key{Code: 'q'}))
got := updated.(prsModel)
if !canceled || cmd != nil || got.status != "canceling rebuild…" {
t.Fatalf("cancel state: canceled=%v status=%q", canceled, got.status)
}
}
func TestNavigationRemainsAvailableDuringBuild(t *testing.T) {
m := newPRsModel()
m.rebuilding = true
m.rows = []prRow{
{kind: "remote", pr: gh.PR{Number: 1}},
{kind: "remote", pr: gh.PR{Number: 2}},
}
m.table.SetRows(buildTableRows(m.rows))
updated, _ := m.Update(tea.KeyPressMsg(tea.Key{Code: tea.KeyDown}))
selected := updated.(prsModel).table.SelectedRow()
if len(selected) < 3 || selected[2] != "2" {
t.Fatalf("build blocked navigation: %v", selected)
}
}
func TestCompletedPullWithoutPlanDoesNotPanic(t *testing.T) {
m := newPRsModel()
m.pulling = true
m.pullCancel = func() {}
updated, cmd := m.Update(pullEvent{done: true})
got := updated.(prsModel)
if got.pulling || cmd != nil {
t.Fatalf("pulling=%v cmd=%v", got.pulling, cmd)
}
}
func TestTruncateTextPreservesUTF8(t *testing.T) {
if got := truncateText("🦞homarr", 2); got != "🦞h" {
t.Fatalf("truncateText() = %q", got)
}
}