Add flag to cmg to use testify/assert in mocks

- Add a `-testify` flag which replaces the usage of `testing.T`'s
  `t.Helper()` and `t.Fail()` in mocks generated by `cmg` with
  `assert.Fail()`. When used, this gives the benefit of printing out a
  stack trace to identify why an unexpected call is happening and will
  be familiar to those already using testify/assert for tests.

Author: douglaswth

mock/cmd/cmg/main.go

@@ -12,10 +12,11 @@ import (
 
 func main() {
 	var (
-		gSet           = flag.NewFlagSet("global", flag.ExitOnError)
-		debug, help, h *bool
-		addGlobals     = func(set *flag.FlagSet) {
+		gSet                    = flag.NewFlagSet("global", flag.ExitOnError)
+		debug, testify, help, h *bool
+		addGlobals              = func(set *flag.FlagSet) {
 			debug = set.Bool("debug", false, "Print debug output")
+			testify = set.Bool("testify", false, "Use github.com/stretchr/testify for assertions")
 			help = set.Bool("help", false, "Print help information")
 			h = set.Bool("h", false, "Print help information")
 		}
@@ -67,7 +68,7 @@ func main() {
 		} else {
 			ctx = log.Context(ctx)
 		}
-		err := cluemockgen.Generate(ctx, args, "")
+		err := cluemockgen.Generate(ctx, args, "", *testify)
 		if err != nil {
 			os.Exit(1)
 		}

mock/cmd/cmg/pkg/generate.go

@@ -14,7 +14,9 @@ import (
 	"goa.design/clue/mock/cmd/cmg/pkg/parse"
 )
 
-func Generate(ctx context.Context, patterns []string, dir string) error {
+// Generate generates the mocks for the given patterns and directory.
+// If testify is true, it uses github.com/stretchr/testify for assertions.
+func Generate(ctx context.Context, patterns []string, dir string, testify bool) error {
 	ps, err := parse.LoadPackages(patterns, dir)
 	if err != nil {
 		log.Error(ctx, err)
@@ -24,7 +26,7 @@ func Generate(ctx context.Context, patterns []string, dir string) error {
 	var errs []error
 
 	for _, p := range ps {
-		err = generatePackage(ctx, p)
+		err = generatePackage(ctx, p, testify)
 		if err != nil {
 			errs = append(errs, err)
 		}
@@ -37,9 +39,11 @@ func Generate(ctx context.Context, patterns []string, dir string) error {
 	return nil
 }
 
-func generatePackage(ctx context.Context, p parse.Package) error {
+// generatePackage generates the mocks for the given package.
+// If testify is true, it uses github.com/stretchr/testify for assertions.
+func generatePackage(ctx context.Context, p parse.Package, testify bool) error {
 	ctx = log.With(ctx, log.KV{K: "pkg name", V: p.Name()})
-	log.Print(ctx, log.KV{K: "pkg path", V: p.PkgPath()})
+	log.Print(ctx, log.KV{K: "pkg path", V: p.PkgPath()}, log.KV{K: "testify", V: testify})
 
 	is, err := p.Interfaces()
 	if err != nil {
@@ -75,7 +79,7 @@ func generatePackage(ctx context.Context, p parse.Package) error {
 		}
 	}
 	for file, interfaces := range interfacesByFile {
-		err = generateFile(ctx, p, file, interfaces)
+		err = generateFile(ctx, p, file, interfaces, testify)
 		if err != nil {
 			return err
 		}
@@ -84,13 +88,15 @@ func generatePackage(ctx context.Context, p parse.Package) error {
 	return nil
 }
 
-func generateFile(ctx context.Context, p parse.Package, file string, interfaces []parse.Interface) error {
+// generateFile generates the mocks for the given file.
+// If testify is true, it uses github.com/stretchr/testify for assertions.
+func generateFile(ctx context.Context, p parse.Package, file string, interfaces []parse.Interface, testify bool) error {
 	ctx = log.With(ctx, log.KV{K: "file", V: file})
 	interfaceNames := make([]string, len(interfaces))
 	for j, i := range interfaces {
 		interfaceNames[j] = i.Name()
 	}
-	log.Print(ctx, log.KV{K: "interface names", V: interfaceNames})
+	log.Print(ctx, log.KV{K: "interface names", V: interfaceNames}, log.KV{K: "testify", V: testify})
 
 	dir, baseFile := filepath.Split(file)
 	mocksDir := filepath.Join(dir, "mocks")
@@ -118,7 +124,7 @@ func generateFile(ctx context.Context, p parse.Package, file string, interfaces
 		}
 	}()
 
-	mocks := generate.NewMocks("mock", p, interfaces, Version)
+	mocks := generate.NewMocks("mock", p, interfaces, Version, testify)
 	if err := mocks.Render(f); err != nil {
 		log.Error(ctx, err)
 		return err

mock/cmd/cmg/pkg/generate/_tests/testify/mocks/testify.go

@@ -0,0 +1,7 @@
+package testify
+
+type (
+	Testify interface {
+		Simple(a, b int) bool
+	}
+)

mock/cmd/cmg/pkg/generate/_tests/testify/testify.go

@@ -10,47 +10,72 @@ import (
 )
 
 type (
+	// Mocks is the interface for the mocks.
 	Mocks interface {
+		// PkgName returns the package name.
 		PkgName() string
+		// PkgImport returns the package import.
 		PkgImport() Import
+		// StdImports returns the standard imports.
 		StdImports() []Import
+		// ExtImports returns the external imports.
 		ExtImports() []Import
+		// IntImports returns the internal imports.
 		IntImports() []Import
+		// Interfaces returns the interfaces.
 		Interfaces() []Interface
+		// ToolVersion returns the tool version.
 		ToolVersion() string
+		// ToolCommandLine returns the tool command line.
 		ToolCommandLine() string
+		// Testify returns true if testify should be used.
+		Testify() bool
+		// Render renders the mocks to the given writer.
 		Render(w io.Writer) error
 	}
 
+	// ToolVersionFunc is the function type for the tool version.
 	ToolVersionFunc func() string
 
+	// mocks is the implementation of the Mocks interface.
 	mocks struct {
 		pkgName, pkgPath                   string
 		pkgImport                          Import
 		stdImports, extImports, intImports []Import
 		interfaces                         []Interface
 		toolVersionFunc                    ToolVersionFunc
+		testify                            bool
 	}
 )
 
 //go:embed mocks.go.tmpl
 var mocksStr string
 
 var (
+	// mocksTmpl is the template for the mocks.
 	mocksTmpl = template.Must(template.New("mocks").Parse(mocksStr))
 )
 
-func NewMocks(prefix string, p parse.Package, interfaces []parse.Interface, toolVersionFunc ToolVersionFunc) Mocks {
+// NewMocks creates a new Mocks instance.
+// If testify is true, it uses github.com/stretchr/testify for assertions.
+func NewMocks(prefix string, p parse.Package, interfaces []parse.Interface, toolVersionFunc ToolVersionFunc, testify bool) Mocks {
 	var (
 		stdImports = importMap{"testing": newImport("testing")}
 		extImports = importMap{"mock": newImport("goa.design/clue/mock")}
 		intImports = make(importMap)
-		modPath    = p.ModPath()
-		m          = &mocks{
+	)
+	if testify {
+		extImports["assert"] = newImport("github.com/stretchr/testify/assert")
+	}
+
+	var (
+		modPath = p.ModPath()
+		m       = &mocks{
 			pkgName:         prefix + p.Name(),
 			pkgPath:         p.PkgPath(),
 			pkgImport:       addImport(newImport(p.PkgPath(), p.Name()), stdImports, extImports, intImports, modPath),
 			toolVersionFunc: toolVersionFunc,
+			testify:         testify,
 		}
 		typeNames = make(typeMap)
 		typeZeros = make(typeMap)
@@ -78,38 +103,52 @@ func NewMocks(prefix string, p parse.Package, interfaces []parse.Interface, tool
 	return m
 }
 
+// PkgName returns the package name.
 func (m *mocks) PkgName() string {
 	return m.pkgName
 }
 
+// PkgImport returns the package import.
 func (m *mocks) PkgImport() Import {
 	return m.pkgImport
 }
 
+// StdImports returns the standard imports.
 func (m *mocks) StdImports() []Import {
 	return m.stdImports
 }
 
+// ExtImports returns the external imports.
 func (m *mocks) ExtImports() []Import {
 	return m.extImports
 }
 
+// IntImports returns the internal imports.
 func (m *mocks) IntImports() []Import {
 	return m.intImports
 }
 
+// Interfaces returns the interfaces.
 func (m *mocks) Interfaces() []Interface {
 	return m.interfaces
 }
 
+// ToolVersion returns the tool version.
 func (m *mocks) ToolVersion() string {
 	return m.toolVersionFunc()
 }
 
+// ToolCommandLine returns the tool command line.
 func (m *mocks) ToolCommandLine() string {
 	return "$ cmg gen " + m.pkgPath
 }
 
+// Testify returns true if testify should be used.
+func (m *mocks) Testify() bool {
+	return m.testify
+}
+
+// Render renders the mocks to the given writer.
 func (m *mocks) Render(w io.Writer) error {
 	return mocksTmpl.Execute(w, m)
 }

mock/cmd/cmg/pkg/generate/mocks.go

@@ -17,13 +17,18 @@ import (
 {{- end }}
 )
 
+{{ $testify := .Testify -}}
 type (
 {{- range $index, $interface := .Interfaces }}
 {{- if ge $index 1 }}
 {{ end }}
 	{{ .Name }}{{ .TypeParameters }} struct {
 		m *mock.Mock
+		{{- if $testify }}
+		assert *assert.Assertions
+		{{- else }}
 		t *testing.T
+		{{- end }}
 	}
 {{ range .Methods }}
 	{{ printf "%v%v" .Func $interface.TypeParameters | printf $interface.MaxFuncLenFmt }} func({{ .Parameters }}){{ if .Results }} {{ .Results }}{{ end }}
@@ -36,7 +41,7 @@ type (
 {{ end }}
 func {{ .Constructor }}{{ .TypeParameters }}(t *testing.T) *{{ .Name }}{{ .TypeParameterVars }} {
 	var (
-		{{ .Var | printf ($import.AliasOrPkgName | .ConstructorFmt) }} = &{{ .Name }}{{ .TypeParameterVars }}{mock.New(), t}
+		{{ .Var | printf ($import.AliasOrPkgName | .ConstructorFmt) }} = &{{ .Name }}{{ .TypeParameterVars }}{mock.New(), {{ if $testify }}assert.New(t){{ else }}t{{ end }}}
 		_ {{ $import.AliasOrPkgName }}.{{ .Name }}{{ .TypeParameterVars }} = m
 	)
 	return {{ .Var }}
@@ -59,8 +64,12 @@ func ({{ .InterfaceVar }} *{{ $interface.Name }}{{ $interface.TypeParameterVars
 		return
 {{- end }}
 	}
+	{{- if $testify }}
+	{{ .InterfaceVar }}.assert.Fail("unexpected {{ .Name }} call")
+	{{- else }}
 	{{ .InterfaceVar }}.t.Helper()
 	{{ .InterfaceVar }}.t.Error("unexpected {{ .Name }} call")
+	{{- end }}
 {{- if .ZeroResults }}
 	return {{ .ZeroResults }}
 {{- end }}

mock/cmd/cmg/pkg/generate/mocks.go.tmpl

@@ -23,6 +23,7 @@ func TestMocks_Render(t *testing.T) {
 	cases := []struct {
 		Name, Pattern string
 		ExpectedFiles []string
+		Testify       bool
 	}{
 		{
 			Name:          "extensive",
@@ -34,6 +35,12 @@ func TestMocks_Render(t *testing.T) {
 			Pattern:       "./conflicts",
 			ExpectedFiles: []string{"conflicts.go"},
 		},
+		{
+			Name:          "testify",
+			Pattern:       "./testify",
+			ExpectedFiles: []string{"testify.go"},
+			Testify:       true,
+		},
 	}
 
 	for _, tc := range cases {
@@ -67,7 +74,7 @@ func TestMocks_Render(t *testing.T) {
 					require.NoError(err)
 					t.Cleanup(func() { assert.NoError(of.Close()) })
 
-					m := NewMocks("mock", p, is, toolVersion)
+					m := NewMocks("mock", p, is, toolVersion, tc.Testify)
 					require.NoError(m.Render(of))
 				}
 
@@ -82,7 +89,7 @@ func TestMocks_Render(t *testing.T) {
 
 			for f, is := range interfacesByFile {
 				f := filepath.Join(mocksDir, f)
-				m := NewMocks("mock", p, is, toolVersion)
+				m := NewMocks("mock", p, is, toolVersion, tc.Testify)
 				b := &bytes.Buffer{}
 
 				err := m.Render(b)