Add tests for logger initialization

Signed-off-by: Robert Lin <robertlin1@gmail.com>

Gopkg.lock

@@ -277,9 +277,12 @@
   revision = "f187355171c936ac84a82793659ebb4936bc1c23"
 
 [[projects]]
-  digest = "1:e7e3141ecc5f7eeae9a1a4438044614049ccdd57a302b8793dec0c29202cadce"
+  digest = "1:c5cc4981dbab46f68150ea9772532a7c26f8109112c7302d7cc0a5011eef3276"
   name = "github.com/stretchr/testify"
-  packages = ["assert"]
+  packages = [
+    "assert",
+    "require",
+  ]
   pruneopts = "UT"
   revision = "5b93e2dc01fd8fbf32aa74a198b0ebe78f6f6b6f"
 
@@ -632,6 +635,7 @@
     "github.com/spf13/cobra",
     "github.com/spf13/pflag",
     "github.com/stretchr/testify/assert",
+    "github.com/stretchr/testify/require",
     "golang.org/x/crypto/ssh/terminal",
     "gopkg.in/bblfsh/client-go.v3",
     "gopkg.in/bblfsh/client-go.v3/tools",

internal/core/pipeline.go

@@ -658,11 +658,15 @@ func (pipeline *Pipeline) Initialize(facts map[string]interface{}) error {
 	if facts == nil {
 		facts = map[string]interface{}{}
 	}
+
+	// set logger from facts, otherwise set the pipeline's logger as the logger
+	// to be used by all analysis tasks by setting the fact
 	if l, exists := facts[ConfigLogger].(Logger); exists {
 		pipeline.l = l
 	} else {
 		facts[ConfigLogger] = pipeline.l
 	}
+
 	if _, exists := facts[ConfigPipelineCommits]; !exists {
 		var err error
 		facts[ConfigPipelineCommits], err = pipeline.Commits(false)

internal/core/pipeline_test.go

@@ -11,6 +11,7 @@ import (
 	"time"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	"gopkg.in/src-d/go-git.v4"
 	"gopkg.in/src-d/go-git.v4/plumbing"
 	"gopkg.in/src-d/go-git.v4/plumbing/object"
@@ -32,6 +33,7 @@ type testPipelineItem struct {
 	InitializeRaises bool
 	InitializePanics bool
 	ConsumePanics    bool
+	Logger           Logger
 }
 
 func (item *testPipelineItem) Name() string {
@@ -51,6 +53,9 @@ func (item *testPipelineItem) Configure(facts map[string]interface{}) error {
 	if item.ConfigureRaises {
 		return errors.New("test1")
 	}
+	if l, ok := facts[ConfigLogger].(Logger); ok {
+		item.Logger = l
+	}
 	return nil
 }
 
@@ -272,13 +277,13 @@ func TestPipelineErrors(t *testing.T) {
 	pipeline.AddItem(item)
 	item.ConfigureRaises = true
 	err := pipeline.Initialize(map[string]interface{}{})
-	assert.NotNil(t, err)
+	assert.Error(t, err)
 	assert.Contains(t, err.Error(), "configure")
 	assert.Contains(t, err.Error(), "test1")
 	item.ConfigureRaises = false
 	item.InitializeRaises = true
 	err = pipeline.Initialize(map[string]interface{}{})
-	assert.NotNil(t, err)
+	assert.Error(t, err)
 	assert.Contains(t, err.Error(), "initialize")
 	assert.Contains(t, err.Error(), "test2")
 	item.InitializeRaises = false
@@ -286,17 +291,42 @@ func TestPipelineErrors(t *testing.T) {
 	assert.Panics(t, func() { pipeline.Initialize(map[string]interface{}{}) })
 }
 
+func TestPipelineInitialize(t *testing.T) {
+	t.Run("without logger fact", func(t *testing.T) {
+		pipeline := NewPipeline(test.Repository)
+		item := &testPipelineItem{}
+		pipeline.AddItem(item)
+		require.NoError(t, pipeline.Initialize(map[string]interface{}{}))
+		// pipeline logger should be initialized, and item logger should be the same
+		require.NotNil(t, pipeline.l)
+		assert.Equal(t, pipeline.l, item.Logger)
+	})
+
+	t.Run("with logger fact", func(t *testing.T) {
+		pipeline := NewPipeline(test.Repository)
+		item := &testPipelineItem{}
+		logger := NewLogger()
+		pipeline.AddItem(item)
+		require.NoError(t, pipeline.Initialize(map[string]interface{}{
+			ConfigLogger: logger,
+		}))
+		// pipeline logger should be set, and the item logger should be the same
+		assert.Equal(t, logger, pipeline.l)
+		assert.Equal(t, logger, item.Logger)
+	})
+}
+
 func TestPipelineRun(t *testing.T) {
 	pipeline := NewPipeline(test.Repository)
 	item := &testPipelineItem{}
 	pipeline.AddItem(item)
-	assert.Nil(t, pipeline.Initialize(map[string]interface{}{}))
+	assert.NoError(t, pipeline.Initialize(map[string]interface{}{}))
 	assert.True(t, item.Initialized)
 	commits := make([]*object.Commit, 1)
 	commits[0], _ = test.Repository.CommitObject(plumbing.NewHash(
 		"af9ddc0db70f09f3f27b4b98e415592a7485171c"))
 	result, err := pipeline.Run(commits)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Equal(t, 2, len(result))
 	assert.Equal(t, item, result[item].(*testPipelineItem))
 	common := result[nil].(*CommonAnalysisResult)

internal/plumbing/diff.go

@@ -88,8 +88,6 @@ func (diff *FileDiff) ListConfigurationOptions() []core.ConfigurationOption {
 func (diff *FileDiff) Configure(facts map[string]interface{}) error {
 	if l, exists := facts[core.ConfigLogger].(core.Logger); exists {
 		diff.l = l
-	} else {
-		diff.l = core.NewLogger()
 	}
 	if val, exists := facts[ConfigFileDiffDisableCleanup].(bool); exists {
 		diff.CleanupDisabled = val

internal/plumbing/diff_test.go

@@ -27,10 +27,11 @@ func TestFileDiffMeta(t *testing.T) {
 	assert.Len(t, fd.ListConfigurationOptions(), 2)
 	assert.Equal(t, fd.ListConfigurationOptions()[0].Name, items.ConfigFileDiffDisableCleanup)
 	assert.Equal(t, fd.ListConfigurationOptions()[1].Name, items.ConfigFileWhitespaceIgnore)
-	facts := map[string]interface{}{}
-	facts[items.ConfigFileDiffDisableCleanup] = true
-	facts[items.ConfigFileWhitespaceIgnore] = true
-	fd.Configure(facts)
+	assert.NoError(t, fd.Configure(map[string]interface{}{
+		core.ConfigLogger:                  core.NewLogger(),
+		items.ConfigFileDiffDisableCleanup: true,
+		items.ConfigFileWhitespaceIgnore:   true,
+	}))
 	assert.True(t, fd.CleanupDisabled)
 	assert.True(t, fd.WhitespaceIgnore)
 }

internal/plumbing/identity/identity_test.go

@@ -41,6 +41,11 @@ func TestIdentityDetectorMeta(t *testing.T) {
 	opts := id.ListConfigurationOptions()
 	assert.Len(t, opts, 1)
 	assert.Equal(t, opts[0].Name, ConfigIdentityDetectorPeopleDictPath)
+	logger := core.NewLogger()
+	assert.NoError(t, id.Configure(map[string]interface{}{
+		core.ConfigLogger: logger,
+	}))
+	assert.Equal(t, logger, id.l)
 }
 
 func TestIdentityDetectorConfigure(t *testing.T) {

internal/plumbing/languages.go

@@ -54,8 +54,6 @@ func (langs *LanguagesDetection) ListConfigurationOptions() []core.Configuration
 func (langs *LanguagesDetection) Configure(facts map[string]interface{}) error {
 	if l, exists := facts[core.ConfigLogger].(core.Logger); exists {
 		langs.l = l
-	} else {
-		langs.l = core.NewLogger()
 	}
 	return nil
 }

internal/plumbing/languages_test.go

@@ -20,8 +20,13 @@ func TestLanguagesDetectionMeta(t *testing.T) {
 	assert.Equal(t, ls.Requires()[1], DependencyBlobCache)
 	opts := ls.ListConfigurationOptions()
 	assert.Len(t, opts, 0)
-	assert.Nil(t, ls.Configure(nil))
-	assert.Nil(t, ls.Initialize(nil))
+	assert.NoError(t, ls.Configure(nil))
+	logger := core.NewLogger()
+	assert.NoError(t, ls.Configure(map[string]interface{}{
+		core.ConfigLogger: logger,
+	}))
+	assert.Equal(t, logger, ls.l)
+	assert.NoError(t, ls.Initialize(nil))
 }
 
 func TestLanguagesDetectionRegistration(t *testing.T) {

internal/plumbing/line_stats_test.go

@@ -23,7 +23,9 @@ func TestLinesStatsMeta(t *testing.T) {
 	assert.Equal(t, ra.Requires()[1], items.DependencyBlobCache)
 	assert.Equal(t, ra.Requires()[2], items.DependencyFileDiff)
 	assert.Nil(t, ra.ListConfigurationOptions())
-	assert.Nil(t, ra.Configure(nil))
+	assert.NoError(t, ra.Configure(map[string]interface{}{
+		core.ConfigLogger: core.NewLogger(),
+	}))
 	for _, f := range ra.Fork(10) {
 		assert.Equal(t, f, ra)
 	}

internal/plumbing/renames_test.go

@@ -34,12 +34,17 @@ func TestRenameAnalysisMeta(t *testing.T) {
 	assert.Len(t, opts, 1)
 	assert.Equal(t, opts[0].Name, ConfigRenameAnalysisSimilarityThreshold)
 	ra.SimilarityThreshold = 0
-	facts := map[string]interface{}{}
-	facts[ConfigRenameAnalysisSimilarityThreshold] = 70
-	ra.Configure(facts)
+
+	assert.NoError(t, ra.Configure(map[string]interface{}{
+		ConfigRenameAnalysisSimilarityThreshold: 70,
+	}))
 	assert.Equal(t, ra.SimilarityThreshold, 70)
-	delete(facts, ConfigRenameAnalysisSimilarityThreshold)
-	ra.Configure(facts)
+
+	logger := core.NewLogger()
+	assert.NoError(t, ra.Configure(map[string]interface{}{
+		core.ConfigLogger: logger,
+	}))
+	assert.Equal(t, logger, ra.l)
 	assert.Equal(t, ra.SimilarityThreshold, 70)
 }
 

internal/plumbing/ticks_test.go

@@ -31,7 +31,11 @@ func TestTicksSinceStartMeta(t *testing.T) {
 	assert.Equal(t, tss.Provides()[0], DependencyTick)
 	assert.Equal(t, len(tss.Requires()), 0)
 	assert.Len(t, tss.ListConfigurationOptions(), 1)
-	tss.Configure(map[string]interface{}{})
+	logger := core.NewLogger()
+	assert.NoError(t, tss.Configure(map[string]interface{}{
+		core.ConfigLogger: logger,
+	}))
+	assert.Equal(t, logger, tss.l)
 }
 
 func TestTicksSinceStartRegistration(t *testing.T) {

internal/plumbing/tree_diff_test.go

@@ -26,6 +26,11 @@ func TestTreeDiffMeta(t *testing.T) {
 	assert.Equal(t, td.Provides()[0], DependencyTreeChanges)
 	opts := td.ListConfigurationOptions()
 	assert.Len(t, opts, 4)
+	logger := core.NewLogger()
+	assert.NoError(t, td.Configure(map[string]interface{}{
+		core.ConfigLogger: logger,
+	}))
+	assert.Equal(t, logger, td.l)
 }
 
 func TestTreeDiffConfigure(t *testing.T) {

internal/plumbing/uast/diff_refiner_test.go

@@ -37,6 +37,11 @@ func TestFileDiffRefinerMeta(t *testing.T) {
 	features := fd.Features()
 	assert.Len(t, features, 1)
 	assert.Equal(t, features[0], FeatureUast)
+	logger := core.NewLogger()
+	assert.NoError(t, fd.Configure(map[string]interface{}{
+		core.ConfigLogger: logger,
+	}))
+	assert.Equal(t, logger, fd.l)
 }
 
 func TestFileDiffRefinerRegistration(t *testing.T) {

internal/plumbing/uast/uast_test.go

@@ -60,6 +60,11 @@ func TestUASTExtractorMeta(t *testing.T) {
 	feats := exr.Features()
 	assert.Len(t, feats, 1)
 	assert.Equal(t, feats[0], FeatureUast)
+	logger := core.NewLogger()
+	assert.NoError(t, exr.Configure(map[string]interface{}{
+		core.ConfigLogger: logger,
+	}))
+	assert.Equal(t, logger, exr.l)
 }
 
 func TestUASTExtractorConfiguration(t *testing.T) {
@@ -239,6 +244,11 @@ func TestUASTChangesMeta(t *testing.T) {
 	assert.Equal(t, ch.Requires()[1], items.DependencyTreeChanges)
 	opts := ch.ListConfigurationOptions()
 	assert.Len(t, opts, 0)
+	logger := core.NewLogger()
+	assert.NoError(t, ch.Configure(map[string]interface{}{
+		core.ConfigLogger: logger,
+	}))
+	assert.Equal(t, logger, ch.l)
 }
 
 func TestUASTChangesRegistration(t *testing.T) {
@@ -369,6 +379,11 @@ func TestUASTChangesSaverMeta(t *testing.T) {
 	assert.Len(t, opts, 1)
 	assert.Equal(t, opts[0].Name, ConfigUASTChangesSaverOutputPath)
 	assert.Equal(t, chs.Flag(), "dump-uast-changes")
+	logger := core.NewLogger()
+	assert.NoError(t, chs.Configure(map[string]interface{}{
+		core.ConfigLogger: logger,
+	}))
+	assert.Equal(t, logger, chs.l)
 }
 
 func TestUASTChangesSaverConfiguration(t *testing.T) {

leaves/burndown_test.go

@@ -57,6 +57,11 @@ func TestBurndownMeta(t *testing.T) {
 	}
 	assert.Len(t, opts, matches)
 	assert.Equal(t, bd.Flag(), "burndown")
+	logger := core.NewLogger()
+	assert.NoError(t, bd.Configure(map[string]interface{}{
+		core.ConfigLogger: logger,
+	}))
+	assert.Equal(t, logger, bd.l)
 }
 
 func TestBurndownConfigure(t *testing.T) {

leaves/comment_sentiment_test.go

@@ -55,6 +55,11 @@ func TestCommentSentimentMeta(t *testing.T) {
 	}
 	assert.Len(t, opts, matches)
 	assert.Equal(t, sent.Flag(), "sentiment")
+	logger := core.NewLogger()
+	assert.NoError(t, sent.Configure(map[string]interface{}{
+		core.ConfigLogger: logger,
+	}))
+	assert.Equal(t, logger, sent.l)
 }
 
 func TestCommentSentimentConfigure(t *testing.T) {

leaves/commits_test.go

@@ -28,6 +28,11 @@ func TestCommitsMeta(t *testing.T) {
 	opts := ca.ListConfigurationOptions()
 	assert.Len(t, opts, 0)
 	assert.Equal(t, ca.Flag(), "commits-stat")
+	logger := core.NewLogger()
+	assert.NoError(t, ca.Configure(map[string]interface{}{
+		core.ConfigLogger: logger,
+	}))
+	assert.Equal(t, logger, ca.l)
 }
 
 func TestCommitsRegistration(t *testing.T) {

leaves/couples_test.go

@@ -33,6 +33,11 @@ func TestCouplesMeta(t *testing.T) {
 	assert.Equal(t, c.Requires()[1], plumbing.DependencyTreeChanges)
 	assert.Equal(t, c.Flag(), "couples")
 	assert.Len(t, c.ListConfigurationOptions(), 0)
+	logger := core.NewLogger()
+	assert.NoError(t, c.Configure(map[string]interface{}{
+		core.ConfigLogger: logger,
+	}))
+	assert.Equal(t, logger, c.l)
 }
 
 func TestCouplesRegistration(t *testing.T) {

leaves/devs_test.go

@@ -41,6 +41,11 @@ func TestDevsMeta(t *testing.T) {
 	assert.Equal(t, d.ListConfigurationOptions()[0].Type, core.BoolConfigurationOption)
 	assert.Equal(t, d.ListConfigurationOptions()[0].Default, false)
 	assert.True(t, len(d.Description()) > 0)
+	logger := core.NewLogger()
+	assert.NoError(t, d.Configure(map[string]interface{}{
+		core.ConfigLogger: logger,
+	}))
+	assert.Equal(t, logger, d.l)
 }
 
 func TestDevsRegistration(t *testing.T) {

leaves/file_history_test.go

@@ -32,6 +32,11 @@ func TestFileHistoryMeta(t *testing.T) {
 	assert.Equal(t, fh.Requires()[2], identity.DependencyAuthor)
 	assert.Len(t, fh.ListConfigurationOptions(), 0)
 	assert.Nil(t, fh.Configure(nil))
+	logger := core.NewLogger()
+	assert.NoError(t, fh.Configure(map[string]interface{}{
+		core.ConfigLogger: logger,
+	}))
+	assert.Equal(t, logger, fh.l)
 }
 
 func TestFileHistoryRegistration(t *testing.T) {

leaves/research/typos_test.go

@@ -34,6 +34,11 @@ func TestTyposDatasetMeta(t *testing.T) {
 	assert.Equal(t, opts[0].Name, ConfigTyposDatasetMaximumAllowedDistance)
 	assert.Equal(t, opts[0].Type, core.IntConfigurationOption)
 	assert.Equal(t, tdb.Flag(), "typos-dataset")
+	logger := core.NewLogger()
+	assert.NoError(t, tdb.Configure(map[string]interface{}{
+		core.ConfigLogger: logger,
+	}))
+	assert.Equal(t, logger, tdb.l)
 }
 
 func TestTyposDatasetRegistration(t *testing.T) {

leaves/shotness_test.go

@@ -45,12 +45,18 @@ func TestShotnessMeta(t *testing.T) {
 	assert.Nil(t, sh.Configure(nil))
 	assert.Equal(t, sh.XpathStruct, DefaultShotnessXpathStruct)
 	assert.Equal(t, sh.XpathName, DefaultShotnessXpathName)
-	facts := map[string]interface{}{}
-	facts[ConfigShotnessXpathStruct] = "xpath!"
-	facts[ConfigShotnessXpathName] = "another!"
-	assert.Nil(t, sh.Configure(facts))
+	assert.NoError(t, sh.Configure(map[string]interface{}{
+		ConfigShotnessXpathStruct: "xpath!",
+		ConfigShotnessXpathName:   "another!",
+	}))
 	assert.Equal(t, sh.XpathStruct, "xpath!")
 	assert.Equal(t, sh.XpathName, "another!")
+
+	logger := core.NewLogger()
+	assert.NoError(t, sh.Configure(map[string]interface{}{
+		core.ConfigLogger: logger,
+	}))
+	assert.Equal(t, logger, sh.l)
 }
 
 func TestShotnessRegistration(t *testing.T) {