Support multiple test files (exercism#141)

When extracting test code from test files, support multiple test files
and not just the first test file.

Author: IsaacG

testrunner/ast.go

@@ -43,35 +43,37 @@ type rootLevelTest struct {
 
 // FindAllRootLevelTests parses the test file and extracts the name,
 // test code and task id for each top level test (parent test) in the file.
-func FindAllRootLevelTests(fileName string) []rootLevelTest {
+func FindAllRootLevelTests(fileNames []string) []rootLevelTest {
 	defer handleASTPanic()
 	tests := []rootLevelTest{}
 	fset := token.NewFileSet()
 	ppc := parser.ParseComments
-	file, err := parser.ParseFile(fset, fileName, nil, ppc)
-	if err != nil {
-		log.Printf("error: not able to parse '%s': %s", fileName, err)
-		return nil
-	}
-	for _, d := range file.Decls {
-		if f, ok := d.(*ast.FuncDecl); ok && strings.HasPrefix(f.Name.Name, "Test") {
-			taskID := findTaskID(f.Doc)
-			fun := &printer.CommentedNode{Node: f, Comments: file.Comments}
-			var buf bytes.Buffer
-			printErr := printer.Fprint(&buf, fset, fun)
-			if printErr != nil {
-				log.Printf("warning: failed to print AST for test %s in %s: %s",
-					f.Name.Name, fileName, err,
-				)
-			}
+	for _, fileName := range fileNames {
+		file, err := parser.ParseFile(fset, fileName, nil, ppc)
+		if err != nil {
+			log.Printf("error: not able to parse '%s': %s", fileName, err)
+			return nil
+		}
+		for _, d := range file.Decls {
+			if f, ok := d.(*ast.FuncDecl); ok && strings.HasPrefix(f.Name.Name, "Test") {
+				taskID := findTaskID(f.Doc)
+				fun := &printer.CommentedNode{Node: f, Comments: file.Comments}
+				var buf bytes.Buffer
+				printErr := printer.Fprint(&buf, fset, fun)
+				if printErr != nil {
+					log.Printf("warning: failed to print AST for test %s in %s: %s",
+						f.Name.Name, fileName, err,
+					)
+				}
 
-			tests = append(tests, rootLevelTest{
-				name:     f.Name.Name,
-				fileName: fileName,
-				code:     buf.String(),
-				taskID:   taskID,
-				pkgName:  file.Name.Name,
-			})
+				tests = append(tests, rootLevelTest{
+					name:     f.Name.Name,
+					fileName: fileName,
+					code:     buf.String(),
+					taskID:   taskID,
+					pkgName:  file.Name.Name,
+				})
+			}
 		}
 	}
 	return tests

testrunner/ast_test.go

@@ -27,7 +27,7 @@ func TestGetFuncCode(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			rootLevelTests := FindAllRootLevelTests(tt.testFile)
+			rootLevelTests := FindAllRootLevelTests([]string{tt.testFile})
 			rootLevelTestsMap := ConvertToMapByTestName(rootLevelTests)
 			if rootLevelTestsMap[tt.testName].code != tt.code {
 				t.Errorf("FindAllRootLevelTests for %s did not return correct code, got %v; want %v",

testrunner/execute.go

@@ -220,8 +220,8 @@ func processTestResults(
 	results := make([]testResult, 0)
 	resultIdxByName := make(map[string]int)
 
-	testFile := FindTestFile(input_dir)
-	rootLevelTests := FindAllRootLevelTests(testFile)
+	testFiles := FindTestFiles(input_dir)
+	rootLevelTests := FindAllRootLevelTests(testFiles)
 	rootLevelTestsMap := ConvertToMapByTestName(rootLevelTests)
 
 	for _, parsedLine := range parsedOutput.testLines {

testrunner/extract.go

@@ -15,31 +15,30 @@ func splitTestName(testName string) (string, string) {
 	return before, after
 }
 
-func FindTestFile(codePath string) string {
-	files, err := os.ReadDir(codePath)
+func FindTestFiles(codePath string) []string {
+	files, err := filepath.Glob(filepath.Join(codePath, "*_test.go"))
 	if err != nil {
 		log.Printf("warning: input_dir '%s' cannot be read: %s", codePath, err)
-		return ""
+		return nil
 	}
+	var found []string
+	for _, testpath := range files {
+		fh, err := os.ReadFile(testpath)
+		if err != nil {
+			log.Printf("warning: test file '%s' read failed: %s", testpath, err)
+		}
 
-	for _, f := range files {
-		if strings.HasSuffix(f.Name(), "_test.go") {
-			testpath := filepath.Join(codePath, f.Name())
-			fh, err := os.ReadFile(testpath)
-			if err != nil {
-				log.Printf("warning: test file '%s' read failed: %s", testpath, err)
-			}
-
-			// We need to check we found the file that actually contains the tests and not only the
-			// generated test cases (cases_test.go).
-			// Text processing is easier than using AST and should be reliable enough.
-			if strings.Contains(string(fh), "func Test") {
-				return testpath
-			}
+		// We need to check we found the file that actually contains the tests and not only the
+		// generated test cases (cases_test.go).
+		// Text processing is easier than using AST and should be reliable enough.
+		if strings.Contains(string(fh), "func Test") {
+			found = append(found, testpath)
 		}
 	}
-	log.Printf("error: test file not found in input_dir '%s'", codePath)
-	return ""
+	if len(found) == 0 {
+		log.Printf("error: test file not found in input_dir '%s'", codePath)
+	}
+	return found
 }
 
 // return the associated test function code from the given test file

testrunner/extract_test.go

@@ -2,6 +2,7 @@ package testrunner
 
 import (
 	"path/filepath"
+	"slices"
 	"strings"
 	"testing"
 )
@@ -40,22 +41,22 @@ func TestFindTestFile(t *testing.T) {
 	tests := []struct {
 		name     string
 		codePath string
-		fileName string
+		fileName []string
 	}{
 		{
 			name:     "found single test file",
 			codePath: filepath.Join("testdata", "practice", "passing"),
-			fileName: filepath.Join("testdata", "practice", "passing", "passing_test.go"),
+			fileName: []string{filepath.Join("testdata", "practice", "passing", "passing_test.go")},
 		},
 		{
 			name:     "found correct test file if there are two",
 			codePath: filepath.Join("testdata", "concept", "conditionals"),
-			fileName: filepath.Join("testdata", "concept", "conditionals", "conditionals_test.go"),
+			fileName: []string{filepath.Join("testdata", "concept", "conditionals", "conditionals_test.go")},
 		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			if tf := FindTestFile(tt.codePath); tf != tt.fileName {
+			if tf := FindTestFiles(tt.codePath); !slices.Equal(tf, tt.fileName) {
 				t.Errorf("findTestFile(%v) = %v; want %v",
 					tt.codePath, tf, tt.fileName)
 			}
@@ -65,7 +66,7 @@ func TestFindTestFile(t *testing.T) {
 
 func TestExtractTestCode(t *testing.T) {
 	tf := filepath.Join("testdata", "concept", "conditionals", "conditionals_test.go")
-	rootLevelTests := FindAllRootLevelTests(tf)
+	rootLevelTests := FindAllRootLevelTests([]string{tf})
 	rootLevelTestsMap := ConvertToMapByTestName(rootLevelTests)
 	tests := []struct {
 		name     string