terraform/internal/configs/configschema/decoder_spec_test.go

930 lines
22 KiB
Go

package configschema
import (
"sort"
"testing"
"github.com/apparentlymart/go-dump/dump"
"github.com/davecgh/go-spew/spew"
"github.com/google/go-cmp/cmp"
"github.com/hashicorp/hcl/v2"
"github.com/hashicorp/hcl/v2/hcldec"
"github.com/hashicorp/hcl/v2/hcltest"
"github.com/zclconf/go-cty/cty"
)
func TestBlockDecoderSpec(t *testing.T) {
tests := map[string]struct {
Schema *Block
TestBody hcl.Body
Want cty.Value
DiagCount int
}{
"empty": {
&Block{},
hcl.EmptyBody(),
cty.EmptyObjectVal,
0,
},
"nil": {
nil,
hcl.EmptyBody(),
cty.EmptyObjectVal,
0,
},
"attributes": {
&Block{
Attributes: map[string]*Attribute{
"optional": {
Type: cty.Number,
Optional: true,
},
"required": {
Type: cty.String,
Required: true,
},
"computed": {
Type: cty.List(cty.Bool),
Computed: true,
},
"optional_computed": {
Type: cty.Map(cty.Bool),
Optional: true,
Computed: true,
},
"optional_computed_overridden": {
Type: cty.Bool,
Optional: true,
Computed: true,
},
"optional_computed_unknown": {
Type: cty.String,
Optional: true,
Computed: true,
},
},
},
hcltest.MockBody(&hcl.BodyContent{
Attributes: hcl.Attributes{
"required": {
Name: "required",
Expr: hcltest.MockExprLiteral(cty.NumberIntVal(5)),
},
"optional_computed_overridden": {
Name: "optional_computed_overridden",
Expr: hcltest.MockExprLiteral(cty.True),
},
"optional_computed_unknown": {
Name: "optional_computed_overridden",
Expr: hcltest.MockExprLiteral(cty.UnknownVal(cty.String)),
},
},
}),
cty.ObjectVal(map[string]cty.Value{
"optional": cty.NullVal(cty.Number),
"required": cty.StringVal("5"), // converted from number to string
"computed": cty.NullVal(cty.List(cty.Bool)),
"optional_computed": cty.NullVal(cty.Map(cty.Bool)),
"optional_computed_overridden": cty.True,
"optional_computed_unknown": cty.UnknownVal(cty.String),
}),
0,
},
"dynamically-typed attribute": {
&Block{
Attributes: map[string]*Attribute{
"foo": {
Type: cty.DynamicPseudoType, // any type is permitted
Required: true,
},
},
},
hcltest.MockBody(&hcl.BodyContent{
Attributes: hcl.Attributes{
"foo": {
Name: "foo",
Expr: hcltest.MockExprLiteral(cty.True),
},
},
}),
cty.ObjectVal(map[string]cty.Value{
"foo": cty.True,
}),
0,
},
"dynamically-typed attribute omitted": {
&Block{
Attributes: map[string]*Attribute{
"foo": {
Type: cty.DynamicPseudoType, // any type is permitted
Optional: true,
},
},
},
hcltest.MockBody(&hcl.BodyContent{}),
cty.ObjectVal(map[string]cty.Value{
"foo": cty.NullVal(cty.DynamicPseudoType),
}),
0,
},
"required attribute omitted": {
&Block{
Attributes: map[string]*Attribute{
"foo": {
Type: cty.Bool,
Required: true,
},
},
},
hcltest.MockBody(&hcl.BodyContent{}),
cty.ObjectVal(map[string]cty.Value{
"foo": cty.NullVal(cty.Bool),
}),
1, // missing required attribute
},
"wrong attribute type": {
&Block{
Attributes: map[string]*Attribute{
"optional": {
Type: cty.Number,
Optional: true,
},
},
},
hcltest.MockBody(&hcl.BodyContent{
Attributes: hcl.Attributes{
"optional": {
Name: "optional",
Expr: hcltest.MockExprLiteral(cty.True),
},
},
}),
cty.ObjectVal(map[string]cty.Value{
"optional": cty.UnknownVal(cty.Number),
}),
1, // incorrect type; number required
},
"blocks": {
&Block{
BlockTypes: map[string]*NestedBlock{
"single": {
Nesting: NestingSingle,
Block: Block{},
},
"list": {
Nesting: NestingList,
Block: Block{},
},
"set": {
Nesting: NestingSet,
Block: Block{},
},
"map": {
Nesting: NestingMap,
Block: Block{},
},
},
},
hcltest.MockBody(&hcl.BodyContent{
Blocks: hcl.Blocks{
&hcl.Block{
Type: "list",
Body: hcl.EmptyBody(),
},
&hcl.Block{
Type: "single",
Body: hcl.EmptyBody(),
},
&hcl.Block{
Type: "list",
Body: hcl.EmptyBody(),
},
&hcl.Block{
Type: "set",
Body: hcl.EmptyBody(),
},
&hcl.Block{
Type: "map",
Labels: []string{"foo"},
LabelRanges: []hcl.Range{hcl.Range{}},
Body: hcl.EmptyBody(),
},
&hcl.Block{
Type: "map",
Labels: []string{"bar"},
LabelRanges: []hcl.Range{hcl.Range{}},
Body: hcl.EmptyBody(),
},
&hcl.Block{
Type: "set",
Body: hcl.EmptyBody(),
},
},
}),
cty.ObjectVal(map[string]cty.Value{
"single": cty.EmptyObjectVal,
"list": cty.ListVal([]cty.Value{
cty.EmptyObjectVal,
cty.EmptyObjectVal,
}),
"set": cty.SetVal([]cty.Value{
cty.EmptyObjectVal,
cty.EmptyObjectVal,
}),
"map": cty.MapVal(map[string]cty.Value{
"foo": cty.EmptyObjectVal,
"bar": cty.EmptyObjectVal,
}),
}),
0,
},
"blocks with dynamically-typed attributes": {
&Block{
BlockTypes: map[string]*NestedBlock{
"single": {
Nesting: NestingSingle,
Block: Block{
Attributes: map[string]*Attribute{
"a": {
Type: cty.DynamicPseudoType,
Optional: true,
},
},
},
},
"list": {
Nesting: NestingList,
Block: Block{
Attributes: map[string]*Attribute{
"a": {
Type: cty.DynamicPseudoType,
Optional: true,
},
},
},
},
"map": {
Nesting: NestingMap,
Block: Block{
Attributes: map[string]*Attribute{
"a": {
Type: cty.DynamicPseudoType,
Optional: true,
},
},
},
},
},
},
hcltest.MockBody(&hcl.BodyContent{
Blocks: hcl.Blocks{
&hcl.Block{
Type: "list",
Body: hcl.EmptyBody(),
},
&hcl.Block{
Type: "single",
Body: hcl.EmptyBody(),
},
&hcl.Block{
Type: "list",
Body: hcl.EmptyBody(),
},
&hcl.Block{
Type: "map",
Labels: []string{"foo"},
LabelRanges: []hcl.Range{hcl.Range{}},
Body: hcl.EmptyBody(),
},
&hcl.Block{
Type: "map",
Labels: []string{"bar"},
LabelRanges: []hcl.Range{hcl.Range{}},
Body: hcl.EmptyBody(),
},
},
}),
cty.ObjectVal(map[string]cty.Value{
"single": cty.ObjectVal(map[string]cty.Value{
"a": cty.NullVal(cty.DynamicPseudoType),
}),
"list": cty.TupleVal([]cty.Value{
cty.ObjectVal(map[string]cty.Value{
"a": cty.NullVal(cty.DynamicPseudoType),
}),
cty.ObjectVal(map[string]cty.Value{
"a": cty.NullVal(cty.DynamicPseudoType),
}),
}),
"map": cty.ObjectVal(map[string]cty.Value{
"foo": cty.ObjectVal(map[string]cty.Value{
"a": cty.NullVal(cty.DynamicPseudoType),
}),
"bar": cty.ObjectVal(map[string]cty.Value{
"a": cty.NullVal(cty.DynamicPseudoType),
}),
}),
}),
0,
},
"too many list items": {
&Block{
BlockTypes: map[string]*NestedBlock{
"foo": {
Nesting: NestingList,
Block: Block{},
MaxItems: 1,
},
},
},
hcltest.MockBody(&hcl.BodyContent{
Blocks: hcl.Blocks{
&hcl.Block{
Type: "foo",
Body: hcl.EmptyBody(),
},
&hcl.Block{
Type: "foo",
Body: unknownBody{hcl.EmptyBody()},
},
},
}),
cty.ObjectVal(map[string]cty.Value{
"foo": cty.UnknownVal(cty.List(cty.EmptyObject)),
}),
0, // max items cannot be validated during decode
},
// dynamic blocks may fulfill MinItems, but there is only one block to
// decode.
"required MinItems": {
&Block{
BlockTypes: map[string]*NestedBlock{
"foo": {
Nesting: NestingList,
Block: Block{},
MinItems: 2,
},
},
},
hcltest.MockBody(&hcl.BodyContent{
Blocks: hcl.Blocks{
&hcl.Block{
Type: "foo",
Body: unknownBody{hcl.EmptyBody()},
},
},
}),
cty.ObjectVal(map[string]cty.Value{
"foo": cty.UnknownVal(cty.List(cty.EmptyObject)),
}),
0,
},
"extraneous attribute": {
&Block{},
hcltest.MockBody(&hcl.BodyContent{
Attributes: hcl.Attributes{
"extra": {
Name: "extra",
Expr: hcltest.MockExprLiteral(cty.StringVal("hello")),
},
},
}),
cty.EmptyObjectVal,
1, // extraneous attribute
},
}
for name, test := range tests {
t.Run(name, func(t *testing.T) {
spec := test.Schema.DecoderSpec()
got, diags := hcldec.Decode(test.TestBody, spec, nil)
if len(diags) != test.DiagCount {
t.Errorf("wrong number of diagnostics %d; want %d", len(diags), test.DiagCount)
for _, diag := range diags {
t.Logf("- %s", diag.Error())
}
}
if !got.RawEquals(test.Want) {
t.Logf("[INFO] implied schema is %s", spew.Sdump(hcldec.ImpliedSchema(spec)))
t.Errorf("wrong result\ngot: %s\nwant: %s", dump.Value(got), dump.Value(test.Want))
}
// Double-check that we're producing consistent results for DecoderSpec
// and ImpliedType.
impliedType := test.Schema.ImpliedType()
if errs := got.Type().TestConformance(impliedType); len(errs) != 0 {
t.Errorf("result does not conform to the schema's implied type")
for _, err := range errs {
t.Logf("- %s", err.Error())
}
}
})
}
}
// this satisfies hcldec.UnknownBody to simulate a dynamic block with an
// unknown number of values.
type unknownBody struct {
hcl.Body
}
func (b unknownBody) Unknown() bool {
return true
}
func TestAttributeDecoderSpec(t *testing.T) {
tests := map[string]struct {
Schema *Attribute
TestBody hcl.Body
Want cty.Value
DiagCount int
}{
"empty": {
&Attribute{},
hcl.EmptyBody(),
cty.NilVal,
0,
},
"nil": {
nil,
hcl.EmptyBody(),
cty.NilVal,
0,
},
"optional string (null)": {
&Attribute{
Type: cty.String,
Optional: true,
},
hcltest.MockBody(&hcl.BodyContent{}),
cty.NullVal(cty.String),
0,
},
"optional string": {
&Attribute{
Type: cty.String,
Optional: true,
},
hcltest.MockBody(&hcl.BodyContent{
Attributes: hcl.Attributes{
"attr": {
Name: "attr",
Expr: hcltest.MockExprLiteral(cty.StringVal("bar")),
},
},
}),
cty.StringVal("bar"),
0,
},
"NestedType with required string": {
&Attribute{
NestedType: &Object{
Nesting: NestingSingle,
Attributes: map[string]*Attribute{
"foo": {
Type: cty.String,
Required: true,
},
},
},
Optional: true,
},
hcltest.MockBody(&hcl.BodyContent{
Attributes: hcl.Attributes{
"attr": {
Name: "attr",
Expr: hcltest.MockExprLiteral(cty.ObjectVal(map[string]cty.Value{
"foo": cty.StringVal("bar"),
})),
},
},
}),
cty.ObjectVal(map[string]cty.Value{
"foo": cty.StringVal("bar"),
}),
0,
},
"NestedType with optional attributes": {
&Attribute{
NestedType: &Object{
Nesting: NestingSingle,
Attributes: map[string]*Attribute{
"foo": {
Type: cty.String,
Optional: true,
},
"bar": {
Type: cty.String,
Optional: true,
},
},
},
Optional: true,
},
hcltest.MockBody(&hcl.BodyContent{
Attributes: hcl.Attributes{
"attr": {
Name: "attr",
Expr: hcltest.MockExprLiteral(cty.ObjectVal(map[string]cty.Value{
"foo": cty.StringVal("bar"),
})),
},
},
}),
cty.ObjectVal(map[string]cty.Value{
"foo": cty.StringVal("bar"),
"bar": cty.NullVal(cty.String),
}),
0,
},
"NestedType with missing required string": {
&Attribute{
NestedType: &Object{
Nesting: NestingSingle,
Attributes: map[string]*Attribute{
"foo": {
Type: cty.String,
Required: true,
},
},
},
Optional: true,
},
hcltest.MockBody(&hcl.BodyContent{
Attributes: hcl.Attributes{
"attr": {
Name: "attr",
Expr: hcltest.MockExprLiteral(cty.EmptyObjectVal),
},
},
}),
cty.UnknownVal(cty.Object(map[string]cty.Type{
"foo": cty.String,
})),
1,
},
// NestedModes
"NestedType NestingModeList valid": {
&Attribute{
NestedType: &Object{
Nesting: NestingList,
Attributes: map[string]*Attribute{
"foo": {
Type: cty.String,
Required: true,
},
},
},
Optional: true,
},
hcltest.MockBody(&hcl.BodyContent{
Attributes: hcl.Attributes{
"attr": {
Name: "attr",
Expr: hcltest.MockExprLiteral(cty.ListVal([]cty.Value{
cty.ObjectVal(map[string]cty.Value{
"foo": cty.StringVal("bar"),
}),
cty.ObjectVal(map[string]cty.Value{
"foo": cty.StringVal("baz"),
}),
})),
},
},
}),
cty.ListVal([]cty.Value{
cty.ObjectVal(map[string]cty.Value{"foo": cty.StringVal("bar")}),
cty.ObjectVal(map[string]cty.Value{"foo": cty.StringVal("baz")}),
}),
0,
},
"NestedType NestingModeList invalid": {
&Attribute{
NestedType: &Object{
Nesting: NestingList,
Attributes: map[string]*Attribute{
"foo": {
Type: cty.String,
Required: true,
},
},
},
Optional: true,
},
hcltest.MockBody(&hcl.BodyContent{
Attributes: hcl.Attributes{
"attr": {
Name: "attr",
Expr: hcltest.MockExprLiteral(cty.ListVal([]cty.Value{cty.ObjectVal(map[string]cty.Value{
// "foo" should be a string, not a list
"foo": cty.ListVal([]cty.Value{cty.StringVal("bar"), cty.StringVal("baz")}),
})})),
},
},
}),
cty.UnknownVal(cty.List(cty.Object(map[string]cty.Type{"foo": cty.String}))),
1,
},
"NestedType NestingModeSet valid": {
&Attribute{
NestedType: &Object{
Nesting: NestingSet,
Attributes: map[string]*Attribute{
"foo": {
Type: cty.String,
Required: true,
},
},
},
Optional: true,
},
hcltest.MockBody(&hcl.BodyContent{
Attributes: hcl.Attributes{
"attr": {
Name: "attr",
Expr: hcltest.MockExprLiteral(cty.SetVal([]cty.Value{
cty.ObjectVal(map[string]cty.Value{
"foo": cty.StringVal("bar"),
}),
cty.ObjectVal(map[string]cty.Value{
"foo": cty.StringVal("baz"),
}),
})),
},
},
}),
cty.SetVal([]cty.Value{
cty.ObjectVal(map[string]cty.Value{"foo": cty.StringVal("bar")}),
cty.ObjectVal(map[string]cty.Value{"foo": cty.StringVal("baz")}),
}),
0,
},
"NestedType NestingModeSet invalid": {
&Attribute{
NestedType: &Object{
Nesting: NestingSet,
Attributes: map[string]*Attribute{
"foo": {
Type: cty.String,
Required: true,
},
},
},
Optional: true,
},
hcltest.MockBody(&hcl.BodyContent{
Attributes: hcl.Attributes{
"attr": {
Name: "attr",
Expr: hcltest.MockExprLiteral(cty.SetVal([]cty.Value{cty.ObjectVal(map[string]cty.Value{
// "foo" should be a string, not a list
"foo": cty.ListVal([]cty.Value{cty.StringVal("bar"), cty.StringVal("baz")}),
})})),
},
},
}),
cty.UnknownVal(cty.Set(cty.Object(map[string]cty.Type{"foo": cty.String}))),
1,
},
"NestedType NestingModeMap valid": {
&Attribute{
NestedType: &Object{
Nesting: NestingMap,
Attributes: map[string]*Attribute{
"foo": {
Type: cty.String,
Required: true,
},
},
},
Optional: true,
},
hcltest.MockBody(&hcl.BodyContent{
Attributes: hcl.Attributes{
"attr": {
Name: "attr",
Expr: hcltest.MockExprLiteral(cty.MapVal(map[string]cty.Value{
"one": cty.ObjectVal(map[string]cty.Value{
"foo": cty.StringVal("bar"),
}),
"two": cty.ObjectVal(map[string]cty.Value{
"foo": cty.StringVal("baz"),
}),
})),
},
},
}),
cty.MapVal(map[string]cty.Value{
"one": cty.ObjectVal(map[string]cty.Value{"foo": cty.StringVal("bar")}),
"two": cty.ObjectVal(map[string]cty.Value{"foo": cty.StringVal("baz")}),
}),
0,
},
"NestedType NestingModeMap invalid": {
&Attribute{
NestedType: &Object{
Nesting: NestingMap,
Attributes: map[string]*Attribute{
"foo": {
Type: cty.String,
Required: true,
},
},
},
Optional: true,
},
hcltest.MockBody(&hcl.BodyContent{
Attributes: hcl.Attributes{
"attr": {
Name: "attr",
Expr: hcltest.MockExprLiteral(cty.MapVal(map[string]cty.Value{
"one": cty.ObjectVal(map[string]cty.Value{
// "foo" should be a string, not a list
"foo": cty.ListVal([]cty.Value{cty.StringVal("bar"), cty.StringVal("baz")}),
}),
})),
},
},
}),
cty.UnknownVal(cty.Map(cty.Object(map[string]cty.Type{"foo": cty.String}))),
1,
},
"deeply NestedType NestingModeList valid": {
&Attribute{
NestedType: &Object{
Nesting: NestingList,
Attributes: map[string]*Attribute{
"foo": {
NestedType: &Object{
Nesting: NestingList,
Attributes: map[string]*Attribute{
"bar": {
Type: cty.String,
Required: true,
},
},
},
Required: true,
},
},
},
Optional: true,
},
hcltest.MockBody(&hcl.BodyContent{
Attributes: hcl.Attributes{
"attr": {
Name: "attr",
Expr: hcltest.MockExprLiteral(cty.ListVal([]cty.Value{
cty.ObjectVal(map[string]cty.Value{
"foo": cty.ListVal([]cty.Value{
cty.ObjectVal(map[string]cty.Value{"bar": cty.StringVal("baz")}),
cty.ObjectVal(map[string]cty.Value{"bar": cty.StringVal("boz")}),
}),
}),
cty.ObjectVal(map[string]cty.Value{
"foo": cty.ListVal([]cty.Value{
cty.ObjectVal(map[string]cty.Value{"bar": cty.StringVal("biz")}),
cty.ObjectVal(map[string]cty.Value{"bar": cty.StringVal("buz")}),
}),
}),
})),
},
},
}),
cty.ListVal([]cty.Value{
cty.ObjectVal(map[string]cty.Value{"foo": cty.ListVal([]cty.Value{
cty.ObjectVal(map[string]cty.Value{"bar": cty.StringVal("baz")}),
cty.ObjectVal(map[string]cty.Value{"bar": cty.StringVal("boz")}),
})}),
cty.ObjectVal(map[string]cty.Value{"foo": cty.ListVal([]cty.Value{
cty.ObjectVal(map[string]cty.Value{"bar": cty.StringVal("biz")}),
cty.ObjectVal(map[string]cty.Value{"bar": cty.StringVal("buz")}),
})}),
}),
0,
},
"deeply NestedType NestingList invalid": {
&Attribute{
NestedType: &Object{
Nesting: NestingList,
Attributes: map[string]*Attribute{
"foo": {
NestedType: &Object{
Nesting: NestingList,
Attributes: map[string]*Attribute{
"bar": {
Type: cty.Number,
Required: true,
},
},
},
Required: true,
},
},
},
Optional: true,
},
hcltest.MockBody(&hcl.BodyContent{
Attributes: hcl.Attributes{
"attr": {
Name: "attr",
Expr: hcltest.MockExprLiteral(cty.ListVal([]cty.Value{
cty.ObjectVal(map[string]cty.Value{
"foo": cty.ListVal([]cty.Value{
// bar should be a Number
cty.ObjectVal(map[string]cty.Value{"bar": cty.True}),
cty.ObjectVal(map[string]cty.Value{"bar": cty.False}),
}),
}),
})),
},
},
}),
cty.UnknownVal(cty.List(cty.Object(map[string]cty.Type{
"foo": cty.List(cty.Object(map[string]cty.Type{"bar": cty.Number})),
}))),
1,
},
}
for name, test := range tests {
t.Run(name, func(t *testing.T) {
spec := test.Schema.decoderSpec("attr")
got, diags := hcldec.Decode(test.TestBody, spec, nil)
if len(diags) != test.DiagCount {
t.Errorf("wrong number of diagnostics %d; want %d", len(diags), test.DiagCount)
for _, diag := range diags {
t.Logf("- %s", diag.Error())
}
}
if !got.RawEquals(test.Want) {
t.Logf("[INFO] implied schema is %s", spew.Sdump(hcldec.ImpliedSchema(spec)))
t.Errorf("wrong result\ngot: %s\nwant: %s", dump.Value(got), dump.Value(test.Want))
}
})
}
}
// TestAttributeDecodeSpec_panic is a temporary test which verifies that
// decoderSpec panics when an invalid Attribute schema is encountered. It will
// be removed when InternalValidate() is extended to validate Attribute specs
// (and is used). See the #FIXME in decoderSpec.
func TestAttributeDecoderSpec_panic(t *testing.T) {
attrS := &Attribute{
Type: cty.Object(map[string]cty.Type{
"nested_attribute": cty.String,
}),
NestedType: &Object{},
Optional: true,
}
defer func() { recover() }()
attrS.decoderSpec("attr")
t.Errorf("expected panic")
}
func TestListOptionalAttrsFromObject(t *testing.T) {
tests := []struct {
input *Object
want []string
}{
{
nil,
[]string{},
},
{
&Object{},
[]string{},
},
{
&Object{
Nesting: NestingSingle,
Attributes: map[string]*Attribute{
"optional": {Type: cty.String, Optional: true},
"required": {Type: cty.Number, Required: true},
"computed": {Type: cty.List(cty.Bool), Computed: true},
"optional_computed": {Type: cty.Map(cty.Bool), Optional: true, Computed: true},
},
},
[]string{"optional", "computed", "optional_computed"},
},
}
for _, test := range tests {
got := listOptionalAttrsFromObject(test.input)
// order is irrelevant
sort.Strings(got)
sort.Strings(test.want)
if diff := cmp.Diff(got, test.want); diff != "" {
t.Fatalf("wrong result: %s\n", diff)
}
}
}