add initial support for deployment variables (#121)

Deployment variables are almost identical to pipeline variables, except
they must be associated with a particular environment.  Also, apparently
the current API for listing deployment variables does not (yet?) support
filtering, paging or sorting.  Supports listing, adding, deleting and
updating deployment variables, but there is no API for getting
individual deployment variables.

Documented at: https://developer.atlassian.com/bitbucket/api/2/reference/resource/repositories/%7Bworkspace%7D/%7Brepo_slug%7D/deployments_config/environments/%7Benvironment_uuid%7D/variables

Signed-off-by: Kent R. Spillner <kspillner@acm.org>

Author: sl4mmy

bitbucket.go

@@ -47,6 +47,10 @@ type repository interface {
 	AddEnvironment(opt RepositoryEnvironmentOptions) (*Environment, error)
 	DeleteEnvironment(opt RepositoryEnvironmentDeleteOptions) (interface{}, error)
 	GetEnvironment(opt RepositoryEnvironmentOptions) (*Environment, error)
+	ListDeploymentVariables(opt RepositoryDeploymentVariablesOptions) (*DeploymentVariables, error)
+	AddDeploymentVariable(opt RepositoryDeploymentVariableOptions) (*DeploymentVariable, error)
+	DeleteDeploymentVariable(opt RepositoryDeploymentVariableDeleteOptions) (interface{}, error)
+	UpdateDeploymentVariable(opt RepositoryDeploymentVariableOptions) (*DeploymentVariable, error)
 }
 
 type repositories interface {
@@ -356,3 +360,31 @@ type RepositoryEnvironmentDeleteOptions struct {
 	RepoSlug string `json:"repo_slug"`
 	Uuid     string `json:"uuid"`
 }
+
+type RepositoryDeploymentVariablesOptions struct {
+	Owner        string `json:"owner"`
+	RepoSlug     string `json:"repo_slug"`
+	Environment *Environment `json:"environment"`
+	Query        string `json:"q"`
+	Sort         string `json:"sort"`
+	PageNum      int    `json:"page"`
+	Pagelen      int    `json:"pagelen"`
+	MaxDepth     int    `json:"max_depth"`
+}
+
+type RepositoryDeploymentVariableOptions struct {
+	Owner        string `json:"owner"`
+	RepoSlug     string `json:"repo_slug"`
+	Environment *Environment `json:"environment"`
+	Uuid         string `json:"uuid"`
+	Key          string `json:"key"`
+	Value        string `json:"value"`
+	Secured      bool   `json:"secured"`
+}
+
+type RepositoryDeploymentVariableDeleteOptions struct {
+	Owner        string `json:"owner"`
+	RepoSlug     string `json:"repo_slug"`
+	Environment *Environment `json:"environment"`
+	Uuid         string `json:"uuid"`
+}

repository.go

@@ -165,6 +165,23 @@ type Environment struct {
 	Type            string
 }
 
+type DeploymentVariables struct {
+	Page      int
+	Pagelen   int
+	MaxDepth  int
+	Size      int
+	Next      string
+	Variables []DeploymentVariable
+}
+
+type DeploymentVariable struct {
+	Type    string
+	Uuid    string
+	Key     string
+	Value   string
+	Secured bool
+}
+
 func (r *Repository) Create(ro *RepositoryOptions) (*Repository, error) {
 	data := r.buildRepositoryBody(ro)
 	urlStr := r.c.requestUrl("/repositories/%s/%s", ro.Owner, ro.RepoSlug)
@@ -492,6 +509,70 @@ func (r *Repository) GetEnvironment(opt *RepositoryEnvironmentOptions) (*Environ
 	return decodeEnvironment(res)
 }
 
+func (r *Repository) ListDeploymentVariables(opt *RepositoryDeploymentVariablesOptions) (*DeploymentVariables, error) {
+	params := url.Values{}
+	if opt.Query != "" {
+		params.Add("q", opt.Query)
+	}
+
+	if opt.Sort != "" {
+		params.Add("sort", opt.Sort)
+	}
+
+	if opt.PageNum > 0 {
+		params.Add("page", strconv.Itoa(opt.PageNum))
+	}
+
+	if opt.Pagelen > 0 {
+		params.Add("pagelen", strconv.Itoa(opt.Pagelen))
+	}
+
+	if opt.MaxDepth > 0 {
+		params.Add("max_depth", strconv.Itoa(opt.MaxDepth))
+	}
+
+	urlStr := r.c.requestUrl("/repositories/%s/%s/deployments_config/environments/%s/variables?%s", opt.Owner, opt.RepoSlug, opt.Environment.Uuid, params.Encode())
+	response, err := r.c.executeRaw("GET", urlStr, "")
+	if err != nil {
+		return nil, err
+	}
+	bodyBytes, err := ioutil.ReadAll(response)
+	if err != nil {
+		return nil, err
+	}
+	bodyString := string(bodyBytes)
+	return decodeDeploymentVariables(bodyString)
+}
+
+func (r *Repository) AddDeploymentVariable(opt *RepositoryDeploymentVariableOptions) (*DeploymentVariable, error) {
+	body := r.buildDeploymentVariableBody(opt)
+	urlStr := r.c.requestUrl("/repositories/%s/%s/deployments_config/environments/%s/variables", opt.Owner, opt.RepoSlug, opt.Environment.Uuid)
+
+	response, err := r.c.execute("POST", urlStr, body)
+	if err != nil {
+		return nil, err
+	}
+
+	return decodeDeploymentVariable(response)
+}
+
+func (r *Repository) DeleteDeploymentVariable(opt *RepositoryDeploymentVariableDeleteOptions) (interface{}, error) {
+	urlStr := r.c.requestUrl("/repositories/%s/%s/deployments_config/environments/%s/variables/%s", opt.Owner, opt.RepoSlug, opt.Environment.Uuid, opt.Uuid)
+	return r.c.execute("DELETE", urlStr, "")
+}
+
+func (r *Repository) UpdateDeploymentVariable(opt *RepositoryDeploymentVariableOptions) (*DeploymentVariable, error) {
+	body := r.buildDeploymentVariableBody(opt)
+	urlStr := r.c.requestUrl("/repositories/%s/%s/deployments_config/environments/%s/variables/%s", opt.Owner, opt.RepoSlug, opt.Environment.Uuid, opt.Uuid)
+
+	response, err := r.c.execute("PUT", urlStr, body)
+	if err != nil {
+		return nil, err
+	}
+
+	return decodeDeploymentVariable(response)
+}
+
 func (r *Repository) buildRepositoryBody(ro *RepositoryOptions) string {
 
 	body := map[string]interface{}{}
@@ -642,6 +723,19 @@ func (r *Repository) buildEnvironmentBody(opt *RepositoryEnvironmentOptions) str
 	return r.buildJsonBody(body)
 }
 
+func (r *Repository) buildDeploymentVariableBody(opt *RepositoryDeploymentVariableOptions) string {
+	body := map[string]interface{}{}
+
+	if opt.Uuid != "" {
+		body["uuid"] = opt.Uuid
+	}
+	body["key"] = opt.Key
+	body["value"] = opt.Value
+	body["secured"] = opt.Secured
+
+	return r.buildJsonBody(body)
+}
+
 func (r *Repository) buildJsonBody(body map[string]interface{}) string {
 
 	data, err := json.Marshal(body)
@@ -1022,6 +1116,83 @@ func decodeEnvironment(response interface{}) (*Environment, error) {
 	return environment, nil
 }
 
+func decodeDeploymentVariables(response string) (*DeploymentVariables, error) {
+	var responseMap map[string]interface{}
+	err := json.Unmarshal([]byte(response), &responseMap)
+	if err != nil {
+		return nil, err
+	}
+
+	values := responseMap["values"].([]interface{})
+	var variablesArray []DeploymentVariable
+	var errs error = nil
+	for idx, value := range values {
+		var variable DeploymentVariable
+		err = mapstructure.Decode(value, &variable)
+		if err != nil {
+			if errs == nil {
+				errs = err
+			} else {
+				errs = fmt.Errorf("%w; deployment variable %d: %w", errs, idx, err)
+			}
+		} else {
+			variablesArray = append(variablesArray, variable)
+		}
+	}
+
+	page, ok := responseMap["page"].(float64)
+	if !ok {
+		page = 0
+	}
+
+	pagelen, ok := responseMap["pagelen"].(float64)
+	if !ok {
+		pagelen = 0
+	}
+
+	max_depth, ok := responseMap["max_depth"].(float64)
+	if !ok {
+		max_depth = 0
+	}
+
+	size, ok := responseMap["size"].(float64)
+	if !ok {
+		size = 0
+	}
+
+	next, ok := responseMap["next"].(string)
+	if !ok {
+		next = ""
+	}
+
+	deploymentVariables := DeploymentVariables{
+		Page:      int(page),
+		Pagelen:   int(pagelen),
+		MaxDepth:  int(max_depth),
+		Size:      int(size),
+		Next:      next,
+		Variables: variablesArray,
+	}
+
+	return &deploymentVariables, nil
+}
+
+func decodeDeploymentVariable(response interface{}) (*DeploymentVariable, error) {
+	responseMap := response.(map[string]interface{})
+
+	if responseMap["type"] == "error" {
+		return nil, DecodeError(responseMap)
+	}
+
+	var variable = new(DeploymentVariable)
+	err := mapstructure.Decode(responseMap, &variable)
+	if err != nil {
+		return nil, err
+	}
+
+	return variable, nil
+}
+
 func (rf RepositoryFile) String() string {
 	return rf.Path
 }

tests/variable_test.go

@@ -0,0 +1,154 @@
+package tests
+
+import (
+	"os"
+	"fmt"
+	"testing"
+	"time"
+
+	_ "github.com/k0kubun/pp"
+	"github.com/ktrysmt/go-bitbucket"
+)
+
+func TestEndToEndDeploymentVariables(t *testing.T) {
+
+	user := os.Getenv("BITBUCKET_TEST_USERNAME")
+	pass := os.Getenv("BITBUCKET_TEST_PASSWORD")
+	owner := os.Getenv("BITBUCKET_TEST_OWNER")
+	repo := os.Getenv("BITBUCKET_TEST_REPOSLUG")
+
+	if user == "" {
+		t.Error("BITBUCKET_TEST_USERNAME is empty.")
+	}
+	if pass == "" {
+		t.Error("BITBUCKET_TEST_PASSWORD is empty.")
+	}
+	if owner == "" {
+		t.Error("BITBUCKET_TEST_OWNER is empty.")
+	}
+	if repo == "" {
+		t.Error("BITBUCKET_TEST_REPOSLUG is empty.")
+	}
+
+	c := bitbucket.NewBasicAuth(user, pass)
+
+	environmentOpt := &bitbucket.RepositoryEnvironmentsOptions{
+		Owner:    owner,
+		RepoSlug: repo,
+	}
+
+	environments, err := c.Repositories.Repository.ListEnvironments(environmentOpt)
+	if err != nil {
+		t.Error(err)
+	}
+
+	if environments == nil {
+		t.Error("list didn't return any environments")
+	}
+
+	environment, err := findEnvironmentByName("Test", environments)
+	if err != nil {
+		t.Error(err)
+	}
+
+	opt := &bitbucket.RepositoryDeploymentVariableOptions{
+		Owner:       owner,
+		RepoSlug:    repo,
+		Environment: environment,
+		Key:         "foo",
+		Value:       "value",
+	}
+
+	variable, err := c.Repositories.Repository.AddDeploymentVariable(opt)
+	if err != nil {
+		t.Error(err)
+	}
+
+	opt.Key = "bar"
+	opt.Value = "other value"
+	opt.Uuid = variable.Uuid
+
+	updatedVariable, err := c.Repositories.Repository.UpdateDeploymentVariable(opt)
+	if err != nil {
+		t.Error(err)
+	}
+
+	listOpt := &bitbucket.RepositoryDeploymentVariablesOptions{
+		Owner:       owner,
+		RepoSlug:    repo,
+		Environment: environment,
+		MaxDepth:    10,
+		PageNum:     1,
+		Pagelen:     10,
+	}
+
+	err = waitForVariables(updatedVariable.Uuid, "bar", "other value", c, listOpt)
+	if err != nil {
+		t.Error(err)
+	}
+
+	deleteOpt := &bitbucket.RepositoryDeploymentVariableDeleteOptions{
+		Owner:       owner,
+		RepoSlug:    repo,
+		Environment: environment,
+		Uuid:        variable.Uuid,
+	}
+
+	_, err = c.Repositories.Repository.DeleteDeploymentVariable(deleteOpt)
+	if err != nil {
+		t.Error(err)
+	}
+
+	err = waitForDeletion(updatedVariable.Uuid, c, listOpt)
+	if err == nil {
+		t.Error("updated variable was not deleted")
+	}
+}
+
+func findEnvironmentByName(name string, e *bitbucket.Environments) (*bitbucket.Environment, error) {
+	for _, environment := range e.Environments {
+		if environment.Name == name {
+			return &environment, nil
+		}
+	}
+
+	return nil, fmt.Errorf("no environment named %s", name)
+}
+
+func waitForDeletion(uuid string, c *bitbucket.Client, opt *bitbucket.RepositoryDeploymentVariablesOptions) error {
+	for i := 0; i < 3; i++ {
+		deploymentVariables, err := c.Repositories.Repository.ListDeploymentVariables(opt)
+		if err != nil {
+			return err
+		}
+
+		for _, deploymentVariable := range deploymentVariables.Variables {
+			if deploymentVariable.Uuid == uuid {
+				time.Sleep(3 * time.Second)
+
+				break
+			}
+		}
+	}
+
+	return fmt.Errorf("update variable not found in list")
+}
+
+func waitForVariables(uuid string, key string, value string, c *bitbucket.Client, opt *bitbucket.RepositoryDeploymentVariablesOptions) error {
+	for i := 0; i < 3; i++ {
+		deploymentVariables, err := c.Repositories.Repository.ListDeploymentVariables(opt)
+		if err != nil {
+			return err
+		}
+
+		for _, deploymentVariable := range deploymentVariables.Variables {
+			if deploymentVariable.Uuid == uuid && deploymentVariable.Key == key && deploymentVariable.Value == value {
+				return nil
+			}
+		}
+
+		time.Sleep(3 * time.Second)
+	}
+
+	return fmt.Errorf("update variable not found in list")
+}