From 9eb0ab0a0fce8a4907335227de982d5c353086b7 Mon Sep 17 00:00:00 2001 From: Ed Date: Wed, 19 Dec 2018 18:00:25 -0500 Subject: [PATCH] Begin working on tests --- check_command_test.go | 340 +++------------------ fakes/fake_git_hub.go | 511 -------------------------------- fakes/fake_git_lab.go | 656 +++++++++++++++++++++++++++++++++++++++++ gitlab_test.go | 178 +---------- go.mod | 7 + go.sum | 35 +++ in_command_test.go | 392 +++--------------------- out_command_test.go | 192 ++++++------ resource_suite_test.go | 41 +-- 9 files changed, 893 insertions(+), 1459 deletions(-) delete mode 100644 fakes/fake_git_hub.go create mode 100644 fakes/fake_git_lab.go diff --git a/check_command_test.go b/check_command_test.go index dde2953..2c175d5 100644 --- a/check_command_test.go +++ b/check_command_test.go @@ -4,49 +4,35 @@ import ( . "github.com/onsi/ginkgo" . "github.com/onsi/gomega" - "github.com/google/go-github/github" + "github.com/xanzy/go-gitlab" - "github.com/concourse/github-release-resource" - "github.com/concourse/github-release-resource/fakes" + "github.com/edtan/gitlab-release-resource" + "github.com/edtan/gitlab-release-resource/fakes" ) var _ = Describe("Check Command", func() { var ( - githubClient *fakes.FakeGitHub + gitlabClient *fakes.FakeGitLab command *resource.CheckCommand - returnedReleases []*github.RepositoryRelease + returnedTags []*gitlab.Tag ) BeforeEach(func() { - githubClient = &fakes.FakeGitHub{} - command = resource.NewCheckCommand(githubClient) + gitlabClient = &fakes.FakeGitLab{} + command = resource.NewCheckCommand(gitlabClient) - returnedReleases = []*github.RepositoryRelease{} + returnedTags = []*gitlab.Tag{} }) JustBeforeEach(func() { - githubClient.ListReleasesReturns(returnedReleases, nil) + gitlabClient.ListTagsReturns(returnedTags, nil) }) Context("when this is the first time that the resource has been run", func() { Context("when there are no releases", func() { BeforeEach(func() { - returnedReleases = []*github.RepositoryRelease{} - }) - - It("returns no versions", func() { - versions, err := command.Run(resource.CheckRequest{}) - Ω(err).ShouldNot(HaveOccurred()) - Ω(versions).Should(BeEmpty()) - }) - }) - - Context("when there are releases that get filtered out", func() { - BeforeEach(func() { - returnedReleases = []*github.RepositoryRelease{ - newDraftRepositoryRelease(1, "v0.1.4"), - } + returnedTags = []*gitlab.Tag{} }) It("returns no versions", func() { @@ -58,15 +44,15 @@ var _ = Describe("Check Command", func() { Context("when there are releases", func() { BeforeEach(func() { - returnedReleases = []*github.RepositoryRelease{ - newRepositoryRelease(1, "v0.4.0"), - newRepositoryRelease(2, "0.1.3"), - newRepositoryRelease(3, "v0.1.2"), + returnedTags = []*gitlab.Tag{ + newTag("v0.4.0", "abc123"), + newTag("0.1.3", "bdc234"), + newTag("v0.1.2", "cde345"), } }) It("outputs the most recent version only", func() { - command := resource.NewCheckCommand(githubClient) + command := resource.NewCheckCommand(gitlabClient) response, err := command.Run(resource.CheckRequest{}) Ω(err).ShouldNot(HaveOccurred()) @@ -82,7 +68,7 @@ var _ = Describe("Check Command", func() { Context("when there are prior versions", func() { Context("when there are no releases", func() { BeforeEach(func() { - returnedReleases = []*github.RepositoryRelease{} + returnedTags = []*gitlab.Tag{} }) It("returns no versions", func() { @@ -95,16 +81,16 @@ var _ = Describe("Check Command", func() { Context("when there are releases", func() { Context("and there is a custom tag filter", func() { BeforeEach(func() { - returnedReleases = []*github.RepositoryRelease{ - newRepositoryRelease(1, "package-0.1.4"), - newRepositoryRelease(2, "package-0.4.0"), - newRepositoryRelease(3, "package-0.1.3"), - newRepositoryRelease(4, "package-0.1.2"), + returnedTags = []*gitlab.Tag{ + newTag("package-0.1.4", "abc123"), + newTag("package-0.4.0", "bcd234"), + newTag("package-0.1.3", "cde345"), + newTag("package-0.1.2", "def456"), } }) It("returns all of the versions that are newer", func() { - command := resource.NewCheckCommand(githubClient) + command := resource.NewCheckCommand(gitlabClient) response, err := command.Run(resource.CheckRequest{ Version: resource.Version{ @@ -123,16 +109,16 @@ var _ = Describe("Check Command", func() { Context("and the releases do not contain a draft release", func() { BeforeEach(func() { - returnedReleases = []*github.RepositoryRelease{ - newRepositoryRelease(1, "v0.1.4"), - newRepositoryRelease(2, "0.4.0"), - newRepositoryRelease(3, "v0.1.3"), - newRepositoryRelease(4, "0.1.2"), + returnedTags = []*gitlab.Tag{ + newTag("v0.1.4", "abc123"), + newTag("0.4.0", "bcd234"), + newTag("v0.1.3", "cde345"), + newTag("0.1.2", "def456"), } }) - It("returns an empty list if the lastet version has been checked", func() { - command := resource.NewCheckCommand(githubClient) + It("returns an empty list if the latest version has been checked", func() { + command := resource.NewCheckCommand(gitlabClient) response, err := command.Run(resource.CheckRequest{ Version: resource.Version{ @@ -145,7 +131,7 @@ var _ = Describe("Check Command", func() { }) It("returns all of the versions that are newer", func() { - command := resource.NewCheckCommand(githubClient) + command := resource.NewCheckCommand(gitlabClient) response, err := command.Run(resource.CheckRequest{ Version: resource.Version{ @@ -162,7 +148,7 @@ var _ = Describe("Check Command", func() { }) It("returns the latest version if the current version is not found", func() { - command := resource.NewCheckCommand(githubClient) + command := resource.NewCheckCommand(gitlabClient) response, err := command.Run(resource.CheckRequest{ Version: resource.Version{ @@ -178,12 +164,12 @@ var _ = Describe("Check Command", func() { Context("when there are not-quite-semver versions", func() { BeforeEach(func() { - returnedReleases = append(returnedReleases, newRepositoryRelease(5, "v1")) - returnedReleases = append(returnedReleases, newRepositoryRelease(6, "v0")) + returnedTags = append(returnedTags, newTag("v1", "abc123")) + returnedTags = append(returnedTags, newTag("v0", "bcd234")) }) It("combines them with the semver versions in a reasonable order", func() { - command := resource.NewCheckCommand(githubClient) + command := resource.NewCheckCommand(gitlabClient) response, err := command.Run(resource.CheckRequest{ Version: resource.Version{ @@ -201,264 +187,6 @@ var _ = Describe("Check Command", func() { }) }) }) - - Context("and one of the releases is a draft", func() { - BeforeEach(func() { - returnedReleases = []*github.RepositoryRelease{ - newDraftRepositoryRelease(1, "v0.1.4"), - newRepositoryRelease(2, "0.4.0"), - newRepositoryRelease(3, "v0.1.3"), - } - }) - - It("returns all of the versions that are newer, and not a draft", func() { - command := resource.NewCheckCommand(githubClient) - - response, err := command.Run(resource.CheckRequest{ - Version: resource.Version{ - Tag: "v0.1.3", - }, - }) - Ω(err).ShouldNot(HaveOccurred()) - - Ω(response).Should(Equal([]resource.Version{ - {Tag: "v0.1.3"}, - {Tag: "0.4.0"}, - })) - }) - }) - - Context("when pre releases are allowed and releases are not", func() { - Context("and one of the releases is a final and another is a draft", func() { - BeforeEach(func() { - returnedReleases = []*github.RepositoryRelease{ - newDraftRepositoryRelease(1, "v0.1.4"), - newRepositoryRelease(2, "0.4.0"), - newPreReleaseRepositoryRelease(1, "v0.4.1-rc.10"), - newPreReleaseRepositoryRelease(2, "0.4.1-rc.9"), - newPreReleaseRepositoryRelease(3, "v0.4.1-rc.8"), - } - - }) - - It("returns all of the versions that are newer, and only pre relases", func() { - command := resource.NewCheckCommand(githubClient) - - response, err := command.Run(resource.CheckRequest{ - Version: resource.Version{ID: "2"}, - Source: resource.Source{Drafts: false, PreRelease: true, Release: false}, - }) - Ω(err).ShouldNot(HaveOccurred()) - - Ω(response).Should(Equal([]resource.Version{ - {Tag: "0.4.1-rc.9"}, - {Tag: "v0.4.1-rc.10"}, - })) - }) - - It("returns the latest prerelease version if the current version is not found", func() { - command := resource.NewCheckCommand(githubClient) - - response, err := command.Run(resource.CheckRequest{ - Version: resource.Version{ID: "5"}, - Source: resource.Source{Drafts: false, PreRelease: true, Release: false}, - }) - Ω(err).ShouldNot(HaveOccurred()) - - Ω(response).Should(Equal([]resource.Version{ - {Tag: "v0.4.1-rc.10"}, - })) - }) - }) - - }) - - Context("when releases and pre releases are allowed", func() { - Context("and final release is newer", func() { - BeforeEach(func() { - returnedReleases = []*github.RepositoryRelease{ - newDraftRepositoryRelease(1, "v0.1.4"), - newRepositoryRelease(1, "0.3.9"), - newRepositoryRelease(2, "0.4.0"), - newRepositoryRelease(3, "v0.4.2"), - newPreReleaseRepositoryRelease(1, "v0.4.1-rc.10"), - newPreReleaseRepositoryRelease(2, "0.4.1-rc.9"), - newPreReleaseRepositoryRelease(3, "v0.4.2-rc.1"), - } - - }) - - It("returns all of the versions that are newer, and are release and prerealse", func() { - command := resource.NewCheckCommand(githubClient) - - response, err := command.Run(resource.CheckRequest{ - Version: resource.Version{Tag: "0.4.0"}, - Source: resource.Source{Drafts: false, PreRelease: true, Release: true}, - }) - Ω(err).ShouldNot(HaveOccurred()) - - Ω(response).Should(Equal([]resource.Version{ - {Tag: "0.4.0"}, - {Tag: "0.4.1-rc.9"}, - {Tag: "v0.4.1-rc.10"}, - {Tag: "v0.4.2-rc.1"}, - {Tag: "v0.4.2"}, - })) - }) - - It("returns the latest release version if the current version is not found", func() { - command := resource.NewCheckCommand(githubClient) - - response, err := command.Run(resource.CheckRequest{ - Version: resource.Version{ID: "5"}, - Source: resource.Source{Drafts: false, PreRelease: true, Release: true}, - }) - Ω(err).ShouldNot(HaveOccurred()) - - Ω(response).Should(Equal([]resource.Version{ - {Tag: "v0.4.2"}, - })) - }) - }) - - Context("and prerelease is newer", func() { - BeforeEach(func() { - returnedReleases = []*github.RepositoryRelease{ - newDraftRepositoryRelease(1, "v0.1.4"), - newRepositoryRelease(1, "0.3.9"), - newRepositoryRelease(2, "0.4.0"), - newRepositoryRelease(3, "v0.4.2"), - newPreReleaseRepositoryRelease(1, "v0.4.1-rc.10"), - newPreReleaseRepositoryRelease(2, "0.4.1-rc.9"), - newPreReleaseRepositoryRelease(3, "v0.4.2-rc.1"), - newPreReleaseRepositoryRelease(4, "v0.4.3-rc.1"), - } - - }) - - It("returns all of the versions that are newer, and are release and prerealse", func() { - command := resource.NewCheckCommand(githubClient) - - response, err := command.Run(resource.CheckRequest{ - Version: resource.Version{Tag: "0.4.0"}, - Source: resource.Source{Drafts: false, PreRelease: true, Release: true}, - }) - Ω(err).ShouldNot(HaveOccurred()) - - Ω(response).Should(Equal([]resource.Version{ - {Tag: "0.4.0"}, - {Tag: "0.4.1-rc.9"}, - {Tag: "v0.4.1-rc.10"}, - {Tag: "v0.4.2-rc.1"}, - {Tag: "v0.4.2"}, - {Tag: "v0.4.3-rc.1"}, - })) - }) - - It("returns the latest prerelease version if the current version is not found", func() { - command := resource.NewCheckCommand(githubClient) - - response, err := command.Run(resource.CheckRequest{ - Version: resource.Version{ID: "5"}, - Source: resource.Source{Drafts: false, PreRelease: true, Release: true}, - }) - Ω(err).ShouldNot(HaveOccurred()) - - Ω(response).Should(Equal([]resource.Version{ - {Tag: "v0.4.3-rc.1"}, - })) - }) - }) - - }) - - Context("when draft releases are allowed", func() { - Context("and one of the releases is a final release", func() { - BeforeEach(func() { - returnedReleases = []*github.RepositoryRelease{ - newDraftRepositoryRelease(1, "v0.1.4"), - newDraftRepositoryRelease(2, "v0.1.3"), - newDraftRepositoryRelease(3, "v0.1.1"), - newRepositoryRelease(2, "0.4.0"), - } - }) - - It("returns all of the versions that are newer, and only draft", func() { - command := resource.NewCheckCommand(githubClient) - - response, err := command.Run(resource.CheckRequest{ - Version: resource.Version{ID: "2"}, - Source: resource.Source{Drafts: true}, - }) - Ω(err).ShouldNot(HaveOccurred()) - - Ω(response).Should(Equal([]resource.Version{ - {ID: "2"}, - {ID: "1"}, - })) - }) - - It("returns the latest draft version if the current version is not found", func() { - command := resource.NewCheckCommand(githubClient) - - response, err := command.Run(resource.CheckRequest{ - Version: resource.Version{ID: "5"}, - Source: resource.Source{Drafts: true}, - }) - Ω(err).ShouldNot(HaveOccurred()) - - Ω(response).Should(Equal([]resource.Version{ - {ID: "1"}, - })) - }) - }) - - Context("and non-of them are semver", func() { - BeforeEach(func() { - returnedReleases = []*github.RepositoryRelease{ - newDraftRepositoryRelease(1, "abc/d"), - newDraftRepositoryRelease(2, "123*4"), - } - }) - - It("returns all of the releases with semver resources", func() { - command := resource.NewCheckCommand(githubClient) - - response, err := command.Run(resource.CheckRequest{ - Version: resource.Version{}, - Source: resource.Source{Drafts: true}, - }) - Ω(err).ShouldNot(HaveOccurred()) - - Ω(response).Should(Equal([]resource.Version{})) - }) - }) - - Context("and one of the releases is not a versioned draft release", func() { - BeforeEach(func() { - returnedReleases = []*github.RepositoryRelease{ - newDraftRepositoryRelease(1, "v0.1.4"), - newDraftRepositoryRelease(2, ""), - newDraftWithNilTagRepositoryRelease(3), - newDraftRepositoryRelease(4, "asdf@example.com"), - } - }) - - It("returns all of the releases with semver resources", func() { - command := resource.NewCheckCommand(githubClient) - - response, err := command.Run(resource.CheckRequest{ - Version: resource.Version{}, - Source: resource.Source{Drafts: true, PreRelease: false}, - }) - Ω(err).ShouldNot(HaveOccurred()) - - Ω(response).Should(Equal([]resource.Version{ - {ID: "1"}, - })) - }) - }) - }) }) }) }) diff --git a/fakes/fake_git_hub.go b/fakes/fake_git_hub.go deleted file mode 100644 index 3f9b929..0000000 --- a/fakes/fake_git_hub.go +++ /dev/null @@ -1,511 +0,0 @@ -// This file was generated by counterfeiter -package fakes - -import ( - "io" - "net/url" - "os" - "sync" - - "github.com/concourse/github-release-resource" - "github.com/google/go-github/github" -) - -type FakeGitHub struct { - ListReleasesStub func() ([]*github.RepositoryRelease, error) - listReleasesMutex sync.RWMutex - listReleasesArgsForCall []struct{} - listReleasesReturns struct { - result1 []*github.RepositoryRelease - result2 error - } - GetReleaseByTagStub func(tag string) (*github.RepositoryRelease, error) - getReleaseByTagMutex sync.RWMutex - getReleaseByTagArgsForCall []struct { - tag string - } - getReleaseByTagReturns struct { - result1 *github.RepositoryRelease - result2 error - } - GetReleaseStub func(id int) (*github.RepositoryRelease, error) - getReleaseMutex sync.RWMutex - getReleaseArgsForCall []struct { - id int - } - getReleaseReturns struct { - result1 *github.RepositoryRelease - result2 error - } - CreateReleaseStub func(release github.RepositoryRelease) (*github.RepositoryRelease, error) - createReleaseMutex sync.RWMutex - createReleaseArgsForCall []struct { - release github.RepositoryRelease - } - createReleaseReturns struct { - result1 *github.RepositoryRelease - result2 error - } - UpdateReleaseStub func(release github.RepositoryRelease) (*github.RepositoryRelease, error) - updateReleaseMutex sync.RWMutex - updateReleaseArgsForCall []struct { - release github.RepositoryRelease - } - updateReleaseReturns struct { - result1 *github.RepositoryRelease - result2 error - } - ListReleaseAssetsStub func(release github.RepositoryRelease) ([]*github.ReleaseAsset, error) - listReleaseAssetsMutex sync.RWMutex - listReleaseAssetsArgsForCall []struct { - release github.RepositoryRelease - } - listReleaseAssetsReturns struct { - result1 []*github.ReleaseAsset - result2 error - } - UploadReleaseAssetStub func(release github.RepositoryRelease, name string, file *os.File) error - uploadReleaseAssetMutex sync.RWMutex - uploadReleaseAssetArgsForCall []struct { - release github.RepositoryRelease - name string - file *os.File - } - uploadReleaseAssetReturns struct { - result1 error - } - DeleteReleaseAssetStub func(asset github.ReleaseAsset) error - deleteReleaseAssetMutex sync.RWMutex - deleteReleaseAssetArgsForCall []struct { - asset github.ReleaseAsset - } - deleteReleaseAssetReturns struct { - result1 error - } - DownloadReleaseAssetStub func(asset github.ReleaseAsset) (io.ReadCloser, error) - downloadReleaseAssetMutex sync.RWMutex - downloadReleaseAssetArgsForCall []struct { - asset github.ReleaseAsset - } - downloadReleaseAssetReturns struct { - result1 io.ReadCloser - result2 error - } - GetTarballLinkStub func(tag string) (*url.URL, error) - getTarballLinkMutex sync.RWMutex - getTarballLinkArgsForCall []struct { - tag string - } - getTarballLinkReturns struct { - result1 *url.URL - result2 error - } - GetZipballLinkStub func(tag string) (*url.URL, error) - getZipballLinkMutex sync.RWMutex - getZipballLinkArgsForCall []struct { - tag string - } - getZipballLinkReturns struct { - result1 *url.URL - result2 error - } - GetRefStub func(tag string) (*github.Reference, error) - getRefMutex sync.RWMutex - getRefArgsForCall []struct { - tag string - } - getRefReturns struct { - result1 *github.Reference - result2 error - } -} - -func (fake *FakeGitHub) ListReleases() ([]*github.RepositoryRelease, error) { - fake.listReleasesMutex.Lock() - fake.listReleasesArgsForCall = append(fake.listReleasesArgsForCall, struct{}{}) - fake.listReleasesMutex.Unlock() - if fake.ListReleasesStub != nil { - return fake.ListReleasesStub() - } else { - return fake.listReleasesReturns.result1, fake.listReleasesReturns.result2 - } -} - -func (fake *FakeGitHub) ListReleasesCallCount() int { - fake.listReleasesMutex.RLock() - defer fake.listReleasesMutex.RUnlock() - return len(fake.listReleasesArgsForCall) -} - -func (fake *FakeGitHub) ListReleasesReturns(result1 []*github.RepositoryRelease, result2 error) { - fake.ListReleasesStub = nil - fake.listReleasesReturns = struct { - result1 []*github.RepositoryRelease - result2 error - }{result1, result2} -} - -func (fake *FakeGitHub) GetReleaseByTag(tag string) (*github.RepositoryRelease, error) { - fake.getReleaseByTagMutex.Lock() - fake.getReleaseByTagArgsForCall = append(fake.getReleaseByTagArgsForCall, struct { - tag string - }{tag}) - fake.getReleaseByTagMutex.Unlock() - if fake.GetReleaseByTagStub != nil { - return fake.GetReleaseByTagStub(tag) - } else { - return fake.getReleaseByTagReturns.result1, fake.getReleaseByTagReturns.result2 - } -} - -func (fake *FakeGitHub) GetReleaseByTagCallCount() int { - fake.getReleaseByTagMutex.RLock() - defer fake.getReleaseByTagMutex.RUnlock() - return len(fake.getReleaseByTagArgsForCall) -} - -func (fake *FakeGitHub) GetReleaseByTagArgsForCall(i int) string { - fake.getReleaseByTagMutex.RLock() - defer fake.getReleaseByTagMutex.RUnlock() - return fake.getReleaseByTagArgsForCall[i].tag -} - -func (fake *FakeGitHub) GetReleaseByTagReturns(result1 *github.RepositoryRelease, result2 error) { - fake.GetReleaseByTagStub = nil - fake.getReleaseByTagReturns = struct { - result1 *github.RepositoryRelease - result2 error - }{result1, result2} -} - -func (fake *FakeGitHub) GetRelease(id int) (*github.RepositoryRelease, error) { - fake.getReleaseMutex.Lock() - fake.getReleaseArgsForCall = append(fake.getReleaseArgsForCall, struct { - id int - }{id}) - fake.getReleaseMutex.Unlock() - if fake.GetReleaseStub != nil { - return fake.GetReleaseStub(id) - } else { - return fake.getReleaseReturns.result1, fake.getReleaseReturns.result2 - } -} - -func (fake *FakeGitHub) GetReleaseCallCount() int { - fake.getReleaseMutex.RLock() - defer fake.getReleaseMutex.RUnlock() - return len(fake.getReleaseArgsForCall) -} - -func (fake *FakeGitHub) GetReleaseArgsForCall(i int) int { - fake.getReleaseMutex.RLock() - defer fake.getReleaseMutex.RUnlock() - return fake.getReleaseArgsForCall[i].id -} - -func (fake *FakeGitHub) GetReleaseReturns(result1 *github.RepositoryRelease, result2 error) { - fake.GetReleaseStub = nil - fake.getReleaseReturns = struct { - result1 *github.RepositoryRelease - result2 error - }{result1, result2} -} - -func (fake *FakeGitHub) CreateRelease(release github.RepositoryRelease) (*github.RepositoryRelease, error) { - fake.createReleaseMutex.Lock() - fake.createReleaseArgsForCall = append(fake.createReleaseArgsForCall, struct { - release github.RepositoryRelease - }{release}) - fake.createReleaseMutex.Unlock() - if fake.CreateReleaseStub != nil { - return fake.CreateReleaseStub(release) - } else { - return fake.createReleaseReturns.result1, fake.createReleaseReturns.result2 - } -} - -func (fake *FakeGitHub) CreateReleaseCallCount() int { - fake.createReleaseMutex.RLock() - defer fake.createReleaseMutex.RUnlock() - return len(fake.createReleaseArgsForCall) -} - -func (fake *FakeGitHub) CreateReleaseArgsForCall(i int) github.RepositoryRelease { - fake.createReleaseMutex.RLock() - defer fake.createReleaseMutex.RUnlock() - return fake.createReleaseArgsForCall[i].release -} - -func (fake *FakeGitHub) CreateReleaseReturns(result1 *github.RepositoryRelease, result2 error) { - fake.CreateReleaseStub = nil - fake.createReleaseReturns = struct { - result1 *github.RepositoryRelease - result2 error - }{result1, result2} -} - -func (fake *FakeGitHub) UpdateRelease(release github.RepositoryRelease) (*github.RepositoryRelease, error) { - fake.updateReleaseMutex.Lock() - fake.updateReleaseArgsForCall = append(fake.updateReleaseArgsForCall, struct { - release github.RepositoryRelease - }{release}) - fake.updateReleaseMutex.Unlock() - if fake.UpdateReleaseStub != nil { - return fake.UpdateReleaseStub(release) - } else { - return fake.updateReleaseReturns.result1, fake.updateReleaseReturns.result2 - } -} - -func (fake *FakeGitHub) UpdateReleaseCallCount() int { - fake.updateReleaseMutex.RLock() - defer fake.updateReleaseMutex.RUnlock() - return len(fake.updateReleaseArgsForCall) -} - -func (fake *FakeGitHub) UpdateReleaseArgsForCall(i int) github.RepositoryRelease { - fake.updateReleaseMutex.RLock() - defer fake.updateReleaseMutex.RUnlock() - return fake.updateReleaseArgsForCall[i].release -} - -func (fake *FakeGitHub) UpdateReleaseReturns(result1 *github.RepositoryRelease, result2 error) { - fake.UpdateReleaseStub = nil - fake.updateReleaseReturns = struct { - result1 *github.RepositoryRelease - result2 error - }{result1, result2} -} - -func (fake *FakeGitHub) ListReleaseAssets(release github.RepositoryRelease) ([]*github.ReleaseAsset, error) { - fake.listReleaseAssetsMutex.Lock() - fake.listReleaseAssetsArgsForCall = append(fake.listReleaseAssetsArgsForCall, struct { - release github.RepositoryRelease - }{release}) - fake.listReleaseAssetsMutex.Unlock() - if fake.ListReleaseAssetsStub != nil { - return fake.ListReleaseAssetsStub(release) - } else { - return fake.listReleaseAssetsReturns.result1, fake.listReleaseAssetsReturns.result2 - } -} - -func (fake *FakeGitHub) ListReleaseAssetsCallCount() int { - fake.listReleaseAssetsMutex.RLock() - defer fake.listReleaseAssetsMutex.RUnlock() - return len(fake.listReleaseAssetsArgsForCall) -} - -func (fake *FakeGitHub) ListReleaseAssetsArgsForCall(i int) github.RepositoryRelease { - fake.listReleaseAssetsMutex.RLock() - defer fake.listReleaseAssetsMutex.RUnlock() - return fake.listReleaseAssetsArgsForCall[i].release -} - -func (fake *FakeGitHub) ListReleaseAssetsReturns(result1 []*github.ReleaseAsset, result2 error) { - fake.ListReleaseAssetsStub = nil - fake.listReleaseAssetsReturns = struct { - result1 []*github.ReleaseAsset - result2 error - }{result1, result2} -} - -func (fake *FakeGitHub) UploadReleaseAsset(release github.RepositoryRelease, name string, file *os.File) error { - fake.uploadReleaseAssetMutex.Lock() - fake.uploadReleaseAssetArgsForCall = append(fake.uploadReleaseAssetArgsForCall, struct { - release github.RepositoryRelease - name string - file *os.File - }{release, name, file}) - fake.uploadReleaseAssetMutex.Unlock() - if fake.UploadReleaseAssetStub != nil { - return fake.UploadReleaseAssetStub(release, name, file) - } else { - return fake.uploadReleaseAssetReturns.result1 - } -} - -func (fake *FakeGitHub) UploadReleaseAssetCallCount() int { - fake.uploadReleaseAssetMutex.RLock() - defer fake.uploadReleaseAssetMutex.RUnlock() - return len(fake.uploadReleaseAssetArgsForCall) -} - -func (fake *FakeGitHub) UploadReleaseAssetArgsForCall(i int) (github.RepositoryRelease, string, *os.File) { - fake.uploadReleaseAssetMutex.RLock() - defer fake.uploadReleaseAssetMutex.RUnlock() - return fake.uploadReleaseAssetArgsForCall[i].release, fake.uploadReleaseAssetArgsForCall[i].name, fake.uploadReleaseAssetArgsForCall[i].file -} - -func (fake *FakeGitHub) UploadReleaseAssetReturns(result1 error) { - fake.UploadReleaseAssetStub = nil - fake.uploadReleaseAssetReturns = struct { - result1 error - }{result1} -} - -func (fake *FakeGitHub) DeleteReleaseAsset(asset github.ReleaseAsset) error { - fake.deleteReleaseAssetMutex.Lock() - fake.deleteReleaseAssetArgsForCall = append(fake.deleteReleaseAssetArgsForCall, struct { - asset github.ReleaseAsset - }{asset}) - fake.deleteReleaseAssetMutex.Unlock() - if fake.DeleteReleaseAssetStub != nil { - return fake.DeleteReleaseAssetStub(asset) - } else { - return fake.deleteReleaseAssetReturns.result1 - } -} - -func (fake *FakeGitHub) DeleteReleaseAssetCallCount() int { - fake.deleteReleaseAssetMutex.RLock() - defer fake.deleteReleaseAssetMutex.RUnlock() - return len(fake.deleteReleaseAssetArgsForCall) -} - -func (fake *FakeGitHub) DeleteReleaseAssetArgsForCall(i int) github.ReleaseAsset { - fake.deleteReleaseAssetMutex.RLock() - defer fake.deleteReleaseAssetMutex.RUnlock() - return fake.deleteReleaseAssetArgsForCall[i].asset -} - -func (fake *FakeGitHub) DeleteReleaseAssetReturns(result1 error) { - fake.DeleteReleaseAssetStub = nil - fake.deleteReleaseAssetReturns = struct { - result1 error - }{result1} -} - -func (fake *FakeGitHub) DownloadReleaseAsset(asset github.ReleaseAsset) (io.ReadCloser, error) { - fake.downloadReleaseAssetMutex.Lock() - fake.downloadReleaseAssetArgsForCall = append(fake.downloadReleaseAssetArgsForCall, struct { - asset github.ReleaseAsset - }{asset}) - fake.downloadReleaseAssetMutex.Unlock() - if fake.DownloadReleaseAssetStub != nil { - return fake.DownloadReleaseAssetStub(asset) - } else { - return fake.downloadReleaseAssetReturns.result1, fake.downloadReleaseAssetReturns.result2 - } -} - -func (fake *FakeGitHub) DownloadReleaseAssetCallCount() int { - fake.downloadReleaseAssetMutex.RLock() - defer fake.downloadReleaseAssetMutex.RUnlock() - return len(fake.downloadReleaseAssetArgsForCall) -} - -func (fake *FakeGitHub) DownloadReleaseAssetArgsForCall(i int) github.ReleaseAsset { - fake.downloadReleaseAssetMutex.RLock() - defer fake.downloadReleaseAssetMutex.RUnlock() - return fake.downloadReleaseAssetArgsForCall[i].asset -} - -func (fake *FakeGitHub) DownloadReleaseAssetReturns(result1 io.ReadCloser, result2 error) { - fake.DownloadReleaseAssetStub = nil - fake.downloadReleaseAssetReturns = struct { - result1 io.ReadCloser - result2 error - }{result1, result2} -} - -func (fake *FakeGitHub) GetTarballLink(tag string) (*url.URL, error) { - fake.getTarballLinkMutex.Lock() - fake.getTarballLinkArgsForCall = append(fake.getTarballLinkArgsForCall, struct { - tag string - }{tag}) - fake.getTarballLinkMutex.Unlock() - if fake.GetTarballLinkStub != nil { - return fake.GetTarballLinkStub(tag) - } else { - return fake.getTarballLinkReturns.result1, fake.getTarballLinkReturns.result2 - } -} - -func (fake *FakeGitHub) GetTarballLinkCallCount() int { - fake.getTarballLinkMutex.RLock() - defer fake.getTarballLinkMutex.RUnlock() - return len(fake.getTarballLinkArgsForCall) -} - -func (fake *FakeGitHub) GetTarballLinkArgsForCall(i int) string { - fake.getTarballLinkMutex.RLock() - defer fake.getTarballLinkMutex.RUnlock() - return fake.getTarballLinkArgsForCall[i].tag -} - -func (fake *FakeGitHub) GetTarballLinkReturns(result1 *url.URL, result2 error) { - fake.GetTarballLinkStub = nil - fake.getTarballLinkReturns = struct { - result1 *url.URL - result2 error - }{result1, result2} -} - -func (fake *FakeGitHub) GetZipballLink(tag string) (*url.URL, error) { - fake.getZipballLinkMutex.Lock() - fake.getZipballLinkArgsForCall = append(fake.getZipballLinkArgsForCall, struct { - tag string - }{tag}) - fake.getZipballLinkMutex.Unlock() - if fake.GetZipballLinkStub != nil { - return fake.GetZipballLinkStub(tag) - } else { - return fake.getZipballLinkReturns.result1, fake.getZipballLinkReturns.result2 - } -} - -func (fake *FakeGitHub) GetZipballLinkCallCount() int { - fake.getZipballLinkMutex.RLock() - defer fake.getZipballLinkMutex.RUnlock() - return len(fake.getZipballLinkArgsForCall) -} - -func (fake *FakeGitHub) GetZipballLinkArgsForCall(i int) string { - fake.getZipballLinkMutex.RLock() - defer fake.getZipballLinkMutex.RUnlock() - return fake.getZipballLinkArgsForCall[i].tag -} - -func (fake *FakeGitHub) GetZipballLinkReturns(result1 *url.URL, result2 error) { - fake.GetZipballLinkStub = nil - fake.getZipballLinkReturns = struct { - result1 *url.URL - result2 error - }{result1, result2} -} - -func (fake *FakeGitHub) GetRef(tag string) (*github.Reference, error) { - fake.getRefMutex.Lock() - fake.getRefArgsForCall = append(fake.getRefArgsForCall, struct { - tag string - }{tag}) - fake.getRefMutex.Unlock() - if fake.GetRefStub != nil { - return fake.GetRefStub(tag) - } else { - return fake.getRefReturns.result1, fake.getRefReturns.result2 - } -} - -func (fake *FakeGitHub) GetRefCallCount() int { - fake.getRefMutex.RLock() - defer fake.getRefMutex.RUnlock() - return len(fake.getRefArgsForCall) -} - -func (fake *FakeGitHub) GetRefArgsForCall(i int) string { - fake.getRefMutex.RLock() - defer fake.getRefMutex.RUnlock() - return fake.getRefArgsForCall[i].tag -} - -func (fake *FakeGitHub) GetRefReturns(result1 *github.Reference, result2 error) { - fake.GetRefStub = nil - fake.getRefReturns = struct { - result1 *github.Reference - result2 error - }{result1, result2} -} - -var _ resource.GitHub = new(FakeGitHub) diff --git a/fakes/fake_git_lab.go b/fakes/fake_git_lab.go new file mode 100644 index 0000000..21e3c81 --- /dev/null +++ b/fakes/fake_git_lab.go @@ -0,0 +1,656 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package fakes + +import ( + sync "sync" + + resource "github.com/edtan/gitlab-release-resource" + gitlab "github.com/xanzy/go-gitlab" +) + +type FakeGitLab struct { + CreateReleaseStub func(string, string) (*gitlab.Release, error) + createReleaseMutex sync.RWMutex + createReleaseArgsForCall []struct { + arg1 string + arg2 string + } + createReleaseReturns struct { + result1 *gitlab.Release + result2 error + } + createReleaseReturnsOnCall map[int]struct { + result1 *gitlab.Release + result2 error + } + CreateTagStub func(string, string) (*gitlab.Tag, error) + createTagMutex sync.RWMutex + createTagArgsForCall []struct { + arg1 string + arg2 string + } + createTagReturns struct { + result1 *gitlab.Tag + result2 error + } + createTagReturnsOnCall map[int]struct { + result1 *gitlab.Tag + result2 error + } + DownloadProjectFileStub func(string, string) error + downloadProjectFileMutex sync.RWMutex + downloadProjectFileArgsForCall []struct { + arg1 string + arg2 string + } + downloadProjectFileReturns struct { + result1 error + } + downloadProjectFileReturnsOnCall map[int]struct { + result1 error + } + GetTagStub func(string) (*gitlab.Tag, error) + getTagMutex sync.RWMutex + getTagArgsForCall []struct { + arg1 string + } + getTagReturns struct { + result1 *gitlab.Tag + result2 error + } + getTagReturnsOnCall map[int]struct { + result1 *gitlab.Tag + result2 error + } + ListTagsStub func() ([]*gitlab.Tag, error) + listTagsMutex sync.RWMutex + listTagsArgsForCall []struct { + } + listTagsReturns struct { + result1 []*gitlab.Tag + result2 error + } + listTagsReturnsOnCall map[int]struct { + result1 []*gitlab.Tag + result2 error + } + ListTagsUntilStub func(string) ([]*gitlab.Tag, error) + listTagsUntilMutex sync.RWMutex + listTagsUntilArgsForCall []struct { + arg1 string + } + listTagsUntilReturns struct { + result1 []*gitlab.Tag + result2 error + } + listTagsUntilReturnsOnCall map[int]struct { + result1 []*gitlab.Tag + result2 error + } + UpdateReleaseStub func(string, string) (*gitlab.Release, error) + updateReleaseMutex sync.RWMutex + updateReleaseArgsForCall []struct { + arg1 string + arg2 string + } + updateReleaseReturns struct { + result1 *gitlab.Release + result2 error + } + updateReleaseReturnsOnCall map[int]struct { + result1 *gitlab.Release + result2 error + } + UploadProjectFileStub func(string) (*gitlab.ProjectFile, error) + uploadProjectFileMutex sync.RWMutex + uploadProjectFileArgsForCall []struct { + arg1 string + } + uploadProjectFileReturns struct { + result1 *gitlab.ProjectFile + result2 error + } + uploadProjectFileReturnsOnCall map[int]struct { + result1 *gitlab.ProjectFile + result2 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeGitLab) CreateRelease(arg1 string, arg2 string) (*gitlab.Release, error) { + fake.createReleaseMutex.Lock() + ret, specificReturn := fake.createReleaseReturnsOnCall[len(fake.createReleaseArgsForCall)] + fake.createReleaseArgsForCall = append(fake.createReleaseArgsForCall, struct { + arg1 string + arg2 string + }{arg1, arg2}) + fake.recordInvocation("CreateRelease", []interface{}{arg1, arg2}) + fake.createReleaseMutex.Unlock() + if fake.CreateReleaseStub != nil { + return fake.CreateReleaseStub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + fakeReturns := fake.createReleaseReturns + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeGitLab) CreateReleaseCallCount() int { + fake.createReleaseMutex.RLock() + defer fake.createReleaseMutex.RUnlock() + return len(fake.createReleaseArgsForCall) +} + +func (fake *FakeGitLab) CreateReleaseCalls(stub func(string, string) (*gitlab.Release, error)) { + fake.createReleaseMutex.Lock() + defer fake.createReleaseMutex.Unlock() + fake.CreateReleaseStub = stub +} + +func (fake *FakeGitLab) CreateReleaseArgsForCall(i int) (string, string) { + fake.createReleaseMutex.RLock() + defer fake.createReleaseMutex.RUnlock() + argsForCall := fake.createReleaseArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeGitLab) CreateReleaseReturns(result1 *gitlab.Release, result2 error) { + fake.createReleaseMutex.Lock() + defer fake.createReleaseMutex.Unlock() + fake.CreateReleaseStub = nil + fake.createReleaseReturns = struct { + result1 *gitlab.Release + result2 error + }{result1, result2} +} + +func (fake *FakeGitLab) CreateReleaseReturnsOnCall(i int, result1 *gitlab.Release, result2 error) { + fake.createReleaseMutex.Lock() + defer fake.createReleaseMutex.Unlock() + fake.CreateReleaseStub = nil + if fake.createReleaseReturnsOnCall == nil { + fake.createReleaseReturnsOnCall = make(map[int]struct { + result1 *gitlab.Release + result2 error + }) + } + fake.createReleaseReturnsOnCall[i] = struct { + result1 *gitlab.Release + result2 error + }{result1, result2} +} + +func (fake *FakeGitLab) CreateTag(arg1 string, arg2 string) (*gitlab.Tag, error) { + fake.createTagMutex.Lock() + ret, specificReturn := fake.createTagReturnsOnCall[len(fake.createTagArgsForCall)] + fake.createTagArgsForCall = append(fake.createTagArgsForCall, struct { + arg1 string + arg2 string + }{arg1, arg2}) + fake.recordInvocation("CreateTag", []interface{}{arg1, arg2}) + fake.createTagMutex.Unlock() + if fake.CreateTagStub != nil { + return fake.CreateTagStub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + fakeReturns := fake.createTagReturns + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeGitLab) CreateTagCallCount() int { + fake.createTagMutex.RLock() + defer fake.createTagMutex.RUnlock() + return len(fake.createTagArgsForCall) +} + +func (fake *FakeGitLab) CreateTagCalls(stub func(string, string) (*gitlab.Tag, error)) { + fake.createTagMutex.Lock() + defer fake.createTagMutex.Unlock() + fake.CreateTagStub = stub +} + +func (fake *FakeGitLab) CreateTagArgsForCall(i int) (string, string) { + fake.createTagMutex.RLock() + defer fake.createTagMutex.RUnlock() + argsForCall := fake.createTagArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeGitLab) CreateTagReturns(result1 *gitlab.Tag, result2 error) { + fake.createTagMutex.Lock() + defer fake.createTagMutex.Unlock() + fake.CreateTagStub = nil + fake.createTagReturns = struct { + result1 *gitlab.Tag + result2 error + }{result1, result2} +} + +func (fake *FakeGitLab) CreateTagReturnsOnCall(i int, result1 *gitlab.Tag, result2 error) { + fake.createTagMutex.Lock() + defer fake.createTagMutex.Unlock() + fake.CreateTagStub = nil + if fake.createTagReturnsOnCall == nil { + fake.createTagReturnsOnCall = make(map[int]struct { + result1 *gitlab.Tag + result2 error + }) + } + fake.createTagReturnsOnCall[i] = struct { + result1 *gitlab.Tag + result2 error + }{result1, result2} +} + +func (fake *FakeGitLab) DownloadProjectFile(arg1 string, arg2 string) error { + fake.downloadProjectFileMutex.Lock() + ret, specificReturn := fake.downloadProjectFileReturnsOnCall[len(fake.downloadProjectFileArgsForCall)] + fake.downloadProjectFileArgsForCall = append(fake.downloadProjectFileArgsForCall, struct { + arg1 string + arg2 string + }{arg1, arg2}) + fake.recordInvocation("DownloadProjectFile", []interface{}{arg1, arg2}) + fake.downloadProjectFileMutex.Unlock() + if fake.DownloadProjectFileStub != nil { + return fake.DownloadProjectFileStub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + fakeReturns := fake.downloadProjectFileReturns + return fakeReturns.result1 +} + +func (fake *FakeGitLab) DownloadProjectFileCallCount() int { + fake.downloadProjectFileMutex.RLock() + defer fake.downloadProjectFileMutex.RUnlock() + return len(fake.downloadProjectFileArgsForCall) +} + +func (fake *FakeGitLab) DownloadProjectFileCalls(stub func(string, string) error) { + fake.downloadProjectFileMutex.Lock() + defer fake.downloadProjectFileMutex.Unlock() + fake.DownloadProjectFileStub = stub +} + +func (fake *FakeGitLab) DownloadProjectFileArgsForCall(i int) (string, string) { + fake.downloadProjectFileMutex.RLock() + defer fake.downloadProjectFileMutex.RUnlock() + argsForCall := fake.downloadProjectFileArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeGitLab) DownloadProjectFileReturns(result1 error) { + fake.downloadProjectFileMutex.Lock() + defer fake.downloadProjectFileMutex.Unlock() + fake.DownloadProjectFileStub = nil + fake.downloadProjectFileReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeGitLab) DownloadProjectFileReturnsOnCall(i int, result1 error) { + fake.downloadProjectFileMutex.Lock() + defer fake.downloadProjectFileMutex.Unlock() + fake.DownloadProjectFileStub = nil + if fake.downloadProjectFileReturnsOnCall == nil { + fake.downloadProjectFileReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.downloadProjectFileReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeGitLab) GetTag(arg1 string) (*gitlab.Tag, error) { + fake.getTagMutex.Lock() + ret, specificReturn := fake.getTagReturnsOnCall[len(fake.getTagArgsForCall)] + fake.getTagArgsForCall = append(fake.getTagArgsForCall, struct { + arg1 string + }{arg1}) + fake.recordInvocation("GetTag", []interface{}{arg1}) + fake.getTagMutex.Unlock() + if fake.GetTagStub != nil { + return fake.GetTagStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + fakeReturns := fake.getTagReturns + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeGitLab) GetTagCallCount() int { + fake.getTagMutex.RLock() + defer fake.getTagMutex.RUnlock() + return len(fake.getTagArgsForCall) +} + +func (fake *FakeGitLab) GetTagCalls(stub func(string) (*gitlab.Tag, error)) { + fake.getTagMutex.Lock() + defer fake.getTagMutex.Unlock() + fake.GetTagStub = stub +} + +func (fake *FakeGitLab) GetTagArgsForCall(i int) string { + fake.getTagMutex.RLock() + defer fake.getTagMutex.RUnlock() + argsForCall := fake.getTagArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeGitLab) GetTagReturns(result1 *gitlab.Tag, result2 error) { + fake.getTagMutex.Lock() + defer fake.getTagMutex.Unlock() + fake.GetTagStub = nil + fake.getTagReturns = struct { + result1 *gitlab.Tag + result2 error + }{result1, result2} +} + +func (fake *FakeGitLab) GetTagReturnsOnCall(i int, result1 *gitlab.Tag, result2 error) { + fake.getTagMutex.Lock() + defer fake.getTagMutex.Unlock() + fake.GetTagStub = nil + if fake.getTagReturnsOnCall == nil { + fake.getTagReturnsOnCall = make(map[int]struct { + result1 *gitlab.Tag + result2 error + }) + } + fake.getTagReturnsOnCall[i] = struct { + result1 *gitlab.Tag + result2 error + }{result1, result2} +} + +func (fake *FakeGitLab) ListTags() ([]*gitlab.Tag, error) { + fake.listTagsMutex.Lock() + ret, specificReturn := fake.listTagsReturnsOnCall[len(fake.listTagsArgsForCall)] + fake.listTagsArgsForCall = append(fake.listTagsArgsForCall, struct { + }{}) + fake.recordInvocation("ListTags", []interface{}{}) + fake.listTagsMutex.Unlock() + if fake.ListTagsStub != nil { + return fake.ListTagsStub() + } + if specificReturn { + return ret.result1, ret.result2 + } + fakeReturns := fake.listTagsReturns + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeGitLab) ListTagsCallCount() int { + fake.listTagsMutex.RLock() + defer fake.listTagsMutex.RUnlock() + return len(fake.listTagsArgsForCall) +} + +func (fake *FakeGitLab) ListTagsCalls(stub func() ([]*gitlab.Tag, error)) { + fake.listTagsMutex.Lock() + defer fake.listTagsMutex.Unlock() + fake.ListTagsStub = stub +} + +func (fake *FakeGitLab) ListTagsReturns(result1 []*gitlab.Tag, result2 error) { + fake.listTagsMutex.Lock() + defer fake.listTagsMutex.Unlock() + fake.ListTagsStub = nil + fake.listTagsReturns = struct { + result1 []*gitlab.Tag + result2 error + }{result1, result2} +} + +func (fake *FakeGitLab) ListTagsReturnsOnCall(i int, result1 []*gitlab.Tag, result2 error) { + fake.listTagsMutex.Lock() + defer fake.listTagsMutex.Unlock() + fake.ListTagsStub = nil + if fake.listTagsReturnsOnCall == nil { + fake.listTagsReturnsOnCall = make(map[int]struct { + result1 []*gitlab.Tag + result2 error + }) + } + fake.listTagsReturnsOnCall[i] = struct { + result1 []*gitlab.Tag + result2 error + }{result1, result2} +} + +func (fake *FakeGitLab) ListTagsUntil(arg1 string) ([]*gitlab.Tag, error) { + fake.listTagsUntilMutex.Lock() + ret, specificReturn := fake.listTagsUntilReturnsOnCall[len(fake.listTagsUntilArgsForCall)] + fake.listTagsUntilArgsForCall = append(fake.listTagsUntilArgsForCall, struct { + arg1 string + }{arg1}) + fake.recordInvocation("ListTagsUntil", []interface{}{arg1}) + fake.listTagsUntilMutex.Unlock() + if fake.ListTagsUntilStub != nil { + return fake.ListTagsUntilStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + fakeReturns := fake.listTagsUntilReturns + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeGitLab) ListTagsUntilCallCount() int { + fake.listTagsUntilMutex.RLock() + defer fake.listTagsUntilMutex.RUnlock() + return len(fake.listTagsUntilArgsForCall) +} + +func (fake *FakeGitLab) ListTagsUntilCalls(stub func(string) ([]*gitlab.Tag, error)) { + fake.listTagsUntilMutex.Lock() + defer fake.listTagsUntilMutex.Unlock() + fake.ListTagsUntilStub = stub +} + +func (fake *FakeGitLab) ListTagsUntilArgsForCall(i int) string { + fake.listTagsUntilMutex.RLock() + defer fake.listTagsUntilMutex.RUnlock() + argsForCall := fake.listTagsUntilArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeGitLab) ListTagsUntilReturns(result1 []*gitlab.Tag, result2 error) { + fake.listTagsUntilMutex.Lock() + defer fake.listTagsUntilMutex.Unlock() + fake.ListTagsUntilStub = nil + fake.listTagsUntilReturns = struct { + result1 []*gitlab.Tag + result2 error + }{result1, result2} +} + +func (fake *FakeGitLab) ListTagsUntilReturnsOnCall(i int, result1 []*gitlab.Tag, result2 error) { + fake.listTagsUntilMutex.Lock() + defer fake.listTagsUntilMutex.Unlock() + fake.ListTagsUntilStub = nil + if fake.listTagsUntilReturnsOnCall == nil { + fake.listTagsUntilReturnsOnCall = make(map[int]struct { + result1 []*gitlab.Tag + result2 error + }) + } + fake.listTagsUntilReturnsOnCall[i] = struct { + result1 []*gitlab.Tag + result2 error + }{result1, result2} +} + +func (fake *FakeGitLab) UpdateRelease(arg1 string, arg2 string) (*gitlab.Release, error) { + fake.updateReleaseMutex.Lock() + ret, specificReturn := fake.updateReleaseReturnsOnCall[len(fake.updateReleaseArgsForCall)] + fake.updateReleaseArgsForCall = append(fake.updateReleaseArgsForCall, struct { + arg1 string + arg2 string + }{arg1, arg2}) + fake.recordInvocation("UpdateRelease", []interface{}{arg1, arg2}) + fake.updateReleaseMutex.Unlock() + if fake.UpdateReleaseStub != nil { + return fake.UpdateReleaseStub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + fakeReturns := fake.updateReleaseReturns + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeGitLab) UpdateReleaseCallCount() int { + fake.updateReleaseMutex.RLock() + defer fake.updateReleaseMutex.RUnlock() + return len(fake.updateReleaseArgsForCall) +} + +func (fake *FakeGitLab) UpdateReleaseCalls(stub func(string, string) (*gitlab.Release, error)) { + fake.updateReleaseMutex.Lock() + defer fake.updateReleaseMutex.Unlock() + fake.UpdateReleaseStub = stub +} + +func (fake *FakeGitLab) UpdateReleaseArgsForCall(i int) (string, string) { + fake.updateReleaseMutex.RLock() + defer fake.updateReleaseMutex.RUnlock() + argsForCall := fake.updateReleaseArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeGitLab) UpdateReleaseReturns(result1 *gitlab.Release, result2 error) { + fake.updateReleaseMutex.Lock() + defer fake.updateReleaseMutex.Unlock() + fake.UpdateReleaseStub = nil + fake.updateReleaseReturns = struct { + result1 *gitlab.Release + result2 error + }{result1, result2} +} + +func (fake *FakeGitLab) UpdateReleaseReturnsOnCall(i int, result1 *gitlab.Release, result2 error) { + fake.updateReleaseMutex.Lock() + defer fake.updateReleaseMutex.Unlock() + fake.UpdateReleaseStub = nil + if fake.updateReleaseReturnsOnCall == nil { + fake.updateReleaseReturnsOnCall = make(map[int]struct { + result1 *gitlab.Release + result2 error + }) + } + fake.updateReleaseReturnsOnCall[i] = struct { + result1 *gitlab.Release + result2 error + }{result1, result2} +} + +func (fake *FakeGitLab) UploadProjectFile(arg1 string) (*gitlab.ProjectFile, error) { + fake.uploadProjectFileMutex.Lock() + ret, specificReturn := fake.uploadProjectFileReturnsOnCall[len(fake.uploadProjectFileArgsForCall)] + fake.uploadProjectFileArgsForCall = append(fake.uploadProjectFileArgsForCall, struct { + arg1 string + }{arg1}) + fake.recordInvocation("UploadProjectFile", []interface{}{arg1}) + fake.uploadProjectFileMutex.Unlock() + if fake.UploadProjectFileStub != nil { + return fake.UploadProjectFileStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + fakeReturns := fake.uploadProjectFileReturns + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeGitLab) UploadProjectFileCallCount() int { + fake.uploadProjectFileMutex.RLock() + defer fake.uploadProjectFileMutex.RUnlock() + return len(fake.uploadProjectFileArgsForCall) +} + +func (fake *FakeGitLab) UploadProjectFileCalls(stub func(string) (*gitlab.ProjectFile, error)) { + fake.uploadProjectFileMutex.Lock() + defer fake.uploadProjectFileMutex.Unlock() + fake.UploadProjectFileStub = stub +} + +func (fake *FakeGitLab) UploadProjectFileArgsForCall(i int) string { + fake.uploadProjectFileMutex.RLock() + defer fake.uploadProjectFileMutex.RUnlock() + argsForCall := fake.uploadProjectFileArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeGitLab) UploadProjectFileReturns(result1 *gitlab.ProjectFile, result2 error) { + fake.uploadProjectFileMutex.Lock() + defer fake.uploadProjectFileMutex.Unlock() + fake.UploadProjectFileStub = nil + fake.uploadProjectFileReturns = struct { + result1 *gitlab.ProjectFile + result2 error + }{result1, result2} +} + +func (fake *FakeGitLab) UploadProjectFileReturnsOnCall(i int, result1 *gitlab.ProjectFile, result2 error) { + fake.uploadProjectFileMutex.Lock() + defer fake.uploadProjectFileMutex.Unlock() + fake.UploadProjectFileStub = nil + if fake.uploadProjectFileReturnsOnCall == nil { + fake.uploadProjectFileReturnsOnCall = make(map[int]struct { + result1 *gitlab.ProjectFile + result2 error + }) + } + fake.uploadProjectFileReturnsOnCall[i] = struct { + result1 *gitlab.ProjectFile + result2 error + }{result1, result2} +} + +func (fake *FakeGitLab) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + fake.createReleaseMutex.RLock() + defer fake.createReleaseMutex.RUnlock() + fake.createTagMutex.RLock() + defer fake.createTagMutex.RUnlock() + fake.downloadProjectFileMutex.RLock() + defer fake.downloadProjectFileMutex.RUnlock() + fake.getTagMutex.RLock() + defer fake.getTagMutex.RUnlock() + fake.listTagsMutex.RLock() + defer fake.listTagsMutex.RUnlock() + fake.listTagsUntilMutex.RLock() + defer fake.listTagsUntilMutex.RUnlock() + fake.updateReleaseMutex.RLock() + defer fake.updateReleaseMutex.RUnlock() + fake.uploadProjectFileMutex.RLock() + defer fake.uploadProjectFileMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeGitLab) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ resource.GitLab = new(FakeGitLab) diff --git a/gitlab_test.go b/gitlab_test.go index 4254e21..942dc25 100644 --- a/gitlab_test.go +++ b/gitlab_test.go @@ -3,18 +3,18 @@ package resource_test import ( "net/http" - . "github.com/concourse/github-release-resource" + . "github.com/edtan/gitlab-release-resource" . "github.com/onsi/ginkgo" . "github.com/onsi/gomega" "github.com/onsi/gomega/ghttp" - "github.com/google/go-github/github" + "github.com/xanzy/go-gitlab" ) -var _ = Describe("GitHub Client", func() { +var _ = Describe("GitLab Client", func() { var server *ghttp.Server - var client *GitHubClient + var client *GitlabClient var source Source BeforeEach(func() { @@ -22,10 +22,10 @@ var _ = Describe("GitHub Client", func() { }) JustBeforeEach(func() { - source.GitHubAPIURL = server.URL() + source.GitLabAPIURL = server.URL() var err error - client, err = NewGitHubClient(source) + client, err = NewGitLabClient(source) Ω(err).ShouldNot(HaveOccurred()) }) @@ -39,16 +39,9 @@ var _ = Describe("GitHub Client", func() { }) It("returns an error if the API URL is bad", func() { - source.GitHubAPIURL = ":" + source.GitLabAPIURL = ":" - _, err := NewGitHubClient(source) - Ω(err).Should(HaveOccurred()) - }) - - It("returns an error if the API URL is bad", func() { - source.GitHubUploadsURL = ":" - - _, err := NewGitHubClient(source) + _, err := NewGitLabClient(source) Ω(err).Should(HaveOccurred()) }) }) @@ -56,7 +49,6 @@ var _ = Describe("GitHub Client", func() { Context("with an OAuth Token", func() { BeforeEach(func() { source = Source{ - Owner: "concourse", Repository: "concourse", AccessToken: "abc123", } @@ -71,7 +63,7 @@ var _ = Describe("GitHub Client", func() { }) It("sends one", func() { - _, err := client.ListReleases() + _, err := client.ListTags() Ω(err).ShouldNot(HaveOccurred()) }) }) @@ -79,7 +71,6 @@ var _ = Describe("GitHub Client", func() { Context("without an OAuth Token", func() { BeforeEach(func() { source = Source{ - Owner: "concourse", Repository: "concourse", } @@ -93,28 +84,7 @@ var _ = Describe("GitHub Client", func() { }) It("sends one", func() { - _, err := client.ListReleases() - Ω(err).ShouldNot(HaveOccurred()) - }) - }) - - Describe("when the source is configured with the deprecated user field", func() { - BeforeEach(func() { - source = Source{ - User: "some-owner", - Repository: "some-repo", - } - - server.AppendHandlers( - ghttp.CombineHandlers( - ghttp.VerifyRequest("GET", "/repos/some-owner/some-repo/releases"), - ghttp.RespondWith(200, "[]"), - ), - ) - }) - - It("uses the provided user as the owner", func() { - _, err := client.ListReleases() + _, err := client.ListTags() Ω(err).ShouldNot(HaveOccurred()) }) }) @@ -122,154 +92,38 @@ var _ = Describe("GitHub Client", func() { Describe("GetRelease", func() { BeforeEach(func() { source = Source{ - Owner: "concourse", Repository: "concourse", } }) - Context("When GitHub's rate limit has been exceeded", func() { - BeforeEach(func() { - rateLimitResponse := `{ - "message": "API rate limit exceeded for 127.0.0.1. (But here's the good news: Authenticated requests get a higher rate limit. Check out the documentation for more details.)", - "documentation_url": "https://developer.github.com/v3/#rate-limiting" - }` - - rateLimitHeaders := http.Header(map[string][]string{ - "X-RateLimit-Limit": {"60"}, - "X-RateLimit-Remaining": {"0"}, - "X-RateLimit-Reset": {"1377013266"}, - }) - - server.AppendHandlers( - ghttp.CombineHandlers( - ghttp.VerifyRequest("GET", "/repos/concourse/concourse/releases/20"), - ghttp.RespondWith(403, rateLimitResponse, rateLimitHeaders), - ), - ) - }) - - It("Returns an appropriate error", func() { - _, err := client.GetRelease(20) - Expect(err).ToNot(BeNil()) - Expect(err.Error()).To(ContainSubstring("API rate limit exceeded for 127.0.0.1. (But here's the good news: Authenticated requests get a higher rate limit. Check out the documentation for more details.)")) - }) - }) }) Describe("GetReleaseByTag", func() { BeforeEach(func() { source = Source{ - Owner: "concourse", Repository: "concourse", } }) - Context("When GitHub's rate limit has been exceeded", func() { - BeforeEach(func() { - rateLimitResponse := `{ - "message": "API rate limit exceeded for 127.0.0.1. (But here's the good news: Authenticated requests get a higher rate limit. Check out the documentation for more details.)", - "documentation_url": "https://developer.github.com/v3/#rate-limiting" - }` - - rateLimitHeaders := http.Header(map[string][]string{ - "X-RateLimit-Limit": {"60"}, - "X-RateLimit-Remaining": {"0"}, - "X-RateLimit-Reset": {"1377013266"}, - }) - - server.AppendHandlers( - ghttp.CombineHandlers( - ghttp.VerifyRequest("GET", "/repos/concourse/concourse/releases/tags/some-tag"), - ghttp.RespondWith(403, rateLimitResponse, rateLimitHeaders), - ), - ) - }) - - It("Returns an appropriate error", func() { - _, err := client.GetReleaseByTag("some-tag") - Expect(err).ToNot(BeNil()) - Expect(err.Error()).To(ContainSubstring("API rate limit exceeded for 127.0.0.1. (But here's the good news: Authenticated requests get a higher rate limit. Check out the documentation for more details.)")) - }) - }) - - Context("When GitHub responds successfully", func() { + Context("When GitLab responds successfully", func() { BeforeEach(func() { server.AppendHandlers( ghttp.CombineHandlers( ghttp.VerifyRequest("GET", "/repos/concourse/concourse/releases/tags/some-tag"), - ghttp.RespondWith(200, `{ "id": 1 }`), + ghttp.RespondWith(200, `{ "id": "1" }`), ), ) }) - It("Returns a populated github.RepositoryRelease", func() { - expectedRelease := &github.RepositoryRelease{ - ID: github.Int(1), + It("Returns a populated github.Tag", func() { + expectedRelease := &gitlab.Tag{ + Name: *gitlab.String("1"), } - release, err := client.GetReleaseByTag("some-tag") + release, err := client.GetTag("some-tag") Ω(err).ShouldNot(HaveOccurred()) Expect(release).To(Equal(expectedRelease)) }) }) }) - - Describe("GetRef", func() { - BeforeEach(func() { - source = Source{ - Owner: "concourse", - Repository: "concourse", - } - }) - - Context("When GitHub's rate limit has been exceeded", func() { - BeforeEach(func() { - rateLimitResponse := `{ - "message": "API rate limit exceeded for 127.0.0.1. (But here's the good news: Authenticated requests get a higher rate limit. Check out the documentation for more details.)", - "documentation_url": "https://developer.github.com/v3/#rate-limiting" - }` - - rateLimitHeaders := http.Header(map[string][]string{ - "X-RateLimit-Limit": {"60"}, - "X-RateLimit-Remaining": {"0"}, - "X-RateLimit-Reset": {"1377013266"}, - }) - - server.AppendHandlers( - ghttp.CombineHandlers( - ghttp.VerifyRequest("GET", "/repos/concourse/concourse/git/refs/tags/some-tag"), - ghttp.RespondWith(403, rateLimitResponse, rateLimitHeaders), - ), - ) - }) - - It("Returns an appropriate error", func() { - _, err := client.GetRef("some-tag") - Expect(err).ToNot(BeNil()) - Expect(err.Error()).To(ContainSubstring("API rate limit exceeded for 127.0.0.1. (But here's the good news: Authenticated requests get a higher rate limit. Check out the documentation for more details.)")) - }) - }) - - Context("When GitHub responds successfully", func() { - BeforeEach(func() { - server.AppendHandlers( - ghttp.CombineHandlers( - ghttp.VerifyRequest("GET", "/repos/concourse/concourse/git/refs/tags/some-tag"), - ghttp.RespondWith(200, `{ "ref": "refs/tags/some-tag" }`), - ), - ) - }) - - It("Returns a populated github.Reference", func() { - expectedReference := &github.Reference{ - Ref: github.String("refs/tags/some-tag"), - } - - reference, err := client.GetRef("some-tag") - - Ω(err).ShouldNot(HaveOccurred()) - Expect(reference).To(Equal(expectedReference)) - }) - }) - }) }) diff --git a/go.mod b/go.mod index f9151b0..2aa05b9 100644 --- a/go.mod +++ b/go.mod @@ -4,7 +4,14 @@ require ( github.com/concourse/github-release-resource v1.0.0 github.com/cppforlife/go-semi-semantic v0.0.0-20160921010311-576b6af77ae4 github.com/google/go-github v17.0.0+incompatible + github.com/kr/pretty v0.1.0 // indirect github.com/mitchellh/colorstring v0.0.0-20150917214807-8631ce90f286 + github.com/onsi/ginkgo v1.7.0 + github.com/onsi/gomega v1.4.3 github.com/xanzy/go-gitlab v0.12.0 + golang.org/x/net v0.0.0-20181217023233-e147a9138326 // indirect golang.org/x/oauth2 v0.0.0-20181106182150-f42d05182288 + golang.org/x/sys v0.0.0-20181218192612-074acd46bca6 // indirect + gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 // indirect + gopkg.in/yaml.v2 v2.2.2 // indirect ) diff --git a/go.sum b/go.sum index 86b2c8e..dd6b56a 100644 --- a/go.sum +++ b/go.sum @@ -2,20 +2,55 @@ github.com/concourse/github-release-resource v1.0.0 h1:jpN453IQGRXNZcyKdmIznnBNX github.com/concourse/github-release-resource v1.0.0/go.mod h1:fTyLw17ZewAEU8MSqLNKj5cM4MSNhhi2uVHUALGZ1Zo= github.com/cppforlife/go-semi-semantic v0.0.0-20160921010311-576b6af77ae4 h1:J+ghqo7ZubTzelkjo9hntpTtP/9lUCWH9icEmAW+B+Q= github.com/cppforlife/go-semi-semantic v0.0.0-20160921010311-576b6af77ae4/go.mod h1:socxpf5+mELPbosI149vWpNlHK6mbfWFxSWOoSndXR8= +github.com/fsnotify/fsnotify v1.4.7 h1:IXs+QLmnXW2CcXuY+8Mzv/fWEsPGWxqefPtCP5CnV9I= +github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo= +github.com/golang/protobuf v1.2.0 h1:P3YflyNX/ehuJFLhxviNdFxQPkGK5cDcApsge1SqnvM= github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= github.com/google/go-github v17.0.0+incompatible h1:N0LgJ1j65A7kfXrZnUDaYCs/Sf4rEjNlfyDHW9dolSY= github.com/google/go-github v17.0.0+incompatible/go.mod h1:zLgOLi98H3fifZn+44m+umXrS52loVEgC2AApnigrVQ= github.com/google/go-querystring v1.0.0 h1:Xkwi/a1rcvNg1PPYe5vI8GbeBY/jrVuDX5ASuANWTrk= github.com/google/go-querystring v1.0.0/go.mod h1:odCYkC5MyYFN7vkCjXpyrEuKhc/BUO6wN/zVPAxq5ck= +github.com/hpcloud/tail v1.0.0 h1:nfCOvKYfkgYP8hkirhJocXT2+zOD8yUNjXaWfTlyFKI= +github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU= +github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI= +github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= +github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= +github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE= +github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= github.com/mitchellh/colorstring v0.0.0-20150917214807-8631ce90f286 h1:KHyL+3mQOF9sPfs26lsefckcFNDcIZtiACQiECzIUkw= github.com/mitchellh/colorstring v0.0.0-20150917214807-8631ce90f286/go.mod h1:l0dey0ia/Uv7NcFFVbCLtqEBQbrT4OCwCSKTEv6enCw= +github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= +github.com/onsi/ginkgo v1.7.0 h1:WSHQ+IS43OoUrWtD1/bbclrwK8TTH5hzp+umCiuxHgs= +github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= +github.com/onsi/gomega v1.4.3 h1:RE1xgDvH7imwFD45h+u2SgIfERHlS2yNG4DObb5BSKU= +github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY= github.com/xanzy/go-gitlab v0.12.0 h1:rs40DfrKvJoIluarQJcFmOADVMlgFGDMXvnEeQpjqGg= github.com/xanzy/go-gitlab v0.12.0/go.mod h1:8zdQa/ri1dfn8eS3Ir1SyfvOKlw7WBJ8DVThkpGiXrs= golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20181108082009-03003ca0c849 h1:FSqE2GGG7wzsYUsWiQ8MZrvEd1EOyU3NCF0AW3Wtltg= golang.org/x/net v0.0.0-20181108082009-03003ca0c849/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20181217023233-e147a9138326 h1:iCzOf0xz39Tstp+Tu/WwyGjUXCk34QhQORRxBeXXTA4= +golang.org/x/net v0.0.0-20181217023233-e147a9138326/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/oauth2 v0.0.0-20181106182150-f42d05182288 h1:JIqe8uIcRBHXDQVvZtHwp80ai3Lw3IJAeJEs55Dc1W0= golang.org/x/oauth2 v0.0.0-20181106182150-f42d05182288/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= +golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20181108010431-42b317875d0f h1:Bl/8QSvNqXvPGPGXa2z5xUTmV7VDcZyvRZ+QQXkXTZQ= golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20181218192612-074acd46bca6 h1:MXtOG7w2ND9qNCUZSDBGll/SpVIq7ftozR9I8/JGBHY= +golang.org/x/sys v0.0.0-20181218192612-074acd46bca6/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +google.golang.org/appengine v1.3.0 h1:FBSsiFRMz3LBeXIomRnVzrQwSDj4ibvcRexLG0LZGQk= google.golang.org/appengine v1.3.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY= +gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/fsnotify.v1 v1.4.7 h1:xOHLXZwVvI9hhs+cLKq5+I5onOuwQLhQwiu63xxlHs4= +gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys= +gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ= +gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw= +gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw= +gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= diff --git a/in_command_test.go b/in_command_test.go index 87f28c3..5b4c3b7 100644 --- a/in_command_test.go +++ b/in_command_test.go @@ -1,11 +1,8 @@ package resource_test import ( - "bytes" "errors" "io/ioutil" - "net/http" - "net/url" "os" "path" "path/filepath" @@ -14,17 +11,17 @@ import ( . "github.com/onsi/gomega" "github.com/onsi/gomega/ghttp" - "github.com/google/go-github/github" + "github.com/xanzy/go-gitlab" - "github.com/concourse/github-release-resource" - "github.com/concourse/github-release-resource/fakes" + "github.com/edtan/gitlab-release-resource" + "github.com/edtan/gitlab-release-resource/fakes" ) var _ = Describe("In Command", func() { var ( command *resource.InCommand - githubClient *fakes.FakeGitHub - githubServer *ghttp.Server + gitlabClient *fakes.FakeGitLab + gitlabServer *ghttp.Server inRequest resource.InRequest @@ -38,16 +35,16 @@ var _ = Describe("In Command", func() { BeforeEach(func() { var err error - githubClient = &fakes.FakeGitHub{} - githubServer = ghttp.NewServer() - command = resource.NewInCommand(githubClient, ioutil.Discard) + gitlabClient = &fakes.FakeGitLab{} + gitlabServer = ghttp.NewServer() + command = resource.NewInCommand(gitlabClient, ioutil.Discard) - tmpDir, err = ioutil.TempDir("", "github-release") + tmpDir, err = ioutil.TempDir("", "gitlab-release") Ω(err).ShouldNot(HaveOccurred()) destDir = filepath.Join(tmpDir, "destination") - githubClient.DownloadReleaseAssetReturns(ioutil.NopCloser(bytes.NewBufferString("some-content")), nil) + gitlabClient.DownloadProjectFileReturns(nil) inRequest = resource.InRequest{} }) @@ -56,59 +53,19 @@ var _ = Describe("In Command", func() { Ω(os.RemoveAll(tmpDir)).Should(Succeed()) }) - buildRelease := func(id int, tag string, draft bool) *github.RepositoryRelease { - return &github.RepositoryRelease{ - ID: github.Int(id), - TagName: github.String(tag), - HTMLURL: github.String("http://google.com"), - Name: github.String("release-name"), - Body: github.String("*markdown*"), - Draft: github.Bool(draft), - Prerelease: github.Bool(false), - } - } - - buildNilTagRelease := func(id int) *github.RepositoryRelease { - return &github.RepositoryRelease{ - ID: github.Int(id), - HTMLURL: github.String("http://google.com"), - Name: github.String("release-name"), - Body: github.String("*markdown*"), - Draft: github.Bool(true), - Prerelease: github.Bool(false), - } - } - - buildAsset := func(id int, name string) *github.ReleaseAsset { - return &github.ReleaseAsset{ - ID: github.Int(id), - Name: &name, - } - } - - buildTagRef := func(tagRef, commitSHA string) *github.Reference { - return &github.Reference{ - Ref: github.String(tagRef), - URL: github.String("https://example.com"), - Object: &github.GitObject{ - Type: github.String("commit"), - SHA: github.String(commitSHA), - URL: github.String("https://example.com"), + buildTag := func(sha, tag string) *gitlab.Tag { + return &gitlab.Tag{ + Commit: &gitlab.Commit{ + ID: *gitlab.String(sha), }, + Name: *gitlab.String(tag), } } Context("when there is a tagged release", func() { Context("when a present version is specified", func() { BeforeEach(func() { - githubClient.GetReleaseByTagReturns(buildRelease(1, "v0.35.0", false), nil) - githubClient.GetRefReturns(buildTagRef("v0.35.0", "f28085a4a8f744da83411f5e09fd7b1709149eee"), nil) - - githubClient.ListReleaseAssetsReturns([]*github.ReleaseAsset{ - buildAsset(0, "example.txt"), - buildAsset(1, "example.rtf"), - buildAsset(2, "example.wtf"), - }, nil) + gitlabClient.GetTagReturns(buildTag("v0.35.0", "abc123"), nil) inRequest.Version = &resource.Version{ Tag: "v0.35.0", @@ -138,26 +95,28 @@ var _ = Describe("In Command", func() { inResponse, inErr = command.Run(destDir, inRequest) Ω(inResponse.Metadata).Should(ConsistOf( - resource.MetadataPair{Name: "url", Value: "http://google.com"}, - resource.MetadataPair{Name: "name", Value: "release-name", URL: "http://google.com"}, - resource.MetadataPair{Name: "body", Value: "*markdown*", Markdown: true}, resource.MetadataPair{Name: "tag", Value: "v0.35.0"}, resource.MetadataPair{Name: "commit_sha", Value: "f28085a4a8f744da83411f5e09fd7b1709149eee"}, )) }) - It("calls #GetReleastByTag with the correct arguments", func() { + It("calls #GetTag with the correct arguments", func() { command.Run(destDir, inRequest) - Ω(githubClient.GetReleaseByTagArgsForCall(0)).Should(Equal("v0.35.0")) + Ω(gitlabClient.GetTagArgsForCall(0)).Should(Equal("v0.35.0")) }) It("downloads only the files that match the globs", func() { inResponse, inErr = command.Run(destDir, inRequest) - Expect(githubClient.DownloadReleaseAssetCallCount()).To(Equal(2)) - Ω(githubClient.DownloadReleaseAssetArgsForCall(0)).Should(Equal(*buildAsset(0, "example.txt"))) - Ω(githubClient.DownloadReleaseAssetArgsForCall(1)).Should(Equal(*buildAsset(1, "example.rtf"))) + Expect(gitlabClient.DownloadProjectFileCallCount()).To(Equal(2)) + arg1, arg2 := gitlabClient.DownloadProjectFileArgsForCall(0) + Ω(arg1).Should(Equal("example.txt")) + Ω(arg2).Should(Equal("path")) + + arg1, arg2 = gitlabClient.DownloadProjectFileArgsForCall(1) + Ω(arg1).Should(Equal("example.rtf")) + Ω(arg2).Should(Equal("path")) }) It("does create the body, tag and version files", func() { @@ -185,8 +144,7 @@ var _ = Describe("In Command", func() { inRequest.Source = resource.Source{ TagFilter: "package-(.*)", } - githubClient.GetReleaseByTagReturns(buildRelease(1, "package-0.35.0", false), nil) - githubClient.GetRefReturns(buildTagRef("package-0.35.0", "f28085a4a8f744da83411f5e09fd7b1709149eee"), nil) + gitlabClient.GetTagReturns(buildTag("package-0.35.0", "abc123"), nil) inResponse, inErr = command.Run(destDir, inRequest) }) @@ -209,165 +167,6 @@ var _ = Describe("In Command", func() { }) }) - Context("when include_source_tarball is true", func() { - var tarballUrl *url.URL - - BeforeEach(func() { - inRequest.Params.IncludeSourceTarball = true - - tarballUrl, _ = url.Parse(githubServer.URL()) - tarballUrl.Path = "/gimme-a-tarball/" - }) - - Context("when getting the tarball link succeeds", func() { - BeforeEach(func() { - githubClient.GetTarballLinkReturns(tarballUrl, nil) - }) - - Context("when downloading the tarball succeeds", func() { - BeforeEach(func() { - githubServer.AppendHandlers( - ghttp.CombineHandlers( - ghttp.VerifyRequest("GET", tarballUrl.Path), - ghttp.RespondWith(http.StatusOK, "source-tar-file-contents"), - ), - ) - }) - - It("succeeds", func() { - inResponse, inErr = command.Run(destDir, inRequest) - - Expect(inErr).ToNot(HaveOccurred()) - }) - - It("downloads the source tarball", func() { - inResponse, inErr = command.Run(destDir, inRequest) - - Expect(githubServer.ReceivedRequests()).To(HaveLen(1)) - }) - - It("saves the source tarball in the destination directory", func() { - inResponse, inErr = command.Run(destDir, inRequest) - - fileContents, err := ioutil.ReadFile(filepath.Join(destDir, "source.tar.gz")) - fContents := string(fileContents) - Expect(err).NotTo(HaveOccurred()) - Expect(fContents).To(Equal("source-tar-file-contents")) - }) - }) - - Context("when downloading the tarball fails", func() { - BeforeEach(func() { - githubServer.AppendHandlers( - ghttp.CombineHandlers( - ghttp.VerifyRequest("GET", tarballUrl.Path), - ghttp.RespondWith(http.StatusInternalServerError, ""), - ), - ) - }) - - It("returns an appropriate error", func() { - inResponse, inErr = command.Run(destDir, inRequest) - - Expect(inErr).To(MatchError("failed to download file `source.tar.gz`: HTTP status 500")) - }) - }) - }) - - Context("when getting the tarball link fails", func() { - disaster := errors.New("oh my") - - BeforeEach(func() { - githubClient.GetTarballLinkReturns(nil, disaster) - }) - - It("returns the error", func() { - inResponse, inErr = command.Run(destDir, inRequest) - - Expect(inErr).To(Equal(disaster)) - }) - }) - }) - - Context("when include_source_zip is true", func() { - var zipUrl *url.URL - - BeforeEach(func() { - inRequest.Params.IncludeSourceZip = true - - zipUrl, _ = url.Parse(githubServer.URL()) - zipUrl.Path = "/gimme-a-zip/" - }) - - Context("when getting the zip link succeeds", func() { - BeforeEach(func() { - githubClient.GetZipballLinkReturns(zipUrl, nil) - }) - - Context("when downloading the zip succeeds", func() { - BeforeEach(func() { - githubServer.AppendHandlers( - ghttp.CombineHandlers( - ghttp.VerifyRequest("GET", zipUrl.Path), - ghttp.RespondWith(http.StatusOK, "source-zip-file-contents"), - ), - ) - }) - - It("succeeds", func() { - inResponse, inErr = command.Run(destDir, inRequest) - - Expect(inErr).ToNot(HaveOccurred()) - }) - - It("downloads the source zip", func() { - inResponse, inErr = command.Run(destDir, inRequest) - - Expect(githubServer.ReceivedRequests()).To(HaveLen(1)) - }) - - It("saves the source zip in the destination directory", func() { - inResponse, inErr = command.Run(destDir, inRequest) - - fileContents, err := ioutil.ReadFile(filepath.Join(destDir, "source.zip")) - fContents := string(fileContents) - Expect(err).NotTo(HaveOccurred()) - Expect(fContents).To(Equal("source-zip-file-contents")) - }) - }) - - Context("when downloading the zip fails", func() { - BeforeEach(func() { - githubServer.AppendHandlers( - ghttp.CombineHandlers( - ghttp.VerifyRequest("GET", zipUrl.Path), - ghttp.RespondWith(http.StatusInternalServerError, ""), - ), - ) - }) - - It("returns an appropriate error", func() { - inResponse, inErr = command.Run(destDir, inRequest) - - Expect(inErr).To(MatchError("failed to download file `source.zip`: HTTP status 500")) - }) - }) - }) - - Context("when getting the zip link fails", func() { - disaster := errors.New("oh my") - - BeforeEach(func() { - githubClient.GetZipballLinkReturns(nil, disaster) - }) - - It("returns the error", func() { - inResponse, inErr = command.Run(destDir, inRequest) - - Expect(inErr).To(Equal(disaster)) - }) - }) - }) }) Context("when no globs are specified", func() { @@ -395,15 +194,23 @@ var _ = Describe("In Command", func() { }) It("downloads all of the files", func() { - Ω(githubClient.DownloadReleaseAssetArgsForCall(0)).Should(Equal(*buildAsset(0, "example.txt"))) - Ω(githubClient.DownloadReleaseAssetArgsForCall(1)).Should(Equal(*buildAsset(1, "example.rtf"))) - Ω(githubClient.DownloadReleaseAssetArgsForCall(2)).Should(Equal(*buildAsset(2, "example.wtf"))) + arg1, arg2 := gitlabClient.DownloadProjectFileArgsForCall(0) + Ω(arg1).Should(Equal("example.txt")) + Ω(arg2).Should(Equal("path")) + + arg1, arg2 = gitlabClient.DownloadProjectFileArgsForCall(1) + Ω(arg1).Should(Equal("example.rtf")) + Ω(arg2).Should(Equal("path")) + + arg1, arg2 = gitlabClient.DownloadProjectFileArgsForCall(2) + Ω(arg1).Should(Equal("example.rtf")) + Ω(arg2).Should(Equal("path")) }) }) Context("when downloading an asset fails", func() { BeforeEach(func() { - githubClient.DownloadReleaseAssetReturns(nil, errors.New("not this time")) + gitlabClient.DownloadProjectFileReturns(errors.New("not this time")) inResponse, inErr = command.Run(destDir, inRequest) }) @@ -411,25 +218,12 @@ var _ = Describe("In Command", func() { Ω(inErr).Should(HaveOccurred()) }) }) - - Context("when listing release assets fails", func() { - disaster := errors.New("nope") - - BeforeEach(func() { - githubClient.ListReleaseAssetsReturns(nil, disaster) - inResponse, inErr = command.Run(destDir, inRequest) - }) - - It("returns the error", func() { - Ω(inErr).Should(Equal(disaster)) - }) - }) }) }) Context("when no tagged release is present", func() { BeforeEach(func() { - githubClient.GetReleaseByTagReturns(nil, nil) + gitlabClient.GetTagReturns(nil, nil) inRequest.Version = &resource.Version{ Tag: "v0.40.0", @@ -447,7 +241,7 @@ var _ = Describe("In Command", func() { disaster := errors.New("nope") BeforeEach(func() { - githubClient.GetReleaseByTagReturns(nil, disaster) + gitlabClient.GetTagReturns(nil, disaster) inRequest.Version = &resource.Version{ Tag: "some-tag", @@ -459,108 +253,4 @@ var _ = Describe("In Command", func() { Ω(inErr).Should(Equal(disaster)) }) }) - - Context("when there is a draft release", func() { - Context("which has a tag", func() { - BeforeEach(func() { - githubClient.GetReleaseReturns(buildRelease(1, "v0.35.0", true), nil) - - inRequest.Version = &resource.Version{ID: "1"} - inResponse, inErr = command.Run(destDir, inRequest) - }) - - It("succeeds", func() { - Ω(inErr).ShouldNot(HaveOccurred()) - }) - - It("returns the fetched version", func() { - Ω(inResponse.Version).Should(Equal(resource.Version{ID: "1"})) - }) - - It("has some sweet metadata", func() { - Ω(inResponse.Metadata).Should(ConsistOf( - resource.MetadataPair{Name: "url", Value: "http://google.com"}, - resource.MetadataPair{Name: "name", Value: "release-name", URL: "http://google.com"}, - resource.MetadataPair{Name: "body", Value: "*markdown*", Markdown: true}, - resource.MetadataPair{Name: "tag", Value: "v0.35.0"}, - resource.MetadataPair{Name: "draft", Value: "true"}, - )) - }) - - It("does create the tag and version files", func() { - contents, err := ioutil.ReadFile(path.Join(destDir, "tag")) - Ω(err).ShouldNot(HaveOccurred()) - Ω(string(contents)).Should(Equal("v0.35.0")) - - contents, err = ioutil.ReadFile(path.Join(destDir, "version")) - Ω(err).ShouldNot(HaveOccurred()) - Ω(string(contents)).Should(Equal("0.35.0")) - }) - }) - - Context("which has an empty tag", func() { - BeforeEach(func() { - githubClient.GetReleaseReturns(buildRelease(1, "", true), nil) - - inRequest.Version = &resource.Version{ID: "1"} - inResponse, inErr = command.Run(destDir, inRequest) - }) - - It("succeeds", func() { - Ω(inErr).ShouldNot(HaveOccurred()) - }) - - It("returns the fetched version", func() { - Ω(inResponse.Version).Should(Equal(resource.Version{ID: "1"})) - }) - - It("has some sweet metadata", func() { - Ω(inResponse.Metadata).Should(ConsistOf( - resource.MetadataPair{Name: "url", Value: "http://google.com"}, - resource.MetadataPair{Name: "name", Value: "release-name", URL: "http://google.com"}, - resource.MetadataPair{Name: "body", Value: "*markdown*", Markdown: true}, - resource.MetadataPair{Name: "tag", Value: ""}, - resource.MetadataPair{Name: "draft", Value: "true"}, - )) - }) - - It("does not create the tag and version files", func() { - Ω(path.Join(destDir, "tag")).ShouldNot(BeAnExistingFile()) - Ω(path.Join(destDir, "version")).ShouldNot(BeAnExistingFile()) - Ω(path.Join(destDir, "commit_sha")).ShouldNot(BeAnExistingFile()) - }) - }) - - Context("which has a nil tag", func() { - BeforeEach(func() { - githubClient.GetReleaseReturns(buildNilTagRelease(1), nil) - - inRequest.Version = &resource.Version{ID: "1"} - inResponse, inErr = command.Run(destDir, inRequest) - }) - - It("succeeds", func() { - Ω(inErr).ShouldNot(HaveOccurred()) - }) - - It("returns the fetched version", func() { - Ω(inResponse.Version).Should(Equal(resource.Version{ID: "1"})) - }) - - It("has some sweet metadata", func() { - Ω(inResponse.Metadata).Should(ConsistOf( - resource.MetadataPair{Name: "url", Value: "http://google.com"}, - resource.MetadataPair{Name: "name", Value: "release-name", URL: "http://google.com"}, - resource.MetadataPair{Name: "body", Value: "*markdown*", Markdown: true}, - resource.MetadataPair{Name: "draft", Value: "true"}, - )) - }) - - It("does not create the tag and version files", func() { - Ω(path.Join(destDir, "tag")).ShouldNot(BeAnExistingFile()) - Ω(path.Join(destDir, "version")).ShouldNot(BeAnExistingFile()) - Ω(path.Join(destDir, "commit_sha")).ShouldNot(BeAnExistingFile()) - }) - }) - }) }) diff --git a/out_command_test.go b/out_command_test.go index 0d93d6a..98c5d9a 100644 --- a/out_command_test.go +++ b/out_command_test.go @@ -9,10 +9,10 @@ import ( . "github.com/onsi/ginkgo" . "github.com/onsi/gomega" - "github.com/concourse/github-release-resource" - "github.com/concourse/github-release-resource/fakes" + "github.com/xanzy/go-gitlab" - "github.com/google/go-github/github" + "github.com/edtan/gitlab-release-resource" + "github.com/edtan/gitlab-release-resource/fakes" ) func file(path, contents string) { @@ -22,7 +22,7 @@ func file(path, contents string) { var _ = Describe("Out Command", func() { var ( command *resource.OutCommand - githubClient *fakes.FakeGitHub + gitlabClient *fakes.FakeGitLab sourcesDir string @@ -32,22 +32,22 @@ var _ = Describe("Out Command", func() { BeforeEach(func() { var err error - githubClient = &fakes.FakeGitHub{} - command = resource.NewOutCommand(githubClient, ioutil.Discard) + gitlabClient = &fakes.FakeGitLab{} + command = resource.NewOutCommand(gitlabClient, ioutil.Discard) - sourcesDir, err = ioutil.TempDir("", "github-release") + sourcesDir, err = ioutil.TempDir("", "gitlab-release") Ω(err).ShouldNot(HaveOccurred()) - githubClient.CreateReleaseStub = func(gh github.RepositoryRelease) (*github.RepositoryRelease, error) { + gitlabClient.CreateReleaseStub = func(gh gitlab.Tag) (*gitlab.Tag, error) { createdRel := gh - createdRel.ID = github.Int(112) - createdRel.HTMLURL = github.String("http://google.com") - createdRel.Name = github.String("release-name") - createdRel.Body = github.String("*markdown*") + createdRel.ID = gitlab.Int(112) + createdRel.HTMLURL = gitlab.String("http://google.com") + createdRel.Name = gitlab.String("release-name") + createdRel.Body = gitlab.String("*markdown*") return &createdRel, nil } - githubClient.UpdateReleaseStub = func(gh github.RepositoryRelease) (*github.RepositoryRelease, error) { + gitlabClient.UpdateReleaseStub = func(gh gitlab.Tag) (*gitlab.Tag, error) { return &gh, nil } }) @@ -57,34 +57,34 @@ var _ = Describe("Out Command", func() { }) Context("when the release has already been created", func() { - existingAssets := []github.ReleaseAsset{ + existingAssets := []gitlab.ReleaseAsset{ { - ID: github.Int(456789), - Name: github.String("unicorns.txt"), + ID: gitlab.Int(456789), + Name: gitlab.String("unicorns.txt"), }, { - ID: github.Int(3450798), - Name: github.String("rainbows.txt"), - State: github.String("new"), + ID: gitlab.Int(3450798), + Name: gitlab.String("rainbows.txt"), + State: gitlab.String("new"), }, } - existingReleases := []github.RepositoryRelease{ + existingReleases := []gitlab.Tag{ { - ID: github.Int(1), - Draft: github.Bool(true), + ID: gitlab.Int(1), + Draft: gitlab.Bool(true), }, { - ID: github.Int(112), - TagName: github.String("some-tag-name"), - Assets: []github.ReleaseAsset{existingAssets[0]}, - Draft: github.Bool(false), + ID: gitlab.Int(112), + TagName: gitlab.String("some-tag-name"), + Assets: []gitlab.ReleaseAsset{existingAssets[0]}, + Draft: gitlab.Bool(false), }, } BeforeEach(func() { - githubClient.ListReleasesStub = func() ([]*github.RepositoryRelease, error) { - rels := []*github.RepositoryRelease{} + gitlabClient.ListReleasesStub = func() ([]*gitlab.Tag, error) { + rels := []*gitlab.Tag{} for _, r := range existingReleases { c := r rels = append(rels, &c) @@ -93,8 +93,8 @@ var _ = Describe("Out Command", func() { return rels, nil } - githubClient.ListReleaseAssetsStub = func(github.RepositoryRelease) ([]*github.ReleaseAsset, error) { - assets := []*github.ReleaseAsset{} + gitlabClient.ListReleaseAssetsStub = func(gitlab.Tag) ([]*gitlab.ReleaseAsset, error) { + assets := []*gitlab.ReleaseAsset{} for _, a := range existingAssets { c := a assets = append(assets, &c) @@ -124,13 +124,13 @@ var _ = Describe("Out Command", func() { _, err := command.Run(sourcesDir, request) Ω(err).ShouldNot(HaveOccurred()) - Ω(githubClient.ListReleaseAssetsCallCount()).Should(Equal(1)) - Ω(githubClient.ListReleaseAssetsArgsForCall(0)).Should(Equal(existingReleases[1])) + Ω(gitlabClient.ListReleaseAssetsCallCount()).Should(Equal(1)) + Ω(gitlabClient.ListReleaseAssetsArgsForCall(0)).Should(Equal(existingReleases[1])) - Ω(githubClient.DeleteReleaseAssetCallCount()).Should(Equal(2)) + Ω(gitlabClient.DeleteReleaseAssetCallCount()).Should(Equal(2)) - Ω(githubClient.DeleteReleaseAssetArgsForCall(0)).Should(Equal(existingAssets[0])) - Ω(githubClient.DeleteReleaseAssetArgsForCall(1)).Should(Equal(existingAssets[1])) + Ω(gitlabClient.DeleteReleaseAssetArgsForCall(0)).Should(Equal(existingAssets[0])) + Ω(gitlabClient.DeleteReleaseAssetArgsForCall(1)).Should(Equal(existingAssets[1])) }) Context("when not set as a draft release", func() { @@ -142,9 +142,9 @@ var _ = Describe("Out Command", func() { _, err := command.Run(sourcesDir, request) Ω(err).ShouldNot(HaveOccurred()) - Ω(githubClient.UpdateReleaseCallCount()).Should(Equal(1)) + Ω(gitlabClient.UpdateReleaseCallCount()).Should(Equal(1)) - updatedRelease := githubClient.UpdateReleaseArgsForCall(0) + updatedRelease := gitlabClient.UpdateReleaseArgsForCall(0) Ω(*updatedRelease.Name).Should(Equal("v0.3.12")) Ω(*updatedRelease.Draft).Should(Equal(false)) }) @@ -159,9 +159,9 @@ var _ = Describe("Out Command", func() { _, err := command.Run(sourcesDir, request) Ω(err).ShouldNot(HaveOccurred()) - Ω(githubClient.UpdateReleaseCallCount()).Should(Equal(1)) + Ω(gitlabClient.UpdateReleaseCallCount()).Should(Equal(1)) - updatedRelease := githubClient.UpdateReleaseArgsForCall(0) + updatedRelease := gitlabClient.UpdateReleaseArgsForCall(0) Ω(*updatedRelease.Name).Should(Equal("v0.3.12")) Ω(*updatedRelease.Draft).Should(Equal(true)) }) @@ -176,9 +176,9 @@ var _ = Describe("Out Command", func() { _, err := command.Run(sourcesDir, request) Ω(err).ShouldNot(HaveOccurred()) - Ω(githubClient.UpdateReleaseCallCount()).Should(Equal(1)) + Ω(gitlabClient.UpdateReleaseCallCount()).Should(Equal(1)) - updatedRelease := githubClient.UpdateReleaseArgsForCall(0) + updatedRelease := gitlabClient.UpdateReleaseArgsForCall(0) Ω(*updatedRelease.Name).Should(Equal("v0.3.12")) Ω(updatedRelease.Body).Should(BeNil()) }) @@ -189,12 +189,12 @@ var _ = Describe("Out Command", func() { _, err := command.Run(sourcesDir, request) Ω(err).ShouldNot(HaveOccurred()) - Ω(githubClient.UpdateReleaseCallCount()).Should(Equal(1)) + Ω(gitlabClient.UpdateReleaseCallCount()).Should(Equal(1)) - updatedRelease := githubClient.UpdateReleaseArgsForCall(0) + updatedRelease := gitlabClient.UpdateReleaseArgsForCall(0) Ω(*updatedRelease.Name).Should(Equal("v0.3.12")) Ω(*updatedRelease.Body).Should(Equal("this is a great release")) - Ω(updatedRelease.TargetCommitish).Should(Equal(github.String(""))) + Ω(updatedRelease.TargetCommitish).Should(Equal(gitlab.String(""))) }) }) @@ -209,12 +209,12 @@ var _ = Describe("Out Command", func() { _, err := command.Run(sourcesDir, request) Ω(err).ShouldNot(HaveOccurred()) - Ω(githubClient.UpdateReleaseCallCount()).Should(Equal(1)) + Ω(gitlabClient.UpdateReleaseCallCount()).Should(Equal(1)) - updatedRelease := githubClient.UpdateReleaseArgsForCall(0) + updatedRelease := gitlabClient.UpdateReleaseArgsForCall(0) Ω(*updatedRelease.Name).Should(Equal("v0.3.12")) Ω(*updatedRelease.Body).Should(Equal("this is a great release")) - Ω(updatedRelease.TargetCommitish).Should(Equal(github.String("1z22f1"))) + Ω(updatedRelease.TargetCommitish).Should(Equal(gitlab.String("1z22f1"))) }) }) }) @@ -242,27 +242,27 @@ var _ = Describe("Out Command", func() { request.Params.CommitishPath = "commitish" }) - It("creates a release on GitHub with the commitish", func() { + It("creates a release on gitlab with the commitish", func() { _, err := command.Run(sourcesDir, request) Ω(err).ShouldNot(HaveOccurred()) - Ω(githubClient.CreateReleaseCallCount()).Should(Equal(1)) - release := githubClient.CreateReleaseArgsForCall(0) + Ω(gitlabClient.CreateReleaseCallCount()).Should(Equal(1)) + release := gitlabClient.CreateReleaseArgsForCall(0) - Ω(release.TargetCommitish).Should(Equal(github.String("a2f4a3"))) + Ω(release.TargetCommitish).Should(Equal(gitlab.String("a2f4a3"))) }) }) Context("without a commitish", func() { - It("creates a release on GitHub without the commitish", func() { + It("creates a release on gitlab without the commitish", func() { _, err := command.Run(sourcesDir, request) Ω(err).ShouldNot(HaveOccurred()) - Ω(githubClient.CreateReleaseCallCount()).Should(Equal(1)) - release := githubClient.CreateReleaseArgsForCall(0) + Ω(gitlabClient.CreateReleaseCallCount()).Should(Equal(1)) + release := gitlabClient.CreateReleaseArgsForCall(0) - // GitHub treats empty string the same as not suppying the field. - Ω(release.TargetCommitish).Should(Equal(github.String(""))) + // gitlab treats empty string the same as not suppying the field. + Ω(release.TargetCommitish).Should(Equal(gitlab.String(""))) }) }) @@ -273,12 +273,12 @@ var _ = Describe("Out Command", func() { request.Params.BodyPath = "body" }) - It("creates a release on GitHub", func() { + It("creates a release on gitlab", func() { _, err := command.Run(sourcesDir, request) Ω(err).ShouldNot(HaveOccurred()) - Ω(githubClient.CreateReleaseCallCount()).Should(Equal(1)) - release := githubClient.CreateReleaseArgsForCall(0) + Ω(gitlabClient.CreateReleaseCallCount()).Should(Equal(1)) + release := gitlabClient.CreateReleaseArgsForCall(0) Ω(*release.Name).Should(Equal("v0.3.12")) Ω(*release.TagName).Should(Equal("0.3.12")) @@ -291,8 +291,8 @@ var _ = Describe("Out Command", func() { _, err := command.Run(sourcesDir, request) Ω(err).ShouldNot(HaveOccurred()) - Ω(githubClient.CreateReleaseCallCount()).Should(Equal(1)) - release := githubClient.CreateReleaseArgsForCall(0) + Ω(gitlabClient.CreateReleaseCallCount()).Should(Equal(1)) + release := gitlabClient.CreateReleaseArgsForCall(0) Ω(*release.Name).Should(Equal("v0.3.12")) Ω(*release.TagName).Should(Equal("0.3.12")) @@ -304,8 +304,8 @@ var _ = Describe("Out Command", func() { _, err := command.Run(sourcesDir, request) Ω(err).ShouldNot(HaveOccurred()) - Ω(githubClient.CreateReleaseCallCount()).Should(Equal(1)) - release := githubClient.CreateReleaseArgsForCall(0) + Ω(gitlabClient.CreateReleaseCallCount()).Should(Equal(1)) + release := gitlabClient.CreateReleaseArgsForCall(0) Ω(*release.Draft).Should(Equal(false)) }) @@ -318,12 +318,12 @@ var _ = Describe("Out Command", func() { request.Source.PreRelease = true }) - It("creates a non-draft pre-release in Github", func() { + It("creates a non-draft pre-release in gitlab", func() { _, err := command.Run(sourcesDir, request) Ω(err).ShouldNot(HaveOccurred()) - Ω(githubClient.CreateReleaseCallCount()).Should(Equal(1)) - release := githubClient.CreateReleaseArgsForCall(0) + Ω(gitlabClient.CreateReleaseCallCount()).Should(Equal(1)) + release := gitlabClient.CreateReleaseArgsForCall(0) Ω(*release.Name).Should(Equal("v0.3.12")) Ω(*release.TagName).Should(Equal("0.3.12")) @@ -354,12 +354,12 @@ var _ = Describe("Out Command", func() { request.Source.PreRelease = true }) - It("creates a final release in Github", func() { + It("creates a final release in gitlab", func() { _, err := command.Run(sourcesDir, request) Ω(err).ShouldNot(HaveOccurred()) - Ω(githubClient.CreateReleaseCallCount()).Should(Equal(1)) - release := githubClient.CreateReleaseArgsForCall(0) + Ω(gitlabClient.CreateReleaseCallCount()).Should(Equal(1)) + release := gitlabClient.CreateReleaseArgsForCall(0) Ω(*release.Name).Should(Equal("v0.3.12")) Ω(*release.TagName).Should(Equal("0.3.12")) @@ -388,12 +388,12 @@ var _ = Describe("Out Command", func() { request.Source.Drafts = true }) - It("creates a release on GitHub in draft mode", func() { + It("creates a release on gitlab in draft mode", func() { _, err := command.Run(sourcesDir, request) Ω(err).ShouldNot(HaveOccurred()) - Ω(githubClient.CreateReleaseCallCount()).Should(Equal(1)) - release := githubClient.CreateReleaseArgsForCall(0) + Ω(gitlabClient.CreateReleaseCallCount()).Should(Equal(1)) + release := gitlabClient.CreateReleaseArgsForCall(0) Ω(*release.Name).Should(Equal("v0.3.12")) Ω(*release.TagName).Should(Equal("0.3.12")) @@ -445,8 +445,8 @@ var _ = Describe("Out Command", func() { _, err := command.Run(sourcesDir, request) Ω(err).ShouldNot(HaveOccurred()) - Ω(githubClient.UploadReleaseAssetCallCount()).Should(Equal(1)) - release, name, file := githubClient.UploadReleaseAssetArgsForCall(0) + Ω(gitlabClient.UploadReleaseAssetCallCount()).Should(Equal(1)) + release, name, file := gitlabClient.UploadReleaseAssetArgsForCall(0) Ω(*release.ID).Should(Equal(112)) Ω(name).Should(Equal("great-file.tgz")) @@ -479,23 +479,23 @@ var _ = Describe("Out Command", func() { Context("when upload release asset fails", func() { BeforeEach(func() { existingAsset := false - githubClient.DeleteReleaseAssetStub = func(github.ReleaseAsset) error { + gitlabClient.DeleteReleaseAssetStub = func(gitlab.ReleaseAsset) error { existingAsset = false return nil } - githubClient.ListReleaseAssetsReturns([]*github.ReleaseAsset{ + gitlabClient.ListReleaseAssetsReturns([]*gitlab.ReleaseAsset{ { - ID: github.Int(456789), - Name: github.String("great-file.tgz"), + ID: gitlab.Int(456789), + Name: gitlab.String("great-file.tgz"), }, { - ID: github.Int(3450798), - Name: github.String("whatever.tgz"), + ID: gitlab.Int(3450798), + Name: gitlab.String("whatever.tgz"), }, }, nil) - githubClient.UploadReleaseAssetStub = func(rel github.RepositoryRelease, name string, file *os.File) error { + gitlabClient.UploadReleaseAssetStub = func(rel gitlab.Tag, name string, file *os.File) error { Expect(ioutil.ReadAll(file)).To(Equal([]byte("matching"))) Expect(existingAsset).To(BeFalse()) existingAsset = true @@ -507,17 +507,17 @@ var _ = Describe("Out Command", func() { _, err := command.Run(sourcesDir, request) Expect(err).To(Equal(errors.New("some-error"))) - Ω(githubClient.UploadReleaseAssetCallCount()).Should(Equal(10)) - Ω(githubClient.ListReleaseAssetsCallCount()).Should(Equal(10)) - Ω(*githubClient.ListReleaseAssetsArgsForCall(9).ID).Should(Equal(112)) + Ω(gitlabClient.UploadReleaseAssetCallCount()).Should(Equal(10)) + Ω(gitlabClient.ListReleaseAssetsCallCount()).Should(Equal(10)) + Ω(*gitlabClient.ListReleaseAssetsArgsForCall(9).ID).Should(Equal(112)) - actualRelease, actualName, actualFile := githubClient.UploadReleaseAssetArgsForCall(9) + actualRelease, actualName, actualFile := gitlabClient.UploadReleaseAssetArgsForCall(9) Ω(*actualRelease.ID).Should(Equal(112)) Ω(actualName).Should(Equal("great-file.tgz")) Ω(actualFile.Name()).Should(Equal(filepath.Join(sourcesDir, "great-file.tgz"))) - Ω(githubClient.DeleteReleaseAssetCallCount()).Should(Equal(10)) - actualAsset := githubClient.DeleteReleaseAssetArgsForCall(8) + Ω(gitlabClient.DeleteReleaseAssetCallCount()).Should(Equal(10)) + actualAsset := gitlabClient.DeleteReleaseAssetArgsForCall(8) Expect(*actualAsset.ID).To(Equal(456789)) }) @@ -531,7 +531,7 @@ var _ = Describe("Out Command", func() { results <- nil results <- errors.New("6") - githubClient.UploadReleaseAssetStub = func(github.RepositoryRelease, string, *os.File) error { + gitlabClient.UploadReleaseAssetStub = func(gitlab.Tag, string, *os.File) error { return <-results } }) @@ -540,17 +540,17 @@ var _ = Describe("Out Command", func() { _, err := command.Run(sourcesDir, request) Expect(err).ToNot(HaveOccurred()) - Ω(githubClient.UploadReleaseAssetCallCount()).Should(Equal(5)) - Ω(githubClient.ListReleaseAssetsCallCount()).Should(Equal(4)) - Ω(*githubClient.ListReleaseAssetsArgsForCall(3).ID).Should(Equal(112)) + Ω(gitlabClient.UploadReleaseAssetCallCount()).Should(Equal(5)) + Ω(gitlabClient.ListReleaseAssetsCallCount()).Should(Equal(4)) + Ω(*gitlabClient.ListReleaseAssetsArgsForCall(3).ID).Should(Equal(112)) - actualRelease, actualName, actualFile := githubClient.UploadReleaseAssetArgsForCall(4) + actualRelease, actualName, actualFile := gitlabClient.UploadReleaseAssetArgsForCall(4) Ω(*actualRelease.ID).Should(Equal(112)) Ω(actualName).Should(Equal("great-file.tgz")) Ω(actualFile.Name()).Should(Equal(filepath.Join(sourcesDir, "great-file.tgz"))) - Ω(githubClient.DeleteReleaseAssetCallCount()).Should(Equal(4)) - actualAsset := githubClient.DeleteReleaseAssetArgsForCall(3) + Ω(gitlabClient.DeleteReleaseAssetCallCount()).Should(Equal(4)) + actualAsset := gitlabClient.DeleteReleaseAssetArgsForCall(3) Expect(*actualAsset.ID).To(Equal(456789)) }) }) @@ -578,8 +578,8 @@ var _ = Describe("Out Command", func() { _, err := command.Run(sourcesDir, request) Ω(err).ShouldNot(HaveOccurred()) - Ω(githubClient.CreateReleaseCallCount()).Should(Equal(1)) - release := githubClient.CreateReleaseArgsForCall(0) + Ω(gitlabClient.CreateReleaseCallCount()).Should(Equal(1)) + release := gitlabClient.CreateReleaseArgsForCall(0) Ω(*release.Name).Should(Equal("v0.3.12")) Ω(*release.TagName).Should(Equal("version-0.3.12")) diff --git a/resource_suite_test.go b/resource_suite_test.go index 777a9aa..cc3027e 100644 --- a/resource_suite_test.go +++ b/resource_suite_test.go @@ -3,46 +3,21 @@ package resource_test import ( "testing" - "github.com/google/go-github/github" . "github.com/onsi/ginkgo" . "github.com/onsi/gomega" + "github.com/xanzy/go-gitlab" ) func TestGithubReleaseResource(t *testing.T) { RegisterFailHandler(Fail) - RunSpecs(t, "Github Release Resource Suite") + RunSpecs(t, "GitLab Release Resource Suite") } -func newRepositoryRelease(id int, version string) *github.RepositoryRelease { - return &github.RepositoryRelease{ - TagName: github.String(version), - Draft: github.Bool(false), - Prerelease: github.Bool(false), - ID: github.Int(id), - } -} - -func newPreReleaseRepositoryRelease(id int, version string) *github.RepositoryRelease { - return &github.RepositoryRelease{ - TagName: github.String(version), - Draft: github.Bool(false), - Prerelease: github.Bool(true), - ID: github.Int(id), - } -} -func newDraftRepositoryRelease(id int, version string) *github.RepositoryRelease { - return &github.RepositoryRelease{ - TagName: github.String(version), - Draft: github.Bool(true), - Prerelease: github.Bool(false), - ID: github.Int(id), - } -} - -func newDraftWithNilTagRepositoryRelease(id int) *github.RepositoryRelease { - return &github.RepositoryRelease{ - Draft: github.Bool(true), - Prerelease: github.Bool(false), - ID: github.Int(id), +func newTag(name, sha string) *gitlab.Tag { + return &gitlab.Tag{ + Commit: &gitlab.Commit{ + ID: *gitlab.String(sha), + }, + Name: *gitlab.String(name), } }