Narrow public interface of GitTesting

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

Author: tw-owen-nelson

cmd/acceptance_test.go

@@ -402,7 +402,7 @@ func runTalismanInPrePushMode(git *git_testing.GitTesting) int {
 
 func runTalisman(git *git_testing.GitTesting) int {
 	wd, _ := os.Getwd()
-	os.Chdir(git.GetRoot())
+	os.Chdir(git.Root())
 	defer func() { os.Chdir(wd) }()
 	prompter := prompt.NewPrompt()
 	promptContext := prompt.NewPromptContext(false, prompter)

cmd/checksum_cmd_test.go

@@ -14,7 +14,7 @@ func TestChecksumCalculatorShouldExitSuccess(t *testing.T) {
 		git.CreateFileWithContents("private.pem", "secret")
 		git.CreateFileWithContents("another/private.pem", "secret")
 		git.CreateFileWithContents("sample.txt", "password")
-		os.Chdir(git.GetRoot())
+		os.Chdir(git.Root())
 
 		checksumCmd := NewChecksumCmd([]string{"*.txt"})
 		assert.Equal(t, 0, checksumCmd.Run(), "Expected run() to return 0 as given patterns are found and .talsimanrc is suggested")
@@ -28,7 +28,7 @@ func TestChecksumCalculatorShouldExitFailure(t *testing.T) {
 		git.CreateFileWithContents("private.pem", "secret")
 		git.CreateFileWithContents("another/private.pem", "secret")
 		git.CreateFileWithContents("sample.txt", "password")
-		os.Chdir(git.GetRoot())
+		os.Chdir(git.Root())
 
 		checksumCmd := NewChecksumCmd([]string{"*.java"})
 		assert.Equal(t, 1, checksumCmd.Run(), "Expected run() to return 1 as given patterns are found and .talsimanrc is suggested")
@@ -38,7 +38,7 @@ func TestChecksumCalculatorShouldExitFailure(t *testing.T) {
 
 func TestChecksumCalculatorShouldExitFailureWhenHasherIsEmpty(t *testing.T) {
 	git_testing.DoInTempGitRepo(func(git *git_testing.GitTesting) {
-		checksumCmd := ChecksumCmd{[]string{"*.java"}, nil, git.GetRoot()}
+		checksumCmd := ChecksumCmd{[]string{"*.java"}, nil, git.Root()}
 		assert.Equal(t, 1, checksumCmd.Run(), "Expected run() to return 1 because hasher failed to start")
 	})
 }

cmd/scanner_cmd_test.go

@@ -14,9 +14,9 @@ func TestScannerCmdRunsSuccessfully(t *testing.T) {
 		git.SetupBaselineFiles("simple-file")
 		git.CreateFileWithContents("some-dir/should-be-included.txt", "safeContents")
 		git.AddAndcommit("*", "Start of Scan")
-		os.Chdir(git.GetRoot())
+		os.Chdir(git.Root())
 
-		scannerCmd := NewScannerCmd(true, &talismanrc.TalismanRC{}, git.GetRoot())
+		scannerCmd := NewScannerCmd(true, &talismanrc.TalismanRC{}, git.Root())
 		scannerCmd.Run()
 		assert.Equal(t, 0, scannerCmd.exitStatus(), "Expected ScannerCmd.exitStatus() to return 0 since no secret is found")
 	})
@@ -31,9 +31,9 @@ func TestScannerCmdDetectsSecretAndFails(t *testing.T) {
 		git.AddAndcommit("*", "Removed secret")
 		git.CreateFileWithContents("some-dir/safe-file.txt", "safeContents")
 		git.AddAndcommit("*", "Start of Scan")
-		os.Chdir(git.GetRoot())
+		os.Chdir(git.Root())
 
-		scannerCmd := NewScannerCmd(false, &talismanrc.TalismanRC{}, git.GetRoot())
+		scannerCmd := NewScannerCmd(false, &talismanrc.TalismanRC{}, git.Root())
 		scannerCmd.Run()
 		assert.Equal(t, 1, scannerCmd.exitStatus(), "Expected ScannerCmd.exitStatus() to return 1 since secret present in history")
 	})
@@ -45,10 +45,10 @@ func TestScannerCmdAddingSecretKeyShouldExitZeroIfFileIsWithinConfiguredScope(t
 		git.CreateFileWithContents("go.sum", awsAccessKeyIDExample)
 		git.CreateFileWithContents("go.mod", awsAccessKeyIDExample)
 		git.AddAndcommit("*", "go sum file")
-		os.Chdir(git.GetRoot())
+		os.Chdir(git.Root())
 
 		tRC := &talismanrc.TalismanRC{ScopeConfig: []talismanrc.ScopeConfig{{ScopeName: "go"}}}
-		scannerCmd := NewScannerCmd(false, tRC, git.GetRoot())
+		scannerCmd := NewScannerCmd(false, tRC, git.Root())
 		scannerCmd.Run()
 		assert.Equal(t, 0, scannerCmd.exitStatus(), "Expected ScannerCmd.exitStatus() to return 0 since no secret is found")
 	})
@@ -60,14 +60,14 @@ func TestScannerCmdDetectsSecretAndIgnoresWhileRunningInIgnoreHistoryModeWithVal
 		git.CreateFileWithContents("go.sum", awsAccessKeyIDExample)
 		git.CreateFileWithContents("go.mod", awsAccessKeyIDExample)
 		git.AddAndcommit("*", "go sum file")
-		os.Chdir(git.GetRoot())
+		os.Chdir(git.Root())
 
 		tRC := &talismanrc.TalismanRC{
 			FileIgnoreConfig: []talismanrc.FileIgnoreConfig{
 				{FileName: "go.sum", Checksum: "582093519ae682d5170aecc9b935af7e90ed528c577ecd2c9dd1fad8f4924ab9"},
 				{FileName: "go.mod", Checksum: "8a03b9b61c505ace06d590d2b9b4f4b6fa70136e14c26875ced149180e00d1af"},
 			}}
-		scannerCmd := NewScannerCmd(true, tRC, git.GetRoot())
+		scannerCmd := NewScannerCmd(true, tRC, git.Root())
 		scannerCmd.Run()
 		assert.Equal(t, 0, scannerCmd.exitStatus(), "Expected ScannerCmd.exitStatus() to return 0 since secrets file ignore is enabled")
 	})
@@ -79,14 +79,14 @@ func TestScannerCmdDetectsSecretWhileRunningNormalScanMode(t *testing.T) {
 		git.CreateFileWithContents("go.sum", awsAccessKeyIDExample)
 		git.CreateFileWithContents("go.mod", awsAccessKeyIDExample)
 		git.AddAndcommit("*", "go sum file")
-		os.Chdir(git.GetRoot())
+		os.Chdir(git.Root())
 
 		tRC := &talismanrc.TalismanRC{
 			FileIgnoreConfig: []talismanrc.FileIgnoreConfig{
 				{FileName: "go.sum", Checksum: "582093519ae682d5170aecc9b935af7e90ed528c577ecd2c9dd1fad8f4924ab9"},
 				{FileName: "go.mod", Checksum: "8a03b9b61c505ace06d590d2b9b4f4b6fa70136e14c26875ced149180e00d1af"},
 			}}
-		scannerCmd := NewScannerCmd(false, tRC, git.GetRoot())
+		scannerCmd := NewScannerCmd(false, tRC, git.Root())
 		scannerCmd.Run()
 		assert.Equal(t, 1, scannerCmd.exitStatus(), "Expected ScannerCmd.exitStatus() to return 1 because file ignore is disabled when scanning history")
 	})

git_testing/git_testing.go

@@ -16,7 +16,7 @@ var Logger *logrus.Entry
 
 // GitTesting provides an API for manipulating a git repository during tests
 type GitTesting struct {
-	gitRoot string
+	root string
 }
 
 type GitOperation func(*GitTesting)
@@ -32,36 +32,41 @@ func DoInTempGitRepo(gitOperation GitOperation) {
 func Init() *GitTesting {
 	fs := afero.NewMemMapFs()
 	path, _ := afero.TempDir(fs, afero.GetTempDir(fs, "talisman-test"), "")
-	return InitAt(path)
+	return initAt(path)
 }
 
-// InitAt creates a GitTesting based at the specified path
-func InitAt(gitRoot string) *GitTesting {
+// initAt creates a GitTesting based at the specified path
+func initAt(gitRoot string) *GitTesting {
 	os.MkdirAll(gitRoot, 0777)
 	testingRepo := &GitTesting{gitRoot}
-	output := testingRepo.ExecCommand("git", "init", ".")
+	output := testingRepo.execCommand("git", "init", ".")
 	logrus.Debugf("Git init result %v", string(output))
-	testingRepo.ExecCommand("git", "config", "user.email", "[email protected]")
-	testingRepo.ExecCommand("git", "config", "user.name", "Talisman Test User")
-	testingRepo.ExecCommand("git", "config", "commit.gpgsign", "false")
+	testingRepo.execCommand("git", "config", "user.email", "[email protected]")
+	testingRepo.execCommand("git", "config", "user.name", "Talisman Test User")
+	testingRepo.execCommand("git", "config", "commit.gpgsign", "false")
 	testingRepo.removeHooks()
 	return testingRepo
 }
 
+// Clean removes the directory containing the git repository represented by a GitTesting
+func (git *GitTesting) Clean() {
+	os.RemoveAll(git.root)
+}
+
 func (git *GitTesting) SetupBaselineFiles(filenames ...string) {
-	Logger.Debugf("Creating %v in %s\n", filenames, git.gitRoot)
+	Logger.Debugf("Creating %v in %s\n", filenames, git.root)
 	for _, filename := range filenames {
 		git.CreateFileWithContents(filename, lorem.Sentence(8, 10), lorem.Sentence(8, 10))
 	}
 	git.AddAndcommit("*", "initial commit")
 }
 
 func (git *GitTesting) EarliestCommit() string {
-	return git.ExecCommand("git", "rev-list", "--max-parents=0", "HEAD")
+	return git.execCommand("git", "rev-list", "--max-parents=0", "HEAD")
 }
 
 func (git *GitTesting) LatestCommit() string {
-	return git.ExecCommand("git", "rev-parse", "HEAD")
+	return git.execCommand("git", "rev-parse", "HEAD")
 }
 
 func (git *GitTesting) CreateFileWithContents(filePath string, contents ...string) string {
@@ -125,11 +130,11 @@ func (git *GitTesting) AddAndcommit(fileName string, message string) {
 }
 
 func (git *GitTesting) Add(fileName string) {
-	git.ExecCommand("git", "add", fileName)
+	git.execCommand("git", "add", fileName)
 }
 
 func (git *GitTesting) Commit(fileName string, message string) {
-	git.ExecCommand("git", "commit", "-m", message)
+	git.execCommand("git", "commit", "-m", message)
 }
 
 // GetBlobDetails returns git blob details for a path
@@ -152,14 +157,14 @@ func (git *GitTesting) GetBlobDetails(fileName string) string {
 	return objectHashAndFilename
 }
 
-// ExecCommand executes a command with given arguments in the git repo directory
-func (git *GitTesting) ExecCommand(commandName string, args ...string) string {
+// execCommand executes a command with given arguments in the git repo directory
+func (git *GitTesting) execCommand(commandName string, args ...string) string {
 	var output []byte
 	git.doInGitRoot(func() {
 		result := exec.Command(commandName, args...)
 		var err error
 		output, err = result.Output()
-		summaryMessage := fmt.Sprintf("Command: %s %v\nWorkingDirectory: %s\nOutput %s\nError: %v", commandName, args, git.gitRoot, string(output), err)
+		summaryMessage := fmt.Sprintf("Command: %s %v\nWorkingDirectory: %s\nOutput %s\nError: %v", commandName, args, git.root, string(output), err)
 		git.die(summaryMessage, err)
 		Logger.Debug(summaryMessage)
 	})
@@ -178,23 +183,18 @@ func (git *GitTesting) die(msg string, err error) {
 
 func (git *GitTesting) doInGitRoot(operation func()) {
 	wd, _ := os.Getwd()
-	os.Chdir(git.gitRoot)
+	os.Chdir(git.root)
 	defer func() { os.Chdir(wd) }()
 	operation()
 }
 
-// GetRoot returns the root directory of the git-testing repo
-func (git *GitTesting) GetRoot() string {
-	return git.gitRoot
+// Root returns the root directory of the git-testing repo
+func (git *GitTesting) Root() string {
+	return git.root
 }
 
 // removeHooks removes all file-system hooks from git-test repo.
 // We do this to prevent any user-installed hooks from interfering with tests.
 func (git *GitTesting) removeHooks() {
-	git.ExecCommand("rm", "-rf", ".git/hooks/")
-}
-
-// Clean removes the directory containing the git repository represented by a GitTesting
-func (git *GitTesting) Clean() {
-	os.RemoveAll(git.gitRoot)
+	git.execCommand("rm", "-rf", ".git/hooks/")
 }

git_testing/git_testing_test.go

@@ -24,15 +24,15 @@ func init() {
 
 func TestInitializingANewRepoSetsUpFolderAndGitStructures(t *testing.T) {
 	DoInTempGitRepo(func(repo *GitTesting) {
-		assert.True(t, exists(repo.gitRoot), "GitTesting initialization should create the directory structure required")
-		assert.True(t, isGitRepo(repo.gitRoot), "Repo root does not contain the .git folder")
+		assert.True(t, exists(repo.root), "GitTesting initialization should create the directory structure required")
+		assert.True(t, isGitRepo(repo.root), "Repo root does not contain the .git folder")
 	})
 }
 
 func TestSettingUpBaselineFilesSetsUpACommitInRepo(t *testing.T) {
 	DoInTempGitRepo(func(repo *GitTesting) {
 		repo.SetupBaselineFiles("a.txt", filepath.Join("alice", "bob", "b.txt"))
-		verifyPresenceOfGitRepoWithCommits(t, 1, repo.gitRoot)
+		verifyPresenceOfGitRepoWithCommits(t, 1, repo.root)
 	})
 }
 
@@ -43,7 +43,7 @@ func TestEditingFilesInARepoWorks(t *testing.T) {
 		content := repo.FileContents("a.txt")
 		assert.True(t, strings.HasSuffix(string(content), "monkey see.\nmonkey do."))
 		repo.AddAndcommit("a.txt", "modified content")
-		verifyPresenceOfGitRepoWithCommits(t, 2, repo.gitRoot)
+		verifyPresenceOfGitRepoWithCommits(t, 2, repo.root)
 	})
 }
 
@@ -53,7 +53,7 @@ func TestRemovingFilesInARepoWorks(t *testing.T) {
 		repo.RemoveFile("a.txt")
 		assert.False(t, exists(filepath.Join("data", "testLocation1", "a.txt")), "Unexpected. Deleted file a.txt still exists inside the repo")
 		repo.AddAndcommit("a.txt", "removed it")
-		verifyPresenceOfGitRepoWithCommits(t, 2, repo.gitRoot)
+		verifyPresenceOfGitRepoWithCommits(t, 2, repo.root)
 	})
 }
 

gitrepo/gitrepo_test.go

@@ -31,7 +31,7 @@ func TestNewRepoGetsCreatedWithAbsolutePath(t *testing.T) {
 
 func TestNoAdditionsBetweenSameRef(t *testing.T) {
 	doInRepoWithCommit(func(git *git_testing.GitTesting) {
-		assert.Len(t, RepoLocatedAt(git.GetRoot()).AdditionsWithinRange("HEAD", "HEAD"), 0,
+		assert.Len(t, RepoLocatedAt(git.Root()).AdditionsWithinRange("HEAD", "HEAD"), 0,
 			"There should be no additions between a ref and itself.")
 	})
 }
@@ -42,7 +42,7 @@ func TestGetDiffForStagedFiles(t *testing.T) {
 		git.CreateFileWithContents("new.txt", "created contents")
 		git.Add("a.txt")
 		git.Add("new.txt")
-		repo := RepoLocatedAt(git.GetRoot())
+		repo := RepoLocatedAt(git.Root())
 		additions := repo.GetDiffForStagedFiles()
 
 		if assert.Len(t, additions, 2) {
@@ -80,7 +80,7 @@ func TestGetDiffForStagedFilesWithSpacesInPath(t *testing.T) {
 	doInRepoWithCommit(func(git *git_testing.GitTesting) {
 		git.AppendFileContent("folder b/c.txt", "New content.\n", "Spanning multiple lines, even.")
 		git.Add("folder b/c.txt")
-		repo := RepoLocatedAt(git.GetRoot())
+		repo := RepoLocatedAt(git.Root())
 		additions := repo.GetDiffForStagedFiles()
 
 		if assert.Len(t, additions, 1) {
@@ -109,7 +109,7 @@ func TestAdditionsReturnsEditsAndAdds(t *testing.T) {
 		git.CreateFileWithContents("new.txt", "created contents")
 		git.AddAndcommit("*", "added to lorem-ipsum content with my own stuff!")
 
-		additions := RepoLocatedAt(git.GetRoot()).additionsInLastCommit()
+		additions := RepoLocatedAt(git.Root()).additionsInLastCommit()
 		assert.Len(t, additions, 2)
 		assert.True(t, strings.HasSuffix(string(additions[0].Data), "New content.\nSpanning multiple lines, even."))
 	})
@@ -120,15 +120,15 @@ func TestNewlyAddedFilesAreCountedAsChanges(t *testing.T) {
 		git.CreateFileWithContents("h", "Hello")
 		git.CreateFileWithContents("foo/bar/w", ", World!")
 		git.AddAndcommit("*", "added hello world")
-		assert.Len(t, RepoLocatedAt(git.GetRoot()).additionsInLastCommit(), 2)
+		assert.Len(t, RepoLocatedAt(git.Root()).additionsInLastCommit(), 2)
 	})
 }
 
 func TestOutgoingContentOfNewlyAddedFilesIsAvailableInChanges(t *testing.T) {
 	doInRepoWithCommit(func(git *git_testing.GitTesting) {
 		git.CreateFileWithContents("foo/bar/w", "new contents")
 		git.AddAndcommit("*", "added new files")
-		repo := RepoLocatedAt(git.GetRoot())
+		repo := RepoLocatedAt(git.Root())
 		assert.Len(t, repo.additionsInLastCommit(), 1)
 		assert.True(t, strings.HasSuffix(string(repo.AdditionsWithinRange("HEAD~1", "HEAD")[0].Data), "new contents"))
 	})
@@ -138,7 +138,7 @@ func TestOutgoingContentOfModifiedFilesIsAvailableInChanges(t *testing.T) {
 	doInRepoWithCommit(func(git *git_testing.GitTesting) {
 		git.AppendFileContent("a.txt", "New content.\n", "Spanning multiple lines, even.")
 		git.AddAndcommit("a.txt", "added to lorem-ipsum content with my own stuff!")
-		repo := RepoLocatedAt(git.GetRoot())
+		repo := RepoLocatedAt(git.Root())
 		assert.Len(t, repo.additionsInLastCommit(), 1)
 		assert.True(t, strings.HasSuffix(string(repo.additionsInLastCommit()[0].Data), "New content.\nSpanning multiple lines, even."))
 	})
@@ -152,7 +152,7 @@ func TestMultipleOutgoingChangesToTheSameFileAreAvailableInAdditions(t *testing.
 		git.AppendFileContent("a.txt", "More new content.\n")
 		git.AddAndcommit("a.txt", "added some more new content")
 
-		repo := RepoLocatedAt(git.GetRoot())
+		repo := RepoLocatedAt(git.Root())
 		assert.Len(t, repo.additionsInLastCommit(), 1)
 		assert.True(t, strings.HasSuffix(string(repo.AdditionsWithinRange("HEAD~2", "HEAD")[0].Data), "New content.\nMore new content.\n"))
 	})
@@ -162,14 +162,14 @@ func TestContentOfDeletedFilesIsNotAvailableInChanges(t *testing.T) {
 	doInRepoWithCommit(func(git *git_testing.GitTesting) {
 		git.RemoveFile("a.txt")
 		git.AddAndcommit("a.txt", "Deleted this file. After all, it only had lorem-ipsum content.")
-		assert.Equal(t, 0, len(RepoLocatedAt(git.GetRoot()).additionsInLastCommit()),
+		assert.Equal(t, 0, len(RepoLocatedAt(git.Root()).additionsInLastCommit()),
 			"There should be no additions because there is only an outgoing deletion")
 	})
 }
 
 func TestDiffContainingBinaryFileChangesDoesNotBlowUp(t *testing.T) {
 	doInRepoWithCommit(func(git *git_testing.GitTesting) {
-		repo := RepoLocatedAt(git.GetRoot())
+		repo := RepoLocatedAt(git.Root())
 		exec.Command("cp", "./pixel.jpg", repo.root).Run()
 		git.AddAndcommit("pixel.jpg", "Testing binary diff.")
 		assert.Len(t, repo.additionsInLastCommit(), 1)
@@ -185,7 +185,7 @@ func TestStagedAdditionsIncludeStagedFiles(t *testing.T) {
 		git.AppendFileContent("a.txt", "More new content\n")
 		git.AppendFileContent("alice/bob/b.txt", "New content to b\n")
 
-		stagedAdditions := RepoLocatedAt(git.GetRoot()).StagedAdditions()
+		stagedAdditions := RepoLocatedAt(git.Root()).StagedAdditions()
 		assert.Len(t, stagedAdditions, 1)
 		assert.Equal(t, "a.txt", string(stagedAdditions[0].Name))
 		assert.Equal(t, "New content.\n", string(stagedAdditions[0].Data))
@@ -197,7 +197,7 @@ func TestStagedAdditionsIncludeStagedNewFiles(t *testing.T) {
 		git.CreateFileWithContents("new.txt", "New content.\n")
 		git.Add("new.txt")
 
-		stagedAdditions := RepoLocatedAt(git.GetRoot()).StagedAdditions()
+		stagedAdditions := RepoLocatedAt(git.Root()).StagedAdditions()
 		assert.Len(t, stagedAdditions, 1)
 		assert.Equal(t, "new.txt", string(stagedAdditions[0].Name))
 		assert.Equal(t, "New content.\n", string(stagedAdditions[0].Data))
@@ -209,7 +209,7 @@ func TestStagedAdditionsShouldNotIncludeDeletedFiles(t *testing.T) {
 		git.RemoveFile("a.txt")
 		git.Add(".")
 
-		stagedAdditions := RepoLocatedAt(git.GetRoot()).StagedAdditions()
+		stagedAdditions := RepoLocatedAt(git.Root()).StagedAdditions()
 		assert.Len(t, stagedAdditions, 0)
 	})
 }