Zanzibar now supports custom interface names in clients, added change…

…s in template, dependencies to check for custom client interface names

codegen/mockgen.go

@@ -22,14 +22,15 @@ package codegen
 
 import (
 	"bytes"
-	"github.com/golang/mock/mockgen/model"
-	"github.com/pkg/errors"
 	"go/token"
 	"os/exec"
 	"path"
 	"sort"
 	"strconv"
 	"strings"
+
+	"github.com/golang/mock/mockgen/model"
+	"github.com/pkg/errors"
 )
 
 const (
@@ -77,7 +78,7 @@ func (b byMethodName) Swap(i, j int)      { b[i], b[j] = b[j], b[i] }
 func (b byMethodName) Less(i, j int) bool { return b[i].Name < b[j].Name }
 
 // AugmentMockWithFixture generates mocks with fixture for the interface in the given package
-func (m MockgenBin) AugmentMockWithFixture(pkg *model.Package, f *Fixture) ([]byte, []byte, error) {
+func (m MockgenBin) AugmentMockWithFixture(pkg *model.Package, f *Fixture, intf string) ([]byte, []byte, error) {
 	methodsMap := make(map[string]*model.Method, len(pkg.Interfaces[0].Methods))
 	validationMap := make(map[string]interface{}, len(pkg.Interfaces[0].Methods))
 	for _, m := range pkg.Interfaces[0].Methods {
@@ -128,9 +129,10 @@ func (m MockgenBin) AugmentMockWithFixture(pkg *model.Package, f *Fixture) ([]by
 	}
 
 	data := map[string]interface{}{
-		"Imports": pkgPathToAlias,
-		"Methods": methods,
-		"Fixture": f,
+		"Imports":         pkgPathToAlias,
+		"Methods":         methods,
+		"Fixture":         f,
+		"ClientInterface": intf,
 	}
 	types, err := m.tmpl.ExecTemplate("fixture_types.tmpl", data, m.pkgHelper)
 	if err != nil {

codegen/module_system.go

@@ -1497,6 +1497,10 @@ func GenerateDependencyStruct(
 	packageHelper *PackageHelper,
 	template *Template,
 ) ([]byte, error) {
+	genCustom, _ := instance.Config["customInterface"].(string)
+	if genCustom != "" {
+		instance.PackageInfo.ExportType = instance.Config["customInterface"].(string)
+	}
 	return template.ExecTemplate(
 		"dependency_struct.tmpl",
 		instance,

codegen/post_gen_hooks.go

@@ -36,8 +36,8 @@ import (
 )
 
 const (
-	defaulClientInterface = "Client"
-	custom                = "custom"
+	defaultClientInterface = "Client"
+	custom                 = "custom"
 )
 
 type mockableClient struct {
@@ -79,7 +79,7 @@ func ClientMockGenHook(h *PackageHelper, t *Template) (PostGenHook, error) {
 
 		importPathMap := make(map[string]string, mockCount)
 		fixtureMap := make(map[string]*Fixture, mockCount)
-		customInterfaceMap := make(map[string]string)
+		clientInterfaceMap := make(map[string]string)
 		pathSymbolMap := make(map[string]string)
 		for _, instance := range clientInstances {
 			key := instance.ClassType + instance.InstanceName
@@ -98,13 +98,18 @@ func ClientMockGenHook(h *PackageHelper, t *Template) (PostGenHook, error) {
 				importPath = client.Config.CustomImportPath
 			}
 
+			clientInterface := defaultClientInterface
+			// if an interfaces name is provided use that, else use "Client"
+			if customInterface != "" {
+				clientInterface = customInterface
+			}
 			importPathMap[key] = importPath
-			customInterfaceMap[key] = customInterface
+			clientInterfaceMap[key] = clientInterface
 
 			// gather all modules that need to generate fixture types
 			f := client.Config.Fixture
 			if f != nil && f.Scenarios != nil {
-				pathSymbolMap[importPath] = defaulClientInterface
+				pathSymbolMap[importPath] = clientInterface
 				fixtureMap[key] = f
 			}
 		}
@@ -144,18 +149,9 @@ func ClientMockGenHook(h *PackageHelper, t *Template) (PostGenHook, error) {
 					genDir := filepath.Join(buildDir, instance.Directory, "mock-client")
 
 					importPath := importPathMap[key]
-					customInterface := customInterfaceMap[key]
 
-					var mock []byte
-					var err error
-					var clientInterface = "Client"
 					// generate mock client, this starts a sub process.
-					// if an interfaces name is provided use that, else use "Client"
-					if customInterface != "" {
-						clientInterface = customInterface
-					}
-
-					mock, err = bin.GenMock(importPath, "clientmock", clientInterface)
+					mock, err := bin.GenMock(importPath, "clientmock", clientInterfaceMap[key])
 					if err != nil {
 						ec <- errors.Wrapf(
 							err,
@@ -168,7 +164,7 @@ func ClientMockGenHook(h *PackageHelper, t *Template) (PostGenHook, error) {
 
 					// generate fixture types and augmented mock client
 					if f, ok := fixtureMap[key]; ok {
-						types, augMock, err := bin.AugmentMockWithFixture(pkgs[importPath], f)
+						types, augMock, err := bin.AugmentMockWithFixture(pkgs[importPath], f, clientInterfaceMap[key])
 						if err != nil {
 							ec <- errors.Wrapf(
 								err,

codegen/templates/augmented_mock.tmpl

@@ -2,15 +2,17 @@
 {{- $methods := .Methods}}
 {{- $fixturePkg := .Fixture.ImportPath -}}
 {{- $scenarios := .Fixture.Scenarios -}}
+{{- $clientinterface := .ClientInterface}}
+
 package clientmock
 
 import (
 	"github.com/golang/mock/gomock"
 )
 
-// MockClientWithFixture is a mock of Client interface with preset fixture
-type MockClientWithFixture struct {
-	*MockClient
+// Mock{{$clientinterface}}WithFixture is a mock of Client interface with preset fixture
+type Mock{{$clientinterface}}WithFixture struct {
+	*Mock{{$clientinterface}}
 	fixture *ClientFixture
 
 	{{range $method := $methods}}
@@ -37,16 +39,16 @@ func (c Call) MinTimes(max int) {
 }
 
 // New creates a new mock instance
-func New(ctrl *gomock.Controller, fixture *ClientFixture) *MockClientWithFixture {
-	return &MockClientWithFixture{
-		MockClient: NewMockClient(ctrl),
+func New(ctrl *gomock.Controller, fixture *ClientFixture) *Mock{{$clientinterface}}WithFixture {
+	return &Mock{{$clientinterface}}WithFixture{
+		Mock{{$clientinterface}}: NewMock{{$clientinterface}}(ctrl),
 		fixture:    fixture,
 	}
 }
 
 // EXPECT shadows the EXPECT method on the underlying mock client.
 // It should not be called directly.
-func (m *MockClientWithFixture) EXPECT() {
+func (m *Mock{{$clientinterface}}WithFixture) EXPECT() {
 	panic("should not call EXPECT directly.")
 }
 
@@ -59,15 +61,15 @@ func (m *MockClientWithFixture) EXPECT() {
 // {{$methodMockType}} mocks the {{$methodName}} method
 type {{$methodMockType}} struct {
 	scenarios  *{{$methodName}}Scenarios
-	mockClient *MockClient
+	mockClient *Mock{{$clientinterface}}
 }
 {{$methodMockMethod := printf "Expect%s" $methodName -}}
 // {{$methodMockMethod}} returns an object that allows the caller to choose expected scenario for {{$methodName}}
-func (m *MockClientWithFixture) {{$methodMockMethod}}() *{{$methodMockType}} {
+func (m *Mock{{$clientinterface}}WithFixture) {{$methodMockMethod}}() *{{$methodMockType}} {
 	if m.{{$methodMockField}} == nil {
 		m.{{$methodMockField}} = &{{$methodMockType}}{
 			scenarios:  m.fixture.{{$methodName}},
-			mockClient: m.MockClient,
+			mockClient: m.Mock{{$clientinterface}},
 		}
 	}
 	return m.{{$methodMockField}}

coverage.tmp

@@ -0,0 +1 @@
+mode: set

examples/example-gateway/build.yaml

@@ -4,9 +4,6 @@ copyrightHeader: ./copyright_header.txt
 endpointConfig: ./endpoints
 genCodePackage: github.com/uber/zanzibar/examples/example-gateway/build/gen-code
 genMock: true
-clientInterfacesMock:
-  github.com/uber/zanzibar/examples/example-gateway/build/clients/contacts:
-  - Client
 middlewareConfig: ./middlewares
 defaultMiddlewareConfig: ./middlewares/default
 packageRoot: github.com/uber/zanzibar/examples/example-gateway