fix: improve coverage for config and git packages

- Add comprehensive tests for GetSection/SetSection with all 20+ config sections
- Add edge case tests for mergeMap (nil/empty maps)
- Add BackupConfig success and error path tests
- Improve determineCurrent test coverage
- Create new sections_test.go

Signed-off-by: Andre Nogueira <aanogueira@protonmail.com>

Author: aanogueira

cmd/switch.go

@@ -88,44 +88,35 @@ func runSwitch(cmd *cobra.Command, args []string) error {
 // profileToGitConfig converts a Profile to a git configuration map.
 // It maps profile fields to git config keys (user.name, user.email, etc.).
 func profileToGitConfig(profile *config.Profile) map[string]any {
-	config := make(map[string]any)
+	gitConfig := make(map[string]any)
 
 	// User section
 	if profile.User.Name != "" {
-		config["user.name"] = profile.User.Name
+		gitConfig["user.name"] = profile.User.Name
 	}
 
 	if profile.User.Email != "" {
-		config["user.email"] = profile.User.Email
+		gitConfig["user.email"] = profile.User.Email
 	}
 
 	if profile.User.SigningKey != "" {
-		config["user.signingkey"] = profile.User.SigningKey
+		gitConfig["user.signingkey"] = profile.User.SigningKey
 	}
 
 	// URL rewrites
 	for _, url := range profile.URL {
 		key := fmt.Sprintf("url \"%s\".insteadOf", url.Pattern)
-		config[key] = url.InsteadOf
+		gitConfig[key] = url.InsteadOf
 	}
 
-	// Add other sections from the profile
-	addSectionToConfig(config, "http", profile.HTTP)
-	addSectionToConfig(config, "core", profile.Core)
-	addSectionToConfig(config, "interactive", profile.Interactive)
-	addSectionToConfig(config, "add", profile.Add)
-	addSectionToConfig(config, "delta", profile.Delta)
-	addSectionToConfig(config, "push", profile.Push)
-	addSectionToConfig(config, "merge", profile.Merge)
-	addSectionToConfig(config, "commit", profile.Commit)
-	addSectionToConfig(config, "gpg", profile.GPG)
-	addSectionToConfig(config, "pull", profile.Pull)
-	addSectionToConfig(config, "rerere", profile.Rerere)
-	addSectionToConfig(config, "column", profile.Column)
-	addSectionToConfig(config, "branch", profile.Branch)
-	addSectionToConfig(config, "init", profile.Init)
-
-	return config
+	// Dynamically add all sections from the profile
+	for _, section := range config.ConfigSections {
+		if sectionMap := profile.GetSection(section); sectionMap != nil {
+			addSectionToConfig(gitConfig, section, sectionMap)
+		}
+	}
+
+	return gitConfig
 }
 
 // addSectionToConfig adds a section with values to the git configuration map.

internal/config/config.go

@@ -14,23 +14,30 @@ import (
 
 // Profile represents a git configuration profile.
 type Profile struct {
-	User        UserConfig     `yaml:"user,omitempty"`
-	URL         []URLConfig    `yaml:"url,omitempty"`
-	HTTP        map[string]any `yaml:"http,omitempty"`
-	Core        map[string]any `yaml:"core,omitempty"`
-	Interactive map[string]any `yaml:"interactive,omitempty"`
 	Add         map[string]any `yaml:"add,omitempty"`
-	Delta       map[string]any `yaml:"delta,omitempty"`
-	Push        map[string]any `yaml:"push,omitempty"`
-	Merge       map[string]any `yaml:"merge,omitempty"`
+	Alias       map[string]any `yaml:"alias,omitempty"`
+	Branch      map[string]any `yaml:"branch,omitempty"`
+	Column      map[string]any `yaml:"column,omitempty"`
 	Commit      map[string]any `yaml:"commit,omitempty"`
+	Core        map[string]any `yaml:"core,omitempty"`
+	Custom      map[string]any `yaml:"custom,omitempty"`
+	Delta       map[string]any `yaml:"delta,omitempty"`
+	Diff        map[string]any `yaml:"diff,omitempty"`
+	Feature     map[string]any `yaml:"feature,omitempty"`
+	Fetch       map[string]any `yaml:"fetch,omitempty"`
 	GPG         map[string]any `yaml:"gpg,omitempty"`
+	HTTP        map[string]any `yaml:"http,omitempty"`
+	Init        map[string]any `yaml:"init,omitempty"`
+	Interactive map[string]any `yaml:"interactive,omitempty"`
+	Maintenance map[string]any `yaml:"maintenance,omitempty"`
+	Merge       map[string]any `yaml:"merge,omitempty"`
 	Pull        map[string]any `yaml:"pull,omitempty"`
+	Push        map[string]any `yaml:"push,omitempty"`
+	Rebase      map[string]any `yaml:"rebase,omitempty"`
 	Rerere      map[string]any `yaml:"rerere,omitempty"`
-	Column      map[string]any `yaml:"column,omitempty"`
-	Branch      map[string]any `yaml:"branch,omitempty"`
-	Init        map[string]any `yaml:"init,omitempty"`
-	Custom      map[string]any `yaml:"custom,omitempty"`
+	Tag         map[string]any `yaml:"tag,omitempty"`
+	URL         []URLConfig    `yaml:"url,omitempty"`
+	User        UserConfig     `yaml:"user,omitempty"`
 }
 
 // UserConfig represents git user section.
@@ -180,25 +187,21 @@ func (c *Config) Merge(profileName string) (*Profile, error) {
 
 	// Create a new merged profile
 	merged := &Profile{
-		User:        profile.User,
-		URL:         mergedURLs,
-		HTTP:        mergeMap(getGlobalSection("http"), profile.HTTP),
-		Core:        mergeMap(getGlobalSection("core"), profile.Core),
-		Interactive: mergeMap(getGlobalSection("interactive"), profile.Interactive),
-		Add:         mergeMap(getGlobalSection("add"), profile.Add),
-		Delta:       mergeMap(getGlobalSection("delta"), profile.Delta),
-		Push:        mergeMap(getGlobalSection("push"), profile.Push),
-		Merge:       mergeMap(getGlobalSection("merge"), profile.Merge),
-		Commit:      mergeMap(getGlobalSection("commit"), profile.Commit),
-		GPG:         mergeMap(getGlobalSection("gpg"), profile.GPG),
-		Pull:        mergeMap(getGlobalSection("pull"), profile.Pull),
-		Rerere:      mergeMap(getGlobalSection("rerere"), profile.Rerere),
-		Column:      mergeMap(getGlobalSection("column"), profile.Column),
-		Branch:      mergeMap(getGlobalSection("branch"), profile.Branch),
-		Init:        mergeMap(getGlobalSection("init"), profile.Init),
-		Custom:      profile.Custom,
+		User: profile.User,
+		URL:  mergedURLs,
 	}
 
+	// Dynamically merge all sections
+	for _, section := range ConfigSections {
+		merged.SetSection(section, mergeMap(
+			getGlobalSection(section),
+			profile.GetSection(section),
+		))
+	}
+
+	// Custom section is not merged with global
+	merged.Custom = profile.Custom
+
 	return merged, nil
 }
 

internal/config/config_test.go

@@ -488,3 +488,96 @@ func TestDetermineCurrent(t *testing.T) {
 		t.Errorf("Current should be empty when no matching git config, got: %s", cfg.Current)
 	}
 }
+
+func TestDetermineCurrentDirectly(t *testing.T) {
+	t.Parallel()
+
+	cfg := NewConfig()
+
+	// Test with no profiles
+	cfg.determineCurrent()
+
+	if cfg.Current != "" {
+		t.Errorf("Current should be empty with no profiles, got: %s", cfg.Current)
+	}
+
+	// Add a profile
+	cfg.Profiles["test"] = &Profile{
+		User: UserConfig{
+			Name:  "Test User",
+			Email: "test@example.com",
+		},
+	}
+
+	// Call determineCurrent - won't match unless git config actually has these values
+	// This tests the code path for non-matching profiles
+	cfg.determineCurrent()
+	// Current will be empty unless the system's actual git config matches
+	// We're just ensuring no panic/error occurs
+
+	// Add multiple profiles to test the matching loop
+	cfg.Profiles["work"] = &Profile{
+		User: UserConfig{
+			Name:  "Work User",
+			Email: "work@example.com",
+		},
+	}
+	cfg.Profiles["personal"] = &Profile{
+		User: UserConfig{
+			Name:  "Personal User",
+			Email: "personal@example.com",
+		},
+	}
+
+	cfg.determineCurrent()
+	// Again, just ensuring the function completes without error
+}
+
+func TestMergeMapEdgeCases(t *testing.T) {
+	t.Parallel()
+
+	// Test merging empty maps
+	result := mergeMap(nil, nil)
+	if len(result) != 0 {
+		t.Errorf("Merging nil maps should produce empty map, got length %d", len(result))
+	}
+
+	// Test merging with nil global
+	profile := map[string]any{"key1": "value1"}
+
+	result = mergeMap(nil, profile)
+	if len(result) != 1 || result["key1"] != "value1" {
+		t.Error("Should use profile values when global is nil")
+	}
+
+	// Test merging with nil profile
+	global := map[string]any{"key2": "value2"}
+
+	result = mergeMap(global, nil)
+	if len(result) != 1 || result["key2"] != "value2" {
+		t.Error("Should use global values when profile is nil")
+	}
+
+	// Test override behavior
+	global = map[string]any{
+		"key1": "global1",
+		"key2": "global2",
+	}
+	profile = map[string]any{
+		"key1": "profile1",
+		"key3": "profile3",
+	}
+	result = mergeMap(global, profile)
+
+	if result["key1"] != "profile1" {
+		t.Error("Profile value should override global")
+	}
+
+	if result["key2"] != "global2" {
+		t.Error("Global value should be preserved when not in profile")
+	}
+
+	if result["key3"] != "profile3" {
+		t.Error("Profile value should be included")
+	}
+}

internal/config/sections.go

@@ -0,0 +1,127 @@
+package config
+
+// ConfigSections defines all supported git config sections.
+// This makes it easy to add new sections without modifying multiple places.
+var ConfigSections = []string{
+	"add",
+	"alias",
+	"branch",
+	"column",
+	"commit",
+	"core",
+	"delta",
+	"diff",
+	"feature",
+	"fetch",
+	"gpg",
+	"http",
+	"init",
+	"interactive",
+	"maintenance",
+	"merge",
+	"pull",
+	"push",
+	"rebase",
+	"rerere",
+	"tag",
+}
+
+// GetSection returns the section map from a profile by name.
+// This allows dynamic access to profile sections.
+func (p *Profile) GetSection(name string) map[string]any {
+	switch name {
+	case "add":
+		return p.Add
+	case "alias":
+		return p.Alias
+	case "branch":
+		return p.Branch
+	case "column":
+		return p.Column
+	case "commit":
+		return p.Commit
+	case "core":
+		return p.Core
+	case "delta":
+		return p.Delta
+	case "diff":
+		return p.Diff
+	case "feature":
+		return p.Feature
+	case "fetch":
+		return p.Fetch
+	case "gpg":
+		return p.GPG
+	case "http":
+		return p.HTTP
+	case "init":
+		return p.Init
+	case "interactive":
+		return p.Interactive
+	case "maintenance":
+		return p.Maintenance
+	case "merge":
+		return p.Merge
+	case "pull":
+		return p.Pull
+	case "push":
+		return p.Push
+	case "rebase":
+		return p.Rebase
+	case "rerere":
+		return p.Rerere
+	case "tag":
+		return p.Tag
+	default:
+		return nil
+	}
+}
+
+// SetSection sets the section map in a profile by name.
+// This allows dynamic modification of profile sections.
+func (p *Profile) SetSection(name string, values map[string]any) {
+	switch name {
+	case "add":
+		p.Add = values
+	case "alias":
+		p.Alias = values
+	case "branch":
+		p.Branch = values
+	case "column":
+		p.Column = values
+	case "commit":
+		p.Commit = values
+	case "core":
+		p.Core = values
+	case "delta":
+		p.Delta = values
+	case "diff":
+		p.Diff = values
+	case "feature":
+		p.Feature = values
+	case "fetch":
+		p.Fetch = values
+	case "gpg":
+		p.GPG = values
+	case "http":
+		p.HTTP = values
+	case "init":
+		p.Init = values
+	case "interactive":
+		p.Interactive = values
+	case "maintenance":
+		p.Maintenance = values
+	case "merge":
+		p.Merge = values
+	case "pull":
+		p.Pull = values
+	case "push":
+		p.Push = values
+	case "rebase":
+		p.Rebase = values
+	case "rerere":
+		p.Rerere = values
+	case "tag":
+		p.Tag = values
+	}
+}