Improve code readability #1

Improve mostly common_utils_test.go

internal/commands/common_utils_test.go

@@ -2,8 +2,8 @@ package commands
 
 import (
 	"fmt"
-	"gitlab.com/revalus/grm/internal/config"
 	"os"
+	"path"
 
 	"github.com/go-git/go-billy/v5"
 	"github.com/go-git/go-billy/v5/osfs"
@@ -13,12 +13,9 @@ import (
 	"github.com/go-git/go-git/v5/storage/filesystem"
 )
 
-type TestSetup struct {
+type TestSetupPaths struct {
-	rootFS         billy.Filesystem
+	baseTestDirectory  string
-	baseRepository struct {
+	baseTestRepository string
-		fileSystem billy.Filesystem
-		repo       *git.Repository
-	}
 }
 
 func checkErrorDuringPreparation(err error) {
@@ -28,111 +25,94 @@ func checkErrorDuringPreparation(err error) {
 	}
 }
 
-func createTmpDir() string {
+func createRepositoryForTest() string {
-
+	systemTMPDirectoryWithTestPath := fmt.Sprintf("%v/grmTest", os.TempDir())
-	baseForTMPDir := fmt.Sprintf("%v/grmTest", os.TempDir())
+	if _, ok := os.Stat(systemTMPDirectoryWithTestPath); ok != nil {
-	if _, ok := os.Stat(baseForTMPDir); ok != nil {
+		err := os.Mkdir(systemTMPDirectoryWithTestPath, 0777)
-		err := os.Mkdir(baseForTMPDir, 0777)
 		checkErrorDuringPreparation(err)
 	}
-
+	temporaryDirPath, err := os.MkdirTemp(systemTMPDirectoryWithTestPath, "*")
-	tempDir, err := os.MkdirTemp(baseForTMPDir, "*")
 	checkErrorDuringPreparation(err)
-
+	return temporaryDirPath
-	return tempDir
 }
 
-func getTestSetup() TestSetup {
+// prepareRepositoryDirectories - prepare directories for file (rootRepositoryDirectory) and git metadata (gitMetadataDirectory)
-
+func prepareRepositoryDirectories(dirName string) (billy.Filesystem, billy.Filesystem) {
-	tmpDir := createTmpDir()
+	rootRepositoryDirectory := osfs.New(dirName)
-
+	gitMetadataDirectory, err := rootRepositoryDirectory.Chroot(".git")
-	baseFileSystem := osfs.New(tmpDir)
-
-	initRepositoryFileSystem, err := baseFileSystem.Chroot("worktree")
 	checkErrorDuringPreparation(err)
 
-	directoryForGitMetadata, err := initRepositoryFileSystem.Chroot(".git")
+	return rootRepositoryDirectory, gitMetadataDirectory
+}
+
+func prepareBasicRepository() TestSetupPaths {
+
+	temporaryDirPath := createRepositoryForTest()
+
+	// Create an interface of abstraction over filesystem to provide tests over multiple systems
+	// baseTestsDirectory - provides to main directory where new directories might be created
+	baseTestsDirectory := osfs.New(temporaryDirPath)
+	rootRepositoryDirectory, gitMetadataDirectory := prepareRepositoryDirectories(baseTestsDirectory.Root() + "/base_repository")
+
+	repository, err := git.Init(filesystem.NewStorage(
+		gitMetadataDirectory,
+		cache.NewObjectLRUDefault()),
+		rootRepositoryDirectory,
+	)
 	checkErrorDuringPreparation(err)
 
-	repository, err := git.Init(filesystem.NewStorage(directoryForGitMetadata, cache.NewObjectLRUDefault()), initRepositoryFileSystem)
+	testFile, err := rootRepositoryDirectory.Create("TestFile.txt")
 	checkErrorDuringPreparation(err)
 
-	fileForFirstCommit, err := initRepositoryFileSystem.Create("TestFile.txt")
+	_, err = testFile.Write([]byte("foo-conent"))
-	checkErrorDuringPreparation(err)
-
-	_, err = fileForFirstCommit.Write([]byte("foo-conent"))
 	checkErrorDuringPreparation(err)
 
 	repositoryWorkTree, err := repository.Worktree()
 	checkErrorDuringPreparation(err)
 
-	repositoryWorkTree.Add(fileForFirstCommit.Name())
+	_, err = repositoryWorkTree.Add(testFile.Name())
-	_, err = repositoryWorkTree.Commit("First commit", &git.CommitOptions{})
-
 	checkErrorDuringPreparation(err)
 
-	return TestSetup{
+	_, err = repositoryWorkTree.Commit("First commit", &git.CommitOptions{})
-		baseRepository: struct {
+	checkErrorDuringPreparation(err)
-			fileSystem billy.Filesystem
+
-			repo       *git.Repository
+	return TestSetupPaths{
-		}{
+		baseTestDirectory:  baseTestsDirectory.Root(),
-			fileSystem: initRepositoryFileSystem,
+		baseTestRepository: rootRepositoryDirectory.Root(),
-			repo:       repository,
-		},
-		rootFS: baseFileSystem,
 	}
 
 }
 
 func makeCommit(wk *git.Worktree, commitMessage string) {
-
 	_, err := wk.Commit(commitMessage, &git.CommitOptions{})
 	checkErrorDuringPreparation(err)
-
 }
 
-func getFSForLocalRepo(dirName string, baseFileSystem billy.Filesystem) (billy.Filesystem, *filesystem.Storage) {
+// createAndCloneRepository - create sub-repository with cloned base repository required to verify sync command
-	fsForLocalRepo, err := baseFileSystem.Chroot(dirName)
+func createAndCloneRepository(repositoryName string, paths TestSetupPaths) *git.Repository {
-	checkErrorDuringPreparation(err)
-	fsForMetadata, err := fsForLocalRepo.Chroot(".git")
-	checkErrorDuringPreparation(err)
-	storageForTestRepo := filesystem.NewStorage(fsForMetadata, cache.NewObjectLRUDefault())
-	return fsForLocalRepo, storageForTestRepo
-}
 
-func getBaseForTestingSyncCommand() (StatusChecker, *git.Repository, config.RepositoryConfig, TestSetup) {
+	baseGitRepository, gitMetadataDirectory := prepareRepositoryDirectories(
-	tmpDirWithInitialRepository := getTestSetup()
+		path.Join(paths.baseTestDirectory, repositoryName),
-	dirNameForLocalRepository := "testRepo"
+	)
-	fsForLocalRepo, storageForTestRepo := getFSForLocalRepo(dirNameForLocalRepository, tmpDirWithInitialRepository.rootFS)
 
-	fakeLocalRepository, err := git.Clone(storageForTestRepo, fsForLocalRepo, &git.CloneOptions{
+	storageForSubRepository := filesystem.NewStorage(gitMetadataDirectory, cache.NewObjectLRUDefault())
-		URL: tmpDirWithInitialRepository.baseRepository.fileSystem.Root(),
+	fakeLocalRepository, err := git.Clone(storageForSubRepository, baseGitRepository, &git.CloneOptions{
+		URL: paths.baseTestRepository,
 	})
 	checkErrorDuringPreparation(err)
-
+	return fakeLocalRepository
-	sc := StatusChecker{
-		workspace: tmpDirWithInitialRepository.rootFS.Root(),
-	}
-
-	repoCfg := config.RepositoryConfig{
-		Name: "test",
-		Src:  tmpDirWithInitialRepository.baseRepository.fileSystem.Root(),
-		Dest: dirNameForLocalRepository,
-	}
-
-	return sc, fakeLocalRepository, repoCfg, tmpDirWithInitialRepository
 }
 
-func getBaseForTestingSyncMultipleRemote() (StatusChecker, *git.Repository, config.RepositoryConfig) {
+func addLocalRepositoryAsAFakeRemoteRepository(repository *git.Repository, baseTestRepositoryPath string) error {
-	sc, fakeLocalRepository, repoCfg, tmpDirWithInitialRepository := getBaseForTestingSyncCommand()
 
-	fakeLocalRepository.CreateRemote(&gitcfg.RemoteConfig{
+	_, err := repository.CreateRemote(&gitcfg.RemoteConfig{
 		Name: "subremote",
-		URLs: []string{tmpDirWithInitialRepository.baseRepository.fileSystem.Root()},
+		URLs: []string{baseTestRepositoryPath},
 	})
-
+	if err != nil {
-	fakeLocalRepository.Fetch(&git.FetchOptions{
+		return err
+	}
+	return repository.Fetch(&git.FetchOptions{
 		RemoteName: "subremote",
 	})
-	return sc, fakeLocalRepository, repoCfg
 }

internal/commands/status_cmd.go

@@ -6,6 +6,7 @@ import (
 	"github.com/go-git/go-git/v5/plumbing"
 	"github.com/go-git/go-git/v5/plumbing/object"
 	"gitlab.com/revalus/grm/internal/config"
+	"path"
 	"sort"
 )
 
@@ -20,7 +21,7 @@ func NewStatusChecker(workspace string) StatusChecker {
 }
 
 func findNumberOfCommitDiffs(srcCommit *object.Commit, dstCommit *object.Commit) int {
-
+	// This function is a helper function to get only five latest items, based on given commit
 	getFiveElementsFromHashes := func(commit *object.Commit, hashedSlice *[]string) *object.Commit {
 
 		var err error
@@ -36,6 +37,7 @@ func findNumberOfCommitDiffs(srcCommit *object.Commit, dstCommit *object.Commit)
 		return commit
 	}
 
+	// Compare diff between sources by hash list (the same hash list must be present to assume the end of changes)
 	getRangeDiff := func(listFist, listSecond []string) (int, bool) {
 		diffRange := 0
 
@@ -54,6 +56,8 @@ func findNumberOfCommitDiffs(srcCommit *object.Commit, dstCommit *object.Commit)
 
 	baseCommitHashes := []string{}
 	destCommitHashes := []string{}
+
+	// Try to find all differences, limit only to five last changes to avoid reading whole repository at once
 	for {
 
 		if srcCommit != nil {
@@ -80,8 +84,8 @@ func (sc StatusChecker) Command(repoCfg config.RepositoryConfig) CommandStatus {
 		Error:   false,
 	}
 
-	destPath := fmt.Sprintf("%v/%v", sc.workspace, repoCfg.Dest)
+	repositoryPath := path.Join(sc.workspace, repoCfg.Dest)
-	repo, err := git.PlainOpen(destPath)
+	repo, err := git.PlainOpen(repositoryPath)
 
 	if err != nil {
 		cmdStatus.Error = true

internal/commands/status_cmd_test.go

@@ -2,7 +2,10 @@ package commands
 
 import (
 	"fmt"
+	"github.com/go-git/go-git/v5/plumbing/cache"
+	"github.com/go-git/go-git/v5/storage/filesystem"
 	"gitlab.com/revalus/grm/internal/config"
+	"path"
 	"testing"
 
 	"github.com/go-git/go-billy/v5/memfs"
@@ -12,10 +15,10 @@ import (
 )
 
 func TestIfBranchesAreEqual(t *testing.T) {
-	tmpDirWithInitialRepository := getTestSetup()
+	pathsToTest := prepareBasicRepository()
 
 	fakeLocalRepo, err := git.Clone(memory.NewStorage(), memfs.New(), &git.CloneOptions{
-		URL: tmpDirWithInitialRepository.baseRepository.fileSystem.Root(),
+		URL: pathsToTest.baseTestRepository,
 	})
 	checkErrorDuringPreparation(err)
 
@@ -42,9 +45,9 @@ func TestIfBranchesAreEqual(t *testing.T) {
 
 func TestIfCurrentBranchIsDifferent(t *testing.T) {
 
-	tmpDirWithInitialRepository := getTestSetup()
+	pathsToTest := prepareBasicRepository()
 	fakeLocalRepo, err := git.Clone(memory.NewStorage(), memfs.New(), &git.CloneOptions{
-		URL: tmpDirWithInitialRepository.baseRepository.fileSystem.Root(),
+		URL: pathsToTest.baseTestRepository,
 	})
 	checkErrorDuringPreparation(err)
 
@@ -85,28 +88,21 @@ func TestIfCurrentBranchIsDifferent(t *testing.T) {
 
 	result = findNumberOfCommitDiffs(currentBranchCommit, remoteBranchCommit)
 	if result != 15 {
-		t.Errorf("Expected to get 5 changes, instead of this got %v", result)
+		t.Errorf("Expected to get 15 changes, instead of this got %v", result)
 	}
 }
 
 func TestCommandRepositoryDoesNotExists(t *testing.T) {
 
-	tmpDirWithInitialRepository := getTestSetup()
+	pathsToTest := prepareBasicRepository()
-	fsForLocalRepo, storageForTestRepo := getFSForLocalRepo("noMatterValue", tmpDirWithInitialRepository.rootFS)
-
-	_, err := git.Clone(storageForTestRepo, fsForLocalRepo, &git.CloneOptions{
-		URL: tmpDirWithInitialRepository.baseRepository.fileSystem.Root(),
-	})
-	checkErrorDuringPreparation(err)
-
 	sc := StatusChecker{
-		workspace: tmpDirWithInitialRepository.rootFS.Root(),
+		workspace: pathsToTest.baseTestDirectory,
 	}
 
 	repoCfg := config.RepositoryConfig{
 		Name: "test",
-		Src:  tmpDirWithInitialRepository.baseRepository.fileSystem.Root(),
+		Src:  pathsToTest.baseTestRepository,
-		Dest: tmpDirWithInitialRepository.rootFS.Root(),
+		Dest: pathsToTest.baseTestDirectory,
 	}
 
 	repoStatus := sc.Command(repoCfg)
@@ -125,12 +121,15 @@ func TestCommandRepositoryDoesNotExists(t *testing.T) {
 
 func TestCommandRepositoryNoRemoteBranch(t *testing.T) {
 
-	tmpDirWithInitialRepository := getTestSetup()
+	pathsToTest := prepareBasicRepository()
-	dirNameForLocalRepository := "testRepo"
+	dirNameForLocalRepository := "sub-repository"
-	fsForLocalRepo, storageForTestRepo := getFSForLocalRepo(dirNameForLocalRepository, tmpDirWithInitialRepository.rootFS)
+	fsForLocalRepo, gitMetadataDirectory := prepareRepositoryDirectories(
+		path.Join(pathsToTest.baseTestDirectory, dirNameForLocalRepository),
+	)
+	storageForTestRepo := filesystem.NewStorage(gitMetadataDirectory, cache.NewObjectLRUDefault())
 
 	fakeLocalRepository, err := git.Clone(storageForTestRepo, fsForLocalRepo, &git.CloneOptions{
-		URL: tmpDirWithInitialRepository.baseRepository.fileSystem.Root(),
+		URL: pathsToTest.baseTestRepository,
 	})
 	checkErrorDuringPreparation(err)
 
@@ -138,12 +137,12 @@ func TestCommandRepositoryNoRemoteBranch(t *testing.T) {
 	checkErrorDuringPreparation(err)
 
 	sc := StatusChecker{
-		workspace: tmpDirWithInitialRepository.rootFS.Root(),
+		workspace: pathsToTest.baseTestDirectory,
 	}
 
 	repoCfg := config.RepositoryConfig{
 		Name: "test",
-		Src:  tmpDirWithInitialRepository.baseRepository.fileSystem.Root(),
+		Src:  pathsToTest.baseTestRepository,
 		Dest: dirNameForLocalRepository,
 	}
 
@@ -164,7 +163,21 @@ func TestCommandRepositoryNoRemoteBranch(t *testing.T) {
 
 func TestCommandAllCorrectWithoutChanges(t *testing.T) {
 
-	sc, _, repoCfg, _ := getBaseForTestingSyncCommand()
+	pathsToTest := prepareBasicRepository()
+	subRepositoryDirectoryName := "sub-repository"
+
+	// Get new empty repository to compare with base repository
+	createAndCloneRepository(subRepositoryDirectoryName, pathsToTest)
+
+	sc := StatusChecker{
+		workspace: pathsToTest.baseTestDirectory,
+	}
+
+	repoCfg := config.RepositoryConfig{
+		Name: "test",
+		Src:  pathsToTest.baseTestRepository,
+		Dest: subRepositoryDirectoryName,
+	}
 
 	repoStatus := sc.Command(repoCfg)
 	expectedMessage := "branch master - ( | origin | \u21910 \u21930 )"
@@ -182,7 +195,19 @@ func TestCommandAllCorrectWithoutChanges(t *testing.T) {
 }
 func TestCommandAllCorrectWithOneChange(t *testing.T) {
 
-	sc, fakeLocalRepository, repoCfg, _ := getBaseForTestingSyncCommand()
+	pathsToTest := prepareBasicRepository()
+	subRepositoryDirectoryName := "sub-repository"
+	fakeLocalRepository := createAndCloneRepository(subRepositoryDirectoryName, pathsToTest)
+
+	sc := StatusChecker{
+		workspace: pathsToTest.baseTestDirectory,
+	}
+
+	repoCfg := config.RepositoryConfig{
+		Name: "test",
+		Src:  pathsToTest.baseTestRepository,
+		Dest: subRepositoryDirectoryName,
+	}
 
 	fakeLocalWorkTree, err := fakeLocalRepository.Worktree()
 	checkErrorDuringPreparation(err)
@@ -207,9 +232,26 @@ func TestCommandAllCorrectWithOneChange(t *testing.T) {
 	}
 }
 
-func TestCommandMultiRemoteNoChanges(t *testing.T) {
+func TestCommandMultiRemotesNoChanges(t *testing.T) {
+	pathsToTest := prepareBasicRepository()
+	subRepositoryDirectoryName := "sub-repository"
+	fakeLocalRepository := createAndCloneRepository(subRepositoryDirectoryName, pathsToTest)
+
+	sc := StatusChecker{
+		workspace: pathsToTest.baseTestDirectory,
+	}
+
+	repoCfg := config.RepositoryConfig{
+		Name: "test",
+		Src:  pathsToTest.baseTestRepository,
+		Dest: subRepositoryDirectoryName,
+	}
+
+	err := addLocalRepositoryAsAFakeRemoteRepository(fakeLocalRepository, pathsToTest.baseTestRepository)
+	if err != nil {
+		t.Errorf("Unexpected error %v", err)
+	}
 
-	sc, _, repoCfg := getBaseForTestingSyncMultipleRemote()
 	repoStatus := sc.Command(repoCfg)
 	expectedMessage := "branch master - ( | origin | \u21910 \u21930 ) - ( | subremote | \u21910 \u21930 )"
 
@@ -225,8 +267,25 @@ func TestCommandMultiRemoteNoChanges(t *testing.T) {
 	}
 }
 
-func TestCommandMultiRemoteWithOneChange(t *testing.T) {
+func TestCommandMultiRemotesWithOneChange(t *testing.T) {
-	sc, fakeLocalRepository, repoCfg := getBaseForTestingSyncMultipleRemote()
+	pathsToTest := prepareBasicRepository()
+	subRepositoryDirectoryName := "sub-repository"
+	fakeLocalRepository := createAndCloneRepository(subRepositoryDirectoryName, pathsToTest)
+
+	sc := StatusChecker{
+		workspace: pathsToTest.baseTestDirectory,
+	}
+
+	repoCfg := config.RepositoryConfig{
+		Name: "test",
+		Src:  pathsToTest.baseTestRepository,
+		Dest: subRepositoryDirectoryName,
+	}
+
+	err := addLocalRepositoryAsAFakeRemoteRepository(fakeLocalRepository, pathsToTest.baseTestRepository)
+	if err != nil {
+		t.Errorf("Unexpected error %v", err)
+	}
 
 	fakeLocalWorkTree, err := fakeLocalRepository.Worktree()
 	checkErrorDuringPreparation(err)

internal/commands/sync_cmd_test.go

@@ -16,14 +16,14 @@ func TestSyncInit(t *testing.T) {
 
 func TestSyncCommand(t *testing.T) {
 
-	testSetup := getTestSetup()
+	pathsToTest := prepareBasicRepository()
 
 	sync := Synchronizer{
-		workspace: testSetup.rootFS.Root(),
+		workspace: pathsToTest.baseTestDirectory,
 	}
 
 	cfg := config.RepositoryConfig{
-		Src:  fmt.Sprintf("file://%v", testSetup.baseRepository.fileSystem.Root()),
+		Src:  fmt.Sprintf("file://%v", pathsToTest.baseTestRepository),
 		Dest: "awesome-go",
 	}
 
@@ -32,10 +32,11 @@ func TestSyncCommand(t *testing.T) {
 		t.Errorf("Unexpected error: %v", cloneStatus.Message)
 	}
 
-	info, err := os.Stat(fmt.Sprintf("%v/awesome-go/.git", testSetup.rootFS.Root()))
+	info, err := os.Stat(fmt.Sprintf("%v/awesome-go/.git", pathsToTest.baseTestDirectory))
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err.Error())
 	}
+
 	if !info.IsDir() {
 		t.Errorf("Expected that the selected path is dir")
 	}

internal/config/config_file_parse.go

@@ -41,9 +41,9 @@ func GetRepositoryConfig(data []byte, fileExtension string) (Configuration, erro
 			return Configuration{}, errors.New(errorMessage)
 		}
 		if repo.Name == "" {
-			splittedGit := strings.Split(repo.Src, "/")
+			splitGit := strings.Split(repo.Src, "/")
-			nameWithExcention := splittedGit[len(splittedGit)-1]
+			nameWithExtension := splitGit[len(splitGit)-1]
-			name := strings.Split(nameWithExcention, ".")[0]
+			name := strings.Split(nameWithExtension, ".")[0]
 			config.Repositories[index].Name = name
 		}
 		if repo.Dest == "" {

internal/grm/app.go

@@ -61,18 +61,18 @@ func (g *GitRepositoryManager) Run(w io.Writer) int {
 	exitCode := 0
 
 	if len(g.cliArguments.LimitToTags) != 0 {
-		err := g.limitTags()
+		err := g.limitRepositoriesToTags()
 		if err != nil {
 			echo.ErrorfMsg(err.Error())
-			exitCode = 1
+			return 1
 		}
 	}
 
 	if g.cliArguments.LimitToName != "" {
-		err := g.limitName()
+		err := g.limitRepositoryToName()
 		if err != nil {
 			echo.ErrorfMsg(err.Error())
-			exitCode = 1
+			return 1
 		}
 	}
 
@@ -108,7 +108,7 @@ func describeStatus(status commands.CommandStatus) {
 	}
 }
 
-func (g *GitRepositoryManager) limitTags() error {
+func (g *GitRepositoryManager) limitRepositoriesToTags() error {
 	limitedTagsTmp := []config.RepositoryConfig{}
 
 	for _, item := range g.configuration.Repositories {
@@ -123,7 +123,7 @@ func (g *GitRepositoryManager) limitTags() error {
 	return nil
 }
 
-func (g *GitRepositoryManager) limitName() error {
+func (g *GitRepositoryManager) limitRepositoryToName() error {
 	for _, item := range g.configuration.Repositories {
 		if g.cliArguments.LimitToName == item.Name {
 			g.configuration.Repositories = []config.RepositoryConfig{item}

internal/grm/app_test.go

@@ -163,7 +163,7 @@ func TestLimitTags(t *testing.T) {
 	}
 	echo.Color(false)
 	echo.Output(emt)
-	grm.limitTags()
+	grm.limitRepositoriesToTags()
 	grm.runCommand(fakeCommand)
 }
 
@@ -192,7 +192,7 @@ func TestLimitName(t *testing.T) {
 	}
 	echo.Color(false)
 	echo.Output(emt)
-	grm.limitName()
+	grm.limitRepositoryToName()
 	grm.runCommand(fakeCommand)
 }
 func TestRunWithNotExistingNameInLimit(t *testing.T) {