Add more tests

blob_cache_test.go

@@ -214,3 +214,58 @@ func TestBlobCacheGetBlob(t *testing.T) {
 	assert.NotNil(t, err)
 	assert.Equal(t, err.Error(), plumbing.ErrObjectNotFound.Error())
 }
+
+func TestBlobCacheDeleteInvalidBlob(t *testing.T) {
+	commit, _ := testRepository.CommitObject(plumbing.NewHash(
+		"2b1ed978194a94edeabbca6de7ff3b5771d4d665"))
+	changes := make(object.Changes, 1)
+	treeFrom, _ := testRepository.TreeObject(plumbing.NewHash(
+		"96c6ece9b2f3c7c51b83516400d278dea5605100"))
+	changes[0] = &object.Change{From: object.ChangeEntry{
+		Name: "analyser.go",
+		Tree: treeFrom,
+		TreeEntry: object.TreeEntry{
+			Name: "analyser.go",
+			Mode: 0100644,
+			Hash: plumbing.NewHash("ffffffffffffffffffffffffffffffffffffffff"),
+		},
+	}, To: object.ChangeEntry{},
+	}
+	deps := map[string]interface{}{}
+	deps["commit"] = commit
+	deps["changes"] = changes
+	result, err := fixtureBlobCache().Consume(deps)
+	assert.Nil(t, err)
+	assert.Equal(t, len(result), 1)
+	cacheIface, exists := result["blob_cache"]
+	assert.True(t, exists)
+	cache := cacheIface.(map[plumbing.Hash]*object.Blob)
+	assert.Equal(t, len(cache), 1)
+	blobFrom, exists := cache[plumbing.NewHash("ffffffffffffffffffffffffffffffffffffffff")]
+	assert.True(t, exists)
+	assert.Equal(t, blobFrom.Size, int64(0))
+}
+
+func TestBlobCacheInsertInvalidBlob(t *testing.T) {
+	commit, _ := testRepository.CommitObject(plumbing.NewHash(
+		"2b1ed978194a94edeabbca6de7ff3b5771d4d665"))
+	changes := make(object.Changes, 1)
+	treeTo, _ := testRepository.TreeObject(plumbing.NewHash(
+		"251f2094d7b523d5bcc60e663b6cf38151bf8844"))
+	changes[0] = &object.Change{From: object.ChangeEntry{}, To: object.ChangeEntry{
+		Name: "pipeline.go",
+		Tree: treeTo,
+		TreeEntry: object.TreeEntry{
+			Name: "pipeline.go",
+			Mode: 0100644,
+			Hash: plumbing.NewHash("ffffffffffffffffffffffffffffffffffffffff"),
+		},
+	},
+	}
+	deps := map[string]interface{}{}
+	deps["commit"] = commit
+	deps["changes"] = changes
+	result, err := fixtureBlobCache().Consume(deps)
+	assert.NotNil(t, err)
+	assert.Equal(t, len(result), 0)
+}

identity.go

@@ -3,11 +3,11 @@ package hercules
 import (
 	"bufio"
 	"os"
+	"sort"
 	"strings"
 
 	"gopkg.in/src-d/go-git.v4"
 	"gopkg.in/src-d/go-git.v4/plumbing/object"
-	"sort"
 )
 
 type IdentityDetector struct {
@@ -99,14 +99,40 @@ func (id *IdentityDetector) GeneratePeopleDict(commits []*object.Commit) {
 				if exists {
 					dict[key] = id
 				} else {
+					id = size
+					size++
 					if toEmail != "" {
-						dict[toEmail] = size
+						dict[toEmail] = id
+						emails[id] = append(emails[id], toEmail)
 					}
 					if toName != "" {
-						dict[toName] = size
+						dict[toName] = id
+						names[id] = append(names[id], toName)
+					}
+					dict[key] = id
+				}
+				if strings.Contains(key, "@") {
+					exists := false
+					for _, val := range emails[id] {
+						if key == val {
+							exists = true
+							break
+						}
+					}
+					if !exists {
+						emails[id] = append(emails[id], key)
+					}
+				} else {
+					exists := false
+					for _, val := range names[id] {
+						if key == val {
+							exists = true
+							break
+						}
+					}
+					if !exists {
+						names[id] = append(names[id], key)
 					}
-					dict[key] = size
-					size += 1
 				}
 			}
 		}

identity_test.go

@@ -2,12 +2,18 @@ package hercules
 
 import (
 	"io"
+	"io/ioutil"
+	"os"
 	"path"
+	"reflect"
+	"strings"
 	"testing"
+	"unsafe"
 
 	"github.com/stretchr/testify/assert"
 	"gopkg.in/src-d/go-git.v4/plumbing"
 	"gopkg.in/src-d/go-git.v4/plumbing/object"
+	"gopkg.in/src-d/go-git.v4/plumbing/storer"
 )
 
 func fixtureIdentityDetector() *IdentityDetector {
@@ -140,3 +146,137 @@ func TestIdentityDetectorFinalize(t *testing.T) {
 	res := id.Finalize()
 	assert.Nil(t, res)
 }
+
+func TestLoadPeopleDictInvalidPath(t *testing.T) {
+	id := fixtureIdentityDetector()
+	ipath := "/xxxyyyzzzInvalidPath!hehe"
+	err := id.LoadPeopleDict(ipath)
+	assert.NotNil(t, err)
+	assert.Equal(t, err.(*os.PathError).Path, ipath)
+}
+
+type fakeBlobEncodedObject struct {
+	Contents string
+}
+
+func (obj fakeBlobEncodedObject) Hash() plumbing.Hash {
+	return plumbing.NewHash("ffffffffffffffffffffffffffffffffffffffff")
+}
+
+func (obj fakeBlobEncodedObject) Type() plumbing.ObjectType {
+	return plumbing.BlobObject
+}
+
+func (obj fakeBlobEncodedObject) SetType(plumbing.ObjectType) {}
+
+func (obj fakeBlobEncodedObject) Size() int64 {
+	return int64(len(obj.Contents))
+}
+
+func (obj fakeBlobEncodedObject) SetSize(int64) {}
+
+func (obj fakeBlobEncodedObject) Reader() (io.ReadCloser, error) {
+	return ioutil.NopCloser(strings.NewReader(obj.Contents)), nil
+}
+
+func (obj fakeBlobEncodedObject) Writer() (io.WriteCloser, error) {
+	return nil, nil
+}
+
+type fakeTreeEncodedObject struct {
+	Name string
+}
+
+func (obj fakeTreeEncodedObject) Hash() plumbing.Hash {
+	return plumbing.NewHash("ffffffffffffffffffffffffffffffffffffffff")
+}
+
+func (obj fakeTreeEncodedObject) Type() plumbing.ObjectType {
+	return plumbing.TreeObject
+}
+
+func (obj fakeTreeEncodedObject) SetType(plumbing.ObjectType) {}
+
+func (obj fakeTreeEncodedObject) Size() int64 {
+	return 1
+}
+
+func (obj fakeTreeEncodedObject) SetSize(int64) {}
+
+func (obj fakeTreeEncodedObject) Reader() (io.ReadCloser, error) {
+	return ioutil.NopCloser(strings.NewReader(
+		"100644 " + obj.Name + "\x00ffffffffffffffffffffffffffffffffffffffff")), nil
+}
+
+func (obj fakeTreeEncodedObject) Writer() (io.WriteCloser, error) {
+	return nil, nil
+}
+
+type fakeEncodedObjectStorer struct {
+	Name string
+	Contents string
+}
+
+func (strr fakeEncodedObjectStorer) NewEncodedObject() plumbing.EncodedObject {
+	return nil
+}
+
+func (strr fakeEncodedObjectStorer) SetEncodedObject(plumbing.EncodedObject) (plumbing.Hash, error) {
+	return plumbing.NewHash("0000000000000000000000000000000000000000"), nil
+}
+
+func (strr fakeEncodedObjectStorer) EncodedObject(objType plumbing.ObjectType, hash plumbing.Hash) (plumbing.EncodedObject, error) {
+  if objType == plumbing.TreeObject {
+	  return fakeTreeEncodedObject{Name: strr.Name}, nil
+  } else if objType == plumbing.BlobObject {
+	  return fakeBlobEncodedObject{Contents: strr.Contents}, nil
+  }
+	return nil, nil
+}
+
+func (strr fakeEncodedObjectStorer) IterEncodedObjects(plumbing.ObjectType) (storer.EncodedObjectIter, error) {
+	return nil, nil
+}
+
+func getFakeCommitWithFile(name string, contents string) *object.Commit {
+	c := object.Commit{
+		Hash: plumbing.NewHash("ffffffffffffffffffffffffffffffffffffffff"),
+		Author: object.Signature{
+			Name: "Vadim Markovtsev",
+			Email: "vadim@sourced.tech",
+		},
+		Committer: object.Signature{
+			Name: "Vadim Markovtsev",
+			Email: "vadim@sourced.tech",
+		},
+		Message: "Virtual file " + name,
+		TreeHash: plumbing.NewHash("ffffffffffffffffffffffffffffffffffffffff"),
+	}
+	voc := reflect.ValueOf(&c)
+	voc = voc.Elem()
+	f := voc.FieldByName("s")
+	ptr := unsafe.Pointer(f.UnsafeAddr())
+	strr := fakeEncodedObjectStorer{Name: name, Contents: contents}
+	*(*storer.EncodedObjectStorer)(ptr) = strr
+	return &c
+}
+
+func TestGeneratePeopleDictMailmap(t *testing.T) {
+	id := fixtureIdentityDetector()
+	commits := make([]*object.Commit, 0)
+	iter, err := testRepository.CommitObjects()
+	commit, err := iter.Next()
+	for ; err != io.EOF; commit, err = iter.Next() {
+		if err != nil {
+			panic(err)
+		}
+		commits = append(commits, commit)
+	}
+  fake := getFakeCommitWithFile(
+	  ".mailmap",
+	  "Strange Guy <vadim@sourced.tech>\nVadim Markovtsev <vadim@sourced.tech> Strange Guy <vadim@sourced.tech>")
+	commits = append(commits, fake)
+	id.GeneratePeopleDict(commits)
+	assert.Contains(t, id.ReversePeopleDict,
+		"strange guy|vadim markovtsev|gmarkhor@gmail.com|vadim@sourced.tech")
+}