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

remove tests and fakes [ci skip]

Browse Source
This commit is contained in:
Amneesh Singh
2022-02-20 02:13:06 +05:30
parent c857b66f5e
commit 45d9fcc84d
8 changed files with 2 additions and 1654 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
Dockerfile
View File

@@ -7,7 +7,7 @@ RUN go build -o /assets/in ./cmd/in
RUN go build -o /assets/out ./cmd/out
RUN go build -o /assets/check ./cmd/check
FROM alpine:edge AS resource
FROM alpine:latest AS resource
RUN apk add --no-cache bash tzdata ca-certificates unzip zip gzip tar
COPY --from=builder assets/ /opt/resource/
RUN chmod +x /opt/resource/*

2
README.md
View File

@@ -1,4 +1,4 @@
[![Concourse CI](https://ci.weirdnatto.in/api/v1/teams/main/pipelines/gitea-release-resource/badge)](https://ci.weirdnatto.in/teams/main/pipelines/gitea-release-resource) [![Docker](https://img.shields.io/docker/image-size/natto17/gitea-release-resource.svg)](https://hub.docker.com/repository/docker/natto17/gitea-release-resorce)
[![Concourse CI](https://ci.weirdnatto.in/api/v1/teams/main/pipelines/gitea-release-resource/badge)](https://ci.weirdnatto.in/teams/main/pipelines/gitea-release-resource) [![Docker](https://img.shields.io/docker/image-size/natto17/gitea-release-resource.svg)](https://hub.docker.com/repository/docker/natto17/gitea-release-resource)
# WIP
Forked from https://github.com/edtan/gitlab-release-resource

192
check_command_test.go
View File

@@ -1,192 +0,0 @@
package resource_test
import (
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"code.gitea.io/sdk/gitea"
"github.com/natto1784/gitea-release-resource"
"github.com/natto1784/gitea-release-resource/fakes"
)
var _ = Describe("Check Command", func() {
var (
giteaClient *fakes.FakeGitea
command *resource.CheckCommand
returnedTags []*gitea.Tag
)
BeforeEach(func() {
giteaClient = &fakes.FakeGitea{}
command = resource.NewCheckCommand(giteaClient)
returnedTags = []*gitea.Tag{}
})
JustBeforeEach(func() {
giteaClient.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() {
returnedTags = []*gitea.Tag{}
})
It("returns no versions", func() {
versions, err := command.Run(resource.CheckRequest{})
Ω(err).ShouldNot(HaveOccurred())
Ω(versions).Should(BeEmpty())
})
})
Context("when there are releases", func() {
BeforeEach(func() {
returnedTags = []*gitea.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(giteaClient)
response, err := command.Run(resource.CheckRequest{})
Ω(err).ShouldNot(HaveOccurred())
Ω(response).Should(HaveLen(1))
Ω(response[0]).Should(Equal(resource.Version{
Tag: "v0.4.0",
}))
})
})
})
Context("when there are prior versions", func() {
Context("when there are no releases", func() {
BeforeEach(func() {
returnedTags = []*gitea.Tag{}
})
It("returns no versions", func() {
versions, err := command.Run(resource.CheckRequest{})
Ω(err).ShouldNot(HaveOccurred())
Ω(versions).Should(BeEmpty())
})
})
Context("when there are releases", func() {
Context("and there is a custom tag filter", func() {
BeforeEach(func() {
returnedTags = []*gitea.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(giteaClient)
response, err := command.Run(resource.CheckRequest{
Version: resource.Version{
Tag: "package-0.1.3",
},
})
Ω(err).ShouldNot(HaveOccurred())
Ω(response).Should(Equal([]resource.Version{
{Tag: "package-0.1.3"},
{Tag: "package-0.1.4"},
{Tag: "package-0.4.0"},
}))
})
})
Context("and the releases do not contain a draft release", func() {
BeforeEach(func() {
returnedTags = []*gitea.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 latest version has been checked", func() {
command := resource.NewCheckCommand(giteaClient)
response, err := command.Run(resource.CheckRequest{
Version: resource.Version{
Tag: "0.4.0",
},
})
Ω(err).ShouldNot(HaveOccurred())
Ω(response).Should(BeEmpty())
})
It("returns all of the versions that are newer", func() {
command := resource.NewCheckCommand(giteaClient)
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: "v0.1.4"},
{Tag: "0.4.0"},
}))
})
It("returns the latest version if the current version is not found", func() {
command := resource.NewCheckCommand(giteaClient)
response, err := command.Run(resource.CheckRequest{
Version: resource.Version{
Tag: "v3.4.5",
},
})
Ω(err).ShouldNot(HaveOccurred())
Ω(response).Should(Equal([]resource.Version{
{Tag: "0.4.0"},
}))
})
Context("when there are not-quite-semver versions", func() {
BeforeEach(func() {
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(giteaClient)
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: "v0.1.4"},
{Tag: "0.4.0"},
{Tag: "v1"},
}))
})
})
})
})
})
})

503
fakes/fake_gitea.go
View File

@@ -1,503 +0,0 @@
// Code generated by counterfeiter. DO NOT EDIT.
package fakes
import (
sync "sync"
resource "github.com/natto1784/gitea-release-resource"
gitea "code.gitea.io/sdk/gitea"
)
type FakeGitea struct {
CreateReleaseStub func(string, string) (*gitea.Release, error)
createReleaseMutex sync.RWMutex
createReleaseArgsForCall []struct {
arg1 string
arg2 string
}
createReleaseReturns struct {
result1 *gitea.Release
result2 error
}
createReleaseReturnsOnCall map[int]struct {
result1 *gitea.Release
result2 error
}
CreateTagStub func(string, string) (*gitea.Tag, error)
createTagMutex sync.RWMutex
createTagArgsForCall []struct {
arg1 string
arg2 string
}
createTagReturns struct {
result1 *gitea.Tag
result2 error
}
createTagReturnsOnCall map[int]struct {
result1 *gitea.Tag
result2 error
}
GetTagStub func(string) (*gitea.Tag, error)
getTagMutex sync.RWMutex
getTagArgsForCall []struct {
arg1 string
}
getTagReturns struct {
result1 *gitea.Tag
result2 error
}
getTagReturnsOnCall map[int]struct {
result1 *gitea.Tag
result2 error
}
ListTagsStub func() ([]*gitea.Tag, error)
listTagsMutex sync.RWMutex
listTagsArgsForCall []struct {
}
listTagsReturns struct {
result1 []*gitea.Tag
result2 error
}
listTagsReturnsOnCall map[int]struct {
result1 []*gitea.Tag
result2 error
}
ListTagsUntilStub func(string) ([]*gitea.Tag, error)
listTagsUntilMutex sync.RWMutex
listTagsUntilArgsForCall []struct {
arg1 string
}
listTagsUntilReturns struct {
result1 []*gitea.Tag
result2 error
}
listTagsUntilReturnsOnCall map[int]struct {
result1 []*gitea.Tag
result2 error
}
UpdateReleaseStub func(string, string) (*gitea.Release, error)
updateReleaseMutex sync.RWMutex
updateReleaseArgsForCall []struct {
arg1 string
arg2 string
}
updateReleaseReturns struct {
result1 *gitea.Release
result2 error
}
updateReleaseReturnsOnCall map[int]struct {
result1 *gitea.Release
result2 error
}
invocations map[string][][]interface{}
invocationsMutex sync.RWMutex
}
func (fake *FakeGitea) CreateRelease(arg1 string, arg2 string) (*gitea.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 *FakeGitea) CreateReleaseCallCount() int {
fake.createReleaseMutex.RLock()
defer fake.createReleaseMutex.RUnlock()
return len(fake.createReleaseArgsForCall)
}
func (fake *FakeGitea) CreateReleaseCalls(stub func(string, string) (*gitea.Release, error)) {
fake.createReleaseMutex.Lock()
defer fake.createReleaseMutex.Unlock()
fake.CreateReleaseStub = stub
}
func (fake *FakeGitea) CreateReleaseArgsForCall(i int) (string, string) {
fake.createReleaseMutex.RLock()
defer fake.createReleaseMutex.RUnlock()
argsForCall := fake.createReleaseArgsForCall[i]
return argsForCall.arg1, argsForCall.arg2
}
func (fake *FakeGitea) CreateReleaseReturns(result1 *gitea.Release, result2 error) {
fake.createReleaseMutex.Lock()
defer fake.createReleaseMutex.Unlock()
fake.CreateReleaseStub = nil
fake.createReleaseReturns = struct {
result1 *gitea.Release
result2 error
}{result1, result2}
}
func (fake *FakeGitea) CreateReleaseReturnsOnCall(i int, result1 *gitea.Release, result2 error) {
fake.createReleaseMutex.Lock()
defer fake.createReleaseMutex.Unlock()
fake.CreateReleaseStub = nil
if fake.createReleaseReturnsOnCall == nil {
fake.createReleaseReturnsOnCall = make(map[int]struct {
result1 *gitea.Release
result2 error
})
}
fake.createReleaseReturnsOnCall[i] = struct {
result1 *gitea.Release
result2 error
}{result1, result2}
}
func (fake *FakeGitea) CreateTag(arg1 string, arg2 string) (*gitea.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 *FakeGitea) CreateTagCallCount() int {
fake.createTagMutex.RLock()
defer fake.createTagMutex.RUnlock()
return len(fake.createTagArgsForCall)
}
func (fake *FakeGitea) CreateTagCalls(stub func(string, string) (*gitea.Tag, error)) {
fake.createTagMutex.Lock()
defer fake.createTagMutex.Unlock()
fake.CreateTagStub = stub
}
func (fake *FakeGitea) CreateTagArgsForCall(i int) (string, string) {
fake.createTagMutex.RLock()
defer fake.createTagMutex.RUnlock()
argsForCall := fake.createTagArgsForCall[i]
return argsForCall.arg1, argsForCall.arg2
}
func (fake *FakeGitea) CreateTagReturns(result1 *gitea.Tag, result2 error) {
fake.createTagMutex.Lock()
defer fake.createTagMutex.Unlock()
fake.CreateTagStub = nil
fake.createTagReturns = struct {
result1 *gitea.Tag
result2 error
}{result1, result2}
}
func (fake *FakeGitea) CreateTagReturnsOnCall(i int, result1 *gitea.Tag, result2 error) {
fake.createTagMutex.Lock()
defer fake.createTagMutex.Unlock()
fake.CreateTagStub = nil
if fake.createTagReturnsOnCall == nil {
fake.createTagReturnsOnCall = make(map[int]struct {
result1 *gitea.Tag
result2 error
})
}
fake.createTagReturnsOnCall[i] = struct {
result1 *gitea.Tag
result2 error
}{result1, result2}
}
func (fake *FakeGitea) GetTag(arg1 string) (*gitea.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 *FakeGitea) GetTagCallCount() int {
fake.getTagMutex.RLock()
defer fake.getTagMutex.RUnlock()
return len(fake.getTagArgsForCall)
}
func (fake *FakeGitea) GetTagCalls(stub func(string) (*gitea.Tag, error)) {
fake.getTagMutex.Lock()
defer fake.getTagMutex.Unlock()
fake.GetTagStub = stub
}
func (fake *FakeGitea) GetTagArgsForCall(i int) string {
fake.getTagMutex.RLock()
defer fake.getTagMutex.RUnlock()
argsForCall := fake.getTagArgsForCall[i]
return argsForCall.arg1
}
func (fake *FakeGitea) GetTagReturns(result1 *gitea.Tag, result2 error) {
fake.getTagMutex.Lock()
defer fake.getTagMutex.Unlock()
fake.GetTagStub = nil
fake.getTagReturns = struct {
result1 *gitea.Tag
result2 error
}{result1, result2}
}
func (fake *FakeGitea) GetTagReturnsOnCall(i int, result1 *gitea.Tag, result2 error) {
fake.getTagMutex.Lock()
defer fake.getTagMutex.Unlock()
fake.GetTagStub = nil
if fake.getTagReturnsOnCall == nil {
fake.getTagReturnsOnCall = make(map[int]struct {
result1 *gitea.Tag
result2 error
})
}
fake.getTagReturnsOnCall[i] = struct {
result1 *gitea.Tag
result2 error
}{result1, result2}
}
func (fake *FakeGitea) ListTags() ([]*gitea.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 *FakeGitea) ListTagsCallCount() int {
fake.listTagsMutex.RLock()
defer fake.listTagsMutex.RUnlock()
return len(fake.listTagsArgsForCall)
}
func (fake *FakeGitea) ListTagsCalls(stub func() ([]*gitea.Tag, error)) {
fake.listTagsMutex.Lock()
defer fake.listTagsMutex.Unlock()
fake.ListTagsStub = stub
}
func (fake *FakeGitea) ListTagsReturns(result1 []*gitea.Tag, result2 error) {
fake.listTagsMutex.Lock()
defer fake.listTagsMutex.Unlock()
fake.ListTagsStub = nil
fake.listTagsReturns = struct {
result1 []*gitea.Tag
result2 error
}{result1, result2}
}
func (fake *FakeGitea) ListTagsReturnsOnCall(i int, result1 []*gitea.Tag, result2 error) {
fake.listTagsMutex.Lock()
defer fake.listTagsMutex.Unlock()
fake.ListTagsStub = nil
if fake.listTagsReturnsOnCall == nil {
fake.listTagsReturnsOnCall = make(map[int]struct {
result1 []*gitea.Tag
result2 error
})
}
fake.listTagsReturnsOnCall[i] = struct {
result1 []*gitea.Tag
result2 error
}{result1, result2}
}
func (fake *FakeGitea) ListTagsUntil(arg1 string) ([]*gitea.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 *FakeGitea) ListTagsUntilCallCount() int {
fake.listTagsUntilMutex.RLock()
defer fake.listTagsUntilMutex.RUnlock()
return len(fake.listTagsUntilArgsForCall)
}
func (fake *FakeGitea) ListTagsUntilCalls(stub func(string) ([]*gitea.Tag, error)) {
fake.listTagsUntilMutex.Lock()
defer fake.listTagsUntilMutex.Unlock()
fake.ListTagsUntilStub = stub
}
func (fake *FakeGitea) ListTagsUntilArgsForCall(i int) string {
fake.listTagsUntilMutex.RLock()
defer fake.listTagsUntilMutex.RUnlock()
argsForCall := fake.listTagsUntilArgsForCall[i]
return argsForCall.arg1
}
func (fake *FakeGitea) ListTagsUntilReturns(result1 []*gitea.Tag, result2 error) {
fake.listTagsUntilMutex.Lock()
defer fake.listTagsUntilMutex.Unlock()
fake.ListTagsUntilStub = nil
fake.listTagsUntilReturns = struct {
result1 []*gitea.Tag
result2 error
}{result1, result2}
}
func (fake *FakeGitea) ListTagsUntilReturnsOnCall(i int, result1 []*gitea.Tag, result2 error) {
fake.listTagsUntilMutex.Lock()
defer fake.listTagsUntilMutex.Unlock()
fake.ListTagsUntilStub = nil
if fake.listTagsUntilReturnsOnCall == nil {
fake.listTagsUntilReturnsOnCall = make(map[int]struct {
result1 []*gitea.Tag
result2 error
})
}
fake.listTagsUntilReturnsOnCall[i] = struct {
result1 []*gitea.Tag
result2 error
}{result1, result2}
}
func (fake *FakeGitea) UpdateRelease(arg1 string, arg2 string) (*gitea.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 *FakeGitea) UpdateReleaseCallCount() int {
fake.updateReleaseMutex.RLock()
defer fake.updateReleaseMutex.RUnlock()
return len(fake.updateReleaseArgsForCall)
}
func (fake *FakeGitea) UpdateReleaseCalls(stub func(string, string) (*gitea.Release, error)) {
fake.updateReleaseMutex.Lock()
defer fake.updateReleaseMutex.Unlock()
fake.UpdateReleaseStub = stub
}
func (fake *FakeGitea) UpdateReleaseArgsForCall(i int) (string, string) {
fake.updateReleaseMutex.RLock()
defer fake.updateReleaseMutex.RUnlock()
argsForCall := fake.updateReleaseArgsForCall[i]
return argsForCall.arg1, argsForCall.arg2
}
func (fake *FakeGitea) UpdateReleaseReturns(result1 *gitea.Release, result2 error) {
fake.updateReleaseMutex.Lock()
defer fake.updateReleaseMutex.Unlock()
fake.UpdateReleaseStub = nil
fake.updateReleaseReturns = struct {
result1 *gitea.Release
result2 error
}{result1, result2}
}
func (fake *FakeGitea) UpdateReleaseReturnsOnCall(i int, result1 *gitea.Release, result2 error) {
fake.updateReleaseMutex.Lock()
defer fake.updateReleaseMutex.Unlock()
fake.UpdateReleaseStub = nil
if fake.updateReleaseReturnsOnCall == nil {
fake.updateReleaseReturnsOnCall = make(map[int]struct {
result1 *gitea.Release
result2 error
})
}
fake.updateReleaseReturnsOnCall[i] = struct {
result1 *gitea.Release
result2 error
}{result1, result2}
}
func (fake *FakeGitea) 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.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()
copiedInvocations := map[string][][]interface{}{}
for key, value := range fake.invocations {
copiedInvocations[key] = value
}
return copiedInvocations
}
func (fake *FakeGitea) 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.Gitea = new(FakeGitea)

129
gitea_test.go
View File

@@ -1,129 +0,0 @@
package resource_test
import (
"net/http"
. "github.com/natto1784/gitea-release-resource"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"code.gitea.io/sdk/gitea"
"github.com/onsi/gomega/ghttp"
)
var _ = Describe("Gitea Client", func() {
var server *ghttp.Server
var client *GiteaClient
var source Source
BeforeEach(func() {
server = ghttp.NewServer()
})
JustBeforeEach(func() {
source.GiteaAPIURL = server.URL()
var err error
client, err = NewGiteaClient(source)
Ω(err).ShouldNot(HaveOccurred())
})
AfterEach(func() {
server.Close()
})
Context("with bad URLs", func() {
BeforeEach(func() {
source.AccessToken = "hello?"
})
It("returns an error if the API URL is bad", func() {
source.GiteaAPIURL = ":"
_, err := NewGiteaClient(source)
Ω(err).Should(HaveOccurred())
})
})
Context("with an OAuth Token", func() {
BeforeEach(func() {
source = Source{
Repository: "concourse",
AccessToken: "abc123",
}
server.AppendHandlers(
ghttp.CombineHandlers(
ghttp.VerifyRequest("GET", "/repos/concourse/concourse/releases"),
ghttp.RespondWith(200, "[]"),
ghttp.VerifyHeaderKV("Authorization", "Bearer abc123"),
),
)
})
It("sends one", func() {
_, err := client.ListTags()
Ω(err).ShouldNot(HaveOccurred())
})
})
Context("without an OAuth Token", func() {
BeforeEach(func() {
source = Source{
Repository: "concourse",
}
server.AppendHandlers(
ghttp.CombineHandlers(
ghttp.VerifyRequest("GET", "/repos/concourse/concourse/releases"),
ghttp.RespondWith(200, "[]"),
ghttp.VerifyHeader(http.Header{"Authorization": nil}),
),
)
})
It("sends one", func() {
_, err := client.ListTags()
Ω(err).ShouldNot(HaveOccurred())
})
})
Describe("GetRelease", func() {
BeforeEach(func() {
source = Source{
Repository: "concourse",
}
})
})
Describe("GetReleaseByTag", func() {
BeforeEach(func() {
source = Source{
Repository: "concourse",
}
})
Context("When Gitea responds successfully", func() {
BeforeEach(func() {
server.AppendHandlers(
ghttp.CombineHandlers(
ghttp.VerifyRequest("GET", "/repos/concourse/concourse/releases/tags/some-tag"),
ghttp.RespondWith(200, `{ "id": "1" }`),
),
)
})
It("Returns a populated github.Tag", func() {
expectedRelease := &gitea.Tag{
Name: *gitea.String("1"),
}
release, err := client.GetTag("some-tag")
Ω(err).ShouldNot(HaveOccurred())
Expect(release).To(Equal(expectedRelease))
})
})
})
})

216
in_command_test.go
View File

@@ -1,216 +0,0 @@
package resource_test
import (
"errors"
"io/ioutil"
"os"
"path"
"path/filepath"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"github.com/onsi/gomega/ghttp"
"code.gitea.io/sdk/gitea"
"github.com/natto1784/gitea-release-resource"
"github.com/natto1784/gitea-release-resource/fakes"
)
var _ = Describe("In Command", func() {
var (
command *resource.InCommand
giteaClient *fakes.FakeGitea
giteaServer *ghttp.Server
inRequest resource.InRequest
inResponse resource.InResponse
inErr error
tmpDir string
destDir string
)
BeforeEach(func() {
var err error
giteaClient = &fakes.FakeGitea{}
giteaServer = ghttp.NewServer()
command = resource.NewInCommand(giteaClient, ioutil.Discard)
tmpDir, err = ioutil.TempDir("", "gitea-release")
Ω(err).ShouldNot(HaveOccurred())
destDir = filepath.Join(tmpDir, "destination")
inRequest = resource.InRequest{}
})
AfterEach(func() {
Ω(os.RemoveAll(tmpDir)).Should(Succeed())
})
buildTag := func(sha, tag string) *gitea.Tag {
return &gitea.Tag{
Commit: &gitea.Commit{
ID: *gitea.String(sha),
},
Name: *gitea.String(tag),
}
}
Context("when there is a tagged release", func() {
Context("when a present version is specified", func() {
BeforeEach(func() {
giteaClient.GetTagReturns(buildTag("v0.35.0", "abc123"), nil)
inRequest.Version = &resource.Version{
Tag: "v0.35.0",
}
})
Context("when valid asset filename globs are given", func() {
BeforeEach(func() {
inRequest.Params = resource.InParams{
Globs: []string{"*.txt", "*.rtf"},
}
})
It("succeeds", func() {
inResponse, inErr = command.Run(destDir, inRequest)
Ω(inErr).ShouldNot(HaveOccurred())
})
It("returns the fetched version", func() {
inResponse, inErr = command.Run(destDir, inRequest)
Ω(inResponse.Version).Should(Equal(resource.Version{Tag: "v0.35.0"}))
})
It("has some sweet metadata", func() {
inResponse, inErr = command.Run(destDir, inRequest)
Ω(inResponse.Metadata).Should(ConsistOf(
resource.MetadataPair{Name: "tag", Value: "v0.35.0"},
resource.MetadataPair{Name: "commit_sha", Value: "f28085a4a8f744da83411f5e09fd7b1709149eee"},
))
})
It("calls #GetTag with the correct arguments", func() {
command.Run(destDir, inRequest)
Ω(giteaClient.GetTagArgsForCall(0)).Should(Equal("v0.35.0"))
})
It("does create the body, tag and version files", func() {
inResponse, inErr = command.Run(destDir, inRequest)
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"))
contents, err = ioutil.ReadFile(path.Join(destDir, "commit_sha"))
Ω(err).ShouldNot(HaveOccurred())
Ω(string(contents)).Should(Equal("f28085a4a8f744da83411f5e09fd7b1709149eee"))
contents, err = ioutil.ReadFile(path.Join(destDir, "body"))
Ω(err).ShouldNot(HaveOccurred())
Ω(string(contents)).Should(Equal("*markdown*"))
})
Context("when there is a custom tag filter", func() {
BeforeEach(func() {
inRequest.Source = resource.Source{
TagFilter: "package-(.*)",
}
giteaClient.GetTagReturns(buildTag("package-0.35.0", "abc123"), nil)
inResponse, inErr = command.Run(destDir, inRequest)
})
It("succeeds", func() {
inResponse, inErr = command.Run(destDir, inRequest)
Expect(inErr).ToNot(HaveOccurred())
})
It("does create the body, tag and version files", func() {
inResponse, inErr = command.Run(destDir, inRequest)
contents, err := ioutil.ReadFile(path.Join(destDir, "tag"))
Ω(err).ShouldNot(HaveOccurred())
Ω(string(contents)).Should(Equal("package-0.35.0"))
contents, err = ioutil.ReadFile(path.Join(destDir, "version"))
Ω(err).ShouldNot(HaveOccurred())
Ω(string(contents)).Should(Equal("0.35.0"))
})
})
})
Context("when no globs are specified", func() {
BeforeEach(func() {
inRequest.Source = resource.Source{}
inResponse, inErr = command.Run(destDir, inRequest)
})
It("succeeds", func() {
Ω(inErr).ShouldNot(HaveOccurred())
})
It("returns the fetched version", func() {
Ω(inResponse.Version).Should(Equal(resource.Version{Tag: "v0.35.0"}))
})
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: "commit_sha", Value: "f28085a4a8f744da83411f5e09fd7b1709149eee"},
))
})
})
})
})
Context("when no tagged release is present", func() {
BeforeEach(func() {
giteaClient.GetTagReturns(nil, nil)
inRequest.Version = &resource.Version{
Tag: "v0.40.0",
}
inResponse, inErr = command.Run(destDir, inRequest)
})
It("returns an error", func() {
Ω(inErr).Should(MatchError("no releases"))
})
})
Context("when getting a tagged release fails", func() {
disaster := errors.New("nope")
BeforeEach(func() {
giteaClient.GetTagReturns(nil, disaster)
inRequest.Version = &resource.Version{
Tag: "some-tag",
}
inResponse, inErr = command.Run(destDir, inRequest)
})
It("returns the error", func() {
Ω(inErr).Should(Equal(disaster))
})
})
})

589
out_command_test.go
View File

@@ -1,589 +0,0 @@
package resource_test
import (
"errors"
"io/ioutil"
"os"
"path/filepath"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"code.gitea.io/sdk/gitea"
"github.com/natto1784/gitea-release-resource"
"github.com/natto1784/gitea-release-resource/fakes"
)
func file(path, contents string) {
Ω(ioutil.WriteFile(path, []byte(contents), 0644)).Should(Succeed())
}
var _ = Describe("Out Command", func() {
var (
command *resource.OutCommand
giteaClient *fakes.FakeGitea
sourcesDir string
request resource.OutRequest
)
BeforeEach(func() {
var err error
giteaClient = &fakes.FakeGitea{}
command = resource.NewOutCommand(giteaClient, ioutil.Discard)
sourcesDir, err = ioutil.TempDir("", "gitea-release")
Ω(err).ShouldNot(HaveOccurred())
giteaClient.CreateReleaseStub = func(gh gitea.Tag) (*gitea.Tag, error) {
createdRel := gh
createdRel.ID = gitea.Int(112)
createdRel.HTMLURL = gitea.String("http://google.com")
createdRel.Name = gitea.String("release-name")
createdRel.Body = gitea.String("*markdown*")
return &createdRel, nil
}
giteaClient.UpdateReleaseStub = func(gh gitea.Tag) (*gitea.Tag, error) {
return &gh, nil
}
})
AfterEach(func() {
Ω(os.RemoveAll(sourcesDir)).Should(Succeed())
})
Context("when the release has already been created", func() {
existingAssets := []gitea.ReleaseAsset{
{
ID: gitea.Int(456789),
Name: gitea.String("unicorns.txt"),
},
{
ID: gitea.Int(3450798),
Name: gitea.String("rainbows.txt"),
State: gitea.String("new"),
},
}
existingReleases := []gitea.Tag{
{
ID: gitea.Int(1),
Draft: gitea.Bool(true),
},
{
ID: gitea.Int(112),
TagName: gitea.String("some-tag-name"),
Assets: []gitea.ReleaseAsset{existingAssets[0]},
Draft: gitea.Bool(false),
},
}
BeforeEach(func() {
giteaClient.ListReleasesStub = func() ([]*gitea.Tag, error) {
rels := []*gitea.Tag{}
for _, r := range existingReleases {
c := r
rels = append(rels, &c)
}
return rels, nil
}
giteaClient.ListReleaseAssetsStub = func(gitea.Tag) ([]*gitea.ReleaseAsset, error) {
assets := []*gitea.ReleaseAsset{}
for _, a := range existingAssets {
c := a
assets = append(assets, &c)
}
return assets, nil
}
namePath := filepath.Join(sourcesDir, "name")
bodyPath := filepath.Join(sourcesDir, "body")
tagPath := filepath.Join(sourcesDir, "tag")
file(namePath, "v0.3.12")
file(bodyPath, "this is a great release")
file(tagPath, "some-tag-name")
request = resource.OutRequest{
Params: resource.OutParams{
NamePath: "name",
BodyPath: "body",
TagPath: "tag",
},
}
})
It("deletes the existing assets", func() {
_, err := command.Run(sourcesDir, request)
Ω(err).ShouldNot(HaveOccurred())
Ω(giteaClient.ListReleaseAssetsCallCount()).Should(Equal(1))
Ω(giteaClient.ListReleaseAssetsArgsForCall(0)).Should(Equal(existingReleases[1]))
Ω(giteaClient.DeleteReleaseAssetCallCount()).Should(Equal(2))
Ω(giteaClient.DeleteReleaseAssetArgsForCall(0)).Should(Equal(existingAssets[0]))
Ω(giteaClient.DeleteReleaseAssetArgsForCall(1)).Should(Equal(existingAssets[1]))
})
Context("when not set as a draft release", func() {
BeforeEach(func() {
request.Source.Drafts = false
})
It("updates the existing release to a non-draft", func() {
_, err := command.Run(sourcesDir, request)
Ω(err).ShouldNot(HaveOccurred())
Ω(giteaClient.UpdateReleaseCallCount()).Should(Equal(1))
updatedRelease := giteaClient.UpdateReleaseArgsForCall(0)
Ω(*updatedRelease.Name).Should(Equal("v0.3.12"))
Ω(*updatedRelease.Draft).Should(Equal(false))
})
})
Context("when set as a draft release", func() {
BeforeEach(func() {
request.Source.Drafts = true
})
It("updates the existing release to a draft", func() {
_, err := command.Run(sourcesDir, request)
Ω(err).ShouldNot(HaveOccurred())
Ω(giteaClient.UpdateReleaseCallCount()).Should(Equal(1))
updatedRelease := giteaClient.UpdateReleaseArgsForCall(0)
Ω(*updatedRelease.Name).Should(Equal("v0.3.12"))
Ω(*updatedRelease.Draft).Should(Equal(true))
})
})
Context("when a body is not supplied", func() {
BeforeEach(func() {
request.Params.BodyPath = ""
})
It("does not blow away the body", func() {
_, err := command.Run(sourcesDir, request)
Ω(err).ShouldNot(HaveOccurred())
Ω(giteaClient.UpdateReleaseCallCount()).Should(Equal(1))
updatedRelease := giteaClient.UpdateReleaseArgsForCall(0)
Ω(*updatedRelease.Name).Should(Equal("v0.3.12"))
Ω(updatedRelease.Body).Should(BeNil())
})
})
Context("when a commitish is not supplied", func() {
It("updates the existing release", func() {
_, err := command.Run(sourcesDir, request)
Ω(err).ShouldNot(HaveOccurred())
Ω(giteaClient.UpdateReleaseCallCount()).Should(Equal(1))
updatedRelease := giteaClient.UpdateReleaseArgsForCall(0)
Ω(*updatedRelease.Name).Should(Equal("v0.3.12"))
Ω(*updatedRelease.Body).Should(Equal("this is a great release"))
Ω(updatedRelease.TargetCommitish).Should(Equal(gitea.String("")))
})
})
Context("when a commitish is supplied", func() {
BeforeEach(func() {
commitishPath := filepath.Join(sourcesDir, "commitish")
file(commitishPath, "1z22f1")
request.Params.CommitishPath = "commitish"
})
It("updates the existing release", func() {
_, err := command.Run(sourcesDir, request)
Ω(err).ShouldNot(HaveOccurred())
Ω(giteaClient.UpdateReleaseCallCount()).Should(Equal(1))
updatedRelease := giteaClient.UpdateReleaseArgsForCall(0)
Ω(*updatedRelease.Name).Should(Equal("v0.3.12"))
Ω(*updatedRelease.Body).Should(Equal("this is a great release"))
Ω(updatedRelease.TargetCommitish).Should(Equal(gitea.String("1z22f1")))
})
})
})
Context("when the release has not already been created", func() {
BeforeEach(func() {
namePath := filepath.Join(sourcesDir, "name")
tagPath := filepath.Join(sourcesDir, "tag")
file(namePath, "v0.3.12")
file(tagPath, "0.3.12")
request = resource.OutRequest{
Params: resource.OutParams{
NamePath: "name",
TagPath: "tag",
},
}
})
Context("with a commitish", func() {
BeforeEach(func() {
commitishPath := filepath.Join(sourcesDir, "commitish")
file(commitishPath, "a2f4a3")
request.Params.CommitishPath = "commitish"
})
It("creates a release on gitea with the commitish", func() {
_, err := command.Run(sourcesDir, request)
Ω(err).ShouldNot(HaveOccurred())
Ω(giteaClient.CreateReleaseCallCount()).Should(Equal(1))
release := giteaClient.CreateReleaseArgsForCall(0)
Ω(release.TargetCommitish).Should(Equal(gitea.String("a2f4a3")))
})
})
Context("without a commitish", func() {
It("creates a release on gitea without the commitish", func() {
_, err := command.Run(sourcesDir, request)
Ω(err).ShouldNot(HaveOccurred())
Ω(giteaClient.CreateReleaseCallCount()).Should(Equal(1))
release := giteaClient.CreateReleaseArgsForCall(0)
// gitea treats empty string the same as not suppying the field.
Ω(release.TargetCommitish).Should(Equal(gitea.String("")))
})
})
Context("with a body", func() {
BeforeEach(func() {
bodyPath := filepath.Join(sourcesDir, "body")
file(bodyPath, "this is a great release")
request.Params.BodyPath = "body"
})
It("creates a release on gitea", func() {
_, err := command.Run(sourcesDir, request)
Ω(err).ShouldNot(HaveOccurred())
Ω(giteaClient.CreateReleaseCallCount()).Should(Equal(1))
release := giteaClient.CreateReleaseArgsForCall(0)
Ω(*release.Name).Should(Equal("v0.3.12"))
Ω(*release.TagName).Should(Equal("0.3.12"))
Ω(*release.Body).Should(Equal("this is a great release"))
})
})
Context("without a body", func() {
It("works", func() {
_, err := command.Run(sourcesDir, request)
Ω(err).ShouldNot(HaveOccurred())
Ω(giteaClient.CreateReleaseCallCount()).Should(Equal(1))
release := giteaClient.CreateReleaseArgsForCall(0)
Ω(*release.Name).Should(Equal("v0.3.12"))
Ω(*release.TagName).Should(Equal("0.3.12"))
Ω(*release.Body).Should(Equal(""))
})
})
It("always defaults to non-draft mode", func() {
_, err := command.Run(sourcesDir, request)
Ω(err).ShouldNot(HaveOccurred())
Ω(giteaClient.CreateReleaseCallCount()).Should(Equal(1))
release := giteaClient.CreateReleaseArgsForCall(0)
Ω(*release.Draft).Should(Equal(false))
})
Context("when pre-release are set and release are not", func() {
BeforeEach(func() {
bodyPath := filepath.Join(sourcesDir, "body")
file(bodyPath, "this is a great release")
request.Source.Release = false
request.Source.PreRelease = true
})
It("creates a non-draft pre-release in gitea", func() {
_, err := command.Run(sourcesDir, request)
Ω(err).ShouldNot(HaveOccurred())
Ω(giteaClient.CreateReleaseCallCount()).Should(Equal(1))
release := giteaClient.CreateReleaseArgsForCall(0)
Ω(*release.Name).Should(Equal("v0.3.12"))
Ω(*release.TagName).Should(Equal("0.3.12"))
Ω(*release.Body).Should(Equal(""))
Ω(*release.Draft).Should(Equal(false))
Ω(*release.Prerelease).Should(Equal(true))
})
It("has some sweet metadata", func() {
outResponse, err := command.Run(sourcesDir, request)
Ω(err).ShouldNot(HaveOccurred())
Ω(outResponse.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: "0.3.12"},
resource.MetadataPair{Name: "pre-release", Value: "true"},
))
})
})
Context("when release and pre-release are set", func() {
BeforeEach(func() {
bodyPath := filepath.Join(sourcesDir, "body")
file(bodyPath, "this is a great release")
request.Source.Release = true
request.Source.PreRelease = true
})
It("creates a final release in gitea", func() {
_, err := command.Run(sourcesDir, request)
Ω(err).ShouldNot(HaveOccurred())
Ω(giteaClient.CreateReleaseCallCount()).Should(Equal(1))
release := giteaClient.CreateReleaseArgsForCall(0)
Ω(*release.Name).Should(Equal("v0.3.12"))
Ω(*release.TagName).Should(Equal("0.3.12"))
Ω(*release.Body).Should(Equal(""))
Ω(*release.Draft).Should(Equal(false))
Ω(*release.Prerelease).Should(Equal(false))
})
It("has some sweet metadata", func() {
outResponse, err := command.Run(sourcesDir, request)
Ω(err).ShouldNot(HaveOccurred())
Ω(outResponse.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: "0.3.12"},
))
})
})
Context("when set as a draft release", func() {
BeforeEach(func() {
bodyPath := filepath.Join(sourcesDir, "body")
file(bodyPath, "this is a great release")
request.Source.Drafts = true
})
It("creates a release on gitea in draft mode", func() {
_, err := command.Run(sourcesDir, request)
Ω(err).ShouldNot(HaveOccurred())
Ω(giteaClient.CreateReleaseCallCount()).Should(Equal(1))
release := giteaClient.CreateReleaseArgsForCall(0)
Ω(*release.Name).Should(Equal("v0.3.12"))
Ω(*release.TagName).Should(Equal("0.3.12"))
Ω(*release.Body).Should(Equal(""))
Ω(*release.Draft).Should(Equal(true))
Ω(*release.Prerelease).Should(Equal(false))
})
It("has some sweet metadata", func() {
outResponse, err := command.Run(sourcesDir, request)
Ω(err).ShouldNot(HaveOccurred())
Ω(outResponse.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: "0.3.12"},
resource.MetadataPair{Name: "draft", Value: "true"},
))
})
})
Context("with file globs", func() {
BeforeEach(func() {
globMatching := filepath.Join(sourcesDir, "great-file.tgz")
globNotMatching := filepath.Join(sourcesDir, "bad-file.txt")
file(globMatching, "matching")
file(globNotMatching, "not matching")
request = resource.OutRequest{
Params: resource.OutParams{
NamePath: "name",
BodyPath: "body",
TagPath: "tag",
Globs: []string{
"*.tgz",
},
},
}
bodyPath := filepath.Join(sourcesDir, "body")
file(bodyPath, "*markdown*")
request.Params.BodyPath = "body"
})
It("uploads matching file globs", func() {
_, err := command.Run(sourcesDir, request)
Ω(err).ShouldNot(HaveOccurred())
Ω(giteaClient.UploadReleaseAssetCallCount()).Should(Equal(1))
release, name, file := giteaClient.UploadReleaseAssetArgsForCall(0)
Ω(*release.ID).Should(Equal(112))
Ω(name).Should(Equal("great-file.tgz"))
Ω(file.Name()).Should(Equal(filepath.Join(sourcesDir, "great-file.tgz")))
})
It("has some sweet metadata", func() {
outResponse, err := command.Run(sourcesDir, request)
Ω(err).ShouldNot(HaveOccurred())
Ω(outResponse.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: "0.3.12"},
))
})
It("returns an error if a glob is provided that does not match any files", func() {
request.Params.Globs = []string{
"*.tgz",
"*.gif",
}
_, err := command.Run(sourcesDir, request)
Ω(err).Should(HaveOccurred())
Ω(err).Should(MatchError("could not find file that matches glob '*.gif'"))
})
Context("when upload release asset fails", func() {
BeforeEach(func() {
existingAsset := false
giteaClient.DeleteReleaseAssetStub = func(gitea.ReleaseAsset) error {
existingAsset = false
return nil
}
giteaClient.ListReleaseAssetsReturns([]*gitea.ReleaseAsset{
{
ID: gitea.Int(456789),
Name: gitea.String("great-file.tgz"),
},
{
ID: gitea.Int(3450798),
Name: gitea.String("whatever.tgz"),
},
}, nil)
giteaClient.UploadReleaseAssetStub = func(rel gitea.Tag, name string, file *os.File) error {
Expect(ioutil.ReadAll(file)).To(Equal([]byte("matching")))
Expect(existingAsset).To(BeFalse())
existingAsset = true
return errors.New("some-error")
}
})
It("retries 10 times", func() {
_, err := command.Run(sourcesDir, request)
Expect(err).To(Equal(errors.New("some-error")))
Ω(giteaClient.UploadReleaseAssetCallCount()).Should(Equal(10))
Ω(giteaClient.ListReleaseAssetsCallCount()).Should(Equal(10))
Ω(*giteaClient.ListReleaseAssetsArgsForCall(9).ID).Should(Equal(112))
actualRelease, actualName, actualFile := giteaClient.UploadReleaseAssetArgsForCall(9)
Ω(*actualRelease.ID).Should(Equal(112))
Ω(actualName).Should(Equal("great-file.tgz"))
Ω(actualFile.Name()).Should(Equal(filepath.Join(sourcesDir, "great-file.tgz")))
Ω(giteaClient.DeleteReleaseAssetCallCount()).Should(Equal(10))
actualAsset := giteaClient.DeleteReleaseAssetArgsForCall(8)
Expect(*actualAsset.ID).To(Equal(456789))
})
Context("when uploading succeeds on the 5th attempt", func() {
BeforeEach(func() {
results := make(chan error, 6)
results <- errors.New("1")
results <- errors.New("2")
results <- errors.New("3")
results <- errors.New("4")
results <- nil
results <- errors.New("6")
giteaClient.UploadReleaseAssetStub = func(gitea.Tag, string, *os.File) error {
return <-results
}
})
It("succeeds", func() {
_, err := command.Run(sourcesDir, request)
Expect(err).ToNot(HaveOccurred())
Ω(giteaClient.UploadReleaseAssetCallCount()).Should(Equal(5))
Ω(giteaClient.ListReleaseAssetsCallCount()).Should(Equal(4))
Ω(*giteaClient.ListReleaseAssetsArgsForCall(3).ID).Should(Equal(112))
actualRelease, actualName, actualFile := giteaClient.UploadReleaseAssetArgsForCall(4)
Ω(*actualRelease.ID).Should(Equal(112))
Ω(actualName).Should(Equal("great-file.tgz"))
Ω(actualFile.Name()).Should(Equal(filepath.Join(sourcesDir, "great-file.tgz")))
Ω(giteaClient.DeleteReleaseAssetCallCount()).Should(Equal(4))
actualAsset := giteaClient.DeleteReleaseAssetArgsForCall(3)
Expect(*actualAsset.ID).To(Equal(456789))
})
})
})
})
Context("when the tag_prefix is set", func() {
BeforeEach(func() {
namePath := filepath.Join(sourcesDir, "name")
tagPath := filepath.Join(sourcesDir, "tag")
file(namePath, "v0.3.12")
file(tagPath, "0.3.12")
request = resource.OutRequest{
Params: resource.OutParams{
NamePath: "name",
TagPath: "tag",
TagPrefix: "version-",
},
}
})
It("appends the TagPrefix onto the TagName", func() {
_, err := command.Run(sourcesDir, request)
Ω(err).ShouldNot(HaveOccurred())
Ω(giteaClient.CreateReleaseCallCount()).Should(Equal(1))
release := giteaClient.CreateReleaseArgsForCall(0)
Ω(*release.Name).Should(Equal("v0.3.12"))
Ω(*release.TagName).Should(Equal("version-0.3.12"))
})
})
})
})

23
resource_suite_test.go
View File

@@ -1,23 +0,0 @@
package resource_test
import (
"testing"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"code.gitea.io/sdk/gitea"
)
func TestGithubReleaseResource(t *testing.T) {
RegisterFailHandler(Fail)
RunSpecs(t, "Gitea Release Resource Suite")
}
func newTag(name, sha string) *gitea.Tag {
return &gitea.Tag{
Commit: &gitea.Commit{
ID: *gitea.String(sha),
},
Name: *gitea.String(name),
}
}