Refactor towards a service type interface.

 - Drop the mapping from env to URLs
 - Rearrange the package names from "promotion" it's about more than just that.
 - Provide a mock cache implementation and test the promotion logic.
 - Flesh out the README.md
 - Allow providing the branch-name from the command-line.

Rework.

Author: bigkevmcd

.gitignore

@@ -0,0 +1 @@
+./services

README.md

@@ -1,3 +1,30 @@
-# promote
+# services
 
 A tool for promoting between GitHub repositories.
+
+This is a pre-alpha PoC for promoting versions of files between environments, represented as repositories.
+
+## Building
+
+```shell
+$ go build ./cmd/services
+```
+
+## Running
+
+You'll need a GitHub token to test this out.
+
+```shell
+$ export GITHUB_TOKEN=<paste in GitHub access token>
+$ ./services promote --from https://github.com/organisation/first-environment.git --to https://github.com/organisation/second-environment.git --service service-a --commit-name <User to commit as> --commit-email <Email to commit as>
+```
+
+If the `commit-name` and `commit-email` are not provided, it will attempt to find them in `~/.gitconfig`, otherwise it will fail.
+
+This will _copy_ a single file `deployment.txt` from `service-a` in `first-environment` to `service-a` in `second-environment`, commit and push, and open a PR for the change.
+
+## Testing
+
+```shell
+$ go test ./...
+```

cmd/services/main.go

@@ -6,15 +6,16 @@ import (
 	"log"
 	"os"
 
-	"github.com/bigkevmcd/promote/pkg/cache"
-	"github.com/bigkevmcd/promote/pkg/promote"
+	"github.com/bigkevmcd/services/pkg/avancement"
+	"github.com/bigkevmcd/services/pkg/git"
 	"github.com/mitchellh/go-homedir"
 	"github.com/tcnksm/go-gitconfig"
 	"github.com/urfave/cli/v2"
 )
 
 const (
 	githubTokenFlag = "github-token"
+	branchNameFlag  = "branch-name"
 	fromFlag        = "from"
 	toFlag          = "to"
 	serviceFlag     = "service"
@@ -37,25 +38,23 @@ var (
 	promoteFlags = []cli.Flag{
 		&cli.StringFlag{
 			Name:     fromFlag,
-			Usage:    "source environment name",
+			Usage:    "source Git repository",
 			Required: true,
 		},
 		&cli.StringFlag{
 			Name:     toFlag,
-			Usage:    "destination environment name",
+			Usage:    "destination Git repository",
 			Required: true,
 		},
 		&cli.StringFlag{
 			Name:     serviceFlag,
 			Usage:    "service name to promote",
 			Required: true,
 		},
-
 		&cli.StringFlag{
-			Name:     mappingFileFlag,
-			Value:    "~/.env-mapping",
-			Usage:    "mapping from environment to repository",
-			Required: false,
+			Name:  branchNameFlag,
+			Usage: "the name to use for the newly created branch",
+			Value: "test-branch",
 		},
 		&cli.StringFlag{
 			Name:     cacheDirFlag,
@@ -81,8 +80,8 @@ var (
 
 func main() {
 	app := &cli.App{
-		Name:  "promotion-tool",
-		Usage: "promote a file between two git repositories",
+		Name:        "services",
+		Description: "manage services lifecycle via GitOps",
 		Commands: []*cli.Command{
 			{
 				Name:   "promote",
@@ -105,7 +104,7 @@ func promoteAction(c *cli.Context) error {
 	toRepo := c.String(toFlag)
 	service := c.String(serviceFlag)
 	token := c.String(githubTokenFlag)
-	newBranchName := "testing"
+	newBranchName := c.String(branchNameFlag)
 
 	cacheDir, err := homedir.Expand(c.String(cacheDirFlag))
 	if err != nil {
@@ -114,23 +113,13 @@ func promoteAction(c *cli.Context) error {
 
 	user, email, err := credentials(c)
 	if err != nil {
-		return fmt.Errorf("unable to establish: %w", err)
+		return fmt.Errorf("unable to establish credentials: %w", err)
 	}
-	cache, err := cache.NewLocalCache(cacheDir, user, email)
+	cache, err := git.NewLocalCache(cacheDir, user, email)
 	if err != nil {
 		return fmt.Errorf("failed to create a local cache in %v: %w", cacheDir, err)
 	}
-
-	mappingFilename, err := homedir.Expand(c.String(mappingFileFlag))
-	if err != nil {
-		return fmt.Errorf("failed to expand mapping file path: %w", err)
-	}
-	mapping, err := promote.LoadMappingFromFile(mappingFilename)
-	if err != nil {
-		return fmt.Errorf("failed to load the mappingfile %s: %w", mappingFilename, err)
-	}
-
-	return promote.PromoteService(cache, token, service, fromRepo, toRepo, newBranchName, mapping)
+	return avancement.New(cache, token).Promote(service, fromRepo, toRepo, newBranchName)
 }
 
 func credentials(c *cli.Context) (string, string, error) {

go.mod

@@ -1,11 +1,11 @@
-module github.com/bigkevmcd/promote
+module github.com/bigkevmcd/services
 
 go 1.13
 
 require (
 	github.com/golang/protobuf v1.3.2 // indirect
 	github.com/google/go-cmp v0.3.0
-	github.com/jenkins-x/go-scm v1.5.71
+	github.com/jenkins-x/go-scm v1.5.77
 	github.com/mitchellh/go-homedir v1.1.0
 	github.com/nbio/st v0.0.0-20140626010706-e9e8d9816f32 // indirect
 	github.com/tcnksm/go-gitconfig v0.1.2

go.sum

@@ -42,8 +42,8 @@ github.com/hpcloud/tail v1.0.0 h1:nfCOvKYfkgYP8hkirhJocXT2+zOD8yUNjXaWfTlyFKI=
 github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
 github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 h1:BQSFePA1RWJOlocH6Fxy8MmwDt+yVQYULKfN0RoTN8A=
 github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99/go.mod h1:1lJo3i6rXxKeerYnT8Nvf0QmHCRC1n8sfWVwXF2Frvo=
-github.com/jenkins-x/go-scm v1.5.71 h1:NWbwd9s5vrxnn0vCJIYhRsUYHY1OZa9WsMx+nTHyfP0=
-github.com/jenkins-x/go-scm v1.5.71/go.mod h1:PCT338UhP/pQ0IeEeMEf/hoLTYKcH7qjGEKd7jPkeYg=
+github.com/jenkins-x/go-scm v1.5.77 h1:7P2PFzYpEIr5xeeqPevfBtpLrgAdEL+ZLQofQ2tU+7s=
+github.com/jenkins-x/go-scm v1.5.77/go.mod h1:PCT338UhP/pQ0IeEeMEf/hoLTYKcH7qjGEKd7jPkeYg=
 github.com/jessevdk/go-flags v1.4.0/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI=
 github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
 github.com/kevinburke/ssh_config v0.0.0-20190725054713-01f96b0aa0cd h1:Coekwdh0v2wtGp9Gmz1Ze3eVRAWJMLokvN3QjdzCHLY=
@@ -156,6 +156,7 @@ gopkg.in/warnings.v0 v0.1.2/go.mod h1:jksf8JmL6Qr/oQM2OXTHunEvvTAsrWBLb6OOjuVWRN
 gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+k8s.io/apimachinery v0.0.0-20190703205208-4cfb76a8bf76 h1:vxMYBaJgczGAIpJAOBco2eHuFYIyDdNIebt60jxLauA=
 k8s.io/apimachinery v0.0.0-20190703205208-4cfb76a8bf76/go.mod h1:M2fZgZL9DbLfeJaPBCDqSqNsdsmLN+V29knYJnIXlMA=
 k8s.io/klog v0.3.1/go.mod h1:Gq+BEi5rUBO/HRz0bTSXDUcqjScdoY3a9IHpCEIOOfk=
 k8s.io/kube-openapi v0.0.0-20190228160746-b3a7cee44a30/go.mod h1:BXM9ceUBTj2QnfH2MK1odQs778ajze1RxcmP6S8RVVc=

pkg/avancement/pull_request.go

@@ -0,0 +1,29 @@
+package avancement
+
+import (
+	"fmt"
+
+	"github.com/bigkevmcd/services/pkg/util"
+	"github.com/jenkins-x/go-scm/scm"
+)
+
+// TODO: OptionFuncs for Base and Title?
+// TODO: For the Head, should this try and determine whether or not this is a
+// fork ("user" of both repoURLs) and if so, simplify the Head?
+func makePullRequestInput(fromURL, toURL, branchName string) (*scm.PullRequestInput, error) {
+	fromUser, fromRepo, err := util.ExtractUserAndRepo(fromURL)
+	if err != nil {
+		return nil, err
+	}
+	_, toRepo, err := util.ExtractUserAndRepo(toURL)
+	if err != nil {
+		return nil, err
+	}
+	title := fmt.Sprintf("promotion from %s to %s", fromRepo, toRepo)
+	return &scm.PullRequestInput{
+		Title: title,
+		Head:  fmt.Sprintf("%s:%s", fromUser, branchName),
+		Base:  "master",
+		Body:  "this is a test body",
+	}, nil
+}

pkg/avancement/pull_request_test.go

@@ -0,0 +1,27 @@
+package avancement
+
+import (
+	"testing"
+
+	"github.com/jenkins-x/go-scm/scm"
+
+	"github.com/google/go-cmp/cmp"
+)
+
+func TestMakePullRequestInput(t *testing.T) {
+	pr, err := makePullRequestInput("https://example.com/project/dev-env.git", "https://example.com/project/prod-env.git", "my-test-branch")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	want := &scm.PullRequestInput{
+		Title: "promotion from dev-env to prod-env",
+		Head:  "project:my-test-branch",
+		Base:  "master",
+		Body:  "this is a test body",
+	}
+
+	if diff := cmp.Diff(want, pr); diff != "" {
+		t.Fatalf("pull request input is different from expected: %s", diff)
+	}
+}

pkg/avancement/service_manager.go

@@ -0,0 +1,84 @@
+package avancement
+
+import (
+	"context"
+	"fmt"
+	"log"
+
+	"github.com/jenkins-x/go-scm/scm"
+
+	"github.com/bigkevmcd/services/pkg/git"
+	"github.com/bigkevmcd/services/pkg/util"
+)
+
+type ServiceManager struct {
+	cache         git.Cache
+	token         string
+	clientFactory scmClientFactory
+}
+
+type scmClientFactory func(token string) *scm.Client
+
+// New creates and returns a new ServiceManager.
+//
+// The token is used to create a Git token
+func New(c git.Cache, token string) *ServiceManager {
+	return &ServiceManager{cache: c, token: token, clientFactory: git.CreateGitHubClient}
+}
+
+// Promote is the main driver for promoting files between two
+// repositories.
+//
+// It uses a Git cache to checkout the code to, and will copy the environment
+// configuration for the `fromURL` to the `toURL` in a named branch.
+func (s *ServiceManager) Promote(service, fromURL, toURL, newBranchName string) error {
+	ctx := context.Background()
+	err := s.cache.CreateAndCheckoutBranch(ctx, toURL, "master", newBranchName)
+	if err != nil {
+		return fmt.Errorf("failed to create and checkout the new branch %v for the %v environment: %w", newBranchName, toURL, err)
+	}
+
+	fileToUpdate := pathForService(service)
+	newBody, err := s.cache.ReadFileFromBranch(ctx, fromURL, fileToUpdate, "master")
+	if err != nil {
+		return fmt.Errorf("failed to read the file %v from the %v environment: %w", fileToUpdate, fromURL, err)
+	}
+	err = s.cache.WriteFileToBranchAndStage(ctx, toURL, newBranchName, fileToUpdate, newBody)
+	if err != nil {
+		return fmt.Errorf("failed to write the updated file to %v: %w", fileToUpdate, err)
+	}
+
+	err = s.cache.CommitAndPushBranch(ctx, toURL, newBranchName, "this is a test commit", s.token)
+	if err != nil {
+		return fmt.Errorf("failed to commit and push branch for environment %v: %w", toURL, err)
+	}
+
+	pr, err := createPullRequest(ctx, fromURL, toURL, newBranchName, s.clientFactory(s.token))
+	if err != nil {
+		return fmt.Errorf("failed to create a pull-request for branch %s in %v: %w", newBranchName, toURL, err)
+	}
+	log.Printf("created PR %d", pr.Number)
+	return nil
+}
+
+func pathForService(s string) string {
+	return fmt.Sprintf("%s/deployment.txt", s)
+}
+
+func createPullRequest(ctx context.Context, fromURL, toURL, newBranchName string, client *scm.Client) (*scm.PullRequest, error) {
+	prInput, err := makePullRequestInput(fromURL, toURL, newBranchName)
+	if err != nil {
+		// TODO: improve this error message
+		return nil, err
+	}
+
+	user, repo, err := util.ExtractUserAndRepo(toURL)
+	if err != nil {
+		// TODO: improve this error message
+		return nil, err
+	}
+	// TODO: come up with a better way of generating the repo URL (this
+	// only works for GitHub)
+	pr, _, err := client.PullRequests.Create(ctx, fmt.Sprintf("%s/%s", user, repo), prInput)
+	return pr, err
+}

pkg/avancement/service_manager_test.go

@@ -0,0 +1,41 @@
+package avancement
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/jenkins-x/go-scm/scm"
+	fakescm "github.com/jenkins-x/go-scm/scm/driver/fake"
+
+	"github.com/bigkevmcd/services/pkg/git/mock"
+)
+
+const (
+	dev     = "https://example.com/testing/dev-env"
+	staging = "https://example.com/testing/staging-env"
+)
+
+var testBody = []byte("this is the body")
+
+func TestPromoteWithSuccess(t *testing.T) {
+	filePath := pathForService("my-service")
+	client, data := fakescm.NewDefault()
+	fakeClientFactory := func(s string) *scm.Client {
+		return client
+	}
+
+	mc := mock.New()
+	mc.AddRepoFile(dev, "master", filePath, testBody)
+
+	sm := New(mc, "testing")
+	sm.clientFactory = fakeClientFactory
+
+	err := sm.Promote("my-service", dev, staging, "my-branch")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	mc.AssertBranchCreated(t, staging, "master", "my-branch")
+	mc.AssertFileWrittenToBranch(t, staging, "my-branch", filePath, testBody)
+	mc.AssertCommitAndPush(t, staging, "my-branch", "this is a test commit", "testing")
+}

pkg/git/client.go

@@ -0,0 +1,20 @@
+package git
+
+import (
+	"context"
+
+	"github.com/jenkins-x/go-scm/scm"
+	"github.com/jenkins-x/go-scm/scm/driver/github"
+	"golang.org/x/oauth2"
+)
+
+// CreateGitHubClient creates and returns a go-scm GitHub client, using the provided
+// oauth2 token.
+func CreateGitHubClient(token string) *scm.Client {
+	client := github.NewDefault()
+	ts := oauth2.StaticTokenSource(
+		&oauth2.Token{AccessToken: token},
+	)
+	client.Client = oauth2.NewClient(context.Background(), ts)
+	return client
+}