Add more tests

blob_cache.go

@@ -137,16 +137,16 @@ func (cache *BlobCache) getBlob(entry *object.ChangeEntry, fileGetter FileGetter
 		}
 		file, err_modules := fileGetter(".gitmodules")
 		if err_modules != nil {
-			return nil, err
+			return nil, err_modules
 		}
 		contents, err_modules := file.Contents()
 		if err_modules != nil {
-			return nil, err
+			return nil, err_modules
 		}
 		modules := config.NewModules()
 		err_modules = modules.Unmarshal([]byte(contents))
 		if err_modules != nil {
-			return nil, err
+			return nil, err_modules
 		}
 		_, exists := modules.Submodules[entry.Name]
 		if exists {

blob_cache_test.go

@@ -365,3 +365,40 @@ func TestBlobCacheGetBlobIgnoreMissing(t *testing.T) {
 	assert.Nil(t, blob)
 	assert.NotNil(t, err)
 }
+
+func TestBlobCacheGetBlobGitModulesErrors(t *testing.T) {
+	cache := fixtureBlobCache()
+	cache.IgnoreMissingSubmodules = false
+	entry := object.ChangeEntry{
+		Name: "labours.py",
+		TreeEntry: object.TreeEntry{
+			Name: "labours.py",
+			Mode: 0160000,
+			Hash: plumbing.NewHash("ffffffffffffffffffffffffffffffffffffffff"),
+		},
+	}
+	getter := func(path string) (*object.File, error) {
+		return nil, plumbing.ErrInvalidType
+	}
+	blob, err := cache.getBlob(&entry, getter)
+	assert.Nil(t, blob)
+	assert.NotNil(t, err)
+	assert.Equal(t, err.Error(), plumbing.ErrInvalidType.Error())
+	getter = func(path string) (*object.File, error) {
+		blob, _ := createDummyBlob(plumbing.NewHash("ffffffffffffffffffffffffffffffffffffffff"), true)
+		return &object.File{Name: "fake", Blob: *blob}, nil
+	}
+	blob, err = cache.getBlob(&entry, getter)
+	assert.Nil(t, blob)
+	assert.NotNil(t, err)
+	assert.Equal(t, err.Error(), "dummy failure")
+	getter = func(path string) (*object.File, error) {
+		blob, _ := testRepository.BlobObject(plumbing.NewHash(
+			"4434197c2b0509d990f09d53a3cabb910bfd34b7"))
+		return &object.File{Name: ".gitmodules", Blob: *blob}, nil
+	}
+	blob, err = cache.getBlob(&entry, getter)
+	assert.Nil(t, blob)
+	assert.NotNil(t, err)
+	assert.NotEqual(t, err.Error(), plumbing.ErrObjectNotFound.Error())
+}

diff_refiner.go

@@ -50,6 +50,11 @@ func (ref *FileDiffRefiner) Consume(deps map[string]interface{}) (map[string]int
 	diffs := deps[DependencyFileDiff].(map[string]FileDiffData)
 	result := map[string]FileDiffData{}
 	for fileName, oldDiff := range diffs {
+		uastChange, exists := changes[fileName]
+		if !exists {
+			result[fileName] = oldDiff
+			continue
+		}
 		suspicious := map[int][2]int{}
 		line := 0
 		for i, diff := range oldDiff.Diffs {
@@ -76,7 +81,6 @@ func (ref *FileDiffRefiner) Consume(deps map[string]interface{}) (map[string]int
 			result[fileName] = oldDiff
 			continue
 		}
-		uastChange := changes[fileName]
 		line2node := make([][]*uast.Node, oldDiff.NewLinesOfCode)
 		VisitEachNode(uastChange.After, func(node *uast.Node) {
 			if node.StartPosition != nil && node.EndPosition != nil {

diff_refiner_test.go

@@ -96,3 +96,58 @@ func TestFileDiffRefinerConsume(t *testing.T) {
 	assert.Equal(t, utf8.RuneCountInString(newDiff.Diffs[6].Text), 41)
 	assert.Equal(t, utf8.RuneCountInString(newDiff.Diffs[7].Text), 231)
 }
+
+func TestFileDiffRefinerConsumeNoUast(t *testing.T) {
+	bytes1, err := ioutil.ReadFile(path.Join("test_data", "1.java"))
+	assert.Nil(t, err)
+	bytes2, err := ioutil.ReadFile(path.Join("test_data", "2.java"))
+	assert.Nil(t, err)
+	dmp := diffmatchpatch.New()
+	src, dst, _ := dmp.DiffLinesToRunes(string(bytes1), string(bytes2))
+	state := map[string]interface{}{}
+	fileDiffs := map[string]FileDiffData{}
+	const fileName = "test.java"
+	fileDiffs[fileName] = FileDiffData{
+		OldLinesOfCode: len(src),
+		NewLinesOfCode: len(dst),
+		Diffs:          dmp.DiffMainRunes(src, dst, false),
+	}
+	state[DependencyFileDiff] = fileDiffs
+	uastChanges := make([]UASTChange, 1)
+	loadUast := func(name string) *uast.Node {
+		bytes, err := ioutil.ReadFile(path.Join("test_data", name))
+		assert.Nil(t, err)
+		node := uast.Node{}
+		proto.Unmarshal(bytes, &node)
+		return &node
+	}
+	state[DependencyUastChanges] = uastChanges
+	uastChanges[0] = UASTChange{
+		Change: &object.Change{
+			From: object.ChangeEntry{Name: fileName},
+			To:   object.ChangeEntry{Name: fileName}},
+		Before: loadUast("uast1.pb"), After: nil,
+	}
+	fd := fixtureFileDiffRefiner()
+	iresult, err := fd.Consume(state)
+	assert.Nil(t, err)
+	result := iresult[DependencyFileDiff].(map[string]FileDiffData)
+	assert.Len(t, result, 1)
+	assert.Equal(t, fileDiffs[fileName], result[fileName])
+	fileDiffs[fileName] = FileDiffData{
+		OldLinesOfCode: 100,
+		NewLinesOfCode: 100,
+		Diffs:          []diffmatchpatch.Diff{{}},
+	}
+	uastChanges[0] = UASTChange{
+		Change: &object.Change{
+			From: object.ChangeEntry{Name: fileName},
+			To:   object.ChangeEntry{Name: fileName}},
+		Before: loadUast("uast1.pb"), After: loadUast("uast2.pb"),
+	}
+	iresult, err = fd.Consume(state)
+	assert.Nil(t, err)
+	result = iresult[DependencyFileDiff].(map[string]FileDiffData)
+	assert.Len(t, result, 1)
+	assert.Equal(t, fileDiffs[fileName], result[fileName])
+}

tree_diff_test.go

@@ -98,3 +98,15 @@ func TestTreeDiffConsumeFirst(t *testing.T) {
 		assert.Equal(t, action, merkletrie.Insert)
 	}
 }
+
+func TestTreeDiffBadCommit(t *testing.T) {
+	td := fixtureTreeDiff()
+	commit, _ := testRepository.CommitObject(plumbing.NewHash(
+		"2b1ed978194a94edeabbca6de7ff3b5771d4d665"))
+	commit.TreeHash = plumbing.NewHash("0000000000000000000000000000000000000000")
+	deps := map[string]interface{}{}
+	deps["commit"] = commit
+	res, err := td.Consume(deps)
+	assert.Nil(t, res)
+	assert.NotNil(t, err)
+}