diff --git a/testgen/execute_template.go b/testgen/execute_template.go new file mode 100644 index 0000000..42716b1 --- /dev/null +++ b/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 +} diff --git a/testgen/generate_cmp_perf_tests.go b/testgen/generate_cmp_perf_tests.go index f02b772..ee64ea5 100644 --- a/testgen/generate_cmp_perf_tests.go +++ b/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 } diff --git a/testgen/generate_function_code_tests.go b/testgen/generate_function_code_tests.go index dfb6df5..cf6b584 100644 --- a/testgen/generate_function_code_tests.go +++ b/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,7 +112,7 @@ 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 @@ -118,37 +120,11 @@ func generateFunctionCodeTestsFile(tpl, dest string, pointer bool) { 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 } diff --git a/testgen/generate_tests.go b/testgen/generate_tests.go index 09d9c0f..de0144f 100644 --- a/testgen/generate_tests.go +++ b/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") } diff --git a/testgen/generate_validation_code_tests.go b/testgen/generate_validation_code_tests.go index 0e176b0..5b02e4a 100644 --- a/testgen/generate_validation_code_tests.go +++ b/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 } diff --git a/testgen/generate_validation_types_tests.go b/testgen/generate_validation_types_tests.go index 1619d53..0b3ebd6 100644 --- a/testgen/generate_validation_types_tests.go +++ b/testgen/generate_validation_types_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" @@ -33,13 +28,20 @@ type TestCase struct { ErrorMessage string } -func generateValidationTypesEndToEndTests() { - generateValidationTypesTestsFile("no_pointer_tests.tpl", "generated_endtoend_no_pointer_tests.go", false) - generateValidationTypesTestsFile("pointer_tests.tpl", "generated_endtoend_pointer_tests.go", true) +func generateValidationTypesEndToEndTests() error { + if err := generateValidationTypesEndToEndTest("no_pointer_tests.tpl", "generated_endtoend_no_pointer_tests.go", false); err != nil { + return err + } + + if err := generateValidationTypesEndToEndTest("pointer_tests.tpl", "generated_endtoend_pointer_tests.go", true); err != nil { + return err + } + + return nil } -func generateValidationTypesTestsFile(tpl, dest string, pointer bool) { - log.Printf("Generating validation types test file: tpl[%s] dest[%s] pointer[%v]\n", tpl, dest, pointer) +func generateValidationTypesEndToEndTest(tplFile, outputFile string, pointer bool) error { + fmt.Printf("Generating validation types test file: tplFile[%s] outputFile[%s] pointer[%v]\n", tplFile, outputFile, pointer) allTestsToGenerate := AllTestCasesToGenerate{} @@ -53,7 +55,7 @@ func generateValidationTypesTestsFile(tpl, dest string, pointer bool) { }) for _, toGenerate := range testCase.testCases { if toGenerate.excludeIf&noPointer != 0 && !pointer { - log.Printf("Skipping no pointer: tag %s type %s\n", testCase.tag, toGenerate.typeClass) + fmt.Printf("Skipping no pointer: tag %s type %s\n", testCase.tag, toGenerate.typeClass) continue } @@ -89,37 +91,11 @@ func generateValidationTypesTestsFile(tpl, dest string, pointer bool) { } } - if err := allTestsToGenerate.GenerateFile(tpl, dest); err != nil { - log.Fatalf("error generation validation types file %s", err) - } - - log.Printf("Generating %s done\n", dest) -} - -func (tc *AllTestCasesToGenerate) 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("ValidationTypesTests").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("ValidationTypesTests", tplFile, outputFile, allTestsToGenerate); err != nil { + return fmt.Errorf("generating validation types 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 } diff --git a/tests/endtoend/generated_numeric_int_tests.go b/tests/endtoend/generated_numeric_int_tests.go index 61ecbed..81d62c7 100644 --- a/tests/endtoend/generated_numeric_int_tests.go +++ b/tests/endtoend/generated_numeric_int_tests.go @@ -17,7 +17,7 @@ func numericIntTypeTests() { numericUint16Tests() numericUint32Tests() numericUint64Tests() - + log.Println("numeric int tests ok") }