Use fakes instead of mocks for use case tests

internal/domain/providers.go

@@ -9,7 +9,7 @@ type RepositoryProvider interface {
 }
 
 type PullRequestProvider interface {
-	GetPullRequestForBranch(string) (pullRequest *PullRequest, err error)
+	GetPullRequestForBranch(branch string) (pullRequest *PullRequest, err error)
 	CreatePullRequest(title string, body string, baseBranch string, headBranch string, draft bool, labels []string) (prUrl string, err error)
 }
 

internal/fakes/domain/fake_branch_provider.go

@@ -0,0 +1,29 @@
+package domain
+
+import (
+	"errors"
+	"fmt"
+
+	"github.com/InditexTech/gh-sherpa/internal/domain"
+)
+
+type FakeBranchProvider struct{}
+
+var _ domain.BranchProvider = (*FakeBranchProvider)(nil)
+
+func NewFakeBranchProvider() FakeBranchProvider {
+	return FakeBranchProvider{}
+}
+
+func (f *FakeBranchProvider) GetBranchName(issueTracker domain.IssueTracker, issueIdentifier string, repo domain.Repository) (branchName string, err error) {
+	switch issueTracker.GetIssueTrackerType() {
+	case domain.IssueTrackerTypeGithub:
+		return fmt.Sprintf("feature/GH-%s-generated-branch-name", issueIdentifier), nil
+	case domain.IssueTrackerTypeJira:
+		return fmt.Sprintf("feature/%s-generated-branch-name", issueIdentifier), nil
+	default:
+
+	}
+
+	return "", errors.New("unknown issue tracker type")
+}

internal/fakes/domain/fake_gh_cli.go

@@ -0,0 +1,15 @@
+package domain
+
+import "github.com/InditexTech/gh-sherpa/internal/domain"
+
+type FakeGhCli struct{}
+
+var _ domain.GhCli = (*FakeGhCli)(nil)
+
+func NewFakeGhCli() FakeGhCli {
+	return FakeGhCli{}
+}
+
+func (f FakeGhCli) Execute(result any, args []string) (err error) {
+	return nil
+}

internal/fakes/domain/fake_git_provider.go

@@ -0,0 +1,142 @@
+package domain
+
+import (
+	"errors"
+	"fmt"
+	"slices"
+	"strings"
+
+	"github.com/InditexTech/gh-sherpa/internal/domain"
+)
+
+type FakeGitProvider struct {
+	RemoteBranches        []string
+	LocalBranches         []string
+	CurrentBranch         string
+	CommitsToPush         map[string][]string
+	BranchWithCommitError []string
+}
+
+var _ domain.GitProvider = (*FakeGitProvider)(nil)
+
+func NewFakeGitProvider() *FakeGitProvider {
+	return &FakeGitProvider{
+		CurrentBranch: "main",
+		RemoteBranches: []string{
+			"main",
+			"develop",
+		},
+		LocalBranches: []string{
+			"main",
+			"develop",
+		},
+		CommitsToPush:         map[string][]string{},
+		BranchWithCommitError: []string{},
+	}
+}
+
+func (f *FakeGitProvider) AddLocalBranches(branches ...string) {
+	f.LocalBranches = append(f.LocalBranches, branches...)
+}
+
+func (f *FakeGitProvider) AddRemoteBranches(branches ...string) {
+	f.RemoteBranches = append(f.RemoteBranches, branches...)
+}
+
+func (f *FakeGitProvider) BranchExists(branch string) bool {
+	return slices.Contains(f.LocalBranches, branch)
+}
+
+func (f *FakeGitProvider) FetchBranchFromOrigin(branch string) (err error) {
+	idx := slices.Index(f.RemoteBranches, branch)
+	if idx == -1 {
+		return fmt.Errorf("remote branch %s not found", branch)
+	}
+	return nil
+}
+
+func (f *FakeGitProvider) CheckoutNewBranchFromOrigin(branch string, base string) (err error) {
+	idx := slices.Index(f.RemoteBranches, base)
+	if idx == -1 {
+		return fmt.Errorf("remote branch %s not found", base)
+	}
+	f.LocalBranches = append(f.LocalBranches, branch)
+	f.CurrentBranch = branch
+	return nil
+}
+
+var ErrGetCurrentBranch = errors.New("no current branch")
+
+func (f *FakeGitProvider) GetCurrentBranch() (branch string, err error) {
+	if f.CurrentBranch != "" {
+		return f.CurrentBranch, nil
+	}
+
+	return "", ErrGetCurrentBranch
+}
+
+func (f *FakeGitProvider) BranchExistsContains(branch string) (name string, exists bool) {
+	for _, b := range f.LocalBranches {
+		if strings.Contains(b, branch) {
+			return b, true
+		}
+	}
+	for _, b := range f.RemoteBranches {
+		if strings.Contains(b, branch) {
+			return b, true
+		}
+	}
+	return "", false
+}
+
+func (f *FakeGitProvider) CheckoutBranch(branch string) (err error) {
+	if !slices.Contains(f.LocalBranches, branch) {
+		return fmt.Errorf("local branch %s not found", branch)
+	}
+	f.CurrentBranch = branch
+	return nil
+}
+
+var ErrGetCommitsToPush = errors.New("error getting commits to push")
+
+func (f *FakeGitProvider) GetCommitsToPush(branch string) (commits []string, err error) {
+	if slices.Contains(f.BranchWithCommitError, branch) {
+		return commits, ErrGetCommitsToPush
+	}
+
+	commits, ok := f.CommitsToPush[branch]
+	if !ok {
+		commits = []string{}
+	}
+
+	return commits, nil
+}
+
+func (f *FakeGitProvider) RemoteBranchExists(branch string) (exists bool) {
+	return slices.Contains(f.RemoteBranches, branch)
+}
+
+func (f *FakeGitProvider) CommitEmpty(message string) (err error) {
+	currentCommits, ok := f.CommitsToPush[f.CurrentBranch]
+	if !ok {
+		currentCommits = []string{}
+	}
+	currentCommits = append(currentCommits, message)
+	f.CommitsToPush[f.CurrentBranch] = currentCommits
+	return nil
+}
+
+func (f *FakeGitProvider) PushBranch(branch string) (err error) {
+	if !slices.Contains(f.LocalBranches, branch) {
+		return fmt.Errorf("local branch %s not found", branch)
+	}
+	if slices.Contains(f.RemoteBranches, branch) {
+		return fmt.Errorf("remote branch %s already exists", branch)
+	}
+	f.RemoteBranches = append(f.RemoteBranches, branch)
+	return nil
+}
+
+func (f *FakeGitProvider) IsCurrentBranch(branch string) bool {
+	return f.CurrentBranch == branch
+}

internal/fakes/domain/fake_issue_tracker.go

@@ -0,0 +1,105 @@
+package domain
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/InditexTech/gh-sherpa/internal/domain"
+	"github.com/InditexTech/gh-sherpa/internal/domain/issue_types"
+)
+
+type FakeIssueTracker struct {
+	IssueTrackerType domain.IssueTrackerType
+	Configurations   map[string]FakeIssueTrackerConfiguration
+}
+
+type FakeIssueTrackerConfiguration struct {
+	IssueTrackerIdentifier string
+	IssueType              issue_types.IssueType
+	IssueTypeLabel         string
+	Issue                  domain.Issue
+}
+
+var _ domain.IssueTracker = (*FakeIssueTracker)(nil)
+
+func NewFakeIssueTracker() *FakeIssueTracker {
+	return &FakeIssueTracker{
+		Configurations: map[string]FakeIssueTrackerConfiguration{},
+	}
+}
+
+func ErrIssueNotInitializedInMap(identifier string) error {
+	return fmt.Errorf("issue %s not initialized in map", identifier)
+}
+
+func (f *FakeIssueTracker) AddIssue(issueId string, issueType issue_types.IssueType) {
+	issueTypeLabel := "kind/" + issueType.String()
+	f.Configurations[issueId] = FakeIssueTrackerConfiguration{
+		IssueTrackerIdentifier: f.IssueTrackerType.String(),
+		IssueType:              issueType,
+		IssueTypeLabel:         issueTypeLabel,
+		Issue: domain.Issue{
+			ID:           issueId,
+			IssueTracker: f.IssueTrackerType,
+			Title:        "Sample issue",
+			Body:         "Sample issue body",
+			Labels: []domain.Label{
+				{
+					Id:   issueTypeLabel,
+					Name: issueTypeLabel,
+				},
+			},
+			Url: "https://github.com/InditexTech/gh-sherpa-repo-test/issues/" + issueId,
+		},
+	}
+}
+
+func (f *FakeIssueTracker) GetIssue(issueId string) (issue domain.Issue, err error) {
+	config, ok := f.Configurations[issueId]
+	if !ok {
+		return domain.Issue{}, ErrIssueNotInitializedInMap(issueId)
+	}
+	return config.Issue, nil
+}
+
+func (f *FakeIssueTracker) GetIssueType(issue domain.Issue) (issueType issue_types.IssueType) {
+	return f.Configurations[issue.ID].IssueType
+}
+
+func (f *FakeIssueTracker) GetIssueTypeLabel(issue domain.Issue) string {
+	return f.Configurations[issue.ID].IssueTypeLabel
+}
+
+func (f *FakeIssueTracker) IdentifyIssue(issueId string) bool {
+	return f.Configurations[issueId].IssueTrackerIdentifier == string(f.IssueTrackerType)
+}
+
+func (f *FakeIssueTracker) FormatIssueId(issueId string) (formattedIssueId string) {
+	issueTrackerType := f.GetIssueTrackerType()
+	if issueTrackerType == domain.IssueTrackerTypeGithub {
+		return fmt.Sprintf("GH-%s", issueId)
+	}
+
+	return issueId
+}
+
+func (f *FakeIssueTracker) ParseRawIssueId(identifier string) (issueId string) {
+	prefix := ""
+
+	switch f.IssueTrackerType {
+	case domain.IssueTrackerTypeGithub:
+		prefix = "GH-"
+	case domain.IssueTrackerTypeJira:
+		prefix = "PROJECTKEY-"
+	}
+
+	if strings.HasPrefix(identifier, prefix) {
+		return strings.ReplaceAll(identifier, prefix, "")
+	}
+
+	return ""
+}
+
+func (f *FakeIssueTracker) GetIssueTrackerType() domain.IssueTrackerType {
+	return f.IssueTrackerType
+}

internal/fakes/domain/fake_issue_tracker_provider.go

@@ -0,0 +1,34 @@
+package domain
+
+import (
+	"errors"
+	"strconv"
+	"strings"
+
+	"github.com/InditexTech/gh-sherpa/internal/domain"
+)
+
+type FakeIssueTrackerProvider struct {
+	IssueTracker domain.IssueTracker
+}
+
+var _ domain.IssueTrackerProvider = (*FakeIssueTrackerProvider)(nil)
+
+func NewFakeIssueTrackerProvider(issueTracker domain.IssueTracker) *FakeIssueTrackerProvider {
+	return &FakeIssueTrackerProvider{
+		IssueTracker: issueTracker,
+	}
+}
+
+func (f *FakeIssueTrackerProvider) GetIssueTracker(identifier string) (issueTracker domain.IssueTracker, err error) {
+	_, err = strconv.Atoi(identifier)
+	if strings.HasPrefix(identifier, "GH-") || strings.HasPrefix(identifier, "PROJECTKEY-") || err == nil {
+		return f.IssueTracker, nil
+	}
+
+	return nil, errors.New("issue tracker not found")
+}
+
+func (f *FakeIssueTrackerProvider) ParseIssueId(identifier string) (issueId string) {
+	return strings.TrimPrefix(identifier, "GH-")
+}