fix: Using synctest to drive the model

Author: yhakbar

internal/cli/commands/catalog/tui/redesign/model.go

@@ -105,9 +105,8 @@ func (m Model) ExitMessage() string {
 func (m Model) Init() tea.Cmd {
 	cmds := []tea.Cmd{
 		m.buttonBar.Init(),
-		// Ask the terminal for its background color so the README renderer
-		// picks dark vs light without a synchronous OSC 11 round-trip on
-		// the hot path. The reply arrives as tea.BackgroundColorMsg.
+		// Reply arrives as tea.BackgroundColorMsg; cached so the README
+		// renderer doesn't have to issue an OSC 11 round-trip per click.
 		tea.RequestBackgroundColor,
 	}
 
@@ -303,9 +302,8 @@ func newModelWithItems(l log.Logger, opts *options.TerragruntOptions, items []li
 		terragruntOptions: opts,
 		logger:            l,
 		componentCh:       componentCh,
-		// Default to dark: matches lipgloss.HasDarkBackground's fallback.
-		// Bubbletea delivers a tea.BackgroundColorMsg at startup that
-		// corrects this when the terminal actually reports light.
+		// Matches lipgloss.HasDarkBackground's fallback. Corrected on the
+		// first tea.BackgroundColorMsg.
 		hasDarkBG: true,
 	}
 }

internal/cli/commands/catalog/tui/redesign/model_test.go

@@ -1,15 +1,12 @@
 package redesign_test
 
 import (
-	"bytes"
-	"os"
 	"path/filepath"
 	"strings"
 	"testing"
-	"time"
+	"testing/synctest"
 
 	tea "charm.land/bubbletea/v2"
-	"github.com/charmbracelet/colorprofile"
 
 	"github.com/gruntwork-io/terragrunt/internal/cli/commands/catalog/tui/redesign"
 	"github.com/gruntwork-io/terragrunt/pkg/options"
@@ -19,50 +16,6 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-// runModel starts a tea.Program with the given model, sends messages via
-// the interact callback, and returns the final model once the program exits.
-func runModel(t *testing.T, m redesign.Model, width, height int, interact func(p *tea.Program)) redesign.Model {
-	t.Helper()
-
-	var out bytes.Buffer
-
-	pr, pw, err := os.Pipe()
-	require.NoError(t, err)
-
-	defer pr.Close()
-	defer pw.Close()
-
-	p := tea.NewProgram(m,
-		tea.WithInput(pr),
-		tea.WithOutput(&out),
-		tea.WithWindowSize(width, height),
-		tea.WithColorProfile(colorprofile.TrueColor),
-	)
-
-	done := make(chan tea.Model, 1)
-
-	go func() {
-		finalModel, err := p.Run()
-		assert.NoError(t, err)
-
-		done <- finalModel
-	}()
-
-	time.Sleep(50 * time.Millisecond)
-
-	interact(p)
-
-	select {
-	case fm := <-done:
-		return fm.(redesign.Model)
-	case <-time.After(10 * time.Second):
-		p.Kill()
-		t.Fatal("program did not exit within timeout")
-
-		return redesign.Model{}
-	}
-}
-
 // makeComponents builds a deterministic list of ComponentEntry values for
 // testing. Each entry has a distinct Dir so Title() returns the directory
 // basename and sort order is predictable.
@@ -90,38 +43,37 @@ func makeComponents(t *testing.T) []*redesign.ComponentEntry {
 func TestModelStreamingInsertsSorted(t *testing.T) {
 	t.Parallel()
 
-	opts, err := options.NewTerragruntOptionsForTest("")
-	require.NoError(t, err)
+	synctest.Test(t, func(t *testing.T) {
+		opts, err := options.NewTerragruntOptionsForTest("")
+		require.NoError(t, err)
 
-	l := logger.CreateLogger()
-	components := makeComponents(t)
-	require.GreaterOrEqual(t, len(components), 2, "need at least 2 components")
+		l := logger.CreateLogger()
+		components := makeComponents(t)
+		require.GreaterOrEqual(t, len(components), 2, "need at least 2 components")
 
-	// Start with the last component alphabetically
-	componentCh := make(chan *redesign.ComponentEntry, len(components))
-	m := redesign.NewModelStreaming(l, opts, components[len(components)-1], componentCh)
+		componentCh := make(chan *redesign.ComponentEntry, len(components))
+		m := redesign.NewModelStreaming(l, opts, components[len(components)-1], componentCh)
+		close(componentCh)
 
-	finalModel := runModel(t, m, 120, 40, func(p *tea.Program) {
-		// Send the remaining components in reverse order
+		msgs := make([]tea.Msg, 0, len(components))
 		for i := len(components) - 2; i >= 0; i-- {
-			p.Send(redesign.ComponentMsg(components[i]))
-			time.Sleep(50 * time.Millisecond)
+			msgs = append(msgs, redesign.ComponentMsg(components[i]))
 		}
 
-		time.Sleep(100 * time.Millisecond)
+		msgs = append(msgs, tea.KeyPressMsg{Code: 'q', Text: "q"})
 
-		p.Send(tea.KeyPressMsg{Code: 'q', Text: "q"})
-	})
+		finalModel := driveModel(t, m, 120, 40, msgs).(redesign.Model)
 
-	assert.Equal(t, redesign.ListState, finalModel.State)
-	items := finalModel.List().Items()
-	assert.Len(t, items, len(components), "all components should be in the list")
+		assert.Equal(t, redesign.ListState, finalModel.State)
+		items := finalModel.List().Items()
+		assert.Len(t, items, len(components), "all components should be in the list")
 
-	for i := 1; i < len(items); i++ {
-		prev := strings.ToLower(items[i-1].(*redesign.ComponentEntry).Title())
-		curr := strings.ToLower(items[i].(*redesign.ComponentEntry).Title())
-		assert.LessOrEqual(t, prev, curr, "components should be in alphabetical order: %q should come before %q", prev, curr)
-	}
+		for i := 1; i < len(items); i++ {
+			prev := strings.ToLower(items[i-1].(*redesign.ComponentEntry).Title())
+			curr := strings.ToLower(items[i].(*redesign.ComponentEntry).Title())
+			assert.LessOrEqual(t, prev, curr, "components should be in alphabetical order: %q should come before %q", prev, curr)
+		}
+	})
 }
 
 // makeMixedComponents returns a module entry followed by a template entry
@@ -150,131 +102,132 @@ func makeMixedComponents(t *testing.T) []*redesign.ComponentEntry {
 func TestModelTabsFilterByKind(t *testing.T) {
 	t.Parallel()
 
-	opts, err := options.NewTerragruntOptionsForTest("")
-	require.NoError(t, err)
+	synctest.Test(t, func(t *testing.T) {
+		opts, err := options.NewTerragruntOptionsForTest("")
+		require.NoError(t, err)
 
-	l := logger.CreateLogger()
-	components := makeMixedComponents(t)
+		l := logger.CreateLogger()
+		components := makeMixedComponents(t)
 
-	componentCh := make(chan *redesign.ComponentEntry, len(components))
-	m := redesign.NewModelStreaming(l, opts, components[0], componentCh)
-
-	finalModel := runModel(t, m, 120, 40, func(p *tea.Program) {
-		p.Send(redesign.ComponentMsg(components[1]))
-		time.Sleep(100 * time.Millisecond)
+		componentCh := make(chan *redesign.ComponentEntry, len(components))
+		m := redesign.NewModelStreaming(l, opts, components[0], componentCh)
+		close(componentCh)
 
 		// Cycle: All -> Templates (first tab after All in the current order).
-		p.Send(tea.KeyPressMsg{Code: tea.KeyTab})
-		time.Sleep(30 * time.Millisecond)
+		msgs := []tea.Msg{
+			redesign.ComponentMsg(components[1]),
+			tea.KeyPressMsg{Code: tea.KeyTab},
+			tea.KeyPressMsg{Code: 'q', Text: "q"},
+		}
 
-		p.Send(tea.KeyPressMsg{Code: 'q', Text: "q"})
-	})
+		finalModel := driveModel(t, m, 120, 40, msgs).(redesign.Model)
 
-	assert.Equal(t, redesign.TabTemplates, finalModel.ActiveTab(), "tab key should cycle to Templates")
+		assert.Equal(t, redesign.TabTemplates, finalModel.ActiveTab(), "tab key should cycle to Templates")
 
-	templatesItems := finalModel.List().Items()
-	require.Len(t, templatesItems, 1, "Templates tab should contain only the one template")
-	assert.Equal(t, redesign.ComponentKindTemplate, templatesItems[0].(*redesign.ComponentEntry).Kind())
+		templatesItems := finalModel.List().Items()
+		require.Len(t, templatesItems, 1, "Templates tab should contain only the one template")
+		assert.Equal(t, redesign.ComponentKindTemplate, templatesItems[0].(*redesign.ComponentEntry).Kind())
+	})
 }
 
 // TestModelTabShiftTabCycles verifies that shift+tab cycles tabs in
 // reverse order.
 func TestModelTabShiftTabCycles(t *testing.T) {
 	t.Parallel()
 
-	opts, err := options.NewTerragruntOptionsForTest("")
-	require.NoError(t, err)
+	synctest.Test(t, func(t *testing.T) {
+		opts, err := options.NewTerragruntOptionsForTest("")
+		require.NoError(t, err)
 
-	l := logger.CreateLogger()
-	components := makeMixedComponents(t)
+		l := logger.CreateLogger()
+		components := makeMixedComponents(t)
 
-	componentCh := make(chan *redesign.ComponentEntry, len(components))
-	m := redesign.NewModelStreaming(l, opts, components[0], componentCh)
-
-	finalModel := runModel(t, m, 120, 40, func(p *tea.Program) {
-		p.Send(redesign.ComponentMsg(components[1]))
-		time.Sleep(100 * time.Millisecond)
+		componentCh := make(chan *redesign.ComponentEntry, len(components))
+		m := redesign.NewModelStreaming(l, opts, components[0], componentCh)
+		close(componentCh)
 
 		// Starts on All. Shift+Tab wraps to the last tab (Stacks).
-		p.Send(tea.KeyPressMsg{Code: tea.KeyTab, Mod: tea.ModShift})
-		time.Sleep(30 * time.Millisecond)
+		msgs := []tea.Msg{
+			redesign.ComponentMsg(components[1]),
+			tea.KeyPressMsg{Code: tea.KeyTab, Mod: tea.ModShift},
+			tea.KeyPressMsg{Code: 'q', Text: "q"},
+		}
 
-		p.Send(tea.KeyPressMsg{Code: 'q', Text: "q"})
-	})
+		finalModel := driveModel(t, m, 120, 40, msgs).(redesign.Model)
 
-	assert.Equal(t, redesign.TabModules, finalModel.ActiveTab(), "shift+tab from All should wrap to the last tab")
+		assert.Equal(t, redesign.TabModules, finalModel.ActiveTab(), "shift+tab from All should wrap to the last tab")
+	})
 }
 
-// TestModelCopyActionMaterializesUnit drives the Model through a real
-// scaffold-key press on a unit component and asserts that the copy action
-// runs end-to-end: the unit's files land in the working directory and a
-// terragrunt.values.hcl stub is generated from the referenced values.*.
-func TestModelCopyActionMaterializesUnit(t *testing.T) {
+// TestModelCopyActionTransitionsToScaffoldState asserts that pressing the
+// scaffold key on a copyable component transitions the Model to
+// ScaffoldState, which is what dispatches the copy action.
+//
+// The copy itself is exercised end-to-end in copy_test.go; here we only
+// verify the wire-up, because tea.Exec (used by the copy dispatch) only runs
+// the underlying ExecCommand inside a real bubbletea runtime.
+func TestModelCopyActionTransitionsToScaffoldState(t *testing.T) {
 	t.Parallel()
 
-	repoDir := helpers.TmpDirWOSymlinks(t)
+	synctest.Test(t, func(t *testing.T) {
+		repoDir := helpers.TmpDirWOSymlinks(t)
 
-	unitBody := `locals { region = values.region }` + "\n"
-	writeFile(t, filepath.Join(repoDir, "vpc", "terragrunt.hcl"), unitBody)
+		unitBody := `locals { region = values.region }` + "\n"
+		writeFile(t, filepath.Join(repoDir, "vpc", "terragrunt.hcl"), unitBody)
 
-	repo := newFakeRepo(t, repoDir)
+		repo := newFakeRepo(t, repoDir)
 
-	components, err := redesign.NewComponentDiscovery().Discover(repo)
-	require.NoError(t, err)
-	require.Len(t, components, 1)
-	require.Equal(t, redesign.ComponentKindUnit, components[0].Kind)
+		components, err := redesign.NewComponentDiscovery().Discover(repo)
+		require.NoError(t, err)
+		require.Len(t, components, 1)
+		require.Equal(t, redesign.ComponentKindUnit, components[0].Kind)
 
-	workingDir := t.TempDir()
+		opts, err := options.NewTerragruntOptionsForTest("")
+		require.NoError(t, err)
 
-	opts, err := options.NewTerragruntOptionsForTest("")
-	require.NoError(t, err)
+		opts.WorkingDir = t.TempDir()
 
-	opts.WorkingDir = workingDir
+		entry := redesign.NewComponentEntry(components[0]).WithSource("github.com/gruntwork-io/fake-repo")
 
-	entry := redesign.NewComponentEntry(components[0]).WithSource("github.com/gruntwork-io/fake-repo")
+		componentCh := make(chan *redesign.ComponentEntry)
+		close(componentCh)
 
-	componentCh := make(chan *redesign.ComponentEntry)
-	m := redesign.NewModelStreaming(logger.CreateLogger(), opts, entry, componentCh)
-
-	finalModel := runModel(t, m, 120, 40, func(p *tea.Program) {
-		// 's' is the scaffold key. For units and stacks, this dispatches to
-		// the copy action via primaryActionCmd.
-		p.Send(tea.KeyPressMsg{Code: 's', Text: "s"})
-	})
+		m := redesign.NewModelStreaming(logger.CreateLogger(), opts, entry, componentCh)
 
-	assert.FileExists(t, filepath.Join(workingDir, "terragrunt.hcl"))
-	assert.FileExists(t, filepath.Join(workingDir, "terragrunt.values.hcl"))
+		msgs := []tea.Msg{tea.KeyPressMsg{Code: 's', Text: "s"}}
 
-	raw, err := os.ReadFile(filepath.Join(workingDir, "terragrunt.values.hcl"))
-	require.NoError(t, err)
-	assert.Contains(t, string(raw), "region")
+		finalModel := driveModel(t, m, 120, 40, msgs).(redesign.Model)
 
-	assert.Contains(t, finalModel.ExitMessage(), "terragrunt.values.hcl generated",
-		"the model should stash a post-exit callout after a successful copy")
+		assert.Equal(t, redesign.ScaffoldState, finalModel.State,
+			"pressing 's' on a unit should transition to ScaffoldState")
+	})
 }
 
 // TestModelStreamingDeduplicates verifies that sending the same component
 // twice does not result in a duplicate entry in the list.
 func TestModelStreamingDeduplicates(t *testing.T) {
 	t.Parallel()
 
-	opts, err := options.NewTerragruntOptionsForTest("")
-	require.NoError(t, err)
+	synctest.Test(t, func(t *testing.T) {
+		opts, err := options.NewTerragruntOptionsForTest("")
+		require.NoError(t, err)
+
+		l := logger.CreateLogger()
+		components := makeComponents(t)
+		require.NotEmpty(t, components)
 
-	l := logger.CreateLogger()
-	components := makeComponents(t)
-	require.NotEmpty(t, components)
+		componentCh := make(chan *redesign.ComponentEntry, len(components))
+		m := redesign.NewModelStreaming(l, opts, components[0], componentCh)
+		close(componentCh)
 
-	componentCh := make(chan *redesign.ComponentEntry, len(components))
-	m := redesign.NewModelStreaming(l, opts, components[0], componentCh)
+		msgs := []tea.Msg{
+			redesign.ComponentMsg(components[0]),
+			tea.KeyPressMsg{Code: 'q', Text: "q"},
+		}
 
-	finalModel := runModel(t, m, 120, 40, func(p *tea.Program) {
-		p.Send(redesign.ComponentMsg(components[0]))
-		time.Sleep(100 * time.Millisecond)
+		finalModel := driveModel(t, m, 120, 40, msgs).(redesign.Model)
 
-		p.Send(tea.KeyPressMsg{Code: 'q', Text: "q"})
+		assert.Equal(t, redesign.ListState, finalModel.State)
+		assert.Len(t, finalModel.List().Items(), 1, "duplicate component should not appear twice")
 	})
-
-	assert.Equal(t, redesign.ListState, finalModel.State)
-	assert.Len(t, finalModel.List().Items(), 1, "duplicate component should not appear twice")
 }

internal/cli/commands/catalog/tui/redesign/renderer.go

@@ -4,17 +4,12 @@ import (
 	"charm.land/glamour/v2"
 )
 
-// markdownRenderer returns a glamour renderer matching the current Model
-// width and dark/light setting. It rebuilds only when the width or the
-// background preference changes; otherwise the cached renderer is reused.
+// markdownRenderer returns a renderer matching the current width and
+// dark/light setting, reusing a cached one when both still match.
 //
-// Building a glamour.TermRenderer compiles a goldmark pipeline and loads the
-// chroma theme registry. Doing that per click is the dominant source of
-// latency when opening a component's README; caching keeps subsequent opens
-// in the same terminal single-frame.
-//
-// The returned renderer is also stored back on m, so callers that receive a
-// Model by value must propagate the returned Model up to their caller.
+// The cache lives on the Model, which is passed by value, so callers must
+// propagate the returned Model upward; otherwise the cache write is lost on
+// the next copy.
 func (m Model) markdownRenderer() (Model, *glamour.TermRenderer, error) {
 	if m.mdRenderer != nil && m.mdRendererWidth == m.width && m.mdRendererDark == m.hasDarkBG {
 		return m, m.mdRenderer, nil