mpeczkowski/GitRepositoryManager
1
0
Fork 0
Code Issues 3 Pull Requests Packages Projects 1 Releases Wiki Activity

Compare commits

base: mpeczkowski:9d7a64a371f6f5e1ef8be6ecca502677451d50c3
Branches Tags
mpeczkowski:main
mpeczkowski:0.2.0
..
compare: mpeczkowski:8cd3ed2127f1c179646cf7bfecd3786eb0a91b9a
Branches Tags
mpeczkowski:main
mpeczkowski:0.2.0

No commits in common. "9d7a64a371f6f5e1ef8be6ecca502677451d50c3" and "8cd3ed2127f1c179646cf7bfecd3786eb0a91b9a" have entirely different histories.
9d7a64a371 ... 8cd3ed2127

10 changed files with 146 additions and 193 deletions
Show Stats Expand all files Collapse all files

130
internal/commands/common_utils_test.go
View File

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

14
internal/commands/status_cmd.go
View File

@ -6,7 +6,6 @@ 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"
)
@ -21,7 +20,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
@ -37,7 +36,6 @@ 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,10 +52,8 @@ func findNumberOfCommitDiffs(srcCommit *object.Commit, dstCommit *object.Commit)
return diffRange, false
}
var baseCommitHashes []string
var destCommitHashes []string
// Try to find all differences, limit only to five last changes to avoid reading whole repository at once
baseCommitHashes := []string{}
destCommitHashes := []string{}
for {
if srcCommit != nil {
@ -84,8 +80,8 @@ func (sc StatusChecker) Command(repoCfg config.RepositoryConfig) CommandStatus {
Error: false,
}
repositoryPath := path.Join(sc.workspace, repoCfg.Dest)
repo, err := git.PlainOpen(repositoryPath)
destPath := fmt.Sprintf("%v/%v", sc.workspace, repoCfg.Dest)
repo, err := git.PlainOpen(destPath)
if err != nil {
cmdStatus.Error = true

115
internal/commands/status_cmd_test.go
View File

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

38
internal/commands/sync_cmd.go
View File

@ -1,7 +1,6 @@
package commands
import (
"errors"
"fmt"
"gitlab.com/revalus/grm/internal/config"
@ -27,14 +26,15 @@ const (
func fetchRepository(repo *git.Repository) (bool, error) {
err := repo.Fetch(&git.FetchOptions{})
switch {
case errors.Is(err, git.NoErrAlreadyUpToDate):
if err == git.NoErrAlreadyUpToDate {
return false, nil
case errors.Is(err, git.NoErrAlreadyUpToDate):
return false, nil
default:
return true, nil
}
if err != nil && err != git.NoErrAlreadyUpToDate {
return false, err
}
return true, nil
}
func cloneRepository(destPath string, repoCfg *config.RepositoryConfig) (bool, error) {
@ -62,22 +62,20 @@ func (s Synchronizer) Command(repoCfg config.RepositoryConfig) CommandStatus {
destPath := fmt.Sprintf("%v/%v", s.workspace, repoCfg.Dest)
repo, err := git.PlainOpen(destPath)
if err != nil {
if errors.Is(err, git.ErrRepositoryNotExists) {
cmdStatus.Changed, err = cloneRepository(destPath, &repoCfg)
cmdStatus.Message = syncCloned
if err != nil && err == git.ErrRepositoryNotExists {
cmdStatus.Changed, err = cloneRepository(destPath, &repoCfg)
cmdStatus.Message = syncCloned
} else if err == nil {
cmdStatus.Changed, err = fetchRepository(repo)
if cmdStatus.Changed {
cmdStatus.Message = syncFetched
} else {
cmdStatus.Error = true
cmdStatus.Message = err.Error()
cmdStatus.Message = syncUpToDate
}
return cmdStatus
}
cmdStatus.Changed, err = fetchRepository(repo)
if cmdStatus.Changed {
cmdStatus.Message = syncFetched
} else {
cmdStatus.Message = syncUpToDate
cmdStatus.Error = true
cmdStatus.Message = err.Error()
return cmdStatus
}
if err != nil {

9
internal/commands/sync_cmd_test.go
View File

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

6
internal/config/config_file_parse.go
View File

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

9
internal/config/config_file_parse_test.go
View File

@ -1,7 +1,6 @@
package config
import (
"errors"
"fmt"
"os"
"reflect"
@ -102,9 +101,9 @@ repositories:
`)
_, err := GetRepositoryConfig(exampleWrongYamlConfig, "yaml")
expectedError := errors.New(fmt.Sprintf(errMissingSrcField, 0))
expectedError := fmt.Sprintf(errMissingSrcField, 0)
if errors.Is(err, expectedError) {
if err.Error() != expectedError {
t.Errorf("Expected to get error with value %v, instead of this got: %v", expectedError, err.Error())
}
}
@ -128,7 +127,7 @@ repositories:
}
expectedError := getDuplicateFieldError("name", "example2", []int{1, 2})
if errors.Is(err, expectedError) {
if err.Error() != expectedError.Error() {
t.Errorf("Expected to get error with value %v, instead of this got: %v", expectedError.Error(), err.Error())
}
}
@ -152,7 +151,7 @@ repositories:
expectedError := getDuplicateFieldError("dest", "example", []int{1, 2})
if errors.Is(err, expectedError) {
if err.Error() != expectedError.Error() {
t.Errorf("Expected to get error with value \"%v\", instead of this got: \"%v\"", expectedError, err)
}
}

12
internal/grm/app.go
View File

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

4
internal/grm/app_test.go
View File

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

2
internal/grm/utils_test.go
View File

@ -29,7 +29,7 @@ func TestGetFileExtension(t *testing.T) {
}
func TestErrorInGetExtensionFile(t *testing.T) {
func TestErrorInGetExcensionFile(t *testing.T) {
result, err := getFileExtension("test")