### 1. Extended File Utility Tests ( internal/util/file.go ) -> 100.0% Coverage

  Added new test cases to file_test.go covering:

  • Special Perm Symbolic Output: Tested all branch cases for named pipes, sockets, character devices, block devices, and SetUID/SetGID/Sticky bits with and without execute bits.
  • Owner IDs Edge Cases: Tested inputs where the file stat is  nil , or the system property  stat.Sys()  returns  nil  or an unexpected type.
  • Lookup Error Paths: Tested invalid/non-existent user and group IDs to verify that  LookupUserName  and  LookupGroupName  successfully handle and bubble up errors.

  ### 2. UI Layout Helper Tests ( internal/ui/util/window.go ) -> 100.0% Coverage

  • Created window_test.go and added direct unit test coverage for  SetupWindow  and  SetupDialogWindow  on  tview.Box  to ensure window title configurations, alignment, and border themes are properly applied.

  ### 3. Loading Container Tests ( internal/ui/util/loading_container.go ) -> Increased Coverage

  • Expanded loading_container_test.go to verify  SetBorderColor  (for both  tview.Box  and  tview.Flex  child components) and  SetMessage .

  ### 4. File Watcher Tests ( internal/util/file_watcher.go ) -> Introduced Coverage (~75%)

  • Created file_watcher_test.go to test  FileWatcher  events in both standard and recursive modes using temporary directories, validating file creation callbacks and proper cleanup routines when  Stop()  is
called.

Author: markusressel

internal/ui/util/loading_container_test.go

@@ -74,4 +74,28 @@ func TestLoadingView_EdgeCases(t *testing.T) {
 	loadingViewNilApp.Start()
 	time.Sleep(150 * time.Millisecond)
 	loadingViewNilApp.Stop()
+
+	// Test SetMessage
+	loadingView.SetMessage("New message")
+	assert.Equal(t, "New message", loadingView.message)
+}
+
+func TestLoadingContainer_SetBorderColorAndMessage(t *testing.T) {
+	app := tview.NewApplication()
+
+	// Content is a Box
+	boxContent := tview.NewBox()
+	containerBox := NewLoadingContainer(app, boxContent, "Title", "Msg")
+	containerBox.SetBorderColor(tcell.ColorBlue)
+	assert.Equal(t, tcell.ColorBlue, boxContent.GetBorderColor())
+
+	// Content is a Flex
+	flexContent := tview.NewFlex()
+	containerFlex := NewLoadingContainer(app, flexContent, "Title", "Msg")
+	containerFlex.SetBorderColor(tcell.ColorRed)
+	assert.Equal(t, tcell.ColorRed, flexContent.GetBorderColor())
+
+	// Test SetMessage
+	containerBox.SetMessage("Another message")
+	assert.Equal(t, "Another message", containerBox.loadingView.message)
 }

internal/ui/util/window_test.go

@@ -0,0 +1,27 @@
+package util
+
+import (
+	"testing"
+	"zfs-file-history/internal/ui/theme"
+
+	"github.com/rivo/tview"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestSetupWindow(t *testing.T) {
+	box := tview.NewBox()
+	box.SetBorder(true)
+	SetupWindow(box, "My Window Title")
+
+	assert.Equal(t, theme.CreateTitleText("My Window Title"), box.GetTitle())
+	assert.Equal(t, theme.Colors.Layout.Border, box.GetBorderColor())
+}
+
+func TestSetupDialogWindow(t *testing.T) {
+	box := tview.NewBox()
+	box.SetBorder(true)
+	SetupDialogWindow(box, "My Dialog Title")
+
+	assert.Equal(t, theme.CreateTitleText("My Dialog Title"), box.GetTitle())
+	assert.Equal(t, theme.Colors.Dialog.Border, box.GetBorderColor())
+}

internal/util/file_test.go

@@ -152,3 +152,81 @@ func TestLookupCurrentUserAndGroupName(t *testing.T) {
 		t.Fatalf("LookupGroupName(%d) returned empty group name", gid)
 	}
 }
+
+func TestUnixPermSymbolic_SpecialFiles(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name string
+		mode os.FileMode
+		want string
+	}{
+		{name: "named pipe", mode: os.ModeNamedPipe | 0o600, want: "prw-------"},
+		{name: "socket", mode: os.ModeSocket | 0o666, want: "srw-rw-rw-"},
+		{name: "char device", mode: os.ModeDevice | os.ModeCharDevice | 0o600, want: "crw-------"},
+		{name: "block device", mode: os.ModeDevice | 0o600, want: "brw-------"},
+		{name: "setuid with execute", mode: os.ModeSetuid | 0o700, want: "-rws------"},
+		{name: "setuid without execute", mode: os.ModeSetuid | 0o600, want: "-rwS------"},
+		{name: "setgid with execute", mode: os.ModeSetgid | 0o070, want: "----rws---"},
+		{name: "setgid without execute", mode: os.ModeSetgid | 0o060, want: "----rwS---"},
+		{name: "sticky with execute", mode: os.ModeSticky | 0o007, want: "-------rwt"},
+		{name: "sticky without execute", mode: os.ModeSticky | 0o006, want: "-------rwT"},
+	}
+
+	for _, tt := range tests {
+		tt := tt
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+			if got := UnixPermSymbolic(tt.mode); got != tt.want {
+				t.Fatalf("UnixPermSymbolic() = %q, want %q", got, tt.want)
+			}
+		})
+	}
+}
+
+type dummyFileInfo struct {
+	os.FileInfo
+	sys interface{}
+}
+
+func (d *dummyFileInfo) Sys() interface{} {
+	return d.sys
+}
+
+func TestUnixOwnerIDs_EdgeCases(t *testing.T) {
+	t.Parallel()
+
+	// stat is nil
+	uid, gid, ok := UnixOwnerIDs(nil)
+	assert.False(t, ok)
+	assert.Zero(t, uid)
+	assert.Zero(t, gid)
+
+	// stat.Sys() is nil
+	uid, gid, ok = UnixOwnerIDs(&dummyFileInfo{sys: nil})
+	assert.False(t, ok)
+	assert.Zero(t, uid)
+	assert.Zero(t, gid)
+
+	// stat.Sys() is wrong type
+	uid, gid, ok = UnixOwnerIDs(&dummyFileInfo{sys: "not-stat_t"})
+	assert.False(t, ok)
+	assert.Zero(t, uid)
+	assert.Zero(t, gid)
+}
+
+func TestLookupUserName_Error(t *testing.T) {
+	t.Parallel()
+	// Lookup a highly unlikely UID
+	username, err := LookupUserName(999999)
+	assert.Error(t, err)
+	assert.Empty(t, username)
+}
+
+func TestLookupGroupName_Error(t *testing.T) {
+	t.Parallel()
+	// Lookup a highly unlikely GID
+	groupName, err := LookupGroupName(999999)
+	assert.Error(t, err)
+	assert.Empty(t, groupName)
+}

internal/util/file_watcher_test.go

@@ -0,0 +1,72 @@
+package util
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestFileWatcher(t *testing.T) {
+	tempDir := t.TempDir()
+
+	fw := NewFileWatcher(tempDir)
+	assert.Equal(t, tempDir, fw.RootPath)
+
+	eventChan := make(chan string, 10)
+	action := func(path string) {
+		eventChan <- path
+	}
+
+	err := fw.Watch(action)
+	assert.NoError(t, err)
+
+	// Write a new file
+	testFile := filepath.Join(tempDir, "test.txt")
+	err = os.WriteFile(testFile, []byte("hello"), 0644)
+	assert.NoError(t, err)
+
+	// Wait for event or timeout
+	select {
+	case eventPath := <-eventChan:
+		assert.NotEmpty(t, eventPath)
+	case <-time.After(3 * time.Second):
+		t.Fatal("timed out waiting for file watcher event")
+	}
+
+	fw.Stop()
+	time.Sleep(100 * time.Millisecond)
+}
+
+func TestFileWatcherRecursive(t *testing.T) {
+	tempDir := t.TempDir()
+	subDir := filepath.Join(tempDir, "subdir")
+	err := os.Mkdir(subDir, 0755)
+	assert.NoError(t, err)
+
+	fw := NewFileWatcher(tempDir)
+	eventChan := make(chan string, 10)
+	action := func(path string) {
+		eventChan <- path
+	}
+
+	fw.WatchRecursive(action)
+
+	// Write a new file in subdir
+	testFile := filepath.Join(subDir, "test.txt")
+	err = os.WriteFile(testFile, []byte("hello"), 0644)
+	assert.NoError(t, err)
+
+	// Wait for event or timeout
+	select {
+	case eventPath := <-eventChan:
+		assert.Contains(t, eventPath, "subdir")
+	case <-time.After(3 * time.Second):
+		t.Fatal("timed out waiting for recursive file watcher event")
+	}
+
+	fw.Stop()
+	time.Sleep(100 * time.Millisecond)
+}