refactor(tests): align UI tests with context and layout changes

commit: 56a05c0012a629216626664e117d9e59feb6c2f2
author: brice · 10mo ago · 2025-12-16 17:04 UTC
committer: brice · 10mo ago · 2025-12-16 20:46 UTC
parent: 79f8362
signature: unsigned

6 files · +302 -646

M internal/ui/component/pane_view_test.go +39 -37


@@ -24,10 +24,13 @@ func TestNewPaneView_CreatesOverlay(t *testing.T) {
24	24		mockFactory.EXPECT().NewOverlay().Return(mockOverlay).Once()
25	25		mockOverlay.EXPECT().SetHexpand(true).Once()
26	26		mockOverlay.EXPECT().SetVexpand(true).Once()
	27	+	mockOverlay.EXPECT().SetVisible(true).Once()
	28	+	mockWebView.EXPECT().SetVisible(true).Once()
27	29		mockOverlay.EXPECT().SetChild(mockWebView).Once()
28	30
29	31		mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBorderBox).Once()
30	32		mockBorderBox.EXPECT().SetCanFocus(false).Once()
	33	+	mockBorderBox.EXPECT().SetCanTarget(false).Once()
31	34		mockBorderBox.EXPECT().AddCssClass("pane-border").Once()
32	35		mockBorderBox.EXPECT().SetHexpand(true).Once()
33	36		mockBorderBox.EXPECT().SetVexpand(true).Once()

@@ -55,10 +58,12 @@ func TestNewPaneView_NilWebView(t *testing.T) {
55	58		mockFactory.EXPECT().NewOverlay().Return(mockOverlay).Once()
56	59		mockOverlay.EXPECT().SetHexpand(true).Once()
57	60		mockOverlay.EXPECT().SetVexpand(true).Once()
	61	+	mockOverlay.EXPECT().SetVisible(true).Once()
58	62		// SetChild should NOT be called when webview is nil
59	63
60	64		mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBorderBox).Once()
61	65		mockBorderBox.EXPECT().SetCanFocus(false).Once()
	66	+	mockBorderBox.EXPECT().SetCanTarget(false).Once()
62	67		mockBorderBox.EXPECT().AddCssClass("pane-border").Once()
63	68		mockBorderBox.EXPECT().SetHexpand(true).Once()
64	69		mockBorderBox.EXPECT().SetVexpand(true).Once()

@@ -86,7 +91,7 @@ func TestSetActive_True_AddsCSSClass(t *testing.T) {
86	91		pv := component.NewPaneView(mockFactory, entity.PaneID("pane-1"), mockWebView)
87	92
88	93		// Expect CSS class to be added
89		-	mockBorderBox.EXPECT().AddCssClass("active-pane").Once()
	94	+	mockBorderBox.EXPECT().AddCssClass("pane-active").Once()
90	95
91	96		// Act
92	97		pv.SetActive(true)

@@ -107,11 +112,11 @@ func TestSetActive_False_RemovesCSSClass(t *testing.T) {
107	112		pv := component.NewPaneView(mockFactory, entity.PaneID("pane-1"), mockWebView)
108	113
109	114		// First activate
110		-	mockBorderBox.EXPECT().AddCssClass("active-pane").Once()
	115	+	mockBorderBox.EXPECT().AddCssClass("pane-active").Once()
111	116		pv.SetActive(true)
112	117
113	118		// Then deactivate
114		-	mockBorderBox.EXPECT().RemoveCssClass("active-pane").Once()
	119	+	mockBorderBox.EXPECT().RemoveCssClass("pane-active").Once()
115	120
116	121		// Act
117	122		pv.SetActive(false)

@@ -189,6 +194,8 @@ func TestSetWebViewWidget_ReplacesWidget(t *testing.T) {
189	194
190	195		// Expect removal of old widget and addition of new
191	196		mockOverlay.EXPECT().SetChild(nil).Once()
	197	+	mockNewWebView.EXPECT().GetParent().Return(nil).Once()
	198	+	mockNewWebView.EXPECT().SetVisible(true).Once()
192	199		mockOverlay.EXPECT().SetChild(mockNewWebView).Once()
193	200
194	201		// Act

@@ -205,22 +212,13 @@ func TestSetWebViewWidget_FromNil(t *testing.T) {
205	212		mockBorderBox := mocks.NewMockBoxWidget(t)
206	213		mockNewWebView := mocks.NewMockWidget(t)
207	214
208		-	// Setup without webview
209		-	mockFactory.EXPECT().NewOverlay().Return(mockOverlay).Once()
210		-	mockOverlay.EXPECT().SetHexpand(true).Once()
211		-	mockOverlay.EXPECT().SetVexpand(true).Once()
212		-	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBorderBox).Once()
213		-	mockBorderBox.EXPECT().SetCanFocus(false).Once()
214		-	mockBorderBox.EXPECT().AddCssClass("pane-border").Once()
215		-	mockBorderBox.EXPECT().SetHexpand(true).Once()
216		-	mockBorderBox.EXPECT().SetVexpand(true).Once()
217		-	mockOverlay.EXPECT().AddOverlay(mockBorderBox).Once()
218		-	mockOverlay.EXPECT().SetClipOverlay(mockBorderBox, false).Once()
219		-	mockOverlay.EXPECT().SetMeasureOverlay(mockBorderBox, false).Once()
	215	+	setupPaneViewMocksNoWebView(mockFactory, mockOverlay, mockBorderBox)
220	216
221	217		pv := component.NewPaneView(mockFactory, entity.PaneID("pane-1"), nil)
222	218
223	219		// Expect only setting new child (no removal since old was nil)
	220	+	mockNewWebView.EXPECT().GetParent().Return(nil).Once()
	221	+	mockNewWebView.EXPECT().SetVisible(true).Once()
224	222		mockOverlay.EXPECT().SetChild(mockNewWebView).Once()
225	223
226	224		// Act

@@ -256,17 +254,7 @@ func TestGrabFocus_NilWebView_ReturnsFalse(t *testing.T) {
256	254		mockOverlay := mocks.NewMockOverlayWidget(t)
257	255		mockBorderBox := mocks.NewMockBoxWidget(t)
258	256
259		-	mockFactory.EXPECT().NewOverlay().Return(mockOverlay).Once()
260		-	mockOverlay.EXPECT().SetHexpand(true).Once()
261		-	mockOverlay.EXPECT().SetVexpand(true).Once()
262		-	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBorderBox).Once()
263		-	mockBorderBox.EXPECT().SetCanFocus(false).Once()
264		-	mockBorderBox.EXPECT().AddCssClass("pane-border").Once()
265		-	mockBorderBox.EXPECT().SetHexpand(true).Once()
266		-	mockBorderBox.EXPECT().SetVexpand(true).Once()
267		-	mockOverlay.EXPECT().AddOverlay(mockBorderBox).Once()
268		-	mockOverlay.EXPECT().SetClipOverlay(mockBorderBox, false).Once()
269		-	mockOverlay.EXPECT().SetMeasureOverlay(mockBorderBox, false).Once()
	257	+	setupPaneViewMocksNoWebView(mockFactory, mockOverlay, mockBorderBox)
270	258
271	259		pv := component.NewPaneView(mockFactory, entity.PaneID("pane-1"), nil)
272	260

@@ -303,17 +291,7 @@ func TestHasFocus_NilWebView_ReturnsFalse(t *testing.T) {
303	291		mockOverlay := mocks.NewMockOverlayWidget(t)
304	292		mockBorderBox := mocks.NewMockBoxWidget(t)
305	293
306		-	mockFactory.EXPECT().NewOverlay().Return(mockOverlay).Once()
307		-	mockOverlay.EXPECT().SetHexpand(true).Once()
308		-	mockOverlay.EXPECT().SetVexpand(true).Once()
309		-	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBorderBox).Once()
310		-	mockBorderBox.EXPECT().SetCanFocus(false).Once()
311		-	mockBorderBox.EXPECT().AddCssClass("pane-border").Once()
312		-	mockBorderBox.EXPECT().SetHexpand(true).Once()
313		-	mockBorderBox.EXPECT().SetVexpand(true).Once()
314		-	mockOverlay.EXPECT().AddOverlay(mockBorderBox).Once()
315		-	mockOverlay.EXPECT().SetClipOverlay(mockBorderBox, false).Once()
316		-	mockOverlay.EXPECT().SetMeasureOverlay(mockBorderBox, false).Once()
	294	+	setupPaneViewMocksNoWebView(mockFactory, mockOverlay, mockBorderBox)
317	295
318	296		pv := component.NewPaneView(mockFactory, entity.PaneID("pane-1"), nil)
319	297

@@ -525,10 +503,34 @@ func setupPaneViewMocks(
525	503		mockFactory.EXPECT().NewOverlay().Return(mockOverlay).Once()
526	504		mockOverlay.EXPECT().SetHexpand(true).Once()
527	505		mockOverlay.EXPECT().SetVexpand(true).Once()
	506	+	mockOverlay.EXPECT().SetVisible(true).Once()
	507	+	mockWebView.EXPECT().SetVisible(true).Once()
528	508		mockOverlay.EXPECT().SetChild(mockWebView).Once()
529	509
530	510		mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBorderBox).Once()
531	511		mockBorderBox.EXPECT().SetCanFocus(false).Once()
	512	+	mockBorderBox.EXPECT().SetCanTarget(false).Once()
	513	+	mockBorderBox.EXPECT().AddCssClass("pane-border").Once()
	514	+	mockBorderBox.EXPECT().SetHexpand(true).Once()
	515	+	mockBorderBox.EXPECT().SetVexpand(true).Once()
	516	+	mockOverlay.EXPECT().AddOverlay(mockBorderBox).Once()
	517	+	mockOverlay.EXPECT().SetClipOverlay(mockBorderBox, false).Once()
	518	+	mockOverlay.EXPECT().SetMeasureOverlay(mockBorderBox, false).Once()
	519	+	}
	520	+
	521	+	func setupPaneViewMocksNoWebView(
	522	+	mockFactory *mocks.MockWidgetFactory,
	523	+	mockOverlay *mocks.MockOverlayWidget,
	524	+	mockBorderBox *mocks.MockBoxWidget,
	525	+	) {
	526	+	mockFactory.EXPECT().NewOverlay().Return(mockOverlay).Once()
	527	+	mockOverlay.EXPECT().SetHexpand(true).Once()
	528	+	mockOverlay.EXPECT().SetVexpand(true).Once()
	529	+	mockOverlay.EXPECT().SetVisible(true).Once()
	530	+
	531	+	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBorderBox).Once()
	532	+	mockBorderBox.EXPECT().SetCanFocus(false).Once()
	533	+	mockBorderBox.EXPECT().SetCanTarget(false).Once()
532	534		mockBorderBox.EXPECT().AddCssClass("pane-border").Once()
533	535		mockBorderBox.EXPECT().SetHexpand(true).Once()
534	536		mockBorderBox.EXPECT().SetVexpand(true).Once()

 	mockFactory.EXPECT().NewOverlay().Return(mockOverlay).Once()
 	mockOverlay.EXPECT().SetHexpand(true).Once()
 	mockOverlay.EXPECT().SetVexpand(true).Once()
+	mockOverlay.EXPECT().SetVisible(true).Once()
+	mockWebView.EXPECT().SetVisible(true).Once()
 	mockOverlay.EXPECT().SetChild(mockWebView).Once()
 	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBorderBox).Once()
 	mockBorderBox.EXPECT().SetCanFocus(false).Once()
+	mockBorderBox.EXPECT().SetCanTarget(false).Once()
 	mockBorderBox.EXPECT().AddCssClass("pane-border").Once()
 	mockBorderBox.EXPECT().SetHexpand(true).Once()
 	mockBorderBox.EXPECT().SetVexpand(true).Once()
 	mockFactory.EXPECT().NewOverlay().Return(mockOverlay).Once()
 	mockOverlay.EXPECT().SetHexpand(true).Once()
 	mockOverlay.EXPECT().SetVexpand(true).Once()
+	mockOverlay.EXPECT().SetVisible(true).Once()
 	// SetChild should NOT be called when webview is nil
 	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBorderBox).Once()
 	mockBorderBox.EXPECT().SetCanFocus(false).Once()
+	mockBorderBox.EXPECT().SetCanTarget(false).Once()
 	mockBorderBox.EXPECT().AddCssClass("pane-border").Once()
 	mockBorderBox.EXPECT().SetHexpand(true).Once()
 	mockBorderBox.EXPECT().SetVexpand(true).Once()
 	pv := component.NewPaneView(mockFactory, entity.PaneID("pane-1"), mockWebView)
 	// Expect CSS class to be added
-	mockBorderBox.EXPECT().AddCssClass("active-pane").Once()
+	mockBorderBox.EXPECT().AddCssClass("pane-active").Once()
 	// Act
 	pv.SetActive(true)
 	pv := component.NewPaneView(mockFactory, entity.PaneID("pane-1"), mockWebView)
 	// First activate
-	mockBorderBox.EXPECT().AddCssClass("active-pane").Once()
+	mockBorderBox.EXPECT().AddCssClass("pane-active").Once()
 	pv.SetActive(true)
 	// Then deactivate
-	mockBorderBox.EXPECT().RemoveCssClass("active-pane").Once()
+	mockBorderBox.EXPECT().RemoveCssClass("pane-active").Once()
 	// Act
 	pv.SetActive(false)
 	// Expect removal of old widget and addition of new
 	mockOverlay.EXPECT().SetChild(nil).Once()
+	mockNewWebView.EXPECT().GetParent().Return(nil).Once()
+	mockNewWebView.EXPECT().SetVisible(true).Once()
 	mockOverlay.EXPECT().SetChild(mockNewWebView).Once()
 	// Act
 	mockBorderBox := mocks.NewMockBoxWidget(t)
 	mockNewWebView := mocks.NewMockWidget(t)
-	// Setup without webview
+	setupPaneViewMocksNoWebView(mockFactory, mockOverlay, mockBorderBox)
-	mockFactory.EXPECT().NewOverlay().Return(mockOverlay).Once()
-	mockOverlay.EXPECT().SetHexpand(true).Once()
-	mockOverlay.EXPECT().SetVexpand(true).Once()
-	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBorderBox).Once()
-	mockBorderBox.EXPECT().SetCanFocus(false).Once()
-	mockBorderBox.EXPECT().AddCssClass("pane-border").Once()
-	mockBorderBox.EXPECT().SetHexpand(true).Once()
-	mockBorderBox.EXPECT().SetVexpand(true).Once()
-	mockOverlay.EXPECT().AddOverlay(mockBorderBox).Once()
-	mockOverlay.EXPECT().SetClipOverlay(mockBorderBox, false).Once()
-	mockOverlay.EXPECT().SetMeasureOverlay(mockBorderBox, false).Once()
 	pv := component.NewPaneView(mockFactory, entity.PaneID("pane-1"), nil)
 	// Expect only setting new child (no removal since old was nil)
+	mockNewWebView.EXPECT().GetParent().Return(nil).Once()
+	mockNewWebView.EXPECT().SetVisible(true).Once()
 	mockOverlay.EXPECT().SetChild(mockNewWebView).Once()
 	// Act
 	mockOverlay := mocks.NewMockOverlayWidget(t)
 	mockBorderBox := mocks.NewMockBoxWidget(t)
-	mockFactory.EXPECT().NewOverlay().Return(mockOverlay).Once()
+	setupPaneViewMocksNoWebView(mockFactory, mockOverlay, mockBorderBox)
-	mockOverlay.EXPECT().SetHexpand(true).Once()
-	mockOverlay.EXPECT().SetVexpand(true).Once()
-	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBorderBox).Once()
-	mockBorderBox.EXPECT().SetCanFocus(false).Once()
-	mockBorderBox.EXPECT().AddCssClass("pane-border").Once()
-	mockBorderBox.EXPECT().SetHexpand(true).Once()
-	mockBorderBox.EXPECT().SetVexpand(true).Once()
-	mockOverlay.EXPECT().AddOverlay(mockBorderBox).Once()
-	mockOverlay.EXPECT().SetClipOverlay(mockBorderBox, false).Once()
-	mockOverlay.EXPECT().SetMeasureOverlay(mockBorderBox, false).Once()
 	pv := component.NewPaneView(mockFactory, entity.PaneID("pane-1"), nil)
 	mockOverlay := mocks.NewMockOverlayWidget(t)
 	mockBorderBox := mocks.NewMockBoxWidget(t)
-	mockFactory.EXPECT().NewOverlay().Return(mockOverlay).Once()
+	setupPaneViewMocksNoWebView(mockFactory, mockOverlay, mockBorderBox)
-	mockOverlay.EXPECT().SetHexpand(true).Once()
-	mockOverlay.EXPECT().SetVexpand(true).Once()
-	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBorderBox).Once()
-	mockBorderBox.EXPECT().SetCanFocus(false).Once()
-	mockBorderBox.EXPECT().AddCssClass("pane-border").Once()
-	mockBorderBox.EXPECT().SetHexpand(true).Once()
-	mockBorderBox.EXPECT().SetVexpand(true).Once()
-	mockOverlay.EXPECT().AddOverlay(mockBorderBox).Once()
-	mockOverlay.EXPECT().SetClipOverlay(mockBorderBox, false).Once()
-	mockOverlay.EXPECT().SetMeasureOverlay(mockBorderBox, false).Once()
 	pv := component.NewPaneView(mockFactory, entity.PaneID("pane-1"), nil)
 	mockFactory.EXPECT().NewOverlay().Return(mockOverlay).Once()
 	mockOverlay.EXPECT().SetHexpand(true).Once()
 	mockOverlay.EXPECT().SetVexpand(true).Once()
+	mockOverlay.EXPECT().SetVisible(true).Once()
+	mockWebView.EXPECT().SetVisible(true).Once()
 	mockOverlay.EXPECT().SetChild(mockWebView).Once()
 	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBorderBox).Once()
 	mockBorderBox.EXPECT().SetCanFocus(false).Once()
+	mockBorderBox.EXPECT().SetCanTarget(false).Once()
+	mockBorderBox.EXPECT().AddCssClass("pane-border").Once()
+	mockBorderBox.EXPECT().SetHexpand(true).Once()
+	mockBorderBox.EXPECT().SetVexpand(true).Once()
+	mockOverlay.EXPECT().AddOverlay(mockBorderBox).Once()
+	mockOverlay.EXPECT().SetClipOverlay(mockBorderBox, false).Once()
+	mockOverlay.EXPECT().SetMeasureOverlay(mockBorderBox, false).Once()
+}
+func setupPaneViewMocksNoWebView(
+	mockFactory *mocks.MockWidgetFactory,
+	mockOverlay *mocks.MockOverlayWidget,
+	mockBorderBox *mocks.MockBoxWidget,
+) {
+	mockFactory.EXPECT().NewOverlay().Return(mockOverlay).Once()
+	mockOverlay.EXPECT().SetHexpand(true).Once()
+	mockOverlay.EXPECT().SetVexpand(true).Once()
+	mockOverlay.EXPECT().SetVisible(true).Once()
+	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBorderBox).Once()
+	mockBorderBox.EXPECT().SetCanFocus(false).Once()
+	mockBorderBox.EXPECT().SetCanTarget(false).Once()
 	mockBorderBox.EXPECT().AddCssClass("pane-border").Once()
 	mockBorderBox.EXPECT().SetHexpand(true).Once()
 	mockBorderBox.EXPECT().SetVexpand(true).Once()

M internal/ui/component/workspace_view_test.go +119 -509

@@ -1,9 +1,9 @@
1	1		package component_test
2	2
3	3		import (
	4	+	"context"
4	5		"testing"
5	6
6		-	"github.com/rs/zerolog"
7	7		"github.com/stretchr/testify/assert"
8	8		"github.com/stretchr/testify/mock"
9	9		"github.com/stretchr/testify/require"

@@ -14,65 +14,37 @@ import (
14	14		"github.com/bnema/dumber/internal/ui/layout/mocks"
15	15		)
16	16
17		-	func TestNewWorkspaceView_CreatesEmptyContainer(t *testing.T) {
18		-	// Arrange
19		-	mockFactory := mocks.NewMockWidgetFactory(t)
20		-	mockBox := mocks.NewMockBoxWidget(t)
21		-
22		-	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBox).Once()
23		-	mockBox.EXPECT().SetHexpand(true).Once()
24		-	mockBox.EXPECT().SetVexpand(true).Once()
25		-
26		-	// Act
27		-	wv := component.NewWorkspaceView(mockFactory, zerolog.Nop())
28		-
29		-	// Assert
30		-	require.NotNil(t, wv)
31		-	assert.Equal(t, 0, wv.PaneCount())
32		-	assert.Equal(t, mockBox, wv.Container())
33		-	}
34		-
35		-	func TestSetWorkspace_NilWorkspace_ReturnsError(t *testing.T) {
36		-	// Arrange
37		-	mockFactory := mocks.NewMockWidgetFactory(t)
38		-	mockBox := mocks.NewMockBoxWidget(t)
39		-
40		-	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBox).Once()
41		-	mockBox.EXPECT().SetHexpand(true).Once()
42		-	mockBox.EXPECT().SetVexpand(true).Once()
	17	+	func setupWorkspaceViewBase(t testing.T, mockFactory mocks.MockWidgetFactory) (context.Context, mocks.MockBoxWidget, mocks.MockOverlayWidget) {
	18	+	ctx := context.Background()
	19	+	mockContainer := mocks.NewMockBoxWidget(t)
	20	+	mockOverlay := mocks.NewMockOverlayWidget(t)
43	21
44		-	wv := component.NewWorkspaceView(mockFactory, zerolog.Nop())
	22	+	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockContainer).Once()
	23	+	mockContainer.EXPECT().SetHexpand(true).Once()
	24	+	mockContainer.EXPECT().SetVexpand(true).Once()
	25	+	mockContainer.EXPECT().SetVisible(true).Once()
45	26
46		-	// Act
47		-	err := wv.SetWorkspace(nil)
	27	+	mockFactory.EXPECT().NewOverlay().Return(mockOverlay).Once()
	28	+	mockOverlay.EXPECT().SetHexpand(true).Once()
	29	+	mockOverlay.EXPECT().SetVexpand(true).Once()
	30	+	mockOverlay.EXPECT().SetChild(mockContainer).Once()
	31	+	mockOverlay.EXPECT().SetVisible(true).Once()
48	32
49		-	// Assert
50		-	assert.ErrorIs(t, err, component.ErrNilWorkspace)
	33	+	return ctx, mockContainer, mockOverlay
51	34		}
52	35
53		-	func TestSetWorkspace_SinglePane_CreatesPaneView(t *testing.T) {
54		-	// Arrange
55		-	mockFactory := mocks.NewMockWidgetFactory(t)
56		-	mockBox := mocks.NewMockBoxWidget(t)
57		-
58		-	// Container creation
59		-	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBox).Once()
60		-	mockBox.EXPECT().SetHexpand(true).Once()
61		-	mockBox.EXPECT().SetVexpand(true).Once()
62		-
63		-	wv := component.NewWorkspaceView(mockFactory, zerolog.Nop())
64		-
65		-	// PaneView creation (via paneViewFactoryAdapter)
	36	+	func setupWorkspacePaneViewMocks(t testing.T, mockFactory mocks.MockWidgetFactory) (mocks.MockOverlayWidget, mocks.MockBoxWidget) {
66	37		mockOverlay := mocks.NewMockOverlayWidget(t)
67	38		mockBorderBox := mocks.NewMockBoxWidget(t)
68	39
69	40		mockFactory.EXPECT().NewOverlay().Return(mockOverlay).Once()
70	41		mockOverlay.EXPECT().SetHexpand(true).Once()
71	42		mockOverlay.EXPECT().SetVexpand(true).Once()
72		-	// No SetChild since WebView is nil
	43	+	mockOverlay.EXPECT().SetVisible(true).Once()
73	44
74	45		mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBorderBox).Once()
75	46		mockBorderBox.EXPECT().SetCanFocus(false).Once()
	47	+	mockBorderBox.EXPECT().SetCanTarget(false).Once()
76	48		mockBorderBox.EXPECT().AddCssClass("pane-border").Once()
77	49		mockBorderBox.EXPECT().SetHexpand(true).Once()
78	50		mockBorderBox.EXPECT().SetVexpand(true).Once()

@@ -80,268 +52,156 @@ func TestSetWorkspace_SinglePane_CreatesPaneView(t *testing.T) {
80	52		mockOverlay.EXPECT().SetClipOverlay(mockBorderBox, false).Once()
81	53		mockOverlay.EXPECT().SetMeasureOverlay(mockBorderBox, false).Once()
82	54
83		-	// Widget appended to container
84		-	mockBox.EXPECT().Append(mockOverlay).Once()
85		-
86		-	// Active state set
87		-	mockBorderBox.EXPECT().AddCssClass("active-pane").Once()
88		-
89		-	pane := entity.NewPane(entity.PaneID("pane-1"))
90		-	node := &entity.PaneNode{ID: "node-1", Pane: pane}
91		-
92		-	ws := &entity.Workspace{
93		-	ID: "ws-1",
94		-	Root: node,
95		-	ActivePaneID: pane.ID,
96		-	}
97		-
98		-	// Act
99		-	err := wv.SetWorkspace(ws)
100		-
101		-	// Assert
102		-	require.NoError(t, err)
103		-	assert.Equal(t, 1, wv.PaneCount())
104		-	assert.Equal(t, pane.ID, wv.GetActivePaneID())
105		-	assert.NotNil(t, wv.GetPaneView(pane.ID))
	55	+	return mockOverlay, mockBorderBox
106	56		}
107	57
108		-	func TestSetActivePaneID_UpdatesStyling(t *testing.T) {
109		-	// Arrange
110		-	mockFactory := mocks.NewMockWidgetFactory(t)
111		-	mockBox := mocks.NewMockBoxWidget(t)
	58	+	func setupStackedLeafMocks(
	59	+	t *testing.T,
	60	+	mockFactory *mocks.MockWidgetFactory,
	61	+	container *mocks.MockOverlayWidget,
	62	+	) (mocks.MockBoxWidget, mocks.MockBoxWidget) {
	63	+	mockStackBox := mocks.NewMockBoxWidget(t)
	64	+	mockTitleBar := mocks.NewMockBoxWidget(t)
	65	+	mockFavicon := mocks.NewMockImageWidget(t)
	66	+	mockLabel := mocks.NewMockLabelWidget(t)
	67	+	mockButton := mocks.NewMockButtonWidget(t)
112	68
113		-	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBox).Once()
114		-	mockBox.EXPECT().SetHexpand(true).Once()
115		-	mockBox.EXPECT().SetVexpand(true).Once()
	69	+	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockStackBox).Once()
	70	+	mockStackBox.EXPECT().SetHexpand(true).Once()
	71	+	mockStackBox.EXPECT().SetVexpand(true).Once()
116	72
117		-	wv := component.NewWorkspaceView(mockFactory, zerolog.Nop())
	73	+	mockFactory.EXPECT().NewBox(layout.OrientationHorizontal, 4).Return(mockTitleBar).Once()
	74	+	mockTitleBar.EXPECT().AddCssClass("stacked-pane-titlebar").Once()
	75	+	mockTitleBar.EXPECT().SetVexpand(false).Once()
118	76
119		-	// Setup two panes
120		-	pane1 := entity.NewPane(entity.PaneID("pane-1"))
121		-	pane2 := entity.NewPane(entity.PaneID("pane-2"))
122		-	node1 := &entity.PaneNode{ID: "node-1", Pane: pane1}
123		-	node2 := &entity.PaneNode{ID: "node-2", Pane: pane2}
124		-
125		-	// Create mock widgets for split
126		-	mockPaned := mocks.NewMockPanedWidget(t)
127		-	mockOverlay1 := mocks.NewMockOverlayWidget(t)
128		-	mockOverlay2 := mocks.NewMockOverlayWidget(t)
129		-	mockBorderBox1 := mocks.NewMockBoxWidget(t)
130		-	mockBorderBox2 := mocks.NewMockBoxWidget(t)
131		-
132		-	// First pane view creation
133		-	mockFactory.EXPECT().NewOverlay().Return(mockOverlay1).Once()
134		-	mockOverlay1.EXPECT().SetHexpand(true).Once()
135		-	mockOverlay1.EXPECT().SetVexpand(true).Once()
136		-	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBorderBox1).Once()
137		-	mockBorderBox1.EXPECT().SetCanFocus(false).Once()
138		-	mockBorderBox1.EXPECT().AddCssClass("pane-border").Once()
139		-	mockBorderBox1.EXPECT().SetHexpand(true).Once()
140		-	mockBorderBox1.EXPECT().SetVexpand(true).Once()
141		-	mockOverlay1.EXPECT().AddOverlay(mockBorderBox1).Once()
142		-	mockOverlay1.EXPECT().SetClipOverlay(mockBorderBox1, false).Once()
143		-	mockOverlay1.EXPECT().SetMeasureOverlay(mockBorderBox1, false).Once()
144		-
145		-	// Second pane view creation
146		-	mockFactory.EXPECT().NewOverlay().Return(mockOverlay2).Once()
147		-	mockOverlay2.EXPECT().SetHexpand(true).Once()
148		-	mockOverlay2.EXPECT().SetVexpand(true).Once()
149		-	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBorderBox2).Once()
150		-	mockBorderBox2.EXPECT().SetCanFocus(false).Once()
151		-	mockBorderBox2.EXPECT().AddCssClass("pane-border").Once()
152		-	mockBorderBox2.EXPECT().SetHexpand(true).Once()
153		-	mockBorderBox2.EXPECT().SetVexpand(true).Once()
154		-	mockOverlay2.EXPECT().AddOverlay(mockBorderBox2).Once()
155		-	mockOverlay2.EXPECT().SetClipOverlay(mockBorderBox2, false).Once()
156		-	mockOverlay2.EXPECT().SetMeasureOverlay(mockBorderBox2, false).Once()
	77	+	mockFactory.EXPECT().NewImage().Return(mockFavicon).Once()
	78	+	mockFavicon.EXPECT().SetFromIconName(mock.Anything).Once()
	79	+	mockFavicon.EXPECT().SetPixelSize(16).Once()
	80	+	mockTitleBar.EXPECT().Append(mockFavicon).Once()
157	81
158		-	// Split view creation
159		-	mockFactory.EXPECT().NewPaned(layout.OrientationHorizontal).Return(mockPaned).Once()
160		-	mockPaned.EXPECT().SetResizeStartChild(true).Once()
161		-	mockPaned.EXPECT().SetResizeEndChild(true).Once()
162		-	mockPaned.EXPECT().SetShrinkStartChild(false).Once()
163		-	mockPaned.EXPECT().SetShrinkEndChild(false).Once()
164		-	mockPaned.EXPECT().SetStartChild(mockOverlay1).Once()
165		-	mockPaned.EXPECT().SetEndChild(mockOverlay2).Once()
166		-	mockPaned.EXPECT().GetAllocatedWidth().Return(0).Once()
167		-	mockPaned.EXPECT().ConnectMap(mock.Anything).Return(uint32(0)).Once()
168		-	mockPaned.EXPECT().AddTickCallback(mock.Anything).Return(uint(0)).Once()
	82	+	mockFactory.EXPECT().NewLabel(mock.Anything).Return(mockLabel).Once()
	83	+	mockLabel.EXPECT().SetEllipsize(layout.EllipsizeEnd).Once()
	84	+	mockLabel.EXPECT().SetMaxWidthChars(30).Once()
	85	+	mockLabel.EXPECT().SetHexpand(true).Once()
	86	+	mockLabel.EXPECT().SetXalign(float32(0.0)).Once()
	87	+	mockTitleBar.EXPECT().Append(mockLabel).Once()
169	88
170		-	mockBox.EXPECT().Append(mockPaned).Once()
	89	+	mockFactory.EXPECT().NewButton().Return(mockButton).Once()
	90	+	mockButton.EXPECT().SetChild(mockTitleBar).Once()
	91	+	mockButton.EXPECT().AddCssClass("stacked-pane-title-button").Once()
	92	+	mockButton.EXPECT().SetFocusOnClick(false).Once()
	93	+	mockButton.EXPECT().SetVexpand(false).Once()
	94	+	mockButton.EXPECT().SetHexpand(true).Once()
	95	+	mockButton.EXPECT().ConnectClicked(mock.Anything).Return(uint32(1)).Once()
171	96
172		-	// Initial active pane is pane-1
173		-	mockBorderBox1.EXPECT().AddCssClass("active-pane").Once()
	97	+	mockStackBox.EXPECT().Append(mockButton).Once()
	98	+	mockStackBox.EXPECT().Append(container).Once()
174	99
175		-	splitNode := &entity.PaneNode{
176		-	ID: "split",
177		-	SplitDir: entity.SplitHorizontal,
178		-	SplitRatio: 0.5,
179		-	Children: []*entity.PaneNode{node1, node2},
180		-	}
	100	+	mockTitleBar.EXPECT().GetParent().Return(nil).Maybe()
	101	+	container.EXPECT().SetVisible(true).Once()
	102	+	mockTitleBar.EXPECT().AddCssClass("active").Once()
181	103
182		-	ws := &entity.Workspace{
183		-	ID: "ws-1",
184		-	Root: splitNode,
185		-	ActivePaneID: pane1.ID,
186		-	}
187		-
188		-	err := wv.SetWorkspace(ws)
189		-	require.NoError(t, err)
	104	+	return mockStackBox, mockTitleBar
	105	+	}
190	106
191		-	// Now change active pane
192		-	mockBorderBox1.EXPECT().RemoveCssClass("active-pane").Once()
193		-	mockBorderBox2.EXPECT().AddCssClass("active-pane").Once()
	107	+	func TestNewWorkspaceView_CreatesEmptyContainer(t *testing.T) {
	108	+	// Arrange
	109	+	mockFactory := mocks.NewMockWidgetFactory(t)
	110	+	ctx, mockBox, _ := setupWorkspaceViewBase(t, mockFactory)
194	111
195	112		// Act
196		-	err = wv.SetActivePaneID(pane2.ID)
	113	+	wv := component.NewWorkspaceView(ctx, mockFactory)
197	114
198	115		// Assert
199		-	require.NoError(t, err)
200		-	assert.Equal(t, pane2.ID, wv.GetActivePaneID())
	116	+	require.NotNil(t, wv)
	117	+	assert.Equal(t, 0, wv.PaneCount())
	118	+	assert.Equal(t, mockBox, wv.Container())
201	119		}
202	120
203		-	func TestSetActivePaneID_InvalidID_ReturnsError(t *testing.T) {
	121	+	func TestSetWorkspace_NilWorkspace_ReturnsError(t *testing.T) {
204	122		// Arrange
205	123		mockFactory := mocks.NewMockWidgetFactory(t)
206		-	mockBox := mocks.NewMockBoxWidget(t)
	124	+	ctx, _, _ := setupWorkspaceViewBase(t, mockFactory)
207	125
208		-	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBox).Once()
209		-	mockBox.EXPECT().SetHexpand(true).Once()
210		-	mockBox.EXPECT().SetVexpand(true).Once()
211		-
212		-	wv := component.NewWorkspaceView(mockFactory, zerolog.Nop())
	126	+	wv := component.NewWorkspaceView(ctx, mockFactory)
213	127
214	128		// Act
215		-	err := wv.SetActivePaneID(entity.PaneID("non-existent"))
	129	+	err := wv.SetWorkspace(ctx, nil)
216	130
217	131		// Assert
218		-	assert.ErrorIs(t, err, component.ErrPaneNotFound)
	132	+	assert.ErrorIs(t, err, component.ErrNilWorkspace)
219	133		}
220	134
221		-	func TestGetPaneView_Existing(t *testing.T) {
	135	+	func TestSetWorkspace_SinglePane_CreatesPaneView(t *testing.T) {
222	136		// Arrange
223	137		mockFactory := mocks.NewMockWidgetFactory(t)
224		-	mockBox := mocks.NewMockBoxWidget(t)
225		-	mockOverlay := mocks.NewMockOverlayWidget(t)
226		-	mockBorderBox := mocks.NewMockBoxWidget(t)
	138	+	ctx, mockBox, _ := setupWorkspaceViewBase(t, mockFactory)
227	139
228		-	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBox).Once()
229		-	mockBox.EXPECT().SetHexpand(true).Once()
230		-	mockBox.EXPECT().SetVexpand(true).Once()
	140	+	wv := component.NewWorkspaceView(ctx, mockFactory)
231	141
232		-	wv := component.NewWorkspaceView(mockFactory, zerolog.Nop())
	142	+	mockOverlay, mockBorderBox := setupWorkspacePaneViewMocks(t, mockFactory)
	143	+	mockStackBox, _ := setupStackedLeafMocks(t, mockFactory, mockOverlay)
233	144
234		-	// PaneView creation
235		-	mockFactory.EXPECT().NewOverlay().Return(mockOverlay).Once()
236		-	mockOverlay.EXPECT().SetHexpand(true).Once()
237		-	mockOverlay.EXPECT().SetVexpand(true).Once()
238		-	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBorderBox).Once()
239		-	mockBorderBox.EXPECT().SetCanFocus(false).Once()
240		-	mockBorderBox.EXPECT().AddCssClass("pane-border").Once()
241		-	mockBorderBox.EXPECT().SetHexpand(true).Once()
242		-	mockBorderBox.EXPECT().SetVexpand(true).Once()
243		-	mockOverlay.EXPECT().AddOverlay(mockBorderBox).Once()
244		-	mockOverlay.EXPECT().SetClipOverlay(mockBorderBox, false).Once()
245		-	mockOverlay.EXPECT().SetMeasureOverlay(mockBorderBox, false).Once()
246		-	mockBox.EXPECT().Append(mockOverlay).Once()
247		-	mockBorderBox.EXPECT().AddCssClass("active-pane").Once()
	145	+	mockStackBox.EXPECT().SetVisible(true).Once()
	146	+	mockBox.EXPECT().Append(mockStackBox).Once()
	147	+	mockBorderBox.EXPECT().AddCssClass("pane-active").Once()
248	148
249	149		pane := entity.NewPane(entity.PaneID("pane-1"))
250	150		node := &entity.PaneNode{ID: "node-1", Pane: pane}
	151	+
251	152		ws := &entity.Workspace{
252	153		ID: "ws-1",
253	154		Root: node,
254	155		ActivePaneID: pane.ID,
255	156		}
256	157
257		-	_ = wv.SetWorkspace(ws)
258		-
259	158		// Act
260		-	result := wv.GetPaneView(pane.ID)
	159	+	err := wv.SetWorkspace(ctx, ws)
261	160
262	161		// Assert
263		-	assert.NotNil(t, result)
	162	+	require.NoError(t, err)
	163	+	assert.Equal(t, 1, wv.PaneCount())
	164	+	assert.Equal(t, pane.ID, wv.GetActivePaneID())
	165	+	assert.NotNil(t, wv.GetPaneView(pane.ID))
264	166		}
265	167
266		-	func TestGetPaneView_NonExistent(t *testing.T) {
	168	+	func TestSetActivePaneID_UpdatesStyling(t *testing.T) {
267	169		// Arrange
268	170		mockFactory := mocks.NewMockWidgetFactory(t)
269		-	mockBox := mocks.NewMockBoxWidget(t)
270		-
271		-	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBox).Once()
272		-	mockBox.EXPECT().SetHexpand(true).Once()
273		-	mockBox.EXPECT().SetVexpand(true).Once()
	171	+	ctx, mockBox, _ := setupWorkspaceViewBase(t, mockFactory)
274	172
275		-	wv := component.NewWorkspaceView(mockFactory, zerolog.Nop())
	173	+	wv := component.NewWorkspaceView(ctx, mockFactory)
276	174
277		-	// Act
278		-	result := wv.GetPaneView(entity.PaneID("non-existent"))
279		-
280		-	// Assert
281		-	assert.Nil(t, result)
282		-	}
	175	+	// Setup two panes
	176	+	pane1 := entity.NewPane(entity.PaneID("pane-1"))
	177	+	pane2 := entity.NewPane(entity.PaneID("pane-2"))
	178	+	node1 := &entity.PaneNode{ID: "node-1", Pane: pane1}
	179	+	node2 := &entity.PaneNode{ID: "node-2", Pane: pane2}
283	180
284		-	func TestGetPaneIDs_ReturnsAllIDs(t *testing.T) {
285		-	// Arrange
286		-	mockFactory := mocks.NewMockWidgetFactory(t)
287		-	mockBox := mocks.NewMockBoxWidget(t)
	181	+	// Create mock widgets for split
288	182		mockPaned := mocks.NewMockPanedWidget(t)
289		-	mockOverlay1 := mocks.NewMockOverlayWidget(t)
290		-	mockOverlay2 := mocks.NewMockOverlayWidget(t)
291		-	mockBorderBox1 := mocks.NewMockBoxWidget(t)
292		-	mockBorderBox2 := mocks.NewMockBoxWidget(t)
293		-
294		-	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBox).Once()
295		-	mockBox.EXPECT().SetHexpand(true).Once()
296		-	mockBox.EXPECT().SetVexpand(true).Once()
297		-
298		-	wv := component.NewWorkspaceView(mockFactory, zerolog.Nop())
299		-
300		-	// First pane view
301		-	mockFactory.EXPECT().NewOverlay().Return(mockOverlay1).Once()
302		-	mockOverlay1.EXPECT().SetHexpand(true).Once()
303		-	mockOverlay1.EXPECT().SetVexpand(true).Once()
304		-	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBorderBox1).Once()
305		-	mockBorderBox1.EXPECT().SetCanFocus(false).Once()
306		-	mockBorderBox1.EXPECT().AddCssClass("pane-border").Once()
307		-	mockBorderBox1.EXPECT().SetHexpand(true).Once()
308		-	mockBorderBox1.EXPECT().SetVexpand(true).Once()
309		-	mockOverlay1.EXPECT().AddOverlay(mockBorderBox1).Once()
310		-	mockOverlay1.EXPECT().SetClipOverlay(mockBorderBox1, false).Once()
311		-	mockOverlay1.EXPECT().SetMeasureOverlay(mockBorderBox1, false).Once()
312		-
313		-	// Second pane view
314		-	mockFactory.EXPECT().NewOverlay().Return(mockOverlay2).Once()
315		-	mockOverlay2.EXPECT().SetHexpand(true).Once()
316		-	mockOverlay2.EXPECT().SetVexpand(true).Once()
317		-	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBorderBox2).Once()
318		-	mockBorderBox2.EXPECT().SetCanFocus(false).Once()
319		-	mockBorderBox2.EXPECT().AddCssClass("pane-border").Once()
320		-	mockBorderBox2.EXPECT().SetHexpand(true).Once()
321		-	mockBorderBox2.EXPECT().SetVexpand(true).Once()
322		-	mockOverlay2.EXPECT().AddOverlay(mockBorderBox2).Once()
323		-	mockOverlay2.EXPECT().SetClipOverlay(mockBorderBox2, false).Once()
324		-	mockOverlay2.EXPECT().SetMeasureOverlay(mockBorderBox2, false).Once()
325		-
326		-	// Split view
	183	+	mockOverlay1, mockBorderBox1 := setupWorkspacePaneViewMocks(t, mockFactory)
	184	+	mockStackBox1, _ := setupStackedLeafMocks(t, mockFactory, mockOverlay1)
	185	+	mockOverlay2, mockBorderBox2 := setupWorkspacePaneViewMocks(t, mockFactory)
	186	+	mockStackBox2, _ := setupStackedLeafMocks(t, mockFactory, mockOverlay2)
	187	+
	188	+	// Split view creation
327	189		mockFactory.EXPECT().NewPaned(layout.OrientationHorizontal).Return(mockPaned).Once()
328	190		mockPaned.EXPECT().SetResizeStartChild(true).Once()
329	191		mockPaned.EXPECT().SetResizeEndChild(true).Once()
330		-	mockPaned.EXPECT().SetShrinkStartChild(false).Once()
331		-	mockPaned.EXPECT().SetShrinkEndChild(false).Once()
332		-	mockPaned.EXPECT().SetStartChild(mockOverlay1).Once()
333		-	mockPaned.EXPECT().SetEndChild(mockOverlay2).Once()
	192	+	mockPaned.EXPECT().SetVisible(true).Twice()
	193	+	mockStackBox1.EXPECT().SetVisible(true).Once()
	194	+	mockStackBox2.EXPECT().SetVisible(true).Once()
	195	+	mockPaned.EXPECT().SetStartChild(mockStackBox1).Once()
	196	+	mockPaned.EXPECT().SetEndChild(mockStackBox2).Once()
334	197		mockPaned.EXPECT().GetAllocatedWidth().Return(0).Once()
335	198		mockPaned.EXPECT().ConnectMap(mock.Anything).Return(uint32(0)).Once()
336	199		mockPaned.EXPECT().AddTickCallback(mock.Anything).Return(uint(0)).Once()
337	200
338	201		mockBox.EXPECT().Append(mockPaned).Once()
339		-	mockBorderBox1.EXPECT().AddCssClass("active-pane").Once()
340	202
341		-	pane1 := entity.NewPane(entity.PaneID("pane-1"))
342		-	pane2 := entity.NewPane(entity.PaneID("pane-2"))
343		-	node1 := &entity.PaneNode{ID: "node-1", Pane: pane1}
344		-	node2 := &entity.PaneNode{ID: "node-2", Pane: pane2}
	203	+	// Initial active pane is pane-1
	204	+	mockBorderBox1.EXPECT().AddCssClass("pane-active").Once()
345	205
346	206		splitNode := &entity.PaneNode{
347	207		ID: "split",

@@ -356,281 +216,31 @@ func TestGetPaneIDs_ReturnsAllIDs(t *testing.T) {
356	216		ActivePaneID: pane1.ID,
357	217		}
358	218
359		-	_ = wv.SetWorkspace(ws)
360		-
361		-	// Act
362		-	ids := wv.GetPaneIDs()
363		-
364		-	// Assert
365		-	assert.Len(t, ids, 2)
366		-	assert.Contains(t, ids, pane1.ID)
367		-	assert.Contains(t, ids, pane2.ID)
368		-	}
369		-
370		-	func TestWidget_ReturnsContainer(t *testing.T) {
371		-	// Arrange
372		-	mockFactory := mocks.NewMockWidgetFactory(t)
373		-	mockBox := mocks.NewMockBoxWidget(t)
374		-
375		-	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBox).Once()
376		-	mockBox.EXPECT().SetHexpand(true).Once()
377		-	mockBox.EXPECT().SetVexpand(true).Once()
378		-
379		-	wv := component.NewWorkspaceView(mockFactory, zerolog.Nop())
380		-
381		-	// Act
382		-	widget := wv.Widget()
383		-
384		-	// Assert
385		-	assert.Equal(t, mockBox, widget)
386		-	}
387		-
388		-	func TestSetOnPaneFocused_SetsCallback(t *testing.T) {
389		-	// Arrange
390		-	mockFactory := mocks.NewMockWidgetFactory(t)
391		-	mockBox := mocks.NewMockBoxWidget(t)
392		-
393		-	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBox).Once()
394		-	mockBox.EXPECT().SetHexpand(true).Once()
395		-	mockBox.EXPECT().SetVexpand(true).Once()
396		-
397		-	wv := component.NewWorkspaceView(mockFactory, zerolog.Nop())
398		-
399		-	callback := func(paneID entity.PaneID) {}
400		-
401		-	// Act
402		-	wv.SetOnPaneFocused(callback)
403		-
404		-	// Assert - callback is set (verified by no panic)
405		-	assert.NotNil(t, wv)
406		-	}
407		-
408		-	func TestSetWebViewWidget_AttachesToPane(t *testing.T) {
409		-	// Arrange
410		-	mockFactory := mocks.NewMockWidgetFactory(t)
411		-	mockBox := mocks.NewMockBoxWidget(t)
412		-	mockOverlay := mocks.NewMockOverlayWidget(t)
413		-	mockBorderBox := mocks.NewMockBoxWidget(t)
414		-	mockWebView := mocks.NewMockWidget(t)
415		-
416		-	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBox).Once()
417		-	mockBox.EXPECT().SetHexpand(true).Once()
418		-	mockBox.EXPECT().SetVexpand(true).Once()
419		-
420		-	wv := component.NewWorkspaceView(mockFactory, zerolog.Nop())
421		-
422		-	// PaneView creation
423		-	mockFactory.EXPECT().NewOverlay().Return(mockOverlay).Once()
424		-	mockOverlay.EXPECT().SetHexpand(true).Once()
425		-	mockOverlay.EXPECT().SetVexpand(true).Once()
426		-	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBorderBox).Once()
427		-	mockBorderBox.EXPECT().SetCanFocus(false).Once()
428		-	mockBorderBox.EXPECT().AddCssClass("pane-border").Once()
429		-	mockBorderBox.EXPECT().SetHexpand(true).Once()
430		-	mockBorderBox.EXPECT().SetVexpand(true).Once()
431		-	mockOverlay.EXPECT().AddOverlay(mockBorderBox).Once()
432		-	mockOverlay.EXPECT().SetClipOverlay(mockBorderBox, false).Once()
433		-	mockOverlay.EXPECT().SetMeasureOverlay(mockBorderBox, false).Once()
434		-	mockBox.EXPECT().Append(mockOverlay).Once()
435		-	mockBorderBox.EXPECT().AddCssClass("active-pane").Once()
436		-
437		-	pane := entity.NewPane(entity.PaneID("pane-1"))
438		-	node := &entity.PaneNode{ID: "node-1", Pane: pane}
439		-	ws := &entity.Workspace{
440		-	ID: "ws-1",
441		-	Root: node,
442		-	ActivePaneID: pane.ID,
443		-	}
444		-
445		-	_ = wv.SetWorkspace(ws)
	219	+	err := wv.SetWorkspace(ctx, ws)
	220	+	require.NoError(t, err)
446	221
447		-	// Expect WebView to be set
448		-	mockOverlay.EXPECT().SetChild(mockWebView).Once()
	222	+	// Now change active pane
	223	+	mockBorderBox1.EXPECT().RemoveCssClass("pane-active").Once()
	224	+	mockBorderBox2.EXPECT().AddCssClass("pane-active").Once()
449	225
450	226		// Act
451		-	err := wv.SetWebViewWidget(pane.ID, mockWebView)
	227	+	err = wv.SetActivePaneID(pane2.ID)
452	228
453	229		// Assert
454	230		require.NoError(t, err)
	231	+	assert.Equal(t, pane2.ID, wv.GetActivePaneID())
455	232		}
456	233
457		-	func TestSetWebViewWidget_NonExistentPane_ReturnsError(t *testing.T) {
	234	+	func TestSetActivePaneID_InvalidID_ReturnsError(t *testing.T) {
458	235		// Arrange
459	236		mockFactory := mocks.NewMockWidgetFactory(t)
460		-	mockBox := mocks.NewMockBoxWidget(t)
461		-	mockWebView := mocks.NewMockWidget(t)
462		-
463		-	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBox).Once()
464		-	mockBox.EXPECT().SetHexpand(true).Once()
465		-	mockBox.EXPECT().SetVexpand(true).Once()
	237	+	ctx, _, _ := setupWorkspaceViewBase(t, mockFactory)
466	238
467		-	wv := component.NewWorkspaceView(mockFactory, zerolog.Nop())
	239	+	wv := component.NewWorkspaceView(ctx, mockFactory)
468	240
469	241		// Act
470		-	err := wv.SetWebViewWidget(entity.PaneID("non-existent"), mockWebView)
	242	+	err := wv.SetActivePaneID(entity.PaneID("non-existent"))
471	243
472	244		// Assert
473	245		assert.ErrorIs(t, err, component.ErrPaneNotFound)
474	246		}
475		-
476		-	func TestFocusPane_DelegatesToPaneView(t *testing.T) {
477		-	// Arrange
478		-	mockFactory := mocks.NewMockWidgetFactory(t)
479		-	mockBox := mocks.NewMockBoxWidget(t)
480		-	mockOverlay := mocks.NewMockOverlayWidget(t)
481		-	mockBorderBox := mocks.NewMockBoxWidget(t)
482		-
483		-	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBox).Once()
484		-	mockBox.EXPECT().SetHexpand(true).Once()
485		-	mockBox.EXPECT().SetVexpand(true).Once()
486		-
487		-	wv := component.NewWorkspaceView(mockFactory, zerolog.Nop())
488		-
489		-	// PaneView creation
490		-	mockFactory.EXPECT().NewOverlay().Return(mockOverlay).Once()
491		-	mockOverlay.EXPECT().SetHexpand(true).Once()
492		-	mockOverlay.EXPECT().SetVexpand(true).Once()
493		-	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBorderBox).Once()
494		-	mockBorderBox.EXPECT().SetCanFocus(false).Once()
495		-	mockBorderBox.EXPECT().AddCssClass("pane-border").Once()
496		-	mockBorderBox.EXPECT().SetHexpand(true).Once()
497		-	mockBorderBox.EXPECT().SetVexpand(true).Once()
498		-	mockOverlay.EXPECT().AddOverlay(mockBorderBox).Once()
499		-	mockOverlay.EXPECT().SetClipOverlay(mockBorderBox, false).Once()
500		-	mockOverlay.EXPECT().SetMeasureOverlay(mockBorderBox, false).Once()
501		-	mockBox.EXPECT().Append(mockOverlay).Once()
502		-	mockBorderBox.EXPECT().AddCssClass("active-pane").Once()
503		-
504		-	pane := entity.NewPane(entity.PaneID("pane-1"))
505		-	node := &entity.PaneNode{ID: "node-1", Pane: pane}
506		-	ws := &entity.Workspace{
507		-	ID: "ws-1",
508		-	Root: node,
509		-	ActivePaneID: pane.ID,
510		-	}
511		-
512		-	_ = wv.SetWorkspace(ws)
513		-
514		-	// Act - FocusPane with nil WebView returns false
515		-	result := wv.FocusPane(pane.ID)
516		-
517		-	// Assert
518		-	assert.False(t, result) // No WebView attached, so GrabFocus fails
519		-	}
520		-
521		-	func TestFocusPane_NonExistentPane_ReturnsFalse(t *testing.T) {
522		-	// Arrange
523		-	mockFactory := mocks.NewMockWidgetFactory(t)
524		-	mockBox := mocks.NewMockBoxWidget(t)
525		-
526		-	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBox).Once()
527		-	mockBox.EXPECT().SetHexpand(true).Once()
528		-	mockBox.EXPECT().SetVexpand(true).Once()
529		-
530		-	wv := component.NewWorkspaceView(mockFactory, zerolog.Nop())
531		-
532		-	// Act
533		-	result := wv.FocusPane(entity.PaneID("non-existent"))
534		-
535		-	// Assert
536		-	assert.False(t, result)
537		-	}
538		-
539		-	func TestRebuild_NilWorkspace_ReturnsError(t *testing.T) {
540		-	// Arrange
541		-	mockFactory := mocks.NewMockWidgetFactory(t)
542		-	mockBox := mocks.NewMockBoxWidget(t)
543		-
544		-	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBox).Once()
545		-	mockBox.EXPECT().SetHexpand(true).Once()
546		-	mockBox.EXPECT().SetVexpand(true).Once()
547		-
548		-	wv := component.NewWorkspaceView(mockFactory, zerolog.Nop())
549		-
550		-	// Act
551		-	err := wv.Rebuild()
552		-
553		-	// Assert
554		-	assert.ErrorIs(t, err, component.ErrNilWorkspace)
555		-	}
556		-
557		-	func TestTreeRenderer_ReturnsRenderer(t *testing.T) {
558		-	// Arrange
559		-	mockFactory := mocks.NewMockWidgetFactory(t)
560		-	mockBox := mocks.NewMockBoxWidget(t)
561		-
562		-	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBox).Once()
563		-	mockBox.EXPECT().SetHexpand(true).Once()
564		-	mockBox.EXPECT().SetVexpand(true).Once()
565		-
566		-	wv := component.NewWorkspaceView(mockFactory, zerolog.Nop())
567		-
568		-	// Act
569		-	renderer := wv.TreeRenderer()
570		-
571		-	// Assert
572		-	assert.NotNil(t, renderer)
573		-	}
574		-
575		-	func TestWorkspace_ReturnsCurrentWorkspace(t *testing.T) {
576		-	// Arrange
577		-	mockFactory := mocks.NewMockWidgetFactory(t)
578		-	mockBox := mocks.NewMockBoxWidget(t)
579		-	mockOverlay := mocks.NewMockOverlayWidget(t)
580		-	mockBorderBox := mocks.NewMockBoxWidget(t)
581		-
582		-	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBox).Once()
583		-	mockBox.EXPECT().SetHexpand(true).Once()
584		-	mockBox.EXPECT().SetVexpand(true).Once()
585		-
586		-	wv := component.NewWorkspaceView(mockFactory, zerolog.Nop())
587		-
588		-	// PaneView creation
589		-	mockFactory.EXPECT().NewOverlay().Return(mockOverlay).Once()
590		-	mockOverlay.EXPECT().SetHexpand(true).Once()
591		-	mockOverlay.EXPECT().SetVexpand(true).Once()
592		-	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBorderBox).Once()
593		-	mockBorderBox.EXPECT().SetCanFocus(false).Once()
594		-	mockBorderBox.EXPECT().AddCssClass("pane-border").Once()
595		-	mockBorderBox.EXPECT().SetHexpand(true).Once()
596		-	mockBorderBox.EXPECT().SetVexpand(true).Once()
597		-	mockOverlay.EXPECT().AddOverlay(mockBorderBox).Once()
598		-	mockOverlay.EXPECT().SetClipOverlay(mockBorderBox, false).Once()
599		-	mockOverlay.EXPECT().SetMeasureOverlay(mockBorderBox, false).Once()
600		-	mockBox.EXPECT().Append(mockOverlay).Once()
601		-	mockBorderBox.EXPECT().AddCssClass("active-pane").Once()
602		-
603		-	pane := entity.NewPane(entity.PaneID("pane-1"))
604		-	node := &entity.PaneNode{ID: "node-1", Pane: pane}
605		-	ws := &entity.Workspace{
606		-	ID: "ws-1",
607		-	Root: node,
608		-	ActivePaneID: pane.ID,
609		-	}
610		-
611		-	_ = wv.SetWorkspace(ws)
612		-
613		-	// Act
614		-	result := wv.Workspace()
615		-
616		-	// Assert
617		-	assert.Equal(t, ws, result)
618		-	}
619		-
620		-	func TestWorkspace_NilBeforeSet(t *testing.T) {
621		-	// Arrange
622		-	mockFactory := mocks.NewMockWidgetFactory(t)
623		-	mockBox := mocks.NewMockBoxWidget(t)
624		-
625		-	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBox).Once()
626		-	mockBox.EXPECT().SetHexpand(true).Once()
627		-	mockBox.EXPECT().SetVexpand(true).Once()
628		-
629		-	wv := component.NewWorkspaceView(mockFactory, zerolog.Nop())
630		-
631		-	// Act
632		-	result := wv.Workspace()
633		-
634		-	// Assert
635		-	assert.Nil(t, result)
636		-	}

@@ -1,9 +1,9 @@
1		package component_test	1		package component_test
2			2
3		import (	3		import (
			4	+	"context"
4		"testing"	5		"testing"
5			6
6	-	"github.com/rs/zerolog"
7		"github.com/stretchr/testify/assert"	7		"github.com/stretchr/testify/assert"
8		"github.com/stretchr/testify/mock"	8		"github.com/stretchr/testify/mock"
9		"github.com/stretchr/testify/require"	9		"github.com/stretchr/testify/require"

@@ -14,65 +14,37 @@ import (
14		"github.com/bnema/dumber/internal/ui/layout/mocks"	14		"github.com/bnema/dumber/internal/ui/layout/mocks"
15		)	15		)
16			16
17	-	func TestNewWorkspaceView_CreatesEmptyContainer(t *testing.T) {	17	+	func setupWorkspaceViewBase(t testing.T, mockFactory mocks.MockWidgetFactory) (context.Context, mocks.MockBoxWidget, mocks.MockOverlayWidget) {
18	-	// Arrange	18	+	ctx := context.Background()
19	-	mockFactory := mocks.NewMockWidgetFactory(t)	19	+	mockContainer := mocks.NewMockBoxWidget(t)
20	-	mockBox := mocks.NewMockBoxWidget(t)	20	+	mockOverlay := mocks.NewMockOverlayWidget(t)
21	-
22	-	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBox).Once()
23	-	mockBox.EXPECT().SetHexpand(true).Once()
24	-	mockBox.EXPECT().SetVexpand(true).Once()
25	-
26	-	// Act
27	-	wv := component.NewWorkspaceView(mockFactory, zerolog.Nop())
28	-
29	-	// Assert
30	-	require.NotNil(t, wv)
31	-	assert.Equal(t, 0, wv.PaneCount())
32	-	assert.Equal(t, mockBox, wv.Container())
33	-	}
34	-
35	-	func TestSetWorkspace_NilWorkspace_ReturnsError(t *testing.T) {
36	-	// Arrange
37	-	mockFactory := mocks.NewMockWidgetFactory(t)
38	-	mockBox := mocks.NewMockBoxWidget(t)
39	-
40	-	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBox).Once()
41	-	mockBox.EXPECT().SetHexpand(true).Once()
42	-	mockBox.EXPECT().SetVexpand(true).Once()
43			21
44	-	wv := component.NewWorkspaceView(mockFactory, zerolog.Nop())	22	+	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockContainer).Once()
			23	+	mockContainer.EXPECT().SetHexpand(true).Once()
			24	+	mockContainer.EXPECT().SetVexpand(true).Once()
			25	+	mockContainer.EXPECT().SetVisible(true).Once()
45			26
46	-	// Act	27	+	mockFactory.EXPECT().NewOverlay().Return(mockOverlay).Once()
47	-	err := wv.SetWorkspace(nil)	28	+	mockOverlay.EXPECT().SetHexpand(true).Once()
			29	+	mockOverlay.EXPECT().SetVexpand(true).Once()
			30	+	mockOverlay.EXPECT().SetChild(mockContainer).Once()
			31	+	mockOverlay.EXPECT().SetVisible(true).Once()
48			32
49	-	// Assert	33	+	return ctx, mockContainer, mockOverlay
50	-	assert.ErrorIs(t, err, component.ErrNilWorkspace)
51		}	34		}
52			35
53	-	func TestSetWorkspace_SinglePane_CreatesPaneView(t *testing.T) {	36	+	func setupWorkspacePaneViewMocks(t testing.T, mockFactory mocks.MockWidgetFactory) (mocks.MockOverlayWidget, mocks.MockBoxWidget) {
54	-	// Arrange
55	-	mockFactory := mocks.NewMockWidgetFactory(t)
56	-	mockBox := mocks.NewMockBoxWidget(t)
57	-
58	-	// Container creation
59	-	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBox).Once()
60	-	mockBox.EXPECT().SetHexpand(true).Once()
61	-	mockBox.EXPECT().SetVexpand(true).Once()
62	-
63	-	wv := component.NewWorkspaceView(mockFactory, zerolog.Nop())
64	-
65	-	// PaneView creation (via paneViewFactoryAdapter)
66		mockOverlay := mocks.NewMockOverlayWidget(t)	37		mockOverlay := mocks.NewMockOverlayWidget(t)
67		mockBorderBox := mocks.NewMockBoxWidget(t)	38		mockBorderBox := mocks.NewMockBoxWidget(t)
68			39
69		mockFactory.EXPECT().NewOverlay().Return(mockOverlay).Once()	40		mockFactory.EXPECT().NewOverlay().Return(mockOverlay).Once()
70		mockOverlay.EXPECT().SetHexpand(true).Once()	41		mockOverlay.EXPECT().SetHexpand(true).Once()
71		mockOverlay.EXPECT().SetVexpand(true).Once()	42		mockOverlay.EXPECT().SetVexpand(true).Once()
72	-	// No SetChild since WebView is nil	43	+	mockOverlay.EXPECT().SetVisible(true).Once()
73			44
74		mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBorderBox).Once()	45		mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBorderBox).Once()
75		mockBorderBox.EXPECT().SetCanFocus(false).Once()	46		mockBorderBox.EXPECT().SetCanFocus(false).Once()
			47	+	mockBorderBox.EXPECT().SetCanTarget(false).Once()
76		mockBorderBox.EXPECT().AddCssClass("pane-border").Once()	48		mockBorderBox.EXPECT().AddCssClass("pane-border").Once()
77		mockBorderBox.EXPECT().SetHexpand(true).Once()	49		mockBorderBox.EXPECT().SetHexpand(true).Once()
78		mockBorderBox.EXPECT().SetVexpand(true).Once()	50		mockBorderBox.EXPECT().SetVexpand(true).Once()

@@ -80,268 +52,156 @@ func TestSetWorkspace_SinglePane_CreatesPaneView(t *testing.T) {
80		mockOverlay.EXPECT().SetClipOverlay(mockBorderBox, false).Once()	52		mockOverlay.EXPECT().SetClipOverlay(mockBorderBox, false).Once()
81		mockOverlay.EXPECT().SetMeasureOverlay(mockBorderBox, false).Once()	53		mockOverlay.EXPECT().SetMeasureOverlay(mockBorderBox, false).Once()
82			54
83	-	// Widget appended to container	55	+	return mockOverlay, mockBorderBox
84	-	mockBox.EXPECT().Append(mockOverlay).Once()
85	-
86	-	// Active state set
87	-	mockBorderBox.EXPECT().AddCssClass("active-pane").Once()
88	-
89	-	pane := entity.NewPane(entity.PaneID("pane-1"))
90	-	node := &entity.PaneNode{ID: "node-1", Pane: pane}
91	-
92	-	ws := &entity.Workspace{
93	-	ID: "ws-1",
94	-	Root: node,
95	-	ActivePaneID: pane.ID,
96	-	}
97	-
98	-	// Act
99	-	err := wv.SetWorkspace(ws)
100	-
101	-	// Assert
102	-	require.NoError(t, err)
103	-	assert.Equal(t, 1, wv.PaneCount())
104	-	assert.Equal(t, pane.ID, wv.GetActivePaneID())
105	-	assert.NotNil(t, wv.GetPaneView(pane.ID))
106		}	56		}
107			57
108	-	func TestSetActivePaneID_UpdatesStyling(t *testing.T) {	58	+	func setupStackedLeafMocks(
109	-	// Arrange	59	+	t *testing.T,
110	-	mockFactory := mocks.NewMockWidgetFactory(t)	60	+	mockFactory *mocks.MockWidgetFactory,
111	-	mockBox := mocks.NewMockBoxWidget(t)	61	+	container *mocks.MockOverlayWidget,
			62	+	) (mocks.MockBoxWidget, mocks.MockBoxWidget) {
			63	+	mockStackBox := mocks.NewMockBoxWidget(t)
			64	+	mockTitleBar := mocks.NewMockBoxWidget(t)
			65	+	mockFavicon := mocks.NewMockImageWidget(t)
			66	+	mockLabel := mocks.NewMockLabelWidget(t)
			67	+	mockButton := mocks.NewMockButtonWidget(t)
112			68
113	-	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBox).Once()	69	+	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockStackBox).Once()
114	-	mockBox.EXPECT().SetHexpand(true).Once()	70	+	mockStackBox.EXPECT().SetHexpand(true).Once()
115	-	mockBox.EXPECT().SetVexpand(true).Once()	71	+	mockStackBox.EXPECT().SetVexpand(true).Once()
116			72
117	-	wv := component.NewWorkspaceView(mockFactory, zerolog.Nop())	73	+	mockFactory.EXPECT().NewBox(layout.OrientationHorizontal, 4).Return(mockTitleBar).Once()
			74	+	mockTitleBar.EXPECT().AddCssClass("stacked-pane-titlebar").Once()
			75	+	mockTitleBar.EXPECT().SetVexpand(false).Once()
118			76
119	-	// Setup two panes	77	+	mockFactory.EXPECT().NewImage().Return(mockFavicon).Once()
120	-	pane1 := entity.NewPane(entity.PaneID("pane-1"))	78	+	mockFavicon.EXPECT().SetFromIconName(mock.Anything).Once()
121	-	pane2 := entity.NewPane(entity.PaneID("pane-2"))	79	+	mockFavicon.EXPECT().SetPixelSize(16).Once()
122	-	node1 := &entity.PaneNode{ID: "node-1", Pane: pane1}	80	+	mockTitleBar.EXPECT().Append(mockFavicon).Once()
123	-	node2 := &entity.PaneNode{ID: "node-2", Pane: pane2}
124	-
125	-	// Create mock widgets for split
126	-	mockPaned := mocks.NewMockPanedWidget(t)
127	-	mockOverlay1 := mocks.NewMockOverlayWidget(t)
128	-	mockOverlay2 := mocks.NewMockOverlayWidget(t)
129	-	mockBorderBox1 := mocks.NewMockBoxWidget(t)
130	-	mockBorderBox2 := mocks.NewMockBoxWidget(t)
131	-
132	-	// First pane view creation
133	-	mockFactory.EXPECT().NewOverlay().Return(mockOverlay1).Once()
134	-	mockOverlay1.EXPECT().SetHexpand(true).Once()
135	-	mockOverlay1.EXPECT().SetVexpand(true).Once()
136	-	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBorderBox1).Once()
137	-	mockBorderBox1.EXPECT().SetCanFocus(false).Once()
138	-	mockBorderBox1.EXPECT().AddCssClass("pane-border").Once()
139	-	mockBorderBox1.EXPECT().SetHexpand(true).Once()
140	-	mockBorderBox1.EXPECT().SetVexpand(true).Once()
141	-	mockOverlay1.EXPECT().AddOverlay(mockBorderBox1).Once()
142	-	mockOverlay1.EXPECT().SetClipOverlay(mockBorderBox1, false).Once()
143	-	mockOverlay1.EXPECT().SetMeasureOverlay(mockBorderBox1, false).Once()
144	-
145	-	// Second pane view creation
146	-	mockFactory.EXPECT().NewOverlay().Return(mockOverlay2).Once()
147	-	mockOverlay2.EXPECT().SetHexpand(true).Once()
148	-	mockOverlay2.EXPECT().SetVexpand(true).Once()
149	-	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBorderBox2).Once()
150	-	mockBorderBox2.EXPECT().SetCanFocus(false).Once()
151	-	mockBorderBox2.EXPECT().AddCssClass("pane-border").Once()
152	-	mockBorderBox2.EXPECT().SetHexpand(true).Once()
153	-	mockBorderBox2.EXPECT().SetVexpand(true).Once()
154	-	mockOverlay2.EXPECT().AddOverlay(mockBorderBox2).Once()
155	-	mockOverlay2.EXPECT().SetClipOverlay(mockBorderBox2, false).Once()
156	-	mockOverlay2.EXPECT().SetMeasureOverlay(mockBorderBox2, false).Once()
157			81
158	-	// Split view creation	82	+	mockFactory.EXPECT().NewLabel(mock.Anything).Return(mockLabel).Once()
159	-	mockFactory.EXPECT().NewPaned(layout.OrientationHorizontal).Return(mockPaned).Once()	83	+	mockLabel.EXPECT().SetEllipsize(layout.EllipsizeEnd).Once()
160	-	mockPaned.EXPECT().SetResizeStartChild(true).Once()	84	+	mockLabel.EXPECT().SetMaxWidthChars(30).Once()
161	-	mockPaned.EXPECT().SetResizeEndChild(true).Once()	85	+	mockLabel.EXPECT().SetHexpand(true).Once()
162	-	mockPaned.EXPECT().SetShrinkStartChild(false).Once()	86	+	mockLabel.EXPECT().SetXalign(float32(0.0)).Once()
163	-	mockPaned.EXPECT().SetShrinkEndChild(false).Once()	87	+	mockTitleBar.EXPECT().Append(mockLabel).Once()
164	-	mockPaned.EXPECT().SetStartChild(mockOverlay1).Once()
165	-	mockPaned.EXPECT().SetEndChild(mockOverlay2).Once()
166	-	mockPaned.EXPECT().GetAllocatedWidth().Return(0).Once()
167	-	mockPaned.EXPECT().ConnectMap(mock.Anything).Return(uint32(0)).Once()
168	-	mockPaned.EXPECT().AddTickCallback(mock.Anything).Return(uint(0)).Once()
169			88
170	-	mockBox.EXPECT().Append(mockPaned).Once()	89	+	mockFactory.EXPECT().NewButton().Return(mockButton).Once()
			90	+	mockButton.EXPECT().SetChild(mockTitleBar).Once()
			91	+	mockButton.EXPECT().AddCssClass("stacked-pane-title-button").Once()
			92	+	mockButton.EXPECT().SetFocusOnClick(false).Once()
			93	+	mockButton.EXPECT().SetVexpand(false).Once()
			94	+	mockButton.EXPECT().SetHexpand(true).Once()
			95	+	mockButton.EXPECT().ConnectClicked(mock.Anything).Return(uint32(1)).Once()
171			96
172	-	// Initial active pane is pane-1	97	+	mockStackBox.EXPECT().Append(mockButton).Once()
173	-	mockBorderBox1.EXPECT().AddCssClass("active-pane").Once()	98	+	mockStackBox.EXPECT().Append(container).Once()
174			99
175	-	splitNode := &entity.PaneNode{	100	+	mockTitleBar.EXPECT().GetParent().Return(nil).Maybe()
176	-	ID: "split",	101	+	container.EXPECT().SetVisible(true).Once()
177	-	SplitDir: entity.SplitHorizontal,	102	+	mockTitleBar.EXPECT().AddCssClass("active").Once()
178	-	SplitRatio: 0.5,
179	-	Children: []*entity.PaneNode{node1, node2},
180	-	}
181			103
182	-	ws := &entity.Workspace{	104	+	return mockStackBox, mockTitleBar
183	-	ID: "ws-1",	105	+	}
184	-	Root: splitNode,
185	-	ActivePaneID: pane1.ID,
186	-	}
187	-
188	-	err := wv.SetWorkspace(ws)
189	-	require.NoError(t, err)
190			106
191	-	// Now change active pane	107	+	func TestNewWorkspaceView_CreatesEmptyContainer(t *testing.T) {
192	-	mockBorderBox1.EXPECT().RemoveCssClass("active-pane").Once()	108	+	// Arrange
193	-	mockBorderBox2.EXPECT().AddCssClass("active-pane").Once()	109	+	mockFactory := mocks.NewMockWidgetFactory(t)
			110	+	ctx, mockBox, _ := setupWorkspaceViewBase(t, mockFactory)
194			111
195		// Act	112		// Act
196	-	err = wv.SetActivePaneID(pane2.ID)	113	+	wv := component.NewWorkspaceView(ctx, mockFactory)
197			114
198		// Assert	115		// Assert
199	-	require.NoError(t, err)	116	+	require.NotNil(t, wv)
200	-	assert.Equal(t, pane2.ID, wv.GetActivePaneID())	117	+	assert.Equal(t, 0, wv.PaneCount())
			118	+	assert.Equal(t, mockBox, wv.Container())
201		}	119		}
202			120
203	-	func TestSetActivePaneID_InvalidID_ReturnsError(t *testing.T) {	121	+	func TestSetWorkspace_NilWorkspace_ReturnsError(t *testing.T) {
204		// Arrange	122		// Arrange
205		mockFactory := mocks.NewMockWidgetFactory(t)	123		mockFactory := mocks.NewMockWidgetFactory(t)
206	-	mockBox := mocks.NewMockBoxWidget(t)	124	+	ctx, _, _ := setupWorkspaceViewBase(t, mockFactory)
207			125
208	-	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBox).Once()	126	+	wv := component.NewWorkspaceView(ctx, mockFactory)
209	-	mockBox.EXPECT().SetHexpand(true).Once()
210	-	mockBox.EXPECT().SetVexpand(true).Once()
211	-
212	-	wv := component.NewWorkspaceView(mockFactory, zerolog.Nop())
213			127
214		// Act	128		// Act
215	-	err := wv.SetActivePaneID(entity.PaneID("non-existent"))	129	+	err := wv.SetWorkspace(ctx, nil)
216			130
217		// Assert	131		// Assert
218	-	assert.ErrorIs(t, err, component.ErrPaneNotFound)	132	+	assert.ErrorIs(t, err, component.ErrNilWorkspace)
219		}	133		}
220			134
221	-	func TestGetPaneView_Existing(t *testing.T) {	135	+	func TestSetWorkspace_SinglePane_CreatesPaneView(t *testing.T) {
222		// Arrange	136		// Arrange
223		mockFactory := mocks.NewMockWidgetFactory(t)	137		mockFactory := mocks.NewMockWidgetFactory(t)
224	-	mockBox := mocks.NewMockBoxWidget(t)	138	+	ctx, mockBox, _ := setupWorkspaceViewBase(t, mockFactory)
225	-	mockOverlay := mocks.NewMockOverlayWidget(t)
226	-	mockBorderBox := mocks.NewMockBoxWidget(t)
227			139
228	-	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBox).Once()	140	+	wv := component.NewWorkspaceView(ctx, mockFactory)
229	-	mockBox.EXPECT().SetHexpand(true).Once()
230	-	mockBox.EXPECT().SetVexpand(true).Once()
231			141
232	-	wv := component.NewWorkspaceView(mockFactory, zerolog.Nop())	142	+	mockOverlay, mockBorderBox := setupWorkspacePaneViewMocks(t, mockFactory)
			143	+	mockStackBox, _ := setupStackedLeafMocks(t, mockFactory, mockOverlay)
233			144
234	-	// PaneView creation	145	+	mockStackBox.EXPECT().SetVisible(true).Once()
235	-	mockFactory.EXPECT().NewOverlay().Return(mockOverlay).Once()	146	+	mockBox.EXPECT().Append(mockStackBox).Once()
236	-	mockOverlay.EXPECT().SetHexpand(true).Once()	147	+	mockBorderBox.EXPECT().AddCssClass("pane-active").Once()
237	-	mockOverlay.EXPECT().SetVexpand(true).Once()
238	-	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBorderBox).Once()
239	-	mockBorderBox.EXPECT().SetCanFocus(false).Once()
240	-	mockBorderBox.EXPECT().AddCssClass("pane-border").Once()
241	-	mockBorderBox.EXPECT().SetHexpand(true).Once()
242	-	mockBorderBox.EXPECT().SetVexpand(true).Once()
243	-	mockOverlay.EXPECT().AddOverlay(mockBorderBox).Once()
244	-	mockOverlay.EXPECT().SetClipOverlay(mockBorderBox, false).Once()
245	-	mockOverlay.EXPECT().SetMeasureOverlay(mockBorderBox, false).Once()
246	-	mockBox.EXPECT().Append(mockOverlay).Once()
247	-	mockBorderBox.EXPECT().AddCssClass("active-pane").Once()
248			148
249		pane := entity.NewPane(entity.PaneID("pane-1"))	149		pane := entity.NewPane(entity.PaneID("pane-1"))
250		node := &entity.PaneNode{ID: "node-1", Pane: pane}	150		node := &entity.PaneNode{ID: "node-1", Pane: pane}
			151	+
251		ws := &entity.Workspace{	152		ws := &entity.Workspace{
252		ID: "ws-1",	153		ID: "ws-1",
253		Root: node,	154		Root: node,
254		ActivePaneID: pane.ID,	155		ActivePaneID: pane.ID,
255		}	156		}
256			157
257	-	_ = wv.SetWorkspace(ws)
258	-
259		// Act	158		// Act
260	-	result := wv.GetPaneView(pane.ID)	159	+	err := wv.SetWorkspace(ctx, ws)
261			160
262		// Assert	161		// Assert
263	-	assert.NotNil(t, result)	162	+	require.NoError(t, err)
			163	+	assert.Equal(t, 1, wv.PaneCount())
			164	+	assert.Equal(t, pane.ID, wv.GetActivePaneID())
			165	+	assert.NotNil(t, wv.GetPaneView(pane.ID))
264		}	166		}
265			167
266	-	func TestGetPaneView_NonExistent(t *testing.T) {	168	+	func TestSetActivePaneID_UpdatesStyling(t *testing.T) {
267		// Arrange	169		// Arrange
268		mockFactory := mocks.NewMockWidgetFactory(t)	170		mockFactory := mocks.NewMockWidgetFactory(t)
269	-	mockBox := mocks.NewMockBoxWidget(t)	171	+	ctx, mockBox, _ := setupWorkspaceViewBase(t, mockFactory)
270	-
271	-	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBox).Once()
272	-	mockBox.EXPECT().SetHexpand(true).Once()
273	-	mockBox.EXPECT().SetVexpand(true).Once()
274			172
275	-	wv := component.NewWorkspaceView(mockFactory, zerolog.Nop())	173	+	wv := component.NewWorkspaceView(ctx, mockFactory)
276			174
277	-	// Act	175	+	// Setup two panes
278	-	result := wv.GetPaneView(entity.PaneID("non-existent"))	176	+	pane1 := entity.NewPane(entity.PaneID("pane-1"))
279	-		177	+	pane2 := entity.NewPane(entity.PaneID("pane-2"))
280	-	// Assert	178	+	node1 := &entity.PaneNode{ID: "node-1", Pane: pane1}
281	-	assert.Nil(t, result)	179	+	node2 := &entity.PaneNode{ID: "node-2", Pane: pane2}
282	-	}
283			180
284	-	func TestGetPaneIDs_ReturnsAllIDs(t *testing.T) {	181	+	// Create mock widgets for split
285	-	// Arrange
286	-	mockFactory := mocks.NewMockWidgetFactory(t)
287	-	mockBox := mocks.NewMockBoxWidget(t)
288		mockPaned := mocks.NewMockPanedWidget(t)	182		mockPaned := mocks.NewMockPanedWidget(t)
289	-	mockOverlay1 := mocks.NewMockOverlayWidget(t)	183	+	mockOverlay1, mockBorderBox1 := setupWorkspacePaneViewMocks(t, mockFactory)
290	-	mockOverlay2 := mocks.NewMockOverlayWidget(t)	184	+	mockStackBox1, _ := setupStackedLeafMocks(t, mockFactory, mockOverlay1)
291	-	mockBorderBox1 := mocks.NewMockBoxWidget(t)	185	+	mockOverlay2, mockBorderBox2 := setupWorkspacePaneViewMocks(t, mockFactory)
292	-	mockBorderBox2 := mocks.NewMockBoxWidget(t)	186	+	mockStackBox2, _ := setupStackedLeafMocks(t, mockFactory, mockOverlay2)
293	-		187	+
294	-	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBox).Once()	188	+	// Split view creation
295	-	mockBox.EXPECT().SetHexpand(true).Once()
296	-	mockBox.EXPECT().SetVexpand(true).Once()
297	-
298	-	wv := component.NewWorkspaceView(mockFactory, zerolog.Nop())
299	-
300	-	// First pane view
301	-	mockFactory.EXPECT().NewOverlay().Return(mockOverlay1).Once()
302	-	mockOverlay1.EXPECT().SetHexpand(true).Once()
303	-	mockOverlay1.EXPECT().SetVexpand(true).Once()
304	-	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBorderBox1).Once()
305	-	mockBorderBox1.EXPECT().SetCanFocus(false).Once()
306	-	mockBorderBox1.EXPECT().AddCssClass("pane-border").Once()
307	-	mockBorderBox1.EXPECT().SetHexpand(true).Once()
308	-	mockBorderBox1.EXPECT().SetVexpand(true).Once()
309	-	mockOverlay1.EXPECT().AddOverlay(mockBorderBox1).Once()
310	-	mockOverlay1.EXPECT().SetClipOverlay(mockBorderBox1, false).Once()
311	-	mockOverlay1.EXPECT().SetMeasureOverlay(mockBorderBox1, false).Once()
312	-
313	-	// Second pane view
314	-	mockFactory.EXPECT().NewOverlay().Return(mockOverlay2).Once()
315	-	mockOverlay2.EXPECT().SetHexpand(true).Once()
316	-	mockOverlay2.EXPECT().SetVexpand(true).Once()
317	-	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBorderBox2).Once()
318	-	mockBorderBox2.EXPECT().SetCanFocus(false).Once()
319	-	mockBorderBox2.EXPECT().AddCssClass("pane-border").Once()
320	-	mockBorderBox2.EXPECT().SetHexpand(true).Once()
321	-	mockBorderBox2.EXPECT().SetVexpand(true).Once()
322	-	mockOverlay2.EXPECT().AddOverlay(mockBorderBox2).Once()
323	-	mockOverlay2.EXPECT().SetClipOverlay(mockBorderBox2, false).Once()
324	-	mockOverlay2.EXPECT().SetMeasureOverlay(mockBorderBox2, false).Once()
325	-
326	-	// Split view
327		mockFactory.EXPECT().NewPaned(layout.OrientationHorizontal).Return(mockPaned).Once()	189		mockFactory.EXPECT().NewPaned(layout.OrientationHorizontal).Return(mockPaned).Once()
328		mockPaned.EXPECT().SetResizeStartChild(true).Once()	190		mockPaned.EXPECT().SetResizeStartChild(true).Once()
329		mockPaned.EXPECT().SetResizeEndChild(true).Once()	191		mockPaned.EXPECT().SetResizeEndChild(true).Once()
330	-	mockPaned.EXPECT().SetShrinkStartChild(false).Once()	192	+	mockPaned.EXPECT().SetVisible(true).Twice()
331	-	mockPaned.EXPECT().SetShrinkEndChild(false).Once()	193	+	mockStackBox1.EXPECT().SetVisible(true).Once()
332	-	mockPaned.EXPECT().SetStartChild(mockOverlay1).Once()	194	+	mockStackBox2.EXPECT().SetVisible(true).Once()
333	-	mockPaned.EXPECT().SetEndChild(mockOverlay2).Once()	195	+	mockPaned.EXPECT().SetStartChild(mockStackBox1).Once()
			196	+	mockPaned.EXPECT().SetEndChild(mockStackBox2).Once()
334		mockPaned.EXPECT().GetAllocatedWidth().Return(0).Once()	197		mockPaned.EXPECT().GetAllocatedWidth().Return(0).Once()
335		mockPaned.EXPECT().ConnectMap(mock.Anything).Return(uint32(0)).Once()	198		mockPaned.EXPECT().ConnectMap(mock.Anything).Return(uint32(0)).Once()
336		mockPaned.EXPECT().AddTickCallback(mock.Anything).Return(uint(0)).Once()	199		mockPaned.EXPECT().AddTickCallback(mock.Anything).Return(uint(0)).Once()
337			200
338		mockBox.EXPECT().Append(mockPaned).Once()	201		mockBox.EXPECT().Append(mockPaned).Once()
339	-	mockBorderBox1.EXPECT().AddCssClass("active-pane").Once()
340			202
341	-	pane1 := entity.NewPane(entity.PaneID("pane-1"))	203	+	// Initial active pane is pane-1
342	-	pane2 := entity.NewPane(entity.PaneID("pane-2"))	204	+	mockBorderBox1.EXPECT().AddCssClass("pane-active").Once()
343	-	node1 := &entity.PaneNode{ID: "node-1", Pane: pane1}
344	-	node2 := &entity.PaneNode{ID: "node-2", Pane: pane2}
345			205
346		splitNode := &entity.PaneNode{	206		splitNode := &entity.PaneNode{
347		ID: "split",	207		ID: "split",

@@ -356,281 +216,31 @@ func TestGetPaneIDs_ReturnsAllIDs(t *testing.T) {
356		ActivePaneID: pane1.ID,	216		ActivePaneID: pane1.ID,
357		}	217		}
358			218
359	-	_ = wv.SetWorkspace(ws)	219	+	err := wv.SetWorkspace(ctx, ws)
360	-		220	+	require.NoError(t, err)
361	-	// Act
362	-	ids := wv.GetPaneIDs()
363	-
364	-	// Assert
365	-	assert.Len(t, ids, 2)
366	-	assert.Contains(t, ids, pane1.ID)
367	-	assert.Contains(t, ids, pane2.ID)
368	-	}
369	-
370	-	func TestWidget_ReturnsContainer(t *testing.T) {
371	-	// Arrange
372	-	mockFactory := mocks.NewMockWidgetFactory(t)
373	-	mockBox := mocks.NewMockBoxWidget(t)
374	-
375	-	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBox).Once()
376	-	mockBox.EXPECT().SetHexpand(true).Once()
377	-	mockBox.EXPECT().SetVexpand(true).Once()
378	-
379	-	wv := component.NewWorkspaceView(mockFactory, zerolog.Nop())
380	-
381	-	// Act
382	-	widget := wv.Widget()
383	-
384	-	// Assert
385	-	assert.Equal(t, mockBox, widget)
386	-	}
387	-
388	-	func TestSetOnPaneFocused_SetsCallback(t *testing.T) {
389	-	// Arrange
390	-	mockFactory := mocks.NewMockWidgetFactory(t)
391	-	mockBox := mocks.NewMockBoxWidget(t)
392	-
393	-	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBox).Once()
394	-	mockBox.EXPECT().SetHexpand(true).Once()
395	-	mockBox.EXPECT().SetVexpand(true).Once()
396	-
397	-	wv := component.NewWorkspaceView(mockFactory, zerolog.Nop())
398	-
399	-	callback := func(paneID entity.PaneID) {}
400	-
401	-	// Act
402	-	wv.SetOnPaneFocused(callback)
403	-
404	-	// Assert - callback is set (verified by no panic)
405	-	assert.NotNil(t, wv)
406	-	}
407	-
408	-	func TestSetWebViewWidget_AttachesToPane(t *testing.T) {
409	-	// Arrange
410	-	mockFactory := mocks.NewMockWidgetFactory(t)
411	-	mockBox := mocks.NewMockBoxWidget(t)
412	-	mockOverlay := mocks.NewMockOverlayWidget(t)
413	-	mockBorderBox := mocks.NewMockBoxWidget(t)
414	-	mockWebView := mocks.NewMockWidget(t)
415	-
416	-	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBox).Once()
417	-	mockBox.EXPECT().SetHexpand(true).Once()
418	-	mockBox.EXPECT().SetVexpand(true).Once()
419	-
420	-	wv := component.NewWorkspaceView(mockFactory, zerolog.Nop())
421	-
422	-	// PaneView creation
423	-	mockFactory.EXPECT().NewOverlay().Return(mockOverlay).Once()
424	-	mockOverlay.EXPECT().SetHexpand(true).Once()
425	-	mockOverlay.EXPECT().SetVexpand(true).Once()
426	-	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBorderBox).Once()
427	-	mockBorderBox.EXPECT().SetCanFocus(false).Once()
428	-	mockBorderBox.EXPECT().AddCssClass("pane-border").Once()
429	-	mockBorderBox.EXPECT().SetHexpand(true).Once()
430	-	mockBorderBox.EXPECT().SetVexpand(true).Once()
431	-	mockOverlay.EXPECT().AddOverlay(mockBorderBox).Once()
432	-	mockOverlay.EXPECT().SetClipOverlay(mockBorderBox, false).Once()
433	-	mockOverlay.EXPECT().SetMeasureOverlay(mockBorderBox, false).Once()
434	-	mockBox.EXPECT().Append(mockOverlay).Once()
435	-	mockBorderBox.EXPECT().AddCssClass("active-pane").Once()
436	-
437	-	pane := entity.NewPane(entity.PaneID("pane-1"))
438	-	node := &entity.PaneNode{ID: "node-1", Pane: pane}
439	-	ws := &entity.Workspace{
440	-	ID: "ws-1",
441	-	Root: node,
442	-	ActivePaneID: pane.ID,
443	-	}
444	-
445	-	_ = wv.SetWorkspace(ws)
446			221
447	-	// Expect WebView to be set	222	+	// Now change active pane
448	-	mockOverlay.EXPECT().SetChild(mockWebView).Once()	223	+	mockBorderBox1.EXPECT().RemoveCssClass("pane-active").Once()
			224	+	mockBorderBox2.EXPECT().AddCssClass("pane-active").Once()
449			225
450		// Act	226		// Act
451	-	err := wv.SetWebViewWidget(pane.ID, mockWebView)	227	+	err = wv.SetActivePaneID(pane2.ID)
452			228
453		// Assert	229		// Assert
454		require.NoError(t, err)	230		require.NoError(t, err)
			231	+	assert.Equal(t, pane2.ID, wv.GetActivePaneID())
455		}	232		}
456			233
457	-	func TestSetWebViewWidget_NonExistentPane_ReturnsError(t *testing.T) {	234	+	func TestSetActivePaneID_InvalidID_ReturnsError(t *testing.T) {
458		// Arrange	235		// Arrange
459		mockFactory := mocks.NewMockWidgetFactory(t)	236		mockFactory := mocks.NewMockWidgetFactory(t)
460	-	mockBox := mocks.NewMockBoxWidget(t)	237	+	ctx, _, _ := setupWorkspaceViewBase(t, mockFactory)
461	-	mockWebView := mocks.NewMockWidget(t)
462	-
463	-	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBox).Once()
464	-	mockBox.EXPECT().SetHexpand(true).Once()
465	-	mockBox.EXPECT().SetVexpand(true).Once()
466			238
467	-	wv := component.NewWorkspaceView(mockFactory, zerolog.Nop())	239	+	wv := component.NewWorkspaceView(ctx, mockFactory)
468			240
469		// Act	241		// Act
470	-	err := wv.SetWebViewWidget(entity.PaneID("non-existent"), mockWebView)	242	+	err := wv.SetActivePaneID(entity.PaneID("non-existent"))
471			243
472		// Assert	244		// Assert
473		assert.ErrorIs(t, err, component.ErrPaneNotFound)	245		assert.ErrorIs(t, err, component.ErrPaneNotFound)
474		}	246		}
475	-
476	-	func TestFocusPane_DelegatesToPaneView(t *testing.T) {
477	-	// Arrange
478	-	mockFactory := mocks.NewMockWidgetFactory(t)
479	-	mockBox := mocks.NewMockBoxWidget(t)
480	-	mockOverlay := mocks.NewMockOverlayWidget(t)
481	-	mockBorderBox := mocks.NewMockBoxWidget(t)
482	-
483	-	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBox).Once()
484	-	mockBox.EXPECT().SetHexpand(true).Once()
485	-	mockBox.EXPECT().SetVexpand(true).Once()
486	-
487	-	wv := component.NewWorkspaceView(mockFactory, zerolog.Nop())
488	-
489	-	// PaneView creation
490	-	mockFactory.EXPECT().NewOverlay().Return(mockOverlay).Once()
491	-	mockOverlay.EXPECT().SetHexpand(true).Once()
492	-	mockOverlay.EXPECT().SetVexpand(true).Once()
493	-	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBorderBox).Once()
494	-	mockBorderBox.EXPECT().SetCanFocus(false).Once()
495	-	mockBorderBox.EXPECT().AddCssClass("pane-border").Once()
496	-	mockBorderBox.EXPECT().SetHexpand(true).Once()
497	-	mockBorderBox.EXPECT().SetVexpand(true).Once()
498	-	mockOverlay.EXPECT().AddOverlay(mockBorderBox).Once()
499	-	mockOverlay.EXPECT().SetClipOverlay(mockBorderBox, false).Once()
500	-	mockOverlay.EXPECT().SetMeasureOverlay(mockBorderBox, false).Once()
501	-	mockBox.EXPECT().Append(mockOverlay).Once()
502	-	mockBorderBox.EXPECT().AddCssClass("active-pane").Once()
503	-
504	-	pane := entity.NewPane(entity.PaneID("pane-1"))
505	-	node := &entity.PaneNode{ID: "node-1", Pane: pane}
506	-	ws := &entity.Workspace{
507	-	ID: "ws-1",
508	-	Root: node,
509	-	ActivePaneID: pane.ID,
510	-	}
511	-
512	-	_ = wv.SetWorkspace(ws)
513	-
514	-	// Act - FocusPane with nil WebView returns false
515	-	result := wv.FocusPane(pane.ID)
516	-
517	-	// Assert
518	-	assert.False(t, result) // No WebView attached, so GrabFocus fails
519	-	}
520	-
521	-	func TestFocusPane_NonExistentPane_ReturnsFalse(t *testing.T) {
522	-	// Arrange
523	-	mockFactory := mocks.NewMockWidgetFactory(t)
524	-	mockBox := mocks.NewMockBoxWidget(t)
525	-
526	-	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBox).Once()
527	-	mockBox.EXPECT().SetHexpand(true).Once()
528	-	mockBox.EXPECT().SetVexpand(true).Once()
529	-
530	-	wv := component.NewWorkspaceView(mockFactory, zerolog.Nop())
531	-
532	-	// Act
533	-	result := wv.FocusPane(entity.PaneID("non-existent"))
534	-
535	-	// Assert
536	-	assert.False(t, result)
537	-	}
538	-
539	-	func TestRebuild_NilWorkspace_ReturnsError(t *testing.T) {
540	-	// Arrange
541	-	mockFactory := mocks.NewMockWidgetFactory(t)
542	-	mockBox := mocks.NewMockBoxWidget(t)
543	-
544	-	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBox).Once()
545	-	mockBox.EXPECT().SetHexpand(true).Once()
546	-	mockBox.EXPECT().SetVexpand(true).Once()
547	-
548	-	wv := component.NewWorkspaceView(mockFactory, zerolog.Nop())
549	-
550	-	// Act
551	-	err := wv.Rebuild()
552	-
553	-	// Assert
554	-	assert.ErrorIs(t, err, component.ErrNilWorkspace)
555	-	}
556	-
557	-	func TestTreeRenderer_ReturnsRenderer(t *testing.T) {
558	-	// Arrange
559	-	mockFactory := mocks.NewMockWidgetFactory(t)
560	-	mockBox := mocks.NewMockBoxWidget(t)
561	-
562	-	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBox).Once()
563	-	mockBox.EXPECT().SetHexpand(true).Once()
564	-	mockBox.EXPECT().SetVexpand(true).Once()
565	-
566	-	wv := component.NewWorkspaceView(mockFactory, zerolog.Nop())
567	-
568	-	// Act
569	-	renderer := wv.TreeRenderer()
570	-
571	-	// Assert
572	-	assert.NotNil(t, renderer)
573	-	}
574	-
575	-	func TestWorkspace_ReturnsCurrentWorkspace(t *testing.T) {
576	-	// Arrange
577	-	mockFactory := mocks.NewMockWidgetFactory(t)
578	-	mockBox := mocks.NewMockBoxWidget(t)
579	-	mockOverlay := mocks.NewMockOverlayWidget(t)
580	-	mockBorderBox := mocks.NewMockBoxWidget(t)
581	-
582	-	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBox).Once()
583	-	mockBox.EXPECT().SetHexpand(true).Once()
584	-	mockBox.EXPECT().SetVexpand(true).Once()
585	-
586	-	wv := component.NewWorkspaceView(mockFactory, zerolog.Nop())
587	-
588	-	// PaneView creation
589	-	mockFactory.EXPECT().NewOverlay().Return(mockOverlay).Once()
590	-	mockOverlay.EXPECT().SetHexpand(true).Once()
591	-	mockOverlay.EXPECT().SetVexpand(true).Once()
592	-	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBorderBox).Once()
593	-	mockBorderBox.EXPECT().SetCanFocus(false).Once()
594	-	mockBorderBox.EXPECT().AddCssClass("pane-border").Once()
595	-	mockBorderBox.EXPECT().SetHexpand(true).Once()
596	-	mockBorderBox.EXPECT().SetVexpand(true).Once()
597	-	mockOverlay.EXPECT().AddOverlay(mockBorderBox).Once()
598	-	mockOverlay.EXPECT().SetClipOverlay(mockBorderBox, false).Once()
599	-	mockOverlay.EXPECT().SetMeasureOverlay(mockBorderBox, false).Once()
600	-	mockBox.EXPECT().Append(mockOverlay).Once()
601	-	mockBorderBox.EXPECT().AddCssClass("active-pane").Once()
602	-
603	-	pane := entity.NewPane(entity.PaneID("pane-1"))
604	-	node := &entity.PaneNode{ID: "node-1", Pane: pane}
605	-	ws := &entity.Workspace{
606	-	ID: "ws-1",
607	-	Root: node,
608	-	ActivePaneID: pane.ID,
609	-	}
610	-
611	-	_ = wv.SetWorkspace(ws)
612	-
613	-	// Act
614	-	result := wv.Workspace()
615	-
616	-	// Assert
617	-	assert.Equal(t, ws, result)
618	-	}
619	-
620	-	func TestWorkspace_NilBeforeSet(t *testing.T) {
621	-	// Arrange
622	-	mockFactory := mocks.NewMockWidgetFactory(t)
623	-	mockBox := mocks.NewMockBoxWidget(t)
624	-
625	-	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBox).Once()
626	-	mockBox.EXPECT().SetHexpand(true).Once()
627	-	mockBox.EXPECT().SetVexpand(true).Once()
628	-
629	-	wv := component.NewWorkspaceView(mockFactory, zerolog.Nop())
630	-
631	-	// Act
632	-	result := wv.Workspace()
633	-
634	-	// Assert
635	-	assert.Nil(t, result)
636	-	}

M internal/ui/input/modal_test.go +46 -33

@@ -1,13 +1,15 @@
1	1		package input
2	2
3	3		import (
	4	+	"context"
4	5		"sync"
5	6		"testing"
6	7		"time"
7	8		)
8	9
9	10		func TestModalState_InitialState(t *testing.T) {
10		-	ms := NewModalState(nil)
	11	+	ctx := context.Background()
	12	+	ms := NewModalState(ctx)
11	13
12	14		if ms.Mode() != ModeNormal {
13	15		t.Errorf("initial mode = %v, want ModeNormal", ms.Mode())

@@ -15,9 +17,10 @@ func TestModalState_InitialState(t *testing.T) {
15	17		}
16	18
17	19		func TestModalState_EnterTabMode(t *testing.T) {
18		-	ms := NewModalState(nil)
	20	+	ctx := context.Background()
	21	+	ms := NewModalState(ctx)
19	22
20		-	ms.EnterTabMode(0)
	23	+	ms.EnterTabMode(ctx, 0)
21	24
22	25		if ms.Mode() != ModeTab {
23	26		t.Errorf("mode after EnterTabMode = %v, want ModeTab", ms.Mode())

@@ -25,9 +28,10 @@ func TestModalState_EnterTabMode(t *testing.T) {
25	28		}
26	29
27	30		func TestModalState_EnterPaneMode(t *testing.T) {
28		-	ms := NewModalState(nil)
	31	+	ctx := context.Background()
	32	+	ms := NewModalState(ctx)
29	33
30		-	ms.EnterPaneMode(0)
	34	+	ms.EnterPaneMode(ctx, 0)
31	35
32	36		if ms.Mode() != ModePane {
33	37		t.Errorf("mode after EnterPaneMode = %v, want ModePane", ms.Mode())

@@ -35,26 +39,28 @@ func TestModalState_EnterPaneMode(t *testing.T) {
35	39		}
36	40
37	41		func TestModalState_ExitMode(t *testing.T) {
38		-	ms := NewModalState(nil)
	42	+	ctx := context.Background()
	43	+	ms := NewModalState(ctx)
39	44
40	45		// Enter tab mode
41		-	ms.EnterTabMode(0)
	46	+	ms.EnterTabMode(ctx, 0)
42	47		if ms.Mode() != ModeTab {
43	48		t.Fatalf("mode should be ModeTab")
44	49		}
45	50
46	51		// Exit mode
47		-	ms.ExitMode()
	52	+	ms.ExitMode(ctx)
48	53		if ms.Mode() != ModeNormal {
49	54		t.Errorf("mode after ExitMode = %v, want ModeNormal", ms.Mode())
50	55		}
51	56		}
52	57
53	58		func TestModalState_ExitMode_FromNormal(t *testing.T) {
54		-	ms := NewModalState(nil)
	59	+	ctx := context.Background()
	60	+	ms := NewModalState(ctx)
55	61
56	62		// ExitMode from normal should be no-op
57		-	ms.ExitMode()
	63	+	ms.ExitMode(ctx)
58	64
59	65		if ms.Mode() != ModeNormal {
60	66		t.Errorf("mode = %v, want ModeNormal", ms.Mode())

@@ -62,29 +68,31 @@ func TestModalState_ExitMode_FromNormal(t *testing.T) {
62	68		}
63	69
64	70		func TestModalState_SwitchModes(t *testing.T) {
65		-	ms := NewModalState(nil)
	71	+	ctx := context.Background()
	72	+	ms := NewModalState(ctx)
66	73
67	74		// Enter tab mode
68		-	ms.EnterTabMode(0)
	75	+	ms.EnterTabMode(ctx, 0)
69	76		if ms.Mode() != ModeTab {
70	77		t.Fatalf("expected ModeTab, got %v", ms.Mode())
71	78		}
72	79
73	80		// Switch to pane mode directly
74		-	ms.EnterPaneMode(0)
	81	+	ms.EnterPaneMode(ctx, 0)
75	82		if ms.Mode() != ModePane {
76	83		t.Errorf("mode after switch to pane = %v, want ModePane", ms.Mode())
77	84		}
78	85
79	86		// Switch back to tab mode
80		-	ms.EnterTabMode(0)
	87	+	ms.EnterTabMode(ctx, 0)
81	88		if ms.Mode() != ModeTab {
82	89		t.Errorf("mode after switch to tab = %v, want ModeTab", ms.Mode())
83	90		}
84	91		}
85	92
86	93		func TestModalState_ModeChangeCallback(t *testing.T) {
87		-	ms := NewModalState(nil)
	94	+	ctx := context.Background()
	95	+	ms := NewModalState(ctx)
88	96
89	97		var callCount int
90	98		var lastFrom, lastTo Mode

@@ -99,7 +107,7 @@ func TestModalState_ModeChangeCallback(t *testing.T) {
99	107		})
100	108
101	109		// Enter tab mode
102		-	ms.EnterTabMode(0)
	110	+	ms.EnterTabMode(ctx, 0)
103	111
104	112		mu.Lock()
105	113		if callCount != 1 {

@@ -111,7 +119,7 @@ func TestModalState_ModeChangeCallback(t *testing.T) {
111	119		mu.Unlock()
112	120
113	121		// Exit mode
114		-	ms.ExitMode()
	122	+	ms.ExitMode(ctx)
115	123
116	124		mu.Lock()
117	125		if callCount != 2 {

@@ -124,7 +132,8 @@ func TestModalState_ModeChangeCallback(t *testing.T) {
124	132		}
125	133
126	134		func TestModalState_NoCallbackWhenAlreadyInMode(t *testing.T) {
127		-	ms := NewModalState(nil)
	135	+	ctx := context.Background()
	136	+	ms := NewModalState(ctx)
128	137
129	138		var callCount int
130	139		ms.SetOnModeChange(func(from, to Mode) {

@@ -132,23 +141,24 @@ func TestModalState_NoCallbackWhenAlreadyInMode(t *testing.T) {
132	141		})
133	142
134	143		// Enter tab mode
135		-	ms.EnterTabMode(0)
	144	+	ms.EnterTabMode(ctx, 0)
136	145		if callCount != 1 {
137	146		t.Fatalf("expected 1 callback, got %d", callCount)
138	147		}
139	148
140	149		// Enter tab mode again (should not trigger callback)
141		-	ms.EnterTabMode(0)
	150	+	ms.EnterTabMode(ctx, 0)
142	151		if callCount != 1 {
143	152		t.Errorf("callback count = %d, want 1 (no new call)", callCount)
144	153		}
145	154		}
146	155
147	156		func TestModalState_Timeout(t *testing.T) {
148		-	ms := NewModalState(nil)
	157	+	ctx := context.Background()
	158	+	ms := NewModalState(ctx)
149	159
150	160		// Enter with short timeout
151		-	ms.EnterTabMode(50 * time.Millisecond)
	161	+	ms.EnterTabMode(ctx, 50*time.Millisecond)
152	162
153	163		if ms.Mode() != ModeTab {
154	164		t.Fatalf("mode should be ModeTab")

@@ -163,14 +173,15 @@ func TestModalState_Timeout(t *testing.T) {
163	173		}
164	174
165	175		func TestModalState_TimeoutReset(t *testing.T) {
166		-	ms := NewModalState(nil)
	176	+	ctx := context.Background()
	177	+	ms := NewModalState(ctx)
167	178
168	179		// Enter with timeout
169		-	ms.EnterTabMode(100 * time.Millisecond)
	180	+	ms.EnterTabMode(ctx, 100*time.Millisecond)
170	181
171	182		// Wait a bit, then reset
172	183		time.Sleep(50 * time.Millisecond)
173		-	ms.ResetTimeout()
	184	+	ms.ResetTimeout(ctx)
174	185
175	186		// Wait a bit more (original timeout would have expired)
176	187		time.Sleep(80 * time.Millisecond)

@@ -189,7 +200,8 @@ func TestModalState_TimeoutReset(t *testing.T) {
189	200		}
190	201
191	202		func TestModalState_ExitCancelsTimeout(t *testing.T) {
192		-	ms := NewModalState(nil)
	203	+	ctx := context.Background()
	204	+	ms := NewModalState(ctx)
193	205
194	206		var callCount int
195	207		ms.SetOnModeChange(func(from, to Mode) {

@@ -197,13 +209,13 @@ func TestModalState_ExitCancelsTimeout(t *testing.T) {
197	209		})
198	210
199	211		// Enter with timeout
200		-	ms.EnterTabMode(100 * time.Millisecond)
	212	+	ms.EnterTabMode(ctx, 100*time.Millisecond)
201	213		if callCount != 1 {
202	214		t.Fatalf("expected 1 callback")
203	215		}
204	216
205	217		// Exit immediately
206		-	ms.ExitMode()
	218	+	ms.ExitMode(ctx)
207	219		if callCount != 2 {
208	220		t.Fatalf("expected 2 callbacks")
209	221		}

@@ -218,7 +230,8 @@ func TestModalState_ExitCancelsTimeout(t *testing.T) {
218	230		}
219	231
220	232		func TestModalState_ConcurrentAccess(t *testing.T) {
221		-	ms := NewModalState(nil)
	233	+	ctx := context.Background()
	234	+	ms := NewModalState(ctx)
222	235
223	236		var wg sync.WaitGroup
224	237		iterations := 100

@@ -229,12 +242,12 @@ func TestModalState_ConcurrentAccess(t *testing.T) {
229	242		go func() {
230	243		defer wg.Done()
231	244		for j := 0; j < iterations; j++ {
232		-	ms.EnterTabMode(0)
	245	+	ms.EnterTabMode(ctx, 0)
233	246		_ = ms.Mode()
234		-	ms.ExitMode()
235		-	ms.EnterPaneMode(0)
	247	+	ms.ExitMode(ctx)
	248	+	ms.EnterPaneMode(ctx, 0)
236	249		_ = ms.Mode()
237		-	ms.ExitMode()
	250	+	ms.ExitMode(ctx)
238	251		}
239	252		}()
240	253		}

 package input
 import (
+	"context"
 	"sync"
 	"testing"
 	"time"
 )
 func TestModalState_InitialState(t *testing.T) {
-	ms := NewModalState(nil)
+	ctx := context.Background()
+	ms := NewModalState(ctx)
 	if ms.Mode() != ModeNormal {
 		t.Errorf("initial mode = %v, want ModeNormal", ms.Mode())
 }
 func TestModalState_EnterTabMode(t *testing.T) {
-	ms := NewModalState(nil)
+	ctx := context.Background()
+	ms := NewModalState(ctx)
-	ms.EnterTabMode(0)
+	ms.EnterTabMode(ctx, 0)
 	if ms.Mode() != ModeTab {
 		t.Errorf("mode after EnterTabMode = %v, want ModeTab", ms.Mode())
 }
 func TestModalState_EnterPaneMode(t *testing.T) {
-	ms := NewModalState(nil)
+	ctx := context.Background()
+	ms := NewModalState(ctx)
-	ms.EnterPaneMode(0)
+	ms.EnterPaneMode(ctx, 0)
 	if ms.Mode() != ModePane {
 		t.Errorf("mode after EnterPaneMode = %v, want ModePane", ms.Mode())
 }
 func TestModalState_ExitMode(t *testing.T) {
-	ms := NewModalState(nil)
+	ctx := context.Background()
+	ms := NewModalState(ctx)
 	// Enter tab mode
-	ms.EnterTabMode(0)
+	ms.EnterTabMode(ctx, 0)
 	if ms.Mode() != ModeTab {
 		t.Fatalf("mode should be ModeTab")
 	}
 	// Exit mode
-	ms.ExitMode()
+	ms.ExitMode(ctx)
 	if ms.Mode() != ModeNormal {
 		t.Errorf("mode after ExitMode = %v, want ModeNormal", ms.Mode())
 	}
 }
 func TestModalState_ExitMode_FromNormal(t *testing.T) {
-	ms := NewModalState(nil)
+	ctx := context.Background()
+	ms := NewModalState(ctx)
 	// ExitMode from normal should be no-op
-	ms.ExitMode()
+	ms.ExitMode(ctx)
 	if ms.Mode() != ModeNormal {
 		t.Errorf("mode = %v, want ModeNormal", ms.Mode())
 }
 func TestModalState_SwitchModes(t *testing.T) {
-	ms := NewModalState(nil)
+	ctx := context.Background()
+	ms := NewModalState(ctx)
 	// Enter tab mode
-	ms.EnterTabMode(0)
+	ms.EnterTabMode(ctx, 0)
 	if ms.Mode() != ModeTab {
 		t.Fatalf("expected ModeTab, got %v", ms.Mode())
 	}
 	// Switch to pane mode directly
-	ms.EnterPaneMode(0)
+	ms.EnterPaneMode(ctx, 0)
 	if ms.Mode() != ModePane {
 		t.Errorf("mode after switch to pane = %v, want ModePane", ms.Mode())
 	}
 	// Switch back to tab mode
-	ms.EnterTabMode(0)
+	ms.EnterTabMode(ctx, 0)
 	if ms.Mode() != ModeTab {
 		t.Errorf("mode after switch to tab = %v, want ModeTab", ms.Mode())
 	}
 }
 func TestModalState_ModeChangeCallback(t *testing.T) {
-	ms := NewModalState(nil)
+	ctx := context.Background()
+	ms := NewModalState(ctx)
 	var callCount int
 	var lastFrom, lastTo Mode
 	})
 	// Enter tab mode
-	ms.EnterTabMode(0)
+	ms.EnterTabMode(ctx, 0)
 	mu.Lock()
 	if callCount != 1 {
 	mu.Unlock()
 	// Exit mode
-	ms.ExitMode()
+	ms.ExitMode(ctx)
 	mu.Lock()
 	if callCount != 2 {
 }
 func TestModalState_NoCallbackWhenAlreadyInMode(t *testing.T) {
-	ms := NewModalState(nil)
+	ctx := context.Background()
+	ms := NewModalState(ctx)
 	var callCount int
 	ms.SetOnModeChange(func(from, to Mode) {
 	})
 	// Enter tab mode
-	ms.EnterTabMode(0)
+	ms.EnterTabMode(ctx, 0)
 	if callCount != 1 {
 		t.Fatalf("expected 1 callback, got %d", callCount)
 	}
 	// Enter tab mode again (should not trigger callback)
-	ms.EnterTabMode(0)
+	ms.EnterTabMode(ctx, 0)
 	if callCount != 1 {
 		t.Errorf("callback count = %d, want 1 (no new call)", callCount)
 	}
 }
 func TestModalState_Timeout(t *testing.T) {
-	ms := NewModalState(nil)
+	ctx := context.Background()
+	ms := NewModalState(ctx)
 	// Enter with short timeout
-	ms.EnterTabMode(50 * time.Millisecond)
+	ms.EnterTabMode(ctx, 50*time.Millisecond)
 	if ms.Mode() != ModeTab {
 		t.Fatalf("mode should be ModeTab")
 }
 func TestModalState_TimeoutReset(t *testing.T) {
-	ms := NewModalState(nil)
+	ctx := context.Background()
+	ms := NewModalState(ctx)
 	// Enter with timeout
-	ms.EnterTabMode(100 * time.Millisecond)
+	ms.EnterTabMode(ctx, 100*time.Millisecond)
 	// Wait a bit, then reset
 	time.Sleep(50 * time.Millisecond)
-	ms.ResetTimeout()
+	ms.ResetTimeout(ctx)
 	// Wait a bit more (original timeout would have expired)
 	time.Sleep(80 * time.Millisecond)
 }
 func TestModalState_ExitCancelsTimeout(t *testing.T) {
-	ms := NewModalState(nil)
+	ctx := context.Background()
+	ms := NewModalState(ctx)
 	var callCount int
 	ms.SetOnModeChange(func(from, to Mode) {
 	})
 	// Enter with timeout
-	ms.EnterTabMode(100 * time.Millisecond)
+	ms.EnterTabMode(ctx, 100*time.Millisecond)
 	if callCount != 1 {
 		t.Fatalf("expected 1 callback")
 	}
 	// Exit immediately
-	ms.ExitMode()
+	ms.ExitMode(ctx)
 	if callCount != 2 {
 		t.Fatalf("expected 2 callbacks")
 	}
 }
 func TestModalState_ConcurrentAccess(t *testing.T) {
-	ms := NewModalState(nil)
+	ctx := context.Background()
+	ms := NewModalState(ctx)
 	var wg sync.WaitGroup
 	iterations := 100
 		go func() {
 			defer wg.Done()
 			for j := 0; j < iterations; j++ {
-				ms.EnterTabMode(0)
+				ms.EnterTabMode(ctx, 0)
 				_ = ms.Mode()
-				ms.ExitMode()
+				ms.ExitMode(ctx)
-				ms.EnterPaneMode(0)
+				ms.EnterPaneMode(ctx, 0)
 				_ = ms.Mode()
-				ms.ExitMode()
+				ms.ExitMode(ctx)
 			}
 		}()
 	}

M internal/ui/layout/split_test.go +8 -0


@@ -18,6 +18,7 @@ import (
18	18		func setupSplitViewMocks(mockPaned *mocks.MockPanedWidget, orientation layout.Orientation) {
19	19		mockPaned.EXPECT().SetResizeStartChild(true).Once()
20	20		mockPaned.EXPECT().SetResizeEndChild(true).Once()
	21	+	mockPaned.EXPECT().SetVisible(true).Once()
21	22		// Note: SetShrinkStartChild/SetShrinkEndChild are NOT called - allowing shrink
22	23		// enables GTK to respect the 50/50 ratio even if children have larger natural sizes
23	24

@@ -43,6 +44,8 @@ func TestNewSplitView_Horizontal(t *testing.T) {
43	44
44	45		mockFactory.EXPECT().NewPaned(layout.OrientationHorizontal).Return(mockPaned).Once()
45	46		setupSplitViewMocks(mockPaned, layout.OrientationHorizontal)
	47	+	mockStartChild.EXPECT().SetVisible(true).Once()
	48	+	mockEndChild.EXPECT().SetVisible(true).Once()
46	49		mockPaned.EXPECT().SetStartChild(mockStartChild).Once()
47	50		mockPaned.EXPECT().SetEndChild(mockEndChild).Once()
48	51

@@ -67,6 +70,8 @@ func TestNewSplitView_Vertical(t *testing.T) {
67	70
68	71		mockFactory.EXPECT().NewPaned(layout.OrientationVertical).Return(mockPaned).Once()
69	72		setupSplitViewMocks(mockPaned, layout.OrientationVertical)
	73	+	mockStartChild.EXPECT().SetVisible(true).Once()
	74	+	mockEndChild.EXPECT().SetVisible(true).Once()
70	75		mockPaned.EXPECT().SetStartChild(mockStartChild).Once()
71	76		mockPaned.EXPECT().SetEndChild(mockEndChild).Once()
72	77

@@ -174,6 +179,7 @@ func TestSwapStart_ReplacesChild(t *testing.T) {
174	179
175	180		mockFactory.EXPECT().NewPaned(mock.Anything).Return(mockPaned).Once()
176	181		setupSplitViewMocks(mockPaned, layout.OrientationHorizontal)
	182	+	mockOldChild.EXPECT().SetVisible(true).Once()
177	183		mockPaned.EXPECT().SetStartChild(mockOldChild).Once()
178	184
179	185		sv := layout.NewSplitView(ctx, mockFactory, layout.OrientationHorizontal, mockOldChild, nil, 0.5)

@@ -199,6 +205,7 @@ func TestSwapEnd_ReplacesChild(t *testing.T) {
199	205
200	206		mockFactory.EXPECT().NewPaned(mock.Anything).Return(mockPaned).Once()
201	207		setupSplitViewMocks(mockPaned, layout.OrientationHorizontal)
	208	+	mockOldChild.EXPECT().SetVisible(true).Once()
202	209		mockPaned.EXPECT().SetEndChild(mockOldChild).Once()
203	210
204	211		sv := layout.NewSplitView(ctx, mockFactory, layout.OrientationHorizontal, nil, mockOldChild, 0.5)

@@ -245,6 +252,7 @@ func TestSwapEnd_ToNil(t *testing.T) {
245	252
246	253		mockFactory.EXPECT().NewPaned(mock.Anything).Return(mockPaned).Once()
247	254		setupSplitViewMocks(mockPaned, layout.OrientationHorizontal)
	255	+	mockOldChild.EXPECT().SetVisible(true).Once()
248	256		mockPaned.EXPECT().SetEndChild(mockOldChild).Once()
249	257
250	258		sv := layout.NewSplitView(ctx, mockFactory, layout.OrientationHorizontal, nil, mockOldChild, 0.5)


@@ -18,6 +18,7 @@ import (
18	func setupSplitViewMocks(mockPaned *mocks.MockPanedWidget, orientation layout.Orientation) {	18		func setupSplitViewMocks(mockPaned *mocks.MockPanedWidget, orientation layout.Orientation) {
19	mockPaned.EXPECT().SetResizeStartChild(true).Once()	19		mockPaned.EXPECT().SetResizeStartChild(true).Once()
20	mockPaned.EXPECT().SetResizeEndChild(true).Once()	20		mockPaned.EXPECT().SetResizeEndChild(true).Once()
		21	+	mockPaned.EXPECT().SetVisible(true).Once()
21	// Note: SetShrinkStartChild/SetShrinkEndChild are NOT called - allowing shrink	22		// Note: SetShrinkStartChild/SetShrinkEndChild are NOT called - allowing shrink
22	// enables GTK to respect the 50/50 ratio even if children have larger natural sizes	23		// enables GTK to respect the 50/50 ratio even if children have larger natural sizes
23		24

@@ -43,6 +44,8 @@ func TestNewSplitView_Horizontal(t *testing.T) {
43		44
44	mockFactory.EXPECT().NewPaned(layout.OrientationHorizontal).Return(mockPaned).Once()	45		mockFactory.EXPECT().NewPaned(layout.OrientationHorizontal).Return(mockPaned).Once()
45	setupSplitViewMocks(mockPaned, layout.OrientationHorizontal)	46		setupSplitViewMocks(mockPaned, layout.OrientationHorizontal)
		47	+	mockStartChild.EXPECT().SetVisible(true).Once()
		48	+	mockEndChild.EXPECT().SetVisible(true).Once()
46	mockPaned.EXPECT().SetStartChild(mockStartChild).Once()	49		mockPaned.EXPECT().SetStartChild(mockStartChild).Once()
47	mockPaned.EXPECT().SetEndChild(mockEndChild).Once()	50		mockPaned.EXPECT().SetEndChild(mockEndChild).Once()
48		51

@@ -67,6 +70,8 @@ func TestNewSplitView_Vertical(t *testing.T) {
67		70
68	mockFactory.EXPECT().NewPaned(layout.OrientationVertical).Return(mockPaned).Once()	71		mockFactory.EXPECT().NewPaned(layout.OrientationVertical).Return(mockPaned).Once()
69	setupSplitViewMocks(mockPaned, layout.OrientationVertical)	72		setupSplitViewMocks(mockPaned, layout.OrientationVertical)
		73	+	mockStartChild.EXPECT().SetVisible(true).Once()
		74	+	mockEndChild.EXPECT().SetVisible(true).Once()
70	mockPaned.EXPECT().SetStartChild(mockStartChild).Once()	75		mockPaned.EXPECT().SetStartChild(mockStartChild).Once()
71	mockPaned.EXPECT().SetEndChild(mockEndChild).Once()	76		mockPaned.EXPECT().SetEndChild(mockEndChild).Once()
72		77

@@ -174,6 +179,7 @@ func TestSwapStart_ReplacesChild(t *testing.T) {
174		179
175	mockFactory.EXPECT().NewPaned(mock.Anything).Return(mockPaned).Once()	180		mockFactory.EXPECT().NewPaned(mock.Anything).Return(mockPaned).Once()
176	setupSplitViewMocks(mockPaned, layout.OrientationHorizontal)	181		setupSplitViewMocks(mockPaned, layout.OrientationHorizontal)
		182	+	mockOldChild.EXPECT().SetVisible(true).Once()
177	mockPaned.EXPECT().SetStartChild(mockOldChild).Once()	183		mockPaned.EXPECT().SetStartChild(mockOldChild).Once()
178		184
179	sv := layout.NewSplitView(ctx, mockFactory, layout.OrientationHorizontal, mockOldChild, nil, 0.5)	185		sv := layout.NewSplitView(ctx, mockFactory, layout.OrientationHorizontal, mockOldChild, nil, 0.5)

@@ -199,6 +205,7 @@ func TestSwapEnd_ReplacesChild(t *testing.T) {
199		205
200	mockFactory.EXPECT().NewPaned(mock.Anything).Return(mockPaned).Once()	206		mockFactory.EXPECT().NewPaned(mock.Anything).Return(mockPaned).Once()
201	setupSplitViewMocks(mockPaned, layout.OrientationHorizontal)	207		setupSplitViewMocks(mockPaned, layout.OrientationHorizontal)
		208	+	mockOldChild.EXPECT().SetVisible(true).Once()
202	mockPaned.EXPECT().SetEndChild(mockOldChild).Once()	209		mockPaned.EXPECT().SetEndChild(mockOldChild).Once()
203		210
204	sv := layout.NewSplitView(ctx, mockFactory, layout.OrientationHorizontal, nil, mockOldChild, 0.5)	211		sv := layout.NewSplitView(ctx, mockFactory, layout.OrientationHorizontal, nil, mockOldChild, 0.5)

@@ -245,6 +252,7 @@ func TestSwapEnd_ToNil(t *testing.T) {
245		252
246	mockFactory.EXPECT().NewPaned(mock.Anything).Return(mockPaned).Once()	253		mockFactory.EXPECT().NewPaned(mock.Anything).Return(mockPaned).Once()
247	setupSplitViewMocks(mockPaned, layout.OrientationHorizontal)	254		setupSplitViewMocks(mockPaned, layout.OrientationHorizontal)
		255	+	mockOldChild.EXPECT().SetVisible(true).Once()
248	mockPaned.EXPECT().SetEndChild(mockOldChild).Once()	256		mockPaned.EXPECT().SetEndChild(mockOldChild).Once()
249		257
250	sv := layout.NewSplitView(ctx, mockFactory, layout.OrientationHorizontal, nil, mockOldChild, 0.5)	258		sv := layout.NewSplitView(ctx, mockFactory, layout.OrientationHorizontal, nil, mockOldChild, 0.5)

M internal/ui/layout/stacked_test.go +3 -0


@@ -37,6 +37,7 @@ func setupPaneMocks(t testing.T, mockFactory mocks.MockWidgetFactory, mockBox
37	37		// Title bar creation
38	38		mockFactory.EXPECT().NewBox(layout.OrientationHorizontal, 4).Return(mockTitleBar).Once()
39	39		mockTitleBar.EXPECT().AddCssClass("stacked-pane-titlebar").Once()
	40	+	mockTitleBar.EXPECT().SetVexpand(false).Once()
40	41
41	42		// Favicon
42	43		mockFactory.EXPECT().NewImage().Return(mockFavicon).Once()

@@ -57,6 +58,8 @@ func setupPaneMocks(t testing.T, mockFactory mocks.MockWidgetFactory, mockBox
57	58		mockButton.EXPECT().SetChild(mockTitleBar).Once()
58	59		mockButton.EXPECT().AddCssClass("stacked-pane-title-button").Once()
59	60		mockButton.EXPECT().SetFocusOnClick(false).Once()
	61	+	mockButton.EXPECT().SetVexpand(false).Once()
	62	+	mockButton.EXPECT().SetHexpand(true).Once()
60	63		mockButton.EXPECT().ConnectClicked(mock.Anything).Return(uint32(1)).Once()
61	64
62	65		// Adding to main box


@@ -37,6 +37,7 @@ func setupPaneMocks(t testing.T, mockFactory mocks.MockWidgetFactory, mockBox
37	// Title bar creation	37		// Title bar creation
38	mockFactory.EXPECT().NewBox(layout.OrientationHorizontal, 4).Return(mockTitleBar).Once()	38		mockFactory.EXPECT().NewBox(layout.OrientationHorizontal, 4).Return(mockTitleBar).Once()
39	mockTitleBar.EXPECT().AddCssClass("stacked-pane-titlebar").Once()	39		mockTitleBar.EXPECT().AddCssClass("stacked-pane-titlebar").Once()
		40	+	mockTitleBar.EXPECT().SetVexpand(false).Once()
40		41
41	// Favicon	42		// Favicon
42	mockFactory.EXPECT().NewImage().Return(mockFavicon).Once()	43		mockFactory.EXPECT().NewImage().Return(mockFavicon).Once()

@@ -57,6 +58,8 @@ func setupPaneMocks(t testing.T, mockFactory mocks.MockWidgetFactory, mockBox
57	mockButton.EXPECT().SetChild(mockTitleBar).Once()	58		mockButton.EXPECT().SetChild(mockTitleBar).Once()
58	mockButton.EXPECT().AddCssClass("stacked-pane-title-button").Once()	59		mockButton.EXPECT().AddCssClass("stacked-pane-title-button").Once()
59	mockButton.EXPECT().SetFocusOnClick(false).Once()	60		mockButton.EXPECT().SetFocusOnClick(false).Once()
		61	+	mockButton.EXPECT().SetVexpand(false).Once()
		62	+	mockButton.EXPECT().SetHexpand(true).Once()
60	mockButton.EXPECT().ConnectClicked(mock.Anything).Return(uint32(1)).Once()	63		mockButton.EXPECT().ConnectClicked(mock.Anything).Return(uint32(1)).Once()
61		64
62	// Adding to main box	65		// Adding to main box

M internal/ui/layout/tree_test.go +87 -67


@@ -13,6 +13,20 @@ import (
13	13		"github.com/bnema/dumber/internal/ui/layout/mocks"
14	14		)
15	15
	16	+	func setupStackedLeafMocks(t testing.T, mockFactory mocks.MockWidgetFactory) (mocks.MockBoxWidget, mocks.MockWidget) {
	17	+	mockStackBox := mocks.NewMockBoxWidget(t)
	18	+	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockStackBox).Once()
	19	+	mockStackBox.EXPECT().SetHexpand(true).Once()
	20	+	mockStackBox.EXPECT().SetVexpand(true).Once()
	21	+
	22	+	mockTitleBar, _, _, _, mockContainer := setupPaneMocks(t, mockFactory, mockStackBox)
	23	+	mockTitleBar.EXPECT().GetParent().Return(nil).Maybe()
	24	+	mockContainer.EXPECT().SetVisible(true).Once()
	25	+	mockTitleBar.EXPECT().AddCssClass("active").Once()
	26	+
	27	+	return mockStackBox, mockContainer
	28	+	}
	29	+
16	30		func TestNewTreeRenderer_CreatesRenderer(t *testing.T) {
17	31		// Arrange
18	32		ctx := context.Background()

@@ -48,7 +62,7 @@ func TestBuild_SingleLeafPane(t *testing.T) {
48	62		ctx := context.Background()
49	63		mockFactory := mocks.NewMockWidgetFactory(t)
50	64		mockPaneViewFactory := mocks.NewMockPaneViewFactory(t)
51		-	mockWidget := mocks.NewMockWidget(t)
	65	+	mockStackBox, mockContainer := setupStackedLeafMocks(t, mockFactory)
52	66
53	67		pane := entity.NewPane(entity.PaneID("pane-1"))
54	68		node := &entity.PaneNode{

@@ -56,7 +70,7 @@ func TestBuild_SingleLeafPane(t *testing.T) {
56	70		Pane: pane,
57	71		}
58	72
59		-	mockPaneViewFactory.EXPECT().CreatePaneView(node).Return(mockWidget).Once()
	73	+	mockPaneViewFactory.EXPECT().CreatePaneView(node).Return(mockContainer).Once()
60	74
61	75		renderer := layout.NewTreeRenderer(ctx, mockFactory, mockPaneViewFactory)
62	76

@@ -65,11 +79,11 @@ func TestBuild_SingleLeafPane(t *testing.T) {
65	79
66	80		// Assert
67	81		require.NoError(t, err)
68		-	assert.Equal(t, mockWidget, widget)
	82	+	assert.Equal(t, mockStackBox, widget)
69	83		assert.Equal(t, 1, renderer.NodeCount())
70	84
71	85		// Verify lookup works
72		-	assert.Equal(t, mockWidget, renderer.Lookup("node-1"))
	86	+	assert.Equal(t, mockStackBox, renderer.Lookup("node-1"))
73	87		}
74	88
75	89		func TestBuild_HorizontalSplit(t *testing.T) {

@@ -78,8 +92,8 @@ func TestBuild_HorizontalSplit(t *testing.T) {
78	92		mockFactory := mocks.NewMockWidgetFactory(t)
79	93		mockPaneViewFactory := mocks.NewMockPaneViewFactory(t)
80	94		mockPaned := mocks.NewMockPanedWidget(t)
81		-	mockLeftWidget := mocks.NewMockWidget(t)
82		-	mockRightWidget := mocks.NewMockWidget(t)
	95	+	mockLeftStackBox, mockLeftContainer := setupStackedLeafMocks(t, mockFactory)
	96	+	mockRightStackBox, mockRightContainer := setupStackedLeafMocks(t, mockFactory)
83	97
84	98		leftPane := entity.NewPane(entity.PaneID("pane-left"))
85	99		rightPane := entity.NewPane(entity.PaneID("pane-right"))

@@ -94,17 +108,18 @@ func TestBuild_HorizontalSplit(t *testing.T) {
94	108		Children: []*entity.PaneNode{leftNode, rightNode},
95	109		}
96	110
97		-	mockPaneViewFactory.EXPECT().CreatePaneView(leftNode).Return(mockLeftWidget).Once()
98		-	mockPaneViewFactory.EXPECT().CreatePaneView(rightNode).Return(mockRightWidget).Once()
	111	+	mockPaneViewFactory.EXPECT().CreatePaneView(leftNode).Return(mockLeftContainer).Once()
	112	+	mockPaneViewFactory.EXPECT().CreatePaneView(rightNode).Return(mockRightContainer).Once()
99	113
100	114		// SplitView creation expectations
101	115		mockFactory.EXPECT().NewPaned(layout.OrientationHorizontal).Return(mockPaned).Once()
102	116		mockPaned.EXPECT().SetResizeStartChild(true).Once()
103	117		mockPaned.EXPECT().SetResizeEndChild(true).Once()
104		-	mockPaned.EXPECT().SetShrinkStartChild(false).Once()
105		-	mockPaned.EXPECT().SetShrinkEndChild(false).Once()
106		-	mockPaned.EXPECT().SetStartChild(mockLeftWidget).Once()
107		-	mockPaned.EXPECT().SetEndChild(mockRightWidget).Once()
	118	+	mockPaned.EXPECT().SetVisible(true).Once()
	119	+	mockLeftStackBox.EXPECT().SetVisible(true).Once()
	120	+	mockRightStackBox.EXPECT().SetVisible(true).Once()
	121	+	mockPaned.EXPECT().SetStartChild(mockLeftStackBox).Once()
	122	+	mockPaned.EXPECT().SetEndChild(mockRightStackBox).Once()
108	123		mockPaned.EXPECT().GetAllocatedWidth().Return(0).Once()
109	124		mockPaned.EXPECT().ConnectMap(mock.Anything).Return(uint32(0)).Once()
110	125		mockPaned.EXPECT().AddTickCallback(mock.Anything).Return(uint(0)).Once()

@@ -126,8 +141,8 @@ func TestBuild_VerticalSplit(t *testing.T) {
126	141		mockFactory := mocks.NewMockWidgetFactory(t)
127	142		mockPaneViewFactory := mocks.NewMockPaneViewFactory(t)
128	143		mockPaned := mocks.NewMockPanedWidget(t)
129		-	mockTopWidget := mocks.NewMockWidget(t)
130		-	mockBottomWidget := mocks.NewMockWidget(t)
	144	+	mockTopStackBox, mockTopContainer := setupStackedLeafMocks(t, mockFactory)
	145	+	mockBottomStackBox, mockBottomContainer := setupStackedLeafMocks(t, mockFactory)
131	146
132	147		topPane := entity.NewPane(entity.PaneID("pane-top"))
133	148		bottomPane := entity.NewPane(entity.PaneID("pane-bottom"))

@@ -142,17 +157,18 @@ func TestBuild_VerticalSplit(t *testing.T) {
142	157		Children: []*entity.PaneNode{topNode, bottomNode},
143	158		}
144	159
145		-	mockPaneViewFactory.EXPECT().CreatePaneView(topNode).Return(mockTopWidget).Once()
146		-	mockPaneViewFactory.EXPECT().CreatePaneView(bottomNode).Return(mockBottomWidget).Once()
	160	+	mockPaneViewFactory.EXPECT().CreatePaneView(topNode).Return(mockTopContainer).Once()
	161	+	mockPaneViewFactory.EXPECT().CreatePaneView(bottomNode).Return(mockBottomContainer).Once()
147	162
148	163		// SplitView creation expectations - should be vertical
149	164		mockFactory.EXPECT().NewPaned(layout.OrientationVertical).Return(mockPaned).Once()
150	165		mockPaned.EXPECT().SetResizeStartChild(true).Once()
151	166		mockPaned.EXPECT().SetResizeEndChild(true).Once()
152		-	mockPaned.EXPECT().SetShrinkStartChild(false).Once()
153		-	mockPaned.EXPECT().SetShrinkEndChild(false).Once()
154		-	mockPaned.EXPECT().SetStartChild(mockTopWidget).Once()
155		-	mockPaned.EXPECT().SetEndChild(mockBottomWidget).Once()
	167	+	mockPaned.EXPECT().SetVisible(true).Once()
	168	+	mockTopStackBox.EXPECT().SetVisible(true).Once()
	169	+	mockBottomStackBox.EXPECT().SetVisible(true).Once()
	170	+	mockPaned.EXPECT().SetStartChild(mockTopStackBox).Once()
	171	+	mockPaned.EXPECT().SetEndChild(mockBottomStackBox).Once()
156	172		mockPaned.EXPECT().GetAllocatedHeight().Return(0).Once()
157	173		mockPaned.EXPECT().ConnectMap(mock.Anything).Return(uint32(0)).Once()
158	174		mockPaned.EXPECT().AddTickCallback(mock.Anything).Return(uint(0)).Once()

@@ -174,9 +190,9 @@ func TestBuild_NestedSplits(t *testing.T) {
174	190		mockPaneViewFactory := mocks.NewMockPaneViewFactory(t)
175	191		mockOuterPaned := mocks.NewMockPanedWidget(t)
176	192		mockInnerPaned := mocks.NewMockPanedWidget(t)
177		-	mockWidget1 := mocks.NewMockWidget(t)
178		-	mockWidget2 := mocks.NewMockWidget(t)
179		-	mockWidget3 := mocks.NewMockWidget(t)
	193	+	mockStackBox1, mockContainer1 := setupStackedLeafMocks(t, mockFactory)
	194	+	mockStackBox2, mockContainer2 := setupStackedLeafMocks(t, mockFactory)
	195	+	mockStackBox3, mockContainer3 := setupStackedLeafMocks(t, mockFactory)
180	196
181	197		// Create tree structure:
182	198		// outer (horizontal)

@@ -208,18 +224,19 @@ func TestBuild_NestedSplits(t *testing.T) {
208	224		}
209	225
210	226		// Setup expectations for leaf nodes
211		-	mockPaneViewFactory.EXPECT().CreatePaneView(node1).Return(mockWidget1).Once()
212		-	mockPaneViewFactory.EXPECT().CreatePaneView(node2).Return(mockWidget2).Once()
213		-	mockPaneViewFactory.EXPECT().CreatePaneView(node3).Return(mockWidget3).Once()
	227	+	mockPaneViewFactory.EXPECT().CreatePaneView(node1).Return(mockContainer1).Once()
	228	+	mockPaneViewFactory.EXPECT().CreatePaneView(node2).Return(mockContainer2).Once()
	229	+	mockPaneViewFactory.EXPECT().CreatePaneView(node3).Return(mockContainer3).Once()
214	230
215	231		// Inner split (vertical) is created first
216	232		mockFactory.EXPECT().NewPaned(layout.OrientationVertical).Return(mockInnerPaned).Once()
217	233		mockInnerPaned.EXPECT().SetResizeStartChild(true).Once()
218	234		mockInnerPaned.EXPECT().SetResizeEndChild(true).Once()
219		-	mockInnerPaned.EXPECT().SetShrinkStartChild(false).Once()
220		-	mockInnerPaned.EXPECT().SetShrinkEndChild(false).Once()
221		-	mockInnerPaned.EXPECT().SetStartChild(mockWidget1).Once()
222		-	mockInnerPaned.EXPECT().SetEndChild(mockWidget2).Once()
	235	+	mockInnerPaned.EXPECT().SetVisible(true).Once()
	236	+	mockStackBox1.EXPECT().SetVisible(true).Once()
	237	+	mockStackBox2.EXPECT().SetVisible(true).Once()
	238	+	mockInnerPaned.EXPECT().SetStartChild(mockStackBox1).Once()
	239	+	mockInnerPaned.EXPECT().SetEndChild(mockStackBox2).Once()
223	240		mockInnerPaned.EXPECT().GetAllocatedHeight().Return(0).Once()
224	241		mockInnerPaned.EXPECT().ConnectMap(mock.Anything).Return(uint32(0)).Once()
225	242		mockInnerPaned.EXPECT().AddTickCallback(mock.Anything).Return(uint(0)).Once()

@@ -228,10 +245,11 @@ func TestBuild_NestedSplits(t *testing.T) {
228	245		mockFactory.EXPECT().NewPaned(layout.OrientationHorizontal).Return(mockOuterPaned).Once()
229	246		mockOuterPaned.EXPECT().SetResizeStartChild(true).Once()
230	247		mockOuterPaned.EXPECT().SetResizeEndChild(true).Once()
231		-	mockOuterPaned.EXPECT().SetShrinkStartChild(false).Once()
232		-	mockOuterPaned.EXPECT().SetShrinkEndChild(false).Once()
	248	+	mockOuterPaned.EXPECT().SetVisible(true).Once()
	249	+	mockInnerPaned.EXPECT().SetVisible(true).Once()
	250	+	mockStackBox3.EXPECT().SetVisible(true).Once()
233	251		mockOuterPaned.EXPECT().SetStartChild(mockInnerPaned).Once()
234		-	mockOuterPaned.EXPECT().SetEndChild(mockWidget3).Once()
	252	+	mockOuterPaned.EXPECT().SetEndChild(mockStackBox3).Once()
235	253		mockOuterPaned.EXPECT().GetAllocatedWidth().Return(0).Once()
236	254		mockOuterPaned.EXPECT().ConnectMap(mock.Anything).Return(uint32(0)).Once()
237	255		mockOuterPaned.EXPECT().AddTickCallback(mock.Anything).Return(uint(0)).Once()

@@ -257,12 +275,12 @@ func TestLookup_ExistingNode(t *testing.T) {
257	275		ctx := context.Background()
258	276		mockFactory := mocks.NewMockWidgetFactory(t)
259	277		mockPaneViewFactory := mocks.NewMockPaneViewFactory(t)
260		-	mockWidget := mocks.NewMockWidget(t)
	278	+	mockStackBox, mockContainer := setupStackedLeafMocks(t, mockFactory)
261	279
262	280		pane := entity.NewPane(entity.PaneID("pane-1"))
263	281		node := &entity.PaneNode{ID: "test-node-id", Pane: pane}
264	282
265		-	mockPaneViewFactory.EXPECT().CreatePaneView(node).Return(mockWidget).Once()
	283	+	mockPaneViewFactory.EXPECT().CreatePaneView(node).Return(mockContainer).Once()
266	284
267	285		renderer := layout.NewTreeRenderer(ctx, mockFactory, mockPaneViewFactory)
268	286		_, _ = renderer.Build(ctx, node)

@@ -271,7 +289,7 @@ func TestLookup_ExistingNode(t *testing.T) {
271	289		result := renderer.Lookup("test-node-id")
272	290
273	291		// Assert
274		-	assert.Equal(t, mockWidget, result)
	292	+	assert.Equal(t, mockStackBox, result)
275	293		}
276	294
277	295		func TestLookup_NonExistentNode(t *testing.T) {

@@ -279,12 +297,12 @@ func TestLookup_NonExistentNode(t *testing.T) {
279	297		ctx := context.Background()
280	298		mockFactory := mocks.NewMockWidgetFactory(t)
281	299		mockPaneViewFactory := mocks.NewMockPaneViewFactory(t)
282		-	mockWidget := mocks.NewMockWidget(t)
	300	+	_, mockContainer := setupStackedLeafMocks(t, mockFactory)
283	301
284	302		pane := entity.NewPane(entity.PaneID("pane-1"))
285	303		node := &entity.PaneNode{ID: "node-1", Pane: pane}
286	304
287		-	mockPaneViewFactory.EXPECT().CreatePaneView(node).Return(mockWidget).Once()
	305	+	mockPaneViewFactory.EXPECT().CreatePaneView(node).Return(mockContainer).Once()
288	306
289	307		renderer := layout.NewTreeRenderer(ctx, mockFactory, mockPaneViewFactory)
290	308		_, _ = renderer.Build(ctx, node)

@@ -301,12 +319,12 @@ func TestLookupNode_Existing(t *testing.T) {
301	319		ctx := context.Background()
302	320		mockFactory := mocks.NewMockWidgetFactory(t)
303	321		mockPaneViewFactory := mocks.NewMockPaneViewFactory(t)
304		-	mockWidget := mocks.NewMockWidget(t)
	322	+	mockStackBox, mockContainer := setupStackedLeafMocks(t, mockFactory)
305	323
306	324		pane := entity.NewPane(entity.PaneID("pane-1"))
307	325		node := &entity.PaneNode{ID: "node-1", Pane: pane}
308	326
309		-	mockPaneViewFactory.EXPECT().CreatePaneView(node).Return(mockWidget).Once()
	327	+	mockPaneViewFactory.EXPECT().CreatePaneView(node).Return(mockContainer).Once()
310	328
311	329		renderer := layout.NewTreeRenderer(ctx, mockFactory, mockPaneViewFactory)
312	330		_, _ = renderer.Build(ctx, node)

@@ -316,7 +334,7 @@ func TestLookupNode_Existing(t *testing.T) {
316	334
317	335		// Assert
318	336		assert.True(t, found)
319		-	assert.Equal(t, mockWidget, widget)
	337	+	assert.Equal(t, mockStackBox, widget)
320	338		}
321	339
322	340		func TestLookupNode_NonExistent(t *testing.T) {

@@ -340,12 +358,12 @@ func TestClear_RemovesAllMappings(t *testing.T) {
340	358		ctx := context.Background()
341	359		mockFactory := mocks.NewMockWidgetFactory(t)
342	360		mockPaneViewFactory := mocks.NewMockPaneViewFactory(t)
343		-	mockWidget := mocks.NewMockWidget(t)
	361	+	_, mockContainer := setupStackedLeafMocks(t, mockFactory)
344	362
345	363		pane := entity.NewPane(entity.PaneID("pane-1"))
346	364		node := &entity.PaneNode{ID: "node-1", Pane: pane}
347	365
348		-	mockPaneViewFactory.EXPECT().CreatePaneView(node).Return(mockWidget).Once()
	366	+	mockPaneViewFactory.EXPECT().CreatePaneView(node).Return(mockContainer).Once()
349	367
350	368		renderer := layout.NewTreeRenderer(ctx, mockFactory, mockPaneViewFactory)
351	369		_, _ = renderer.Build(ctx, node)

@@ -366,8 +384,8 @@ func TestGetNodeIDs_ReturnsAllIDs(t *testing.T) {
366	384		ctx := context.Background()
367	385		mockPaneViewFactory := mocks.NewMockPaneViewFactory(t)
368	386		mockPaned := mocks.NewMockPanedWidget(t)
369		-	mockWidget1 := mocks.NewMockWidget(t)
370		-	mockWidget2 := mocks.NewMockWidget(t)
	387	+	mockLeftStackBox, mockLeftContainer := setupStackedLeafMocks(t, mockFactory)
	388	+	mockRightStackBox, mockRightContainer := setupStackedLeafMocks(t, mockFactory)
371	389
372	390		pane1 := entity.NewPane(entity.PaneID("pane-1"))
373	391		pane2 := entity.NewPane(entity.PaneID("pane-2"))

@@ -382,16 +400,17 @@ func TestGetNodeIDs_ReturnsAllIDs(t *testing.T) {
382	400		Children: []*entity.PaneNode{node1, node2},
383	401		}
384	402
385		-	mockPaneViewFactory.EXPECT().CreatePaneView(node1).Return(mockWidget1).Once()
386		-	mockPaneViewFactory.EXPECT().CreatePaneView(node2).Return(mockWidget2).Once()
	403	+	mockPaneViewFactory.EXPECT().CreatePaneView(node1).Return(mockLeftContainer).Once()
	404	+	mockPaneViewFactory.EXPECT().CreatePaneView(node2).Return(mockRightContainer).Once()
387	405
388	406		mockFactory.EXPECT().NewPaned(layout.OrientationHorizontal).Return(mockPaned).Once()
389	407		mockPaned.EXPECT().SetResizeStartChild(true).Once()
390	408		mockPaned.EXPECT().SetResizeEndChild(true).Once()
391		-	mockPaned.EXPECT().SetShrinkStartChild(false).Once()
392		-	mockPaned.EXPECT().SetShrinkEndChild(false).Once()
393		-	mockPaned.EXPECT().SetStartChild(mockWidget1).Once()
394		-	mockPaned.EXPECT().SetEndChild(mockWidget2).Once()
	409	+	mockPaned.EXPECT().SetVisible(true).Once()
	410	+	mockLeftStackBox.EXPECT().SetVisible(true).Once()
	411	+	mockRightStackBox.EXPECT().SetVisible(true).Once()
	412	+	mockPaned.EXPECT().SetStartChild(mockLeftStackBox).Once()
	413	+	mockPaned.EXPECT().SetEndChild(mockRightStackBox).Once()
395	414		mockPaned.EXPECT().GetAllocatedWidth().Return(0).Once()
396	415		mockPaned.EXPECT().ConnectMap(mock.Anything).Return(uint32(0)).Once()
397	416		mockPaned.EXPECT().AddTickCallback(mock.Anything).Return(uint(0)).Once()

@@ -414,8 +433,8 @@ func TestBuild_ClearsPreviousMappings(t *testing.T) {
414	433		ctx := context.Background()
415	434		mockFactory := mocks.NewMockWidgetFactory(t)
416	435		mockPaneViewFactory := mocks.NewMockPaneViewFactory(t)
417		-	mockWidget1 := mocks.NewMockWidget(t)
418		-	mockWidget2 := mocks.NewMockWidget(t)
	436	+	mockOldStackBox, mockOldContainer := setupStackedLeafMocks(t, mockFactory)
	437	+	mockNewStackBox, mockNewContainer := setupStackedLeafMocks(t, mockFactory)
419	438
420	439		pane1 := entity.NewPane(entity.PaneID("pane-1"))
421	440		node1 := &entity.PaneNode{ID: "old-node", Pane: pane1}

@@ -423,15 +442,15 @@ func TestBuild_ClearsPreviousMappings(t *testing.T) {
423	442		pane2 := entity.NewPane(entity.PaneID("pane-2"))
424	443		node2 := &entity.PaneNode{ID: "new-node", Pane: pane2}
425	444
426		-	mockPaneViewFactory.EXPECT().CreatePaneView(node1).Return(mockWidget1).Once()
427		-	mockPaneViewFactory.EXPECT().CreatePaneView(node2).Return(mockWidget2).Once()
	445	+	mockPaneViewFactory.EXPECT().CreatePaneView(node1).Return(mockOldContainer).Once()
	446	+	mockPaneViewFactory.EXPECT().CreatePaneView(node2).Return(mockNewContainer).Once()
428	447
429	448		renderer := layout.NewTreeRenderer(ctx, mockFactory, mockPaneViewFactory)
430	449
431	450		// First build
432	451		_, _ = renderer.Build(ctx, node1)
433	452		require.Equal(t, 1, renderer.NodeCount())
434		-	require.NotNil(t, renderer.Lookup("old-node"))
	453	+	require.Equal(t, mockOldStackBox, renderer.Lookup("old-node"))
435	454
436	455		// Act - second build should clear old mappings
437	456		_, _ = renderer.Build(ctx, node2)

@@ -439,7 +458,7 @@ func TestBuild_ClearsPreviousMappings(t *testing.T) {
439	458		// Assert
440	459		assert.Equal(t, 1, renderer.NodeCount())
441	460		assert.Nil(t, renderer.Lookup("old-node"))
442		-	assert.NotNil(t, renderer.Lookup("new-node"))
	461	+	assert.Equal(t, mockNewStackBox, renderer.Lookup("new-node"))
443	462		}
444	463
445	464		func TestBuild_NilPaneViewFactory_ReturnsNilForLeaves(t *testing.T) {

@@ -465,12 +484,12 @@ func TestBuild_EmptyNodeID_NotStored(t *testing.T) {
465	484		ctx := context.Background()
466	485		mockFactory := mocks.NewMockWidgetFactory(t)
467	486		mockPaneViewFactory := mocks.NewMockPaneViewFactory(t)
468		-	mockWidget := mocks.NewMockWidget(t)
	487	+	_, mockContainer := setupStackedLeafMocks(t, mockFactory)
469	488
470	489		pane := entity.NewPane(entity.PaneID("pane-1"))
471	490		node := &entity.PaneNode{ID: "", Pane: pane} // Empty ID
472	491
473		-	mockPaneViewFactory.EXPECT().CreatePaneView(node).Return(mockWidget).Once()
	492	+	mockPaneViewFactory.EXPECT().CreatePaneView(node).Return(mockContainer).Once()
474	493
475	494		renderer := layout.NewTreeRenderer(ctx, mockFactory, mockPaneViewFactory)
476	495

@@ -489,8 +508,8 @@ func TestUpdateSplitRatio_ExistingNode(t *testing.T) {
489	508		ctx := context.Background()
490	509		mockPaneViewFactory := mocks.NewMockPaneViewFactory(t)
491	510		mockPaned := mocks.NewMockPanedWidget(t)
492		-	mockWidget1 := mocks.NewMockWidget(t)
493		-	mockWidget2 := mocks.NewMockWidget(t)
	511	+	mockLeftStackBox, mockLeftContainer := setupStackedLeafMocks(t, mockFactory)
	512	+	mockRightStackBox, mockRightContainer := setupStackedLeafMocks(t, mockFactory)
494	513
495	514		pane1 := entity.NewPane(entity.PaneID("pane-1"))
496	515		pane2 := entity.NewPane(entity.PaneID("pane-2"))

@@ -505,16 +524,17 @@ func TestUpdateSplitRatio_ExistingNode(t *testing.T) {
505	524		Children: []*entity.PaneNode{node1, node2},
506	525		}
507	526
508		-	mockPaneViewFactory.EXPECT().CreatePaneView(node1).Return(mockWidget1).Once()
509		-	mockPaneViewFactory.EXPECT().CreatePaneView(node2).Return(mockWidget2).Once()
	527	+	mockPaneViewFactory.EXPECT().CreatePaneView(node1).Return(mockLeftContainer).Once()
	528	+	mockPaneViewFactory.EXPECT().CreatePaneView(node2).Return(mockRightContainer).Once()
510	529
511	530		mockFactory.EXPECT().NewPaned(layout.OrientationHorizontal).Return(mockPaned).Once()
512	531		mockPaned.EXPECT().SetResizeStartChild(true).Once()
513	532		mockPaned.EXPECT().SetResizeEndChild(true).Once()
514		-	mockPaned.EXPECT().SetShrinkStartChild(false).Once()
515		-	mockPaned.EXPECT().SetShrinkEndChild(false).Once()
516		-	mockPaned.EXPECT().SetStartChild(mockWidget1).Once()
517		-	mockPaned.EXPECT().SetEndChild(mockWidget2).Once()
	533	+	mockPaned.EXPECT().SetVisible(true).Once()
	534	+	mockLeftStackBox.EXPECT().SetVisible(true).Once()
	535	+	mockRightStackBox.EXPECT().SetVisible(true).Once()
	536	+	mockPaned.EXPECT().SetStartChild(mockLeftStackBox).Once()
	537	+	mockPaned.EXPECT().SetEndChild(mockRightStackBox).Once()
518	538		mockPaned.EXPECT().GetAllocatedWidth().Return(0).Once()
519	539		mockPaned.EXPECT().ConnectMap(mock.Anything).Return(uint32(0)).Once()
520	540		mockPaned.EXPECT().AddTickCallback(mock.Anything).Return(uint(0)).Once()

 	"github.com/bnema/dumber/internal/ui/layout/mocks"
 )
+func setupStackedLeafMocks(t *testing.T, mockFactory *mocks.MockWidgetFactory) (*mocks.MockBoxWidget, *mocks.MockWidget) {
+	mockStackBox := mocks.NewMockBoxWidget(t)
+	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockStackBox).Once()
+	mockStackBox.EXPECT().SetHexpand(true).Once()
+	mockStackBox.EXPECT().SetVexpand(true).Once()
+	mockTitleBar, _, _, _, mockContainer := setupPaneMocks(t, mockFactory, mockStackBox)
+	mockTitleBar.EXPECT().GetParent().Return(nil).Maybe()
+	mockContainer.EXPECT().SetVisible(true).Once()
+	mockTitleBar.EXPECT().AddCssClass("active").Once()
+	return mockStackBox, mockContainer
+}
 func TestNewTreeRenderer_CreatesRenderer(t *testing.T) {
 	// Arrange
 	ctx := context.Background()
 	ctx := context.Background()
 	mockFactory := mocks.NewMockWidgetFactory(t)
 	mockPaneViewFactory := mocks.NewMockPaneViewFactory(t)
-	mockWidget := mocks.NewMockWidget(t)
+	mockStackBox, mockContainer := setupStackedLeafMocks(t, mockFactory)
 	pane := entity.NewPane(entity.PaneID("pane-1"))
 	node := &entity.PaneNode{
 		Pane: pane,
 	}
-	mockPaneViewFactory.EXPECT().CreatePaneView(node).Return(mockWidget).Once()
+	mockPaneViewFactory.EXPECT().CreatePaneView(node).Return(mockContainer).Once()
 	renderer := layout.NewTreeRenderer(ctx, mockFactory, mockPaneViewFactory)
 	// Assert
 	require.NoError(t, err)
-	assert.Equal(t, mockWidget, widget)
+	assert.Equal(t, mockStackBox, widget)
 	assert.Equal(t, 1, renderer.NodeCount())
 	// Verify lookup works
-	assert.Equal(t, mockWidget, renderer.Lookup("node-1"))
+	assert.Equal(t, mockStackBox, renderer.Lookup("node-1"))
 }
 func TestBuild_HorizontalSplit(t *testing.T) {
 	mockFactory := mocks.NewMockWidgetFactory(t)
 	mockPaneViewFactory := mocks.NewMockPaneViewFactory(t)
 	mockPaned := mocks.NewMockPanedWidget(t)
-	mockLeftWidget := mocks.NewMockWidget(t)
+	mockLeftStackBox, mockLeftContainer := setupStackedLeafMocks(t, mockFactory)
-	mockRightWidget := mocks.NewMockWidget(t)
+	mockRightStackBox, mockRightContainer := setupStackedLeafMocks(t, mockFactory)
 	leftPane := entity.NewPane(entity.PaneID("pane-left"))
 	rightPane := entity.NewPane(entity.PaneID("pane-right"))
 		Children:   []*entity.PaneNode{leftNode, rightNode},
 	}
-	mockPaneViewFactory.EXPECT().CreatePaneView(leftNode).Return(mockLeftWidget).Once()
+	mockPaneViewFactory.EXPECT().CreatePaneView(leftNode).Return(mockLeftContainer).Once()
-	mockPaneViewFactory.EXPECT().CreatePaneView(rightNode).Return(mockRightWidget).Once()
+	mockPaneViewFactory.EXPECT().CreatePaneView(rightNode).Return(mockRightContainer).Once()
 	// SplitView creation expectations
 	mockFactory.EXPECT().NewPaned(layout.OrientationHorizontal).Return(mockPaned).Once()
 	mockPaned.EXPECT().SetResizeStartChild(true).Once()
 	mockPaned.EXPECT().SetResizeEndChild(true).Once()
-	mockPaned.EXPECT().SetShrinkStartChild(false).Once()
+	mockPaned.EXPECT().SetVisible(true).Once()
-	mockPaned.EXPECT().SetShrinkEndChild(false).Once()
+	mockLeftStackBox.EXPECT().SetVisible(true).Once()
-	mockPaned.EXPECT().SetStartChild(mockLeftWidget).Once()
+	mockRightStackBox.EXPECT().SetVisible(true).Once()
-	mockPaned.EXPECT().SetEndChild(mockRightWidget).Once()
+	mockPaned.EXPECT().SetStartChild(mockLeftStackBox).Once()
+	mockPaned.EXPECT().SetEndChild(mockRightStackBox).Once()
 	mockPaned.EXPECT().GetAllocatedWidth().Return(0).Once()
 	mockPaned.EXPECT().ConnectMap(mock.Anything).Return(uint32(0)).Once()
 	mockPaned.EXPECT().AddTickCallback(mock.Anything).Return(uint(0)).Once()
 	mockFactory := mocks.NewMockWidgetFactory(t)
 	mockPaneViewFactory := mocks.NewMockPaneViewFactory(t)
 	mockPaned := mocks.NewMockPanedWidget(t)
-	mockTopWidget := mocks.NewMockWidget(t)
+	mockTopStackBox, mockTopContainer := setupStackedLeafMocks(t, mockFactory)
-	mockBottomWidget := mocks.NewMockWidget(t)
+	mockBottomStackBox, mockBottomContainer := setupStackedLeafMocks(t, mockFactory)
 	topPane := entity.NewPane(entity.PaneID("pane-top"))
 	bottomPane := entity.NewPane(entity.PaneID("pane-bottom"))
 		Children:   []*entity.PaneNode{topNode, bottomNode},
 	}
-	mockPaneViewFactory.EXPECT().CreatePaneView(topNode).Return(mockTopWidget).Once()
+	mockPaneViewFactory.EXPECT().CreatePaneView(topNode).Return(mockTopContainer).Once()
-	mockPaneViewFactory.EXPECT().CreatePaneView(bottomNode).Return(mockBottomWidget).Once()
+	mockPaneViewFactory.EXPECT().CreatePaneView(bottomNode).Return(mockBottomContainer).Once()
 	// SplitView creation expectations - should be vertical
 	mockFactory.EXPECT().NewPaned(layout.OrientationVertical).Return(mockPaned).Once()
 	mockPaned.EXPECT().SetResizeStartChild(true).Once()
 	mockPaned.EXPECT().SetResizeEndChild(true).Once()
-	mockPaned.EXPECT().SetShrinkStartChild(false).Once()
+	mockPaned.EXPECT().SetVisible(true).Once()
-	mockPaned.EXPECT().SetShrinkEndChild(false).Once()
+	mockTopStackBox.EXPECT().SetVisible(true).Once()
-	mockPaned.EXPECT().SetStartChild(mockTopWidget).Once()
+	mockBottomStackBox.EXPECT().SetVisible(true).Once()
-	mockPaned.EXPECT().SetEndChild(mockBottomWidget).Once()
+	mockPaned.EXPECT().SetStartChild(mockTopStackBox).Once()
+	mockPaned.EXPECT().SetEndChild(mockBottomStackBox).Once()
 	mockPaned.EXPECT().GetAllocatedHeight().Return(0).Once()
 	mockPaned.EXPECT().ConnectMap(mock.Anything).Return(uint32(0)).Once()
 	mockPaned.EXPECT().AddTickCallback(mock.Anything).Return(uint(0)).Once()
 	mockPaneViewFactory := mocks.NewMockPaneViewFactory(t)
 	mockOuterPaned := mocks.NewMockPanedWidget(t)
 	mockInnerPaned := mocks.NewMockPanedWidget(t)
-	mockWidget1 := mocks.NewMockWidget(t)
+	mockStackBox1, mockContainer1 := setupStackedLeafMocks(t, mockFactory)
-	mockWidget2 := mocks.NewMockWidget(t)
+	mockStackBox2, mockContainer2 := setupStackedLeafMocks(t, mockFactory)
-	mockWidget3 := mocks.NewMockWidget(t)
+	mockStackBox3, mockContainer3 := setupStackedLeafMocks(t, mockFactory)
 	// Create tree structure:
 	//       outer (horizontal)
 	}
 	// Setup expectations for leaf nodes
-	mockPaneViewFactory.EXPECT().CreatePaneView(node1).Return(mockWidget1).Once()
+	mockPaneViewFactory.EXPECT().CreatePaneView(node1).Return(mockContainer1).Once()
-	mockPaneViewFactory.EXPECT().CreatePaneView(node2).Return(mockWidget2).Once()
+	mockPaneViewFactory.EXPECT().CreatePaneView(node2).Return(mockContainer2).Once()
-	mockPaneViewFactory.EXPECT().CreatePaneView(node3).Return(mockWidget3).Once()
+	mockPaneViewFactory.EXPECT().CreatePaneView(node3).Return(mockContainer3).Once()
 	// Inner split (vertical) is created first
 	mockFactory.EXPECT().NewPaned(layout.OrientationVertical).Return(mockInnerPaned).Once()
 	mockInnerPaned.EXPECT().SetResizeStartChild(true).Once()
 	mockInnerPaned.EXPECT().SetResizeEndChild(true).Once()
-	mockInnerPaned.EXPECT().SetShrinkStartChild(false).Once()
+	mockInnerPaned.EXPECT().SetVisible(true).Once()
-	mockInnerPaned.EXPECT().SetShrinkEndChild(false).Once()
+	mockStackBox1.EXPECT().SetVisible(true).Once()
-	mockInnerPaned.EXPECT().SetStartChild(mockWidget1).Once()
+	mockStackBox2.EXPECT().SetVisible(true).Once()
-	mockInnerPaned.EXPECT().SetEndChild(mockWidget2).Once()
+	mockInnerPaned.EXPECT().SetStartChild(mockStackBox1).Once()
+	mockInnerPaned.EXPECT().SetEndChild(mockStackBox2).Once()
 	mockInnerPaned.EXPECT().GetAllocatedHeight().Return(0).Once()
 	mockInnerPaned.EXPECT().ConnectMap(mock.Anything).Return(uint32(0)).Once()
 	mockInnerPaned.EXPECT().AddTickCallback(mock.Anything).Return(uint(0)).Once()
 	mockFactory.EXPECT().NewPaned(layout.OrientationHorizontal).Return(mockOuterPaned).Once()
 	mockOuterPaned.EXPECT().SetResizeStartChild(true).Once()
 	mockOuterPaned.EXPECT().SetResizeEndChild(true).Once()
-	mockOuterPaned.EXPECT().SetShrinkStartChild(false).Once()
+	mockOuterPaned.EXPECT().SetVisible(true).Once()
-	mockOuterPaned.EXPECT().SetShrinkEndChild(false).Once()
+	mockInnerPaned.EXPECT().SetVisible(true).Once()
+	mockStackBox3.EXPECT().SetVisible(true).Once()
 	mockOuterPaned.EXPECT().SetStartChild(mockInnerPaned).Once()
-	mockOuterPaned.EXPECT().SetEndChild(mockWidget3).Once()
+	mockOuterPaned.EXPECT().SetEndChild(mockStackBox3).Once()
 	mockOuterPaned.EXPECT().GetAllocatedWidth().Return(0).Once()
 	mockOuterPaned.EXPECT().ConnectMap(mock.Anything).Return(uint32(0)).Once()
 	mockOuterPaned.EXPECT().AddTickCallback(mock.Anything).Return(uint(0)).Once()
 	ctx := context.Background()
 	mockFactory := mocks.NewMockWidgetFactory(t)
 	mockPaneViewFactory := mocks.NewMockPaneViewFactory(t)
-	mockWidget := mocks.NewMockWidget(t)
+	mockStackBox, mockContainer := setupStackedLeafMocks(t, mockFactory)
 	pane := entity.NewPane(entity.PaneID("pane-1"))
 	node := &entity.PaneNode{ID: "test-node-id", Pane: pane}
-	mockPaneViewFactory.EXPECT().CreatePaneView(node).Return(mockWidget).Once()
+	mockPaneViewFactory.EXPECT().CreatePaneView(node).Return(mockContainer).Once()
 	renderer := layout.NewTreeRenderer(ctx, mockFactory, mockPaneViewFactory)
 	_, _ = renderer.Build(ctx, node)
 	result := renderer.Lookup("test-node-id")
 	// Assert
-	assert.Equal(t, mockWidget, result)
+	assert.Equal(t, mockStackBox, result)
 }
 func TestLookup_NonExistentNode(t *testing.T) {
 	ctx := context.Background()
 	mockFactory := mocks.NewMockWidgetFactory(t)
 	mockPaneViewFactory := mocks.NewMockPaneViewFactory(t)
-	mockWidget := mocks.NewMockWidget(t)
+	_, mockContainer := setupStackedLeafMocks(t, mockFactory)
 	pane := entity.NewPane(entity.PaneID("pane-1"))
 	node := &entity.PaneNode{ID: "node-1", Pane: pane}
-	mockPaneViewFactory.EXPECT().CreatePaneView(node).Return(mockWidget).Once()
+	mockPaneViewFactory.EXPECT().CreatePaneView(node).Return(mockContainer).Once()
 	renderer := layout.NewTreeRenderer(ctx, mockFactory, mockPaneViewFactory)
 	_, _ = renderer.Build(ctx, node)
 	ctx := context.Background()
 	mockFactory := mocks.NewMockWidgetFactory(t)
 	mockPaneViewFactory := mocks.NewMockPaneViewFactory(t)
-	mockWidget := mocks.NewMockWidget(t)
+	mockStackBox, mockContainer := setupStackedLeafMocks(t, mockFactory)
 	pane := entity.NewPane(entity.PaneID("pane-1"))
 	node := &entity.PaneNode{ID: "node-1", Pane: pane}
-	mockPaneViewFactory.EXPECT().CreatePaneView(node).Return(mockWidget).Once()
+	mockPaneViewFactory.EXPECT().CreatePaneView(node).Return(mockContainer).Once()
 	renderer := layout.NewTreeRenderer(ctx, mockFactory, mockPaneViewFactory)
 	_, _ = renderer.Build(ctx, node)
 	// Assert
 	assert.True(t, found)
-	assert.Equal(t, mockWidget, widget)
+	assert.Equal(t, mockStackBox, widget)
 }
 func TestLookupNode_NonExistent(t *testing.T) {
 	ctx := context.Background()
 	mockFactory := mocks.NewMockWidgetFactory(t)
 	mockPaneViewFactory := mocks.NewMockPaneViewFactory(t)
-	mockWidget := mocks.NewMockWidget(t)
+	_, mockContainer := setupStackedLeafMocks(t, mockFactory)
 	pane := entity.NewPane(entity.PaneID("pane-1"))
 	node := &entity.PaneNode{ID: "node-1", Pane: pane}
-	mockPaneViewFactory.EXPECT().CreatePaneView(node).Return(mockWidget).Once()
+	mockPaneViewFactory.EXPECT().CreatePaneView(node).Return(mockContainer).Once()
 	renderer := layout.NewTreeRenderer(ctx, mockFactory, mockPaneViewFactory)
 	_, _ = renderer.Build(ctx, node)
 	ctx := context.Background()
 	mockPaneViewFactory := mocks.NewMockPaneViewFactory(t)
 	mockPaned := mocks.NewMockPanedWidget(t)
-	mockWidget1 := mocks.NewMockWidget(t)
+	mockLeftStackBox, mockLeftContainer := setupStackedLeafMocks(t, mockFactory)
-	mockWidget2 := mocks.NewMockWidget(t)
+	mockRightStackBox, mockRightContainer := setupStackedLeafMocks(t, mockFactory)
 	pane1 := entity.NewPane(entity.PaneID("pane-1"))
 	pane2 := entity.NewPane(entity.PaneID("pane-2"))
 		Children:   []*entity.PaneNode{node1, node2},
 	}
-	mockPaneViewFactory.EXPECT().CreatePaneView(node1).Return(mockWidget1).Once()
+	mockPaneViewFactory.EXPECT().CreatePaneView(node1).Return(mockLeftContainer).Once()
-	mockPaneViewFactory.EXPECT().CreatePaneView(node2).Return(mockWidget2).Once()
+	mockPaneViewFactory.EXPECT().CreatePaneView(node2).Return(mockRightContainer).Once()
 	mockFactory.EXPECT().NewPaned(layout.OrientationHorizontal).Return(mockPaned).Once()
 	mockPaned.EXPECT().SetResizeStartChild(true).Once()
 	mockPaned.EXPECT().SetResizeEndChild(true).Once()
-	mockPaned.EXPECT().SetShrinkStartChild(false).Once()
+	mockPaned.EXPECT().SetVisible(true).Once()
-	mockPaned.EXPECT().SetShrinkEndChild(false).Once()
+	mockLeftStackBox.EXPECT().SetVisible(true).Once()
-	mockPaned.EXPECT().SetStartChild(mockWidget1).Once()
+	mockRightStackBox.EXPECT().SetVisible(true).Once()
-	mockPaned.EXPECT().SetEndChild(mockWidget2).Once()
+	mockPaned.EXPECT().SetStartChild(mockLeftStackBox).Once()
+	mockPaned.EXPECT().SetEndChild(mockRightStackBox).Once()
 	mockPaned.EXPECT().GetAllocatedWidth().Return(0).Once()
 	mockPaned.EXPECT().ConnectMap(mock.Anything).Return(uint32(0)).Once()
 	mockPaned.EXPECT().AddTickCallback(mock.Anything).Return(uint(0)).Once()
 	ctx := context.Background()
 	mockFactory := mocks.NewMockWidgetFactory(t)
 	mockPaneViewFactory := mocks.NewMockPaneViewFactory(t)
-	mockWidget1 := mocks.NewMockWidget(t)
+	mockOldStackBox, mockOldContainer := setupStackedLeafMocks(t, mockFactory)
-	mockWidget2 := mocks.NewMockWidget(t)
+	mockNewStackBox, mockNewContainer := setupStackedLeafMocks(t, mockFactory)
 	pane1 := entity.NewPane(entity.PaneID("pane-1"))
 	node1 := &entity.PaneNode{ID: "old-node", Pane: pane1}
 	pane2 := entity.NewPane(entity.PaneID("pane-2"))
 	node2 := &entity.PaneNode{ID: "new-node", Pane: pane2}
-	mockPaneViewFactory.EXPECT().CreatePaneView(node1).Return(mockWidget1).Once()
+	mockPaneViewFactory.EXPECT().CreatePaneView(node1).Return(mockOldContainer).Once()
-	mockPaneViewFactory.EXPECT().CreatePaneView(node2).Return(mockWidget2).Once()
+	mockPaneViewFactory.EXPECT().CreatePaneView(node2).Return(mockNewContainer).Once()
 	renderer := layout.NewTreeRenderer(ctx, mockFactory, mockPaneViewFactory)
 	// First build
 	_, _ = renderer.Build(ctx, node1)
 	require.Equal(t, 1, renderer.NodeCount())
-	require.NotNil(t, renderer.Lookup("old-node"))
+	require.Equal(t, mockOldStackBox, renderer.Lookup("old-node"))
 	// Act - second build should clear old mappings
 	_, _ = renderer.Build(ctx, node2)
 	// Assert
 	assert.Equal(t, 1, renderer.NodeCount())
 	assert.Nil(t, renderer.Lookup("old-node"))
-	assert.NotNil(t, renderer.Lookup("new-node"))
+	assert.Equal(t, mockNewStackBox, renderer.Lookup("new-node"))
 }
 func TestBuild_NilPaneViewFactory_ReturnsNilForLeaves(t *testing.T) {
 	ctx := context.Background()
 	mockFactory := mocks.NewMockWidgetFactory(t)
 	mockPaneViewFactory := mocks.NewMockPaneViewFactory(t)
-	mockWidget := mocks.NewMockWidget(t)
+	_, mockContainer := setupStackedLeafMocks(t, mockFactory)
 	pane := entity.NewPane(entity.PaneID("pane-1"))
 	node := &entity.PaneNode{ID: "", Pane: pane} // Empty ID
-	mockPaneViewFactory.EXPECT().CreatePaneView(node).Return(mockWidget).Once()
+	mockPaneViewFactory.EXPECT().CreatePaneView(node).Return(mockContainer).Once()
 	renderer := layout.NewTreeRenderer(ctx, mockFactory, mockPaneViewFactory)
 	ctx := context.Background()
 	mockPaneViewFactory := mocks.NewMockPaneViewFactory(t)
 	mockPaned := mocks.NewMockPanedWidget(t)
-	mockWidget1 := mocks.NewMockWidget(t)
+	mockLeftStackBox, mockLeftContainer := setupStackedLeafMocks(t, mockFactory)
-	mockWidget2 := mocks.NewMockWidget(t)
+	mockRightStackBox, mockRightContainer := setupStackedLeafMocks(t, mockFactory)
 	pane1 := entity.NewPane(entity.PaneID("pane-1"))
 	pane2 := entity.NewPane(entity.PaneID("pane-2"))
 		Children:   []*entity.PaneNode{node1, node2},
 	}
-	mockPaneViewFactory.EXPECT().CreatePaneView(node1).Return(mockWidget1).Once()
+	mockPaneViewFactory.EXPECT().CreatePaneView(node1).Return(mockLeftContainer).Once()
-	mockPaneViewFactory.EXPECT().CreatePaneView(node2).Return(mockWidget2).Once()
+	mockPaneViewFactory.EXPECT().CreatePaneView(node2).Return(mockRightContainer).Once()
 	mockFactory.EXPECT().NewPaned(layout.OrientationHorizontal).Return(mockPaned).Once()
 	mockPaned.EXPECT().SetResizeStartChild(true).Once()
 	mockPaned.EXPECT().SetResizeEndChild(true).Once()
-	mockPaned.EXPECT().SetShrinkStartChild(false).Once()
+	mockPaned.EXPECT().SetVisible(true).Once()
-	mockPaned.EXPECT().SetShrinkEndChild(false).Once()
+	mockLeftStackBox.EXPECT().SetVisible(true).Once()
-	mockPaned.EXPECT().SetStartChild(mockWidget1).Once()
+	mockRightStackBox.EXPECT().SetVisible(true).Once()
-	mockPaned.EXPECT().SetEndChild(mockWidget2).Once()
+	mockPaned.EXPECT().SetStartChild(mockLeftStackBox).Once()
+	mockPaned.EXPECT().SetEndChild(mockRightStackBox).Once()
 	mockPaned.EXPECT().GetAllocatedWidth().Return(0).Once()
 	mockPaned.EXPECT().ConnectMap(mock.Anything).Return(uint32(0)).Once()
 	mockPaned.EXPECT().AddTickCallback(mock.Anything).Return(uint(0)).Once()