terraform/internal/command/plan_test.go

1473 lines
39 KiB
Go
Raw Permalink Normal View History

2014-06-19 22:51:05 +02:00
package command
import (
"bytes"
"context"
"fmt"
2014-06-19 22:51:05 +02:00
"io/ioutil"
"os"
"path"
2014-07-12 06:03:56 +02:00
"path/filepath"
2014-09-18 19:40:23 +02:00
"strings"
"sync"
2014-06-19 22:51:05 +02:00
"testing"
"time"
2014-06-19 22:51:05 +02:00
"github.com/davecgh/go-spew/spew"
"github.com/zclconf/go-cty/cty"
"github.com/hashicorp/terraform/internal/addrs"
backendinit "github.com/hashicorp/terraform/internal/backend/init"
"github.com/hashicorp/terraform/internal/configs/configschema"
"github.com/hashicorp/terraform/internal/plans"
"github.com/hashicorp/terraform/internal/providers"
"github.com/hashicorp/terraform/internal/states"
"github.com/hashicorp/terraform/internal/terraform"
"github.com/hashicorp/terraform/internal/tfdiags"
2014-06-19 22:51:05 +02:00
)
func TestPlan(t *testing.T) {
td := tempDir(t)
testCopyDir(t, testFixturePath("plan"), td)
defer os.RemoveAll(td)
defer testChdir(t, td)()
p := planFixtureProvider()
2021-02-22 17:55:00 +01:00
view, done := testView(t)
c := &PlanCommand{
Meta: Meta{
testingOverrides: metaOverridesForProvider(p),
View: view,
},
}
args := []string{}
2021-02-22 17:55:00 +01:00
code := c.Run(args)
output := done(t)
if code != 0 {
t.Fatalf("bad: %d\n\n%s", code, output.Stderr())
}
}
2017-02-03 22:02:22 +01:00
func TestPlan_lockedState(t *testing.T) {
td := tempDir(t)
testCopyDir(t, testFixturePath("plan"), td)
defer os.RemoveAll(td)
defer testChdir(t, td)()
2017-02-03 22:02:22 +01:00
unlock, err := testLockState(testDataDir, filepath.Join(td, DefaultStateFilename))
2017-02-03 22:02:22 +01:00
if err != nil {
t.Fatal(err)
}
defer unlock()
p := planFixtureProvider()
2021-02-22 17:55:00 +01:00
view, done := testView(t)
2017-02-03 22:02:22 +01:00
c := &PlanCommand{
Meta: Meta{
testingOverrides: metaOverridesForProvider(p),
View: view,
2017-02-03 22:02:22 +01:00
},
}
args := []string{}
2021-02-22 17:55:00 +01:00
code := c.Run(args)
if code == 0 {
t.Fatal("expected error", done(t).Stdout())
2017-02-03 22:02:22 +01:00
}
2021-02-22 17:55:00 +01:00
output := done(t).Stderr()
if !strings.Contains(output, "lock") {
2017-02-03 22:02:22 +01:00
t.Fatal("command output does not look like a lock error:", output)
}
}
func TestPlan_plan(t *testing.T) {
tmp, cwd := testCwd(t)
defer testFixCwd(t, tmp, cwd)
planPath := testPlanFileNoop(t)
p := testProvider()
2021-02-22 17:55:00 +01:00
view, done := testView(t)
c := &PlanCommand{
Meta: Meta{
testingOverrides: metaOverridesForProvider(p),
View: view,
},
}
args := []string{planPath}
2021-02-22 17:55:00 +01:00
code := c.Run(args)
output := done(t)
if code != 1 {
t.Fatalf("wrong exit status %d; want 1\nstderr: %s", code, output.Stderr())
}
}
func TestPlan_destroy(t *testing.T) {
td := tempDir(t)
testCopyDir(t, testFixturePath("plan"), td)
defer os.RemoveAll(td)
defer testChdir(t, td)()
originalState := states.BuildState(func(s *states.SyncState) {
s.SetResourceInstanceCurrent(
addrs.Resource{
Mode: addrs.ManagedResourceMode,
Type: "test_instance",
Name: "foo",
}.Instance(addrs.NoKey).Absolute(addrs.RootModuleInstance),
&states.ResourceInstanceObjectSrc{
AttrsJSON: []byte(`{"id":"bar"}`),
Status: states.ObjectReady,
},
addrs.AbsProviderConfig{
Provider: addrs.NewDefaultProvider("test"),
Module: addrs.RootModule,
},
)
})
outPath := testTempFile(t)
statePath := testStateFile(t, originalState)
p := planFixtureProvider()
2021-02-22 17:55:00 +01:00
view, done := testView(t)
c := &PlanCommand{
Meta: Meta{
testingOverrides: metaOverridesForProvider(p),
View: view,
},
}
args := []string{
"-destroy",
"-out", outPath,
"-state", statePath,
}
2021-02-22 17:55:00 +01:00
code := c.Run(args)
output := done(t)
if code != 0 {
t.Fatalf("bad: %d\n\n%s", code, output.Stderr())
}
plan := testReadPlan(t, outPath)
for _, rc := range plan.Changes.Resources {
if got, want := rc.Action, plans.Delete; got != want {
t.Fatalf("wrong action %s for %s; want %s\nplanned change: %s", got, rc.Addr, want, spew.Sdump(rc))
}
}
}
2014-09-19 02:16:09 +02:00
2014-06-20 20:47:02 +02:00
func TestPlan_noState(t *testing.T) {
td := tempDir(t)
testCopyDir(t, testFixturePath("plan"), td)
defer os.RemoveAll(td)
defer testChdir(t, td)()
p := planFixtureProvider()
2021-02-22 17:55:00 +01:00
view, done := testView(t)
2014-06-20 20:47:02 +02:00
c := &PlanCommand{
Meta: Meta{
testingOverrides: metaOverridesForProvider(p),
View: view,
},
2014-06-19 22:51:05 +02:00
}
args := []string{}
2021-02-22 17:55:00 +01:00
code := c.Run(args)
output := done(t)
if code != 0 {
t.Fatalf("bad: %d\n\n%s", code, output.Stderr())
2014-06-19 22:51:05 +02:00
}
2014-06-26 18:56:29 +02:00
// Verify that refresh was called
if p.ReadResourceCalled {
t.Fatal("ReadResource should not be called")
2014-06-26 18:56:29 +02:00
}
2014-06-19 22:51:05 +02:00
// Verify that the provider was called with the existing state
actual := p.PlanResourceChangeRequest.PriorState
expected := cty.NullVal(p.GetProviderSchemaResponse.ResourceTypes["test_instance"].Block.ImpliedType())
if !expected.RawEquals(actual) {
t.Fatalf("wrong prior state\ngot: %#v\nwant: %#v", actual, expected)
2014-06-19 22:51:05 +02:00
}
}
2014-06-19 22:51:28 +02:00
2014-06-27 07:23:51 +02:00
func TestPlan_outPath(t *testing.T) {
td := tempDir(t)
testCopyDir(t, testFixturePath("plan"), td)
defer os.RemoveAll(td)
defer testChdir(t, td)()
outPath := filepath.Join(td, "test.plan")
2014-06-27 07:23:51 +02:00
p := planFixtureProvider()
2021-02-22 17:55:00 +01:00
view, done := testView(t)
2014-06-27 07:23:51 +02:00
c := &PlanCommand{
Meta: Meta{
testingOverrides: metaOverridesForProvider(p),
View: view,
},
2014-06-27 07:23:51 +02:00
}
2021-01-12 22:13:10 +01:00
p.PlanResourceChangeResponse = &providers.PlanResourceChangeResponse{
PlannedState: cty.NullVal(cty.EmptyObject),
2014-06-27 07:23:51 +02:00
}
args := []string{
"-out", outPath,
}
2021-02-22 17:55:00 +01:00
code := c.Run(args)
output := done(t)
if code != 0 {
t.Fatalf("bad: %d\n\n%s", code, output.Stderr())
2014-06-27 07:23:51 +02:00
}
testReadPlan(t, outPath) // will call t.Fatal itself if the file cannot be read
2014-06-27 07:23:51 +02:00
}
func TestPlan_outPathNoChange(t *testing.T) {
td := tempDir(t)
testCopyDir(t, testFixturePath("plan"), td)
defer os.RemoveAll(td)
defer testChdir(t, td)()
originalState := states.BuildState(func(s *states.SyncState) {
s.SetResourceInstanceCurrent(
addrs.Resource{
Mode: addrs.ManagedResourceMode,
Type: "test_instance",
Name: "foo",
}.Instance(addrs.NoKey).Absolute(addrs.RootModuleInstance),
&states.ResourceInstanceObjectSrc{
// Aside from "id" (which is computed) the values here must
// exactly match the values in the "plan" test fixture in order
// to produce the empty plan we need for this test.
AttrsJSON: []byte(`{"id":"bar","ami":"bar","network_interface":[{"description":"Main network interface","device_index":"0"}]}`),
Status: states.ObjectReady,
},
addrs.AbsProviderConfig{
Provider: addrs.NewDefaultProvider("test"),
Module: addrs.RootModule,
},
)
})
statePath := testStateFile(t, originalState)
outPath := filepath.Join(td, "test.plan")
p := planFixtureProvider()
2021-02-22 17:55:00 +01:00
view, done := testView(t)
c := &PlanCommand{
Meta: Meta{
testingOverrides: metaOverridesForProvider(p),
View: view,
},
}
args := []string{
"-out", outPath,
"-state", statePath,
}
2021-02-22 17:55:00 +01:00
code := c.Run(args)
output := done(t)
if code != 0 {
t.Fatalf("bad: %d\n\n%s", code, output.Stderr())
}
plan := testReadPlan(t, outPath)
if !plan.Changes.Empty() {
t.Fatalf("Expected empty plan to be written to plan file, got: %s", spew.Sdump(plan))
}
}
2017-01-19 05:50:45 +01:00
// When using "-out" with a backend, the plan should encode the backend config
func TestPlan_outBackend(t *testing.T) {
// Create a temporary working directory that is empty
td := tempDir(t)
testCopyDir(t, testFixturePath("plan-out-backend"), td)
2017-01-19 05:50:45 +01:00
defer os.RemoveAll(td)
defer testChdir(t, td)()
originalState := states.BuildState(func(s *states.SyncState) {
s.SetResourceInstanceCurrent(
addrs.Resource{
Mode: addrs.ManagedResourceMode,
Type: "test_instance",
Name: "foo",
}.Instance(addrs.NoKey).Absolute(addrs.RootModuleInstance),
&states.ResourceInstanceObjectSrc{
AttrsJSON: []byte(`{"id":"bar","ami":"bar"}`),
Status: states.ObjectReady,
2017-01-19 05:50:45 +01:00
},
addrs.AbsProviderConfig{
Provider: addrs.NewDefaultProvider("test"),
Module: addrs.RootModule,
},
)
})
2017-01-19 05:50:45 +01:00
// Set up our backend state
2017-01-19 05:50:45 +01:00
dataState, srv := testBackendState(t, originalState, 200)
defer srv.Close()
testStateFileRemote(t, dataState)
outPath := "foo"
p := testProvider()
p.GetProviderSchemaResponse = &providers.GetProviderSchemaResponse{
2021-01-12 22:13:10 +01:00
ResourceTypes: map[string]providers.Schema{
"test_instance": {
2021-01-12 22:13:10 +01:00
Block: &configschema.Block{
Attributes: map[string]*configschema.Attribute{
"id": {
Type: cty.String,
Computed: true,
},
"ami": {
Type: cty.String,
Optional: true,
},
},
},
},
},
}
p.PlanResourceChangeFn = func(req providers.PlanResourceChangeRequest) providers.PlanResourceChangeResponse {
return providers.PlanResourceChangeResponse{
PlannedState: req.ProposedNewState,
}
}
2021-02-22 17:55:00 +01:00
view, done := testView(t)
2017-01-19 05:50:45 +01:00
c := &PlanCommand{
Meta: Meta{
testingOverrides: metaOverridesForProvider(p),
View: view,
2017-01-19 05:50:45 +01:00
},
}
args := []string{
"-out", outPath,
}
2021-02-22 17:55:00 +01:00
code := c.Run(args)
output := done(t)
if code != 0 {
t.Logf("stdout: %s", output.Stdout())
t.Fatalf("plan command failed with exit code %d\n\n%s", code, output.Stderr())
2017-01-19 05:50:45 +01:00
}
plan := testReadPlan(t, outPath)
if !plan.Changes.Empty() {
t.Fatalf("Expected empty plan to be written to plan file, got: %s", spew.Sdump(plan))
2017-01-19 05:50:45 +01:00
}
if got, want := plan.Backend.Type, "http"; got != want {
t.Errorf("wrong backend type %q; want %q", got, want)
}
if got, want := plan.Backend.Workspace, "default"; got != want {
t.Errorf("wrong backend workspace %q; want %q", got, want)
2017-01-19 05:50:45 +01:00
}
{
httpBackend := backendinit.Backend("http")()
schema := httpBackend.ConfigSchema()
got, err := plan.Backend.Config.Decode(schema.ImpliedType())
if err != nil {
t.Fatalf("failed to decode backend config in plan: %s", err)
}
want, err := dataState.Backend.Config(schema)
if err != nil {
t.Fatalf("failed to decode cached config: %s", err)
}
if !want.RawEquals(got) {
t.Errorf("wrong backend config\ngot: %#v\nwant: %#v", got, want)
}
2017-01-19 05:50:45 +01:00
}
}
func TestPlan_refreshFalse(t *testing.T) {
// Create a temporary working directory that is empty
td := tempDir(t)
testCopyDir(t, testFixturePath("plan"), td)
defer os.RemoveAll(td)
defer testChdir(t, td)()
p := planFixtureProvider()
2021-02-22 17:55:00 +01:00
view, done := testView(t)
2014-06-26 18:56:29 +02:00
c := &PlanCommand{
Meta: Meta{
testingOverrides: metaOverridesForProvider(p),
View: view,
},
2014-06-26 18:56:29 +02:00
}
args := []string{
"-refresh=false",
}
2021-02-22 17:55:00 +01:00
code := c.Run(args)
output := done(t)
if code != 0 {
t.Fatalf("bad: %d\n\n%s", code, output.Stderr())
2014-06-26 18:56:29 +02:00
}
if p.ReadResourceCalled {
t.Fatal("ReadResource should not have been called")
2014-06-26 18:56:29 +02:00
}
}
2014-06-20 20:47:02 +02:00
func TestPlan_state(t *testing.T) {
// Create a temporary working directory that is empty
td := tempDir(t)
testCopyDir(t, testFixturePath("plan"), td)
defer os.RemoveAll(td)
defer testChdir(t, td)()
2014-09-18 19:40:23 +02:00
originalState := testState()
statePath := testStateFile(t, originalState)
2014-06-19 22:51:05 +02:00
p := planFixtureProvider()
2021-02-22 17:55:00 +01:00
view, done := testView(t)
2014-06-20 20:47:02 +02:00
c := &PlanCommand{
Meta: Meta{
testingOverrides: metaOverridesForProvider(p),
View: view,
},
2014-06-19 22:51:05 +02:00
}
args := []string{
"-state", statePath,
}
2021-02-22 17:55:00 +01:00
code := c.Run(args)
output := done(t)
if code != 0 {
t.Fatalf("bad: %d\n\n%s", code, output.Stderr())
2014-06-19 22:51:05 +02:00
}
// Verify that the provider was called with the existing state
actual := p.PlanResourceChangeRequest.PriorState
expected := cty.ObjectVal(map[string]cty.Value{
2018-10-15 00:36:19 +02:00
"id": cty.StringVal("bar"),
"ami": cty.NullVal(cty.String),
"network_interface": cty.NullVal(cty.List(cty.Object(map[string]cty.Type{
2018-10-15 00:36:19 +02:00
"device_index": cty.String,
"description": cty.String,
}))),
})
if !expected.RawEquals(actual) {
t.Fatalf("wrong prior state\ngot: %#v\nwant: %#v", actual, expected)
2014-06-19 22:51:05 +02:00
}
}
2014-07-12 06:03:56 +02:00
func TestPlan_stateDefault(t *testing.T) {
// Create a temporary working directory that is empty
td := tempDir(t)
testCopyDir(t, testFixturePath("plan"), td)
defer os.RemoveAll(td)
defer testChdir(t, td)()
// Generate state and move it to the default path
2014-09-18 19:40:23 +02:00
originalState := testState()
statePath := testStateFile(t, originalState)
os.Rename(statePath, path.Join(td, "terraform.tfstate"))
2014-07-12 06:03:56 +02:00
p := planFixtureProvider()
2021-02-22 17:55:00 +01:00
view, done := testView(t)
2014-07-12 06:03:56 +02:00
c := &PlanCommand{
Meta: Meta{
testingOverrides: metaOverridesForProvider(p),
View: view,
},
2014-07-12 06:03:56 +02:00
}
args := []string{}
2021-02-22 17:55:00 +01:00
code := c.Run(args)
output := done(t)
if code != 0 {
t.Fatalf("bad: %d\n\n%s", code, output.Stderr())
2014-07-12 06:03:56 +02:00
}
// Verify that the provider was called with the existing state
actual := p.PlanResourceChangeRequest.PriorState
expected := cty.ObjectVal(map[string]cty.Value{
2018-10-15 00:36:19 +02:00
"id": cty.StringVal("bar"),
"ami": cty.NullVal(cty.String),
"network_interface": cty.NullVal(cty.List(cty.Object(map[string]cty.Type{
2018-10-15 00:36:19 +02:00
"device_index": cty.String,
"description": cty.String,
}))),
})
if !expected.RawEquals(actual) {
t.Fatalf("wrong prior state\ngot: %#v\nwant: %#v", actual, expected)
2014-07-12 06:03:56 +02:00
}
}
2014-07-18 20:37:27 +02:00
func TestPlan_validate(t *testing.T) {
// This is triggered by not asking for input so we have to set this to false
test = false
defer func() { test = true }()
td := tempDir(t)
testCopyDir(t, testFixturePath("plan-invalid"), td)
defer os.RemoveAll(td)
defer testChdir(t, td)()
p := testProvider()
p.GetProviderSchemaResponse = &providers.GetProviderSchemaResponse{
2021-01-12 22:13:10 +01:00
ResourceTypes: map[string]providers.Schema{
"test_instance": {
2021-01-12 22:13:10 +01:00
Block: &configschema.Block{
Attributes: map[string]*configschema.Attribute{
"id": {Type: cty.String, Optional: true, Computed: true},
},
},
},
},
}
p.PlanResourceChangeFn = func(req providers.PlanResourceChangeRequest) providers.PlanResourceChangeResponse {
return providers.PlanResourceChangeResponse{
PlannedState: req.ProposedNewState,
}
}
2021-02-22 17:55:00 +01:00
view, done := testView(t)
c := &PlanCommand{
Meta: Meta{
testingOverrides: metaOverridesForProvider(p),
View: view,
},
}
2021-02-22 17:55:00 +01:00
args := []string{"-no-color"}
code := c.Run(args)
output := done(t)
if code != 1 {
t.Fatalf("bad: %d\n\n%s", code, output.Stderr())
}
2021-02-22 17:55:00 +01:00
actual := output.Stderr()
if want := "Error: Invalid count argument"; !strings.Contains(actual, want) {
t.Fatalf("unexpected error output\ngot:\n%s\n\nshould contain: %s", actual, want)
}
if want := "9: count = timestamp()"; !strings.Contains(actual, want) {
t.Fatalf("unexpected error output\ngot:\n%s\n\nshould contain: %s", actual, want)
}
}
2014-07-18 20:37:27 +02:00
func TestPlan_vars(t *testing.T) {
// Create a temporary working directory that is empty
td := tempDir(t)
testCopyDir(t, testFixturePath("plan-vars"), td)
defer os.RemoveAll(td)
defer testChdir(t, td)()
p := planVarsFixtureProvider()
2021-02-22 17:55:00 +01:00
view, done := testView(t)
2014-07-18 20:37:27 +02:00
c := &PlanCommand{
Meta: Meta{
testingOverrides: metaOverridesForProvider(p),
View: view,
2014-07-18 20:37:27 +02:00
},
}
actual := ""
p.PlanResourceChangeFn = func(req providers.PlanResourceChangeRequest) (resp providers.PlanResourceChangeResponse) {
actual = req.ProposedNewState.GetAttr("value").AsString()
resp.PlannedState = req.ProposedNewState
return
2014-07-18 20:37:27 +02:00
}
args := []string{
"-var", "foo=bar",
}
2021-02-22 17:55:00 +01:00
code := c.Run(args)
output := done(t)
if code != 0 {
t.Fatalf("bad: %d\n\n%s", code, output.Stderr())
2014-07-18 20:37:27 +02:00
}
if actual != "bar" {
t.Fatal("didn't work")
}
}
2014-07-18 23:00:40 +02:00
func TestPlan_varsUnset(t *testing.T) {
// Create a temporary working directory that is empty
td := tempDir(t)
testCopyDir(t, testFixturePath("plan-vars"), td)
defer os.RemoveAll(td)
defer testChdir(t, td)()
// The plan command will prompt for interactive input of var.foo.
// We'll answer "bar" to that prompt, which should then allow this
// configuration to apply even though var.foo doesn't have a
// default value and there are no -var arguments on our command line.
// This will (helpfully) panic if more than one variable is requested during plan:
// https://github.com/hashicorp/terraform/issues/26027
close := testInteractiveInput(t, []string{"bar"})
defer close()
p := planVarsFixtureProvider()
2021-02-22 17:55:00 +01:00
view, done := testView(t)
c := &PlanCommand{
Meta: Meta{
testingOverrides: metaOverridesForProvider(p),
View: view,
},
}
args := []string{}
2021-02-22 17:55:00 +01:00
code := c.Run(args)
output := done(t)
if code != 0 {
t.Fatalf("bad: %d\n\n%s", code, output.Stderr())
}
}
// This test adds a required argument to the test provider to validate
// processing of user input:
// https://github.com/hashicorp/terraform/issues/26035
func TestPlan_providerArgumentUnset(t *testing.T) {
// Create a temporary working directory that is empty
td := tempDir(t)
testCopyDir(t, testFixturePath("plan"), td)
defer os.RemoveAll(td)
defer testChdir(t, td)()
// Disable test mode so input would be asked
test = false
defer func() { test = true }()
// The plan command will prompt for interactive input of provider.test.region
defaultInputReader = bytes.NewBufferString("us-east-1\n")
p := planFixtureProvider()
// override the planFixtureProvider schema to include a required provider argument
p.GetProviderSchemaResponse = &providers.GetProviderSchemaResponse{
2021-01-12 22:13:10 +01:00
Provider: providers.Schema{
Block: &configschema.Block{
Attributes: map[string]*configschema.Attribute{
"region": {Type: cty.String, Required: true},
},
},
},
2021-01-12 22:13:10 +01:00
ResourceTypes: map[string]providers.Schema{
"test_instance": {
2021-01-12 22:13:10 +01:00
Block: &configschema.Block{
Attributes: map[string]*configschema.Attribute{
"id": {Type: cty.String, Optional: true, Computed: true},
"ami": {Type: cty.String, Optional: true, Computed: true},
},
BlockTypes: map[string]*configschema.NestedBlock{
"network_interface": {
Nesting: configschema.NestingList,
Block: configschema.Block{
Attributes: map[string]*configschema.Attribute{
"device_index": {Type: cty.String, Optional: true},
"description": {Type: cty.String, Optional: true},
},
},
},
},
},
},
},
}
2021-02-22 17:55:00 +01:00
view, done := testView(t)
c := &PlanCommand{
Meta: Meta{
testingOverrides: metaOverridesForProvider(p),
View: view,
},
}
args := []string{}
2021-02-22 17:55:00 +01:00
code := c.Run(args)
output := done(t)
if code != 0 {
t.Fatalf("bad: %d\n\n%s", code, output.Stderr())
}
}
// Test that terraform properly merges provider configuration that's split
// between config files and interactive input variables.
// https://github.com/hashicorp/terraform/issues/28956
func TestPlan_providerConfigMerge(t *testing.T) {
td := tempDir(t)
testCopyDir(t, testFixturePath("plan-provider-input"), td)
defer os.RemoveAll(td)
defer testChdir(t, td)()
// Disable test mode so input would be asked
test = false
defer func() { test = true }()
// The plan command will prompt for interactive input of provider.test.region
defaultInputReader = bytes.NewBufferString("us-east-1\n")
p := planFixtureProvider()
// override the planFixtureProvider schema to include a required provider argument and a nested block
p.GetProviderSchemaResponse = &providers.GetProviderSchemaResponse{
Provider: providers.Schema{
Block: &configschema.Block{
Attributes: map[string]*configschema.Attribute{
"region": {Type: cty.String, Required: true},
"url": {Type: cty.String, Required: true},
},
BlockTypes: map[string]*configschema.NestedBlock{
"auth": {
Nesting: configschema.NestingList,
Block: configschema.Block{
Attributes: map[string]*configschema.Attribute{
"user": {Type: cty.String, Required: true},
"password": {Type: cty.String, Required: true},
},
},
},
},
},
},
ResourceTypes: map[string]providers.Schema{
"test_instance": {
Block: &configschema.Block{
Attributes: map[string]*configschema.Attribute{
"id": {Type: cty.String, Optional: true, Computed: true},
},
},
},
},
}
view, done := testView(t)
c := &PlanCommand{
Meta: Meta{
testingOverrides: metaOverridesForProvider(p),
View: view,
},
}
args := []string{}
code := c.Run(args)
output := done(t)
if code != 0 {
t.Fatalf("bad: %d\n\n%s", code, output.Stderr())
}
if !p.ConfigureProviderCalled {
t.Fatal("configure provider not called")
}
// For this test, we want to confirm that we've sent the expected config
// value *to* the provider.
got := p.ConfigureProviderRequest.Config
want := cty.ObjectVal(map[string]cty.Value{
"auth": cty.ListVal([]cty.Value{
cty.ObjectVal(map[string]cty.Value{
"user": cty.StringVal("one"),
"password": cty.StringVal("onepw"),
}),
cty.ObjectVal(map[string]cty.Value{
"user": cty.StringVal("two"),
"password": cty.StringVal("twopw"),
}),
}),
"region": cty.StringVal("us-east-1"),
"url": cty.StringVal("example.com"),
})
if !got.RawEquals(want) {
t.Fatal("wrong provider config")
}
}
2014-07-18 23:00:40 +02:00
func TestPlan_varFile(t *testing.T) {
// Create a temporary working directory that is empty
td := tempDir(t)
testCopyDir(t, testFixturePath("plan-vars"), td)
defer os.RemoveAll(td)
defer testChdir(t, td)()
2014-07-18 23:00:40 +02:00
varFilePath := testTempFile(t)
if err := ioutil.WriteFile(varFilePath, []byte(planVarFile), 0644); err != nil {
t.Fatalf("err: %s", err)
}
p := planVarsFixtureProvider()
2021-02-22 17:55:00 +01:00
view, done := testView(t)
2014-07-18 23:00:40 +02:00
c := &PlanCommand{
Meta: Meta{
testingOverrides: metaOverridesForProvider(p),
View: view,
2014-07-18 23:00:40 +02:00
},
}
actual := ""
p.PlanResourceChangeFn = func(req providers.PlanResourceChangeRequest) (resp providers.PlanResourceChangeResponse) {
actual = req.ProposedNewState.GetAttr("value").AsString()
resp.PlannedState = req.ProposedNewState
return
2014-07-18 23:00:40 +02:00
}
args := []string{
"-var-file", varFilePath,
}
2021-02-22 17:55:00 +01:00
code := c.Run(args)
output := done(t)
if code != 0 {
t.Fatalf("bad: %d\n\n%s", code, output.Stderr())
2014-07-18 23:00:40 +02:00
}
if actual != "bar" {
t.Fatal("didn't work")
}
}
func TestPlan_varFileDefault(t *testing.T) {
// Create a temporary working directory that is empty
td := tempDir(t)
testCopyDir(t, testFixturePath("plan-vars"), td)
defer os.RemoveAll(td)
defer testChdir(t, td)()
varFilePath := filepath.Join(td, "terraform.tfvars")
if err := ioutil.WriteFile(varFilePath, []byte(planVarFile), 0644); err != nil {
t.Fatalf("err: %s", err)
}
p := planVarsFixtureProvider()
2021-02-22 17:55:00 +01:00
view, done := testView(t)
c := &PlanCommand{
Meta: Meta{
testingOverrides: metaOverridesForProvider(p),
View: view,
},
}
actual := ""
p.PlanResourceChangeFn = func(req providers.PlanResourceChangeRequest) (resp providers.PlanResourceChangeResponse) {
actual = req.ProposedNewState.GetAttr("value").AsString()
resp.PlannedState = req.ProposedNewState
return
}
args := []string{}
2021-02-22 17:55:00 +01:00
code := c.Run(args)
output := done(t)
if code != 0 {
t.Fatalf("bad: %d\n\n%s", code, output.Stderr())
}
if actual != "bar" {
t.Fatal("didn't work")
}
}
func TestPlan_varFileWithDecls(t *testing.T) {
// Create a temporary working directory that is empty
td := tempDir(t)
testCopyDir(t, testFixturePath("plan-vars"), td)
defer os.RemoveAll(td)
defer testChdir(t, td)()
varFilePath := testTempFile(t)
if err := ioutil.WriteFile(varFilePath, []byte(planVarFileWithDecl), 0644); err != nil {
t.Fatalf("err: %s", err)
}
p := planVarsFixtureProvider()
2021-02-22 17:55:00 +01:00
view, done := testView(t)
c := &PlanCommand{
Meta: Meta{
testingOverrides: metaOverridesForProvider(p),
View: view,
},
}
args := []string{
"-var-file", varFilePath,
}
2021-02-22 17:55:00 +01:00
code := c.Run(args)
output := done(t)
if code == 0 {
t.Fatalf("succeeded; want failure\n\n%s", output.Stdout())
}
2021-02-22 17:55:00 +01:00
msg := output.Stderr()
if got, want := msg, "Variable declaration in .tfvars file"; !strings.Contains(got, want) {
t.Fatalf("missing expected error message\nwant message containing %q\ngot:\n%s", want, got)
}
}
func TestPlan_detailedExitcode(t *testing.T) {
td := tempDir(t)
testCopyDir(t, testFixturePath("plan"), td)
defer os.RemoveAll(td)
defer testChdir(t, td)()
t.Run("return 1", func(t *testing.T) {
view, done := testView(t)
c := &PlanCommand{
Meta: Meta{
// Running plan without setting testingOverrides is similar to plan without init
View: view,
},
}
code := c.Run([]string{"-detailed-exitcode"})
output := done(t)
if code != 1 {
t.Fatalf("bad: %d\n\n%s", code, output.Stderr())
}
})
t.Run("return 2", func(t *testing.T) {
p := planFixtureProvider()
view, done := testView(t)
c := &PlanCommand{
Meta: Meta{
testingOverrides: metaOverridesForProvider(p),
View: view,
},
}
code := c.Run([]string{"-detailed-exitcode"})
output := done(t)
if code != 2 {
t.Fatalf("bad: %d\n\n%s", code, output.Stderr())
}
})
}
func TestPlan_detailedExitcode_emptyDiff(t *testing.T) {
td := tempDir(t)
testCopyDir(t, testFixturePath("plan-emptydiff"), td)
defer os.RemoveAll(td)
defer testChdir(t, td)()
p := testProvider()
2021-02-22 17:55:00 +01:00
view, done := testView(t)
c := &PlanCommand{
Meta: Meta{
testingOverrides: metaOverridesForProvider(p),
View: view,
},
}
args := []string{"-detailed-exitcode"}
2021-02-22 17:55:00 +01:00
code := c.Run(args)
output := done(t)
if code != 0 {
t.Fatalf("bad: %d\n\n%s", code, output.Stderr())
}
}
func TestPlan_shutdown(t *testing.T) {
// Create a temporary working directory that is empty
td := tempDir(t)
testCopyDir(t, testFixturePath("apply-shutdown"), td)
defer os.RemoveAll(td)
defer testChdir(t, td)()
cancelled := make(chan struct{})
shutdownCh := make(chan struct{})
p := testProvider()
2021-02-22 17:55:00 +01:00
view, done := testView(t)
c := &PlanCommand{
Meta: Meta{
testingOverrides: metaOverridesForProvider(p),
View: view,
ShutdownCh: shutdownCh,
},
}
p.StopFn = func() error {
close(cancelled)
return nil
}
var once sync.Once
p.PlanResourceChangeFn = func(req providers.PlanResourceChangeRequest) (resp providers.PlanResourceChangeResponse) {
once.Do(func() {
shutdownCh <- struct{}{}
})
// Because of the internal lock in the MockProvider, we can't
// coordinate directly with the calling of Stop, and making the
// MockProvider concurrent is disruptive to a lot of existing tests.
// Wait here a moment to help make sure the main goroutine gets to the
// Stop call before we exit, or the plan may finish before it can be
// canceled.
time.Sleep(200 * time.Millisecond)
s := req.ProposedNewState.AsValueMap()
s["ami"] = cty.StringVal("bar")
resp.PlannedState = cty.ObjectVal(s)
return
}
p.GetProviderSchemaResponse = &providers.GetProviderSchemaResponse{
2021-01-12 22:13:10 +01:00
ResourceTypes: map[string]providers.Schema{
"test_instance": {
2021-01-12 22:13:10 +01:00
Block: &configschema.Block{
Attributes: map[string]*configschema.Attribute{
"ami": {Type: cty.String, Optional: true},
},
},
},
},
}
code := c.Run([]string{})
2021-02-22 17:55:00 +01:00
output := done(t)
if code != 1 {
2021-02-22 17:55:00 +01:00
t.Errorf("wrong exit code %d; want 1\noutput:\n%s", code, output.Stdout())
}
select {
case <-cancelled:
default:
t.Error("command not cancelled")
}
}
func TestPlan_init_required(t *testing.T) {
td := tempDir(t)
testCopyDir(t, testFixturePath("plan"), td)
defer os.RemoveAll(td)
defer testChdir(t, td)()
2021-02-22 17:55:00 +01:00
view, done := testView(t)
c := &PlanCommand{
Meta: Meta{
// Running plan without setting testingOverrides is similar to plan without init
View: view,
},
}
2021-03-22 21:38:56 +01:00
args := []string{"-no-color"}
2021-02-22 17:55:00 +01:00
code := c.Run(args)
output := done(t)
if code != 1 {
t.Fatalf("expected error, got success")
}
2021-02-22 17:55:00 +01:00
got := output.Stderr()
backend/local: Check dependency lock consistency before any operations In historical versions of Terraform the responsibility to check this was inside the terraform.NewContext function, along with various other assorted concerns that made that function particularly complicated. More recently, we reduced the responsibility of the "terraform" package only to instantiating particular named plugins, assuming that its caller is responsible for selecting appropriate versions of any providers that _are_ external. However, until this commit we were just assuming that "terraform init" had correctly selected appropriate plugins and recorded them in the lock file, and so nothing was dealing with the problem of ensuring that there haven't been any changes to the lock file or config since the most recent "terraform init" which would cause us to need to re-evaluate those decisions. Part of the game here is to slightly extend the role of the dependency locks object to also carry information about a subset of provider addresses whose lock entries we're intentionally disregarding as part of the various little edge-case features we have for overridding providers: dev_overrides, "unmanaged providers", and the testing overrides in our own unit tests. This is an in-memory-only annotation, never included in the serialized plan files on disk. I had originally intended to create a new package to encapsulate all of this plugin-selection logic, including both the version constraint checking here and also the handling of the provider factory functions, but as an interim step I've just made version constraint consistency checks the responsibility of the backend/local package, which means that we'll always catch problems as part of preparing for local operations, while not imposing these additional checks on commands that _don't_ run local operations, such as "terraform apply" when in remote operations mode.
2021-09-30 02:31:43 +02:00
if !(strings.Contains(got, "terraform init") && strings.Contains(got, "provider registry.terraform.io/hashicorp/test: required by this configuration but no version is selected")) {
2021-02-22 17:55:00 +01:00
t.Fatal("wrong error message in output:", got)
}
}
// Config with multiple resources, targeting plan of a subset
func TestPlan_targeted(t *testing.T) {
td := tempDir(t)
testCopyDir(t, testFixturePath("apply-targeted"), td)
defer os.RemoveAll(td)
defer testChdir(t, td)()
p := testProvider()
p.GetProviderSchemaResponse = &providers.GetProviderSchemaResponse{
ResourceTypes: map[string]providers.Schema{
"test_instance": {
Block: &configschema.Block{
Attributes: map[string]*configschema.Attribute{
"id": {Type: cty.String, Computed: true},
},
},
},
},
}
p.PlanResourceChangeFn = func(req providers.PlanResourceChangeRequest) providers.PlanResourceChangeResponse {
return providers.PlanResourceChangeResponse{
PlannedState: req.ProposedNewState,
}
}
2021-02-17 19:01:30 +01:00
view, done := testView(t)
c := &PlanCommand{
Meta: Meta{
testingOverrides: metaOverridesForProvider(p),
View: view,
},
}
args := []string{
"-target", "test_instance.foo",
"-target", "test_instance.baz",
}
2021-02-22 17:55:00 +01:00
code := c.Run(args)
output := done(t)
if code != 0 {
t.Fatalf("bad: %d\n\n%s", code, output.Stderr())
}
2021-02-22 17:55:00 +01:00
if got, want := output.Stdout(), "3 to add, 0 to change, 0 to destroy"; !strings.Contains(got, want) {
t.Fatalf("bad change summary, want %q, got:\n%s", want, got)
}
}
// Diagnostics for invalid -target flags
func TestPlan_targetFlagsDiags(t *testing.T) {
testCases := map[string]string{
"test_instance.": "Dot must be followed by attribute name.",
"test_instance": "Resource specification must include a resource type and name.",
}
for target, wantDiag := range testCases {
t.Run(target, func(t *testing.T) {
td := testTempDir(t)
defer os.RemoveAll(td)
defer testChdir(t, td)()
2021-02-22 17:55:00 +01:00
view, done := testView(t)
c := &PlanCommand{
Meta: Meta{
View: view,
},
}
args := []string{
"-target", target,
}
2021-02-22 17:55:00 +01:00
code := c.Run(args)
output := done(t)
if code != 1 {
t.Fatalf("bad: %d\n\n%s", code, output.Stdout())
}
2021-02-22 17:55:00 +01:00
got := output.Stderr()
if !strings.Contains(got, target) {
t.Fatalf("bad error output, want %q, got:\n%s", target, got)
}
if !strings.Contains(got, wantDiag) {
t.Fatalf("bad error output, want %q, got:\n%s", wantDiag, got)
}
})
}
}
func TestPlan_replace(t *testing.T) {
td := tempDir(t)
testCopyDir(t, testFixturePath("plan-replace"), td)
defer os.RemoveAll(td)
defer testChdir(t, td)()
originalState := states.BuildState(func(s *states.SyncState) {
s.SetResourceInstanceCurrent(
addrs.Resource{
Mode: addrs.ManagedResourceMode,
Type: "test_instance",
Name: "a",
}.Instance(addrs.NoKey).Absolute(addrs.RootModuleInstance),
&states.ResourceInstanceObjectSrc{
AttrsJSON: []byte(`{"id":"hello"}`),
Status: states.ObjectReady,
},
addrs.AbsProviderConfig{
Provider: addrs.NewDefaultProvider("test"),
Module: addrs.RootModule,
},
)
})
statePath := testStateFile(t, originalState)
p := testProvider()
p.GetProviderSchemaResponse = &providers.GetProviderSchemaResponse{
ResourceTypes: map[string]providers.Schema{
"test_instance": {
Block: &configschema.Block{
Attributes: map[string]*configschema.Attribute{
"id": {Type: cty.String, Computed: true},
},
},
},
},
}
p.PlanResourceChangeFn = func(req providers.PlanResourceChangeRequest) providers.PlanResourceChangeResponse {
return providers.PlanResourceChangeResponse{
PlannedState: req.ProposedNewState,
}
}
view, done := testView(t)
c := &PlanCommand{
Meta: Meta{
testingOverrides: metaOverridesForProvider(p),
View: view,
},
}
args := []string{
"-state", statePath,
"-no-color",
"-replace", "test_instance.a",
}
code := c.Run(args)
output := done(t)
if code != 0 {
t.Fatalf("wrong exit code %d\n\n%s", code, output.Stderr())
}
stdout := output.Stdout()
if got, want := stdout, "1 to add, 0 to change, 1 to destroy"; !strings.Contains(got, want) {
t.Errorf("wrong plan summary\ngot output:\n%s\n\nwant substring: %s", got, want)
}
if got, want := stdout, "test_instance.a will be replaced, as requested"; !strings.Contains(got, want) {
t.Errorf("missing replace explanation\ngot output:\n%s\n\nwant substring: %s", got, want)
}
}
// Verify that the parallelism flag allows no more than the desired number of
// concurrent calls to PlanResourceChange.
func TestPlan_parallelism(t *testing.T) {
// Create a temporary working directory that is empty
td := tempDir(t)
testCopyDir(t, testFixturePath("parallelism"), td)
defer os.RemoveAll(td)
defer testChdir(t, td)()
par := 4
// started is a semaphore that we use to ensure that we never have more
// than "par" plan operations happening concurrently
started := make(chan struct{}, par)
// beginCtx is used as a starting gate to hold back PlanResourceChange
// calls until we reach the desired concurrency. The cancel func "begin" is
// called once we reach the desired concurrency, allowing all apply calls
// to proceed in unison.
beginCtx, begin := context.WithCancel(context.Background())
// Since our mock provider has its own mutex preventing concurrent calls
// to ApplyResourceChange, we need to use a number of separate providers
// here. They will all have the same mock implementation function assigned
// but crucially they will each have their own mutex.
providerFactories := map[addrs.Provider]providers.Factory{}
for i := 0; i < 10; i++ {
name := fmt.Sprintf("test%d", i)
provider := &terraform.MockProvider{}
provider.GetProviderSchemaResponse = &providers.GetProviderSchemaResponse{
ResourceTypes: map[string]providers.Schema{
name + "_instance": {Block: &configschema.Block{}},
},
}
provider.PlanResourceChangeFn = func(req providers.PlanResourceChangeRequest) providers.PlanResourceChangeResponse {
// If we ever have more than our intended parallelism number of
// plan operations running concurrently, the semaphore will fail.
select {
case started <- struct{}{}:
defer func() {
<-started
}()
default:
t.Fatal("too many concurrent apply operations")
}
// If we never reach our intended parallelism, the context will
// never be canceled and the test will time out.
if len(started) >= par {
begin()
}
<-beginCtx.Done()
// do some "work"
// Not required for correctness, but makes it easier to spot a
// failure when there is more overlap.
time.Sleep(10 * time.Millisecond)
return providers.PlanResourceChangeResponse{
PlannedState: req.ProposedNewState,
}
}
providerFactories[addrs.NewDefaultProvider(name)] = providers.FactoryFixed(provider)
}
testingOverrides := &testingOverrides{
Providers: providerFactories,
}
view, done := testView(t)
c := &PlanCommand{
Meta: Meta{
testingOverrides: testingOverrides,
View: view,
},
}
args := []string{
fmt.Sprintf("-parallelism=%d", par),
}
res := c.Run(args)
output := done(t)
if res != 0 {
t.Fatal(output.Stdout())
}
}
func TestPlan_warnings(t *testing.T) {
td := tempDir(t)
testCopyDir(t, testFixturePath("plan"), td)
defer os.RemoveAll(td)
defer testChdir(t, td)()
t.Run("full warnings", func(t *testing.T) {
p := planWarningsFixtureProvider()
view, done := testView(t)
c := &PlanCommand{
Meta: Meta{
testingOverrides: metaOverridesForProvider(p),
View: view,
},
}
code := c.Run([]string{})
output := done(t)
if code != 0 {
t.Fatalf("bad: %d\n\n%s", code, output.Stderr())
}
// the output should contain 3 warnings (returned by planWarningsFixtureProvider())
wantWarnings := []string{
"warning 1",
"warning 2",
"warning 3",
}
for _, want := range wantWarnings {
if !strings.Contains(output.Stdout(), want) {
t.Errorf("missing warning %s", want)
}
}
})
t.Run("compact warnings", func(t *testing.T) {
p := planWarningsFixtureProvider()
view, done := testView(t)
c := &PlanCommand{
Meta: Meta{
testingOverrides: metaOverridesForProvider(p),
View: view,
},
}
code := c.Run([]string{"-compact-warnings"})
output := done(t)
if code != 0 {
t.Fatalf("bad: %d\n\n%s", code, output.Stderr())
}
// the output should contain 3 warnings (returned by planWarningsFixtureProvider())
// and the message that plan was run with -compact-warnings
wantWarnings := []string{
"warning 1",
"warning 2",
"warning 3",
"To see the full warning notes, run Terraform without -compact-warnings.",
}
for _, want := range wantWarnings {
if !strings.Contains(output.Stdout(), want) {
t.Errorf("missing warning %s", want)
}
}
})
}
// planFixtureSchema returns a schema suitable for processing the
// configuration in testdata/plan . This schema should be
// assigned to a mock provider named "test".
func planFixtureSchema() *providers.GetProviderSchemaResponse {
return &providers.GetProviderSchemaResponse{
2021-01-12 22:13:10 +01:00
ResourceTypes: map[string]providers.Schema{
"test_instance": {
2021-01-12 22:13:10 +01:00
Block: &configschema.Block{
Attributes: map[string]*configschema.Attribute{
"id": {Type: cty.String, Optional: true, Computed: true},
"ami": {Type: cty.String, Optional: true},
},
BlockTypes: map[string]*configschema.NestedBlock{
"network_interface": {
Nesting: configschema.NestingList,
Block: configschema.Block{
Attributes: map[string]*configschema.Attribute{
"device_index": {Type: cty.String, Optional: true},
"description": {Type: cty.String, Optional: true},
},
},
},
},
},
},
},
}
}
// planFixtureProvider returns a mock provider that is configured for basic
// operation with the configuration in testdata/plan. This mock has
2021-01-12 22:13:10 +01:00
// GetSchemaResponse and PlanResourceChangeFn populated, with the plan
// step just passing through the new object proposed by Terraform Core.
func planFixtureProvider() *terraform.MockProvider {
p := testProvider()
p.GetProviderSchemaResponse = planFixtureSchema()
p.PlanResourceChangeFn = func(req providers.PlanResourceChangeRequest) providers.PlanResourceChangeResponse {
return providers.PlanResourceChangeResponse{
PlannedState: req.ProposedNewState,
}
}
return p
}
// planVarsFixtureSchema returns a schema suitable for processing the
// configuration in testdata/plan-vars . This schema should be
// assigned to a mock provider named "test".
func planVarsFixtureSchema() *providers.GetProviderSchemaResponse {
return &providers.GetProviderSchemaResponse{
2021-01-12 22:13:10 +01:00
ResourceTypes: map[string]providers.Schema{
"test_instance": {
2021-01-12 22:13:10 +01:00
Block: &configschema.Block{
Attributes: map[string]*configschema.Attribute{
"id": {Type: cty.String, Optional: true, Computed: true},
"value": {Type: cty.String, Optional: true},
},
},
},
},
}
}
// planVarsFixtureProvider returns a mock provider that is configured for basic
// operation with the configuration in testdata/plan-vars. This mock has
2021-01-12 22:13:10 +01:00
// GetSchemaResponse and PlanResourceChangeFn populated, with the plan
// step just passing through the new object proposed by Terraform Core.
func planVarsFixtureProvider() *terraform.MockProvider {
p := testProvider()
p.GetProviderSchemaResponse = planVarsFixtureSchema()
p.PlanResourceChangeFn = func(req providers.PlanResourceChangeRequest) providers.PlanResourceChangeResponse {
return providers.PlanResourceChangeResponse{
PlannedState: req.ProposedNewState,
}
}
return p
}
// planFixtureProvider returns a mock provider that is configured for basic
// operation with the configuration in testdata/plan. This mock has
// GetSchemaResponse and PlanResourceChangeFn populated, returning 3 warnings.
func planWarningsFixtureProvider() *terraform.MockProvider {
p := testProvider()
p.GetProviderSchemaResponse = planFixtureSchema()
p.PlanResourceChangeFn = func(req providers.PlanResourceChangeRequest) providers.PlanResourceChangeResponse {
return providers.PlanResourceChangeResponse{
Diagnostics: tfdiags.Diagnostics{
tfdiags.SimpleWarning("warning 1"),
tfdiags.SimpleWarning("warning 2"),
tfdiags.SimpleWarning("warning 3"),
},
PlannedState: req.ProposedNewState,
}
}
return p
}
2014-07-18 23:00:40 +02:00
const planVarFile = `
foo = "bar"
`
2014-09-18 19:40:23 +02:00
const planVarFileWithDecl = `
foo = "bar"
variable "nope" {
}
`