plans/objchange: AssertPlanValid function
Completing our set of provider result safety-check functions, AssertPlanValid checks a result from a provider's PlanResourceChange to make sure it doesn't propose a change that is not valid within the user model of Terraform. Specifically, it forbids the provider from planning a value that contradicts what the user gave in configuration, which is important to ensure that making a reference to an attribute elsewhere in the configuration will produce exactly the given result, as users reasonably expect. Providers _are_ allowed (and, in fact, required) to make changes to any Computed attribute values declared in the schema in order to fill in the default values that the provider has generated. Later checks during the apply phase will ensure that the provider remains true to these planned values, to ensure that Terraform can keep its promise of doing exactly what was planned or presenting an error explaining why not.
This commit is contained in:
Martin Atkins
parent
5f8916b4fd
commit
fec6e0328d
|
|
@ -0,0 +1,259 @@
|
|||
package objchange
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
|
||||
"github.com/zclconf/go-cty/cty"
|
||||
|
||||
"github.com/hashicorp/terraform/configs/configschema"
|
||||
)
|
||||
|
||||
// AssertPlanValid checks checks whether a planned new state returned by a
|
||||
// provider's PlanResourceChange method is suitable to achieve a change
|
||||
// from priorState to config. It returns a slice with nonzero length if
|
||||
// any problems are detected. Because problems here indicate bugs in the
|
||||
// provider that generated the plannedState, they are written with provider
|
||||
// developers as an audience, rather than end-users.
|
||||
//
|
||||
// All of the given values must have the same type and must conform to the
|
||||
// implied type of the given schema, or this function may panic or produce
|
||||
// garbage results.
|
||||
//
|
||||
// During planning, a provider may only make changes to attributes that are
|
||||
// null (unset) in the configuration and are marked as "computed" in the
|
||||
// resource type schema, in order to insert any default values the provider
|
||||
// may know about. If the default value cannot be determined until apply time,
|
||||
// the provider can return an unknown value. Providers are forbidden from
|
||||
// planning a change that disagrees with any non-null argument in the
|
||||
// configuration.
|
||||
//
|
||||
// As a special exception, providers _are_ allowed to provide attribute values
|
||||
// conflicting with configuration if and only if the planned value exactly
|
||||
// matches the corresponding attribute value in the prior state. The provider
|
||||
// can use this to signal that the new value is functionally equivalent to
|
||||
// the old and thus no change is required.
|
||||
func AssertPlanValid(schema *configschema.Block, priorState, config, plannedState cty.Value) []error {
|
||||
return assertPlanValid(schema, priorState, config, plannedState, nil)
|
||||
}
|
||||
|
||||
func assertPlanValid(schema *configschema.Block, priorState, config, plannedState cty.Value, path cty.Path) []error {
|
||||
var errs []error
|
||||
if plannedState.IsNull() && !config.IsNull() {
|
||||
errs = append(errs, path.NewErrorf("planned for absense but config wants existence"))
|
||||
return errs
|
||||
}
|
||||
if config.IsNull() && !plannedState.IsNull() {
|
||||
errs = append(errs, path.NewErrorf("planned for existence but config wants absense"))
|
||||
return errs
|
||||
}
|
||||
if plannedState.IsNull() {
|
||||
// No further checks possible if the planned value is null
|
||||
return errs
|
||||
}
|
||||
|
||||
impTy := schema.ImpliedType()
|
||||
|
||||
for name, attrS := range schema.Attributes {
|
||||
plannedV := plannedState.GetAttr(name)
|
||||
configV := config.GetAttr(name)
|
||||
priorV := cty.NullVal(attrS.Type)
|
||||
if !priorState.IsNull() {
|
||||
priorV = priorState.GetAttr(name)
|
||||
}
|
||||
|
||||
path := append(path, cty.GetAttrStep{Name: name})
|
||||
moreErrs := assertPlannedValueValid(attrS, priorV, configV, plannedV, path)
|
||||
errs = append(errs, moreErrs...)
|
||||
}
|
||||
for name, blockS := range schema.BlockTypes {
|
||||
path := append(path, cty.GetAttrStep{Name: name})
|
||||
plannedV := plannedState.GetAttr(name)
|
||||
configV := config.GetAttr(name)
|
||||
priorV := cty.NullVal(impTy.AttributeType(name))
|
||||
if !priorState.IsNull() {
|
||||
priorV = priorState.GetAttr(name)
|
||||
}
|
||||
if plannedV.RawEquals(configV) {
|
||||
// Easy path: nothing has changed at all
|
||||
continue
|
||||
}
|
||||
if !plannedV.IsKnown() {
|
||||
errs = append(errs, path.NewErrorf("attribute representing nested block must not be unknown itself; set nested attribute values to unknown instead"))
|
||||
continue
|
||||
}
|
||||
|
||||
switch blockS.Nesting {
|
||||
case configschema.NestingSingle:
|
||||
moreErrs := assertPlanValid(&blockS.Block, priorV, configV, plannedV, path)
|
||||
errs = append(errs, moreErrs...)
|
||||
case configschema.NestingList:
|
||||
// A NestingList might either be a list or a tuple, depending on
|
||||
// whether there are dynamically-typed attributes inside. However,
|
||||
// both support a similar-enough API that we can treat them the
|
||||
// same for our purposes here.
|
||||
if plannedV.IsNull() {
|
||||
errs = append(errs, path.NewErrorf("attribute representing a list of nested blocks must be empty to indicate no blocks, not null"))
|
||||
continue
|
||||
}
|
||||
|
||||
plannedL := plannedV.LengthInt()
|
||||
configL := configV.LengthInt()
|
||||
if plannedL != configL {
|
||||
errs = append(errs, path.NewErrorf("block count in plan (%d) disagrees with count in config (%d)", plannedL, configL))
|
||||
continue
|
||||
}
|
||||
for it := plannedV.ElementIterator(); it.Next(); {
|
||||
idx, plannedEV := it.Element()
|
||||
path := append(path, cty.IndexStep{Key: idx})
|
||||
if !plannedEV.IsKnown() {
|
||||
errs = append(errs, path.NewErrorf("element representing nested block must not be unknown itself; set nested attribute values to unknown instead"))
|
||||
continue
|
||||
}
|
||||
if !configV.HasIndex(idx).True() {
|
||||
continue // should never happen since we checked the lengths above
|
||||
}
|
||||
configEV := configV.Index(idx)
|
||||
priorEV := cty.NullVal(blockS.ImpliedType())
|
||||
if !priorV.IsNull() && priorV.HasIndex(idx).True() {
|
||||
priorEV = priorV.Index(idx)
|
||||
}
|
||||
|
||||
moreErrs := assertPlanValid(&blockS.Block, priorEV, configEV, plannedEV, path)
|
||||
errs = append(errs, moreErrs...)
|
||||
}
|
||||
case configschema.NestingMap:
|
||||
if plannedV.IsNull() {
|
||||
errs = append(errs, path.NewErrorf("attribute representing a map of nested blocks must be empty to indicate no blocks, not null"))
|
||||
continue
|
||||
}
|
||||
|
||||
// A NestingMap might either be a map or an object, depending on
|
||||
// whether there are dynamically-typed attributes inside, but
|
||||
// that's decided statically and so all values will have the same
|
||||
// kind.
|
||||
if plannedV.Type().IsObjectType() {
|
||||
plannedAtys := plannedV.Type().AttributeTypes()
|
||||
configAtys := configV.Type().AttributeTypes()
|
||||
for k := range plannedAtys {
|
||||
if _, ok := configAtys[k]; !ok {
|
||||
errs = append(errs, path.NewErrorf("block key %q from plan is not present in config", k))
|
||||
continue
|
||||
}
|
||||
path := append(path, cty.GetAttrStep{Name: k})
|
||||
|
||||
plannedEV := plannedV.GetAttr(k)
|
||||
if !plannedEV.IsKnown() {
|
||||
errs = append(errs, path.NewErrorf("element representing nested block must not be unknown itself; set nested attribute values to unknown instead"))
|
||||
continue
|
||||
}
|
||||
configEV := configV.GetAttr(k)
|
||||
priorEV := cty.NullVal(blockS.ImpliedType())
|
||||
if !priorV.IsNull() && priorV.Type().HasAttribute(k) {
|
||||
priorEV = priorV.GetAttr(k)
|
||||
}
|
||||
moreErrs := assertPlanValid(&blockS.Block, priorEV, configEV, plannedEV, path)
|
||||
errs = append(errs, moreErrs...)
|
||||
}
|
||||
for k := range configAtys {
|
||||
if _, ok := plannedAtys[k]; !ok {
|
||||
errs = append(errs, path.NewErrorf("block key %q from config is not present in plan", k))
|
||||
continue
|
||||
}
|
||||
}
|
||||
} else {
|
||||
plannedL := plannedV.LengthInt()
|
||||
configL := configV.LengthInt()
|
||||
if plannedL != configL {
|
||||
errs = append(errs, path.NewErrorf("block count in plan (%d) disagrees with count in config (%d)", plannedL, configL))
|
||||
continue
|
||||
}
|
||||
for it := plannedV.ElementIterator(); it.Next(); {
|
||||
idx, plannedEV := it.Element()
|
||||
path := append(path, cty.IndexStep{Key: idx})
|
||||
if !plannedEV.IsKnown() {
|
||||
errs = append(errs, path.NewErrorf("element representing nested block must not be unknown itself; set nested attribute values to unknown instead"))
|
||||
continue
|
||||
}
|
||||
k := idx.AsString()
|
||||
if !configV.HasIndex(idx).True() {
|
||||
errs = append(errs, path.NewErrorf("block key %q from plan is not present in config", k))
|
||||
continue
|
||||
}
|
||||
configEV := configV.Index(idx)
|
||||
priorEV := cty.NullVal(blockS.ImpliedType())
|
||||
if !priorV.IsNull() && priorV.HasIndex(idx).True() {
|
||||
priorEV = priorV.GetAttr(k)
|
||||
}
|
||||
moreErrs := assertPlanValid(&blockS.Block, priorEV, configEV, plannedEV, path)
|
||||
errs = append(errs, moreErrs...)
|
||||
}
|
||||
for it := configV.ElementIterator(); it.Next(); {
|
||||
idx, _ := it.Element()
|
||||
if !plannedV.HasIndex(idx).True() {
|
||||
errs = append(errs, path.NewErrorf("block key %q from config is not present in plan", idx.AsString()))
|
||||
continue
|
||||
}
|
||||
}
|
||||
}
|
||||
case configschema.NestingSet:
|
||||
if plannedV.IsNull() {
|
||||
errs = append(errs, path.NewErrorf("attribute representing a set of nested blocks must be empty to indicate no blocks, not null"))
|
||||
continue
|
||||
}
|
||||
|
||||
// Because set elements have no identifier with which to correlate
|
||||
// them, we can't robustly validate the plan for a nested block
|
||||
// backed by a set, and so unfortunately we need to just trust the
|
||||
// provider to do the right thing. :(
|
||||
//
|
||||
// (In principle we could correlate elements by matching the
|
||||
// subset of attributes explicitly set in config, except for the
|
||||
// special diff suppression rule which allows for there to be a
|
||||
// planned value that is constructed by mixing part of a prior
|
||||
// value with part of a config value, creating an entirely new
|
||||
// element that is not present in either prior nor config.)
|
||||
for it := plannedV.ElementIterator(); it.Next(); {
|
||||
idx, plannedEV := it.Element()
|
||||
path := append(path, cty.IndexStep{Key: idx})
|
||||
if !plannedEV.IsKnown() {
|
||||
errs = append(errs, path.NewErrorf("element representing nested block must not be unknown itself; set nested attribute values to unknown instead"))
|
||||
continue
|
||||
}
|
||||
}
|
||||
|
||||
default:
|
||||
panic(fmt.Sprintf("unsupported nesting mode %s", blockS.Nesting))
|
||||
}
|
||||
}
|
||||
|
||||
return errs
|
||||
}
|
||||
|
||||
func assertPlannedValueValid(attrS *configschema.Attribute, priorV, configV, plannedV cty.Value, path cty.Path) []error {
|
||||
var errs []error
|
||||
if plannedV.RawEquals(configV) {
|
||||
// This is the easy path: provider didn't change anything at all.
|
||||
return errs
|
||||
}
|
||||
if plannedV.RawEquals(priorV) && !priorV.IsNull() {
|
||||
// Also pretty easy: there is a prior value and the provider has
|
||||
// returned it unchanged. This indicates that configV and plannedV
|
||||
// are functionally equivalent and so the provider wishes to disregard
|
||||
// the configuration value in favor of the prior.
|
||||
return errs
|
||||
}
|
||||
if attrS.Computed && configV.IsNull() {
|
||||
// The provider is allowed to change the value of any computed
|
||||
// attribute that isn't explicitly set in the config.
|
||||
return errs
|
||||
}
|
||||
|
||||
// If none of the above conditions match, the provider has made an invalid
|
||||
// change to this attribute.
|
||||
if priorV.IsNull() {
|
||||
errs = append(errs, path.NewErrorf("planned value %#v does not match config value %#v", plannedV, configV))
|
||||
return errs
|
||||
}
|
||||
errs = append(errs, path.NewErrorf("planned value %#v does not match config value %#v nor prior value %#v", plannedV, configV, priorV))
|
||||
return errs
|
||||
}
|
||||
|
|
@ -0,0 +1,527 @@
|
|||
package objchange
|
||||
|
||||
import (
|
||||
"testing"
|
||||
|
||||
"github.com/apparentlymart/go-dump/dump"
|
||||
"github.com/zclconf/go-cty/cty"
|
||||
|
||||
"github.com/hashicorp/terraform/configs/configschema"
|
||||
"github.com/hashicorp/terraform/tfdiags"
|
||||
)
|
||||
|
||||
func TestAssertPlanValid(t *testing.T) {
|
||||
tests := map[string]struct {
|
||||
Schema *configschema.Block
|
||||
Prior cty.Value
|
||||
Config cty.Value
|
||||
Planned cty.Value
|
||||
WantErrs []string
|
||||
}{
|
||||
"all empty": {
|
||||
&configschema.Block{},
|
||||
cty.EmptyObjectVal,
|
||||
cty.EmptyObjectVal,
|
||||
cty.EmptyObjectVal,
|
||||
nil,
|
||||
},
|
||||
"no computed, all match": {
|
||||
&configschema.Block{
|
||||
Attributes: map[string]*configschema.Attribute{
|
||||
"a": {
|
||||
Type: cty.String,
|
||||
Optional: true,
|
||||
},
|
||||
},
|
||||
BlockTypes: map[string]*configschema.NestedBlock{
|
||||
"b": {
|
||||
Nesting: configschema.NestingList,
|
||||
Block: configschema.Block{
|
||||
Attributes: map[string]*configschema.Attribute{
|
||||
"c": {
|
||||
Type: cty.String,
|
||||
Optional: true,
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"a": cty.StringVal("a value"),
|
||||
"b": cty.ListVal([]cty.Value{
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"c": cty.StringVal("c value"),
|
||||
}),
|
||||
}),
|
||||
}),
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"a": cty.StringVal("a value"),
|
||||
"b": cty.ListVal([]cty.Value{
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"c": cty.StringVal("c value"),
|
||||
}),
|
||||
}),
|
||||
}),
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"a": cty.StringVal("a value"),
|
||||
"b": cty.ListVal([]cty.Value{
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"c": cty.StringVal("c value"),
|
||||
}),
|
||||
}),
|
||||
}),
|
||||
nil,
|
||||
},
|
||||
"no computed, plan matches, no prior": {
|
||||
&configschema.Block{
|
||||
Attributes: map[string]*configschema.Attribute{
|
||||
"a": {
|
||||
Type: cty.String,
|
||||
Optional: true,
|
||||
},
|
||||
},
|
||||
BlockTypes: map[string]*configschema.NestedBlock{
|
||||
"b": {
|
||||
Nesting: configschema.NestingList,
|
||||
Block: configschema.Block{
|
||||
Attributes: map[string]*configschema.Attribute{
|
||||
"c": {
|
||||
Type: cty.String,
|
||||
Optional: true,
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
cty.NullVal(cty.Object(map[string]cty.Type{
|
||||
"a": cty.String,
|
||||
"b": cty.List(cty.Object(map[string]cty.Type{
|
||||
"c": cty.String,
|
||||
})),
|
||||
})),
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"a": cty.StringVal("a value"),
|
||||
"b": cty.ListVal([]cty.Value{
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"c": cty.StringVal("c value"),
|
||||
}),
|
||||
}),
|
||||
}),
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"a": cty.StringVal("a value"),
|
||||
"b": cty.ListVal([]cty.Value{
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"c": cty.StringVal("c value"),
|
||||
}),
|
||||
}),
|
||||
}),
|
||||
nil,
|
||||
},
|
||||
"no computed, invalid change in plan": {
|
||||
&configschema.Block{
|
||||
Attributes: map[string]*configschema.Attribute{
|
||||
"a": {
|
||||
Type: cty.String,
|
||||
Optional: true,
|
||||
},
|
||||
},
|
||||
BlockTypes: map[string]*configschema.NestedBlock{
|
||||
"b": {
|
||||
Nesting: configschema.NestingList,
|
||||
Block: configschema.Block{
|
||||
Attributes: map[string]*configschema.Attribute{
|
||||
"c": {
|
||||
Type: cty.String,
|
||||
Optional: true,
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
cty.NullVal(cty.Object(map[string]cty.Type{
|
||||
"a": cty.String,
|
||||
"b": cty.List(cty.Object(map[string]cty.Type{
|
||||
"c": cty.String,
|
||||
})),
|
||||
})),
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"a": cty.StringVal("a value"),
|
||||
"b": cty.ListVal([]cty.Value{
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"c": cty.StringVal("c value"),
|
||||
}),
|
||||
}),
|
||||
}),
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"a": cty.StringVal("a value"),
|
||||
"b": cty.ListVal([]cty.Value{
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"c": cty.StringVal("new c value"),
|
||||
}),
|
||||
}),
|
||||
}),
|
||||
[]string{
|
||||
`.b[0].c: planned value cty.StringVal("new c value") does not match config value cty.StringVal("c value")`,
|
||||
},
|
||||
},
|
||||
"no computed, diff suppression in plan": {
|
||||
&configschema.Block{
|
||||
Attributes: map[string]*configschema.Attribute{
|
||||
"a": {
|
||||
Type: cty.String,
|
||||
Optional: true,
|
||||
},
|
||||
},
|
||||
BlockTypes: map[string]*configschema.NestedBlock{
|
||||
"b": {
|
||||
Nesting: configschema.NestingList,
|
||||
Block: configschema.Block{
|
||||
Attributes: map[string]*configschema.Attribute{
|
||||
"c": {
|
||||
Type: cty.String,
|
||||
Optional: true,
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"a": cty.StringVal("a value"),
|
||||
"b": cty.ListVal([]cty.Value{
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"c": cty.StringVal("c value"),
|
||||
}),
|
||||
}),
|
||||
}),
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"a": cty.StringVal("a value"),
|
||||
"b": cty.ListVal([]cty.Value{
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"c": cty.StringVal("new c value"),
|
||||
}),
|
||||
}),
|
||||
}),
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"a": cty.StringVal("a value"),
|
||||
"b": cty.ListVal([]cty.Value{
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"c": cty.StringVal("c value"), // plan uses value from prior object
|
||||
}),
|
||||
}),
|
||||
}),
|
||||
nil,
|
||||
},
|
||||
"no computed, all null": {
|
||||
&configschema.Block{
|
||||
Attributes: map[string]*configschema.Attribute{
|
||||
"a": {
|
||||
Type: cty.String,
|
||||
Optional: true,
|
||||
},
|
||||
},
|
||||
BlockTypes: map[string]*configschema.NestedBlock{
|
||||
"b": {
|
||||
Nesting: configschema.NestingList,
|
||||
Block: configschema.Block{
|
||||
Attributes: map[string]*configschema.Attribute{
|
||||
"c": {
|
||||
Type: cty.String,
|
||||
Optional: true,
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"a": cty.NullVal(cty.String),
|
||||
"b": cty.ListVal([]cty.Value{
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"c": cty.NullVal(cty.String),
|
||||
}),
|
||||
}),
|
||||
}),
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"a": cty.NullVal(cty.String),
|
||||
"b": cty.ListVal([]cty.Value{
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"c": cty.NullVal(cty.String),
|
||||
}),
|
||||
}),
|
||||
}),
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"a": cty.NullVal(cty.String),
|
||||
"b": cty.ListVal([]cty.Value{
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"c": cty.NullVal(cty.String),
|
||||
}),
|
||||
}),
|
||||
}),
|
||||
nil,
|
||||
},
|
||||
|
||||
// Nested block collections are never null
|
||||
"nested list, null in plan": {
|
||||
&configschema.Block{
|
||||
BlockTypes: map[string]*configschema.NestedBlock{
|
||||
"b": {
|
||||
Nesting: configschema.NestingList,
|
||||
Block: configschema.Block{
|
||||
Attributes: map[string]*configschema.Attribute{
|
||||
"c": {
|
||||
Type: cty.String,
|
||||
Optional: true,
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
cty.NullVal(cty.Object(map[string]cty.Type{
|
||||
"b": cty.List(cty.Object(map[string]cty.Type{
|
||||
"c": cty.String,
|
||||
})),
|
||||
})),
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"b": cty.ListValEmpty(cty.Object(map[string]cty.Type{
|
||||
"c": cty.String,
|
||||
})),
|
||||
}),
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"b": cty.NullVal(cty.List(cty.Object(map[string]cty.Type{
|
||||
"c": cty.String,
|
||||
}))),
|
||||
}),
|
||||
[]string{
|
||||
`.b: attribute representing a list of nested blocks must be empty to indicate no blocks, not null`,
|
||||
},
|
||||
},
|
||||
"nested set, null in plan": {
|
||||
&configschema.Block{
|
||||
BlockTypes: map[string]*configschema.NestedBlock{
|
||||
"b": {
|
||||
Nesting: configschema.NestingSet,
|
||||
Block: configschema.Block{
|
||||
Attributes: map[string]*configschema.Attribute{
|
||||
"c": {
|
||||
Type: cty.String,
|
||||
Optional: true,
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
cty.NullVal(cty.Object(map[string]cty.Type{
|
||||
"b": cty.Set(cty.Object(map[string]cty.Type{
|
||||
"c": cty.String,
|
||||
})),
|
||||
})),
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"b": cty.SetValEmpty(cty.Object(map[string]cty.Type{
|
||||
"c": cty.String,
|
||||
})),
|
||||
}),
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"b": cty.NullVal(cty.Set(cty.Object(map[string]cty.Type{
|
||||
"c": cty.String,
|
||||
}))),
|
||||
}),
|
||||
[]string{
|
||||
`.b: attribute representing a set of nested blocks must be empty to indicate no blocks, not null`,
|
||||
},
|
||||
},
|
||||
"nested map, null in plan": {
|
||||
&configschema.Block{
|
||||
BlockTypes: map[string]*configschema.NestedBlock{
|
||||
"b": {
|
||||
Nesting: configschema.NestingMap,
|
||||
Block: configschema.Block{
|
||||
Attributes: map[string]*configschema.Attribute{
|
||||
"c": {
|
||||
Type: cty.String,
|
||||
Optional: true,
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
cty.NullVal(cty.Object(map[string]cty.Type{
|
||||
"b": cty.Map(cty.Object(map[string]cty.Type{
|
||||
"c": cty.String,
|
||||
})),
|
||||
})),
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"b": cty.MapValEmpty(cty.Object(map[string]cty.Type{
|
||||
"c": cty.String,
|
||||
})),
|
||||
}),
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"b": cty.NullVal(cty.Map(cty.Object(map[string]cty.Type{
|
||||
"c": cty.String,
|
||||
}))),
|
||||
}),
|
||||
[]string{
|
||||
`.b: attribute representing a map of nested blocks must be empty to indicate no blocks, not null`,
|
||||
},
|
||||
},
|
||||
|
||||
// We don't actually do any validation for nested set blocks, and so
|
||||
// the remaining cases here are just intending to ensure we don't
|
||||
// inadvertently start generating errors incorrectly in future.
|
||||
"nested set, no computed, no changes": {
|
||||
&configschema.Block{
|
||||
BlockTypes: map[string]*configschema.NestedBlock{
|
||||
"b": {
|
||||
Nesting: configschema.NestingSet,
|
||||
Block: configschema.Block{
|
||||
Attributes: map[string]*configschema.Attribute{
|
||||
"c": {
|
||||
Type: cty.String,
|
||||
Optional: true,
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"b": cty.SetVal([]cty.Value{
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"c": cty.StringVal("c value"),
|
||||
}),
|
||||
}),
|
||||
}),
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"b": cty.SetVal([]cty.Value{
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"c": cty.StringVal("c value"),
|
||||
}),
|
||||
}),
|
||||
}),
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"b": cty.SetVal([]cty.Value{
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"c": cty.StringVal("c value"),
|
||||
}),
|
||||
}),
|
||||
}),
|
||||
nil,
|
||||
},
|
||||
"nested set, no computed, invalid change in plan": {
|
||||
&configschema.Block{
|
||||
BlockTypes: map[string]*configschema.NestedBlock{
|
||||
"b": {
|
||||
Nesting: configschema.NestingSet,
|
||||
Block: configschema.Block{
|
||||
Attributes: map[string]*configschema.Attribute{
|
||||
"c": {
|
||||
Type: cty.String,
|
||||
Optional: true,
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"b": cty.SetVal([]cty.Value{
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"c": cty.StringVal("c value"),
|
||||
}),
|
||||
}),
|
||||
}),
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"b": cty.SetVal([]cty.Value{
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"c": cty.StringVal("c value"),
|
||||
}),
|
||||
}),
|
||||
}),
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"b": cty.SetVal([]cty.Value{
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"c": cty.StringVal("new c value"), // matches neither prior nor config
|
||||
}),
|
||||
}),
|
||||
}),
|
||||
nil,
|
||||
},
|
||||
"nested set, no computed, diff suppressed": {
|
||||
&configschema.Block{
|
||||
BlockTypes: map[string]*configschema.NestedBlock{
|
||||
"b": {
|
||||
Nesting: configschema.NestingSet,
|
||||
Block: configschema.Block{
|
||||
Attributes: map[string]*configschema.Attribute{
|
||||
"c": {
|
||||
Type: cty.String,
|
||||
Optional: true,
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"b": cty.SetVal([]cty.Value{
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"c": cty.StringVal("c value"),
|
||||
}),
|
||||
}),
|
||||
}),
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"b": cty.SetVal([]cty.Value{
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"c": cty.StringVal("new c value"),
|
||||
}),
|
||||
}),
|
||||
}),
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"b": cty.SetVal([]cty.Value{
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"c": cty.StringVal("c value"), // plan uses value from prior object
|
||||
}),
|
||||
}),
|
||||
}),
|
||||
nil,
|
||||
},
|
||||
}
|
||||
|
||||
for name, test := range tests {
|
||||
t.Run(name, func(t *testing.T) {
|
||||
errs := AssertPlanValid(test.Schema, test.Prior, test.Config, test.Planned)
|
||||
|
||||
wantErrs := make(map[string]struct{})
|
||||
gotErrs := make(map[string]struct{})
|
||||
for _, err := range errs {
|
||||
gotErrs[tfdiags.FormatError(err)] = struct{}{}
|
||||
}
|
||||
for _, msg := range test.WantErrs {
|
||||
wantErrs[msg] = struct{}{}
|
||||
}
|
||||
|
||||
t.Logf(
|
||||
"\nprior: %sconfig: %splanned: %s",
|
||||
dump.Value(test.Planned),
|
||||
dump.Value(test.Config),
|
||||
dump.Value(test.Planned),
|
||||
)
|
||||
for msg := range wantErrs {
|
||||
if _, ok := gotErrs[msg]; !ok {
|
||||
t.Errorf("missing expected error: %s", msg)
|
||||
}
|
||||
}
|
||||
for msg := range gotErrs {
|
||||
if _, ok := wantErrs[msg]; !ok {
|
||||
t.Errorf("unexpected extra error: %s", msg)
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue