Update plugin_test.go

plugin_test.go

@@ -1,411 +1,263 @@
 package main
 
 import (
-	"fmt"
-	"io/ioutil"
 	"os"
 	"os/exec"
-	"os/user"
+	"testing"
-	"path/filepath"
-	"regexp"
-	"strings"
-	"time"
 
-	"github.com/Sirupsen/logrus"
+	. "github.com/franela/goblin"
-	"github.com/aws/aws-sdk-go/aws/credentials"
-	"github.com/aws/aws-sdk-go/aws/credentials/stscreds"
-	"github.com/aws/aws-sdk-go/aws/session"
-	"github.com/aws/aws-sdk-go/service/sts"
 )
 
-type (
+func TestPlugin(t *testing.T) {
-	// Config holds input parameters for the plugin
+	g := Goblin(t)
-	Config struct {
-		Actions          []string
-		Vars             map[string]string
-		Secrets          map[string]string
-		InitOptions      InitOptions
-		FmtOptions       FmtOptions
-		Cacert           string
-		Sensitive        bool
-		RoleARN          string
-		RootDir          string
-		Parallelism      int
-		Targets          []string
-		VarFiles         []string
-		TerraformDataDir string
-	}
-
-	// Netrc is credentials for cloning
-	Netrc struct {
-		Machine  string
-		Login    string
-		Password string
-	}
-
-	// InitOptions include options for the Terraform's init command
-	InitOptions struct {
-		BackendConfig []string `json:"backend-config"`
-		Lock          *bool    `json:"lock"`
-		LockTimeout   string   `json:"lock-timeout"`
-	}
-
-	// FmtOptions fmt options for the Terraform's fmt command
-	FmtOptions struct {
-		List  *bool `json:"list"`
-		Write *bool `json:"write"`
-		Diff  *bool `json:"diff"`
-		Check *bool `json:"check"`
-	}
 
-	// Plugin represents the plugin instance to be executed
+	g.Describe("CopyTfEnv", func() {
-	Plugin struct {
+		g.It("Should create copies of TF_VAR_ to lowercase", func() {
-		Config    Config
+			// Set some initial TF_VAR_ that are uppercase
-		Netrc     Netrc
+			os.Setenv("TF_VAR_SOMETHING", "some value")
-		Terraform Terraform
+			os.Setenv("TF_VAR_SOMETHING_ELSE", "some other value")
-	}
+			os.Setenv("TF_VAR_BASE64", "dGVzdA==")
-)
-
-// Exec executes the plugin
-func (p Plugin) Exec() error {
-	// Install specified version of terraform
-	if p.Terraform.Version != "" {
-		err := installTerraform(p.Terraform.Version)
-
-		if err != nil {
-			return err
-		}
-	}
-
-	if p.Config.RoleARN != "" {
-		assumeRole(p.Config.RoleARN)
-	}
-
-	// writing the .netrc file with Github credentials in it.
-	err := writeNetrc(p.Netrc.Machine, p.Netrc.Login, p.Netrc.Password)
-	if err != nil {
-		return err
-	}
-
-	var terraformDataDir string = ".terraform"
-	if p.Config.TerraformDataDir != "" {
-		terraformDataDir = p.Config.TerraformDataDir
-		os.Setenv("TF_DATA_DIR", p.Config.TerraformDataDir)
-	}
-
-	var commands []*exec.Cmd
-
-	commands = append(commands, exec.Command("terraform", "version"))
 
 			CopyTfEnv()
 
-	if p.Config.Cacert != "" {
+			// Make sure new env vars exist with proper values
-		commands = append(commands, installCaCert(p.Config.Cacert))
+			g.Assert(os.Getenv("TF_VAR_something")).Equal("some value")
-	}
+			g.Assert(os.Getenv("TF_VAR_something_else")).Equal("some other value")
-
+			g.Assert(os.Getenv("TF_VAR_base64")).Equal("dGVzdA==")
-	commands = append(commands, deleteCache(terraformDataDir))
+		})
-	commands = append(commands, initCommand(p.Config.InitOptions))
+	})
-	commands = append(commands, getModules())
+
-
+	g.Describe("tfApply", func() {
-	// Add commands listed from Actions
+		g.It("Should return correct apply commands given the arguments", func() {
-	for _, action := range p.Config.Actions {
+			type args struct {
-		switch action {
+				config Config
-		case "fmt":
+			}
-			commands = append(commands, tfFmt(p.Config))
+
-		case "validate":
+			tests := []struct {
-			commands = append(commands, tfValidate())
+				name string
-		case "plan":
+				args args
-			commands = append(commands, tfPlan(p.Config, false))
+				want *exec.Cmd
-		case "plan-destroy":
+			}{
-			commands = append(commands, tfPlan(p.Config, true))
+				{
-		case "apply":
+					"default",
-			commands = append(commands, tfApply(p.Config))
+					args{config: Config{}},
-		case "destroy":
+					exec.Command("terraform", "apply", "plan.tfout"),
-			commands = append(commands, tfDestroy(p.Config))
+				},
-		default:
+				{
-			return fmt.Errorf("valid actions are: fmt, validate, plan, apply, plan-destroy, destroy.  You provided %s", action)
+					"with parallelism",
-		}
+					args{config: Config{Parallelism: 5}},
-	}
+					exec.Command("terraform", "apply", "-parallelism=5", "plan.tfout"),
-
+				},
-	commands = append(commands, deleteCache(terraformDataDir))
+				{
-
+					"with targets",
-	for _, c := range commands {
+					args{config: Config{Targets: []string{"target1", "target2"}}},
-		if c.Dir == "" {
+					exec.Command("terraform", "apply", "--target", "target1", "--target", "target2", "plan.tfout"),
-			wd, err := os.Getwd()
+				},
-			if err == nil {
+			}
-				c.Dir = wd
+
-			}
+			for _, tt := range tests {
-		}
+				g.Assert(tfApply(tt.args.config)).Equal(tt.want)
-		if p.Config.RootDir != "" {
+			}
-			c.Dir = c.Dir + "/" + p.Config.RootDir
+		})
-		}
+	})
-		c.Stdout = os.Stdout
+
-		c.Stderr = os.Stderr
+	g.Describe("tfDestroy", func() {
-		if !p.Config.Sensitive {
+		g.It("Should return correct destroy commands given the arguments", func() {
-			trace(c)
+			type args struct {
-		}
+				config Config
-
+			}
-		err := c.Run()
+
-		if err != nil {
+			tests := []struct {
-			logrus.WithFields(logrus.Fields{
+				name string
-				"error": err,
+				args args
-			}).Fatal("Failed to execute a command")
+				want *exec.Cmd
-		}
+			}{
-		logrus.Debug("Command completed successfully")
+				{
-	}
+					"default",
-
+					args{config: Config{}},
-	return nil
+					exec.Command("terraform", "destroy", "-force"),
-}
+				},
-
+				{
-// CopyTfEnv creates copies of TF_VAR_ to lowercase
+					"with parallelism",
-func CopyTfEnv() {
+					args{config: Config{Parallelism: 5}},
-	tfVar := regexp.MustCompile(`^TF_VAR_.*$`)
+					exec.Command("terraform", "destroy", "-parallelism=5", "-force"),
-	for _, e := range os.Environ() {
+				},
-		pair := strings.SplitN(e, "=", 2)
+				{
-		if tfVar.MatchString(pair[0]) {
+					"with targets",
-			name := strings.Split(pair[0], "TF_VAR_")
+					args{config: Config{Targets: []string{"target1", "target2"}}},
-			os.Setenv(fmt.Sprintf("TF_VAR_%s", strings.ToLower(name[1])), pair[1])
+					exec.Command("terraform", "destroy", "-target=target1", "-target=target2", "-force"),
-		}
+				},
-	}
+				{
-}
+					"with vars",
-
+					args{config: Config{Vars: map[string]string{"username": "someuser", "password": "1pass"}}},
-func assumeRole(roleArn string) {
+					exec.Command("terraform", "destroy", "-var", "username=someuser", "-var", "password=1pass", "-force"),
-	client := sts.New(session.New())
+				},
-	duration := time.Hour * 1
+				{
-	stsProvider := &stscreds.AssumeRoleProvider{
+					"with var-files",
-		Client:          client,
+					args{config: Config{VarFiles: []string{"common.tfvars", "prod.tfvars"}}},
-		Duration:        duration,
+					exec.Command("terraform", "destroy", "-var-file=common.tfvars", "-var-file=prod.tfvars", "-force"),
-		RoleARN:         roleArn,
+				},
-		RoleSessionName: "drone",
+			}
-	}
+
-
+			for _, tt := range tests {
-	value, err := credentials.NewCredentials(stsProvider).Get()
+				g.Assert(tfDestroy(tt.args.config)).Equal(tt.want)
-	if err != nil {
+			}
-		logrus.WithFields(logrus.Fields{
+		})
-			"error": err,
+	})
-		}).Fatal("Error assuming role!")
+	
-	}
+	g.Describe("tfValidate", func() {
-	os.Setenv("AWS_ACCESS_KEY_ID", value.AccessKeyID)
+		g.It("Should return correct validate command", func() {
-	os.Setenv("AWS_SECRET_ACCESS_KEY", value.SecretAccessKey)
+			tests := []struct {
-	os.Setenv("AWS_SESSION_TOKEN", value.SessionToken)
+				name string
-}
+				want *exec.Cmd
-
+			}{
-func deleteCache(terraformDataDir string) *exec.Cmd {
+				{
-	return exec.Command(
+					"default",
-		"rm",
+					exec.Command("terraform", "validate"),
-		"-rf",
+				},
-		terraformDataDir,
+			}
-	)
+
-}
+			for _, tt := range tests {
-
+				g.Assert(tfValidate()).Equal(tt.want)
-func getModules() *exec.Cmd {
+			}
-	return exec.Command(
+		})
-		"terraform",
+	})
-		"get",
+
-	)
+	g.Describe("tfPlan", func() {
-}
+		g.It("Should return correct plan commands given the arguments", func() {
-
+			type args struct {
-func initCommand(config InitOptions) *exec.Cmd {
+				config Config
-	args := []string{
+			}
-		"init",
+
-	}
+			tests := []struct {
-
+				name    string
-	for _, v := range config.BackendConfig {
+				args    args
-		args = append(args, fmt.Sprintf("-backend-config=%s", v))
+				destroy bool
-	}
+				want    *exec.Cmd
-
+			}{
-	// True is default in TF
+				{
-	if config.Lock != nil {
+					"default",
-		args = append(args, fmt.Sprintf("-lock=%t", *config.Lock))
+					args{config: Config{}},
-	}
+					false,
-
+					exec.Command("terraform", "plan", "-out=plan.tfout"),
-	// "0s" is default in TF
+				},
-	if config.LockTimeout != "" {
+				{
-		args = append(args, fmt.Sprintf("-lock-timeout=%s", config.LockTimeout))
-	}
-
-	// Fail Terraform execution on prompt
-	args = append(args, "-input=false")
-
-	return exec.Command(
-		"terraform",
-		args...,
-	)
-}
-
-func installCaCert(cacert string) *exec.Cmd {
-	ioutil.WriteFile("/usr/local/share/ca-certificates/ca_cert.crt", []byte(cacert), 0644)
-	return exec.Command(
-		"update-ca-certificates",
-	)
-}
-
-func trace(cmd *exec.Cmd) {
-	fmt.Println("$", strings.Join(cmd.Args, " "))
-}
-
-func tfApply(config Config) *exec.Cmd {
-	args := []string{
-		"apply",
-	}
-	for _, v := range config.Targets {
-		args = append(args, "--target", fmt.Sprintf("%s", v))
-	}
-	if config.Parallelism > 0 {
-		args = append(args, fmt.Sprintf("-parallelism=%d", config.Parallelism))
-	}
-	if config.InitOptions.Lock != nil {
-		args = append(args, fmt.Sprintf("-lock=%t", *config.InitOptions.Lock))
-	}
-	if config.InitOptions.LockTimeout != "" {
-		args = append(args, fmt.Sprintf("-lock-timeout=%s", config.InitOptions.LockTimeout))
-	}
-	args = append(args, getTfoutPath())
-
-	return exec.Command(
-		"terraform",
-		args...,
-	)
-}
-
-func tfDestroy(config Config) *exec.Cmd {
-	args := []string{
 					"destroy",
-	}
+					args{config: Config{}},
-	for _, v := range config.Targets {
+					true,
-		args = append(args, fmt.Sprintf("-target=%s", v))
+					exec.Command("terraform", "plan", "-destroy"),
-	}
+				},
-	args = append(args, varFiles(config.VarFiles)...)
+				{
-	args = append(args, vars(config.Vars)...)
+					"with vars",
-	if config.Parallelism > 0 {
+					args{config: Config{Vars: map[string]string{"username": "someuser", "password": "1pass"}}},
-		args = append(args, fmt.Sprintf("-parallelism=%d", config.Parallelism))
+					false,
-	}
+					exec.Command("terraform", "plan", "-out=plan.tfout", "-var", "username=someuser", "-var", "password=1pass"),
-	if config.InitOptions.Lock != nil {
+				},
-		args = append(args, fmt.Sprintf("-lock=%t", *config.InitOptions.Lock))
+				{
-	}
+					"with var-files",
-	if config.InitOptions.LockTimeout != "" {
+					args{config: Config{VarFiles: []string{"common.tfvars", "prod.tfvars"}}},
-		args = append(args, fmt.Sprintf("-lock-timeout=%s", config.InitOptions.LockTimeout))
+					false,
-	}
+					exec.Command("terraform", "plan", "-out=plan.tfout", "-var-file=common.tfvars", "-var-file=prod.tfvars"),
-	args = append(args, "-force")
+				},
-	return exec.Command(
+			}
-		"terraform",
+
-		args...,
+			for _, tt := range tests {
-	)
+				g.Assert(tfPlan(tt.args.config, tt.destroy)).Equal(tt.want)
+			}
+		})
+	})
+	g.Describe("tfFmt", func() {
+		g.It("Should return correct fmt commands given the arguments", func() {
+			type args struct {
+				config Config
+			}
+
+			affirmative := true
+			negative := false
+
+			tests := []struct {
+				name string
+				args args
+				want *exec.Cmd
+			}{
+				{
+					"default",
+					args{config: Config{}},
+					exec.Command("terraform", "fmt"),
+				},
+				{
+					"with list",
+					args{config: Config{FmtOptions: FmtOptions{List: &affirmative}}},
+					exec.Command("terraform", "fmt", "-list=true"),
+				},
+				{
+					"with write",
+					args{config: Config{FmtOptions: FmtOptions{Write: &affirmative}}},
+					exec.Command("terraform", "fmt", "-write=true"),
+				},
+				{
+					"with diff",
+					args{config: Config{FmtOptions: FmtOptions{Diff: &affirmative}}},
+					exec.Command("terraform", "fmt", "-diff=true"),
+				},
+				{
+					"with check",
+					args{config: Config{FmtOptions: FmtOptions{Check: &affirmative}}},
+					exec.Command("terraform", "fmt", "-check=true"),
+				},
+				{
+					"with combination",
+					args{config: Config{FmtOptions: FmtOptions{
+						List:  &negative,
+						Write: &negative,
+						Diff:  &affirmative,
+						Check: &affirmative,
+					}}},
+					exec.Command("terraform", "fmt", "-list=false", "-write=false", "-diff=true", "-check=true"),
+				},
+			}
+
+			for _, tt := range tests {
+				g.Assert(tfFmt(tt.args.config)).Equal(tt.want)
+			}
+		})
+	})
+
+	g.Describe("tfDataDir", func() {
+		g.It("Should override the terraform data dir environment variable when provided", func() {
+			type args struct {
+				config Config
+			}
+
+			tests := []struct {
+				name string
+				args args
+				want *exec.Cmd
+			}{
+				{
+					"with TerraformDataDir",
+					args{config: Config{TerraformDataDir: ".overriden_terraform_dir"}},
+					exec.Command("terraform", "apply", ".overriden_terraform_dir.plan.tfout"),
+				},
+				{
+					"with TerraformDataDir value as .terraform",
+					args{config: Config{TerraformDataDir: ".terraform"}},
+					exec.Command("terraform", "apply", "plan.tfout"),
+				},
+				{
+					"without TerraformDataDir",
+					args{config: Config{}},
+					exec.Command("terraform", "apply", "plan.tfout"),
+				},
+			}
+
+			for _, tt := range tests {
+				os.Setenv("TF_DATA_DIR", tt.args.config.TerraformDataDir)
+				applied := tfApply(tt.args.config)
+
+				g.Assert(applied).Equal(tt.want)
+
+			}
+		})
+	})
 }
-
-func tfPlan(config Config, destroy bool) *exec.Cmd {
-	args := []string{
-		"plan",
-	}
-
-	if destroy {
-		args = append(args, "-destroy")
-	} else {
-		args = append(args, fmt.Sprintf("-out=%s", getTfoutPath()))
-	}
-
-	for _, v := range config.Targets {
-		args = append(args, "--target", fmt.Sprintf("%s", v))
-	}
-	args = append(args, varFiles(config.VarFiles)...)
-	args = append(args, vars(config.Vars)...)
-	if config.Parallelism > 0 {
-		args = append(args, fmt.Sprintf("-parallelism=%d", config.Parallelism))
-	}
-	if config.InitOptions.Lock != nil {
-		args = append(args, fmt.Sprintf("-lock=%t", *config.InitOptions.Lock))
-	}
-	if config.InitOptions.LockTimeout != "" {
-		args = append(args, fmt.Sprintf("-lock-timeout=%s", config.InitOptions.LockTimeout))
-	}
-	return exec.Command(
-		"terraform",
-		args...,
-	)
-}
-
-func tfValidate() *exec.Cmd {
-	args := []string{
-		"validate",
-	}
-	return exec.Command(
-		"terraform",
-		args...,
-	)
-}
-
-func tfFmt(config Config) *exec.Cmd {
-	args := []string{
-		"fmt",
-	}
-	if config.FmtOptions.List != nil {
-		args = append(args, fmt.Sprintf("-list=%t", *config.FmtOptions.List))
-	}
-	if config.FmtOptions.Write != nil {
-		args = append(args, fmt.Sprintf("-write=%t", *config.FmtOptions.Write))
-	}
-	if config.FmtOptions.Diff != nil {
-		args = append(args, fmt.Sprintf("-diff=%t", *config.FmtOptions.Diff))
-	}
-	if config.FmtOptions.Check != nil {
-		args = append(args, fmt.Sprintf("-check=%t", *config.FmtOptions.Check))
-	}
-	return exec.Command(
-		"terraform",
-		args...,
-	)
-}
-
-func getTfoutPath() string {
-	terraformDataDir := os.Getenv("TF_DATA_DIR")
-	if terraformDataDir == ".terraform" || terraformDataDir == "" {
-		return "plan.tfout"
-	} else {
-		return fmt.Sprintf("%s.plan.tfout", terraformDataDir)
-	}
-}
-
-func vars(vs map[string]string) []string {
-	var args []string
-	for k, v := range vs {
-		args = append(args, "-var", fmt.Sprintf("%s=%s", k, v))
-	}
-	return args
-}
-
-func varFiles(vfs []string) []string {
-	var args []string
-	for _, v := range vfs {
-		args = append(args, fmt.Sprintf("-var-file=%s", v))
-	}
-	return args
-}
-
-// helper function to write a netrc file.
-// The following code comes from the official Git plugin for Drone:
-// https://github.com/drone-plugins/drone-git/blob/8386effd2fe8c8695cf979427f8e1762bd805192/utils.go#L43-L68
-func writeNetrc(machine, login, password string) error {
-	if machine == "" {
-		return nil
-	}
-	out := fmt.Sprintf(
-		netrcFile,
-		machine,
-		login,
-		password,
-	)
-
-	home := "/root"
-	u, err := user.Current()
-	if err == nil {
-		home = u.HomeDir
-	}
-	path := filepath.Join(home, ".netrc")
-	return ioutil.WriteFile(path, []byte(out), 0600)
-}
-
-const netrcFile = `
-machine %s
-login %s
-password %s
-`