Improve coverage in proteus

This improves coverage in all packages in proteus and extract common utils to
go-parse-utils

Author: Serabe

.gitignore

@@ -22,3 +22,5 @@ _testmain.go
 *.exe
 *.test
 *.prof
+
+coverage.txt

.travis.yml

@@ -9,7 +9,7 @@ matrix:
         - go: tip
 
 install:
-  - go get -t -v ./...
+  - go get -t -u -v ./...
 
 script:
   - make test

Makefile

@@ -4,7 +4,7 @@ COVERAGE_MODE := atomic
 
 test:
 	@echo "mode: $(COVERAGE_MODE)" > $(COVERAGE_REPORT); \
-	for dir in `find . -name "*.go" | grep -o '.*/' | sort -u`; do \
+	for dir in `find . -name "*.go" | grep -o '.*/' | sort -u | grep -v './fixtures/'`; do \
 		go test $$dir -coverprofile=$(COVERAGE_PROFILE) -covermode=$(COVERAGE_MODE); \
 		if [ $$? != 0 ]; then \
 			exit 2; \

rpc/context.go

@@ -80,8 +80,16 @@ func firstTypeName(tuple *types.Tuple) types.Object {
 	return t.(*types.Named).Obj()
 }
 
+func (c *context) pkgPath() string {
+	if c.pkg != nil {
+		return c.pkg.Path()
+	}
+
+	return ""
+}
+
 func (c *context) addImport(path string) {
-	if path == c.pkg.Path() {
+	if path == c.pkgPath() {
 		return
 	}
 

rpc/context_test.go

@@ -0,0 +1,53 @@
+package rpc
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/src-d/proteus/protobuf"
+	"github.com/stretchr/testify/assert"
+
+	"gopkg.in/src-d/go-parse-utils.v1"
+)
+
+func TestContext_isNameDefined(t *testing.T) {
+	pkg, err := parseutil.NewImporter().Import("github.com/src-d/proteus/fixtures")
+	if err != nil {
+		assert.Fail(t, fmt.Sprintf("could not import project fixtures: %v", err))
+	}
+	ctx := &context{pkg: pkg}
+
+	assert.True(t, ctx.isNameDefined("Foo"), "Generator is defined")
+	assert.False(t, ctx.isNameDefined("supercalifragilisticexpialidocious"), "this pakage has something to say")
+}
+
+func TestContext_findMessage(t *testing.T) {
+	ctx := &context{
+		proto: &protobuf.Package{
+			Messages: []*protobuf.Message{
+				&protobuf.Message{Name: "a"},
+			},
+		},
+	}
+
+	var msg *protobuf.Message
+	msg = ctx.findMessage("a")
+	assert.NotNil(t, msg)
+
+	msg = ctx.findMessage("nothere")
+	assert.Nil(t, msg)
+}
+
+func TestContext_addImport(t *testing.T) {
+	ctx := &context{}
+
+	assert.Equal(t, 0, len(ctx.imports))
+	ctx.addImport("my-path")
+	assert.Equal(t, 1, len(ctx.imports))
+
+	ctx.addImport("other-path")
+	assert.Equal(t, 2, len(ctx.imports), "adds other element")
+
+	ctx.addImport("my-path")
+	assert.Equal(t, 2, len(ctx.imports), "does not addd the same element twice")
+}

rpc/rpc.go

@@ -11,7 +11,8 @@ import (
 
 	"github.com/src-d/proteus/protobuf"
 	"github.com/src-d/proteus/report"
-	"github.com/src-d/proteus/source"
+
+	"gopkg.in/src-d/go-parse-utils.v1"
 )
 
 // Generator generates implementations of an RPC server for a package.
@@ -45,12 +46,12 @@ import (
 // The file will be written to the package path and it will be named
 // "server.proteus.go"
 type Generator struct {
-	importer *source.Importer
+	importer *parseutil.Importer
 }
 
 // NewGenerator creates a new Generator.
 func NewGenerator() *Generator {
-	return &Generator{source.NewImporter()}
+	return &Generator{parseutil.NewImporter()}
 }
 
 // Generate creates a new file in the package at the given path and implements

rpc/rpc_test.go

@@ -53,6 +53,13 @@ const expectedFuncNotGenerated = `func (s *FooServer) DoFoo(ctx context.Context,
 	return
 }`
 
+const expectedFuncNotGeneratedAndNotNullable = `func (s *FooServer) DoFoo(ctx context.Context, in *Foo) (result *Bar, err error) {
+	result = new(Bar)
+	aux := DoFoo(in)
+	result = &aux
+	return
+}`
+
 const expectedFuncGenerated = `func (s *FooServer) DoFoo(ctx context.Context, in *FooRequest) (result *FooResponse, err error) {
 	result = new(FooResponse)
 	result.Result1, result.Result2, result.Result3 = DoFoo(in.Arg1, in.Arg2, in.Arg3)
@@ -109,6 +116,16 @@ func (s *RPCSuite) TestDeclMethod() {
 			},
 			expectedFuncNotGenerated,
 		},
+		{
+			"func output not generated and not nullable",
+			&protobuf.RPC{
+				Name:   "DoFoo",
+				Method: "DoFoo",
+				Input:  protobuf.NewNamed("", "Foo"),
+				Output: notNullable(protobuf.NewNamed("", "Bar")),
+			},
+			expectedFuncNotGeneratedAndNotNullable,
+		},
 		{
 			"func generated",
 			&protobuf.RPC{
@@ -366,6 +383,13 @@ func (s *RPCSuite) fakePkg() *types.Package {
 	return pkg
 }
 
+func notNullable(t protobuf.Type) protobuf.Type {
+	src := scanner.NewNamed("", "X")
+	src.SetNullable(false)
+	t.SetSource(src)
+	return t
+}
+
 func render(decl ast.Decl) (string, error) {
 	var buf bytes.Buffer
 	if err := printer.Fprint(&buf, token.NewFileSet(), decl); err != nil {

scanner/context.go

@@ -6,7 +6,7 @@ import (
 	"go/token"
 	"strings"
 
-	"github.com/src-d/proteus/source"
+	"gopkg.in/src-d/go-parse-utils.v1"
 )
 
 // context holds all the scanning context of a single package. Contains all
@@ -31,7 +31,7 @@ type context struct {
 }
 
 func newContext(path string) (*context, error) {
-	pkg, err := source.PackageAST(path)
+	pkg, err := parseutil.PackageAST(path)
 	if err != nil {
 		return nil, err
 	}

scanner/context_test.go

@@ -0,0 +1,44 @@
+package scanner
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+var goSrc = filepath.Join(os.Getenv("GOPATH"), "src")
+var projectDir = filepath.Join(goSrc, "github.com/src-d/proteus")
+
+func TestNewContext_error(t *testing.T) {
+	createDirWithMultipleFiles("erroring")
+	defer removeDir("erroring")
+	_, err := newContext("github.com/src-d/proteus/fixtures/erroring/multiple")
+	assert.NotNil(t, err)
+}
+
+func createDirWithMultipleFiles(pkg string) error {
+	path := filepath.Join(projectDir, pkg)
+	os.Mkdir(path, os.ModeDir)
+
+	f, err := os.Create(filepath.Join(path, "foo.go"))
+	if err != nil {
+		return err
+	}
+	f.Write([]byte("package foo"))
+	f.Close()
+
+	f, err = os.Create(filepath.Join(path, "bar.go"))
+	if err != nil {
+		return err
+	}
+	f.Write([]byte("package bar"))
+	f.Close()
+
+	return nil
+}
+
+func removeDir(pkg string) {
+	os.RemoveAll(filepath.Join(projectDir, pkg))
+}

scanner/package_test.go

@@ -0,0 +1,125 @@
+package scanner
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestBaseType(t *testing.T) {
+	typ := newBaseType()
+	name := "BaseType"
+
+	assertRepeatable(t, typ, name)
+	assertNullable(t, typ, name)
+	assert.Panics(t, func() { typ.TypeString() }, "does not implement TypeString")
+	assert.Panics(t, func() { typ.String() }, "does not implement String")
+	assert.Panics(t, func() { typ.UnqualifiedName() }, "does not implement UnqualifiedName")
+}
+
+func TestBasic(t *testing.T) {
+	typ := NewBasic("basic")
+	name := "Basic"
+
+	assertRepeatable(t, typ, name)
+
+	assert.True(t, typ.IsNullable(), "Basic is nullable by default")
+	typ.SetNullable(false)
+	assert.True(t, typ.IsNullable(), "Basic cannot be set not nullable")
+
+	assert.Equal(t, "basic", typ.String(), "Basic.String returns type's name")
+	assert.Equal(t, "basic", typ.TypeString(), "Basic.TypeString returns type's name")
+	assert.Equal(t, "basic", typ.UnqualifiedName(), "Basic.UnqualifiedName returns type's name")
+}
+
+func TestNamed_withPath(t *testing.T) {
+	typ := NewNamed("pkg", "name")
+	name := "Named (with path)"
+
+	assertRepeatable(t, typ, name)
+	assertNullable(t, typ, name)
+
+	assert.Equal(t, "pkg.name", typ.String(), "Named.String() (with path) returns type's name with path")
+	assert.Equal(t, "pkg.name", typ.TypeString(), "Named.TypeString() (with path) returns type's name with path")
+	assert.Equal(t, "name", typ.UnqualifiedName(), "Named.UnqualifiedName() (with path) returns type's name without path")
+}
+
+func TestNamed_withoutPath(t *testing.T) {
+	typ := NewNamed("", "name")
+	name := "Named (without path)"
+
+	assertRepeatable(t, typ, name)
+	assertNullable(t, typ, name)
+
+	assert.Equal(t, "name", typ.String(), "Named.String() (with path) returns type's name without path")
+	assert.Equal(t, "name", typ.TypeString(), "Named.TypeString() (with path) returns type's name without path")
+	assert.Equal(t, "name", typ.UnqualifiedName(), "Named.UnqualifiedName() (with path) returns type's name without path")
+}
+
+func TestAlias_IsNullable(t *testing.T) {
+	typ := NewAlias(newBaseType(), newBaseType()).(*Alias)
+
+	assert.False(t, typ.IsNullable(), "Alias is not nullable if neither the type nor the underlying is nullable")
+	typ.Type.SetNullable(true)
+	typ.Underlying.SetNullable(false)
+	assert.True(t, typ.IsNullable(), "Alias is nullable if the type is nullable but the underlying is not")
+	typ.Type.SetNullable(false)
+	typ.Underlying.SetNullable(true)
+	assert.True(t, typ.IsNullable(), "Alias is nullable if the type is not nullable but the underlying is")
+	typ.Type.SetNullable(true)
+	typ.Underlying.SetNullable(true)
+	assert.True(t, typ.IsNullable(), "Alias is nullable if both the type and the underlying are")
+}
+
+func TestAlias_IsRepeated(t *testing.T) {
+	typ := NewAlias(newBaseType(), newBaseType()).(*Alias)
+
+	assert.False(t, typ.IsRepeated(), "Alias is not repeated if neither the type nor the underlying is repeated")
+
+	typ.Type.SetRepeated(true)
+	typ.Underlying.SetRepeated(false)
+	assert.True(t, typ.IsRepeated(), "Alias is repeated if the type is repeated but the underlying is not")
+	typ.Type.SetRepeated(false)
+	typ.Underlying.SetRepeated(true)
+	assert.True(t, typ.IsRepeated(), "Alias is repeated if the type is not repeated but the underlying is")
+	typ.Type.SetRepeated(true)
+	typ.Underlying.SetRepeated(true)
+	assert.True(t, typ.IsRepeated(), "Alias is repeated if both the type and the underlying are")
+}
+
+func TestAlias_stringMethods(t *testing.T) {
+	typ := NewAlias(NewNamed("", "Aliasing"), NewBasic("string"))
+
+	assert.Equal(t, "type Aliasing string", typ.String(), "Alias.String returns a type declaration for the alias")
+	assert.Equal(t, "Aliasing", typ.TypeString(), "Alias.TypeString returns the type string for the alias")
+	assert.Equal(t, "Aliasing", typ.UnqualifiedName(), "Alias.UnqualifiedName returns the unqualified name of the alias")
+}
+
+func TestMap(t *testing.T) {
+	typ := NewMap(NewBasic("string"), NewBasic("int"))
+	name := "Map"
+
+	assertRepeatable(t, typ, name)
+	assertNullable(t, typ, name)
+	assert.Equal(t, "map[string]int", typ.String(), "Map.String returns a map signature")
+	assert.Equal(t, "map[string]int", typ.TypeString(), "Map.TypeString returns a map signature")
+	assert.Equal(t, "map[string]int", typ.UnqualifiedName(), "Map.UnqualifiedName returns a map signature")
+}
+
+// assertRepeatable asserts a type respond as expected to IsRepeated and SetRepeated.
+func assertRepeatable(t *testing.T, typ Type, name string) {
+	assert.False(t, typ.IsRepeated(), "%s is not repeated by default", name)
+	typ.SetRepeated(true)
+	assert.True(t, typ.IsRepeated(), "%s can be set as repeated", name)
+	typ.SetRepeated(false)
+	assert.False(t, typ.IsRepeated(), "%s can be set as not repeated", name)
+}
+
+// assertNullable asserts a type responds as expected to IsNullable and SetNullable.
+func assertNullable(t *testing.T, typ Type, name string) {
+	assert.False(t, typ.IsNullable(), "%s is not nullable by default", name)
+	typ.SetNullable(true)
+	assert.True(t, typ.IsNullable(), "%s can be set as nullable", name)
+	typ.SetNullable(false)
+	assert.False(t, typ.IsNullable(), "%s can be set as not nullable", name)
+}

scanner/scanner.go

@@ -11,7 +11,8 @@ import (
 	"sync"
 
 	"github.com/src-d/proteus/report"
-	"github.com/src-d/proteus/source"
+
+	"gopkg.in/src-d/go-parse-utils.v1"
 )
 
 var goPath = os.Getenv("GOPATH")
@@ -20,7 +21,7 @@ var goPath = os.Getenv("GOPATH")
 // and extract types and structs from.
 type Scanner struct {
 	packages []string
-	importer *source.Importer
+	importer *parseutil.Importer
 }
 
 // ErrNoGoPathSet is the error returned when the GOPATH variable is not
@@ -47,7 +48,7 @@ func New(packages ...string) (*Scanner, error) {
 
 	return &Scanner{
 		packages: packages,
-		importer: source.NewImporter(),
+		importer: parseutil.NewImporter(),
 	}, nil
 }
 
@@ -89,11 +90,11 @@ func (s *Scanner) Scan() ([]*Package, error) {
 func (s *Scanner) scanPackage(p string) (*Package, error) {
 	pkg, err := s.importer.ImportWithFilters(
 		p,
-		source.FileFilters{
-			func(pkg, file string, typ source.FileType) bool {
+		parseutil.FileFilters{
+			func(pkg, file string, typ parseutil.FileType) bool {
 				return !strings.HasSuffix(file, ".pb.go")
 			},
-			func(pkg, file string, typ source.FileType) bool {
+			func(pkg, file string, typ parseutil.FileType) bool {
 				return !strings.HasSuffix(file, ".proteus.go")
 			},
 		},