fix(test): configure git user in TestCommitChangelog for CI

The test relied on global git config for author identity, which is
not available in CI environments.

Author: outofcoffee

.gitignore

@@ -2,3 +2,4 @@
 /.idea/
 /dist/
 since
+.claude/*.local.json

convcommits/commits_test.go

@@ -18,6 +18,7 @@ package convcommits
 
 import (
 	"reflect"
+	"sort"
 	"testing"
 )
 
@@ -56,3 +57,54 @@ func TestCategoriseByType(t *testing.T) {
 		})
 	}
 }
+
+func TestCategoriseByType_scopedCommits(t *testing.T) {
+	commits := []string{"feat(api): add endpoint", "fix(ui): correct layout"}
+	got := CategoriseByType(commits)
+
+	if len(got) != 2 {
+		t.Fatalf("expected 2 categories, got %d", len(got))
+	}
+	if _, ok := got["feat"]; !ok {
+		t.Errorf("expected 'feat' category, got keys: %v", got)
+	}
+	if _, ok := got["fix"]; !ok {
+		t.Errorf("expected 'fix' category, got keys: %v", got)
+	}
+}
+
+func TestCategoriseByType_breakingChange(t *testing.T) {
+	commits := []string{"feat!: breaking feature"}
+	got := CategoriseByType(commits)
+
+	if _, ok := got["BREAKING CHANGE"]; !ok {
+		t.Errorf("expected 'BREAKING CHANGE' category, got keys: %v", got)
+	}
+}
+
+func TestCategoriseByType_noPrefix(t *testing.T) {
+	commits := []string{"some random commit message"}
+	got := CategoriseByType(commits)
+
+	if _, ok := got[""]; !ok {
+		t.Errorf("expected empty prefix category, got keys: %v", got)
+	}
+}
+
+func TestDetermineTypes(t *testing.T) {
+	commits := []string{"feat: foo", "fix: bar", "feat: baz"}
+	got := DetermineTypes(commits)
+	sort.Strings(got)
+
+	want := []string{"feat", "fix"}
+	sort.Strings(want)
+
+	if len(got) != len(want) {
+		t.Fatalf("DetermineTypes() length = %d, want %d", len(got), len(want))
+	}
+	for i := range got {
+		if got[i] != want[i] {
+			t.Errorf("DetermineTypes()[%d] = %v, want %v", i, got[i], want[i])
+		}
+	}
+}

convcommits/commits_test_extra_test.go

@@ -120,3 +120,80 @@ func TestDetermineChangeType(t *testing.T) {
 		})
 	}
 }
+
+func TestGetNextVersion_withVPrefix(t *testing.T) {
+	got := GetNextVersion("1.2.3", true, []string{"feat: new feature"})
+	want := "v1.3.0"
+	if got != want {
+		t.Errorf("GetNextVersion() with vPrefix = %v, want %v", got, want)
+	}
+}
+
+func TestGetNextVersion_noChanges(t *testing.T) {
+	got := GetNextVersion("1.2.3", false, []string{"unknown: something"})
+	want := ""
+	if got != want {
+		t.Errorf("GetNextVersion() with no recognised changes = %v, want %v", got, want)
+	}
+}
+
+func TestDetermineChangeType_allPatchTypes(t *testing.T) {
+	patchTypes := []string{"build", "chore", "ci", "docs", "fix", "refactor", "security", "style", "test"}
+	for _, pt := range patchTypes {
+		t.Run(pt, func(t *testing.T) {
+			got := DetermineChangeType([]string{pt})
+			if got != ComponentPatch {
+				t.Errorf("DetermineChangeType(%v) = %v, want %v", pt, got, ComponentPatch)
+			}
+		})
+	}
+}
+
+func TestDetermineChangeType_none(t *testing.T) {
+	got := DetermineChangeType([]string{"unknown"})
+	if got != ComponentNone {
+		t.Errorf("DetermineChangeType(unknown) = %v, want %v", got, ComponentNone)
+	}
+}
+
+func TestDetermineChangeType_majorTakesPrecedence(t *testing.T) {
+	got := DetermineChangeType([]string{"feat", "BREAKING CHANGE", "fix"})
+	if got != ComponentMajor {
+		t.Errorf("DetermineChangeType() = %v, want %v", got, ComponentMajor)
+	}
+}
+
+func TestBumpVersion(t *testing.T) {
+	tests := []struct {
+		name      string
+		version   string
+		component Component
+		want      string
+	}{
+		{
+			name:      "bump major resets minor and patch",
+			version:   "1.5.9",
+			component: ComponentMajor,
+			want:      "2.0.0",
+		},
+		{
+			name:      "bump minor resets patch",
+			version:   "1.5.9",
+			component: ComponentMinor,
+			want:      "1.6.0",
+		},
+		{
+			name:      "bump patch only",
+			version:   "1.5.9",
+			component: ComponentPatch,
+			want:      "1.5.10",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := bumpVersion(tt.version, tt.component); got != tt.want {
+				t.Errorf("bumpVersion() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

semver/versions_test.go

@@ -16,7 +16,11 @@ limitations under the License.
 
 package vcs
 
-import "testing"
+import (
+	"reflect"
+	"regexp"
+	"testing"
+)
 
 func Test_getShortMessage(t *testing.T) {
 	type args struct {
@@ -50,3 +54,89 @@ func Test_getShortMessage(t *testing.T) {
 		})
 	}
 }
+
+func TestFlattenCommits(t *testing.T) {
+	tags := []TagCommits{
+		{
+			TagMeta: TagMeta{Name: "v1"},
+			Commits: []string{"feat: a", "fix: b"},
+		},
+		{
+			TagMeta: TagMeta{Name: "v2"},
+			Commits: []string{"chore: c"},
+		},
+	}
+	got := FlattenCommits(&tags)
+	want := []string{"feat: a", "fix: b", "chore: c"}
+	if !reflect.DeepEqual(got, want) {
+		t.Errorf("FlattenCommits() = %v, want %v", got, want)
+	}
+}
+
+func TestFlattenCommits_empty(t *testing.T) {
+	tags := []TagCommits{}
+	got := FlattenCommits(&tags)
+	if len(got) != 0 {
+		t.Errorf("FlattenCommits() = %v, want empty", got)
+	}
+}
+
+func Test_shouldInclude(t *testing.T) {
+	tests := []struct {
+		name     string
+		message  string
+		excludes []*regexp.Regexp
+		want     bool
+	}{
+		{
+			name:     "no excludes",
+			message:  "feat: something",
+			excludes: nil,
+			want:     true,
+		},
+		{
+			name:     "matching exclude",
+			message:  "build: release v1.0.0",
+			excludes: []*regexp.Regexp{regexp.MustCompile(`^build: release`)},
+			want:     false,
+		},
+		{
+			name:     "non-matching exclude",
+			message:  "feat: new feature",
+			excludes: []*regexp.Regexp{regexp.MustCompile(`^build: release`)},
+			want:     true,
+		},
+		{
+			name:    "multiple excludes with one match",
+			message: "chore: bump deps",
+			excludes: []*regexp.Regexp{
+				regexp.MustCompile(`^build: release`),
+				regexp.MustCompile(`^chore: bump`),
+			},
+			want: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := shouldInclude(tt.message, tt.excludes); got != tt.want {
+				t.Errorf("shouldInclude() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func Test_getShortMessage_singleLine(t *testing.T) {
+	got := getShortMessage("simple message")
+	want := "simple message"
+	if got != want {
+		t.Errorf("getShortMessage() = %v, want %v", got, want)
+	}
+}
+
+func Test_getShortMessage_withLeadingWhitespace(t *testing.T) {
+	got := getShortMessage("  message with spaces  ")
+	want := "message with spaces"
+	if got != want {
+		t.Errorf("getShortMessage() = %v, want %v", got, want)
+	}
+}