Use file named .talismanrc on in-memory fs for tests

Because it's an in-memory filesystem, we can just use a file named
.talismanrc instead of creating and using a temp file.

Authored-by: Owen Nelson <[email protected]>

Author: tw-owen-nelson

detector/filecontent/filecontent_detector.go

@@ -114,7 +114,7 @@ func (fc *FileContentDetector) Test(comparator helpers.IgnoreEvaluator, currentA
 				return
 			}
 
-			if string(addition.Name) == talismanrc.DefaultRCFileName {
+			if string(addition.Name) == talismanrc.RCFileName {
 				content := re.ReplaceAllString(string(addition.Data), "")
 				data := []byte(content)
 				addition.Data = data
@@ -169,7 +169,7 @@ func processContent(c content, threshold severity.Severity, result *helpers.Dete
 			log.WithFields(log.Fields{
 				"filePath": c.path,
 			}).Info(c.contentType.getInfo())
-			if string(c.name) == talismanrc.DefaultRCFileName || !c.severity.ExceedsThreshold(threshold) {
+			if string(c.name) == talismanrc.RCFileName || !c.severity.ExceedsThreshold(threshold) {
 				result.Warn(c.path, "filecontent", fmt.Sprintf(c.contentType.getMessageFormat(), formatForReporting(res)), []string{}, c.severity)
 			} else {
 				result.Fail(c.path, "filecontent", fmt.Sprintf(c.contentType.getMessageFormat(), formatForReporting(res)), []string{}, c.severity)

detector/helpers/detection_results_test.go

@@ -116,18 +116,13 @@ func TestTalismanRCSuggestionWhenThereAreFailures(t *testing.T) {
 
 	// Creating temp file with some content
 	fs := afero.NewMemMapFs()
-	file, err := afero.TempFile(fs, "", "talismanrc")
-	assert.NoError(t, err)
-	ignoreFile := file.Name()
-
 	talismanrc.SetFs__(fs)
-	talismanrc.SetRcFilename__(ignoreFile)
 
 	existingContent := `fileignoreconfig:
 - filename: existing.pem
   checksum: 123444ddssa75333b25b6275f97680604add51b84eb8f4a3b9dcbbc652e6f27ac
 `
-	err = afero.WriteFile(fs, ignoreFile, []byte(existingContent), 0666)
+	err := afero.WriteFile(fs, talismanrc.RCFileName, []byte(existingContent), 0666)
 	assert.NoError(t, err)
 
 	// The tests below depend on the upper configuration which is shared across all three of them. Hence the order in
@@ -137,39 +132,39 @@ func TestTalismanRCSuggestionWhenThereAreFailures(t *testing.T) {
 		prompter.EXPECT().Confirm(gomock.Any()).Return(false).Times(0)
 
 		results.Report(promptContext, "default")
-		bytesFromFile, err := afero.ReadFile(fs, ignoreFile)
+		bytesFromFile, err := afero.ReadFile(fs, talismanrc.RCFileName)
 
 		assert.NoError(t, err)
 		assert.Equal(t, existingContent, string(bytesFromFile))
 	})
 
-	_ = afero.WriteFile(fs, ignoreFile, []byte(existingContent), 0666)
+	_ = afero.WriteFile(fs, talismanrc.RCFileName, []byte(existingContent), 0666)
 	t.Run("when user declines, entry should not be added to talismanrc", func(t *testing.T) {
 		promptContext := prompt.NewPromptContext(true, prompter)
 		prompter.EXPECT().Confirm("Do you want to add some_file.pem with above checksum in talismanrc ?").Return(false)
 		results.Fail("some_file.pem", "filecontent", "Bomb", []string{}, severity.Low)
 
 		results.Report(promptContext, "default")
-		bytesFromFile, err := afero.ReadFile(fs, ignoreFile)
+		bytesFromFile, err := afero.ReadFile(fs, talismanrc.RCFileName)
 
 		assert.NoError(t, err)
 		assert.Equal(t, existingContent, string(bytesFromFile))
 	})
 
-	_ = afero.WriteFile(fs, ignoreFile, []byte(existingContent), 0666)
+	_ = afero.WriteFile(fs, talismanrc.RCFileName, []byte(existingContent), 0666)
 	t.Run("when interactive flag is set to false, it should not ask user", func(t *testing.T) {
 		promptContext := prompt.NewPromptContext(false, prompter)
 		prompter.EXPECT().Confirm(gomock.Any()).Return(false).Times(0)
 		results.Fail("some_file.pem", "filecontent", "Bomb", []string{}, severity.Low)
 
 		results.Report(promptContext, "default")
-		bytesFromFile, err := afero.ReadFile(fs, ignoreFile)
+		bytesFromFile, err := afero.ReadFile(fs, talismanrc.RCFileName)
 
 		assert.NoError(t, err)
 		assert.Equal(t, existingContent, string(bytesFromFile))
 	})
 
-	_ = afero.WriteFile(fs, ignoreFile, []byte(existingContent), 0666)
+	_ = afero.WriteFile(fs, talismanrc.RCFileName, []byte(existingContent), 0666)
 	t.Run("when user confirms, entry should be appended to given ignore file", func(t *testing.T) {
 		promptContext := prompt.NewPromptContext(true, prompter)
 		prompter.EXPECT().Confirm("Do you want to add some_file.pem with above checksum in talismanrc ?").Return(true)
@@ -184,13 +179,13 @@ func TestTalismanRCSuggestionWhenThereAreFailures(t *testing.T) {
 version: "1.0"
 `
 		results.Report(promptContext, "default")
-		bytesFromFile, err := afero.ReadFile(fs, ignoreFile)
+		bytesFromFile, err := afero.ReadFile(fs, talismanrc.RCFileName)
 
 		assert.NoError(t, err)
 		assert.Equal(t, expectedFileContent, string(bytesFromFile))
 	})
 
-	_ = afero.WriteFile(fs, ignoreFile, []byte(existingContent), 0666)
+	_ = afero.WriteFile(fs, talismanrc.RCFileName, []byte(existingContent), 0666)
 	t.Run("when user confirms, entry for existing file should updated", func(t *testing.T) {
 		promptContext := prompt.NewPromptContext(true, prompter)
 		prompter.EXPECT().Confirm("Do you want to add existing.pem with above checksum in talismanrc ?").Return(true)
@@ -203,13 +198,13 @@ version: "1.0"
 version: "1.0"
 `
 		results.Report(promptContext, "default")
-		bytesFromFile, err := afero.ReadFile(fs, ignoreFile)
+		bytesFromFile, err := afero.ReadFile(fs, talismanrc.RCFileName)
 
 		assert.NoError(t, err)
 		assert.Equal(t, expectedFileContent, string(bytesFromFile))
 	})
 
-	_ = afero.WriteFile(fs, ignoreFile, []byte(existingContent), 0666)
+	_ = afero.WriteFile(fs, talismanrc.RCFileName, []byte(existingContent), 0666)
 	t.Run("when user confirms for multiple entries, they should be appended to given ignore file", func(t *testing.T) {
 		promptContext := prompt.NewPromptContext(true, prompter)
 		prompter.EXPECT().Confirm("Do you want to add some_file.pem with above checksum in talismanrc ?").Return(true)
@@ -228,12 +223,12 @@ version: "1.0"
 version: "1.0"
 `
 		results.Report(promptContext, "default")
-		bytesFromFile, err := afero.ReadFile(fs, ignoreFile)
+		bytesFromFile, err := afero.ReadFile(fs, talismanrc.RCFileName)
 
 		assert.NoError(t, err)
 		assert.Equal(t, expectedFileContent, string(bytesFromFile))
 	})
 
-	err = fs.Remove(ignoreFile)
+	err = fs.Remove(talismanrc.RCFileName)
 	assert.NoError(t, err)
 }

detector/pattern/pattern_detector.go

@@ -88,7 +88,7 @@ func (detector PatternDetector) processMatch(match match, result *helpers.Detect
 	for _, detectionWithSeverity := range match.detections {
 		for _, detection := range detectionWithSeverity.detections {
 			if detection != "" {
-				if string(match.name) == talismanrc.DefaultRCFileName || !detectionWithSeverity.severity.ExceedsThreshold(threshold) {
+				if string(match.name) == talismanrc.RCFileName || !detectionWithSeverity.severity.ExceedsThreshold(threshold) {
 					log.WithFields(log.Fields{
 						"filePath": match.path,
 						"pattern":  detection,

talismanrc/rc_file.go

@@ -10,19 +10,18 @@ import (
 )
 
 const (
-	//DefaultRCFileName represents the name of default file in which all the ignore patterns are configured in new version
-	DefaultRCVersion         = "1.0"
-	DefaultRCFileName string = ".talismanrc"
+	// RCFileName represents the name of default file in which all the ignore patterns are configured in new version
+	RCFileName       = ".talismanrc"
+	DefaultRCVersion = "1.0"
 )
 
 var (
-	fs                = afero.NewOsFs()
-	currentRCFileName = DefaultRCFileName
+	fs = afero.NewOsFs()
 )
 
 // Load creates a TalismanRC struct based on a .talismanrc file, if present
 func Load() (*TalismanRC, error) {
-	fileContents, err := afero.ReadFile(fs, currentRCFileName)
+	fileContents, err := afero.ReadFile(fs, RCFileName)
 	if err != nil {
 		// File does not exist or is not readable, proceed as if there is no .talismanrc
 		fileContents = []byte{}
@@ -46,16 +45,12 @@ func talismanRCFromYaml(fileContents []byte) (*TalismanRC, error) {
 
 func (tRC *TalismanRC) saveToFile() {
 	ignoreEntries, _ := yaml.Marshal(&tRC)
-	err := afero.WriteFile(fs, currentRCFileName, ignoreEntries, 0644)
+	err := afero.WriteFile(fs, RCFileName, ignoreEntries, 0644)
 	if err != nil {
-		logr.Errorf("error writing to %s: %s", currentRCFileName, err)
+		logr.Errorf("error writing to %s: %s", RCFileName, err)
 	}
 }
 
 func SetFs__(_fs afero.Fs) {
 	fs = _fs
 }
-
-func SetRcFilename__(rcFileName string) {
-	currentRCFileName = rcFileName
-}

talismanrc/rc_file_test.go

@@ -11,21 +11,18 @@ import (
 
 func TestLoadingFromFile(t *testing.T) {
 	fs := afero.NewMemMapFs()
-	file, err := afero.TempFile(fs, "", DefaultRCFileName)
-	assert.NoError(t, err, "Problem setting up test .talismanrc?")
-	talismanRCFile := file.Name()
 	SetFs__(fs)
 
 	t.Run("Creates an empty TalismanRC if .talismanrc file doesn't exist", func(t *testing.T) {
-		SetRcFilename__("not-a-file")
+		talismanRCFileExists, _ := afero.Exists(fs, RCFileName)
+		assert.False(t, talismanRCFileExists, ".talismanrc file should NOT exist for this test!")
 		emptyRC, err := Load()
 		assert.NoError(t, err, "Should not error if there is a problem reading the file")
 		assert.Equal(t, &TalismanRC{Version: DefaultRCVersion}, emptyRC)
 	})
 
 	t.Run("Loads all valid TalismanRC fields", func(t *testing.T) {
-		SetRcFilename__(talismanRCFile)
-		err = afero.WriteFile(fs, talismanRCFile, []byte(fullyConfiguredTalismanRC), 0666)
+		err := afero.WriteFile(fs, RCFileName, []byte(fullyConfiguredTalismanRC), 0666)
 		assert.NoError(t, err, "Problem setting up test .talismanrc?")
 
 		talismanRCFromFile, _ := Load()
@@ -45,8 +42,6 @@ func TestLoadingFromFile(t *testing.T) {
 		}
 		assert.Equal(t, expectedTalismanRC, talismanRCFromFile)
 	})
-
-	SetRcFilename__(DefaultRCFileName)
 }
 
 func TestWritingToFile(t *testing.T) {
@@ -55,22 +50,22 @@ func TestWritingToFile(t *testing.T) {
 	SetFs__(fs)
 
 	t.Run("When there is no .talismanrc file", func(t *testing.T) {
-		talismanRCFileExists, _ := afero.Exists(fs, DefaultRCFileName)
+		talismanRCFileExists, _ := afero.Exists(fs, RCFileName)
 		assert.False(t, talismanRCFileExists, "Problem setting up tests")
 		tRC.saveToFile()
-		talismanRCFileExists, _ = afero.Exists(fs, DefaultRCFileName)
+		talismanRCFileExists, _ = afero.Exists(fs, RCFileName)
 		assert.True(t, talismanRCFileExists, "Should have created a new .talismanrc file")
-		fileContents, _ := afero.ReadFile(fs, DefaultRCFileName)
+		fileContents, _ := afero.ReadFile(fs, RCFileName)
 		assert.Equal(t, "version: \"1.0\"\n", string(fileContents))
 	})
 
 	t.Run("When there already is a .talismanrc file", func(t *testing.T) {
-		err := afero.WriteFile(fs, DefaultRCFileName, []byte("Some existing content to overwrite"), 0666)
+		err := afero.WriteFile(fs, RCFileName, []byte("Some existing content to overwrite"), 0666)
 		assert.NoError(t, err, "Problem setting up tests")
 		tRC.saveToFile()
-		talismanRCFileExists, _ := afero.Exists(fs, DefaultRCFileName)
+		talismanRCFileExists, _ := afero.Exists(fs, RCFileName)
 		assert.True(t, talismanRCFileExists, "Should have created a new .talismanrc file")
-		fileContents, _ := afero.ReadFile(fs, DefaultRCFileName)
+		fileContents, _ := afero.ReadFile(fs, RCFileName)
 		assert.Equal(t, "version: \"1.0\"\n", string(fileContents))
 	})
 }

talismanrc/talismanrc_test.go

@@ -126,12 +126,7 @@ func TestIgnoringDetectors(t *testing.T) {
 
 func TestAddingFileIgnores(t *testing.T) {
 	fs := afero.NewMemMapFs()
-	file, err := afero.TempFile(fs, "", DefaultRCFileName)
-	assert.NoError(t, err)
-	ignoreFile := file.Name()
-
 	SetFs__(fs)
-	SetRcFilename__(ignoreFile)
 
 	ignoreConfig := FileIgnoreConfig{
 		FileName: "Foo",
@@ -141,11 +136,11 @@ func TestAddingFileIgnores(t *testing.T) {
 		initialRCConfig.AddIgnores([]FileIgnoreConfig{ignoreConfig})
 		newRCConfig, _ := Load()
 		assert.Equal(t, 1, len(newRCConfig.FileIgnoreConfig))
-		_ = fs.Remove(ignoreFile)
+		_ = fs.Remove(RCFileName)
 	})
 
 	t.Run("When .talismanrc has lots of configurations", func(t *testing.T) {
-		err = afero.WriteFile(fs, ignoreFile, []byte(fullyConfiguredTalismanRC), 0666)
+		err := afero.WriteFile(fs, RCFileName, []byte(fullyConfiguredTalismanRC), 0666)
 		assert.NoError(t, err)
 
 		initialRCConfig, _ := Load()