chore(coverage): find file cosmetics (#150)

Author: vladopajic

pkg/testcoverage/coverage/cover.go

@@ -10,9 +10,9 @@ import (
 	"path/filepath"
 	"strings"
 
-	"github.com/vladopajic/go-test-coverage/v2/pkg/testcoverage/path"
-
 	"golang.org/x/tools/cover"
+
+	"github.com/vladopajic/go-test-coverage/v2/pkg/testcoverage/path"
 )
 
 const IgnoreText = "coverage-ignore"
@@ -23,6 +23,103 @@ type Config struct {
 	ExcludePaths []string
 }
 
+func GenerateCoverageStats(cfg Config) ([]Stats, error) {
+	profiles, err := parseProfiles(cfg.Profiles)
+	if err != nil {
+		return nil, fmt.Errorf("parsing profiles: %w", err)
+	}
+
+	files, err := findFiles(profiles, cfg.LocalPrefix)
+	if err != nil {
+		return nil, err
+	}
+
+	fileStats := make([]Stats, 0, len(profiles))
+	excludeRules := compileExcludePathRules(cfg.ExcludePaths)
+
+	for _, profile := range profiles {
+		fi, ok := files[profile.FileName]
+		if !ok { // coverage-ignore
+			// should already be handled above, but let's check it again
+			return nil, fmt.Errorf("could not find file [%s]", profile.FileName)
+		}
+
+		if ok := matches(excludeRules, fi.noPrefixName); ok {
+			continue // this file is excluded
+		}
+
+		s, err := coverageForFile(profile, fi)
+		if err != nil {
+			return nil, err
+		}
+
+		if s.Total == 0 {
+			// do not include files that doesn't have statements.
+			// this can happen when everything is excluded with comment annotations, or
+			// simply file doesn't have any statement.
+			//
+			// note: we are explicitly adding `continue` statement, instead of having code like this:
+			// if s.Total != 0 {
+			// 	fileStats = append(fileStats, s)
+			// }
+			// because with `continue` add additional statements in coverage profile which will require
+			// to have it covered with tests. since this is interesting case, to have it covered
+			// with tests, we have code written in this way
+			continue
+		}
+
+		fileStats = append(fileStats, s)
+	}
+
+	return fileStats, nil
+}
+
+func coverageForFile(profile *cover.Profile, fi fileInfo) (Stats, error) {
+	source, err := os.ReadFile(fi.path)
+	if err != nil { // coverage-ignore
+		return Stats{}, fmt.Errorf("failed reading file source [%s]: %w", fi.path, err)
+	}
+
+	funcs, blocks, err := findFuncsAndBlocks(source)
+	if err != nil { // coverage-ignore
+		return Stats{}, err
+	}
+
+	annotations, err := findAnnotations(source)
+	if err != nil { // coverage-ignore
+		return Stats{}, err
+	}
+
+	s := sumCoverage(profile, funcs, blocks, annotations)
+	s.Name = fi.noPrefixName
+
+	return s, nil
+}
+
+type fileInfo struct {
+	path         string
+	noPrefixName string
+}
+
+func findFiles(profiles []*cover.Profile, prefix string) (map[string]fileInfo, error) {
+	result := make(map[string]fileInfo)
+	findFile := findFileCreator()
+
+	for _, profile := range profiles {
+		file, noPrefixName, err := findFile(profile.FileName, prefix)
+		if err != nil {
+			return nil, fmt.Errorf("could not find file [%s]: %w", profile.FileName, err)
+		}
+
+		result[profile.FileName] = fileInfo{
+			path:         file,
+			noPrefixName: noPrefixName,
+		}
+	}
+
+	return result, nil
+}
+
 func findFileCreator() func(file, prefix string) (string, string, error) {
 	cache := make(map[string]*build.Package)
 
@@ -57,56 +154,6 @@ func findFileCreator() func(file, prefix string) (string, string, error) {
 	}
 }
 
-func GenerateCoverageStats(cfg Config) ([]Stats, error) {
-	profiles, err := parseProfiles(cfg.Profiles)
-	if err != nil {
-		return nil, fmt.Errorf("parsing profiles: %w", err)
-	}
-
-	findFile := findFileCreator()
-	fileStats := make([]Stats, 0, len(profiles))
-	excludeRules := compileExcludePathRules(cfg.ExcludePaths)
-
-	for _, profile := range profiles {
-		file, noPrefixName, err := findFile(profile.FileName, cfg.LocalPrefix)
-		if err != nil {
-			return nil, fmt.Errorf("could not find file [%s]: %w", profile.FileName, err)
-		}
-
-		if ok := matches(excludeRules, noPrefixName); ok {
-			continue // this file is excluded
-		}
-
-		source, err := os.ReadFile(file)
-		if err != nil { // coverage-ignore
-			return nil, fmt.Errorf("failed reading file source [%s]: %w", profile.FileName, err)
-		}
-
-		funcs, blocks, err := findFuncsAndBlocks(source)
-		if err != nil { // coverage-ignore
-			return nil, err
-		}
-
-		annotations, err := findAnnotations(source)
-		if err != nil { // coverage-ignore
-			return nil, err
-		}
-
-		s := coverageForFile(profile, funcs, blocks, annotations)
-		if s.Total == 0 {
-			// do not include files that doesn't have statements
-			// this can happen when everything is excluded with comment annotations, or
-			// simply file doesn't have any statement
-			continue
-		}
-
-		s.Name = noPrefixName
-		fileStats = append(fileStats, s)
-	}
-
-	return fileStats, nil
-}
-
 func findAnnotations(source []byte) ([]extent, error) {
 	fset := token.NewFileSet()
 
@@ -207,7 +254,7 @@ func hasExtentWithStartLine(ee []extent, startLine int) bool {
 	return found
 }
 
-func coverageForFile(profile *cover.Profile, funcs, blocks, annotations []extent) Stats {
+func sumCoverage(profile *cover.Profile, funcs, blocks, annotations []extent) Stats {
 	s := Stats{}
 
 	for _, f := range funcs {

pkg/testcoverage/coverage/cover_test.go

@@ -189,7 +189,7 @@ func Test_findFuncs(t *testing.T) {
 	}, blocks)
 }
 
-func Test_coverageForFile(t *testing.T) {
+func Test_sumCoverage(t *testing.T) {
 	t.Parallel()
 
 	funcs := []Extent{
@@ -205,17 +205,17 @@ func Test_coverageForFile(t *testing.T) {
 		{StartLine: 12, EndLine: 20, NumStmt: 5},
 	}}
 
-	s := CoverageForFile(profile, funcs, nil, nil)
+	s := SumCoverage(profile, funcs, nil, nil)
 	assert.Equal(t, Stats{Total: 10, Covered: 0}, s)
 
 	// Coverage should be empty when every function is excluded
-	s = CoverageForFile(profile, funcs, nil, funcs)
+	s = SumCoverage(profile, funcs, nil, funcs)
 	assert.Equal(t, Stats{Total: 0, Covered: 0}, s)
 
 	// Case when annotations is set on block (it should ignore whole block)
 	annotations := []Extent{{StartLine: 4, EndLine: 4}}
 	blocks := []Extent{{StartLine: 4, EndLine: 10}}
-	s = CoverageForFile(profile, funcs, blocks, annotations)
+	s = SumCoverage(profile, funcs, blocks, annotations)
 	assert.Equal(t, Stats{Total: 7, Covered: 0}, s)
 }
 

pkg/testcoverage/coverage/export_test.go

@@ -5,7 +5,7 @@ var (
 	FindAnnotations    = findAnnotations
 	FindFuncsAndBlocks = findFuncsAndBlocks
 	ParseProfiles      = parseProfiles
-	CoverageForFile    = coverageForFile
+	SumCoverage        = sumCoverage
 )
 
 type Extent = extent