SEIT
/
drone-terraform
5
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

Update plugin_test.go

pull/106/head
Gurarpit Singh 5 years ago
committed by GitHub
parent
9649375dd1
commit
f5fab045b2
No known key found for this signature in database GPG Key ID: 4AEE18F83AFDEB23
1 changed files with 237 additions and 385 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 646
      plugin_test.go

646
plugin_test.go
View File

@ -1,411 +1,263 @@
package main package main
import ( import (
"fmt"
"io/ioutil"
"os" "os"
"os/exec" "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
Plugin struct {
Config Config
Netrc Netrc
Terraform Terraform
}
)
// 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 != "" { g.Describe("CopyTfEnv", func() {
assumeRole(p.Config.RoleARN) g.It("Should create copies of TF_VAR_ to lowercase", func() {
} // Set some initial TF_VAR_ that are uppercase
os.Setenv("TF_VAR_SOMETHING", "some value")
// writing the .netrc file with Github credentials in it. os.Setenv("TF_VAR_SOMETHING_ELSE", "some other value")
err := writeNetrc(p.Netrc.Machine, p.Netrc.Login, p.Netrc.Password) os.Setenv("TF_VAR_BASE64", "dGVzdA==")
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() 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", "destroy",
args{config: Config{}},
true,
exec.Command("terraform", "plan", "-destroy"),
},
{
"with vars",
args{config: Config{Vars: map[string]string{"username": "someuser", "password": "1pass"}}},
false,
exec.Command("terraform", "plan", "-out=plan.tfout", "-var", "username=someuser", "-var", "password=1pass"),
},
{
"with var-files",
args{config: Config{VarFiles: []string{"common.tfvars", "prod.tfvars"}}},
false,
exec.Command("terraform", "plan", "-out=plan.tfout", "-var-file=common.tfvars", "-var-file=prod.tfvars"),
},
}
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)
}
})
})
} }
for _, v := range config.Targets {
args = append(args, fmt.Sprintf("-target=%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))
}
args = append(args, "-force")
return exec.Command(
"terraform",
args...,
)
}
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
`

Write Preview
Loading…
Cancel
Save