natto1784/gitea-release-resource
1
0
Fork 0
Code Issues 1 Pull Requests Projects Releases Wiki Activity

Begin working on tests

Browse Source
This commit is contained in:
Ed
2018-12-19 18:00:25 -05:00
parent 7cab700694
commit 9eb0ab0a0f
9 changed files with 893 additions and 1459 deletions
Download Patch File Download Diff File Expand all files Collapse all files

340
check_command_test.go
View File

@@ -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"},
}))
})
})
})
})
})
})

511
fakes/fake_git_hub.go
View File

@@ -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)

656
fakes/fake_git_lab.go Normal file
View File

@@ -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)

178
gitlab_test.go
View File

@@ -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))
})
})
})
})

7
go.mod
View File

@@ -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
)

35
go.sum
View File

@@ -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=

392
in_command_test.go
View File

@@ -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())
})
})
})
})

192
out_command_test.go
View File

@@ -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"))

41
resource_suite_test.go
View File

@@ -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),
}
}