terraform/internal/cloud/e2e/apply_auto_approve_test.go

258 lines
7.5 KiB
Go
Raw Normal View History

2021-09-22 23:53:33 +02:00
//go:build e2e
// +build e2e
package main
import (
"context"
"io/ioutil"
"log"
"os"
2021-09-22 23:53:33 +02:00
"testing"
expect "github.com/Netflix/go-expect"
2021-09-22 23:53:33 +02:00
tfe "github.com/hashicorp/go-tfe"
"github.com/hashicorp/terraform/internal/e2e"
tfversion "github.com/hashicorp/terraform/version"
2021-09-22 23:53:33 +02:00
)
func Test_terraform_apply_autoApprove(t *testing.T) {
t.Parallel()
skipWithoutRemoteTerraformVersion(t)
2021-09-22 23:53:33 +02:00
ctx := context.Background()
2021-09-22 23:53:33 +02:00
cases := map[string]struct {
operations []operationSets
validations func(t *testing.T, orgName string)
2021-09-22 23:53:33 +02:00
}{
"workspace manual apply, terraform apply without auto-approve, expect prompt": {
operations: []operationSets{
2021-09-22 23:53:33 +02:00
{
prep: func(t *testing.T, orgName, dir string) {
wsName := "app"
_ = createWorkspace(t, orgName, tfe.WorkspaceCreateOptions{
Name: tfe.String(wsName),
TerraformVersion: tfe.String(tfversion.String()),
AutoApply: tfe.Bool(false),
})
tfBlock := terraformConfigCloudBackendName(orgName, wsName)
writeMainTF(t, tfBlock, dir)
},
commands: []tfCommand{
{
command: []string{"init"},
2021-10-19 23:06:41 +02:00
expectedCmdOutput: `Terraform Cloud has been successfully initialized!`,
},
{
command: []string{"apply"},
expectedCmdOutput: `Do you want to perform these actions in workspace "app"?`,
userInput: []string{"yes"},
postInputOutput: []string{`Apply complete!`},
},
},
2021-09-22 23:53:33 +02:00
},
},
validations: func(t *testing.T, orgName string) {
workspace, err := tfeClient.Workspaces.ReadWithOptions(ctx, orgName, "app", &tfe.WorkspaceReadOptions{Include: "current_run"})
2021-09-22 23:53:33 +02:00
if err != nil {
t.Fatal(err)
}
if workspace.CurrentRun == nil {
t.Fatal("Expected workspace to have run, but got nil")
}
if workspace.CurrentRun.Status != tfe.RunApplied {
t.Fatalf("Expected run status to be `applied`, but is %s", workspace.CurrentRun.Status)
2021-09-22 23:53:33 +02:00
}
},
},
"workspace auto apply, terraform apply without auto-approve, expect prompt": {
operations: []operationSets{
2021-09-22 23:53:33 +02:00
{
prep: func(t *testing.T, orgName, dir string) {
wsName := "app"
_ = createWorkspace(t, orgName, tfe.WorkspaceCreateOptions{
Name: tfe.String(wsName),
TerraformVersion: tfe.String(tfversion.String()),
AutoApply: tfe.Bool(true),
})
tfBlock := terraformConfigCloudBackendName(orgName, wsName)
writeMainTF(t, tfBlock, dir)
},
commands: []tfCommand{
{
command: []string{"init"},
2021-10-19 23:06:41 +02:00
expectedCmdOutput: `Terraform Cloud has been successfully initialized!`,
},
{
command: []string{"apply"},
expectedCmdOutput: `Do you want to perform these actions in workspace "app"?`,
userInput: []string{"yes"},
postInputOutput: []string{`Apply complete!`},
},
},
2021-09-22 23:53:33 +02:00
},
},
validations: func(t *testing.T, orgName string) {
workspace, err := tfeClient.Workspaces.ReadWithOptions(ctx, orgName, "app", &tfe.WorkspaceReadOptions{Include: "current_run"})
2021-09-22 23:53:33 +02:00
if err != nil {
t.Fatal(err)
}
if workspace.CurrentRun == nil {
t.Fatal("Expected workspace to have run, but got nil")
2021-09-22 23:53:33 +02:00
}
if workspace.CurrentRun.Status != tfe.RunApplied {
t.Fatalf("Expected run status to be `applied`, but is %s", workspace.CurrentRun.Status)
2021-09-22 23:53:33 +02:00
}
},
},
"workspace manual apply, terraform apply with auto-approve, no prompt": {
operations: []operationSets{
2021-09-22 23:53:33 +02:00
{
prep: func(t *testing.T, orgName, dir string) {
wsName := "app"
_ = createWorkspace(t, orgName, tfe.WorkspaceCreateOptions{
Name: tfe.String(wsName),
TerraformVersion: tfe.String(tfversion.String()),
AutoApply: tfe.Bool(false),
})
tfBlock := terraformConfigCloudBackendName(orgName, wsName)
writeMainTF(t, tfBlock, dir)
},
commands: []tfCommand{
{
command: []string{"init"},
2021-10-19 23:06:41 +02:00
expectedCmdOutput: `Terraform Cloud has been successfully initialized!`,
},
{
command: []string{"apply", "-auto-approve"},
expectedCmdOutput: `Apply complete!`,
},
},
2021-09-22 23:53:33 +02:00
},
},
validations: func(t *testing.T, orgName string) {
workspace, err := tfeClient.Workspaces.ReadWithOptions(ctx, orgName, "app", &tfe.WorkspaceReadOptions{Include: "current_run"})
2021-09-22 23:53:33 +02:00
if err != nil {
t.Fatal(err)
}
if workspace.CurrentRun == nil {
t.Fatal("Expected workspace to have run, but got nil")
2021-09-22 23:53:33 +02:00
}
if workspace.CurrentRun.Status != tfe.RunApplied {
t.Fatalf("Expected run status to be `applied`, but is %s", workspace.CurrentRun.Status)
}
},
},
"workspace auto apply, terraform apply with auto-approve, no prompt": {
operations: []operationSets{
2021-09-22 23:53:33 +02:00
{
prep: func(t *testing.T, orgName, dir string) {
wsName := "app"
_ = createWorkspace(t, orgName, tfe.WorkspaceCreateOptions{
Name: tfe.String(wsName),
TerraformVersion: tfe.String(tfversion.String()),
AutoApply: tfe.Bool(true),
})
tfBlock := terraformConfigCloudBackendName(orgName, wsName)
writeMainTF(t, tfBlock, dir)
},
commands: []tfCommand{
{
command: []string{"init"},
2021-10-19 23:06:41 +02:00
expectedCmdOutput: `Terraform Cloud has been successfully initialized!`,
},
{
command: []string{"apply", "-auto-approve"},
expectedCmdOutput: `Apply complete!`,
},
},
2021-09-22 23:53:33 +02:00
},
},
validations: func(t *testing.T, orgName string) {
workspace, err := tfeClient.Workspaces.ReadWithOptions(ctx, orgName, "app", &tfe.WorkspaceReadOptions{Include: "current_run"})
2021-09-22 23:53:33 +02:00
if err != nil {
t.Fatal(err)
}
if workspace.CurrentRun == nil {
t.Fatal("Expected workspace to have run, but got nil")
2021-09-22 23:53:33 +02:00
}
if workspace.CurrentRun.Status != tfe.RunApplied {
t.Fatalf("Expected run status to be `applied`, but is %s", workspace.CurrentRun.Status)
}
},
},
}
for name, tc := range cases {
log.Println("Test: ", name)
organization, cleanup := createOrganization(t)
2021-09-22 23:53:33 +02:00
defer cleanup()
exp, err := expect.NewConsole(expect.WithStdout(os.Stdout), expect.WithDefaultTimeout(expectConsoleTimeout))
if err != nil {
t.Fatal(err)
}
defer exp.Close()
2021-09-22 23:53:33 +02:00
tmpDir, err := ioutil.TempDir("", "terraform-test")
if err != nil {
t.Fatal(err)
}
defer os.RemoveAll(tmpDir)
2021-09-22 23:53:33 +02:00
tf := e2e.NewBinary(terraformBin, tmpDir)
tf.AddEnv("TF_LOG=info")
2021-09-22 23:53:33 +02:00
tf.AddEnv(cliConfigFileEnv)
defer tf.Close()
2021-09-22 23:53:33 +02:00
for _, op := range tc.operations {
op.prep(t, organization.Name, tf.WorkDir())
for _, tfCmd := range op.commands {
cmd := tf.Cmd(tfCmd.command...)
cmd.Stdin = exp.Tty()
cmd.Stdout = exp.Tty()
cmd.Stderr = exp.Tty()
err = cmd.Start()
if err != nil {
t.Fatal(err)
}
if tfCmd.expectedCmdOutput != "" {
_, err := exp.ExpectString(tfCmd.expectedCmdOutput)
if err != nil {
t.Fatal(err)
}
2021-09-22 23:53:33 +02:00
}
lenInput := len(tfCmd.userInput)
lenInputOutput := len(tfCmd.postInputOutput)
if lenInput > 0 {
for i := 0; i < lenInput; i++ {
input := tfCmd.userInput[i]
exp.SendLine(input)
// use the index to find the corresponding
// output that matches the input.
if lenInputOutput-1 >= i {
output := tfCmd.postInputOutput[i]
_, err := exp.ExpectString(output)
if err != nil {
t.Fatal(err)
}
}
}
}
err = cmd.Wait()
if err != nil {
t.Fatal(err)
}
2021-09-22 23:53:33 +02:00
}
}
if tc.validations != nil {
tc.validations(t, organization.Name)
}
2021-09-22 23:53:33 +02:00
}
}