Add typos tests

Signed-off-by: Vadim Markovtsev <vadim@sourced.tech>

Author: vmarkovtsev

leaves/research/typos.go

@@ -55,6 +55,10 @@ const (
 	// DefaultMaximumAllowedTypoDistance is the default value of the maximum Levenshtein distance
 	// between two identifiers to consider them a typo-fix pair.
 	DefaultMaximumAllowedTypoDistance = 4
+	// ConfigTyposDatasetMaximumAllowedDistance is the name of the configuration option
+	// (`TyposDatasetBuilder.Configure()`) which sets the maximum Levenshtein distance between
+	// two identifiers to consider them a typo-fix pair.
+	ConfigTyposDatasetMaximumAllowedDistance = "TyposDatasetBuilder.MaximumAllowedDistance"
 )
 
 // Name of this PipelineItem. Uniquely identifies the type, used for mapping keys, etc.
@@ -80,11 +84,22 @@ func (tdb *TyposDatasetBuilder) Requires() []string {
 
 // ListConfigurationOptions returns the list of changeable public properties of this PipelineItem.
 func (tdb *TyposDatasetBuilder) ListConfigurationOptions() []core.ConfigurationOption {
-	return nil
+	options := [...]core.ConfigurationOption{{
+		Name: ConfigTyposDatasetMaximumAllowedDistance,
+		Description: "Maximum Levenshtein distance between two identifiers to consider them " +
+			"a typo-fix pair.",
+		Flag:    "typos-max-distance",
+		Type:    core.IntConfigurationOption,
+		Default: DefaultMaximumAllowedTypoDistance},
+	}
+	return options[:]
 }
 
 // Configure sets the properties previously published by ListConfigurationOptions().
 func (tdb *TyposDatasetBuilder) Configure(facts map[string]interface{}) error {
+	if val, exists := facts[ConfigTyposDatasetMaximumAllowedDistance].(int); exists {
+		tdb.MaximumAllowedDistance = val
+	}
 	return nil
 }
 
@@ -101,7 +116,7 @@ func (tdb *TyposDatasetBuilder) Description() string {
 // Initialize resets the temporary caches and prepares this PipelineItem for a series of Consume()
 // calls. The repository which is going to be analysed is supplied as an argument.
 func (tdb *TyposDatasetBuilder) Initialize(repository *git.Repository) error {
-	if tdb.MaximumAllowedDistance == 0 {
+	if tdb.MaximumAllowedDistance <= 0 {
 		tdb.MaximumAllowedDistance = DefaultMaximumAllowedTypoDistance
 	}
 	tdb.lcontext = &levenshtein.Context{}

leaves/research/typos_test.go

@@ -1 +1,208 @@
 package research
+
+import (
+	"bytes"
+	"testing"
+
+	"github.com/gogo/protobuf/proto"
+	"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/hercules.v9/internal/core"
+	"gopkg.in/src-d/hercules.v9/internal/pb"
+	items "gopkg.in/src-d/hercules.v9/internal/plumbing"
+	uast_items "gopkg.in/src-d/hercules.v9/internal/plumbing/uast"
+	"gopkg.in/src-d/hercules.v9/internal/test"
+)
+
+func TestTyposDatasetMeta(t *testing.T) {
+	tdb := TyposDatasetBuilder{}
+	assert.Equal(t, tdb.Name(), "TyposDataset")
+	assert.Len(t, tdb.Provides(), 0)
+	required := [...]string{
+		uast_items.DependencyUastChanges, items.DependencyFileDiff, items.DependencyBlobCache}
+	for _, name := range required {
+		assert.Contains(t, tdb.Requires(), name)
+	}
+	opts := tdb.ListConfigurationOptions()
+	assert.Len(t, opts, 1)
+	assert.Equal(t, opts[0].Name, ConfigTyposDatasetMaximumAllowedDistance)
+	assert.Equal(t, opts[0].Type, core.IntConfigurationOption)
+	assert.Equal(t, tdb.Flag(), "typos-dataset")
+}
+
+func TestTyposDatasetRegistration(t *testing.T) {
+	summoned := core.Registry.Summon((&TyposDatasetBuilder{}).Name())
+	assert.Len(t, summoned, 1)
+	assert.Equal(t, summoned[0].Name(), "TyposDataset")
+	leaves := core.Registry.GetLeaves()
+	matched := false
+	for _, tp := range leaves {
+		if tp.Flag() == (&TyposDatasetBuilder{}).Flag() {
+			matched = true
+			break
+		}
+	}
+	assert.True(t, matched)
+}
+
+func TestTyposDatasetConfigure(t *testing.T) {
+	tdb := TyposDatasetBuilder{}
+	facts := map[string]interface{}{}
+	facts[ConfigTyposDatasetMaximumAllowedDistance] = 5
+	assert.Nil(t, tdb.Configure(facts))
+	assert.Equal(t, tdb.MaximumAllowedDistance, 5)
+	facts = map[string]interface{}{}
+	assert.Nil(t, tdb.Configure(facts))
+	assert.Equal(t, tdb.MaximumAllowedDistance, 5)
+}
+
+func AddHash(t *testing.T, cache map[plumbing.Hash]*items.CachedBlob, hash string) {
+	objhash := plumbing.NewHash(hash)
+	blob, err := test.Repository.BlobObject(objhash)
+	assert.Nil(t, err)
+	cb := &items.CachedBlob{Blob: *blob}
+	err = cb.Cache()
+	assert.Nil(t, err)
+	cache[objhash] = cb
+}
+
+func TestTyposDatasetConsume(t *testing.T) {
+	deps := map[string]interface{}{}
+	cache := map[plumbing.Hash]*items.CachedBlob{}
+	AddHash(t, cache, "b9a12fd144274c99c7c9a0a32a0268f8b36d2f2c")
+	AddHash(t, cache, "d5f8e61069136f3578457a3131800ede353527b8")
+	AddHash(t, cache, "75bb0a09fc01db55d7322f0fae523453edba7846")
+	deps[items.DependencyBlobCache] = cache
+	changes := make(object.Changes, 2)
+	treeFrom, _ := test.Repository.TreeObject(plumbing.NewHash(
+		"eac25f9126db00e38fa72a59d49773a84580d4ce"))
+	treeTo, _ := test.Repository.TreeObject(plumbing.NewHash(
+		"828467b465864b1f757dcec9a034be49030fc8b9"))
+	changes[0] = &object.Change{From: object.ChangeEntry{
+		Name: "file_test.go",
+		Tree: treeFrom,
+		TreeEntry: object.TreeEntry{
+			Name: "file_test.go",
+			Mode: 0100644,
+			Hash: plumbing.NewHash("75bb0a09fc01db55d7322f0fae523453edba7846"),
+		},
+	}, To: object.ChangeEntry{
+		Name: "file_test.go",
+		Tree: treeTo,
+		TreeEntry: object.TreeEntry{
+			Name: "file_test.go",
+			Mode: 0100644,
+			Hash: plumbing.NewHash("75bb0a09fc01db55d7322f0fae523453edba7846"),
+		},
+	}}
+	changes[1] = &object.Change{From: object.ChangeEntry{}, To: object.ChangeEntry{
+		Name: "blob_cache_test.go",
+		Tree: treeTo,
+		TreeEntry: object.TreeEntry{
+			Name: "blob_cache_test.go",
+			Mode: 0100644,
+			Hash: plumbing.NewHash("b9a12fd144274c99c7c9a0a32a0268f8b36d2f2c"),
+		},
+	},
+	}
+	deps[items.DependencyTreeChanges] = changes
+	deps[core.DependencyCommit], _ = test.Repository.CommitObject(plumbing.NewHash(
+		"84165d3b02647fae12cc026c7a580045246e8c98"))
+	deps[core.DependencyIsMerge] = false
+	uastItem := &uast_items.Extractor{}
+	assert.Nil(t, uastItem.Initialize(test.Repository))
+	uastResult, err := uastItem.Consume(deps)
+	assert.Nil(t, err)
+	deps[uast_items.DependencyUasts] = uastResult[uast_items.DependencyUasts]
+	uastChanges := &uast_items.Changes{}
+	assert.Nil(t, uastChanges.Initialize(test.Repository))
+	_, err = uastChanges.Consume(deps)
+	assert.Nil(t, err)
+	changes[0].To.TreeEntry.Hash = plumbing.NewHash("d5f8e61069136f3578457a3131800ede353527b8")
+	uastResult, err = uastItem.Consume(deps)
+	assert.Nil(t, err)
+	deps[uast_items.DependencyUasts] = uastResult[uast_items.DependencyUasts]
+	changesResult, err := uastChanges.Consume(deps)
+	assert.Nil(t, err)
+	deps[uast_items.DependencyUastChanges] = changesResult[uast_items.DependencyUastChanges]
+	fd := &items.FileDiff{}
+	assert.Nil(t, fd.Initialize(test.Repository))
+	diffResult, err := fd.Consume(deps)
+	assert.Nil(t, err)
+	deps[items.DependencyFileDiff] = diffResult[items.DependencyFileDiff]
+
+	tbd := &TyposDatasetBuilder{}
+	assert.Nil(t, tbd.Initialize(test.Repository))
+	res, err := tbd.Consume(deps)
+	assert.Nil(t, res)
+	assert.Nil(t, err)
+	assert.Len(t, tbd.typos, 4)
+	assert.Equal(t, tbd.typos[0].Wrong, "TestZeroInitializeFile")
+	assert.Equal(t, tbd.typos[0].Correct, "TestZeroInitialize")
+	assert.Equal(t, tbd.typos[0].Commit, plumbing.NewHash(
+		"84165d3b02647fae12cc026c7a580045246e8c98"))
+	assert.Equal(t, tbd.typos[0].File, "file_test.go")
+	assert.Equal(t, tbd.typos[0].Line, 74)
+
+	deps[core.DependencyIsMerge] = true
+	res, err = tbd.Consume(deps)
+	assert.Nil(t, res)
+	assert.Nil(t, err)
+	assert.Len(t, tbd.typos, 4)
+}
+
+func fixtureTyposDataset() *TyposDatasetBuilder {
+	tdb := TyposDatasetBuilder{}
+	tdb.Initialize(test.Repository)
+	tdb.typos = append(tdb.typos, Typo{
+		Wrong:   "Fo",
+		Correct: "Foo",
+		Commit:  plumbing.ZeroHash,
+		File:    "bar.go",
+		Line:    7,
+	})
+	return &tdb
+}
+
+func TestTyposDatasetFinalize(t *testing.T) {
+	tdb := fixtureTyposDataset()
+	tdb.typos = append(tdb.typos, tdb.typos[0])
+	x := tdb.Finalize().(TyposResult)
+	assert.Len(t, x.Typos, 1)
+	assert.Equal(t, x.Typos[0], Typo{
+		Wrong:   "Fo",
+		Correct: "Foo",
+		Commit:  plumbing.ZeroHash,
+		File:    "bar.go",
+		Line:    7,
+	})
+}
+
+func TestTyposDatasetSerialize(t *testing.T) {
+	ca := fixtureTyposDataset()
+	res := ca.Finalize().(TyposResult)
+	buffer := &bytes.Buffer{}
+	err := ca.Serialize(res, false, buffer)
+	assert.Nil(t, err)
+	assert.Equal(t, `  - wrong: Fo
+    correct: Foo
+    commit: 0000000000000000000000000000000000000000
+    file: bar.go
+    line: 7
+`, buffer.String())
+
+	buffer = &bytes.Buffer{}
+	err = ca.Serialize(res, true, buffer)
+	assert.Nil(t, err)
+	msg := pb.TyposDataset{}
+	assert.Nil(t, proto.Unmarshal(buffer.Bytes(), &msg))
+	assert.Len(t, msg.Typos, 1)
+	assert.Equal(t, *msg.Typos[0], pb.Typo{
+		Wrong:   "Fo",
+		Correct: "Foo",
+		Commit:  "0000000000000000000000000000000000000000",
+		File:    "bar.go",
+		Line:    7,
+	})
+}