cmdiotest: add black-box test suite for cmdio prompts (#5248)

## Summary
Adds `libs/cmdio/cmdiotest`: a pipe-backed harness plus 41 baseline
tests covering `cmdio.RunPrompt`, `Secret`, `RunSelect`, and
`SelectOrdered`. Each test drives the entry point through a pair of
`os.Pipe`s, captures the rendered screen via an in-process VT emulator,
and pins both the visible output (golden snapshots) and the returned
`(value, err)`. No pty required, so the suite runs on every supported OS
without `term.OpenPTY` quirks.

Background: #5231 sketched a similar baseline against promptui using a
pty + vt10x. That PR is a point-in-time snapshot and will be closed;
this PR is a fresh net-add against `main`, targeting the current
bubbletea-backed implementation from #5232. The golden screen snapshots
are byte-identical to those captured against promptui in #5231 —
concrete evidence that the bubbletea rewrite preserved the visible
behavior.

Properties of the new suite:
- All 41 tests use `t.Parallel()`; wall time is ~0.6s, no flakes across
`-race` × 3 and sequential × 10.
- `Term[T]` is generic over result type — one constructor per cmdio
entry point, one `Result()` method.
- Two small test-only hooks on `cmdIO` (`teaWindowSize`, `teaFPS`); both
zero-valued and inert outside `NewTestIO`, so production code paths are
unchanged.

## Test plan
- [x] `go test ./libs/cmdio/...` passes
- [x] `go test -race ./libs/cmdio/cmdiotest/...` passes

This pull request and its description were written by Isaac.

Author: pietern

NOTICE

@@ -139,6 +139,10 @@ charmbracelet/lipgloss - https://github.com/charmbracelet/lipgloss
 Copyright (c) 2021-2025 Charmbracelet, Inc
 License - https://github.com/charmbracelet/lipgloss/blob/master/LICENSE
 
+charmbracelet/x/ansi - https://github.com/charmbracelet/x
+Copyright (c) 2023-2025 Charmbracelet, Inc
+License - https://github.com/charmbracelet/x/blob/main/ansi/LICENSE
+
 Masterminds/semver - https://github.com/Masterminds/semver
 Copyright (C) 2014-2019, Matt Butcher and Matt Farina
 License - https://github.com/Masterminds/semver/blob/master/LICENSE.txt

go.mod

@@ -12,6 +12,7 @@ require (
 	github.com/charmbracelet/bubbletea v1.3.10 // MIT
 	github.com/charmbracelet/huh v1.0.0 // MIT
 	github.com/charmbracelet/lipgloss v1.1.0 // MIT
+	github.com/charmbracelet/x/ansi v0.11.6 // MIT
 	github.com/databricks/databricks-sdk-go v0.132.0 // Apache-2.0
 	github.com/google/jsonschema-go v0.4.3 // MIT
 	github.com/google/uuid v1.6.0 // BSD-3-Clause
@@ -53,7 +54,6 @@ require (
 	github.com/catppuccin/go v0.3.0 // indirect
 	github.com/cespare/xxhash/v2 v2.3.0 // indirect
 	github.com/charmbracelet/colorprofile v0.4.1 // indirect
-	github.com/charmbracelet/x/ansi v0.11.6 // indirect
 	github.com/charmbracelet/x/cellbuf v0.0.15 // indirect
 	github.com/charmbracelet/x/exp/strings v0.0.0-20240722160745-212f7b056ed0 // indirect
 	github.com/charmbracelet/x/term v0.2.2 // indirect

libs/cmdio/cmdiotest/prompt_alt_key_noop_baseline_test.go

@@ -0,0 +1,43 @@
+package cmdiotest_test
+
+import (
+	"testing"
+
+	"github.com/databricks/cli/libs/cmdio"
+	"github.com/databricks/cli/libs/cmdio/cmdiotest/termtest"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// TestPromptBaseline_AltKeyNoop pins that Alt-prefixed keys are silent
+// no-ops in [cmdio.RunPrompt]. Specifically, Alt+f (the readline binding
+// for "move forward by word") must neither move the cursor nor insert a
+// literal 'f' into the buffer. The same shape applies to Alt+b, Alt+d,
+// Alt+Backspace, and any other modified key the prompt model doesn't
+// handle; pinning Alt+f covers the class.
+func TestPromptBaseline_AltKeyNoop(t *testing.T) {
+	t.Parallel()
+	tm := termtest.NewPrompt(t, cmdio.PromptOptions{
+		Label: "Workspace name",
+	})
+	tm.WaitFor("Workspace name")
+
+	// Type "hello" and move cursor two places left so it sits mid-word.
+	// If Alt+f moved the cursor (or inserted), goldens 01 and 02 would
+	// diverge.
+	tm.Type("hello")
+	tm.Type(termtest.KeyLeft)
+	tm.Type(termtest.KeyLeft)
+	tm.Golden("01-cursor-mid")
+
+	tm.Type("\x1bf")
+	tm.Golden("02-after-alt-f")
+
+	tm.Type(termtest.KeyEnter)
+	v, err := tm.Result()
+	require.NoError(t, err, "raw output: %q", tm.Raw())
+	// Final guard: the returned value must be exactly "hello". A literal
+	// 'f' insertion would surface here even if the goldens above somehow
+	// missed it.
+	assert.Equal(t, "hello", v)
+}

libs/cmdio/cmdiotest/prompt_ctrl_c_baseline_test.go

@@ -0,0 +1,32 @@
+package cmdiotest_test
+
+import (
+	"testing"
+
+	"github.com/databricks/cli/libs/cmdio"
+	"github.com/databricks/cli/libs/cmdio/cmdiotest/termtest"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// TestPromptBaseline_CtrlC pins Ctrl+C cancellation for RunPrompt. Mirrors
+// the equivalent Secret test: error is returned, value is empty, snapshot
+// captures any "^C" that the terminal echoed.
+func TestPromptBaseline_CtrlC(t *testing.T) {
+	t.Parallel()
+	tm := termtest.NewPrompt(t, cmdio.PromptOptions{
+		Label: "Workspace name",
+	})
+	tm.WaitFor("Workspace name")
+	tm.Golden("01-empty")
+
+	tm.Type("partial input")
+	tm.Golden("02-after-typing")
+
+	tm.Type(termtest.KeyCtrlC)
+
+	v, err := tm.Result()
+	require.Error(t, err)
+	assert.EqualError(t, err, "^C")
+	assert.Empty(t, v)
+}

libs/cmdio/cmdiotest/prompt_ctrl_fb_baseline_test.go

@@ -0,0 +1,36 @@
+package cmdiotest_test
+
+import (
+	"testing"
+
+	"github.com/databricks/cli/libs/cmdio"
+	"github.com/databricks/cli/libs/cmdio/cmdiotest/termtest"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// TestPromptBaseline_CtrlFCtrlB pins that Ctrl+F and Ctrl+B move the cursor
+// one character forward and backward in [cmdio.RunPrompt], the same as the
+// right and left arrow keys. The emacs-style bindings are de-facto aliases
+// for the arrow keys; this test pins that equivalence.
+func TestPromptBaseline_CtrlFCtrlB(t *testing.T) {
+	t.Parallel()
+	tm := termtest.NewPrompt(t, cmdio.PromptOptions{
+		Label: "Workspace name",
+	})
+	tm.WaitFor("Workspace name")
+	tm.Type("hello")
+	tm.Golden("01-cursor-end")
+
+	tm.Type(termtest.KeyCtrlB)
+	tm.Type(termtest.KeyCtrlB)
+	tm.Golden("02-after-ctrl-b-twice")
+
+	tm.Type(termtest.KeyCtrlF)
+	tm.Golden("03-after-ctrl-f")
+
+	tm.Type(termtest.KeyEnter)
+	v, err := tm.Result()
+	require.NoError(t, err, "raw output: %q", tm.Raw())
+	assert.Equal(t, "hello", v)
+}

libs/cmdio/cmdiotest/prompt_ctrl_h_baseline_test.go

@@ -0,0 +1,35 @@
+package cmdiotest_test
+
+import (
+	"testing"
+
+	"github.com/databricks/cli/libs/cmdio"
+	"github.com/databricks/cli/libs/cmdio/cmdiotest/termtest"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// TestPromptBaseline_CtrlH pins that Ctrl+H deletes the character to the
+// left of the cursor in [cmdio.RunPrompt] — the same as the Backspace key.
+// Ctrl+H sends BS (0x08) and Backspace sends DEL (0x7f); the prompt model
+// handles both as backspace, making the control-character form a de-facto
+// alias. This test pins that equivalence so a future change can't silently
+// drop it.
+func TestPromptBaseline_CtrlH(t *testing.T) {
+	t.Parallel()
+	tm := termtest.NewPrompt(t, cmdio.PromptOptions{
+		Label: "Workspace name",
+	})
+	tm.WaitFor("Workspace name")
+	tm.Type("hello")
+	tm.Golden("01-typed-hello")
+
+	tm.Type(termtest.KeyCtrlH)
+	tm.Type(termtest.KeyCtrlH)
+	tm.Golden("02-after-ctrl-h-twice")
+
+	tm.Type(termtest.KeyEnter)
+	v, err := tm.Result()
+	require.NoError(t, err, "raw output: %q", tm.Raw())
+	assert.Equal(t, "hel", v)
+}

libs/cmdio/cmdiotest/prompt_ctrl_j_baseline_test.go

@@ -0,0 +1,30 @@
+package cmdiotest_test
+
+import (
+	"testing"
+
+	"github.com/databricks/cli/libs/cmdio"
+	"github.com/databricks/cli/libs/cmdio/cmdiotest/termtest"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// TestPromptBaseline_CtrlJ pins that Ctrl+J submits the prompt in
+// [cmdio.RunPrompt] — the same as the Enter (Return) key. Enter sends CR
+// (0x0d) and Ctrl+J sends LF (0x0a); the prompt model treats both as
+// submit. A future change that only reacts to CR would silently swallow
+// Ctrl+J; this test pins the parity.
+func TestPromptBaseline_CtrlJ(t *testing.T) {
+	t.Parallel()
+	tm := termtest.NewPrompt(t, cmdio.PromptOptions{
+		Label: "Workspace name",
+	})
+	tm.WaitFor("Workspace name")
+	tm.Type("hello")
+	tm.Golden("01-typed-hello")
+
+	tm.Type(termtest.KeyCtrlJ)
+	v, err := tm.Result()
+	require.NoError(t, err, "raw output: %q", tm.Raw())
+	assert.Equal(t, "hello", v)
+}

libs/cmdio/cmdiotest/prompt_cursor_editing_baseline_test.go

@@ -0,0 +1,59 @@
+package cmdiotest_test
+
+import (
+	"testing"
+
+	"github.com/databricks/cli/libs/cmdio"
+	"github.com/databricks/cli/libs/cmdio/cmdiotest/termtest"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// TestPromptBaseline_CursorEditing pins how RunPrompt responds to cursor
+// movement and line-editing keys: ←/→, Home/End, Backspace, Ctrl+W, Ctrl+U.
+// The prompt model handles ←/→ and Backspace; Home/End/Ctrl+W/Ctrl+U are
+// no-ops, so the goldens after them are intentionally identical to the
+// post-Backspace one. The Delete key (\x1b[3~) is *not* covered here
+// because it exits the prompt with EOF; that behavior is pinned separately
+// by TestPromptBaseline_DeleteKeyExits.
+func TestPromptBaseline_CursorEditing(t *testing.T) {
+	t.Parallel()
+	tm := termtest.NewPrompt(t, cmdio.PromptOptions{
+		Label: "Workspace name",
+	})
+	tm.WaitFor("Workspace name")
+	tm.Golden("01-empty")
+
+	tm.Type("hello world")
+	tm.Golden("02-typed")
+
+	tm.Type(termtest.KeyHome)
+	tm.Type("X")
+	tm.Golden("03-insert-at-start")
+
+	tm.Type(termtest.KeyEnd)
+	tm.Type("!")
+	tm.Golden("04-insert-at-end")
+
+	tm.Type(termtest.KeyLeft)
+	tm.Type(termtest.KeyLeft)
+	tm.Type("Y")
+	tm.Golden("05-insert-mid")
+
+	tm.Type(termtest.KeyBackspace)
+	tm.Golden("06-after-backspace")
+
+	tm.Type(termtest.KeyCtrlW)
+	tm.Golden("07-after-ctrl-w")
+
+	tm.Type(termtest.KeyCtrlU)
+	tm.Golden("08-after-ctrl-u")
+
+	tm.Type(termtest.KeyEnter)
+
+	v, err := tm.Result()
+	require.NoError(t, err, "raw output: %q", tm.Raw())
+	// The goldens above show the visible buffer is "hello worldX!" when
+	// Enter fires; that's what the prompt returns.
+	assert.Equal(t, "hello worldX!", v, "snapshot:\n%s", tm.Snapshot())
+}

libs/cmdio/cmdiotest/prompt_delete_key_exits_baseline_test.go

@@ -0,0 +1,36 @@
+package cmdiotest_test
+
+import (
+	"io"
+	"testing"
+
+	"github.com/databricks/cli/libs/cmdio"
+	"github.com/databricks/cli/libs/cmdio/cmdiotest/termtest"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// TestPromptBaseline_DeleteKeyExits pins a surprising behavior of
+// [cmdio.RunPrompt]: pressing the Delete key (\x1b[3~) exits the prompt with
+// io.EOF, just like Ctrl+D would on an empty line — and discards any input
+// the user had already typed. The prompt model collapses both keys into the
+// same EOF path; see prompt.go for the rationale. Pinning the behavior here
+// makes sure a future change that splits the two keys is intentional.
+func TestPromptBaseline_DeleteKeyExits(t *testing.T) {
+	t.Parallel()
+	tm := termtest.NewPrompt(t, cmdio.PromptOptions{
+		Label: "Workspace name",
+	})
+	tm.WaitFor("Workspace name")
+
+	// Type some content first to prove the buffer is non-empty from the user's
+	// perspective. This is what makes the behavior surprising: the prompt
+	// still exits even though the user has typed input.
+	tm.Type("hello")
+	tm.Type(termtest.KeyDelete)
+
+	v, err := tm.Result()
+	require.Error(t, err, "raw output: %q", tm.Raw())
+	assert.ErrorIs(t, err, io.EOF)
+	assert.Empty(t, v, "Delete-as-EOF discards typed input")
+}

libs/cmdio/cmdiotest/prompt_hide_entered_baseline_test.go

@@ -0,0 +1,50 @@
+package cmdiotest_test
+
+import (
+	"testing"
+
+	"github.com/databricks/cli/libs/cmdio"
+	"github.com/databricks/cli/libs/cmdio/cmdiotest/termtest"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// TestPromptBaseline_HideEnteredFalse pins the default post-Enter rendering
+// of [cmdio.RunPrompt]: with HideEntered=false (the default), the entered
+// value is shown alongside the label after the prompt closes.
+func TestPromptBaseline_HideEnteredFalse(t *testing.T) {
+	t.Parallel()
+	tm := termtest.NewPrompt(t, cmdio.PromptOptions{
+		Label:       "Workspace name",
+		HideEntered: false,
+	})
+	tm.WaitFor("Workspace name")
+	tm.Type("hello")
+	tm.Type(termtest.KeyEnter)
+
+	v, err := tm.Result()
+	require.NoError(t, err, "raw output: %q", tm.Raw())
+	assert.Equal(t, "hello", v, "snapshot:\n%s", tm.Snapshot())
+
+	tm.Golden("01-after-enter")
+}
+
+// TestPromptBaseline_HideEnteredTrue pins that HideEntered=true clears the
+// prompt frame after the user submits, leaving no trace of the entered value
+// on screen. This is the path used by [cmdio.Secret].
+func TestPromptBaseline_HideEnteredTrue(t *testing.T) {
+	t.Parallel()
+	tm := termtest.NewPrompt(t, cmdio.PromptOptions{
+		Label:       "Workspace name",
+		HideEntered: true,
+	})
+	tm.WaitFor("Workspace name")
+	tm.Type("hello")
+	tm.Type(termtest.KeyEnter)
+
+	v, err := tm.Result()
+	require.NoError(t, err, "raw output: %q", tm.Raw())
+	assert.Equal(t, "hello", v, "snapshot:\n%s", tm.Snapshot())
+
+	tm.Golden("01-after-enter")
+}