tests: improve coverage

Author: abice

generator/generator_test.go

@@ -443,3 +443,152 @@ func TestStringWithSingleBacktickValue(t *testing.T) {
 		fmt.Println(string(output))
 	}
 }
+
+// TestNewGeneratorWithConfig tests the NewGeneratorWithConfig constructor
+func TestNewGeneratorWithConfig(t *testing.T) {
+	config := GeneratorConfig{
+		NoPrefix:        true,
+		LowercaseLookup: true,
+		Marshal:         true,
+		SQL:             true,
+		SQLInt:          true,
+		JSONPkg:         "custom/json",
+		Prefix:          "TestPrefix",
+		BuildTags:       []string{"tag1", "tag2"},
+		NoComments:      true,
+		Values:          true,
+	}
+
+	g := NewGeneratorWithConfig(config)
+
+	assert.NotNil(t, g)
+	assert.Equal(t, config.NoPrefix, g.NoPrefix)
+	assert.Equal(t, config.LowercaseLookup, g.LowercaseLookup)
+	assert.Equal(t, config.Marshal, g.Marshal)
+	assert.Equal(t, config.SQL, g.SQL)
+	assert.Equal(t, config.SQLInt, g.SQLInt)
+	assert.Equal(t, config.JSONPkg, g.JSONPkg)
+	assert.Equal(t, config.Prefix, g.Prefix)
+	assert.Equal(t, config.BuildTags, g.BuildTags)
+	assert.Equal(t, config.NoComments, g.NoComments)
+	assert.Equal(t, config.Values, g.Values)
+
+	// Test default values
+	assert.Equal(t, "-", g.Version)
+	assert.Equal(t, "-", g.Revision)
+	assert.Equal(t, "-", g.BuildDate)
+	assert.Equal(t, "-", g.BuiltBy)
+	assert.NotNil(t, g.knownTemplates)
+	assert.NotNil(t, g.t)
+	assert.NotNil(t, g.fileSet)
+	assert.NotNil(t, g.userTemplateNames)
+}
+
+// TestNewGeneratorConfig tests the NewGeneratorConfig constructor
+func TestNewGeneratorConfig(t *testing.T) {
+	config := NewGeneratorConfig()
+
+	assert.NotNil(t, config)
+	assert.False(t, config.NoPrefix)
+	assert.NotNil(t, config.ReplacementNames)
+	assert.Equal(t, "encoding/json", config.JSONPkg)
+	assert.Empty(t, config.ReplacementNames)
+}
+
+// TestWithSQLInt tests the WithSQLInt option
+func TestWithSQLInt(t *testing.T) {
+	config := &GeneratorConfig{}
+	option := WithSQLInt()
+
+	assert.False(t, config.SQLInt)
+	option(config)
+	assert.True(t, config.SQLInt)
+}
+
+// TestWithValues tests the WithValues option
+func TestWithValues(t *testing.T) {
+	config := &GeneratorConfig{}
+	option := WithValues()
+
+	assert.False(t, config.Values)
+	option(config)
+	assert.True(t, config.Values)
+}
+
+// TestWithJsonPkg tests the WithJsonPkg option
+func TestWithJsonPkg(t *testing.T) {
+	config := &GeneratorConfig{}
+	testPkg := "custom/json/package"
+	option := WithJsonPkg(testPkg)
+
+	assert.Empty(t, config.JSONPkg)
+	option(config)
+	assert.Equal(t, testPkg, config.JSONPkg)
+}
+
+// TestWithNoComments tests the WithNoComments option
+func TestWithNoComments(t *testing.T) {
+	config := &GeneratorConfig{}
+	option := WithNoComments()
+
+	assert.False(t, config.NoComments)
+	option(config)
+	assert.True(t, config.NoComments)
+}
+
+// TestWithBuildTags tests the WithBuildTags option
+func TestWithBuildTags(t *testing.T) {
+	config := &GeneratorConfig{}
+	testTags := []string{"tag1", "tag2", "tag3"}
+	option := WithBuildTags(testTags...)
+
+	assert.Empty(t, config.BuildTags)
+	option(config)
+	assert.Equal(t, testTags, config.BuildTags)
+
+	// Test appending more tags
+	moreTags := []string{"tag4", "tag5"}
+	option2 := WithBuildTags(moreTags...)
+	option2(config)
+	expectedTags := append(testTags, moreTags...)
+	assert.Equal(t, expectedTags, config.BuildTags)
+}
+
+// TestAllOptionsIntegration tests using multiple options together
+func TestAllOptionsIntegration(t *testing.T) {
+	g := NewGenerator(
+		WithSQLInt(),
+		WithValues(),
+		WithJsonPkg("custom/json"),
+		WithNoComments(),
+		WithBuildTags("integration", "test"),
+	)
+
+	assert.True(t, g.SQLInt)
+	assert.True(t, g.Values)
+	assert.Equal(t, "custom/json", g.JSONPkg)
+	assert.True(t, g.NoComments)
+	assert.Equal(t, []string{"integration", "test"}, g.BuildTags)
+}
+
+// TestGeneratorConfigWithTemplates tests NewGeneratorWithConfig with templates
+func TestGeneratorConfigWithTemplates(t *testing.T) {
+	config := GeneratorConfig{
+		// Use empty template file names to avoid file not found errors
+		TemplateFileNames: []string{},
+	}
+
+	g := NewGeneratorWithConfig(config)
+	assert.NotNil(t, g)
+	assert.Equal(t, config.TemplateFileNames, g.TemplateFileNames)
+
+	// Test with non-empty but valid scenario - no actual templates needed for coverage
+	config2 := GeneratorConfig{
+		NoPrefix: true,
+		Values:   true,
+	}
+	g2 := NewGeneratorWithConfig(config2)
+	assert.NotNil(t, g2)
+	assert.True(t, g2.NoPrefix)
+	assert.True(t, g2.Values)
+}