5caec5d fix(history): tighten sidebar regression coverage · dumber

M internal/ui/browser_window_test.go +11 -3


@@ -1225,6 +1225,7 @@ func TestApp_HistorySidebarToggleHandler_NilFocusedWindowIsNoOp(t *testing.T) {
1225	1225		// TestHistorySidebarConfig_OnCloseHidesSidebar verifies that the OnClose
1226	1226		// callback hides the sidebar for the owning browser window.
1227	1227		func TestHistorySidebarConfig_OnCloseHidesSidebar(t *testing.T) {
	1228	+	ctx := context.Background()
1228	1229		tab := entity.NewTab(entity.TabID("tab-1"), entity.WorkspaceID("ws-1"), entity.NewPane(entity.PaneID("pane-1")))
1229	1230		bwTabs := entity.NewTabList()
1230	1231		bwTabs.Add(tab)

@@ -1238,10 +1239,17 @@ func TestHistorySidebarConfig_OnCloseHidesSidebar(t *testing.T) {
1238	1239		sidebarVisible: true,
1239	1240		}
1240	1241
1241		-	// Simulate the hide step used by OnClose's hideAndRestoreFocus closure.
1242		-	bw.hideHistorySidebar()
1243		-	assert.False(t, bw.sidebarVisible, "sidebar must be hidden by hideAndRestoreFocus")
	1242	+	app := &App{
	1243	+	tabs: entity.NewTabList(),
	1244	+	browserWindows: map[string]*browserWindow{bw.id: bw},
	1245	+	workspaceViews: map[entity.TabID]*component.WorkspaceView{tab.ID: {}},
	1246	+	}
	1247	+	app.tabs.Add(tab)
	1248	+
	1249	+	cfg := app.buildHistorySidebarConfig(ctx, bw)
	1250	+	cfg.OnClose()
1244	1251
	1252	+	assert.False(t, bw.sidebarVisible, "sidebar must be hidden by OnClose")
1245	1253		}
1246	1254
1247	1255		// =============================================================================

 // TestHistorySidebarConfig_OnCloseHidesSidebar verifies that the OnClose
 // callback hides the sidebar for the owning browser window.
 func TestHistorySidebarConfig_OnCloseHidesSidebar(t *testing.T) {
+	ctx := context.Background()
 	tab := entity.NewTab(entity.TabID("tab-1"), entity.WorkspaceID("ws-1"), entity.NewPane(entity.PaneID("pane-1")))
 	bwTabs := entity.NewTabList()
 	bwTabs.Add(tab)
 		sidebarVisible: true,
 	}
-	// Simulate the hide step used by OnClose's hideAndRestoreFocus closure.
+	app := &App{
-	bw.hideHistorySidebar()
+		tabs:           entity.NewTabList(),
-	assert.False(t, bw.sidebarVisible, "sidebar must be hidden by hideAndRestoreFocus")
+		browserWindows: map[string]*browserWindow{bw.id: bw},
+		workspaceViews: map[entity.TabID]*component.WorkspaceView{tab.ID: {}},
+	}
+	app.tabs.Add(tab)
+	cfg := app.buildHistorySidebarConfig(ctx, bw)
+	cfg.OnClose()
+	assert.False(t, bw.sidebarVisible, "sidebar must be hidden by OnClose")
 }
 // =============================================================================

M internal/ui/component/history_sidebar.go +16 -3


@@ -95,6 +95,10 @@ type HistorySidebar struct {
95	95		// Retained callbacks
96	96		retainedCallbacks []interface{}
97	97
	98	+	// idleScheduler dispatches work onto the GTK main thread.
	99	+	// Tests may override it to exercise scheduled callbacks deterministically.
	100	+	idleScheduler func(glib.SourceFunc)
	101	+
98	102		// Context
99	103		ctx context.Context
100	104		cancel context.CancelFunc

@@ -804,7 +808,7 @@ func (hs *HistorySidebar) doFTSearch(query string, gen uint64) {
804	808		}
805	809		return false
806	810		})
807		-	glib.IdleAdd(&cb, 0)
	811	+	hs.scheduleIdle(cb)
808	812		}()
809	813		}
810	814

@@ -826,6 +830,14 @@ func (hs HistorySidebar) applySearchResults(entries []entity.HistoryEntry, gen
826	830		return true
827	831		}
828	832
	833	+	func (hs *HistorySidebar) scheduleIdle(cb glib.SourceFunc) {
	834	+	if hs != nil && hs.idleScheduler != nil {
	835	+	hs.idleScheduler(cb)
	836	+	return
	837	+	}
	838	+	glib.IdleAdd(&cb, 0)
	839	+	}
	840	+
829	841		// scheduleClearList clears the list box on the GTK main thread.
830	842		func (hs *HistorySidebar) scheduleClearList() {
831	843		cb := glib.SourceFunc(func(uintptr) bool {

@@ -839,7 +851,7 @@ func (hs *HistorySidebar) scheduleClearList() {
839	851		listBox.RemoveAll()
840	852		return false
841	853		})
842		-	glib.IdleAdd(&cb, 0)
	854	+	hs.scheduleIdle(cb)
843	855		}
844	856
845	857		// scheduleRebuild schedules a list rebuild on the GTK main thread.

@@ -848,7 +860,7 @@ func (hs *HistorySidebar) scheduleRebuild() {
848	860		hs.rebuildList()
849	861		return false
850	862		})
851		-	glib.IdleAdd(&cb, 0)
	863	+	hs.scheduleIdle(cb)
852	864		}
853	865
854	866		// =============================================================================

@@ -1240,6 +1252,7 @@ func (hs *HistorySidebar) handleDeleteKey() bool {
1240	1252		hs.prevSelectedURL = nextSelectedURL
1241	1253		hs.searchGen++
1242	1254		hs.removeFromAllEntries(url, entryID)
	1255	+	hs.totalLoaded = len(hs.allEntries)
1243	1256		hs.removeFromSearchResults(entryID)
1244	1257		hs.rebuildLocalGroups()
1245	1258		hs.mu.Unlock()

 	// Retained callbacks
 	retainedCallbacks []interface{}
+	// idleScheduler dispatches work onto the GTK main thread.
+	// Tests may override it to exercise scheduled callbacks deterministically.
+	idleScheduler func(glib.SourceFunc)
 	// Context
 	ctx    context.Context
 	cancel context.CancelFunc
 			}
 			return false
 		})
-		glib.IdleAdd(&cb, 0)
+		hs.scheduleIdle(cb)
 	}()
 }
 	return true
 }
+func (hs *HistorySidebar) scheduleIdle(cb glib.SourceFunc) {
+	if hs != nil && hs.idleScheduler != nil {
+		hs.idleScheduler(cb)
+		return
+	}
+	glib.IdleAdd(&cb, 0)
+}
 // scheduleClearList clears the list box on the GTK main thread.
 func (hs *HistorySidebar) scheduleClearList() {
 	cb := glib.SourceFunc(func(uintptr) bool {
 		listBox.RemoveAll()
 		return false
 	})
-	glib.IdleAdd(&cb, 0)
+	hs.scheduleIdle(cb)
 }
 // scheduleRebuild schedules a list rebuild on the GTK main thread.
 		hs.rebuildList()
 		return false
 	})
-	glib.IdleAdd(&cb, 0)
+	hs.scheduleIdle(cb)
 }
 // =============================================================================
 			hs.prevSelectedURL = nextSelectedURL
 			hs.searchGen++
 			hs.removeFromAllEntries(url, entryID)
+			hs.totalLoaded = len(hs.allEntries)
 			hs.removeFromSearchResults(entryID)
 			hs.rebuildLocalGroups()
 			hs.mu.Unlock()

M internal/ui/component/history_sidebar_search_test.go +28 -12


@@ -9,6 +9,7 @@ import (
9	9
10	10		"github.com/bnema/dumber/internal/application/dto"
11	11		"github.com/bnema/dumber/internal/domain/entity"
	12	+	"github.com/bnema/puregotk/v4/glib"
12	13		"github.com/rs/zerolog"
13	14		"github.com/stretchr/testify/assert"
14	15		"github.com/stretchr/testify/require"

@@ -151,6 +152,7 @@ func (f *fakeHistorySidebarHistory) Delete(ctx context.Context, id int64) error
151	152
152	153		func TestApplySearchResults_StaleGenerationDropsResultsAfterSearch(t *testing.T) {
153	154		searchCalled := make(chan struct{}, 1)
	155	+	idleCalled := make(chan glib.SourceFunc, 1)
154	156
155	157		history := &fakeHistorySidebarHistory{
156	158		searchFn: func(context.Context, dto.HistorySearchInput) (*dto.HistorySearchOutput, error) {

@@ -165,20 +167,29 @@ func TestApplySearchResults_StaleGenerationDropsResultsAfterSearch(t *testing.T)
165	167		hs.ctx = context.Background()
166	168		hs.historyUC = history
167	169		hs.searchGen = 1
	170	+	hs.idleScheduler = func(cb glib.SourceFunc) {
	171	+	idleCalled <- cb
	172	+	}
168	173
169		-	// Start search with gen=1
	174	+	// Start search with gen=1.
170	175		hs.doFTSearch("test", 1)
171		-	<-searchCalled // Wait for the goroutine to pick up the search
	176	+	select {
	177	+	case <-searchCalled:
	178	+	case <-time.After(time.Second):
	179	+	t.Fatal("timed out waiting for search use case to be invoked")
	180	+	}
172	181
173		-	// Advance gen before the UI callback would apply results.
	182	+	// Advance gen before the queued UI callback applies results.
174	183		hs.mu.Lock()
175	184		hs.searchGen = 2
176	185		hs.mu.Unlock()
177	186
178		-	applied := hs.applySearchResults([]*entity.HistoryEntry{{
179		-	ID: 1, URL: "https://result.com", Title: "Result", LastVisited: time.Now(),
180		-	}}, 1, nil)
181		-	assert.False(t, applied, "stale search results must be dropped")
	187	+	select {
	188	+	case cb := <-idleCalled:
	189	+	cb(0)
	190	+	case <-time.After(time.Second):
	191	+	t.Fatal("timed out waiting for scheduled idle callback")
	192	+	}
182	193
183	194		hs.mu.RLock()
184	195		defer hs.mu.RUnlock()

@@ -189,6 +200,7 @@ func TestApplySearchResults_StaleGenerationDropsResultsAfterSearch(t *testing.T)
189	200
190	201		func TestApplySearchResults_CurrentGenerationAppliedAfterSearch(t *testing.T) {
191	202		searchCalled := make(chan struct{}, 1)
	203	+	idleCalled := make(chan glib.SourceFunc, 1)
192	204
193	205		history := &fakeHistorySidebarHistory{
194	206		searchFn: func(context.Context, dto.HistorySearchInput) (*dto.HistorySearchOutput, error) {

@@ -203,6 +215,9 @@ func TestApplySearchResults_CurrentGenerationAppliedAfterSearch(t *testing.T) {
203	215		hs.ctx = context.Background()
204	216		hs.historyUC = history
205	217		hs.searchGen = 1
	218	+	hs.idleScheduler = func(cb glib.SourceFunc) {
	219	+	idleCalled <- cb
	220	+	}
206	221
207	222		// Start the search and wait for the use case to be invoked.
208	223		hs.doFTSearch("live", 1)

@@ -212,11 +227,12 @@ func TestApplySearchResults_CurrentGenerationAppliedAfterSearch(t *testing.T) {
212	227		t.Fatal("timed out waiting for search use case to be invoked")
213	228		}
214	229
215		-	// glib.IdleAdd is a no-op without GTK, so apply the callback effect directly.
216		-	applied := hs.applySearchResults([]*entity.HistoryEntry{
217		-	{ID: 1, URL: "https://live.com", Title: "Live", LastVisited: time.Now()},
218		-	}, 1, nil)
219		-	require.True(t, applied)
	230	+	select {
	231	+	case cb := <-idleCalled:
	232	+	cb(0)
	233	+	case <-time.After(time.Second):
	234	+	t.Fatal("timed out waiting for scheduled idle callback")
	235	+	}
220	236
221	237		hs.mu.RLock()
222	238		assert.NotNil(t, hs.searchResults)

 	"github.com/bnema/dumber/internal/application/dto"
 	"github.com/bnema/dumber/internal/domain/entity"
+	"github.com/bnema/puregotk/v4/glib"
 	"github.com/rs/zerolog"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 func TestApplySearchResults_StaleGenerationDropsResultsAfterSearch(t *testing.T) {
 	searchCalled := make(chan struct{}, 1)
+	idleCalled := make(chan glib.SourceFunc, 1)
 	history := &fakeHistorySidebarHistory{
 		searchFn: func(context.Context, dto.HistorySearchInput) (*dto.HistorySearchOutput, error) {
 	hs.ctx = context.Background()
 	hs.historyUC = history
 	hs.searchGen = 1
+	hs.idleScheduler = func(cb glib.SourceFunc) {
+		idleCalled <- cb
+	}
-	// Start search with gen=1
+	// Start search with gen=1.
 	hs.doFTSearch("test", 1)
-	<-searchCalled // Wait for the goroutine to pick up the search
+	select {
+	case <-searchCalled:
+	case <-time.After(time.Second):
+		t.Fatal("timed out waiting for search use case to be invoked")
+	}
-	// Advance gen before the UI callback would apply results.
+	// Advance gen before the queued UI callback applies results.
 	hs.mu.Lock()
 	hs.searchGen = 2
 	hs.mu.Unlock()
-	applied := hs.applySearchResults([]*entity.HistoryEntry{{
+	select {
-		ID: 1, URL: "https://result.com", Title: "Result", LastVisited: time.Now(),
+	case cb := <-idleCalled:
-	}}, 1, nil)
+		cb(0)
-	assert.False(t, applied, "stale search results must be dropped")
+	case <-time.After(time.Second):
+		t.Fatal("timed out waiting for scheduled idle callback")
+	}
 	hs.mu.RLock()
 	defer hs.mu.RUnlock()
 func TestApplySearchResults_CurrentGenerationAppliedAfterSearch(t *testing.T) {
 	searchCalled := make(chan struct{}, 1)
+	idleCalled := make(chan glib.SourceFunc, 1)
 	history := &fakeHistorySidebarHistory{
 		searchFn: func(context.Context, dto.HistorySearchInput) (*dto.HistorySearchOutput, error) {
 	hs.ctx = context.Background()
 	hs.historyUC = history
 	hs.searchGen = 1
+	hs.idleScheduler = func(cb glib.SourceFunc) {
+		idleCalled <- cb
+	}
 	// Start the search and wait for the use case to be invoked.
 	hs.doFTSearch("live", 1)
 		t.Fatal("timed out waiting for search use case to be invoked")
 	}
-	// glib.IdleAdd is a no-op without GTK, so apply the callback effect directly.
+	select {
-	applied := hs.applySearchResults([]*entity.HistoryEntry{
+	case cb := <-idleCalled:
-		{ID: 1, URL: "https://live.com", Title: "Live", LastVisited: time.Now()},
+		cb(0)
-	}, 1, nil)
+	case <-time.After(time.Second):
-	require.True(t, applied)
+		t.Fatal("timed out waiting for scheduled idle callback")
+	}
 	hs.mu.RLock()
 	assert.NotNil(t, hs.searchResults)