From f93ff7c7e70ed27dd5b0287d27b1a6d7ef0539bd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Daniel=20S=C3=A1nchez=20Navarro?= Date: Tue, 28 May 2024 11:33:50 +0200 Subject: [PATCH 1/5] chore: initial commit From 862d18128c8696b3e7accd7345690fc03cb026e3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Daniel=20S=C3=A1nchez=20Navarro?= Date: Wed, 5 Jun 2024 16:58:58 +0200 Subject: [PATCH 2/5] fix: throw error if given issue id is a pull request number --- internal/issue_trackers/github/github.go | 54 +++- internal/issue_trackers/github/github_test.go | 246 +++++++++++------- 2 files changed, 198 insertions(+), 102 deletions(-) diff --git a/internal/issue_trackers/github/github.go b/internal/issue_trackers/github/github.go index 931053e..d6d2dbf 100644 --- a/internal/issue_trackers/github/github.go +++ b/internal/issue_trackers/github/github.go @@ -17,9 +17,18 @@ var issuePattern = regexp.MustCompile(`^(?i:GH-)?(?P\d+)$`) var ErrIssueNotFound = fmt.Errorf("the issue was not found") +var ErrIdIsPullRequestNumber = func(identifier string) error { + return fmt.Errorf("given identifier %s is a Pull Request number", identifier) +} + +type GithubCli interface { + domain.GhCli + domain.RepositoryProvider +} + type Github struct { cfg Configuration - cli domain.GhCli + cli GithubCli } type Configuration struct { @@ -27,31 +36,48 @@ type Configuration struct { } type ghIssue struct { - Number int64 - Title string - Body string - Labels []Label - Url string + Number int64 + Title string + Body string + Labels []Label + Url string + PullRequest *ghPullRequest `json:"pull_request"` } +func (i ghIssue) isPullRequest() bool { + return i.PullRequest != nil +} + +type ghPullRequest map[string]any + type Label struct { - Id string + Id int Name string Description string Color string } +var newGhCli = func() GithubCli { + return &gh.Cli{} +} + // New returns a new Github issue tracker with the given configuration func New(cfg Configuration) (*Github, error) { return &Github{ cfg: cfg, - cli: &gh.Cli{}, + cli: newGhCli(), }, nil } func (g *Github) GetIssue(identifier string) (issue domain.Issue, err error) { - command := []string{"issue", "view", identifier, "--json", "labels,number,title,body,url"} + repo, err := g.cli.GetRepository() + if err != nil { + return nil, err + } + + apiPath := fmt.Sprintf("/repos/%s/issues/%s", repo.NameWithOwner, identifier) + command := []string{"api", apiPath} result := ghIssue{} @@ -63,12 +89,18 @@ func (g *Github) GetIssue(identifier string) (issue domain.Issue, err error) { return } + if result.isPullRequest() { + return nil, ErrIdIsPullRequestNumber(identifier) + } + labels := make([]domain.Label, len(result.Labels)) for i, label := range result.Labels { labels[i] = domain.Label{ - Id: label.Id, - Name: label.Name, + Id: fmt.Sprintf("%d", label.Id), + Name: label.Name, + Description: label.Description, + Color: label.Color, } } diff --git a/internal/issue_trackers/github/github_test.go b/internal/issue_trackers/github/github_test.go index fc966d6..855dd33 100644 --- a/internal/issue_trackers/github/github_test.go +++ b/internal/issue_trackers/github/github_test.go @@ -1,6 +1,7 @@ package github import ( + "errors" "fmt" "testing" @@ -9,16 +10,51 @@ import ( "github.com/InditexTech/gh-sherpa/internal/domain/issue_types" "github.com/InditexTech/gh-sherpa/internal/gh" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/suite" ) type fakeCli struct { gh.Cli issue *ghIssue + err error } -var _ domain.GhCli = (*fakeCli)(nil) +func (f *fakeCli) setError() { + f.err = errors.New("error") +} + +func (f *fakeCli) setIssue(number int) { + f.issue = &ghIssue{ + Number: int64(number), + Title: "Issue Title", + Body: "Issue Body", + Url: "https://github.example.com/owner/repo/issues/1", + Labels: []Label{ + { + Id: 1, + Name: "kind/feature", + Description: "feature kind label", + Color: "#fff", + }, + }, + } +} + +func (f *fakeCli) resetLabels() { + f.issue.Labels = []Label{} +} -func (f *fakeCli) GetRepo() (repo *domain.Repository, err error) { +func (f *fakeCli) addIssueTypeLabel(issueType issue_types.IssueType) { + f.issue.Labels = append(f.issue.Labels, Label{ + Id: len(issueType), + Name: fmt.Sprintf("kind/%s", issueType), + Description: fmt.Sprintf("%s kind label", issueType), + }) +} + +var _ GithubCli = (*fakeCli)(nil) + +func (f *fakeCli) GetRepository() (repo *domain.Repository, err error) { repo = &domain.Repository{ Name: "Repo 1", Owner: "Owner 1", @@ -30,6 +66,9 @@ func (f *fakeCli) GetRepo() (repo *domain.Repository, err error) { var errExecuteError = fmt.Errorf("execute error") func (f *fakeCli) Execute(result any, _ []string) (err error) { + if f.err != nil { + return f.err + } if f.issue == nil { return errExecuteError } @@ -43,110 +82,135 @@ func (f *fakeCli) Execute(result any, _ []string) (err error) { return } -func TestGetIssue(t *testing.T) { - newGhIssue := func(number int, labels []string) *ghIssue { - labl := make([]Label, len(labels)) - for i, label := range labels { - labl[i] = Label{Name: label} - } +type GithubTestSuite struct { + suite.Suite + github *Github + fakeCli *fakeCli + defaultIssueID string + expectedIssue *Issue + newGhCli func() GithubCli +} - return &ghIssue{ - Number: int64(number), - Title: "fake title", - Body: "fake body", - Url: "fake url", - Labels: labl, - } - } +func TestGithubSuite(t *testing.T) { + suite.Run(t, new(GithubTestSuite)) +} + +func (s *GithubTestSuite) SetupSuite() { + s.defaultIssueID = "1" + s.newGhCli = newGhCli +} - newIssue := func(id string, typeLabel string, issueType issue_types.IssueType, labels []string) Issue { - labl := make([]domain.Label, len(labels)) - for i, label := range labels { - labl[i] = domain.Label{Name: label} - } +func (s *GithubTestSuite) TearDownSuite() { + newGhCli = s.newGhCli +} - return Issue{ - id: id, - title: "fake title", - body: "fake body", - url: "fake url", - typeLabel: typeLabel, - issueType: issueType, - labels: labl, - } +func (s *GithubTestSuite) SetupSubTest() { + s.fakeCli = &fakeCli{} + s.fakeCli.setIssue(1) + + newGhCli = func() GithubCli { + return s.fakeCli } - tests := []struct { - name string - identifier string - retrievedIssue *ghIssue - want Issue - wantErr bool - }{ - { - name: "should return bug issue", - identifier: "1", - retrievedIssue: newGhIssue(1, []string{"kind/bug"}), - want: newIssue("1", "kind/bug", issue_types.Bug, []string{"kind/bug"}), - }, - { - name: "should return feature issue", - identifier: "1", - retrievedIssue: newGhIssue(1, []string{"kind/enhancement", "other/label"}), - want: newIssue("1", "kind/enhancement", issue_types.Feature, []string{"kind/enhancement", "other/label"}), + cfg := Configuration{ + Github: config.Github{ + IssueLabels: config.GithubIssueLabels{ + issue_types.Bug: {"kind/bug", "kind/bugfix"}, + issue_types.Feature: {"kind/feature", "kind/enhancement"}, + issue_types.Refactoring: {}, + }, }, - { - name: "should return unknown issue if no label is present", - identifier: "1", - retrievedIssue: newGhIssue(1, []string{}), - want: newIssue("1", "", issue_types.Unknown, []string{}), - }, - { - name: "should return unknown issue if could not determine type", - identifier: "1", - retrievedIssue: newGhIssue(1, []string{"random-label", "other-label"}), - want: newIssue("1", "", issue_types.Unknown, []string{"random-label", "other-label"}), - }, - { - name: "should return error if could not execute", - wantErr: true, + } + + g, err := New(cfg) + s.Require().NoError(err) + + s.github = g + + s.expectedIssue = &Issue{ + id: s.defaultIssueID, + title: "Issue Title", + body: "Issue Body", + url: "https://github.example.com/owner/repo/issues/1", + typeLabel: "kind/feature", + issueType: issue_types.Feature, + labels: []domain.Label{ + { + Id: "1", + Name: "kind/feature", + Description: "feature kind label", + Color: "#fff", + }, }, } +} - for _, tc := range tests { - tc := tc - t.Run(tc.name, func(t *testing.T) { - github := &Github{ - cli: &fakeCli{ - issue: tc.retrievedIssue, - }, - cfg: Configuration{ - Github: config.Github{ - IssueLabels: config.GithubIssueLabels{ - issue_types.Bug: {"kind/bug", "kind/bugfix"}, - issue_types.Feature: {"kind/feature", "kind/enhancement"}, - issue_types.Refactoring: {}, - }, - }, - }, - } +func (s *GithubTestSuite) TestGetIssue() { + s.Run("should return error if could not execute", func() { + s.fakeCli.setError() - issue, err := github.GetIssue(tc.identifier) + issue, err := s.github.GetIssue(s.defaultIssueID) - if tc.wantErr { - assert.Error(t, err) - return - } + s.Error(err) + s.Nil(issue) + }) + + s.Run("should return bug issue", func() { + s.fakeCli.resetLabels() + s.fakeCli.addIssueTypeLabel(issue_types.Bug) + + issue, err := s.github.GetIssue(s.defaultIssueID) + + s.NoError(err) + s.Require().NotNil(issue) + s.Equal(issue_types.Bug, issue.Type()) + s.Equal("kind/bug", issue.TypeLabel()) + }) + + s.Run("should return unknown issue if no label is present", func() { + s.fakeCli.resetLabels() + + issue, err := s.github.GetIssue(s.defaultIssueID) + + s.NoError(err) + s.Require().NotNil(issue) + s.Equal(issue_types.Unknown, issue.Type()) + }) + + s.Run("should return unknown issue if could not determine label type", func() { + s.fakeCli.resetLabels() + s.fakeCli.addIssueTypeLabel("random-label") + + issue, err := s.github.GetIssue(s.defaultIssueID) + + s.NoError(err) + s.Require().NotNil(issue) + s.Equal(issue_types.Unknown, issue.Type()) + }) + + s.Run("should return issue", func() { + issue, err := s.github.GetIssue(s.defaultIssueID) + + s.NoError(err) + s.Require().NotNil(s.expectedIssue) + s.Equal(*s.expectedIssue, issue) + }) + + s.Run("should return error if given issue id is a pull request number", func() { + s.fakeCli.issue.PullRequest = &ghPullRequest{} + + issueId := "99" + issue, err := s.github.GetIssue(issueId) + + s.ErrorContains(err, ErrIdIsPullRequestNumber(issueId).Error()) + s.Nil(issue) + }) - assert.NoError(t, err) - assert.Equal(t, tc.want, issue) - }) - } } func Test_CheckConfiguration(t *testing.T) { type fields struct { - Cli domain.GhCli + Cli GithubCli } tests := []struct { name string @@ -167,7 +231,7 @@ func Test_CheckConfiguration(t *testing.T) { func Test_IdentifyIssue(t *testing.T) { type fields struct { - Cli domain.GhCli + Cli GithubCli } type args struct { identifier string From e22f8b5cfa3bb508c2ac1411e5d0e7cf3804bebe Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Daniel=20S=C3=A1nchez=20Navarro?= Date: Thu, 6 Jun 2024 11:17:14 +0200 Subject: [PATCH 3/5] refactor: remove ghCli domain interface --- internal/domain/providers.go | 5 +---- internal/fakes/domain/fake_gh_cli.go | 4 ---- internal/gh/cli.go | 2 -- internal/issue_trackers/github/github.go | 8 ++++---- internal/issue_trackers/github/github_test.go | 10 +++++----- 5 files changed, 10 insertions(+), 19 deletions(-) diff --git a/internal/domain/providers.go b/internal/domain/providers.go index 15a7df2..a0b3696 100644 --- a/internal/domain/providers.go +++ b/internal/domain/providers.go @@ -1,9 +1,5 @@ package domain -type GhCli interface { - Execute(result any, args []string) (err error) -} - type RepositoryProvider interface { GetRepository() (repo *Repository, err error) } @@ -35,3 +31,4 @@ type GitProvider interface { type BranchProvider interface { GetBranchName(issue Issue, repo Repository) (branchName string, err error) } + diff --git a/internal/fakes/domain/fake_gh_cli.go b/internal/fakes/domain/fake_gh_cli.go index cbfde68..4adbd7f 100644 --- a/internal/fakes/domain/fake_gh_cli.go +++ b/internal/fakes/domain/fake_gh_cli.go @@ -1,11 +1,7 @@ package domain -import "github.com/InditexTech/gh-sherpa/internal/domain" - type FakeGhCli struct{} -var _ domain.GhCli = (*FakeGhCli)(nil) - func NewFakeGhCli() FakeGhCli { return FakeGhCli{} } diff --git a/internal/gh/cli.go b/internal/gh/cli.go index d968364..d7ba26a 100644 --- a/internal/gh/cli.go +++ b/internal/gh/cli.go @@ -13,8 +13,6 @@ import ( type Cli struct{} -var _ domain.GhCli = (*Cli)(nil) - func (c *Cli) GetRepository() (repo *domain.Repository, err error) { baseCommand := []string{"repo", "view", "--json", "name,owner,nameWithOwner,defaultBranchRef"} diff --git a/internal/issue_trackers/github/github.go b/internal/issue_trackers/github/github.go index d6d2dbf..03b86e9 100644 --- a/internal/issue_trackers/github/github.go +++ b/internal/issue_trackers/github/github.go @@ -21,14 +21,14 @@ var ErrIdIsPullRequestNumber = func(identifier string) error { return fmt.Errorf("given identifier %s is a Pull Request number", identifier) } -type GithubCli interface { - domain.GhCli +type githubCli interface { + Execute(result interface{}, command []string) error domain.RepositoryProvider } type Github struct { cfg Configuration - cli GithubCli + cli githubCli } type Configuration struct { @@ -57,7 +57,7 @@ type Label struct { Color string } -var newGhCli = func() GithubCli { +var newGhCli = func() githubCli { return &gh.Cli{} } diff --git a/internal/issue_trackers/github/github_test.go b/internal/issue_trackers/github/github_test.go index 855dd33..214875b 100644 --- a/internal/issue_trackers/github/github_test.go +++ b/internal/issue_trackers/github/github_test.go @@ -52,7 +52,7 @@ func (f *fakeCli) addIssueTypeLabel(issueType issue_types.IssueType) { }) } -var _ GithubCli = (*fakeCli)(nil) +var _ githubCli = (*fakeCli)(nil) func (f *fakeCli) GetRepository() (repo *domain.Repository, err error) { repo = &domain.Repository{ @@ -88,7 +88,7 @@ type GithubTestSuite struct { fakeCli *fakeCli defaultIssueID string expectedIssue *Issue - newGhCli func() GithubCli + newGhCli func() githubCli } func TestGithubSuite(t *testing.T) { @@ -108,7 +108,7 @@ func (s *GithubTestSuite) SetupSubTest() { s.fakeCli = &fakeCli{} s.fakeCli.setIssue(1) - newGhCli = func() GithubCli { + newGhCli = func() githubCli { return s.fakeCli } @@ -210,7 +210,7 @@ func (s *GithubTestSuite) TestGetIssue() { func Test_CheckConfiguration(t *testing.T) { type fields struct { - Cli GithubCli + Cli githubCli } tests := []struct { name string @@ -231,7 +231,7 @@ func Test_CheckConfiguration(t *testing.T) { func Test_IdentifyIssue(t *testing.T) { type fields struct { - Cli GithubCli + Cli githubCli } type args struct { identifier string From 8433b51000d09b9b5ec5687659cd066c07263897 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Daniel=20S=C3=A1nchez=20Navarro?= Date: Thu, 6 Jun 2024 11:33:08 +0200 Subject: [PATCH 4/5] chore: update mocks --- internal/mocks/domain/mock_GhCli.go | 75 ----- internal/mocks/domain/mock_GitProvider.go | 104 +++---- internal/mocks/domain/mock_Issue.go | 98 +++--- internal/mocks/domain/mock_IssueTracker.go | 340 --------------------- 4 files changed, 101 insertions(+), 516 deletions(-) delete mode 100644 internal/mocks/domain/mock_GhCli.go delete mode 100644 internal/mocks/domain/mock_IssueTracker.go diff --git a/internal/mocks/domain/mock_GhCli.go b/internal/mocks/domain/mock_GhCli.go deleted file mode 100644 index 20e41fc..0000000 --- a/internal/mocks/domain/mock_GhCli.go +++ /dev/null @@ -1,75 +0,0 @@ -// Code generated by mockery v2.32.4. DO NOT EDIT. - -package domain - -import mock "github.com/stretchr/testify/mock" - -// MockGhCli is an autogenerated mock type for the GhCli type -type MockGhCli struct { - mock.Mock -} - -type MockGhCli_Expecter struct { - mock *mock.Mock -} - -func (_m *MockGhCli) EXPECT() *MockGhCli_Expecter { - return &MockGhCli_Expecter{mock: &_m.Mock} -} - -// Execute provides a mock function with given fields: result, args -func (_m *MockGhCli) Execute(result interface{}, args []string) error { - ret := _m.Called(result, args) - - var r0 error - if rf, ok := ret.Get(0).(func(interface{}, []string) error); ok { - r0 = rf(result, args) - } else { - r0 = ret.Error(0) - } - - return r0 -} - -// MockGhCli_Execute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Execute' -type MockGhCli_Execute_Call struct { - *mock.Call -} - -// Execute is a helper method to define mock.On call -// - result interface{} -// - args []string -func (_e *MockGhCli_Expecter) Execute(result interface{}, args interface{}) *MockGhCli_Execute_Call { - return &MockGhCli_Execute_Call{Call: _e.mock.On("Execute", result, args)} -} - -func (_c *MockGhCli_Execute_Call) Run(run func(result interface{}, args []string)) *MockGhCli_Execute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(interface{}), args[1].([]string)) - }) - return _c -} - -func (_c *MockGhCli_Execute_Call) Return(err error) *MockGhCli_Execute_Call { - _c.Call.Return(err) - return _c -} - -func (_c *MockGhCli_Execute_Call) RunAndReturn(run func(interface{}, []string) error) *MockGhCli_Execute_Call { - _c.Call.Return(run) - return _c -} - -// NewMockGhCli creates a new instance of MockGhCli. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewMockGhCli(t interface { - mock.TestingT - Cleanup(func()) -}) *MockGhCli { - mock := &MockGhCli{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} diff --git a/internal/mocks/domain/mock_GitProvider.go b/internal/mocks/domain/mock_GitProvider.go index 28e2d84..97106d2 100644 --- a/internal/mocks/domain/mock_GitProvider.go +++ b/internal/mocks/domain/mock_GitProvider.go @@ -59,58 +59,6 @@ func (_c *MockGitProvider_BranchExists_Call) RunAndReturn(run func(string) bool) return _c } -// BranchExistsContains provides a mock function with given fields: branch -func (_m *MockGitProvider) BranchExistsContains(branch string) (string, bool) { - ret := _m.Called(branch) - - var r0 string - var r1 bool - if rf, ok := ret.Get(0).(func(string) (string, bool)); ok { - return rf(branch) - } - if rf, ok := ret.Get(0).(func(string) string); ok { - r0 = rf(branch) - } else { - r0 = ret.Get(0).(string) - } - - if rf, ok := ret.Get(1).(func(string) bool); ok { - r1 = rf(branch) - } else { - r1 = ret.Get(1).(bool) - } - - return r0, r1 -} - -// MockGitProvider_BranchExistsContains_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BranchExistsContains' -type MockGitProvider_BranchExistsContains_Call struct { - *mock.Call -} - -// BranchExistsContains is a helper method to define mock.On call -// - branch string -func (_e *MockGitProvider_Expecter) BranchExistsContains(branch interface{}) *MockGitProvider_BranchExistsContains_Call { - return &MockGitProvider_BranchExistsContains_Call{Call: _e.mock.On("BranchExistsContains", branch)} -} - -func (_c *MockGitProvider_BranchExistsContains_Call) Run(run func(branch string)) *MockGitProvider_BranchExistsContains_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(string)) - }) - return _c -} - -func (_c *MockGitProvider_BranchExistsContains_Call) Return(name string, exists bool) *MockGitProvider_BranchExistsContains_Call { - _c.Call.Return(name, exists) - return _c -} - -func (_c *MockGitProvider_BranchExistsContains_Call) RunAndReturn(run func(string) (string, bool)) *MockGitProvider_BranchExistsContains_Call { - _c.Call.Return(run) - return _c -} - // CheckoutBranch provides a mock function with given fields: branch func (_m *MockGitProvider) CheckoutBranch(branch string) error { ret := _m.Called(branch) @@ -280,6 +228,58 @@ func (_c *MockGitProvider_FetchBranchFromOrigin_Call) RunAndReturn(run func(stri return _c } +// FindBranch provides a mock function with given fields: substring +func (_m *MockGitProvider) FindBranch(substring string) (string, bool) { + ret := _m.Called(substring) + + var r0 string + var r1 bool + if rf, ok := ret.Get(0).(func(string) (string, bool)); ok { + return rf(substring) + } + if rf, ok := ret.Get(0).(func(string) string); ok { + r0 = rf(substring) + } else { + r0 = ret.Get(0).(string) + } + + if rf, ok := ret.Get(1).(func(string) bool); ok { + r1 = rf(substring) + } else { + r1 = ret.Get(1).(bool) + } + + return r0, r1 +} + +// MockGitProvider_FindBranch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindBranch' +type MockGitProvider_FindBranch_Call struct { + *mock.Call +} + +// FindBranch is a helper method to define mock.On call +// - substring string +func (_e *MockGitProvider_Expecter) FindBranch(substring interface{}) *MockGitProvider_FindBranch_Call { + return &MockGitProvider_FindBranch_Call{Call: _e.mock.On("FindBranch", substring)} +} + +func (_c *MockGitProvider_FindBranch_Call) Run(run func(substring string)) *MockGitProvider_FindBranch_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *MockGitProvider_FindBranch_Call) Return(branch string, exists bool) *MockGitProvider_FindBranch_Call { + _c.Call.Return(branch, exists) + return _c +} + +func (_c *MockGitProvider_FindBranch_Call) RunAndReturn(run func(string) (string, bool)) *MockGitProvider_FindBranch_Call { + _c.Call.Return(run) + return _c +} + // GetCommitsToPush provides a mock function with given fields: branch func (_m *MockGitProvider) GetCommitsToPush(branch string) ([]string, error) { ret := _m.Called(branch) diff --git a/internal/mocks/domain/mock_Issue.go b/internal/mocks/domain/mock_Issue.go index 1d7914f..0193da7 100644 --- a/internal/mocks/domain/mock_Issue.go +++ b/internal/mocks/domain/mock_Issue.go @@ -145,131 +145,131 @@ func (_c *MockIssue_ID_Call) RunAndReturn(run func() string) *MockIssue_ID_Call return _c } -// IssueTrackerType provides a mock function with given fields: -func (_m *MockIssue) IssueTrackerType() domain.IssueTrackerType { +// Title provides a mock function with given fields: +func (_m *MockIssue) Title() string { ret := _m.Called() - var r0 domain.IssueTrackerType - if rf, ok := ret.Get(0).(func() domain.IssueTrackerType); ok { + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { r0 = rf() } else { - r0 = ret.Get(0).(domain.IssueTrackerType) + r0 = ret.Get(0).(string) } return r0 } -// MockIssue_IssueTrackerType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IssueTrackerType' -type MockIssue_IssueTrackerType_Call struct { +// MockIssue_Title_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Title' +type MockIssue_Title_Call struct { *mock.Call } -// IssueTrackerType is a helper method to define mock.On call -func (_e *MockIssue_Expecter) IssueTrackerType() *MockIssue_IssueTrackerType_Call { - return &MockIssue_IssueTrackerType_Call{Call: _e.mock.On("IssueTrackerType")} +// Title is a helper method to define mock.On call +func (_e *MockIssue_Expecter) Title() *MockIssue_Title_Call { + return &MockIssue_Title_Call{Call: _e.mock.On("Title")} } -func (_c *MockIssue_IssueTrackerType_Call) Run(run func()) *MockIssue_IssueTrackerType_Call { +func (_c *MockIssue_Title_Call) Run(run func()) *MockIssue_Title_Call { _c.Call.Run(func(args mock.Arguments) { run() }) return _c } -func (_c *MockIssue_IssueTrackerType_Call) Return(_a0 domain.IssueTrackerType) *MockIssue_IssueTrackerType_Call { +func (_c *MockIssue_Title_Call) Return(_a0 string) *MockIssue_Title_Call { _c.Call.Return(_a0) return _c } -func (_c *MockIssue_IssueTrackerType_Call) RunAndReturn(run func() domain.IssueTrackerType) *MockIssue_IssueTrackerType_Call { +func (_c *MockIssue_Title_Call) RunAndReturn(run func() string) *MockIssue_Title_Call { _c.Call.Return(run) return _c } -// IssueType provides a mock function with given fields: -func (_m *MockIssue) IssueType() issue_types.IssueType { +// TrackerType provides a mock function with given fields: +func (_m *MockIssue) TrackerType() domain.IssueTrackerType { ret := _m.Called() - var r0 issue_types.IssueType - if rf, ok := ret.Get(0).(func() issue_types.IssueType); ok { + var r0 domain.IssueTrackerType + if rf, ok := ret.Get(0).(func() domain.IssueTrackerType); ok { r0 = rf() } else { - r0 = ret.Get(0).(issue_types.IssueType) + r0 = ret.Get(0).(domain.IssueTrackerType) } return r0 } -// MockIssue_IssueType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IssueType' -type MockIssue_IssueType_Call struct { +// MockIssue_TrackerType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TrackerType' +type MockIssue_TrackerType_Call struct { *mock.Call } -// IssueType is a helper method to define mock.On call -func (_e *MockIssue_Expecter) IssueType() *MockIssue_IssueType_Call { - return &MockIssue_IssueType_Call{Call: _e.mock.On("IssueType")} +// TrackerType is a helper method to define mock.On call +func (_e *MockIssue_Expecter) TrackerType() *MockIssue_TrackerType_Call { + return &MockIssue_TrackerType_Call{Call: _e.mock.On("TrackerType")} } -func (_c *MockIssue_IssueType_Call) Run(run func()) *MockIssue_IssueType_Call { +func (_c *MockIssue_TrackerType_Call) Run(run func()) *MockIssue_TrackerType_Call { _c.Call.Run(func(args mock.Arguments) { run() }) return _c } -func (_c *MockIssue_IssueType_Call) Return(_a0 issue_types.IssueType) *MockIssue_IssueType_Call { +func (_c *MockIssue_TrackerType_Call) Return(_a0 domain.IssueTrackerType) *MockIssue_TrackerType_Call { _c.Call.Return(_a0) return _c } -func (_c *MockIssue_IssueType_Call) RunAndReturn(run func() issue_types.IssueType) *MockIssue_IssueType_Call { +func (_c *MockIssue_TrackerType_Call) RunAndReturn(run func() domain.IssueTrackerType) *MockIssue_TrackerType_Call { _c.Call.Return(run) return _c } -// IssueTypeLabel provides a mock function with given fields: -func (_m *MockIssue) IssueTypeLabel() string { +// Type provides a mock function with given fields: +func (_m *MockIssue) Type() issue_types.IssueType { ret := _m.Called() - var r0 string - if rf, ok := ret.Get(0).(func() string); ok { + var r0 issue_types.IssueType + if rf, ok := ret.Get(0).(func() issue_types.IssueType); ok { r0 = rf() } else { - r0 = ret.Get(0).(string) + r0 = ret.Get(0).(issue_types.IssueType) } return r0 } -// MockIssue_IssueTypeLabel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IssueTypeLabel' -type MockIssue_IssueTypeLabel_Call struct { +// MockIssue_Type_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Type' +type MockIssue_Type_Call struct { *mock.Call } -// IssueTypeLabel is a helper method to define mock.On call -func (_e *MockIssue_Expecter) IssueTypeLabel() *MockIssue_IssueTypeLabel_Call { - return &MockIssue_IssueTypeLabel_Call{Call: _e.mock.On("IssueTypeLabel")} +// Type is a helper method to define mock.On call +func (_e *MockIssue_Expecter) Type() *MockIssue_Type_Call { + return &MockIssue_Type_Call{Call: _e.mock.On("Type")} } -func (_c *MockIssue_IssueTypeLabel_Call) Run(run func()) *MockIssue_IssueTypeLabel_Call { +func (_c *MockIssue_Type_Call) Run(run func()) *MockIssue_Type_Call { _c.Call.Run(func(args mock.Arguments) { run() }) return _c } -func (_c *MockIssue_IssueTypeLabel_Call) Return(_a0 string) *MockIssue_IssueTypeLabel_Call { +func (_c *MockIssue_Type_Call) Return(_a0 issue_types.IssueType) *MockIssue_Type_Call { _c.Call.Return(_a0) return _c } -func (_c *MockIssue_IssueTypeLabel_Call) RunAndReturn(run func() string) *MockIssue_IssueTypeLabel_Call { +func (_c *MockIssue_Type_Call) RunAndReturn(run func() issue_types.IssueType) *MockIssue_Type_Call { _c.Call.Return(run) return _c } -// Title provides a mock function with given fields: -func (_m *MockIssue) Title() string { +// TypeLabel provides a mock function with given fields: +func (_m *MockIssue) TypeLabel() string { ret := _m.Called() var r0 string @@ -282,29 +282,29 @@ func (_m *MockIssue) Title() string { return r0 } -// MockIssue_Title_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Title' -type MockIssue_Title_Call struct { +// MockIssue_TypeLabel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TypeLabel' +type MockIssue_TypeLabel_Call struct { *mock.Call } -// Title is a helper method to define mock.On call -func (_e *MockIssue_Expecter) Title() *MockIssue_Title_Call { - return &MockIssue_Title_Call{Call: _e.mock.On("Title")} +// TypeLabel is a helper method to define mock.On call +func (_e *MockIssue_Expecter) TypeLabel() *MockIssue_TypeLabel_Call { + return &MockIssue_TypeLabel_Call{Call: _e.mock.On("TypeLabel")} } -func (_c *MockIssue_Title_Call) Run(run func()) *MockIssue_Title_Call { +func (_c *MockIssue_TypeLabel_Call) Run(run func()) *MockIssue_TypeLabel_Call { _c.Call.Run(func(args mock.Arguments) { run() }) return _c } -func (_c *MockIssue_Title_Call) Return(_a0 string) *MockIssue_Title_Call { +func (_c *MockIssue_TypeLabel_Call) Return(_a0 string) *MockIssue_TypeLabel_Call { _c.Call.Return(_a0) return _c } -func (_c *MockIssue_Title_Call) RunAndReturn(run func() string) *MockIssue_Title_Call { +func (_c *MockIssue_TypeLabel_Call) RunAndReturn(run func() string) *MockIssue_TypeLabel_Call { _c.Call.Return(run) return _c } diff --git a/internal/mocks/domain/mock_IssueTracker.go b/internal/mocks/domain/mock_IssueTracker.go deleted file mode 100644 index 131783f..0000000 --- a/internal/mocks/domain/mock_IssueTracker.go +++ /dev/null @@ -1,340 +0,0 @@ -// Code generated by mockery v2.32.4. DO NOT EDIT. - -package domain - -import ( - domain "github.com/InditexTech/gh-sherpa/internal/domain" - issue_types "github.com/InditexTech/gh-sherpa/internal/domain/issue_types" - - mock "github.com/stretchr/testify/mock" -) - -// MockIssueTracker is an autogenerated mock type for the IssueTracker type -type MockIssueTracker struct { - mock.Mock -} - -type MockIssueTracker_Expecter struct { - mock *mock.Mock -} - -func (_m *MockIssueTracker) EXPECT() *MockIssueTracker_Expecter { - return &MockIssueTracker_Expecter{mock: &_m.Mock} -} - -// FormatIssueId provides a mock function with given fields: issueId -func (_m *MockIssueTracker) FormatIssueId(issueId string) string { - ret := _m.Called(issueId) - - var r0 string - if rf, ok := ret.Get(0).(func(string) string); ok { - r0 = rf(issueId) - } else { - r0 = ret.Get(0).(string) - } - - return r0 -} - -// MockIssueTracker_FormatIssueId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FormatIssueId' -type MockIssueTracker_FormatIssueId_Call struct { - *mock.Call -} - -// FormatIssueId is a helper method to define mock.On call -// - issueId string -func (_e *MockIssueTracker_Expecter) FormatIssueId(issueId interface{}) *MockIssueTracker_FormatIssueId_Call { - return &MockIssueTracker_FormatIssueId_Call{Call: _e.mock.On("FormatIssueId", issueId)} -} - -func (_c *MockIssueTracker_FormatIssueId_Call) Run(run func(issueId string)) *MockIssueTracker_FormatIssueId_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(string)) - }) - return _c -} - -func (_c *MockIssueTracker_FormatIssueId_Call) Return(formattedIssueId string) *MockIssueTracker_FormatIssueId_Call { - _c.Call.Return(formattedIssueId) - return _c -} - -func (_c *MockIssueTracker_FormatIssueId_Call) RunAndReturn(run func(string) string) *MockIssueTracker_FormatIssueId_Call { - _c.Call.Return(run) - return _c -} - -// GetIssue provides a mock function with given fields: identifier -func (_m *MockIssueTracker) GetIssue(identifier string) (domain.Issue, error) { - ret := _m.Called(identifier) - - var r0 domain.Issue - var r1 error - if rf, ok := ret.Get(0).(func(string) (domain.Issue, error)); ok { - return rf(identifier) - } - if rf, ok := ret.Get(0).(func(string) domain.Issue); ok { - r0 = rf(identifier) - } else { - r0 = ret.Get(0).(domain.Issue) - } - - if rf, ok := ret.Get(1).(func(string) error); ok { - r1 = rf(identifier) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// MockIssueTracker_GetIssue_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetIssue' -type MockIssueTracker_GetIssue_Call struct { - *mock.Call -} - -// GetIssue is a helper method to define mock.On call -// - identifier string -func (_e *MockIssueTracker_Expecter) GetIssue(identifier interface{}) *MockIssueTracker_GetIssue_Call { - return &MockIssueTracker_GetIssue_Call{Call: _e.mock.On("GetIssue", identifier)} -} - -func (_c *MockIssueTracker_GetIssue_Call) Run(run func(identifier string)) *MockIssueTracker_GetIssue_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(string)) - }) - return _c -} - -func (_c *MockIssueTracker_GetIssue_Call) Return(issue domain.Issue, err error) *MockIssueTracker_GetIssue_Call { - _c.Call.Return(issue, err) - return _c -} - -func (_c *MockIssueTracker_GetIssue_Call) RunAndReturn(run func(string) (domain.Issue, error)) *MockIssueTracker_GetIssue_Call { - _c.Call.Return(run) - return _c -} - -// GetIssueTrackerType provides a mock function with given fields: -func (_m *MockIssueTracker) GetIssueTrackerType() domain.IssueTrackerType { - ret := _m.Called() - - var r0 domain.IssueTrackerType - if rf, ok := ret.Get(0).(func() domain.IssueTrackerType); ok { - r0 = rf() - } else { - r0 = ret.Get(0).(domain.IssueTrackerType) - } - - return r0 -} - -// MockIssueTracker_GetIssueTrackerType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetIssueTrackerType' -type MockIssueTracker_GetIssueTrackerType_Call struct { - *mock.Call -} - -// GetIssueTrackerType is a helper method to define mock.On call -func (_e *MockIssueTracker_Expecter) GetIssueTrackerType() *MockIssueTracker_GetIssueTrackerType_Call { - return &MockIssueTracker_GetIssueTrackerType_Call{Call: _e.mock.On("GetIssueTrackerType")} -} - -func (_c *MockIssueTracker_GetIssueTrackerType_Call) Run(run func()) *MockIssueTracker_GetIssueTrackerType_Call { - _c.Call.Run(func(args mock.Arguments) { - run() - }) - return _c -} - -func (_c *MockIssueTracker_GetIssueTrackerType_Call) Return(_a0 domain.IssueTrackerType) *MockIssueTracker_GetIssueTrackerType_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *MockIssueTracker_GetIssueTrackerType_Call) RunAndReturn(run func() domain.IssueTrackerType) *MockIssueTracker_GetIssueTrackerType_Call { - _c.Call.Return(run) - return _c -} - -// GetIssueType provides a mock function with given fields: issue -func (_m *MockIssueTracker) GetIssueType(issue domain.Issue) issue_types.IssueType { - ret := _m.Called(issue) - - var r0 issue_types.IssueType - if rf, ok := ret.Get(0).(func(domain.Issue) issue_types.IssueType); ok { - r0 = rf(issue) - } else { - r0 = ret.Get(0).(issue_types.IssueType) - } - - return r0 -} - -// MockIssueTracker_GetIssueType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetIssueType' -type MockIssueTracker_GetIssueType_Call struct { - *mock.Call -} - -// GetIssueType is a helper method to define mock.On call -// - issue domain.Issue -func (_e *MockIssueTracker_Expecter) GetIssueType(issue interface{}) *MockIssueTracker_GetIssueType_Call { - return &MockIssueTracker_GetIssueType_Call{Call: _e.mock.On("GetIssueType", issue)} -} - -func (_c *MockIssueTracker_GetIssueType_Call) Run(run func(issue domain.Issue)) *MockIssueTracker_GetIssueType_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(domain.Issue)) - }) - return _c -} - -func (_c *MockIssueTracker_GetIssueType_Call) Return(issueType issue_types.IssueType) *MockIssueTracker_GetIssueType_Call { - _c.Call.Return(issueType) - return _c -} - -func (_c *MockIssueTracker_GetIssueType_Call) RunAndReturn(run func(domain.Issue) issue_types.IssueType) *MockIssueTracker_GetIssueType_Call { - _c.Call.Return(run) - return _c -} - -// GetIssueTypeLabel provides a mock function with given fields: issue -func (_m *MockIssueTracker) GetIssueTypeLabel(issue domain.Issue) string { - ret := _m.Called(issue) - - var r0 string - if rf, ok := ret.Get(0).(func(domain.Issue) string); ok { - r0 = rf(issue) - } else { - r0 = ret.Get(0).(string) - } - - return r0 -} - -// MockIssueTracker_GetIssueTypeLabel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetIssueTypeLabel' -type MockIssueTracker_GetIssueTypeLabel_Call struct { - *mock.Call -} - -// GetIssueTypeLabel is a helper method to define mock.On call -// - issue domain.Issue -func (_e *MockIssueTracker_Expecter) GetIssueTypeLabel(issue interface{}) *MockIssueTracker_GetIssueTypeLabel_Call { - return &MockIssueTracker_GetIssueTypeLabel_Call{Call: _e.mock.On("GetIssueTypeLabel", issue)} -} - -func (_c *MockIssueTracker_GetIssueTypeLabel_Call) Run(run func(issue domain.Issue)) *MockIssueTracker_GetIssueTypeLabel_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(domain.Issue)) - }) - return _c -} - -func (_c *MockIssueTracker_GetIssueTypeLabel_Call) Return(_a0 string) *MockIssueTracker_GetIssueTypeLabel_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *MockIssueTracker_GetIssueTypeLabel_Call) RunAndReturn(run func(domain.Issue) string) *MockIssueTracker_GetIssueTypeLabel_Call { - _c.Call.Return(run) - return _c -} - -// IdentifyIssue provides a mock function with given fields: identifier -func (_m *MockIssueTracker) IdentifyIssue(identifier string) bool { - ret := _m.Called(identifier) - - var r0 bool - if rf, ok := ret.Get(0).(func(string) bool); ok { - r0 = rf(identifier) - } else { - r0 = ret.Get(0).(bool) - } - - return r0 -} - -// MockIssueTracker_IdentifyIssue_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IdentifyIssue' -type MockIssueTracker_IdentifyIssue_Call struct { - *mock.Call -} - -// IdentifyIssue is a helper method to define mock.On call -// - identifier string -func (_e *MockIssueTracker_Expecter) IdentifyIssue(identifier interface{}) *MockIssueTracker_IdentifyIssue_Call { - return &MockIssueTracker_IdentifyIssue_Call{Call: _e.mock.On("IdentifyIssue", identifier)} -} - -func (_c *MockIssueTracker_IdentifyIssue_Call) Run(run func(identifier string)) *MockIssueTracker_IdentifyIssue_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(string)) - }) - return _c -} - -func (_c *MockIssueTracker_IdentifyIssue_Call) Return(_a0 bool) *MockIssueTracker_IdentifyIssue_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *MockIssueTracker_IdentifyIssue_Call) RunAndReturn(run func(string) bool) *MockIssueTracker_IdentifyIssue_Call { - _c.Call.Return(run) - return _c -} - -// ParseRawIssueId provides a mock function with given fields: identifier -func (_m *MockIssueTracker) ParseRawIssueId(identifier string) string { - ret := _m.Called(identifier) - - var r0 string - if rf, ok := ret.Get(0).(func(string) string); ok { - r0 = rf(identifier) - } else { - r0 = ret.Get(0).(string) - } - - return r0 -} - -// MockIssueTracker_ParseRawIssueId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ParseRawIssueId' -type MockIssueTracker_ParseRawIssueId_Call struct { - *mock.Call -} - -// ParseRawIssueId is a helper method to define mock.On call -// - identifier string -func (_e *MockIssueTracker_Expecter) ParseRawIssueId(identifier interface{}) *MockIssueTracker_ParseRawIssueId_Call { - return &MockIssueTracker_ParseRawIssueId_Call{Call: _e.mock.On("ParseRawIssueId", identifier)} -} - -func (_c *MockIssueTracker_ParseRawIssueId_Call) Run(run func(identifier string)) *MockIssueTracker_ParseRawIssueId_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(string)) - }) - return _c -} - -func (_c *MockIssueTracker_ParseRawIssueId_Call) Return(issueId string) *MockIssueTracker_ParseRawIssueId_Call { - _c.Call.Return(issueId) - return _c -} - -func (_c *MockIssueTracker_ParseRawIssueId_Call) RunAndReturn(run func(string) string) *MockIssueTracker_ParseRawIssueId_Call { - _c.Call.Return(run) - return _c -} - -// NewMockIssueTracker creates a new instance of MockIssueTracker. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewMockIssueTracker(t interface { - mock.TestingT - Cleanup(func()) -}) *MockIssueTracker { - mock := &MockIssueTracker{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} From 45cf53538a405264b3b37e581f110e28f6657028 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Daniel=20S=C3=A1nchez=20Navarro?= Date: Thu, 6 Jun 2024 11:43:46 +0200 Subject: [PATCH 5/5] chore: format code --- internal/domain/providers.go | 1 - 1 file changed, 1 deletion(-) diff --git a/internal/domain/providers.go b/internal/domain/providers.go index a0b3696..4dd199e 100644 --- a/internal/domain/providers.go +++ b/internal/domain/providers.go @@ -31,4 +31,3 @@ type GitProvider interface { type BranchProvider interface { GetBranchName(issue Issue, repo Repository) (branchName string, err error) } -