refactor: integration tests to CommitSuite (#9)

These longer tests now run the setup before each test to ensure that they have a fresh cloned repository each time

Author: jdockerty

today_test.go

@@ -8,6 +8,7 @@ import (
 	"github.com/go-git/go-git/v5"
 	"github.com/go-git/go-git/v5/plumbing/object"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/suite"
 )
 
 // TODO: Cleanup the larger tests which use setupRepo func into `suite` tests.
@@ -30,137 +31,105 @@ const (
 	twoDaysSince   time.Duration = 48 * time.Hour
 )
 
-func TestValidatePathsProducesErrorWithInvalidDir(t *testing.T) {
-	invalidPath := []string{"/does/not/exist"}
-	err := validatePaths(invalidPath)
-	assert.Error(t, err)
+// Involves all tests which require reading/writing of a commit, this is requires the setup and teardown
+// of a directory which is tracked by git.
+type CommitSuite struct {
+	suite.Suite
+	Repo     *git.Repository // Repo to use within the test suite.
+	Worktree *git.Worktree
 }
 
-func TestValidatePathsProducesErrorWithNoGitDir(t *testing.T) {
-	gitDirNotExist := []string{"/tmp"}
-	err := validatePaths(gitDirNotExist)
-	assert.Error(t, err)
-}
+func setupRepo(url string, t *testing.T) (*git.Repository, error) {
 
-func TestValidatePathsWithGitDir(t *testing.T) {
-	gitDirExists := []string{currentDir} // Current directory is tracked by git
-	err := validatePaths(gitDirExists)
-	assert.Nil(t, err)
-}
+	r, err := git.PlainClone(t.TempDir(), false, &git.CloneOptions{
+		URL:               url,
+		RecurseSubmodules: git.DefaultSubmoduleRecursionDepth,
+	})
+	if err != nil {
+		return nil, err
+	}
 
-func TestGetRepositories(t *testing.T) {
-	gitDir := []string{currentDir}
-	_, err := getRepositories(gitDir)
-	assert.Nil(t, err)
+	return r, nil
 }
 
-func TestDoesContainAuthor(t *testing.T) {
-	testCommit := &object.Commit{
-		Author: object.Signature{
-			Name:  "testUser",
-			Email: "[email protected]",
-			When:  time.Now().UTC(),
-		},
+// Setup before every test, whilst this might be a little inefficient for getting the repository before
+// every test, we do so to ensure that our commit history is completely fresh from previous test commits.
+func (suite *CommitSuite) SetupTest() {
+	r, err := setupRepo(thisRepo, suite.T())
+	if err != nil {
+		suite.FailNow("Unable to setup CommitSuite repo: %s\n", err)
 	}
 
-	got := containsAuthor(testCommit, "testUser")
-	assert.True(t, got)
-}
+	suite.Repo = r
 
-func TestDoesNotContainAuthor(t *testing.T) {
-	testCommit := &object.Commit{
-		Author: object.Signature{
-			Name:  "testUser",
-			Email: "[email protected]",
-			When:  time.Now().UTC(),
-		},
+	w, err := r.Worktree()
+	if err != nil {
+		suite.FailNow("Unable to setup CommitSuite worktree: %s\n", err)
 	}
-
-	got := containsAuthor(testCommit, "John")
-	assert.False(t, got)
+	suite.Worktree = w
 }
 
-func TestFullContainsAuthor(t *testing.T) {
-
-	assert := assert.New(t)
+func (suite *CommitSuite) TestFullContainsAuthor() {
 
-	r, err := setupRepo(thisRepo, t)
-	assert.Nil(err)
+	assert := assert.New(suite.T())
 
-	w, err := r.Worktree()
+	w, err := suite.Repo.Worktree()
 	assert.Nil(err)
 
 	_, err = w.Commit("TEST", testSignature)
 	assert.Nil(err)
 
 	m := make(map[string]*git.Repository, 1)
-	m["today"] = r
+	m["today"] = suite.Repo
 	msgs, err := getCommitMessages(m, testSignature.Author.Name, true, oneMinuteSince)
 	assert.Nil(err)
 
 	assert.Contains(msgs, "today")
 	assert.GreaterOrEqual(2, len(msgs)) // Our 2 commits here and any others which are within 48 hours.
 
 }
-func TestFullContainsAuthorHasNoCommits(t *testing.T) {
 
-	assert := assert.New(t)
+func (suite *CommitSuite) TestFullContainsAuthorHasNoCommits() {
 
-	r, err := setupRepo(thisRepo, t)
-	assert.Nil(err)
+	assert := assert.New(suite.T())
 
-	w, err := r.Worktree()
-	assert.Nil(err)
-
-	_, err = w.Commit("TEST", testSignature)
+	_, err := suite.Worktree.Commit("TEST", testSignature)
 	assert.Nil(err)
 
 	m := make(map[string]*git.Repository, 1)
-	m["today"] = r
+	m["today"] = suite.Repo
 	msgs, err := getCommitMessages(m, "INVALID_COMMIT_AUTHOR", true, oneMinuteSince)
 	assert.Nil(err)
 
 	assert.Contains(msgs, "today")
 	assert.Equal(0, len(msgs["today"]))
-
 }
 
-func TestNoResultsForZeroSinceValue(t *testing.T) {
-
-	assert := assert.New(t)
+func (suite *CommitSuite) TestNoResultsForZeroSinceValue() {
 
-	r, err := setupRepo(thisRepo, t)
-	assert.Nil(err)
+	assert := assert.New(suite.T())
 
-	w, err := r.Worktree()
-	assert.Nil(err)
-
-	_, err = w.Commit("TEST", testSignature)
+	_, err := suite.Worktree.Commit("TEST", testSignature)
 	assert.Nil(err)
 
 	m := make(map[string]*git.Repository, 1)
-	m["today"] = r
+	m["today"] = suite.Repo
 	msgs, err := getCommitMessages(m, "", true, zeroTime)
 	assert.Nil(err)
 
 	assert.Equal(0, len(msgs["today"]))
 
 }
-func TestResultsForMinimalSinceValue(t *testing.T) {
-
-	assert := assert.New(t)
 
-	r, err := setupRepo(thisRepo, t)
-	assert.Nil(err)
+func (suite *CommitSuite) TestResultsForMinimalSinceValue() {
 
-	w, err := r.Worktree()
-	assert.Nil(err)
+	assert := assert.New(suite.T())
 
-	_, err = w.Commit("TEST", testSignature)
+	_, err := suite.Worktree.Commit("TEST", testSignature)
 	assert.Nil(err)
 
 	m := make(map[string]*git.Repository, 1)
-	m["today"] = r
+	m["today"] = suite.Repo
 	msgs, err := getCommitMessages(m, "", true, oneMinuteSince)
 	assert.Nil(err)
 
@@ -170,23 +139,18 @@ func TestResultsForMinimalSinceValue(t *testing.T) {
 
 }
 
-func TestResultsForLargerSinceValue(t *testing.T) {
+func (suite *CommitSuite) TestResultsForLargerSinceValue() {
 
-	assert := assert.New(t)
+	assert := assert.New(suite.T())
 
-	r, err := setupRepo(thisRepo, t)
+	_, err := suite.Worktree.Commit("TEST", testSignature)
 	assert.Nil(err)
 
-	w, err := r.Worktree()
-	assert.Nil(err)
-
-	_, err = w.Commit("TEST", testSignature)
-	assert.Nil(err)
-	_, err = w.Commit("TEST2", testSignature)
+	_, err = suite.Worktree.Commit("TEST2", testSignature)
 	assert.Nil(err)
 
 	m := make(map[string]*git.Repository, 1)
-	m["today"] = r
+	m["today"] = suite.Repo
 	msgs, err := getCommitMessages(m, "", true, twoDaysSince)
 	assert.Nil(err)
 
@@ -195,57 +159,86 @@ func TestResultsForLargerSinceValue(t *testing.T) {
 
 }
 
-func TestShortCommitMessage(t *testing.T) {
+func (suite *CommitSuite) TestShortCommitMessage() {
 
-	assert := assert.New(t)
-
-	r, err := setupRepo(thisRepo, t)
-	assert.Nil(err)
-
-	w, err := r.Worktree()
-	assert.Nil(err)
+	assert := assert.New(suite.T())
 
-	_, err = w.Commit("TEST\nNOT SEEN", testSignature)
+	_, err := suite.Worktree.Commit("TEST\nNOT SEEN", testSignature)
 	assert.Nil(err)
 
 	m := make(map[string]*git.Repository, 1)
-	m["today"] = r
+	m["today"] = suite.Repo
 	msgs, err := getCommitMessages(m, "", true, oneMinuteSince)
 	assert.Nil(err)
 
 	assert.Equal(4, len(msgs["today"][0])) // Length of 'TEST' = 4
 }
 
-func TestLongCommitMessage(t *testing.T) {
+func (suite *CommitSuite) TestLongCommitMessage() {
 
-	assert := assert.New(t)
+	assert := assert.New(suite.T())
 
-	r, err := setupRepo(thisRepo, t)
-	assert.Nil(err)
-
-	w, err := r.Worktree()
-	assert.Nil(err)
-
-	_, err = w.Commit("TEST\nSEEN", testSignature)
+	_, err := suite.Worktree.Commit("TEST\nSEEN", testSignature)
 	assert.Nil(err)
 
 	m := make(map[string]*git.Repository, 1)
-	m["today"] = r
+	m["today"] = suite.Repo
 	msgs, err := getCommitMessages(m, "", false, oneMinuteSince)
 	assert.Nil(err)
 
 	assert.Equal("TEST\nSEEN", msgs["today"][0])
 }
 
-func setupRepo(url string, t *testing.T) (*git.Repository, error) {
+func TestCommitSuite(t *testing.T) {
+	suite.Run(t, new(CommitSuite))
+}
 
-	r, err := git.PlainClone(t.TempDir(), false, &git.CloneOptions{
-		URL:               url,
-		RecurseSubmodules: git.DefaultSubmoduleRecursionDepth,
-	})
-	if err != nil {
-		return nil, err
+func TestValidatePathsProducesErrorWithInvalidDir(t *testing.T) {
+	invalidPath := []string{"/does/not/exist"}
+	err := validatePaths(invalidPath)
+	assert.Error(t, err)
+}
+
+func TestValidatePathsProducesErrorWithNoGitDir(t *testing.T) {
+	gitDirNotExist := []string{"/tmp"}
+	err := validatePaths(gitDirNotExist)
+	assert.Error(t, err)
+}
+
+func TestValidatePathsWithGitDir(t *testing.T) {
+	gitDirExists := []string{currentDir} // Current directory is tracked by git
+	err := validatePaths(gitDirExists)
+	assert.Nil(t, err)
+}
+
+func TestGetRepositories(t *testing.T) {
+	gitDir := []string{currentDir}
+	_, err := getRepositories(gitDir)
+	assert.Nil(t, err)
+}
+
+func TestDoesContainAuthor(t *testing.T) {
+	testCommit := &object.Commit{
+		Author: object.Signature{
+			Name:  "testUser",
+			Email: "[email protected]",
+			When:  time.Now().UTC(),
+		},
 	}
 
-	return r, nil
+	got := containsAuthor(testCommit, "testUser")
+	assert.True(t, got)
+}
+
+func TestDoesNotContainAuthor(t *testing.T) {
+	testCommit := &object.Commit{
+		Author: object.Signature{
+			Name:  "testUser",
+			Email: "[email protected]",
+			When:  time.Now().UTC(),
+		},
+	}
+
+	got := containsAuthor(testCommit, "John")
+	assert.False(t, got)
 }