Merge pull request #369 from bmf-san/test/increase-line-coverage-for-codecov

test: increase line coverage to ~83.5% for Codecov

Author: bmf-san

cmd/version_test.go

@@ -391,3 +391,94 @@ func TestCompareSemanticVersions_DifferentLengths(t *testing.T) {
 		t.Errorf("compareSemanticVersions(v1.1, v1.0.9) = %d, want 1", got)
 	}
 }
+
+// ─── ensureCreatedAtSet: exercise the CreatedAt="" branch ─────────────────────
+
+func TestVersioner_EnsureCreatedAtSet(t *testing.T) {
+	tempDir := t.TempDir()
+	configPath := filepath.Join(tempDir, ".ggcconfig.yaml")
+	// Empty YAML: LoadConfig will use defaults — CreatedAt stays ""
+	if err := os.WriteFile(configPath, []byte(""), 0644); err != nil {
+		t.Fatalf("WriteFile: %v", err)
+	}
+
+	originalHome := os.Getenv("HOME")
+	if err := os.Setenv("HOME", tempDir); err != nil {
+		t.Fatalf("Setenv HOME: %v", err)
+	}
+	t.Cleanup(func() { _ = os.Setenv("HOME", originalHome) })
+
+	originalGetter := getVersionInfo
+	SetVersionGetter(nil) // no version update — isolate ensureCreatedAtSet
+	t.Cleanup(func() { getVersionInfo = originalGetter })
+
+	var buf bytes.Buffer
+	v := &Versioner{
+		gitClient:    testutil.NewMockGitClient(),
+		outputWriter: &buf,
+		helper:       NewHelper(),
+		execCommand:  exec.Command,
+	}
+	v.helper.outputWriter = &buf
+	v.Version([]string{})
+
+	output := buf.String()
+	if strings.Contains(output, "warn: failed to set created-at") {
+		t.Errorf("unexpected created-at warning: %s", output)
+	}
+	if !strings.Contains(output, "ggc version") {
+		t.Errorf("expected version in output, got: %s", output)
+	}
+}
+
+// ─── updateVersionInfoFromBuild: exercise when getVersionInfo returns new info ─
+
+func TestVersioner_UpdateVersionInfoFromBuild(t *testing.T) {
+	tempDir := t.TempDir()
+	configPath := filepath.Join(tempDir, ".ggcconfig.yaml")
+	if err := os.WriteFile(configPath, []byte(""), 0644); err != nil {
+		t.Fatalf("WriteFile: %v", err)
+	}
+
+	originalHome := os.Getenv("HOME")
+	if err := os.Setenv("HOME", tempDir); err != nil {
+		t.Fatalf("Setenv HOME: %v", err)
+	}
+	t.Cleanup(func() { _ = os.Setenv("HOME", originalHome) })
+
+	originalGetter := getVersionInfo
+	SetVersionGetter(func() (string, string) { return "v99.0.0", "commit9999" })
+	t.Cleanup(func() { getVersionInfo = originalGetter })
+
+	var buf bytes.Buffer
+	v := &Versioner{
+		gitClient:    testutil.NewMockGitClient(),
+		outputWriter: &buf,
+		helper:       NewHelper(),
+		execCommand:  exec.Command,
+	}
+	v.helper.outputWriter = &buf
+	v.Version([]string{})
+
+	output := buf.String()
+	if !strings.Contains(output, "v99.0.0") {
+		t.Errorf("expected v99.0.0 in output, got: %s", output)
+	}
+}
+
+// ─── updateConfigValue: exercise the Set-failure warning path ─────────────────
+
+func TestVersioner_UpdateConfigValue_Error(t *testing.T) {
+	var buf bytes.Buffer
+	v := &Versioner{
+		gitClient:    testutil.NewMockGitClient(),
+		outputWriter: &buf,
+	}
+	cm := config.NewConfigManager(testutil.NewMockGitClient())
+	// Empty key fails sanitizeConfigPath → Set returns error → warn logged
+	v.updateConfigValue(cm, "", "value")
+
+	if !strings.Contains(buf.String(), "warn: failed to set") {
+		t.Errorf("expected warn in output, got: %q", buf.String())
+	}
+}

internal/config/config_test.go

@@ -2211,3 +2211,187 @@ func TestSetMapValue(t *testing.T) {
 		t.Errorf("Expected no error setting int value, got %v", err)
 	}
 }
+
+// ─── failingGitClient forces ConfigSetGlobal to return errors for sync tests ───
+// git.ConfigOps requires ConfigGetGlobal, ConfigSetGlobal, GetVersion, GetCommitHash.
+
+type failingGitClient struct {
+	failKey string // if empty, all ConfigSetGlobal calls fail
+}
+
+func newFailingGitClient(failKey string) *failingGitClient {
+	return &failingGitClient{failKey: failKey}
+}
+
+func (f *failingGitClient) ConfigGetGlobal(_ string) (string, error) { return "", nil }
+func (f *failingGitClient) ConfigSetGlobal(key, _ string) error {
+	if f.failKey == "" || key == f.failKey {
+		return fmt.Errorf("forced git error for %s", key)
+	}
+	return nil
+}
+func (f *failingGitClient) GetVersion() (string, error)    { return "test", nil }
+func (f *failingGitClient) GetCommitHash() (string, error) { return "abc", nil }
+
+func newTestConfigManagerWithFailingGit(failKey string) *Manager {
+	return NewConfigManager(newFailingGitClient(failKey))
+}
+
+// TestSyncDefaultSettings_EditorError covers the error return when setting core.editor fails
+func TestSyncDefaultSettings_EditorError(t *testing.T) {
+	cm := newTestConfigManagerWithFailingGit("core.editor")
+	cfg := cm.GetConfig()
+	cfg.Default.Editor = "vim"
+	err := cm.syncDefaultSettings(cfg)
+	if err == nil {
+		t.Error("expected error when core.editor ConfigSetGlobal fails")
+	}
+}
+
+// TestSyncDefaultSettings_MergeToolError covers the merge.tool error path
+func TestSyncDefaultSettings_MergeToolError(t *testing.T) {
+	cm := newTestConfigManagerWithFailingGit("merge.tool")
+	cfg := cm.GetConfig()
+	cfg.Default.Editor = "" // skip editor
+	cfg.Default.MergeTool = "vimdiff"
+	err := cm.syncDefaultSettings(cfg)
+	if err == nil {
+		t.Error("expected error when merge.tool ConfigSetGlobal fails")
+	}
+}
+
+// TestSyncDefaultSettings_BranchError covers the init.defaultBranch error path
+func TestSyncDefaultSettings_BranchError(t *testing.T) {
+	cm := newTestConfigManagerWithFailingGit("init.defaultBranch")
+	cfg := cm.GetConfig()
+	cfg.Default.Editor = ""
+	cfg.Default.MergeTool = ""
+	cfg.Default.Branch = "main"
+	err := cm.syncDefaultSettings(cfg)
+	if err == nil {
+		t.Error("expected error when init.defaultBranch ConfigSetGlobal fails")
+	}
+}
+
+// TestSyncUISettings_ColorError covers the color.ui error path
+func TestSyncUISettings_ColorError(t *testing.T) {
+	cm := newTestConfigManagerWithFailingGit("color.ui")
+	cfg := cm.GetConfig()
+	err := cm.syncUISettings(cfg)
+	if err == nil {
+		t.Error("expected error when color.ui ConfigSetGlobal fails")
+	}
+}
+
+// TestSyncUISettings_PagerError covers the core.pager error path.
+// color.ui always uses ConfigSetGlobal; we use a key-specific failing mock so
+// color.ui succeeds but core.pager fails.
+func TestSyncUISettings_PagerError(t *testing.T) {
+	cm := newTestConfigManagerWithFailingGit("core.pager")
+	cfg := cm.GetConfig()
+	cfg.UI.Color = true  // color.ui will call ConfigSetGlobal("color.ui","true") → passes
+	cfg.UI.Pager = false // triggers the pager branch → fails
+	err := cm.syncUISettings(cfg)
+	if err == nil {
+		t.Error("expected error when core.pager ConfigSetGlobal fails")
+	}
+}
+
+// TestSyncBehaviorSettings_AutoFetchError covers the fetch.auto error path
+func TestSyncBehaviorSettings_AutoFetchError(t *testing.T) {
+	cm := newTestConfigManagerWithFailingGit("fetch.auto")
+	cfg := cm.GetConfig()
+	err := cm.syncBehaviorSettings(cfg)
+	if err == nil {
+		t.Error("expected error when fetch.auto ConfigSetGlobal fails")
+	}
+}
+
+// TestSyncAliasSettings_Error covers the alias set error path
+func TestSyncAliasSettings_Error(t *testing.T) {
+	cm := newTestConfigManagerWithFailingGit("alias.co")
+	cfg := cm.GetConfig()
+	cfg.Aliases = map[string]interface{}{"co": "checkout"}
+	err := cm.syncAliasSettings(cfg)
+	if err == nil {
+		t.Error("expected error when alias ConfigSetGlobal fails")
+	}
+}
+
+// TestSyncToGitConfig_DefaultSettingsError verifies syncToGitConfig propagates editor error
+func TestSyncToGitConfig_DefaultSettingsError(t *testing.T) {
+	cm := newTestConfigManagerWithFailingGit("core.editor")
+	cfg := cm.GetConfig()
+	cfg.Default.Editor = "vim"
+	err := cm.syncToGitConfig()
+	if err == nil {
+		t.Error("expected syncToGitConfig to return error on editor failure")
+	}
+}
+
+// ─── helpers for FileOps error injection ───────────────────────────────────────
+
+// mockTempFileWriteError is a TempFile whose Write always fails.
+type mockTempFileWriteError struct {
+	name string
+}
+
+func (m *mockTempFileWriteError) Write(_ []byte) (int, error) {
+	return 0, fmt.Errorf("forced write error")
+}
+func (m *mockTempFileWriteError) Close() error { return nil }
+func (m *mockTempFileWriteError) Name() string { return m.name }
+
+// MockFileOpsWithWriteError wraps MockFileOps and injects a write error via CreateTemp.
+type MockFileOpsWithWriteError struct {
+	*MockFileOps
+}
+
+func NewMockFileOpsWithWriteError() *MockFileOpsWithWriteError {
+	return &MockFileOpsWithWriteError{MockFileOps: NewMockFileOps()}
+}
+
+func (m *MockFileOpsWithWriteError) CreateTemp(dir, pattern string) (TempFile, error) {
+	return &mockTempFileWriteError{name: dir + "/tmp_" + pattern}, nil
+}
+
+// MockFileOpsWithRenameError wraps MockFileOps and makes Rename always fail.
+type MockFileOpsWithRenameError struct {
+	*MockFileOps
+}
+
+func NewMockFileOpsWithRenameError() *MockFileOpsWithRenameError {
+	return &MockFileOpsWithRenameError{MockFileOps: NewMockFileOps()}
+}
+
+func (m *MockFileOpsWithRenameError) Rename(_, _ string) error {
+	return fmt.Errorf("forced rename error")
+}
+
+// TestWriteTempConfigWithOps_WriteError verifies that a write error is propagated.
+func TestWriteTempConfigWithOps_WriteError(t *testing.T) {
+	mockFS := NewMockFileOpsWithWriteError()
+	if err := mockFS.MkdirAll("/test", 0700); err != nil {
+		t.Fatal(err)
+	}
+	cm := newTestConfigManager()
+	cm.configPath = "/test/cfg.yaml"
+	_, err := cm.writeTempConfigWithOps("/test", []byte("data"), mockFS)
+	if err == nil {
+		t.Error("expected error when temp-file Write fails")
+	}
+}
+
+// TestReplaceConfigFileWithOps_RenameError simulates a rename failure
+func TestReplaceConfigFileWithOps_RenameError(t *testing.T) {
+	mockFS := NewMockFileOpsWithRenameError()
+	if err := mockFS.MkdirAll("/test", 0700); err != nil {
+		t.Fatal(err)
+	}
+	cm := newTestConfigManager()
+	cm.configPath = "/test/cfg.yaml"
+	err := cm.replaceConfigFileWithOps("/test/.tmp-file", mockFS)
+	if err == nil {
+		t.Error("expected error when rename fails")
+	}
+}

internal/keybindings/context_manager_test.go

@@ -2,6 +2,7 @@ package keybindings
 
 import (
 	"testing"
+	"time"
 
 	"github.com/bmf-san/ggc/v8/internal/config"
 )
@@ -60,3 +61,100 @@ func TestContextManagerStackAndCallbacks(t *testing.T) {
 		t.Fatalf("exit on empty stack returned %v", got)
 	}
 }
+
+// ── ContextManager: SetContext, ForceEnvironment ─────────────────────────────
+
+func TestContextManager_SetContext(t *testing.T) {
+	resolver := NewKeyBindingResolver(&config.Config{})
+	RegisterBuiltinProfiles(resolver)
+	cm := NewContextManager(resolver)
+
+	var transitions [][2]Context
+	cm.RegisterContextCallback(ContextResults, func(from, to Context) {
+		transitions = append(transitions, [2]Context{from, to})
+	})
+
+	// SetContext to new context
+	cm.SetContext(ContextResults)
+	if cm.GetCurrentContext() != ContextResults {
+		t.Errorf("SetContext: current = %v, want %v", cm.GetCurrentContext(), ContextResults)
+	}
+	if len(transitions) != 1 {
+		t.Errorf("expected 1 transition callback, got %d", len(transitions))
+	}
+
+	// SetContext to same context should be no-op
+	cm.SetContext(ContextResults)
+	if len(transitions) != 1 {
+		t.Errorf("SetContext same context should not fire callback, got %d transitions", len(transitions))
+	}
+
+	// Stack should be unmodified
+	if len(cm.GetContextStack()) != 0 {
+		t.Errorf("SetContext should not modify stack, got %v", cm.GetContextStack())
+	}
+}
+
+func TestContextManager_ForceEnvironment(t *testing.T) {
+	resolver := NewKeyBindingResolver(&config.Config{})
+	RegisterBuiltinProfiles(resolver)
+	cm := NewContextManager(resolver)
+
+	// Should not panic
+	cm.ForceEnvironment("darwin", "xterm-256color")
+}
+
+func TestContextManager_ForceEnvironment_NilCM(t *testing.T) {
+	var cm *ContextManager
+	// Should not panic
+	cm.ForceEnvironment("linux", "xterm")
+}
+
+// ── ContextTransitionAnimator ────────────────────────────────────────────────
+
+func TestContextTransitionAnimator_FadeAndSlide(t *testing.T) {
+	cta := NewContextTransitionAnimator()
+	cta.SetDuration(0) // no sleep in tests
+
+	cta.SetStyle("fade")
+	cta.AnimateTransition(ContextGlobal, ContextResults)
+
+	cta.SetStyle("slide")
+	cta.AnimateTransition(ContextGlobal, ContextInput)
+}
+
+func TestContextTransitionAnimator_Disable(t *testing.T) {
+	cta := NewContextTransitionAnimator()
+	cta.Disable()
+	// Should return early without doing anything
+	cta.AnimateTransition(ContextGlobal, ContextResults)
+	if cta.enabled {
+		t.Error("expected disabled animator")
+	}
+}
+
+func TestContextTransitionAnimator_Enable(t *testing.T) {
+	cta := NewContextTransitionAnimator()
+	cta.Disable()
+	cta.Enable()
+	if !cta.enabled {
+		t.Error("expected enabled animator")
+	}
+}
+
+func TestContextTransitionAnimator_RegisterAnimation(t *testing.T) {
+	cta := NewContextTransitionAnimator()
+	cta.RegisterAnimation(func(from, to Context) {})
+	cta.RegisterAnimation(func(from, to Context) {})
+	if len(cta.animations) != 2 {
+		t.Errorf("expected 2 registered animations, got %d", len(cta.animations))
+	}
+}
+
+func TestContextTransitionAnimator_SetDuration(t *testing.T) {
+	cta := NewContextTransitionAnimator()
+	cta.SetDuration(500 * time.Millisecond)
+	if cta.duration != 500*time.Millisecond {
+		t.Errorf("duration = %v, want 500ms", cta.duration)
+	}
+}