chore: cosmetic naming

Author: vladopajic

pkg/testcoverage/check.go

@@ -87,7 +87,7 @@ func Analyze(cfg Config, current, base []coverage.Stats) AnalyzeResult {
 			makePackageStats(current), thr.Package, overrideRules,
 		),
 		FilesWithUncoveredLines: coverage.StatsFilterWithUncoveredLines(current),
-		TotalStats:              coverage.CalcTotalStats(current),
+		TotalStats:              coverage.StatsCalcTotal(current),
 		HasBaseBreakdown:        len(base) > 0,
 		Diff:                    calculateStatsDiff(current, base),
 	}
@@ -114,7 +114,7 @@ func saveCoverageBreakdown(cfg Config, stats []coverage.Stats) error {
 	}
 
 	//nolint:mnd,wrapcheck,gosec // relax
-	return os.WriteFile(cfg.BreakdownFileName, coverage.SerializeStats(stats), 0o644)
+	return os.WriteFile(cfg.BreakdownFileName, coverage.StatsSerialize(stats), 0o644)
 }
 
 func loadBaseCoverageBreakdown(cfg Config) ([]coverage.Stats, error) {
@@ -127,7 +127,7 @@ func loadBaseCoverageBreakdown(cfg Config) ([]coverage.Stats, error) {
 		return nil, fmt.Errorf("reading file content failed: %w", err)
 	}
 
-	stats, err := coverage.DeserializeStats(data)
+	stats, err := coverage.StatsDeserialize(data)
 	if err != nil {
 		return nil, fmt.Errorf("parsing file failed: %w", err)
 	}

pkg/testcoverage/check_test.go

@@ -238,7 +238,7 @@ func TestCheck(t *testing.T) {
 
 		stats, err := GenerateCoverageStats(cfg)
 		assert.NoError(t, err)
-		assert.Equal(t, coverage.SerializeStats(stats), contentBytes)
+		assert.Equal(t, coverage.StatsSerialize(stats), contentBytes)
 	})
 
 	t.Run("valid profile - invalid base breakdown file", func(t *testing.T) {

pkg/testcoverage/coverage/cover_test.go

@@ -56,7 +56,7 @@ func Test_GenerateCoverageStats(t *testing.T) {
 	assert.NoError(t, err)
 	assert.NotEmpty(t, stats2)
 	// stats2 should have less total statements because cover.go should have been excluded
-	assert.Greater(t, CalcTotalStats(stats1).Total, CalcTotalStats(stats2).Total)
+	assert.Greater(t, StatsCalcTotal(stats1).Total, StatsCalcTotal(stats2).Total)
 
 	// should remove prefix from stats
 	stats3, err := GenerateCoverageStats(Config{
@@ -65,17 +65,17 @@ func Test_GenerateCoverageStats(t *testing.T) {
 	})
 	assert.NoError(t, err)
 	assert.NotEmpty(t, stats3)
-	assert.Equal(t, CalcTotalStats(stats1), CalcTotalStats(stats3))
+	assert.Equal(t, StatsCalcTotal(stats1), StatsCalcTotal(stats3))
 	assert.NotContains(t, stats3[0].Name, prefix)
-	assert.NotEqual(t, 100, CalcTotalStats(stats3).CoveredPercentage())
+	assert.NotEqual(t, 100, StatsCalcTotal(stats3).CoveredPercentage())
 
 	// should have total coverage because of second profile
 	stats4, err := GenerateCoverageStats(Config{
 		Profiles: []string{profileOK, profileOKFull},
 	})
 	assert.NoError(t, err)
 	assert.NotEmpty(t, stats4)
-	assert.Equal(t, 100, CalcTotalStats(stats4).CoveredPercentage())
+	assert.Equal(t, 100, StatsCalcTotal(stats4).CoveredPercentage())
 
 	// should not have `badge/generate.go` in statistics because it has no statements
 	stats5, err := GenerateCoverageStats(Config{

pkg/testcoverage/coverage/types.go

@@ -108,7 +108,7 @@ func compileExcludePathRules(excludePaths []string) []*regexp.Regexp {
 	return compiled
 }
 
-func CalcTotalStats(stats []Stats) Stats {
+func StatsCalcTotal(stats []Stats) Stats {
 	total := Stats{}
 
 	for _, s := range stats {
@@ -153,7 +153,7 @@ func filter[T any](slice []T, predicate func(T) bool) []T {
 	return result
 }
 
-func SerializeStats(stats []Stats) []byte {
+func StatsSerialize(stats []Stats) []byte {
 	b := bytes.Buffer{}
 	sep, nl := []byte(";"), []byte("\n")
 
@@ -172,7 +172,7 @@ func SerializeStats(stats []Stats) []byte {
 
 var ErrInvalidFormat = errors.New("invalid format")
 
-func DeserializeStats(b []byte) ([]Stats, error) {
+func StatsDeserialize(b []byte) ([]Stats, error) {
 	deserializeLine := func(bl []byte) (Stats, error) {
 		fields := bytes.Split(bl, []byte(";"))
 		if len(fields) != 3 { //nolint:mnd // relax

pkg/testcoverage/coverage/types_test.go

@@ -48,25 +48,25 @@ func TestStatsSerialization(t *testing.T) {
 		{Name: "bar", Total: 9, Covered: 2},
 	}
 
-	b := SerializeStats(stats)
+	b := StatsSerialize(stats)
 	assert.Equal(t, "foo;11;1\nbar;9;2\n", string(b))
 
-	ds, err := DeserializeStats(b)
+	ds, err := StatsDeserialize(b)
 	assert.NoError(t, err)
 	assert.Equal(t, stats, ds)
 
 	// ignore empty lines
-	ds, err = DeserializeStats([]byte("\n\n\n\n"))
+	ds, err = StatsDeserialize([]byte("\n\n\n\n"))
 	assert.NoError(t, err)
 	assert.Empty(t, ds)
 
 	// invalid formats
-	_, err = DeserializeStats([]byte("foo;11;"))
+	_, err = StatsDeserialize([]byte("foo;11;"))
 	assert.Error(t, err)
 
-	_, err = DeserializeStats([]byte("foo;;11"))
+	_, err = StatsDeserialize([]byte("foo;;11"))
 	assert.Error(t, err)
 
-	_, err = DeserializeStats([]byte("foo;"))
+	_, err = StatsDeserialize([]byte("foo;"))
 	assert.Error(t, err)
 }