refactor testgen (#93)

testgen/execute_template.go

@@ -0,0 +1,37 @@
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"go/format"
+	"os"
+	"text/template"
+)
+
+func ExecTemplate(tplName, tplFile, output string, data any) error {
+	tpl, err := os.ReadFile(tplFile)
+	if err != nil {
+		return fmt.Errorf("error reading %s: %s", tplFile, err)
+	}
+
+	tmpl, err := template.New(tplName).Parse(string(tpl))
+	if err != nil {
+		return fmt.Errorf("error parsing template %s: %s", tplFile, err)
+	}
+
+	code := new(bytes.Buffer)
+	if err := tmpl.Execute(code, data); err != nil {
+		return err
+	}
+
+	formattedCode, err := format.Source(code.Bytes())
+	if err != nil {
+		return err
+	}
+
+	if err := os.WriteFile(output, formattedCode, 0644); err != nil {
+		return err
+	}
+
+	return nil
+}

testgen/generate_cmp_perf_tests.go

@@ -1,13 +1,8 @@
 package main
 
 import (
-	"bytes"
 	"fmt"
-	"go/format"
-	"log"
-	"os"
 	"strings"
-	"text/template"
 
 	"github.com/opencodeco/validgen/internal/common"
 	"golang.org/x/text/cases"
@@ -27,29 +22,36 @@ type CmpBenchTest struct {
 	ValidInput   string
 }
 
-func generateComparativePerformanceTests() {
-	generateComparativePerformanceTest("cmp_perf_no_pointer_tests.tpl", "generated_cmp_perf_no_pointer_test.go", false)
-	generateComparativePerformanceTest("cmp_perf_pointer_tests.tpl", "generated_cmp_perf_pointer_test.go", true)
+func generateComparativePerformanceTests() error {
+	if err := generateComparativePerformanceTest("cmp_perf_no_pointer_tests.tpl", "generated_cmp_perf_no_pointer_test.go", false); err != nil {
+		return err
+	}
+
+	if err := generateComparativePerformanceTest("cmp_perf_pointer_tests.tpl", "generated_cmp_perf_pointer_test.go", true); err != nil {
+		return err
+	}
+
+	return nil
 }
 
-func generateComparativePerformanceTest(tpl, dest string, pointer bool) {
-	log.Printf("Generating comparative performance tests file: tpl[%s] dest[%s] pointer[%v]\n", tpl, dest, pointer)
+func generateComparativePerformanceTest(tplFile, outputFile string, pointer bool) error {
+	fmt.Printf("Generating comparative performance tests file: tplFile[%s] outputFile[%s] pointer[%v]\n", tplFile, outputFile, pointer)
 
 	benchTests := CmpBenchTests{}
 
 	for _, typeVal := range typesValidation {
 		if typeVal.validatorTag == "" {
-			log.Printf("Skipping tag %s: go-validator tag not defined\n", typeVal.tag)
+			fmt.Printf("Skipping tag %s: go-validator tag not defined\n", typeVal.tag)
 			continue
 		}
 
 		for _, testCase := range typeVal.testCases {
 			if testCase.excludeIf&cmpBenchTests != 0 {
-				log.Printf("Skipping test: tag %s type %s\n", typeVal.tag, testCase.typeClass)
+				fmt.Printf("Skipping test: tag %s type %s\n", typeVal.tag, testCase.typeClass)
 				continue
 			}
 			if testCase.excludeIf&noPointer != 0 && !pointer {
-				log.Printf("Skipping no pointer: tag %s type %s\n", typeVal.tag, testCase.typeClass)
+				fmt.Printf("Skipping no pointer: tag %s type %s\n", typeVal.tag, testCase.typeClass)
 				continue
 			}
 
@@ -86,39 +88,13 @@ func generateComparativePerformanceTest(tpl, dest string, pointer bool) {
 		}
 	}
 
-	log.Printf("%d test cases were generated\n", len(benchTests.Tests))
-
-	if err := benchTests.GenerateFile(tpl, dest); err != nil {
-		log.Fatalf("error generating comparative performance tests file %s", err)
-	}
-
-	log.Println("Generating done")
-}
+	fmt.Printf("%d test cases were generated\n", len(benchTests.Tests))
 
-func (cbt *CmpBenchTests) GenerateFile(tplFile, output string) error {
-	tpl, err := os.ReadFile(tplFile)
-	if err != nil {
-		return fmt.Errorf("error reading %s: %s", tplFile, err)
+	if err := ExecTemplate("BenchTest", tplFile, outputFile, benchTests); err != nil {
+		return fmt.Errorf("error generating comparative performance tests file %s", err)
 	}
 
-	tmpl, err := template.New("BenchTest").Parse(string(tpl))
-	if err != nil {
-		return fmt.Errorf("error parsing template %s: %s", tplFile, err)
-	}
-
-	code := new(bytes.Buffer)
-	if err := tmpl.Execute(code, cbt); err != nil {
-		return err
-	}
-
-	formattedCode, err := format.Source(code.Bytes())
-	if err != nil {
-		return err
-	}
-
-	if err := os.WriteFile(output, formattedCode, 0644); err != nil {
-		return err
-	}
+	fmt.Printf("Generating %s done\n", outputFile)
 
 	return nil
 }

testgen/generate_function_code_tests.go

@@ -1,12 +1,7 @@
 package main
 
 import (
-	"bytes"
 	"fmt"
-	"go/format"
-	"log"
-	"os"
-	"text/template"
 
 	"github.com/opencodeco/validgen/internal/analyzer"
 	"github.com/opencodeco/validgen/internal/codegenerator"
@@ -34,13 +29,20 @@ type FunctionCodeTestField struct {
 	Tag  string
 }
 
-func generateFunctionCodeUnitTests() {
-	generateFunctionCodeTestsFile("function_code_test.tpl", "generated_function_code_no_pointer_test.go", false)
-	generateFunctionCodeTestsFile("function_code_test.tpl", "generated_function_code_pointer_test.go", true)
+func generateFunctionCodeUnitTests() error {
+	if err := generateFunctionCodeUnitTest("function_code_test.tpl", "generated_function_code_no_pointer_test.go", false); err != nil {
+		return err
+	}
+
+	if err := generateFunctionCodeUnitTest("function_code_test.tpl", "generated_function_code_pointer_test.go", true); err != nil {
+		return err
+	}
+
+	return nil
 }
 
-func generateFunctionCodeTestsFile(tpl, dest string, pointer bool) {
-	log.Printf("Generating function code test file: tpl[%s] dest[%s] pointer[%v]\n", tpl, dest, pointer)
+func generateFunctionCodeUnitTest(tplFile, outputFile string, pointer bool) error {
+	fmt.Printf("Generating function code test file: tplFile[%s] outputFile[%s] pointer[%v]\n", tplFile, outputFile, pointer)
 
 	funcName := "TestBuildFunctionCode"
 	if pointer {
@@ -66,7 +68,7 @@ func generateFunctionCodeTestsFile(tpl, dest string, pointer bool) {
 
 		for _, toGenerate := range typeValidation.testCases {
 			if toGenerate.excludeIf&noPointer != 0 && !pointer {
-				log.Printf("Skipping no pointer: tag %s type %s\n", typeValidation.tag, toGenerate.typeClass)
+				fmt.Printf("Skipping no pointer: tag %s type %s\n", typeValidation.tag, toGenerate.typeClass)
 				continue
 			}
 
@@ -84,7 +86,7 @@ func generateFunctionCodeTestsFile(tpl, dest string, pointer bool) {
 				fieldName := "Field" + cases.Title(language.Und).String(typeValidation.tag) + fieldType.ToStringName()
 				parsedValidation, err := analyzer.ParserValidation(validation)
 				if err != nil {
-					log.Fatalf("failed to parse validation %q: %v", validation, err)
+					return fmt.Errorf("failed to parse validation %q: %v", validation, err)
 				}
 
 				newTest.Fields = append(newTest.Fields, FunctionCodeTestField{
@@ -110,45 +112,19 @@ func generateFunctionCodeTestsFile(tpl, dest string, pointer bool) {
 
 		expectedCode, err := gv.BuildFuncValidatorCode()
 		if err != nil {
-			log.Fatalf("failed to build function validator code for struct %q: %v", newTest.StructName, err)
+			return fmt.Errorf("failed to build function validator code for struct %q: %v", newTest.StructName, err)
 		}
 
 		newTest.ExpectedCode = expectedCode
 
 		testCases.Tests = append(testCases.Tests, newTest)
 	}
 
-	if err := testCases.GenerateFile(tpl, dest); err != nil {
-		log.Fatalf("error generating function code tests file %s", err)
-	}
-
-	log.Printf("Generating %s done\n", dest)
-}
-
-func (tc *FunctionCodeTestCases) GenerateFile(tplFile, output string) error {
-	tpl, err := os.ReadFile(tplFile)
-	if err != nil {
-		return fmt.Errorf("error reading %s: %s", tplFile, err)
-	}
-
-	tmpl, err := template.New("ValidationCodeTests").Parse(string(tpl))
-	if err != nil {
-		return err
-	}
-
-	code := new(bytes.Buffer)
-	if err := tmpl.Execute(code, tc); err != nil {
-		return err
+	if err := ExecTemplate("FunctionCodeTests", tplFile, outputFile, testCases); err != nil {
+		return fmt.Errorf("generating function code tests file %s", err)
 	}
 
-	formattedCode, err := format.Source(code.Bytes())
-	if err != nil {
-		return err
-	}
-
-	if err := os.WriteFile(output, formattedCode, 0644); err != nil {
-		return err
-	}
+	fmt.Printf("Generating %s done\n", outputFile)
 
 	return nil
 }

testgen/generate_tests.go

@@ -2,15 +2,31 @@ package main
 
 import (
 	"fmt"
+	"os"
 )
 
 func main() {
 	fmt.Println("Generating tests files")
 
-	generateValidationTypesEndToEndTests()
-	generateValidationCodeUnitTests()
-	generateFunctionCodeUnitTests()
-	generateComparativePerformanceTests()
+	if err := generateValidationTypesEndToEndTests(); err != nil {
+		fmt.Printf("error generating validation types end-to-end tests: %s\n", err)
+		os.Exit(1)
+	}
+
+	if err := generateValidationCodeUnitTests(); err != nil {
+		fmt.Printf("error generating validation code unit tests: %s\n", err)
+		os.Exit(1)
+	}
+
+	if err := generateFunctionCodeUnitTests(); err != nil {
+		fmt.Printf("error generating function code unit tests: %s\n", err)
+		os.Exit(1)
+	}
+
+	if err := generateComparativePerformanceTests(); err != nil {
+		fmt.Printf("error generating comparative performance tests: %s\n", err)
+		os.Exit(1)
+	}
 
 	fmt.Println("Generating done")
 }

testgen/generate_validation_code_tests.go

@@ -1,12 +1,7 @@
 package main
 
 import (
-	"bytes"
 	"fmt"
-	"go/format"
-	"log"
-	"os"
-	"text/template"
 
 	"github.com/opencodeco/validgen/internal/analyzer"
 	"github.com/opencodeco/validgen/internal/codegenerator"
@@ -28,13 +23,20 @@ type ValidationCodeTestCase struct {
 	ExpectedCode string
 }
 
-func generateValidationCodeUnitTests() {
-	generateValidationCodeTestsFile("build_validation_code_test.tpl", "generated_validation_code_no_pointer_test.go", false)
-	generateValidationCodeTestsFile("build_validation_code_test.tpl", "generated_validation_code_pointer_test.go", true)
+func generateValidationCodeUnitTests() error {
+	if err := generateValidationCodeUnitTest("build_validation_code_test.tpl", "generated_validation_code_no_pointer_test.go", false); err != nil {
+		return err
+	}
+
+	if err := generateValidationCodeUnitTest("build_validation_code_test.tpl", "generated_validation_code_pointer_test.go", true); err != nil {
+		return err
+	}
+
+	return nil
 }
 
-func generateValidationCodeTestsFile(tpl, dest string, pointer bool) {
-	log.Printf("Generating validation code test file: tpl[%s] dest[%s] pointer[%v]\n", tpl, dest, pointer)
+func generateValidationCodeUnitTest(tplFile, outputFile string, pointer bool) error {
+	fmt.Printf("Generating validation code test file: tplFile[%s] outputFile[%s] pointer[%v]\n", tplFile, outputFile, pointer)
 
 	funcName := "TestBuildValidationCode"
 	if pointer {
@@ -48,7 +50,7 @@ func generateValidationCodeTestsFile(tpl, dest string, pointer bool) {
 	for _, typeValidation := range typesValidation {
 		for _, toGenerate := range typeValidation.testCases {
 			if toGenerate.excludeIf&noPointer != 0 && !pointer {
-				log.Printf("Skipping no pointer: tag %s type %s\n", typeValidation.tag, toGenerate.typeClass)
+				fmt.Printf("Skipping no pointer: tag %s type %s\n", typeValidation.tag, toGenerate.typeClass)
 				continue
 			}
 
@@ -68,11 +70,11 @@ func generateValidationCodeTestsFile(tpl, dest string, pointer bool) {
 				gv := codegenerator.GenValidations{}
 				parsedValidation, err := analyzer.ParserValidation(validation)
 				if err != nil {
-					log.Fatalf("failed to parse validation %q: %v", validation, err)
+					return fmt.Errorf("failed to parse validation %q: %v", validation, err)
 				}
 				expectedValidationCode, err := gv.BuildValidationCode(fieldName, fieldType, []*analyzer.Validation{parsedValidation})
 				if err != nil {
-					log.Fatalf("failed to build validation code for %q: %v", fieldName, err)
+					return fmt.Errorf("failed to build validation code for %q: %v", fieldName, err)
 				}
 
 				testCases.Tests = append(testCases.Tests, ValidationCodeTestCase{
@@ -86,37 +88,11 @@ func generateValidationCodeTestsFile(tpl, dest string, pointer bool) {
 		}
 	}
 
-	if err := testCases.GenerateFile(tpl, dest); err != nil {
-		log.Fatalf("error generation validation code tests file %s", err)
-	}
-
-	log.Printf("Generating %s done\n", dest)
-}
-
-func (at *ValidationCodeTestCases) GenerateFile(tplFile, output string) error {
-	tpl, err := os.ReadFile(tplFile)
-	if err != nil {
-		return fmt.Errorf("error reading %s: %s", tplFile, err)
-	}
-
-	tmpl, err := template.New("ValidationCodeTests").Parse(string(tpl))
-	if err != nil {
-		return err
-	}
-
-	code := new(bytes.Buffer)
-	if err := tmpl.Execute(code, at); err != nil {
-		return err
+	if err := ExecTemplate("ValidationCodeTests", tplFile, outputFile, testCases); err != nil {
+		return fmt.Errorf("error generating validation code tests file %s", err)
 	}
 
-	formattedCode, err := format.Source(code.Bytes())
-	if err != nil {
-		return err
-	}
-
-	if err := os.WriteFile(output, formattedCode, 0644); err != nil {
-		return err
-	}
+	fmt.Printf("Generating %s done\n", outputFile)
 
 	return nil
 }