174 lines
7.1 KiB
Go
174 lines
7.1 KiB
Go
package tui
|
|
|
|
import (
|
|
"errors"
|
|
"strings"
|
|
"testing"
|
|
|
|
tea "github.com/charmbracelet/bubbletea"
|
|
|
|
"proxyctl/internal/app"
|
|
"proxyctl/internal/profile"
|
|
"proxyctl/internal/target"
|
|
)
|
|
|
|
type progressiveDetectionModule struct {
|
|
snapshot app.Snapshot
|
|
streams []chan app.OperationUpdate
|
|
begins int
|
|
}
|
|
|
|
func (m *progressiveDetectionModule) Snapshot() app.Snapshot {
|
|
snapshot := cloneDetectionSnapshot(m.snapshot)
|
|
if m.begins == 0 {
|
|
for i := range snapshot.Targets {
|
|
snapshot.Targets[i].DetectionPhase = app.TargetChecking
|
|
}
|
|
}
|
|
return snapshot
|
|
}
|
|
func (m *progressiveDetectionModule) Dispatch(app.Intent) app.Result {
|
|
return app.Result{Snapshot: m.snapshot}
|
|
}
|
|
func (m *progressiveDetectionModule) StartOperation(intent app.Intent) app.OperationStream {
|
|
m.begins++
|
|
for i := range m.snapshot.Targets {
|
|
m.snapshot.Targets[i].DetectionPhase = app.TargetChecking
|
|
m.snapshot.Targets[i].DetectionErr = nil
|
|
}
|
|
return app.OperationStream{Snapshot: cloneDetectionSnapshot(m.snapshot), Updates: m.streams[m.begins-1]}
|
|
}
|
|
|
|
func TestCompleteModelStreamsStartupAndRefreshByTargetWithoutMovingSelection(t *testing.T) {
|
|
startup := make(chan app.OperationUpdate, 4)
|
|
refresh := make(chan app.OperationUpdate, 4)
|
|
module := &progressiveDetectionModule{
|
|
snapshot: app.Snapshot{Targets: []app.TargetSnapshot{
|
|
{ID: "shell", Description: target.Description{Name: "Shell", Summary: "Shell description"}},
|
|
{ID: "apt", Description: target.Description{Name: "APT", Summary: "APT description"}},
|
|
{ID: "docker", Description: target.Description{Name: "Docker", Summary: "Docker description"}},
|
|
}},
|
|
streams: []chan app.OperationUpdate{startup, refresh},
|
|
}
|
|
model := resizedModel(t, module, themeModeNoColor, 120, 36)
|
|
assertUsableFrame(t, model.View(), 120, 36,
|
|
"> … Checking Shell", "… Checking APT", "… Checking Docker",
|
|
"Shell description", "Availability and configuration inspection are in progress.",
|
|
)
|
|
|
|
// Selection remains usable while checks run, and is retained by identity
|
|
// even when a later product row completes first.
|
|
model = updateKey(model, "down")
|
|
if model.selectedTargetID != "apt" {
|
|
t.Fatalf("selection during startup = %q, want apt", model.selectedTargetID)
|
|
}
|
|
command := model.Init()
|
|
if command == nil {
|
|
t.Fatal("startup did not wait for progressive detection")
|
|
}
|
|
|
|
startup <- module.detectionUpdate("docker", app.TargetReady, true, target.Enabled, "docker enabled", nil)
|
|
model, command = applyDetectionCommand(t, model, command)
|
|
view := model.View()
|
|
assertOrder(t, view, "Shell", "APT", "Docker")
|
|
assertUsableFrame(t, view, 120, 36, "… Checking Shell", "> … Checking APT", "● Enabled Docker")
|
|
if model.selectedTargetID != "apt" {
|
|
t.Fatalf("out-of-order completion moved selection to %q", model.selectedTargetID)
|
|
}
|
|
|
|
failure := errors.New("apt-config inspection failed")
|
|
startup <- module.detectionUpdate("shell", app.TargetDetectionFailed, false, "", "", failure)
|
|
model, command = applyDetectionCommand(t, model, command)
|
|
assertUsableFrame(t, model.View(), 120, 36, "! Failed Shell", "> … Checking APT", "● Enabled Docker")
|
|
|
|
startup <- module.detectionUpdate("apt", app.TargetReady, false, target.Disabled, "apt-config is unavailable", nil)
|
|
model, command = applyDetectionCommand(t, model, command)
|
|
startup <- app.FailedOperationUpdate(cloneDetectionSnapshot(module.snapshot), app.OperationStatus{Summary: "Some Target checks failed", TargetID: "shell"}, nil, "shell", failure)
|
|
model, command = applyDetectionCommand(t, model, command)
|
|
if command != nil || model.selectedTargetID != "shell" {
|
|
t.Fatalf("failed startup did not focus the first failed Target: command=%v selection=%q", command != nil, model.selectedTargetID)
|
|
}
|
|
assertUsableFrame(t, model.View(), 120, 36, "> ! Failed Shell", "● Enabled Docker")
|
|
model = updateKey(model, "down")
|
|
|
|
updated, command := model.Update(keyMessage("r"))
|
|
model = updated.(Model)
|
|
if command == nil || module.begins != 2 {
|
|
t.Fatalf("refresh did not reuse progressive detection: command=%v begins=%d", command != nil, module.begins)
|
|
}
|
|
assertUsableFrame(t, model.View(), 120, 36, "… Checking Shell", "… Checking APT", "> … Checking Docker")
|
|
|
|
refresh <- module.detectionUpdate("apt", app.TargetReady, true, target.Enabled, "apt enabled", nil)
|
|
model, command = applyDetectionCommand(t, model, command)
|
|
assertUsableFrame(t, model.View(), 120, 36, "… Checking Shell", "● Enabled APT", "> … Checking Docker")
|
|
if model.selectedTargetID != "docker" {
|
|
t.Fatalf("refresh completion moved selection to %q", model.selectedTargetID)
|
|
}
|
|
}
|
|
|
|
func TestCompleteModelReconcilesAuthoritativeSnapshotWhenDetectionGenerationClosesStale(t *testing.T) {
|
|
startup := make(chan app.OperationUpdate)
|
|
module := &progressiveDetectionModule{
|
|
snapshot: app.Snapshot{Targets: []app.TargetSnapshot{{
|
|
ID: "shell", Description: target.Description{Name: "Shell", Summary: "Shell description"},
|
|
}}},
|
|
streams: []chan app.OperationUpdate{startup},
|
|
}
|
|
model := resizedModel(t, module, themeModeNoColor, 80, 24)
|
|
assertUsableFrame(t, model.View(), 80, 24, "> … Checking Shell")
|
|
|
|
// A newer Application generation has already established the authoritative
|
|
// result, so the stale stream closes without publishing a completion update.
|
|
_ = module.detectionUpdate("shell", app.TargetReady, true, target.Enabled, "shell enabled", nil)
|
|
close(startup)
|
|
model, next := applyDetectionCommand(t, model, model.Init())
|
|
if next != nil || model.operation.active {
|
|
t.Fatalf("stale closure left detection active: next=%v active=%v", next != nil, model.operation.active)
|
|
}
|
|
assertUsableFrame(t, model.View(), 80, 24, "> ● Enabled Shell", "Evidence: shell enabled")
|
|
}
|
|
|
|
func (m *progressiveDetectionModule) detectionUpdate(id string, phase app.TargetDetectionPhase, available bool, state target.State, evidence string, err error) app.OperationUpdate {
|
|
for i := range m.snapshot.Targets {
|
|
if m.snapshot.Targets[i].ID != id {
|
|
continue
|
|
}
|
|
m.snapshot.Targets[i].DetectionPhase = phase
|
|
m.snapshot.Targets[i].DetectionErr = err
|
|
m.snapshot.Targets[i].Available = available
|
|
m.snapshot.Targets[i].AvailabilityEvidence = evidence
|
|
m.snapshot.Targets[i].State = state
|
|
m.snapshot.Targets[i].Evidence = evidence
|
|
break
|
|
}
|
|
progressPhase := app.TargetProgressSucceeded
|
|
if err != nil {
|
|
progressPhase = app.TargetProgressFailed
|
|
}
|
|
return app.RunningOperationUpdate(cloneDetectionSnapshot(m.snapshot), app.OperationStatus{Summary: "Checked Target", TargetID: id}, []app.TargetProgress{{TargetID: id, Phase: progressPhase, State: state, Evidence: evidence, Err: err}})
|
|
}
|
|
|
|
func cloneDetectionSnapshot(snapshot app.Snapshot) app.Snapshot {
|
|
snapshot.Targets = append([]app.TargetSnapshot(nil), snapshot.Targets...)
|
|
snapshot.Profiles = append([]profile.Profile(nil), snapshot.Profiles...)
|
|
return snapshot
|
|
}
|
|
|
|
func applyDetectionCommand(t *testing.T, model Model, command tea.Cmd) (Model, tea.Cmd) {
|
|
t.Helper()
|
|
updated, next := model.Update(command())
|
|
return updated.(Model), next
|
|
}
|
|
|
|
func assertOrder(t *testing.T, view string, values ...string) {
|
|
t.Helper()
|
|
last := -1
|
|
for _, value := range values {
|
|
index := strings.Index(view, value)
|
|
if index <= last {
|
|
t.Fatalf("%q did not follow prior Target in frame:\n%s", value, view)
|
|
}
|
|
last = index
|
|
}
|
|
}
|