From 45d9fcc84d55c4ed6b661220b5e725826c06b330 Mon Sep 17 00:00:00 2001 From: natto1784 Date: Sun, 20 Feb 2022 02:13:06 +0530 Subject: [PATCH] remove tests and fakes [ci skip] --- Dockerfile | 2 +- README.md | 2 +- check_command_test.go | 192 -------------- fakes/fake_gitea.go | 503 ----------------------------------- gitea_test.go | 129 --------- in_command_test.go | 216 --------------- out_command_test.go | 589 ----------------------------------------- resource_suite_test.go | 23 -- 8 files changed, 2 insertions(+), 1654 deletions(-) delete mode 100644 check_command_test.go delete mode 100644 fakes/fake_gitea.go delete mode 100644 gitea_test.go delete mode 100644 in_command_test.go delete mode 100644 out_command_test.go delete mode 100644 resource_suite_test.go diff --git a/Dockerfile b/Dockerfile index a692503..e243414 100644 --- a/Dockerfile +++ b/Dockerfile @@ -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/* diff --git a/README.md b/README.md index 8bd826a..9f8e6c3 100644 --- a/README.md +++ b/README.md @@ -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 diff --git a/check_command_test.go b/check_command_test.go deleted file mode 100644 index 82de19c..0000000 --- a/check_command_test.go +++ /dev/null @@ -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"}, - })) - }) - }) - }) - }) - }) -}) diff --git a/fakes/fake_gitea.go b/fakes/fake_gitea.go deleted file mode 100644 index 1363e88..0000000 --- a/fakes/fake_gitea.go +++ /dev/null @@ -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) diff --git a/gitea_test.go b/gitea_test.go deleted file mode 100644 index d1a8167..0000000 --- a/gitea_test.go +++ /dev/null @@ -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)) - }) - }) - }) -}) diff --git a/in_command_test.go b/in_command_test.go deleted file mode 100644 index 696cd84..0000000 --- a/in_command_test.go +++ /dev/null @@ -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)) - }) - }) -}) diff --git a/out_command_test.go b/out_command_test.go deleted file mode 100644 index 477ef9f..0000000 --- a/out_command_test.go +++ /dev/null @@ -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")) - }) - }) - }) -}) diff --git a/resource_suite_test.go b/resource_suite_test.go deleted file mode 100644 index 1664220..0000000 --- a/resource_suite_test.go +++ /dev/null @@ -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), - } -}