Q. `--with-calls` option to generate functions to track and inspect the calls made to a mock

[dnwe]

Currently moq will always generate the call tracking and inspection functionality as part of its template. Personally I prefer to have moq just generate the func callers. Is this a usecase that you'd like to support with a PR to add a cmdline flag opt-out/opt-in, or would you prefer not to have the complexity?

Something along the lines of this:

diff --git a/internal/template/template.go b/internal/template/template.go
index 9e2672c..04eb642 100644
--- a/internal/template/template.go
+++ b/internal/template/template.go
@@ -93,6 +93,7 @@ type {{.MockName}}
    // {{.Name}}Func mocks the {{.Name}} method.
    {{.Name}}Func func({{.ArgList}}) {{.ReturnArgTypeList}}
 {{end}}
+{{- if $.WithCalls -}}
    // calls tracks calls to the methods.
    calls struct {
 {{- range .Methods}}
@@ -105,9 +106,12 @@ type {{.MockName}}
        }
 {{- end}}
    }
+{{end}}
+{{- if $.WithCalls -}}
 {{- range .Methods}}
    lock{{.Name}} {{$.Imports | SyncPkgQualifier}}.RWMutex
 {{- end}}
+{{end}}
 }
 {{range .Methods}}
 // {{.Name}} calls {{.Name}}Func.
@@ -123,6 +127,7 @@ func (mock *{{$mock.MockName}}
        panic("{{$mock.MockName}}.{{.Name}}Func: method is nil but {{$mock.InterfaceName}}.{{.Name}} was just called")
    }
 {{- end}}
+{{- if $.WithCalls -}}
    callInfo := struct {
        {{- range .Params}}
        {{.Name | Exported}} {{.TypeString}}
@@ -135,6 +140,7 @@ func (mock *{{$mock.MockName}}
    mock.lock{{.Name}}.Lock()
    mock.calls.{{.Name}} = append(mock.calls.{{.Name}}, callInfo)
    mock.lock{{.Name}}.Unlock()
+{{- end}}
 {{- if .Returns}}
    {{- if $.StubImpl}}
    if mock.{{.Name}}Func == nil {
@@ -156,7 +162,7 @@ func (mock *{{$mock.MockName}}
    mock.{{.Name}}Func({{.ArgCallList}})
 {{- end}}
 }
-
+{{- if $.WithCalls -}}
 // {{.Name}}Calls gets all the calls that were made to {{.Name}}.
 // Check the length with:
 //
@@ -200,6 +206,7 @@ func (mock *{{$mock.MockName}}) ResetCalls() {
    mock.lock{{.Name}}.Unlock()
    {{end -}}
 }
+{{- end}}
 {{end -}}
 {{end -}}
 `
diff --git a/internal/template/template_data.go b/internal/template/template_data.go
index 2a3caeb..0ac6039 100644
--- a/internal/template/template_data.go
+++ b/internal/template/template_data.go
@@ -16,6 +16,7 @@ type Data struct {
    Mocks           []MockData
    StubImpl        bool
    SkipEnsure      bool
+   WithCalls       bool
    WithResets      bool
 }

diff --git a/main.go b/main.go
index 89adb3d..0fffdeb 100644
--- a/main.go
+++ b/main.go
@@ -22,6 +22,7 @@ type userFlags struct {
    formatter  string
    stubImpl   bool
    skipEnsure bool
+   withCalls  bool
    withResets bool
    remove     bool
    args       []string
@@ -38,6 +39,8 @@ func main() {
    flag.BoolVar(&flags.skipEnsure, "skip-ensure", false,
        "suppress mock implementation check, avoid import cycle if mocks generated outside of the tested package")
    flag.BoolVar(&flags.remove, "rm", false, "first remove output file, if it exists")
+   flag.BoolVar(&flags.withCalls, "with-calls", true,
+       "generate functions to track and inspect the calls made to a mock")
    flag.BoolVar(&flags.withResets, "with-resets", false,
        "generate functions to facilitate resetting calls made to a mock")

@@ -89,6 +92,7 @@ func run(flags userFlags) error {
        Formatter:  flags.formatter,
        StubImpl:   flags.stubImpl,
        SkipEnsure: flags.skipEnsure,
+       WithCalls:  flags.withCalls,
        WithResets: flags.withResets,
    })
    if err != nil {
diff --git a/pkg/moq/moq.go b/pkg/moq/moq.go
index e8a2975..4f5191b 100644
--- a/pkg/moq/moq.go
+++ b/pkg/moq/moq.go
@@ -28,6 +28,7 @@ type Config struct {
    Formatter  string
    StubImpl   bool
    SkipEnsure bool
+   WithCalls  bool
    WithResets bool
 }

@@ -82,10 +83,11 @@ func (m *Mocker) Mock(w io.Writer, namePairs ...string) error {
        Mocks:      mocks,
        StubImpl:   m.cfg.StubImpl,
        SkipEnsure: m.cfg.SkipEnsure,
+       WithCalls:  m.cfg.WithCalls,
        WithResets: m.cfg.WithResets,
    }

-   if data.MocksSomeMethod() {
+   if data.MocksSomeMethod() && m.cfg.WithCalls {
        m.registry.AddImport(types.NewPackage("sync", "sync"))
    }
    if m.registry.SrcPkgName() != m.mockPkgName() {

[breml]

I like this proposal. For me it is the same. In most test cases I only use the func callers. Sometimes I check for the number of calls for a particular method (len of calls). I can not remember a case, where I actually inspected the actual calls struct it self.

In regards to backwards compatibility / non breaking changes, I feel the flag would need to be "opt-out", e.g. something like --omit-calls.

[endigma]

I think this could be better as a runtime config option similar to adding hooks? We have some cases where we want/don't want counting for the same mock in different contexts.