remove tests and fakes [ci skip]

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/*

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
 

check_command_test.go

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

fakes/fake_gitea.go

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

gitea_test.go

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

in_command_test.go

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

out_command_test.go

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

resource_suite_test.go

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