test: add TestFixAcronyms with comprehensive test cases

Add unit tests for FixAcronyms function covering:
- Basic acronym replacements (Id, Url, Api, Sql, Json)
- Words that should NOT be corrupted (Identifier, Curling, XmlParser)
- Multiple acronyms in one string
- Already-correct acronyms staying unchanged
- Empty strings

Also export FixAcronyms to make it testable from external test package.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: kalbasit

generator/helpers.go

@@ -53,10 +53,10 @@ func extractBulkFor(comment string) string {
 
 func toSingular(s string) string { return inflection.Singular(s) }
 
-// fixAcronyms corrects common Go acronym casing issues using word-boundary-aware
+// FixAcronyms corrects common Go acronym casing issues using word-boundary-aware
 // regex replacements to avoid corrupting words that contain acronyms as substrings.
 // For example: Id -> ID, Api -> API, Sql -> SQL, Url -> URL.
-func fixAcronyms(content []byte) []byte {
+func FixAcronyms(content []byte) []byte {
 	// Common Go acronyms that should be all caps, with their correct form.
 	acronymReplacements := []struct {
 		pattern     string
@@ -91,13 +91,20 @@ func fixAcronyms(content []byte) []byte {
 			continue
 		}
 
-		// Match acronym when preceded by a lowercase letter and followed by
-		// a capital letter or end of string. This prevents replacing "Id" in
-		// "Identifier" (where it should stay as "Id") but correctly handles
-		// "userId" -> "userID" and "myId" -> "myID".
-		regex := regexp.MustCompile(`([a-z])(` + r.pattern + `)([A-Z]|$)`)
-		repl := "$1" + r.replacement + "$3"
-		result = regex.ReplaceAllString(result, repl)
+		// Use three patterns to handle acronym in different positions:
+		// 1. `([a-z])(Acronym)([A-Z])` - acronym in middle of camelCase, e.g., "JsonM" in "userJsonM"
+		// 2. `([a-z])(Acronym)$` - acronym at end of identifier, e.g., "Id" in "userId"
+		// 3. `([a-z])(Acronym)([^A-Za-z])` - acronym followed by non-letter (space, punctuation, etc.)
+		regexMid := regexp.MustCompile(`([a-z])(` + r.pattern + `)([A-Z])`)
+		regexEnd := regexp.MustCompile(`([a-z])(` + r.pattern + `)$`)
+		regexNonLetter := regexp.MustCompile(`([a-z])(` + r.pattern + `)([^A-Za-z])`)
+
+		// For middle case: preserve the following uppercase letter via ${3}
+		result = regexMid.ReplaceAllString(result, "${1}"+r.replacement+"${3}")
+		// For non-letter case: preserve the following character via ${3}
+		result = regexNonLetter.ReplaceAllString(result, "${1}"+r.replacement+"${3}")
+		// For end case: no ${3} since there's no following letter
+		result = regexEnd.ReplaceAllString(result, "${1}"+r.replacement)
 	}
 
 	return []byte(result)
@@ -122,7 +129,7 @@ func writeFile(dir, filename string, content []byte) {
 	}
 
 	// 3. Fix acronym casing (Api -> API, Id -> ID, etc.)
-	fixed := fixAcronyms(formatted)
+	fixed := FixAcronyms(formatted)
 
 	if err := os.WriteFile(filepath.Join(dir, filename), fixed, 0o644); err != nil { //nolint:gosec
 		log.Fatal(err)

generator/helpers_test.go

@@ -0,0 +1,124 @@
+package generator_test
+
+import (
+	"testing"
+
+	"github.com/kalbasit/sqlc-multi-db/generator"
+)
+
+func TestFixAcronyms(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name     string
+		input    string
+		expected string
+	}{
+		{
+			name:     "Simple Id to ID",
+			input:    "userId",
+			expected: "userID",
+		},
+		{
+			name:     "Url to URL",
+			input:    "profileUrl",
+			expected: "profileURL",
+		},
+		{
+			name:     "Api to API",
+			input:    "fetchApiData",
+			expected: "fetchAPIData",
+		},
+		{
+			name:     "Sql to SQL",
+			input:    "execSqlQuery",
+			expected: "execSQLQuery",
+		},
+		{
+			name:     "Json to JSON",
+			input:    "parseJsonBody",
+			expected: "parseJSONBody",
+		},
+		{
+			name:     "Identifier should not be corrupted",
+			input:    "Identifier",
+			expected: "Identifier",
+		},
+		{
+			name:     "Curling should not be corrupted to CURLing",
+			input:    "Curling",
+			expected: "Curling",
+		},
+		{
+			name:     "XmlParser should not be corrupted",
+			input:    "XmlParser",
+			expected: "XmlParser",
+		},
+		{
+			name:     "HtmlDocument should not be corrupted",
+			input:    "HtmlDocument",
+			expected: "HtmlDocument",
+		},
+		{
+			name:     "Multiple acronyms in one string",
+			input:    "userId and profileUrl",
+			expected: "userID and profileURL",
+		},
+		{
+			name:     "Id at end of string",
+			input:    "GetUserId",
+			expected: "GetUserID",
+		},
+		{
+			name:     "Already correct ID should stay",
+			input:    "GetUserID",
+			expected: "GetUserID",
+		},
+		{
+			name:     "Already correct URL should stay",
+			input:    "profileURL",
+			expected: "profileURL",
+		},
+		{
+			name:     "Tcp connection",
+			input:    "openTcpConnection",
+			expected: "openTCPConnection",
+		},
+		{
+			name:     "Jwt token",
+			input:    "validateJwtToken",
+			expected: "validateJWTToken",
+		},
+		{
+			name:     "Ec2 instance",
+			input:    "launchEc2Instance",
+			expected: "launchEC2Instance",
+		},
+		{
+			name:     "Json web token Jwt",
+			input:    "parseJsonWebToken",
+			expected: "parseJSONWebToken",
+		},
+		{
+			name:     "Uuid should not change (not in our list)",
+			input:    "userUuid",
+			expected: "userUuid",
+		},
+		{
+			name:     "Empty string",
+			input:    "",
+			expected: "",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			result := generator.FixAcronyms([]byte(tt.input))
+			if string(result) != tt.expected {
+				t.Errorf("FixAcronyms(%q) = %q, want %q", tt.input, string(result), tt.expected)
+			}
+		})
+	}
+}