refactor(tests): fix unit testing approach with proper mocking

commit: b1ee2a5463040b275b6de8293ed2f00c75df496e
author: bamen · 13mo ago · 2025-09-19 04:24 UTC
committer: bamen · 13mo ago · 2025-09-19 04:26 UTC
parent: c736f06
signature: unsigned

7 files · +60 -348

M internal/app/browser/browser.go +1 -1


@@ -57,7 +57,7 @@ type BrowserApp struct {
57	57		schemeHandler *api.SchemeHandler
58	58		messageHandler *messaging.Handler
59	59		shortcutHandler *ShortcutHandler
60		-	windowShortcutHandler *WindowShortcutHandler
	60	+	windowShortcutHandler WindowShortcutHandlerInterface
61	61		}
62	62
63	63		// Run starts the browser application


@@ -57,7 +57,7 @@ type BrowserApp struct {
57		schemeHandler *api.SchemeHandler	57		schemeHandler *api.SchemeHandler
58		messageHandler *messaging.Handler	58		messageHandler *messaging.Handler
59		shortcutHandler *ShortcutHandler	59		shortcutHandler *ShortcutHandler
60	-	windowShortcutHandler *WindowShortcutHandler	60	+	windowShortcutHandler WindowShortcutHandlerInterface
61		}	61		}
62			62
63		// Run starts the browser application	63		// Run starts the browser application

M internal/app/browser/interfaces.go +5 -0


@@ -81,3 +81,8 @@ type BrowserAppInterface interface {
81	81		type WindowInterface interface {
82	82		SetChild(widget uintptr)
83	83		}
	84	+
	85	+	// WindowShortcutHandlerInterface abstracts window shortcut handling for testing
	86	+	type WindowShortcutHandlerInterface interface {
	87	+	Cleanup()
	88	+	}


@@ -81,3 +81,8 @@ type BrowserAppInterface interface {
81	type WindowInterface interface {	81		type WindowInterface interface {
82	SetChild(widget uintptr)	82		SetChild(widget uintptr)
83	}	83		}
		84	+
		85	+	// WindowShortcutHandlerInterface abstracts window shortcut handling for testing
		86	+	type WindowShortcutHandlerInterface interface {
		87	+	Cleanup()
		88	+	}

M internal/app/browser/mocks/mock_browser.go +35 -0


@@ -715,3 +715,38 @@ func (mr MockWindowInterfaceMockRecorder) SetChild(widget interface{}) gomock.
715	715		mr.mock.ctrl.T.Helper()
716	716		return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetChild", reflect.TypeOf((*MockWindowInterface)(nil).SetChild), widget)
717	717		}
	718	+
	719	+	// MockWindowShortcutHandlerInterface is a mock of WindowShortcutHandlerInterface interface.
	720	+	type MockWindowShortcutHandlerInterface struct {
	721	+	ctrl *gomock.Controller
	722	+	recorder *MockWindowShortcutHandlerInterfaceMockRecorder
	723	+	}
	724	+
	725	+	// MockWindowShortcutHandlerInterfaceMockRecorder is the mock recorder for MockWindowShortcutHandlerInterface.
	726	+	type MockWindowShortcutHandlerInterfaceMockRecorder struct {
	727	+	mock *MockWindowShortcutHandlerInterface
	728	+	}
	729	+
	730	+	// NewMockWindowShortcutHandlerInterface creates a new mock instance.
	731	+	func NewMockWindowShortcutHandlerInterface(ctrl gomock.Controller) MockWindowShortcutHandlerInterface {
	732	+	mock := &MockWindowShortcutHandlerInterface{ctrl: ctrl}
	733	+	mock.recorder = &MockWindowShortcutHandlerInterfaceMockRecorder{mock}
	734	+	return mock
	735	+	}
	736	+
	737	+	// EXPECT returns an object that allows the caller to indicate expected use.
	738	+	func (m MockWindowShortcutHandlerInterface) EXPECT() MockWindowShortcutHandlerInterfaceMockRecorder {
	739	+	return m.recorder
	740	+	}
	741	+
	742	+	// Cleanup mocks base method.
	743	+	func (m *MockWindowShortcutHandlerInterface) Cleanup() {
	744	+	m.ctrl.T.Helper()
	745	+	m.ctrl.Call(m, "Cleanup")
	746	+	}
	747	+
	748	+	// Cleanup indicates an expected call of Cleanup.
	749	+	func (mr MockWindowShortcutHandlerInterfaceMockRecorder) Cleanup() gomock.Call {
	750	+	mr.mock.ctrl.T.Helper()
	751	+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Cleanup", reflect.TypeOf((*MockWindowShortcutHandlerInterface)(nil).Cleanup))
	752	+	}


@@ -715,3 +715,38 @@ func (mr MockWindowInterfaceMockRecorder) SetChild(widget interface{}) gomock.
715	mr.mock.ctrl.T.Helper()	715		mr.mock.ctrl.T.Helper()
716	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetChild", reflect.TypeOf((*MockWindowInterface)(nil).SetChild), widget)	716		return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetChild", reflect.TypeOf((*MockWindowInterface)(nil).SetChild), widget)
717	}	717		}
		718	+
		719	+	// MockWindowShortcutHandlerInterface is a mock of WindowShortcutHandlerInterface interface.
		720	+	type MockWindowShortcutHandlerInterface struct {
		721	+	ctrl *gomock.Controller
		722	+	recorder *MockWindowShortcutHandlerInterfaceMockRecorder
		723	+	}
		724	+
		725	+	// MockWindowShortcutHandlerInterfaceMockRecorder is the mock recorder for MockWindowShortcutHandlerInterface.
		726	+	type MockWindowShortcutHandlerInterfaceMockRecorder struct {
		727	+	mock *MockWindowShortcutHandlerInterface
		728	+	}
		729	+
		730	+	// NewMockWindowShortcutHandlerInterface creates a new mock instance.
		731	+	func NewMockWindowShortcutHandlerInterface(ctrl gomock.Controller) MockWindowShortcutHandlerInterface {
		732	+	mock := &MockWindowShortcutHandlerInterface{ctrl: ctrl}
		733	+	mock.recorder = &MockWindowShortcutHandlerInterfaceMockRecorder{mock}
		734	+	return mock
		735	+	}
		736	+
		737	+	// EXPECT returns an object that allows the caller to indicate expected use.
		738	+	func (m MockWindowShortcutHandlerInterface) EXPECT() MockWindowShortcutHandlerInterfaceMockRecorder {
		739	+	return m.recorder
		740	+	}
		741	+
		742	+	// Cleanup mocks base method.
		743	+	func (m *MockWindowShortcutHandlerInterface) Cleanup() {
		744	+	m.ctrl.T.Helper()
		745	+	m.ctrl.Call(m, "Cleanup")
		746	+	}
		747	+
		748	+	// Cleanup indicates an expected call of Cleanup.
		749	+	func (mr MockWindowShortcutHandlerInterfaceMockRecorder) Cleanup() gomock.Call {
		750	+	mr.mock.ctrl.T.Helper()
		751	+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Cleanup", reflect.TypeOf((*MockWindowShortcutHandlerInterface)(nil).Cleanup))
		752	+	}

A internal/app/browser/test_helpers.go +8 -0

@@ -0,0 +1,8 @@
	1	+	package browser
	2	+
	3	+	// Mock WindowShortcutHandler for testing
	4	+	type mockWindowShortcutHandler struct{}
	5	+
	6	+	func (m *mockWindowShortcutHandler) Cleanup() {
	7	+	// No-op for testing
	8	+	}⏎̸

@@ -0,0 +1,8 @@
	1	+	package browser
	2	+
	3	+	// Mock WindowShortcutHandler for testing
	4	+	type mockWindowShortcutHandler struct{}
	5	+
	6	+	func (m *mockWindowShortcutHandler) Cleanup() {
	7	+	// No-op for testing
	8	+	}⏎̸

D internal/app/browser/workspace_manager_bench_test.go +0 -344

@@ -1,344 +0,0 @@
1	-	package browser
2	-
3	-	import (
4	-	"testing"
5	-	"time"
6	-
7	-	"github.com/bnema/dumber/pkg/webkit"
8	-	)
9	-
10	-	func BenchmarkSplitNode(b *testing.B) {
11	-	wm := newTestWorkspaceManagerWithMocks(b)
12	-
13	-	b.ResetTimer()
14	-	for i := 0; i < b.N; i++ {
15	-	b.StopTimer()
16	-	// Reset to single node for each iteration
17	-	wm = newTestWorkspaceManagerWithMocks(b)
18	-	b.StartTimer()
19	-
20	-	_, err := wm.splitNode(wm.root, "right")
21	-	if err != nil {
22	-	b.Fatalf("Split failed: %v", err)
23	-	}
24	-	}
25	-	}
26	-
27	-	func BenchmarkClosePane(b *testing.B) {
28	-	for i := 0; i < b.N; i++ {
29	-	b.StopTimer()
30	-	wm := newTestWorkspaceManagerWithMocks(b)
31	-	node, err := wm.splitNode(wm.root, "right")
32	-	if err != nil {
33	-	b.Fatalf("Setup split failed: %v", err)
34	-	}
35	-	b.StartTimer()
36	-
37	-	err = wm.closePane(node)
38	-	if err != nil {
39	-	b.Fatalf("Close failed: %v", err)
40	-	}
41	-	}
42	-	}
43	-
44	-	func BenchmarkTreeTraversal(b *testing.B) {
45	-	wm := newTestWorkspaceManagerWithMocks(b)
46	-
47	-	// Build a complex tree with 15 leaves
48	-	leaves := []*paneNode{wm.root}
49	-	for i := 0; i < 14; i++ {
50	-	if len(leaves) > 0 {
51	-	// Split the first leaf
52	-	target := leaves[0]
53	-	leaves = leaves[1:] // Remove the target from leaves
54	-
55	-	newNode, err := wm.splitNode(target, "right")
56	-	if err != nil {
57	-	b.Fatalf("Setup split %d failed: %v", i, err)
58	-	}
59	-
60	-	// Add both resulting leaves back
61	-	leaves = append(leaves, target, newNode)
62	-	}
63	-	}
64	-
65	-	b.ResetTimer()
66	-	for i := 0; i < b.N; i++ {
67	-	wm.collectLeaves()
68	-	}
69	-	}
70	-
71	-	func BenchmarkCollectLeavesFrom(b *testing.B) {
72	-	wm := newTestWorkspaceManagerWithMocks(b)
73	-
74	-	// Build a balanced binary tree
75	-	for i := 0; i < 10; i++ {
76	-	leaves := wm.collectLeaves()
77	-	if len(leaves) > 0 {
78	-	_, err := wm.splitNode(leaves[0], "right")
79	-	if err != nil {
80	-	b.Fatalf("Setup split %d failed: %v", i, err)
81	-	}
82	-	}
83	-	}
84	-
85	-	b.ResetTimer()
86	-	for i := 0; i < b.N; i++ {
87	-	wm.collectLeavesFrom(wm.root)
88	-	}
89	-	}
90	-
91	-	func BenchmarkLeftmostLeaf(b *testing.B) {
92	-	wm := newTestWorkspaceManagerWithMocks(b)
93	-
94	-	// Create a deep left-leaning tree
95	-	current := wm.root
96	-	for i := 0; i < 20; i++ {
97	-	newNode, err := wm.splitNode(current, "left")
98	-	if err != nil {
99	-	b.Fatalf("Setup split %d failed: %v", i, err)
100	-	}
101	-	current = newNode
102	-	}
103	-
104	-	b.ResetTimer()
105	-	for i := 0; i < b.N; i++ {
106	-	wm.leftmostLeaf(wm.root)
107	-	}
108	-	}
109	-
110	-	func BenchmarkFindReplacementRoot(b *testing.B) {
111	-	wm := newTestWorkspaceManagerWithMocks(b)
112	-
113	-	// Build a complex tree
114	-	leaves := wm.collectLeaves()
115	-	for i := 0; i < 15; i++ {
116	-	if len(leaves) > 0 {
117	-	target := leaves[i%len(leaves)]
118	-	newNode, err := wm.splitNode(target, "right")
119	-	if err != nil {
120	-	continue
121	-	}
122	-	leaves = append(leaves, newNode)
123	-	}
124	-	}
125	-
126	-	excludeNode := wm.root
127	-
128	-	b.ResetTimer()
129	-	for i := 0; i < b.N; i++ {
130	-	wm.findReplacementRoot(excludeNode)
131	-	}
132	-	}
133	-
134	-	func BenchmarkFocusAdjacent(b *testing.B) {
135	-	wm := newTestWorkspaceManagerWithMocks(b)
136	-
137	-	// Create a 2x2 grid of panes with known geometry
138	-	right, _ := wm.splitNode(wm.root, "right")
139	-	bottom, _ := wm.splitNode(wm.root, "down")
140	-	_, _ = wm.splitNode(right, "down")
141	-
142	-	// Set up widget bounds for focus calculations
143	-	webkit.SetWidgetBoundsForTesting(wm.root.container, webkit.WidgetBounds{X: 0, Y: 0, Width: 100, Height: 100})
144	-	webkit.SetWidgetBoundsForTesting(right.container, webkit.WidgetBounds{X: 120, Y: 0, Width: 100, Height: 100})
145	-	webkit.SetWidgetBoundsForTesting(bottom.container, webkit.WidgetBounds{X: 0, Y: 120, Width: 100, Height: 100})
146	-
147	-	wm.active = wm.root
148	-
149	-	b.ResetTimer()
150	-	for i := 0; i < b.N; i++ {
151	-	wm.focusAdjacent("right")
152	-	wm.focusAdjacent("left")
153	-	}
154	-	}
155	-
156	-	func BenchmarkStructuralNeighbor(b *testing.B) {
157	-	wm := newTestWorkspaceManagerWithMocks(b)
158	-
159	-	// Create a complex nested structure
160	-	right, _ := wm.splitNode(wm.root, "right")
161	-	_, _ = wm.splitNode(right, "down")
162	-	_, _ = wm.splitNode(wm.root, "down")
163	-
164	-	// Set up geometry
165	-	webkit.SetWidgetBoundsForTesting(wm.root.container, webkit.WidgetBounds{X: 0, Y: 0, Width: 100, Height: 100})
166	-
167	-	b.ResetTimer()
168	-	for i := 0; i < b.N; i++ {
169	-	wm.structuralNeighbor(wm.root, "right")
170	-	wm.structuralNeighbor(wm.root, "down")
171	-	}
172	-	}
173	-
174	-	func BenchmarkClosestLeafFromSubtree(b *testing.B) {
175	-	wm := newTestWorkspaceManagerWithMocks(b)
176	-
177	-	// Build a subtree with multiple leaves
178	-	right, _ := wm.splitNode(wm.root, "right")
179	-	_, _ = wm.splitNode(right, "down")
180	-	_, _ = wm.splitNode(right, "up")
181	-
182	-	// Set up geometry for all nodes
183	-	leaves := wm.collectLeavesFrom(right)
184	-	for i, leaf := range leaves {
185	-	webkit.SetWidgetBoundsForTesting(leaf.container, webkit.WidgetBounds{
186	-	X: float64(i * 50), Y: 0, Width: 45, Height: 100,
187	-	})
188	-	}
189	-
190	-	b.ResetTimer()
191	-	for i := 0; i < b.N; i++ {
192	-	wm.closestLeafFromSubtree(right, 25, 50, "right")
193	-	}
194	-	}
195	-
196	-	func BenchmarkComplexTreeOperations(b *testing.B) {
197	-	b.Run("SplitAndClose", func(b *testing.B) {
198	-	for i := 0; i < b.N; i++ {
199	-	b.StopTimer()
200	-	wm := newTestWorkspaceManagerWithMocks(b)
201	-	b.StartTimer()
202	-
203	-	// Split multiple times then close in reverse order
204	-	nodes := []*paneNode{wm.root}
205	-	for j := 0; j < 5; j++ {
206	-	newNode, err := wm.splitNode(nodes[len(nodes)-1], "right")
207	-	if err != nil {
208	-	b.Fatalf("Split failed: %v", err)
209	-	}
210	-	nodes = append(nodes, newNode)
211	-	}
212	-
213	-	// Close all but root
214	-	for j := len(nodes) - 1; j > 0; j-- {
215	-	err := wm.closePane(nodes[j])
216	-	if err != nil {
217	-	b.Fatalf("Close failed: %v", err)
218	-	}
219	-	}
220	-	}
221	-	})
222	-
223	-	b.Run("BuildBalancedTree", func(b *testing.B) {
224	-	for i := 0; i < b.N; i++ {
225	-	b.StopTimer()
226	-	wm := newTestWorkspaceManagerWithMocks(b)
227	-	b.StartTimer()
228	-
229	-	// Build a balanced tree by alternating split directions
230	-	leaves := []*paneNode{wm.root}
231	-	directions := []string{"right", "down", "left", "up"}
232	-
233	-	for j := 0; j < 15 && len(leaves) > 0; j++ {
234	-	target := leaves[j%len(leaves)]
235	-	direction := directions[j%len(directions)]
236	-
237	-	newNode, err := wm.splitNode(target, direction)
238	-	if err != nil {
239	-	continue
240	-	}
241	-	leaves = append(leaves, newNode)
242	-	}
243	-	}
244	-	})
245	-	}
246	-
247	-	func BenchmarkMemoryOperations(b *testing.B) {
248	-	b.Run("ViewToNodeMapping", func(b *testing.B) {
249	-	wm := newTestWorkspaceManagerWithMocks(b)
250	-
251	-	// Create many nodes to stress the map
252	-	for i := 0; i < 100; i++ {
253	-	leaves := wm.collectLeaves()
254	-	if len(leaves) > 0 {
255	-	_, _ = wm.splitNode(leaves[0], "right")
256	-	}
257	-	}
258	-
259	-	b.ResetTimer()
260	-	for i := 0; i < b.N; i++ {
261	-	// Access all mappings
262	-	for view, node := range wm.viewToNode {
263	-	_ = view
264	-	_ = node
265	-	}
266	-	}
267	-	})
268	-
269	-	b.Run("TreeWalkMemory", func(b *testing.B) {
270	-	wm := newTestWorkspaceManagerWithMocks(b)
271	-
272	-	// Build deep tree
273	-	current := wm.root
274	-	for i := 0; i < 50; i++ {
275	-	newNode, err := wm.splitNode(current, "right")
276	-	if err != nil {
277	-	break
278	-	}
279	-	current = newNode
280	-	}
281	-
282	-	b.ResetTimer()
283	-	for i := 0; i < b.N; i++ {
284	-	// Multiple tree operations that allocate
285	-	leaves := wm.collectLeaves()
286	-	_ = leaves
287	-	countNodes(wm.root)
288	-	wm.leftmostLeaf(wm.root)
289	-	}
290	-	})
291	-	}
292	-
293	-	// Helper function for benchmarks
294	-	func newTestWorkspaceManagerWithMocks(tb testing.TB) *WorkspaceManager {
295	-	tb.Helper()
296	-	webkit.ResetWidgetStubsForTesting()
297	-
298	-	rootView, err := webkit.NewWebView(&webkit.Config{})
299	-	if err != nil {
300	-	tb.Fatalf("failed to create root webview: %v", err)
301	-	}
302	-
303	-	rootPane := &BrowserPane{
304	-	webView: rootView,
305	-	id: "root",
306	-	}
307	-
308	-	app := &BrowserApp{
309	-	panes: []*BrowserPane{rootPane},
310	-	activePane: rootPane,
311	-	webView: rootView,
312	-	}
313	-
314	-	wm := &WorkspaceManager{
315	-	app: app,
316	-	window: rootView.Window(),
317	-	viewToNode: make(map[webkit.WebView]paneNode),
318	-	lastSplitMsg: make(map[*webkit.WebView]time.Time),
319	-	lastExitMsg: make(map[*webkit.WebView]time.Time),
320	-	}
321	-
322	-	wm.createWebViewFn = func() (*webkit.WebView, error) {
323	-	return webkit.NewWebView(&webkit.Config{})
324	-	}
325	-
326	-	wm.createPaneFn = func(view webkit.WebView) (BrowserPane, error) {
327	-	return &BrowserPane{
328	-	webView: view,
329	-	id: "bench-pane",
330	-	}, nil
331	-	}
332	-
333	-	root := &paneNode{
334	-	pane: rootPane,
335	-	container: rootView.RootWidget(),
336	-	isLeaf: true,
337	-	}
338	-	wm.root = root
339	-	wm.active = root
340	-	wm.mainPane = root
341	-	wm.viewToNode[rootView] = root
342	-
343	-	return wm
344	-	}

@@ -1,344 +0,0 @@
1	-	package browser
2	-
3	-	import (
4	-	"testing"
5	-	"time"
6	-
7	-	"github.com/bnema/dumber/pkg/webkit"
8	-	)
9	-
10	-	func BenchmarkSplitNode(b *testing.B) {
11	-	wm := newTestWorkspaceManagerWithMocks(b)
12	-
13	-	b.ResetTimer()
14	-	for i := 0; i < b.N; i++ {
15	-	b.StopTimer()
16	-	// Reset to single node for each iteration
17	-	wm = newTestWorkspaceManagerWithMocks(b)
18	-	b.StartTimer()
19	-
20	-	_, err := wm.splitNode(wm.root, "right")
21	-	if err != nil {
22	-	b.Fatalf("Split failed: %v", err)
23	-	}
24	-	}
25	-	}
26	-
27	-	func BenchmarkClosePane(b *testing.B) {
28	-	for i := 0; i < b.N; i++ {
29	-	b.StopTimer()
30	-	wm := newTestWorkspaceManagerWithMocks(b)
31	-	node, err := wm.splitNode(wm.root, "right")
32	-	if err != nil {
33	-	b.Fatalf("Setup split failed: %v", err)
34	-	}
35	-	b.StartTimer()
36	-
37	-	err = wm.closePane(node)
38	-	if err != nil {
39	-	b.Fatalf("Close failed: %v", err)
40	-	}
41	-	}
42	-	}
43	-
44	-	func BenchmarkTreeTraversal(b *testing.B) {
45	-	wm := newTestWorkspaceManagerWithMocks(b)
46	-
47	-	// Build a complex tree with 15 leaves
48	-	leaves := []*paneNode{wm.root}
49	-	for i := 0; i < 14; i++ {
50	-	if len(leaves) > 0 {
51	-	// Split the first leaf
52	-	target := leaves[0]
53	-	leaves = leaves[1:] // Remove the target from leaves
54	-
55	-	newNode, err := wm.splitNode(target, "right")
56	-	if err != nil {
57	-	b.Fatalf("Setup split %d failed: %v", i, err)
58	-	}
59	-
60	-	// Add both resulting leaves back
61	-	leaves = append(leaves, target, newNode)
62	-	}
63	-	}
64	-
65	-	b.ResetTimer()
66	-	for i := 0; i < b.N; i++ {
67	-	wm.collectLeaves()
68	-	}
69	-	}
70	-
71	-	func BenchmarkCollectLeavesFrom(b *testing.B) {
72	-	wm := newTestWorkspaceManagerWithMocks(b)
73	-
74	-	// Build a balanced binary tree
75	-	for i := 0; i < 10; i++ {
76	-	leaves := wm.collectLeaves()
77	-	if len(leaves) > 0 {
78	-	_, err := wm.splitNode(leaves[0], "right")
79	-	if err != nil {
80	-	b.Fatalf("Setup split %d failed: %v", i, err)
81	-	}
82	-	}
83	-	}
84	-
85	-	b.ResetTimer()
86	-	for i := 0; i < b.N; i++ {
87	-	wm.collectLeavesFrom(wm.root)
88	-	}
89	-	}
90	-
91	-	func BenchmarkLeftmostLeaf(b *testing.B) {
92	-	wm := newTestWorkspaceManagerWithMocks(b)
93	-
94	-	// Create a deep left-leaning tree
95	-	current := wm.root
96	-	for i := 0; i < 20; i++ {
97	-	newNode, err := wm.splitNode(current, "left")
98	-	if err != nil {
99	-	b.Fatalf("Setup split %d failed: %v", i, err)
100	-	}
101	-	current = newNode
102	-	}
103	-
104	-	b.ResetTimer()
105	-	for i := 0; i < b.N; i++ {
106	-	wm.leftmostLeaf(wm.root)
107	-	}
108	-	}
109	-
110	-	func BenchmarkFindReplacementRoot(b *testing.B) {
111	-	wm := newTestWorkspaceManagerWithMocks(b)
112	-
113	-	// Build a complex tree
114	-	leaves := wm.collectLeaves()
115	-	for i := 0; i < 15; i++ {
116	-	if len(leaves) > 0 {
117	-	target := leaves[i%len(leaves)]
118	-	newNode, err := wm.splitNode(target, "right")
119	-	if err != nil {
120	-	continue
121	-	}
122	-	leaves = append(leaves, newNode)
123	-	}
124	-	}
125	-
126	-	excludeNode := wm.root
127	-
128	-	b.ResetTimer()
129	-	for i := 0; i < b.N; i++ {
130	-	wm.findReplacementRoot(excludeNode)
131	-	}
132	-	}
133	-
134	-	func BenchmarkFocusAdjacent(b *testing.B) {
135	-	wm := newTestWorkspaceManagerWithMocks(b)
136	-
137	-	// Create a 2x2 grid of panes with known geometry
138	-	right, _ := wm.splitNode(wm.root, "right")
139	-	bottom, _ := wm.splitNode(wm.root, "down")
140	-	_, _ = wm.splitNode(right, "down")
141	-
142	-	// Set up widget bounds for focus calculations
143	-	webkit.SetWidgetBoundsForTesting(wm.root.container, webkit.WidgetBounds{X: 0, Y: 0, Width: 100, Height: 100})
144	-	webkit.SetWidgetBoundsForTesting(right.container, webkit.WidgetBounds{X: 120, Y: 0, Width: 100, Height: 100})
145	-	webkit.SetWidgetBoundsForTesting(bottom.container, webkit.WidgetBounds{X: 0, Y: 120, Width: 100, Height: 100})
146	-
147	-	wm.active = wm.root
148	-
149	-	b.ResetTimer()
150	-	for i := 0; i < b.N; i++ {
151	-	wm.focusAdjacent("right")
152	-	wm.focusAdjacent("left")
153	-	}
154	-	}
155	-
156	-	func BenchmarkStructuralNeighbor(b *testing.B) {
157	-	wm := newTestWorkspaceManagerWithMocks(b)
158	-
159	-	// Create a complex nested structure
160	-	right, _ := wm.splitNode(wm.root, "right")
161	-	_, _ = wm.splitNode(right, "down")
162	-	_, _ = wm.splitNode(wm.root, "down")
163	-
164	-	// Set up geometry
165	-	webkit.SetWidgetBoundsForTesting(wm.root.container, webkit.WidgetBounds{X: 0, Y: 0, Width: 100, Height: 100})
166	-
167	-	b.ResetTimer()
168	-	for i := 0; i < b.N; i++ {
169	-	wm.structuralNeighbor(wm.root, "right")
170	-	wm.structuralNeighbor(wm.root, "down")
171	-	}
172	-	}
173	-
174	-	func BenchmarkClosestLeafFromSubtree(b *testing.B) {
175	-	wm := newTestWorkspaceManagerWithMocks(b)
176	-
177	-	// Build a subtree with multiple leaves
178	-	right, _ := wm.splitNode(wm.root, "right")
179	-	_, _ = wm.splitNode(right, "down")
180	-	_, _ = wm.splitNode(right, "up")
181	-
182	-	// Set up geometry for all nodes
183	-	leaves := wm.collectLeavesFrom(right)
184	-	for i, leaf := range leaves {
185	-	webkit.SetWidgetBoundsForTesting(leaf.container, webkit.WidgetBounds{
186	-	X: float64(i * 50), Y: 0, Width: 45, Height: 100,
187	-	})
188	-	}
189	-
190	-	b.ResetTimer()
191	-	for i := 0; i < b.N; i++ {
192	-	wm.closestLeafFromSubtree(right, 25, 50, "right")
193	-	}
194	-	}
195	-
196	-	func BenchmarkComplexTreeOperations(b *testing.B) {
197	-	b.Run("SplitAndClose", func(b *testing.B) {
198	-	for i := 0; i < b.N; i++ {
199	-	b.StopTimer()
200	-	wm := newTestWorkspaceManagerWithMocks(b)
201	-	b.StartTimer()
202	-
203	-	// Split multiple times then close in reverse order
204	-	nodes := []*paneNode{wm.root}
205	-	for j := 0; j < 5; j++ {
206	-	newNode, err := wm.splitNode(nodes[len(nodes)-1], "right")
207	-	if err != nil {
208	-	b.Fatalf("Split failed: %v", err)
209	-	}
210	-	nodes = append(nodes, newNode)
211	-	}
212	-
213	-	// Close all but root
214	-	for j := len(nodes) - 1; j > 0; j-- {
215	-	err := wm.closePane(nodes[j])
216	-	if err != nil {
217	-	b.Fatalf("Close failed: %v", err)
218	-	}
219	-	}
220	-	}
221	-	})
222	-
223	-	b.Run("BuildBalancedTree", func(b *testing.B) {
224	-	for i := 0; i < b.N; i++ {
225	-	b.StopTimer()
226	-	wm := newTestWorkspaceManagerWithMocks(b)
227	-	b.StartTimer()
228	-
229	-	// Build a balanced tree by alternating split directions
230	-	leaves := []*paneNode{wm.root}
231	-	directions := []string{"right", "down", "left", "up"}
232	-
233	-	for j := 0; j < 15 && len(leaves) > 0; j++ {
234	-	target := leaves[j%len(leaves)]
235	-	direction := directions[j%len(directions)]
236	-
237	-	newNode, err := wm.splitNode(target, direction)
238	-	if err != nil {
239	-	continue
240	-	}
241	-	leaves = append(leaves, newNode)
242	-	}
243	-	}
244	-	})
245	-	}
246	-
247	-	func BenchmarkMemoryOperations(b *testing.B) {
248	-	b.Run("ViewToNodeMapping", func(b *testing.B) {
249	-	wm := newTestWorkspaceManagerWithMocks(b)
250	-
251	-	// Create many nodes to stress the map
252	-	for i := 0; i < 100; i++ {
253	-	leaves := wm.collectLeaves()
254	-	if len(leaves) > 0 {
255	-	_, _ = wm.splitNode(leaves[0], "right")
256	-	}
257	-	}
258	-
259	-	b.ResetTimer()
260	-	for i := 0; i < b.N; i++ {
261	-	// Access all mappings
262	-	for view, node := range wm.viewToNode {
263	-	_ = view
264	-	_ = node
265	-	}
266	-	}
267	-	})
268	-
269	-	b.Run("TreeWalkMemory", func(b *testing.B) {
270	-	wm := newTestWorkspaceManagerWithMocks(b)
271	-
272	-	// Build deep tree
273	-	current := wm.root
274	-	for i := 0; i < 50; i++ {
275	-	newNode, err := wm.splitNode(current, "right")
276	-	if err != nil {
277	-	break
278	-	}
279	-	current = newNode
280	-	}
281	-
282	-	b.ResetTimer()
283	-	for i := 0; i < b.N; i++ {
284	-	// Multiple tree operations that allocate
285	-	leaves := wm.collectLeaves()
286	-	_ = leaves
287	-	countNodes(wm.root)
288	-	wm.leftmostLeaf(wm.root)
289	-	}
290	-	})
291	-	}
292	-
293	-	// Helper function for benchmarks
294	-	func newTestWorkspaceManagerWithMocks(tb testing.TB) *WorkspaceManager {
295	-	tb.Helper()
296	-	webkit.ResetWidgetStubsForTesting()
297	-
298	-	rootView, err := webkit.NewWebView(&webkit.Config{})
299	-	if err != nil {
300	-	tb.Fatalf("failed to create root webview: %v", err)
301	-	}
302	-
303	-	rootPane := &BrowserPane{
304	-	webView: rootView,
305	-	id: "root",
306	-	}
307	-
308	-	app := &BrowserApp{
309	-	panes: []*BrowserPane{rootPane},
310	-	activePane: rootPane,
311	-	webView: rootView,
312	-	}
313	-
314	-	wm := &WorkspaceManager{
315	-	app: app,
316	-	window: rootView.Window(),
317	-	viewToNode: make(map[webkit.WebView]paneNode),
318	-	lastSplitMsg: make(map[*webkit.WebView]time.Time),
319	-	lastExitMsg: make(map[*webkit.WebView]time.Time),
320	-	}
321	-
322	-	wm.createWebViewFn = func() (*webkit.WebView, error) {
323	-	return webkit.NewWebView(&webkit.Config{})
324	-	}
325	-
326	-	wm.createPaneFn = func(view webkit.WebView) (BrowserPane, error) {
327	-	return &BrowserPane{
328	-	webView: view,
329	-	id: "bench-pane",
330	-	}, nil
331	-	}
332	-
333	-	root := &paneNode{
334	-	pane: rootPane,
335	-	container: rootView.RootWidget(),
336	-	isLeaf: true,
337	-	}
338	-	wm.root = root
339	-	wm.active = root
340	-	wm.mainPane = root
341	-	wm.viewToNode[rootView] = root
342	-
343	-	return wm
344	-	}

M internal/app/browser/workspace_manager_test.go +4 -0


@@ -17,10 +17,14 @@ func newTestWorkspaceManager(t testing.T) WorkspaceManager {
17	17
18	18		rootPane := &BrowserPane{webView: rootView}
19	19
	20	+	// Create mock window shortcut handler
	21	+	mockWindowShortcutHandler := &mockWindowShortcutHandler{}
	22	+
20	23		app := &BrowserApp{}
21	24		app.panes = []*BrowserPane{rootPane}
22	25		app.activePane = rootPane
23	26		app.webView = rootView
	27	+	app.windowShortcutHandler = mockWindowShortcutHandler
24	28
25	29		wm := NewWorkspaceManager(app, rootPane)
26	30		wm.createWebViewFn = func() (*webkit.WebView, error) {


@@ -17,10 +17,14 @@ func newTestWorkspaceManager(t testing.T) WorkspaceManager {
17		17
18	rootPane := &BrowserPane{webView: rootView}	18		rootPane := &BrowserPane{webView: rootView}
19		19
		20	+	// Create mock window shortcut handler
		21	+	mockWindowShortcutHandler := &mockWindowShortcutHandler{}
		22	+
20	app := &BrowserApp{}	23		app := &BrowserApp{}
21	app.panes = []*BrowserPane{rootPane}	24		app.panes = []*BrowserPane{rootPane}
22	app.activePane = rootPane	25		app.activePane = rootPane
23	app.webView = rootView	26		app.webView = rootView
		27	+	app.windowShortcutHandler = mockWindowShortcutHandler
24		28
25	wm := NewWorkspaceManager(app, rootPane)	29		wm := NewWorkspaceManager(app, rootPane)
26	wm.createWebViewFn = func() (*webkit.WebView, error) {	30		wm.createWebViewFn = func() (*webkit.WebView, error) {

M internal/app/browser/workspace_manager_tree_test.go +7 -3


@@ -553,10 +553,14 @@ func newTestWorkspaceManagerWithMocksForTree(t testing.T) WorkspaceManager {
553	553		id: "root",
554	554		}
555	555
	556	+	// Create mock window shortcut handler
	557	+	mockWindowShortcutHandler := &mockWindowShortcutHandler{}
	558	+
556	559		app := &BrowserApp{
557		-	panes: []*BrowserPane{rootPane},
558		-	activePane: rootPane,
559		-	webView: rootView,
	560	+	panes: []*BrowserPane{rootPane},
	561	+	activePane: rootPane,
	562	+	webView: rootView,
	563	+	windowShortcutHandler: mockWindowShortcutHandler,
560	564		}
561	565
562	566		wm := &WorkspaceManager{

 		id:      "root",
 	}
+	// Create mock window shortcut handler
+	mockWindowShortcutHandler := &mockWindowShortcutHandler{}
 	app := &BrowserApp{
-		panes:      []*BrowserPane{rootPane},
+		panes:                 []*BrowserPane{rootPane},
-		activePane: rootPane,
+		activePane:            rootPane,
-		webView:    rootView,
+		webView:               rootView,
+		windowShortcutHandler: mockWindowShortcutHandler,
 	}
 	wm := &WorkspaceManager{