assert that running whitespace does not change lines of code for old / new but does produce a "different" diff than without it - DK

Signed-off-by: Andrew Kutta <andrew.kutta@gmail.com>

internal/plumbing/diff.go

@@ -24,10 +24,12 @@ const (
 	// the human interpretability of diffs.
 	ConfigFileDiffDisableCleanup = "FileDiff.NoCleanup"
 
-	ConfigFileWhitespaceCleanup = "FileDiff.NoWhitespace"
-
 	// DependencyFileDiff is the name of the dependency provided by FileDiff.
 	DependencyFileDiff = "file_diff"
+
+	// ConfigFileWhitespaceCleanup is the name of the configuration option (FileDiff.Configure())
+	// to suppress whitespace which can lead to detecting formatting changes versus core code changes
+	ConfigFileWhitespaceCleanup = "FileDiff.NoWhitespace"
 )
 
 // FileDiffData is the type of the dependency provided by FileDiff.

internal/plumbing/diff_test.go

@@ -24,12 +24,15 @@ func TestFileDiffMeta(t *testing.T) {
 	assert.Equal(t, len(fd.Requires()), 2)
 	assert.Equal(t, fd.Requires()[0], items.DependencyTreeChanges)
 	assert.Equal(t, fd.Requires()[1], items.DependencyBlobCache)
-	assert.Len(t, fd.ListConfigurationOptions(), 1)
+	assert.Len(t, fd.ListConfigurationOptions(), 2)
 	assert.Equal(t, fd.ListConfigurationOptions()[0].Name, items.ConfigFileDiffDisableCleanup)
+	assert.Equal(t, fd.ListConfigurationOptions()[1].Name, items.ConfigFileWhitespaceCleanup)
 	facts := map[string]interface{}{}
 	facts[items.ConfigFileDiffDisableCleanup] = true
+	facts[items.ConfigFileWhitespaceCleanup] = true
 	fd.Configure(facts)
 	assert.True(t, fd.CleanupDisabled)
+	assert.True(t, fd.WhitespaceIgnore)
 }
 
 func TestFileDiffRegistration(t *testing.T) {
@@ -272,6 +275,48 @@ func TestFileDiffDarkMagic(t *testing.T) {
 	assert.Equal(t, magicDiffs.NewLinesOfCode, plainDiffs.NewLinesOfCode)
 }
 
+func TestFileDiffWhitespaceDarkMagic(t *testing.T) {
+	fd := fixtures.FileDiff()
+	deps := map[string]interface{}{}
+	cache := map[plumbing.Hash]*items.CachedBlob{}
+	items.AddHash(t, cache, "448eb3f312849b0ca766063d06b09481c987b309") // 1.java
+	items.AddHash(t, cache, "3312c92f3e8bdfbbdb30bccb6acd1b85bc338dfc") // 2.java
+	deps[items.DependencyBlobCache] = cache
+	changes := make(object.Changes, 1)
+	treeFrom, _ := test.Repository.TreeObject(plumbing.NewHash(
+		"f02289bfe843388a1bb3c7dea210374082dd86b9"))
+	treeTo, _ := test.Repository.TreeObject(plumbing.NewHash(
+		"eca91acf1fd828f20dcb653a061d8c97d965bc6c"))
+	changes[0] = &object.Change{From: object.ChangeEntry{
+		Name: "test.java",
+		Tree: treeFrom,
+		TreeEntry: object.TreeEntry{
+			Name: "test.java",
+			Mode: 0100644,
+			Hash: plumbing.NewHash("448eb3f312849b0ca766063d06b09481c987b309"),
+		},
+	}, To: object.ChangeEntry{
+		Name: "test.java",
+		Tree: treeTo,
+		TreeEntry: object.TreeEntry{
+			Name: "test.java",
+			Mode: 0100644,
+			Hash: plumbing.NewHash("3312c92f3e8bdfbbdb30bccb6acd1b85bc338dfc"),
+		},
+	}}
+	deps[items.DependencyTreeChanges] = changes
+	res, err := fd.Consume(deps)
+	assert.Nil(t, err)
+	magicDiffs := res[items.DependencyFileDiff].(map[string]items.FileDiffData)["test.java"]
+	fd.WhitespaceIgnore = true
+	res, err = fd.Consume(deps)
+	assert.Nil(t, err)
+	plainDiffs := res[items.DependencyFileDiff].(map[string]items.FileDiffData)["test.java"]
+	assert.NotEqual(t, magicDiffs.Diffs, plainDiffs.Diffs)
+	assert.Equal(t, magicDiffs.OldLinesOfCode, plainDiffs.OldLinesOfCode)
+	assert.Equal(t, magicDiffs.NewLinesOfCode, plainDiffs.NewLinesOfCode)
+}
+
 func TestFileDiffFork(t *testing.T) {
 	fd1 := fixtures.FileDiff()
 	clones := fd1.Fork(1)
@@ -279,4 +324,4 @@ func TestFileDiffFork(t *testing.T) {
 	fd2 := clones[0].(*items.FileDiff)
 	assert.True(t, fd1 == fd2)
 	fd1.Merge([]core.PipelineItem{fd2})
-}
+}