From cc5e9dc7f545881ec2ebac537230e329e1d28311 Mon Sep 17 00:00:00 2001 From: Adham Helal Date: Mon, 1 Aug 2016 14:23:39 +0200 Subject: [PATCH 1/9] Support pre release --- README.md | 5 +++++ check_command.go | 6 +++++- out_command.go | 3 +++ resources.go | 1 + 4 files changed, 14 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index 11c6264..228580a 100644 --- a/README.md +++ b/README.md @@ -28,6 +28,11 @@ Fetches and creates versioned GitHub resources. will be detected and published. Note that releases must have semver compliant tags to be detected, even if they're drafts. +* `pre_release`: *Optional. Default `false`.* When set to `true`, `put` produces + pre-release and `check` only detects prereleases. If `false`, only non-prerelease releases + will be detected and published. Note that releases must have semver compliant + tags to be detected. + ### Example ``` yaml diff --git a/check_command.go b/check_command.go index ad71a10..4d9fd1c 100644 --- a/check_command.go +++ b/check_command.go @@ -35,6 +35,10 @@ func (c *CheckCommand) Run(request CheckRequest) ([]Version, error) { if request.Source.Drafts != *release.Draft { continue } + if request.Source.PreRelease != *release.Prerelease { + continue + } + if release.TagName == nil { continue } @@ -67,7 +71,7 @@ func (c *CheckCommand) Run(request CheckRequest) ([]Version, error) { for _, release := range filteredReleases { if !upToLatest { - if *release.Draft { + if *release.Draft || *release.Prerelease { id := *release.ID upToLatest = request.Version.ID == strconv.Itoa(id) } else { diff --git a/out_command.go b/out_command.go index f74a59c..75eee5a 100644 --- a/out_command.go +++ b/out_command.go @@ -58,12 +58,14 @@ func (c *OutCommand) Run(sourceDir string, request OutRequest) (OutResponse, err } draft := request.Source.Drafts + prerelease := request.Source.PreRelease release := &github.RepositoryRelease{ Name: github.String(name), TagName: github.String(tag), Body: github.String(body), Draft: github.Bool(draft), + Prerelease: github.Bool(prerelease), TargetCommitish: github.String(targetCommitish), } @@ -89,6 +91,7 @@ func (c *OutCommand) Run(sourceDir string, request OutRequest) (OutResponse, err existingRelease.Name = github.String(name) existingRelease.TargetCommitish = github.String(targetCommitish) existingRelease.Draft = github.Bool(draft) + existingRelease.Prerelease = github.Bool(prerelease) if bodySpecified { existingRelease.Body = github.String(body) diff --git a/resources.go b/resources.go index 761fbfb..a9f53ab 100644 --- a/resources.go +++ b/resources.go @@ -8,6 +8,7 @@ type Source struct { GitHubUploadsURL string `json:"github_uploads_url"` AccessToken string `json:"access_token"` Drafts bool `json:"drafts"` + PreRelease bool `json:"pre_release"` } type CheckRequest struct { From ee96e0d46bddb033ef0b5744b08068a1461f1b39 Mon Sep 17 00:00:00 2001 From: Adham Helal Date: Thu, 15 Sep 2016 16:31:32 +0200 Subject: [PATCH 2/9] Add functionality to support Release and Prerelease together --- README.md | 16 +++++++++++----- check_command.go | 6 +++++- cmd/check/check.go | 2 +- cmd/out/out.go | 2 +- out_command.go | 5 ++++- resources.go | 7 +++++++ 6 files changed, 29 insertions(+), 9 deletions(-) diff --git a/README.md b/README.md index 228580a..622ab8b 100644 --- a/README.md +++ b/README.md @@ -23,16 +23,22 @@ Fetches and creates versioned GitHub resources. for uploading. If `github_api_url` is set, this value defaults to the same value, but if you have your own endpoint, this field will override it. +* `release`: *Optional. Default `true`.* When set to `true`, `put` produces + release and `check` will detects releases. If `false`, `put` and `check` will ignore releases. + Note that releases must have semver compliant tags to be detected. + +* `pre_release`: *Optional. Default `false`.* When set to `true`, `put` produces + pre-release and `check` detects prereleases. If `false`, only non-prerelease releases + will be detected and published. Note that releases must have semver compliant + tags to be detected. + If `release` and `pre_release` are set to `true` `put` produces + release and `check` will detects prereleases and releases. + * `drafts`: *Optional. Default `false`.* When set to `true`, `put` produces drafts and `check` only detects drafts. If `false`, only non-draft releases will be detected and published. Note that releases must have semver compliant tags to be detected, even if they're drafts. -* `pre_release`: *Optional. Default `false`.* When set to `true`, `put` produces - pre-release and `check` only detects prereleases. If `false`, only non-prerelease releases - will be detected and published. Note that releases must have semver compliant - tags to be detected. - ### Example ``` yaml diff --git a/check_command.go b/check_command.go index 4d9fd1c..3131144 100644 --- a/check_command.go +++ b/check_command.go @@ -35,7 +35,11 @@ func (c *CheckCommand) Run(request CheckRequest) ([]Version, error) { if request.Source.Drafts != *release.Draft { continue } - if request.Source.PreRelease != *release.Prerelease { + + // Should we skip this release + // a- prerelease condition dont match our source config + // b- release condition match prerealse in github since github has true/false to describe release/prerelase + if request.Source.PreRelease != *release.Prerelease && request.Source.Release == *release.Prerelease { continue } diff --git a/cmd/check/check.go b/cmd/check/check.go index 469ef6d..f97489d 100644 --- a/cmd/check/check.go +++ b/cmd/check/check.go @@ -8,7 +8,7 @@ import ( ) func main() { - var request resource.CheckRequest + request := resource.NewCheckRequest() inputRequest(&request) github, err := resource.NewGitHubClient(request.Source) diff --git a/cmd/out/out.go b/cmd/out/out.go index 7b92e3f..a84234e 100644 --- a/cmd/out/out.go +++ b/cmd/out/out.go @@ -13,7 +13,7 @@ func main() { os.Exit(1) } - var request resource.OutRequest + request := resource.NewCheckRequest() inputRequest(&request) sourceDir := os.Args[1] diff --git a/out_command.go b/out_command.go index 75eee5a..5d877d6 100644 --- a/out_command.go +++ b/out_command.go @@ -58,7 +58,10 @@ func (c *OutCommand) Run(sourceDir string, request OutRequest) (OutResponse, err } draft := request.Source.Drafts - prerelease := request.Source.PreRelease + prerelease := false + if request.Source.PreRelease == true && request.Source.Release == false { + prerelease = request.Source.PreRelease + } release := &github.RepositoryRelease{ Name: github.String(name), diff --git a/resources.go b/resources.go index a9f53ab..2e56d98 100644 --- a/resources.go +++ b/resources.go @@ -9,6 +9,7 @@ type Source struct { AccessToken string `json:"access_token"` Drafts bool `json:"drafts"` PreRelease bool `json:"pre_release"` + Release bool `json:"release"` } type CheckRequest struct { @@ -16,6 +17,12 @@ type CheckRequest struct { Version Version `json:"version"` } +func NewCheckRequest() CheckRequest { + res := CheckRequest{} + res.Source.Release = true + return res +} + type InRequest struct { Source Source `json:"source"` Version *Version `json:"version"` From 5c3e29a4163529249ad50a9034f8880dbc0e2cf3 Mon Sep 17 00:00:00 2001 From: Adham Helal Date: Wed, 21 Sep 2016 12:32:53 +0200 Subject: [PATCH 3/9] Fix test for new tests --- check_command_test.go | 2 +- resource_suite_test.go | 3 +++ 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/check_command_test.go b/check_command_test.go index 1e098bf..ebb990c 100644 --- a/check_command_test.go +++ b/check_command_test.go @@ -277,7 +277,7 @@ var _ = Describe("Check Command", func() { response, err := command.Run(resource.CheckRequest{ Version: resource.Version{}, - Source: resource.Source{Drafts: true}, + Source: resource.Source{Drafts: true, PreRelease: false}, }) Ω(err).ShouldNot(HaveOccurred()) diff --git a/resource_suite_test.go b/resource_suite_test.go index b557c56..6fe7656 100644 --- a/resource_suite_test.go +++ b/resource_suite_test.go @@ -17,6 +17,7 @@ func newRepositoryRelease(id int, version string) *github.RepositoryRelease { return &github.RepositoryRelease{ TagName: github.String(version), Draft: github.Bool(false), + Prerelease: github.Bool(false), ID: github.Int(id), } } @@ -25,6 +26,7 @@ func newDraftRepositoryRelease(id int, version string) *github.RepositoryRelease return &github.RepositoryRelease{ TagName: github.String(version), Draft: github.Bool(true), + Prerelease: github.Bool(false), ID: github.Int(id), } } @@ -32,6 +34,7 @@ func newDraftRepositoryRelease(id int, version string) *github.RepositoryRelease func newDraftWithNilTagRepositoryRelease(id int) *github.RepositoryRelease { return &github.RepositoryRelease{ Draft: github.Bool(true), + Prerelease: github.Bool(false), ID: github.Int(id), } } From 9d4d6f8b295dec64a07709c1412c02bca8b5f28c Mon Sep 17 00:00:00 2001 From: Adham Helal Date: Thu, 22 Sep 2016 13:22:46 +0200 Subject: [PATCH 4/9] Add tests for check pre release --- check_command_test.go | 159 +++++++++++++++++++++++++++++++++++++++++ resource_suite_test.go | 30 +++++--- 2 files changed, 178 insertions(+), 11 deletions(-) diff --git a/check_command_test.go b/check_command_test.go index ebb990c..b4b3d51 100644 --- a/check_command_test.go +++ b/check_command_test.go @@ -200,6 +200,165 @@ var _ = Describe("Check Command", func() { }) }) + Context("when pre releases are allowed and releases are not", func() { + Context("and one of the releases is a final and another is a draft", func() { + BeforeEach(func() { + returnedReleases = []*github.RepositoryRelease{ + newDraftRepositoryRelease(1, "v0.1.4"), + newRepositoryRelease(2, "0.4.0"), + newPreReleaseRepositoryRelease(1, "v0.4.1-rc.10"), + newPreReleaseRepositoryRelease(2, "0.4.1-rc.9"), + newPreReleaseRepositoryRelease(3, "v0.4.1-rc.8"), + + } + + }) + + It("returns all of the versions that are newer, and only pre relases", func() { + command := resource.NewCheckCommand(githubClient) + + response, err := command.Run(resource.CheckRequest{ + Version: resource.Version{ID: "2"}, + Source: resource.Source{Drafts: false, + PreRelease: true, + Release: false}, + }) + Ω(err).ShouldNot(HaveOccurred()) + + Ω(response).Should(Equal([]resource.Version{ + {Tag: "0.4.1-rc.9"}, + {Tag: "v0.4.1-rc.10"}, + })) + }) + + It("returns the latest prerelease version if the current version is not found", func() { + command := resource.NewCheckCommand(githubClient) + + response, err := command.Run(resource.CheckRequest{ + Version: resource.Version{ID: "5"}, + Source: resource.Source{Drafts: false, + PreRelease: true, + Release: false}, + }) + Ω(err).ShouldNot(HaveOccurred()) + + Ω(response).Should(Equal([]resource.Version{ + {Tag: "v0.4.1-rc.10"}, + })) + }) + }) + + }) + + + Context("when releases and pre releases are allowed", func() { + Context("and final release is newer", func() { + BeforeEach(func() { + returnedReleases = []*github.RepositoryRelease{ + newDraftRepositoryRelease(1, "v0.1.4"), + newRepositoryRelease(1, "0.3.9"), + newRepositoryRelease(2, "0.4.0"), + newRepositoryRelease(3, "v0.4.2"), + newPreReleaseRepositoryRelease(1, "v0.4.1-rc.10"), + newPreReleaseRepositoryRelease(2, "0.4.1-rc.9"), + newPreReleaseRepositoryRelease(3, "v0.4.2-rc.1"), + } + + }) + + It("returns all of the versions that are newer, and are release and prerealse", func() { + command := resource.NewCheckCommand(githubClient) + + response, err := command.Run(resource.CheckRequest{ + Version: resource.Version{Tag: "0.4.0"}, + Source: resource.Source{Drafts: false, + PreRelease: true, + Release: true}, + }) + Ω(err).ShouldNot(HaveOccurred()) + + Ω(response).Should(Equal([]resource.Version{ + {Tag: "0.4.0"}, + {Tag: "0.4.1-rc.9"}, + {Tag: "v0.4.1-rc.10"}, + {Tag: "v0.4.2-rc.1"}, + {Tag: "v0.4.2"}, + })) + }) + + It("returns the latest release version if the current version is not found", func() { + command := resource.NewCheckCommand(githubClient) + + response, err := command.Run(resource.CheckRequest{ + Version: resource.Version{ID: "5"}, + Source: resource.Source{Drafts: false, + PreRelease: true, + Release: true}, + }) + Ω(err).ShouldNot(HaveOccurred()) + + Ω(response).Should(Equal([]resource.Version{ + {Tag: "v0.4.2"}, + })) + }) + }) + + Context("and prerelease is newer", func() { + BeforeEach(func() { + returnedReleases = []*github.RepositoryRelease{ + newDraftRepositoryRelease(1, "v0.1.4"), + newRepositoryRelease(1, "0.3.9"), + newRepositoryRelease(2, "0.4.0"), + newRepositoryRelease(3, "v0.4.2"), + newPreReleaseRepositoryRelease(1, "v0.4.1-rc.10"), + newPreReleaseRepositoryRelease(2, "0.4.1-rc.9"), + newPreReleaseRepositoryRelease(3, "v0.4.2-rc.1"), + newPreReleaseRepositoryRelease(4, "v0.4.3-rc.1"), + + } + + }) + + It("returns all of the versions that are newer, and are release and prerealse", func() { + command := resource.NewCheckCommand(githubClient) + + response, err := command.Run(resource.CheckRequest{ + Version: resource.Version{Tag: "0.4.0"}, + Source: resource.Source{Drafts: false, + PreRelease: true, + Release: true}, + }) + Ω(err).ShouldNot(HaveOccurred()) + + Ω(response).Should(Equal([]resource.Version{ + {Tag: "0.4.0"}, + {Tag: "0.4.1-rc.9"}, + {Tag: "v0.4.1-rc.10"}, + {Tag: "v0.4.2-rc.1"}, + {Tag: "v0.4.2"}, + {Tag: "v0.4.3-rc.1"}, + })) + }) + + It("returns the latest prerelease version if the current version is not found", func() { + command := resource.NewCheckCommand(githubClient) + + response, err := command.Run(resource.CheckRequest{ + Version: resource.Version{ID: "5"}, + Source: resource.Source{Drafts: false, + PreRelease: true, + Release: true}, + }) + Ω(err).ShouldNot(HaveOccurred()) + + Ω(response).Should(Equal([]resource.Version{ + {Tag: "v0.4.3-rc.1"}, + })) + }) + }) + + }) + Context("when draft releases are allowed", func() { Context("and one of the releases is a final release", func() { BeforeEach(func() { diff --git a/resource_suite_test.go b/resource_suite_test.go index 6fe7656..777a9aa 100644 --- a/resource_suite_test.go +++ b/resource_suite_test.go @@ -15,26 +15,34 @@ func TestGithubReleaseResource(t *testing.T) { func newRepositoryRelease(id int, version string) *github.RepositoryRelease { return &github.RepositoryRelease{ - TagName: github.String(version), - Draft: github.Bool(false), - Prerelease: github.Bool(false), - ID: github.Int(id), + TagName: github.String(version), + Draft: github.Bool(false), + Prerelease: github.Bool(false), + ID: github.Int(id), } } +func newPreReleaseRepositoryRelease(id int, version string) *github.RepositoryRelease { + return &github.RepositoryRelease{ + TagName: github.String(version), + Draft: github.Bool(false), + Prerelease: github.Bool(true), + ID: github.Int(id), + } +} func newDraftRepositoryRelease(id int, version string) *github.RepositoryRelease { return &github.RepositoryRelease{ - TagName: github.String(version), - Draft: github.Bool(true), - Prerelease: github.Bool(false), - ID: github.Int(id), + TagName: github.String(version), + Draft: github.Bool(true), + Prerelease: github.Bool(false), + ID: github.Int(id), } } func newDraftWithNilTagRepositoryRelease(id int) *github.RepositoryRelease { return &github.RepositoryRelease{ - Draft: github.Bool(true), - Prerelease: github.Bool(false), - ID: github.Int(id), + Draft: github.Bool(true), + Prerelease: github.Bool(false), + ID: github.Int(id), } } From 2d0b25aacac058b9bb4caa4228477e8b216d0f18 Mon Sep 17 00:00:00 2001 From: Adham Helal Date: Thu, 22 Sep 2016 13:57:42 +0200 Subject: [PATCH 5/9] Let us know if its a prerelease in the metadata --- metadata.go | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/metadata.go b/metadata.go index dbab695..eefa5b2 100644 --- a/metadata.go +++ b/metadata.go @@ -47,5 +47,12 @@ func metadataFromRelease(release *github.RepositoryRelease) []MetadataPair { }) } + + if *release.Prerelease { + metadata = append(metadata, MetadataPair{ + Name: "pre-release", + Value: "true", + }) + } return metadata } From b6a959dd6abc622ffeef7038c8f67c3d6a4021b3 Mon Sep 17 00:00:00 2001 From: Adham Helal Date: Thu, 22 Sep 2016 13:58:23 +0200 Subject: [PATCH 6/9] Make in tests support prerelease data type --- in_command_test.go | 24 +++++++++++++----------- 1 file changed, 13 insertions(+), 11 deletions(-) diff --git a/in_command_test.go b/in_command_test.go index d89a471..44ea40a 100644 --- a/in_command_test.go +++ b/in_command_test.go @@ -58,22 +58,24 @@ var _ = Describe("In Command", func() { buildRelease := func(id int, tag string, draft bool) *github.RepositoryRelease { return &github.RepositoryRelease{ - ID: github.Int(id), - TagName: github.String(tag), - HTMLURL: github.String("http://google.com"), - Name: github.String("release-name"), - Body: github.String("*markdown*"), - Draft: github.Bool(draft), + ID: github.Int(id), + TagName: github.String(tag), + HTMLURL: github.String("http://google.com"), + Name: github.String("release-name"), + Body: github.String("*markdown*"), + Draft: github.Bool(draft), + Prerelease: github.Bool(false), } } buildNilTagRelease := func(id int) *github.RepositoryRelease { return &github.RepositoryRelease{ - ID: github.Int(id), - HTMLURL: github.String("http://google.com"), - Name: github.String("release-name"), - Body: github.String("*markdown*"), - Draft: github.Bool(true), + ID: github.Int(id), + HTMLURL: github.String("http://google.com"), + Name: github.String("release-name"), + Body: github.String("*markdown*"), + Draft: github.Bool(true), + Prerelease: github.Bool(false), } } From ddb19ff3de8b12072d75fea4bf7c0c39c41b1bd1 Mon Sep 17 00:00:00 2001 From: Adham Helal Date: Thu, 22 Sep 2016 13:59:34 +0200 Subject: [PATCH 7/9] Add pre-release out tests --- out_command_test.go | 72 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 72 insertions(+) diff --git a/out_command_test.go b/out_command_test.go index 23cf4aa..9bb05f3 100644 --- a/out_command_test.go +++ b/out_command_test.go @@ -310,6 +310,77 @@ var _ = Describe("Out Command", func() { Ω(*release.Draft).Should(Equal(false)) }) + Context("when prerelease are set and realses 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 release on GitHub in draft mode", func() { + _, err := command.Run(sourcesDir, request) + Ω(err).ShouldNot(HaveOccurred()) + + Ω(githubClient.CreateReleaseCallCount()).Should(Equal(1)) + release := githubClient.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 prerelease 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 release on GitHub in draft mode", func() { + _, err := command.Run(sourcesDir, request) + Ω(err).ShouldNot(HaveOccurred()) + + Ω(githubClient.CreateReleaseCallCount()).Should(Equal(1)) + release := githubClient.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") @@ -328,6 +399,7 @@ var _ = Describe("Out Command", func() { Ω(*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() { From 04bc09c6765cf912f5a11c1db89940e0ac5eb7da Mon Sep 17 00:00:00 2001 From: Adham Helal Date: Thu, 22 Sep 2016 22:22:42 +0200 Subject: [PATCH 8/9] fmt and typos --- check_command_test.go | 29 +++++++---------------------- metadata.go | 1 - out_command_test.go | 4 ++-- 3 files changed, 9 insertions(+), 25 deletions(-) diff --git a/check_command_test.go b/check_command_test.go index b4b3d51..59271c0 100644 --- a/check_command_test.go +++ b/check_command_test.go @@ -209,7 +209,6 @@ var _ = Describe("Check Command", func() { newPreReleaseRepositoryRelease(1, "v0.4.1-rc.10"), newPreReleaseRepositoryRelease(2, "0.4.1-rc.9"), newPreReleaseRepositoryRelease(3, "v0.4.1-rc.8"), - } }) @@ -219,9 +218,7 @@ var _ = Describe("Check Command", func() { response, err := command.Run(resource.CheckRequest{ Version: resource.Version{ID: "2"}, - Source: resource.Source{Drafts: false, - PreRelease: true, - Release: false}, + Source: resource.Source{Drafts: false, PreRelease: true, Release: false}, }) Ω(err).ShouldNot(HaveOccurred()) @@ -236,9 +233,7 @@ var _ = Describe("Check Command", func() { response, err := command.Run(resource.CheckRequest{ Version: resource.Version{ID: "5"}, - Source: resource.Source{Drafts: false, - PreRelease: true, - Release: false}, + Source: resource.Source{Drafts: false, PreRelease: true, Release: false}, }) Ω(err).ShouldNot(HaveOccurred()) @@ -250,7 +245,6 @@ var _ = Describe("Check Command", func() { }) - Context("when releases and pre releases are allowed", func() { Context("and final release is newer", func() { BeforeEach(func() { @@ -271,9 +265,7 @@ var _ = Describe("Check Command", func() { response, err := command.Run(resource.CheckRequest{ Version: resource.Version{Tag: "0.4.0"}, - Source: resource.Source{Drafts: false, - PreRelease: true, - Release: true}, + Source: resource.Source{Drafts: false, PreRelease: true, Release: true}, }) Ω(err).ShouldNot(HaveOccurred()) @@ -291,9 +283,7 @@ var _ = Describe("Check Command", func() { response, err := command.Run(resource.CheckRequest{ Version: resource.Version{ID: "5"}, - Source: resource.Source{Drafts: false, - PreRelease: true, - Release: true}, + Source: resource.Source{Drafts: false, PreRelease: true, Release: true}, }) Ω(err).ShouldNot(HaveOccurred()) @@ -314,7 +304,6 @@ var _ = Describe("Check Command", func() { newPreReleaseRepositoryRelease(2, "0.4.1-rc.9"), newPreReleaseRepositoryRelease(3, "v0.4.2-rc.1"), newPreReleaseRepositoryRelease(4, "v0.4.3-rc.1"), - } }) @@ -324,9 +313,7 @@ var _ = Describe("Check Command", func() { response, err := command.Run(resource.CheckRequest{ Version: resource.Version{Tag: "0.4.0"}, - Source: resource.Source{Drafts: false, - PreRelease: true, - Release: true}, + Source: resource.Source{Drafts: false, PreRelease: true, Release: true}, }) Ω(err).ShouldNot(HaveOccurred()) @@ -345,9 +332,7 @@ var _ = Describe("Check Command", func() { response, err := command.Run(resource.CheckRequest{ Version: resource.Version{ID: "5"}, - Source: resource.Source{Drafts: false, - PreRelease: true, - Release: true}, + Source: resource.Source{Drafts: false, PreRelease: true, Release: true}, }) Ω(err).ShouldNot(HaveOccurred()) @@ -358,7 +343,7 @@ var _ = Describe("Check Command", func() { }) }) - + Context("when draft releases are allowed", func() { Context("and one of the releases is a final release", func() { BeforeEach(func() { diff --git a/metadata.go b/metadata.go index eefa5b2..1f8fb2f 100644 --- a/metadata.go +++ b/metadata.go @@ -47,7 +47,6 @@ func metadataFromRelease(release *github.RepositoryRelease) []MetadataPair { }) } - if *release.Prerelease { metadata = append(metadata, MetadataPair{ Name: "pre-release", diff --git a/out_command_test.go b/out_command_test.go index 9bb05f3..ad21a80 100644 --- a/out_command_test.go +++ b/out_command_test.go @@ -310,7 +310,7 @@ var _ = Describe("Out Command", func() { Ω(*release.Draft).Should(Equal(false)) }) - Context("when prerelease are set and realses are not", func() { + Context("creates a non-draft pre-release in Github", func() { BeforeEach(func() { bodyPath := filepath.Join(sourcesDir, "body") file(bodyPath, "this is a great release") @@ -346,7 +346,7 @@ var _ = Describe("Out Command", func() { }) }) - Context("when release and prerelease are set", func() { + Context("creates a final release in Github", func() { BeforeEach(func() { bodyPath := filepath.Join(sourcesDir, "body") file(bodyPath, "this is a great release") From f6d82f6c58b21241e28d1cac734f86322e36d3be Mon Sep 17 00:00:00 2001 From: Adham Helal Date: Tue, 27 Sep 2016 14:50:31 +0200 Subject: [PATCH 9/9] Fix the test context and it :| --- out_command_test.go | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/out_command_test.go b/out_command_test.go index ad21a80..0d93d6a 100644 --- a/out_command_test.go +++ b/out_command_test.go @@ -310,7 +310,7 @@ var _ = Describe("Out Command", func() { Ω(*release.Draft).Should(Equal(false)) }) - Context("creates a non-draft pre-release in Github", func() { + 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") @@ -318,7 +318,7 @@ var _ = Describe("Out Command", func() { request.Source.PreRelease = true }) - It("creates a release on GitHub in draft mode", func() { + It("creates a non-draft pre-release in Github", func() { _, err := command.Run(sourcesDir, request) Ω(err).ShouldNot(HaveOccurred()) @@ -346,7 +346,7 @@ var _ = Describe("Out Command", func() { }) }) - Context("creates a final release in Github", func() { + Context("when release and pre-release are set", func() { BeforeEach(func() { bodyPath := filepath.Join(sourcesDir, "body") file(bodyPath, "this is a great release") @@ -354,7 +354,7 @@ var _ = Describe("Out Command", func() { request.Source.PreRelease = true }) - It("creates a release on GitHub in draft mode", func() { + It("creates a final release in Github", func() { _, err := command.Run(sourcesDir, request) Ω(err).ShouldNot(HaveOccurred())