Auto publish draft on deploy and skip user confirm (#30)

Add new flags on deploy command:

  - Flag --publish-draft which takes the latest draft and publishes it
	before deployment.
  
  - Flag --skip-confirmation which skips the user confirmation dialog in
	deploy command, which is a manual step that can be eliminated for
	automation. 

Other changes:

  - Fix case of panic when no release is found, LastRelease now returns
	an error even on 404 instead of a nil release.

  - Remove pkg/errors and replace with standard error wrapping.

  - Remove Mock prefix from methods of mock package.

Author: nstratos

ACKNOWLEDGMENTS.md

@@ -7,7 +7,6 @@ Ergo makes primarily use of the following OSS projects:
 * [github](https://github.com/google/go-github)
 * [go-version](https://github.com/hashicorp/go-version)
 * [go-homedir](https://github.com/mitchellh/go-homedir)
-* [errors](https://github.com/pkg/errors)
 * [table](https://github.com/rodaine/table)
 * [cobra](https://github.com/spf13/cobra)
 * [viper](https://github.com/spf13/viper)

commands/deploy.go

@@ -16,6 +16,8 @@ func defineDeployCommand() *cobra.Command {
 		releaseInterval string
 		allowForcePush  bool
 		branchesString  string
+		skipConfirm     bool
+		publishDraft    bool
 	)
 
 	deployCmd := &cobra.Command{
@@ -28,16 +30,18 @@ func defineDeployCommand() *cobra.Command {
 	deployCmd.Flags().StringVar(&releaseInterval, "releaseInterval", "25m", "Duration to wait between releases. ('5m', '1h25m', '30s')")
 	deployCmd.Flags().BoolVar(&allowForcePush, "force", false, "Allow force push if deploy branch has diverged from base")
 	deployCmd.Flags().StringVar(&branchesString, "branches", "", "Comma separated list of branches")
+	deployCmd.Flags().BoolVar(&skipConfirm, "skip-confirmation", false, "Create the draft without asking for user confirmation.")
+	deployCmd.Flags().BoolVar(&publishDraft, "publish-draft", false, "Publish the latest draft release before deployment.")
 
 	deployCmd.RunE = func(cmd *cobra.Command, args []string) error {
-		return defineDeployCommandRun(releaseInterval, releaseOffset, branchesString, allowForcePush)
+		return defineDeployCommandRun(releaseInterval, releaseOffset, branchesString, allowForcePush, skipConfirm, publishDraft)
 	}
 
 	return deployCmd
 }
 
 // defineDeployCommandRun defines the deploy command run actions.
-func defineDeployCommandRun(releaseInterval, releaseOffset, branchesString string, allowForcePush bool) error {
+func defineDeployCommandRun(releaseInterval, releaseOffset, branchesString string, allowForcePush, skipConfirm, publishDraft bool) error {
 	ctx := context.Background()
 
 	if branchesString != "" {
@@ -57,5 +61,5 @@ func defineDeployCommandRun(releaseInterval, releaseOffset, branchesString strin
 		opts.ReleaseBodyReplace,
 		opts.ReleaseBranches,
 		opts.ReleaseBodyBranches,
-	).Do(ctx, releaseInterval, releaseOffset, allowForcePush)
+	).Do(ctx, releaseInterval, releaseOffset, allowForcePush, skipConfirm, publishDraft)
 }

ergo.go

@@ -10,6 +10,7 @@ type Host interface {
 	CreateDraftRelease(ctx context.Context, name, tagName, releaseBody, targetBranch string) error
 	LastRelease(ctx context.Context) (*Release, error)
 	EditRelease(ctx context.Context, release *Release) (*Release, error)
+	PublishRelease(ctx context.Context, releaseID int64) error
 	CompareBranch(ctx context.Context, baseBranch, branch string) (*StatusReport, error)
 	DiffCommits(ctx context.Context, releaseBranches []string, baseBranch string) ([]*StatusReport, error)
 	CreateTag(ctx context.Context, versionName, sha, m string) (*Tag, error)
@@ -44,6 +45,7 @@ type Release struct {
 	Body       string
 	TagName    string
 	ReleaseURL string
+	Draft      bool
 }
 
 // StatusReport struct is responsible to keep the information about current status.

github/github.go

@@ -16,7 +16,6 @@ type RepositoryClient struct {
 	organization string
 	repo         string
 	client       *github.Client
-	curRelease   *github.RepositoryRelease
 }
 
 // NewGithubClient set up a github client.
@@ -49,60 +48,66 @@ func (gc *RepositoryClient) CreateDraftRelease(ctx context.Context, name, tagNam
 		TargetCommitish: &targetBranch,
 	}
 
-	githubRelease, _, err := gc.client.Repositories.CreateRelease(
+	_, _, err := gc.client.Repositories.CreateRelease(
 		ctx,
 		gc.organization,
 		gc.repo,
 		githubRelease,
 	)
 
-	gc.curRelease = githubRelease
-
 	return err
 }
 
 // LastRelease fetches the latest release for a repository.
 func (gc *RepositoryClient) LastRelease(ctx context.Context) (*ergo.Release, error) {
 	githubRelease, _, err := gc.client.Repositories.GetLatestRelease(
 		ctx, gc.organization, gc.repo)
-
-	errResponse, ok := err.(*github.ErrorResponse)
-
-	errHasResponse := ok
-	if errHasResponse && errResponse.Response.StatusCode == http.StatusNotFound {
-		return nil, nil
-	}
-
 	if err != nil {
+		var errorResponse *github.ErrorResponse
+		if errors.As(err, &errorResponse) && errorResponse.Response.StatusCode == http.StatusNotFound {
+			return nil, fmt.Errorf("latest release not found: %w", errorResponse)
+		}
 		return nil, err
 	}
 
-	gc.curRelease = githubRelease
-
 	return &ergo.Release{
 		ID:         *githubRelease.ID,
 		Body:       *githubRelease.Body,
 		TagName:    githubRelease.GetTagName(),
 		ReleaseURL: githubRelease.GetHTMLURL(),
+		Draft:      githubRelease.GetDraft(),
 	}, nil
 }
 
 // EditRelease allows to edit a repository release.
 func (gc *RepositoryClient) EditRelease(ctx context.Context, release *ergo.Release) (*ergo.Release, error) {
-
-	if gc.curRelease == nil {
-		return nil, errors.New("curRelease is empty")
+	if release == nil {
+		return nil, errors.New("nothing to release: input release is nil")
+	}
+	releasePayload := &github.RepositoryRelease{
+		Body: &release.Body,
 	}
 
-	githubRelease := gc.curRelease
-	githubRelease.Body = &release.Body
+	githubRelease, _, err := gc.client.Repositories.EditRelease(ctx, gc.organization, gc.repo, release.ID, releasePayload)
+	if err != nil {
+		return nil, err
+	}
 
-	githubRelease, _, err := gc.client.Repositories.EditRelease(
-		ctx, gc.organization, gc.repo, release.ID, githubRelease)
+	release.Body = githubRelease.GetBody()
 
-	release.Body = *githubRelease.Body
+	return release, nil
+}
 
-	return release, err
+// PublishRelease changes the draft flag of a repo release to false.
+func (gc *RepositoryClient) PublishRelease(ctx context.Context, releaseID int64) error {
+	editReleasePayload := &github.RepositoryRelease{
+		Draft: github.Bool(false),
+	}
+	_, _, err := gc.client.Repositories.EditRelease(ctx, gc.organization, gc.repo, releaseID, editReleasePayload)
+	if err != nil {
+		return fmt.Errorf("editing draft flag of release (ID=%d): %w", releaseID, err)
+	}
+	return nil
 }
 
 // GetRef branch reference object given the branch name.

github/github_test.go

@@ -2,7 +2,9 @@ package github
 
 import (
 	"context"
+	"errors"
 	"fmt"
+	"io"
 	"net/http"
 	"net/http/httptest"
 	"net/url"
@@ -29,6 +31,23 @@ func setup() (client *github.Client, mux *http.ServeMux, teardown func()) {
 	return client, mux, server.Close
 }
 
+func testBody(t *testing.T, r *http.Request, want string) {
+	t.Helper()
+	b, err := io.ReadAll(r.Body)
+	if err != nil {
+		t.Fatalf("Error reading request body: %v", err)
+	}
+	if got := string(b); got != want {
+		t.Errorf("request body\nhave: %q\nwant: %q", got, want)
+	}
+}
+
+func testMethod(t *testing.T, r *http.Request, want string) {
+	if want != r.Method {
+		t.Errorf("Request method = %v, want %v", r.Method, want)
+	}
+}
+
 func TestNewGithubClient(t *testing.T) {
 	ctx := context.Background()
 	client := NewGithubClient(ctx, "access_token")
@@ -176,7 +195,7 @@ func TestLastReleaseShouldReturnTheLastRelease(t *testing.T) {
 	}
 }
 
-func TestLastReleaseShouldNotReturnErrorForInvalidStatusCode(t *testing.T) {
+func TestLastReleaseShouldReturnWrappedErrorForCodeStatusNotFound(t *testing.T) {
 	ctx := context.Background()
 	client, mux, tearDown := setup()
 	defer tearDown()
@@ -187,12 +206,14 @@ func TestLastReleaseShouldNotReturnErrorForInvalidStatusCode(t *testing.T) {
 
 	repClient := NewRepositoryClient("o", "r", client)
 
-	got, err := repClient.LastRelease(ctx)
-	if err != nil {
-		t.Error("Should not return error for 404 status code")
+	_, err := repClient.LastRelease(ctx)
+	var errorResponse *github.ErrorResponse
+	if !errors.As(err, &errorResponse) {
+		t.Fatalf("LastRelease(GitHub API responds with 404) returned wrapped error of type %T, want: %T,", err, errorResponse)
 	}
-	if got != nil {
-		t.Error("Release should be nil")
+	if got, want := errorResponse.Response.StatusCode, http.StatusNotFound; got != want {
+		t.Errorf("LastRelease(GitHub API responds with 404) returned wrapped error of type %T with StatusCode %d, want: %d",
+			errorResponse, got, want)
 	}
 }
 
@@ -274,19 +295,75 @@ func TestEditReleaseShouldEditTheRelease(t *testing.T) {
 	}
 }
 
-func TestEditReleaseShouldReturnErrorForNilCurrentRelease(t *testing.T) {
+func TestEditReleaseShouldReturnErrorForNilInputRelease(t *testing.T) {
 	ctx := context.Background()
 	client, _, tearDown := setup()
 	defer tearDown()
 
 	repClient := NewRepositoryClient("o", "r", client)
 
-	rel, err := repClient.EditRelease(ctx, nil)
+	_, err := repClient.EditRelease(ctx, nil)
 	if err == nil {
-		t.Fatalf("Should return eror ")
+		t.Fatalf("EditRelease should return error when input release is nil")
 	}
-	if rel != nil {
-		t.Errorf("got = %v; want nil", rel)
+}
+
+func TestEditReleaseShouldReturnErrorOnGitHubAPIError(t *testing.T) {
+	ctx := context.Background()
+	client, mux, tearDown := setup()
+	defer tearDown()
+
+	mux.HandleFunc("/repos/o/r/releases/12", func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusServiceUnavailable)
+	})
+
+	repClient := NewRepositoryClient("o", "r", client)
+
+	editRelease := &ergo.Release{
+		ID:         12,
+		Body:       "release_body",
+		TagName:    "tag_name",
+		ReleaseURL: "release_url",
+	}
+	_, err := repClient.EditRelease(ctx, editRelease)
+	if err == nil {
+		t.Errorf("EditRelease should return error when GitHub API sends code 503")
+	}
+}
+
+func TestPublishReleaseSuccess(t *testing.T) {
+	client, mux, tearDown := setup()
+	defer tearDown()
+
+	mux.HandleFunc("/repos/o/r/releases/12", func(w http.ResponseWriter, r *http.Request) {
+		testMethod(t, r, "PATCH")
+		testBody(t, r, `{"draft":false}`+"\n")
+		fmt.Fprintf(w, `{}`)
+	})
+
+	repoClient := NewRepositoryClient("o", "r", client)
+
+	ctx := context.Background()
+	if err := repoClient.PublishRelease(ctx, 12); err != nil {
+		t.Errorf("PublishRelease returned error: %v", err)
+	}
+}
+
+func TestPublishReleaseError(t *testing.T) {
+	client, mux, tearDown := setup()
+	defer tearDown()
+
+	mux.HandleFunc("/repos/o/r/releases/12", func(w http.ResponseWriter, r *http.Request) {
+		testMethod(t, r, "PATCH")
+		testBody(t, r, `{"draft":false}`+"\n")
+		w.WriteHeader(http.StatusServiceUnavailable)
+	})
+
+	repoClient := NewRepositoryClient("o", "r", client)
+
+	ctx := context.Background()
+	if err := repoClient.PublishRelease(ctx, 12); err == nil {
+		t.Error("PublishRelease expected to return error")
 	}
 }
 

go.mod

@@ -13,7 +13,7 @@ require (
 	github.com/mattn/go-isatty v0.0.7 // indirect
 	github.com/mattn/go-runewidth v0.0.4 // indirect
 	github.com/mitchellh/go-homedir v1.1.0
-	github.com/pkg/errors v0.8.1
+	github.com/pkg/errors v0.8.1 // indirect
 	github.com/rodaine/table v1.0.0
 	github.com/spf13/cobra v0.0.3
 	github.com/spf13/viper v1.3.2

mock/cli.go

@@ -8,31 +8,28 @@ import (
 
 // CLI is a mock implementation.
 type CLI struct {
-	MockConfirmation func() (bool, error)
+	ConfirmationFn func() (bool, error)
 
 	mu                sync.Mutex
 	ConfirmationCalls int
 }
 
 // PrintTable is a mock implementation.
-func (c *CLI) PrintTable(header []string, values [][]string) {
-}
+func (c *CLI) PrintTable(header []string, values [][]string) {}
 
 // PrintColorizedLine is a mock implementation.
-func (c *CLI) PrintColorizedLine(title, content string, level ergo.MessageLevel) {
-}
+func (c *CLI) PrintColorizedLine(title, content string, level ergo.MessageLevel) {}
 
 // PrintLine is a mock implementation.
-func (c *CLI) PrintLine(content ...interface{}) {
-}
+func (c *CLI) PrintLine(content ...interface{}) {}
 
 // Confirmation is a mock implementation.
 func (c *CLI) Confirmation(actionText, cancellationMessage, successMessage string) (bool, error) {
 	c.mu.Lock()
 	c.ConfirmationCalls++
 	c.mu.Unlock()
-	if c.MockConfirmation != nil {
-		return c.MockConfirmation()
+	if c.ConfirmationFn != nil {
+		return c.ConfirmationFn()
 	}
 	return true, nil
 }