terraform/internal/command/arguments/plan_test.go

208 lines
5.2 KiB
Go
Raw Normal View History

2021-02-22 17:55:00 +01:00
package arguments
import (
"strings"
"testing"
"github.com/google/go-cmp/cmp"
"github.com/google/go-cmp/cmp/cmpopts"
"github.com/hashicorp/terraform/internal/addrs"
"github.com/hashicorp/terraform/internal/plans"
2021-02-22 17:55:00 +01:00
)
func TestParsePlan_basicValid(t *testing.T) {
testCases := map[string]struct {
args []string
want *Plan
}{
"defaults": {
nil,
&Plan{
DetailedExitCode: false,
InputEnabled: true,
OutPath: "",
ViewType: ViewHuman,
State: &State{Lock: true},
Vars: &Vars{},
Operation: &Operation{
PlanMode: plans.NormalMode,
Parallelism: 10,
Refresh: true,
},
2021-02-22 17:55:00 +01:00
},
},
"setting all options": {
[]string{"-destroy", "-detailed-exitcode", "-input=false", "-out=saved.tfplan"},
&Plan{
DetailedExitCode: true,
InputEnabled: false,
OutPath: "saved.tfplan",
ViewType: ViewHuman,
State: &State{Lock: true},
Vars: &Vars{},
Operation: &Operation{
PlanMode: plans.DestroyMode,
Parallelism: 10,
Refresh: true,
},
2021-02-22 17:55:00 +01:00
},
},
"JSON view disables input": {
[]string{"-json"},
&Plan{
DetailedExitCode: false,
InputEnabled: false,
OutPath: "",
ViewType: ViewJSON,
State: &State{Lock: true},
Vars: &Vars{},
Operation: &Operation{
PlanMode: plans.NormalMode,
Parallelism: 10,
Refresh: true,
},
},
},
2021-02-22 17:55:00 +01:00
}
cmpOpts := cmpopts.IgnoreUnexported(Operation{}, Vars{}, State{})
2021-02-22 17:55:00 +01:00
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
got, diags := ParsePlan(tc.args)
if len(diags) > 0 {
t.Fatalf("unexpected diags: %v", diags)
}
if diff := cmp.Diff(tc.want, got, cmpOpts); diff != "" {
t.Errorf("unexpected result\n%s", diff)
2021-02-22 17:55:00 +01:00
}
})
}
}
func TestParsePlan_invalid(t *testing.T) {
got, diags := ParsePlan([]string{"-frob"})
if len(diags) == 0 {
t.Fatal("expected diags but got none")
}
if got, want := diags.Err().Error(), "flag provided but not defined"; !strings.Contains(got, want) {
t.Fatalf("wrong diags\n got: %s\nwant: %s", got, want)
}
if got.ViewType != ViewHuman {
t.Fatalf("wrong view type, got %#v, want %#v", got.ViewType, ViewHuman)
}
}
func TestParsePlan_tooManyArguments(t *testing.T) {
got, diags := ParsePlan([]string{"saved.tfplan"})
if len(diags) == 0 {
t.Fatal("expected diags but got none")
}
if got, want := diags.Err().Error(), "Too many command line arguments"; !strings.Contains(got, want) {
t.Fatalf("wrong diags\n got: %s\nwant: %s", got, want)
}
if got.ViewType != ViewHuman {
t.Fatalf("wrong view type, got %#v, want %#v", got.ViewType, ViewHuman)
}
}
func TestParsePlan_targets(t *testing.T) {
foobarbaz, _ := addrs.ParseTargetStr("foo_bar.baz")
boop, _ := addrs.ParseTargetStr("module.boop")
testCases := map[string]struct {
args []string
want []addrs.Targetable
wantErr string
}{
"no targets by default": {
args: nil,
want: nil,
},
"one target": {
args: []string{"-target=foo_bar.baz"},
want: []addrs.Targetable{foobarbaz.Subject},
},
"two targets": {
args: []string{"-target=foo_bar.baz", "-target", "module.boop"},
want: []addrs.Targetable{foobarbaz.Subject, boop.Subject},
},
"invalid traversal": {
args: []string{"-target=foo."},
want: nil,
wantErr: "Dot must be followed by attribute name",
},
"invalid target": {
args: []string{"-target=data[0].foo"},
want: nil,
wantErr: "A data source name is required",
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
got, diags := ParsePlan(tc.args)
if len(diags) > 0 {
if tc.wantErr == "" {
t.Fatalf("unexpected diags: %v", diags)
} else if got := diags.Err().Error(); !strings.Contains(got, tc.wantErr) {
t.Fatalf("wrong diags\n got: %s\nwant: %s", got, tc.wantErr)
}
}
if !cmp.Equal(got.Operation.Targets, tc.want) {
t.Fatalf("unexpected result\n%s", cmp.Diff(got.Operation.Targets, tc.want))
}
})
}
}
func TestParsePlan_vars(t *testing.T) {
testCases := map[string]struct {
args []string
want []FlagNameValue
}{
"no var flags by default": {
args: nil,
want: nil,
},
"one var": {
args: []string{"-var", "foo=bar"},
want: []FlagNameValue{
{Name: "-var", Value: "foo=bar"},
},
},
"one var-file": {
args: []string{"-var-file", "cool.tfvars"},
want: []FlagNameValue{
{Name: "-var-file", Value: "cool.tfvars"},
},
},
"ordering preserved": {
args: []string{
"-var", "foo=bar",
"-var-file", "cool.tfvars",
"-var", "boop=beep",
},
want: []FlagNameValue{
{Name: "-var", Value: "foo=bar"},
{Name: "-var-file", Value: "cool.tfvars"},
{Name: "-var", Value: "boop=beep"},
},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
got, diags := ParsePlan(tc.args)
if len(diags) > 0 {
t.Fatalf("unexpected diags: %v", diags)
}
if vars := got.Vars.All(); !cmp.Equal(vars, tc.want) {
t.Fatalf("unexpected result\n%s", cmp.Diff(vars, tc.want))
}
if got, want := got.Vars.Empty(), len(tc.want) == 0; got != want {
t.Fatalf("expected Empty() to return %t, but was %t", want, got)
}
})
}
}