Generation from interface aliases

Makefile

@@ -20,6 +20,9 @@ generate:
  go run ./cmd/minimock/minimock.go -i ./tests.contextAccepter -o ./tests/context_accepter_mock.go
  go run ./cmd/minimock/minimock.go -i github.com/gojuno/minimock/v3.Tester -o ./tests/package_name_specified_test.go -p tests_test
  go run ./cmd/minimock/minimock.go -i ./tests.actor -o ./tests/actor_mock.go
+ go run ./cmd/minimock/minimock.go -i ./tests.formatterAlias -o ./tests/formatter_alias_mock.go
+ go run ./cmd/minimock/minimock.go -i ./tests.formatterType -o ./tests/formatter_type_mock.go
+ go run ./cmd/minimock/minimock.go -i ./tests.reader -o ./tests/reader_mock.go
 
 ./bin:
  mkdir ./bin

README.md

@@ -16,6 +16,7 @@ The main features of minimock are:
 * It supports generics.
 * It works well with [table driven tests](https://dave.cheney.net/2013/06/09/writing-table-driven-tests-in-go) because you can set up mocks for several methods in one line of code using the builder pattern.
 * It can generate several mocks in one run.
+* It can generate mocks from interface aliases.
 * It generates code that passes default set of [golangci-lint](https://github.com/golangci/golangci-lint) checks.
 * It puts //go:generate instruction into the generated code, so all you need to do when the source interface is updated is to run the `go generate ./...` command from within the project's directory.
 * It makes sure that all mocked methods have been called during the test and keeps your test code clean and up to date.

equal.go

@@ -64,6 +64,7 @@ func Diff(e, a interface{}) string {
  return ""
  }
 
+ initialKind := k
  if k == reflect.Ptr {
  t = t.Elem()
  k = t.Kind()
@@ -73,7 +74,7 @@ func Diff(e, a interface{}) string {
  return ""
  }
 
- if k == reflect.Struct {
+ if initialKind == reflect.Struct {
  a = setAnyContext(e, a)
  }
 

go.mod

@@ -2,7 +2,7 @@ module github.com/gojuno/minimock/v3
 
 require (
  github.com/davecgh/go-spew v1.1.1
- github.com/hexdigest/gowrap v1.3.7
+ github.com/hexdigest/gowrap v1.3.10
  github.com/pkg/errors v0.9.1
  github.com/pmezard/go-difflib v1.0.0
  github.com/stretchr/testify v1.8.4

go.sum

@@ -5,8 +5,8 @@ github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaS
 github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
 github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
-github.com/hexdigest/gowrap v1.3.7 h1:vgfh7NQEZQyMe17PBaMX/d4+7hTLyxo2q4DFTfx3p1E=
-github.com/hexdigest/gowrap v1.3.7/go.mod h1:5KTYxPjK1RRfD+9L4Oo9gjP3XNAs4rkoVK2E7eAEFyM=
+github.com/hexdigest/gowrap v1.3.10 h1:e8NwAdtnwpRJ4Ks76+GctDNCFIkHR2TCFCWshug/zIE=
+github.com/hexdigest/gowrap v1.3.10/go.mod h1:5KTYxPjK1RRfD+9L4Oo9gjP3XNAs4rkoVK2E7eAEFyM=
 github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
 github.com/kr/pretty v0.3.0 h1:WgNl7dwNpEZ6jJ9k1snq4pZsg7DOEN8hP9Xw0Tsjwk0=
 github.com/kr/pretty v0.3.0/go.mod h1:640gp4NfQd8pI5XOwp5fnNeVWj67G7CFk/SaSQn7NBk=

internal/types/interface.go

@@ -5,6 +5,9 @@ import (
  "go/ast"
  "go/printer"
  "go/token"
+ "strings"
+
+ "github.com/hexdigest/gowrap/pkg"
 )
 
 // InterfaceSpecification represents abstraction over interface type. It contains all the metadata
@@ -23,17 +26,13 @@ type InterfaceSpecificationParam struct {
 }
 
 func FindAllInterfaces(p *ast.Package, pattern string) []InterfaceSpecification {
- // Find all declared types in a single package
- types := []*ast.TypeSpec{}
- for _, file := range p.Files {
- types = append(types, findAllTypeSpecsInFile(file)...)
- }
-
  // Filter interfaces from all the declarations
  interfaces := []*ast.TypeSpec{}
- for _, typeSpec := range types {
- if isInterface(typeSpec) {
- interfaces = append(interfaces, typeSpec)
+ for _, file := range p.Files {
+ for _, typeSpec := range findAllTypeSpecsInFile(file) {
+ if isInterface(typeSpec, file.Imports) {
+ interfaces = append(interfaces, typeSpec)
+ }
  }
  }
 
@@ -57,8 +56,121 @@ func FindAllInterfaces(p *ast.Package, pattern string) []InterfaceSpecification
  return interfaceSpecifications
 }
 
-func isInterface(typeSpec *ast.TypeSpec) bool {
- // Check if this type declaration is specifically an interface declaration
+func isInterface(typeSpec *ast.TypeSpec, fileImports []*ast.ImportSpec) bool {
+ // we are generating mocks for interfaces,
+ // interface aliases to types from the same package
+ // and aliases to types from another package
+ return isInterfaceType(typeSpec) ||
+ isInterfaceAlias(typeSpec, fileImports) ||
+ isExportedInterfaceAlias(typeSpec, fileImports)
+}
+
+// isInterfaceAlias checks if type is an alias to other
+// interface type that is in the same package
+func isInterfaceAlias(typeSpec *ast.TypeSpec, fileImports []*ast.ImportSpec) bool {
+ ident, ok := typeSpec.Type.(*ast.Ident)
+ if !ok {
+ return false
+ }
+
+ if ident.Obj == nil {
+ return false
+ }
+
+ if ts, ok := ident.Obj.Decl.(*ast.TypeSpec); ok {
+ return isInterface(ts, fileImports)
+ }
+
+ return false
+}
+
+// isExportedInterfaceAlias checks if type is an alias to other
+// interface type that is in other exported package
+func isExportedInterfaceAlias(typeSpec *ast.TypeSpec, fileImports []*ast.ImportSpec) bool {
+ selector, ok := typeSpec.Type.(*ast.SelectorExpr)
+ if !ok {
+ return false
+ }
+
+ ident, ok := selector.X.(*ast.Ident)
+ if !ok {
+ return false
+ }
+
+ srcPkgPath := findSourcePackage(ident, fileImports)
+ srcAst, err := getPackageAst(srcPkgPath)
+ if err != nil {
+ return false
+ }
+
+ typeSpec, imports := findTypeSpecInPackage(srcAst, selector.Sel.Name)
+
+ // we have to check recursively because checked typed might be
+ // another alias to other interface
+ return isInterface(typeSpec, imports)
+}
+
+func getPackageAst(packagePath string) (*ast.Package, error) {
+ srcPkg, err := pkg.Load(packagePath)
+ if err != nil {
+ return nil, err
+ }
+
+ fs := token.NewFileSet()
+ srcAst, err := pkg.AST(fs, srcPkg)
+ if err != nil {
+ return nil, err
+ }
+
+ return srcAst, nil
+}
+
+func findTypeSpecInPackage(p *ast.Package, name string) (typeSpec *ast.TypeSpec, imports []*ast.ImportSpec) {
+ for _, f := range p.Files {
+ if f == nil {
+ continue
+ }
+ types := findAllTypeSpecsInFile(f)
+ typeSpec, found := findTypeByName(types, name)
+ if found {
+ return typeSpec, f.Imports
+ }
+ }
+
+ return
+}
+
+func findTypeByName(types []*ast.TypeSpec, name string) (*ast.TypeSpec, bool) {
+ for _, ts := range types {
+ if ts.Name.Name == name {
+ return ts, true
+ }
+ }
+
+ return nil, false
+}
+
+func findSourcePackage(ident *ast.Ident, imports []*ast.ImportSpec) string {
+ for _, imp := range imports {
+ cleanPath := strings.Trim(imp.Path.Value, "\"")
+ if imp.Name != nil {
+ if ident.Name == imp.Name.Name {
+ return cleanPath
+ }
+
+ continue
+ }
+
+ slash := strings.LastIndex(cleanPath, "/")
+ if ident.Name == cleanPath[slash+1:] {
+ return cleanPath
+ }
+ }
+
+ return ""
+}
+
+func isInterfaceType(typeSpec *ast.TypeSpec) bool {
  _, ok := typeSpec.Type.(*ast.InterfaceType)
  return ok
 }