v3: Fix constructor name not respecting exported-ness

Fixes #993

Author: LandonTClipp

.mockery_testify.yml

@@ -3,13 +3,14 @@ force-file-write: true
 formatter: "goimports"
 all: True
 dir: "{{.InterfaceDirRelative}}"
-structname: "Mock{{.InterfaceName}}"
+structname: "{{.Mock}}{{.InterfaceName}}"
 pkgname: "{{.SrcPackageName}}"
 filename: "mocks_testify_{{.SrcPackageName}}_test.go"
 template-data:
   boilerplate-file: "./.boilerplate.txt"
 packages:
   github.com/vektra/mockery/v3/internal/cmd:
+  github.com/vektra/mockery/v3/internal/fixtures/unexported:
   github.com/vektra/mockery/v3/internal/fixtures/buildtag/comment:
   github.com/vektra/mockery/v3/internal/fixtures/example_project/replace_type:
     config:

config/config.go

@@ -92,7 +92,7 @@ func NewDefaultKoanf(ctx context.Context) (*koanf.Koanf, error) {
 		ForceFileWrite:              addr(false),
 		Formatter:                   addr("goimports"),
 		LogLevel:                    addr("info"),
-		StructName:                  addr("Mock{{.InterfaceName}}"),
+		StructName:                  addr("{{.Mock}}{{.InterfaceName}}"),
 		PkgName:                     addr("{{.SrcPackageName}}"),
 		Recursive:                   addr(false),
 		RequireTemplateSchemaExists: addr(true),

docs/configuration.md

@@ -19,7 +19,7 @@ filename: mocks_test.go
 force-file-write: false
 formatter: goimports
 log-level: info
-structname: Mock{{.InterfaceName}}
+structname: {{.Mock}}{{.InterfaceName}}
 pkgname: '{{.SrcPackageName}}'
 recursive: false
 template: testify
@@ -83,7 +83,7 @@ import (
           dir: "{{.InterfaceDir}}"
           filename: "mocks_test.go"
           outpkg: "{{.PackageName}}_test"
-          structname: "Mock{{.InterfaceName}}"
+          structname: "{{.Mock}}{{.InterfaceName}}"
         interfaces:
           Foo:
           Bar:
@@ -127,7 +127,7 @@ Parameter Descriptions
 | `formatter`                                            | :fontawesome-solid-x:     | `#!yaml "goimports"`                  | The formatter to use on the rendered template. Choices are: `gofmt`, `goimports`, `noop`.                                                                                                                                                            |
 | `include-interface-regex`                              | :fontawesome-solid-x:     | `#!yaml ""`                           | When set, only interface names that match the expression will be generated. This setting is ignored if `all: True` is specified in the configuration. To further refine the interfaces generated, use `exclude-interface-regex`.                               |
 | `log-level`                                            | :fontawesome-solid-x:     | `#!yaml "info"`                       | Set the level of the logger                                                                                                                                                                                                                          |
-| `structname`                                             | :fontawesome-solid-check: | `#!yaml "Mock{{.InterfaceName}}"`   | The name of the generated interface implementation.                                                                                                                                                                                                                      |
+| `structname`                                           | :fontawesome-solid-check: | `#!yaml "{{.Mock}}{{.InterfaceName}}"` | The name of the generated interface implementation.                                                                                                                                                                                                                      |
 | `packages`                                             | :fontawesome-solid-x:     | `#!yaml null`                         | A dictionary containing configuration describing the packages and interfaces to generate mocks for.                                                                                                                                                  |
 | `pkgname`                                              | :fontawesome-solid-check: | `#!yaml "{{.SrcPackageName}}"`        | The `#!go package name` given to the generated mock files.                                                                                                                                                                                           |
 | `recursive`                                            | :fontawesome-solid-x:     | `#!yaml false`                        | When set to `true` on a particular package, mockery will recursively search for all sub-packages and inject those packages into the config map.                                                                                                      |

internal/cmd/init_test.go

@@ -42,7 +42,7 @@ func Test_initRun(t *testing.T) {
 			args: args{
 				args: []string{"github.com/org/repo"},
 				params: func(t *testing.T, configPath string) argGetter {
-					m := NewMockargGetter(t)
+					m := newmockargGetter(t)
 					m.EXPECT().GetString("config").Return(configPath, nil)
 					return m
 				},

internal/cmd/mocks_testify_cmd_test.go

@@ -28,8 +28,8 @@ func (s *testStruct) ExecDoB0v2() interfaceB0 {
 
 func Test(t *testing.T) {
 	t.Run("ExecDoB", func(t *testing.T) {
-		mockInterfaceB := NewMockinterfaceB(t)
-		mockInterfaceA := NewMockinterfaceA(t)
+		mockInterfaceB := newmockinterfaceB(t)
+		mockInterfaceA := newmockinterfaceA(t)
 		mockInterfaceA.On("DoB", mock.Anything).Return(mockInterfaceB)
 
 		s := testStruct{
@@ -39,8 +39,8 @@ func Test(t *testing.T) {
 		assert.Equal(t, mockInterfaceB, res)
 	})
 	t.Run("ExecDoB0", func(t *testing.T) {
-		mockInterfaceB0 := NewMockinterfaceB0(t)
-		mockInterfaceA := NewMockinterfaceA(t)
+		mockInterfaceB0 := newmockinterfaceB0(t)
+		mockInterfaceA := newmockinterfaceA(t)
 		mockInterfaceA.On("DoB0", mock.Anything).Return(mockInterfaceB0)
 
 		s := testStruct{
@@ -50,8 +50,8 @@ func Test(t *testing.T) {
 		assert.Equal(t, mockInterfaceB0, res)
 	})
 	t.Run("ExecDoB0v2", func(t *testing.T) {
-		mockInterfaceB0 := NewMockinterfaceB0(t)
-		mockInterfaceA := NewMockinterfaceA(t)
+		mockInterfaceB0 := newmockinterfaceB0(t)
+		mockInterfaceA := newmockinterfaceA(t)
 		mockInterfaceA.On("DoB0v2", mock.Anything).Return(mockInterfaceB0)
 
 		s := testStruct{