| package hcldec |
| |
| import ( |
| "fmt" |
| "reflect" |
| "testing" |
| |
| "github.com/hashicorp/hcl/v2" |
| "github.com/hashicorp/hcl/v2/hclsyntax" |
| "github.com/zclconf/go-cty/cty" |
| ) |
| |
| func TestDecode(t *testing.T) { |
| tests := []struct { |
| config string |
| spec Spec |
| ctx *hcl.EvalContext |
| want cty.Value |
| diagCount int |
| }{ |
| { |
| ``, |
| &ObjectSpec{}, |
| nil, |
| cty.EmptyObjectVal, |
| 0, |
| }, |
| { |
| "a = 1\n", |
| &ObjectSpec{}, |
| nil, |
| cty.EmptyObjectVal, |
| 1, // attribute named "a" is not expected here |
| }, |
| { |
| "a = 1\n", |
| &ObjectSpec{ |
| "a": &AttrSpec{ |
| Name: "a", |
| Type: cty.Number, |
| }, |
| }, |
| nil, |
| cty.ObjectVal(map[string]cty.Value{ |
| "a": cty.NumberIntVal(1), |
| }), |
| 0, |
| }, |
| { |
| "a = 1\n", |
| &AttrSpec{ |
| Name: "a", |
| Type: cty.Number, |
| }, |
| nil, |
| cty.NumberIntVal(1), |
| 0, |
| }, |
| { |
| "a = 1\n", |
| &DefaultSpec{ |
| Primary: &AttrSpec{ |
| Name: "a", |
| Type: cty.Number, |
| }, |
| Default: &LiteralSpec{ |
| Value: cty.NumberIntVal(10), |
| }, |
| }, |
| nil, |
| cty.NumberIntVal(1), |
| 0, |
| }, |
| { |
| "", |
| &DefaultSpec{ |
| Primary: &AttrSpec{ |
| Name: "a", |
| Type: cty.Number, |
| }, |
| Default: &LiteralSpec{ |
| Value: cty.NumberIntVal(10), |
| }, |
| }, |
| nil, |
| cty.NumberIntVal(10), |
| 0, |
| }, |
| { |
| "a = 1\n", |
| ObjectSpec{ |
| "foo": &DefaultSpec{ |
| Primary: &AttrSpec{ |
| Name: "a", |
| Type: cty.Number, |
| }, |
| Default: &LiteralSpec{ |
| Value: cty.NumberIntVal(10), |
| }, |
| }, |
| }, |
| nil, |
| cty.ObjectVal(map[string]cty.Value{"foo": cty.NumberIntVal(1)}), |
| 0, |
| }, |
| { |
| "a = \"1\"\n", |
| &AttrSpec{ |
| Name: "a", |
| Type: cty.Number, |
| }, |
| nil, |
| cty.NumberIntVal(1), |
| 0, |
| }, |
| { |
| "a = true\n", |
| &AttrSpec{ |
| Name: "a", |
| Type: cty.Number, |
| }, |
| nil, |
| cty.UnknownVal(cty.Number), |
| 1, // incorrect type - number required. |
| }, |
| { |
| ``, |
| &AttrSpec{ |
| Name: "a", |
| Type: cty.Number, |
| Required: true, |
| }, |
| nil, |
| cty.NullVal(cty.Number), |
| 1, // attribute "a" is required |
| }, |
| |
| { |
| ` |
| b { |
| } |
| `, |
| &BlockSpec{ |
| TypeName: "b", |
| Nested: ObjectSpec{}, |
| }, |
| nil, |
| cty.EmptyObjectVal, |
| 0, |
| }, |
| { |
| ` |
| b "baz" { |
| } |
| `, |
| &BlockSpec{ |
| TypeName: "b", |
| Nested: &BlockLabelSpec{ |
| Index: 0, |
| Name: "name", |
| }, |
| }, |
| nil, |
| cty.StringVal("baz"), |
| 0, |
| }, |
| { |
| ` |
| b "baz" {} |
| b "foo" {} |
| `, |
| &BlockSpec{ |
| TypeName: "b", |
| Nested: &BlockLabelSpec{ |
| Index: 0, |
| Name: "name", |
| }, |
| }, |
| nil, |
| cty.StringVal("baz"), |
| 1, // duplicate "b" block |
| }, |
| { |
| ` |
| b { |
| } |
| `, |
| &BlockSpec{ |
| TypeName: "b", |
| Nested: &BlockLabelSpec{ |
| Index: 0, |
| Name: "name", |
| }, |
| }, |
| nil, |
| cty.NullVal(cty.String), |
| 1, // missing name label |
| }, |
| { |
| ``, |
| &BlockSpec{ |
| TypeName: "b", |
| Nested: ObjectSpec{}, |
| }, |
| nil, |
| cty.NullVal(cty.EmptyObject), |
| 0, |
| }, |
| { |
| "a {}\n", |
| &BlockSpec{ |
| TypeName: "b", |
| Nested: ObjectSpec{}, |
| }, |
| nil, |
| cty.NullVal(cty.EmptyObject), |
| 1, // blocks of type "a" are not supported |
| }, |
| { |
| ``, |
| &BlockSpec{ |
| TypeName: "b", |
| Nested: ObjectSpec{}, |
| Required: true, |
| }, |
| nil, |
| cty.NullVal(cty.EmptyObject), |
| 1, // a block of type "b" is required |
| }, |
| { |
| ` |
| b {} |
| b {} |
| `, |
| &BlockSpec{ |
| TypeName: "b", |
| Nested: ObjectSpec{}, |
| Required: true, |
| }, |
| nil, |
| cty.EmptyObjectVal, |
| 1, // only one "b" block is allowed |
| }, |
| { |
| ` |
| b { |
| } |
| `, |
| &BlockAttrsSpec{ |
| TypeName: "b", |
| ElementType: cty.String, |
| }, |
| nil, |
| cty.MapValEmpty(cty.String), |
| 0, |
| }, |
| { |
| ` |
| b { |
| hello = "world" |
| } |
| `, |
| &BlockAttrsSpec{ |
| TypeName: "b", |
| ElementType: cty.String, |
| }, |
| nil, |
| cty.MapVal(map[string]cty.Value{ |
| "hello": cty.StringVal("world"), |
| }), |
| 0, |
| }, |
| { |
| ` |
| b { |
| hello = true |
| } |
| `, |
| &BlockAttrsSpec{ |
| TypeName: "b", |
| ElementType: cty.String, |
| }, |
| nil, |
| cty.MapVal(map[string]cty.Value{ |
| "hello": cty.StringVal("true"), |
| }), |
| 0, |
| }, |
| { |
| ` |
| b { |
| hello = true |
| goodbye = 5 |
| } |
| `, |
| &BlockAttrsSpec{ |
| TypeName: "b", |
| ElementType: cty.String, |
| }, |
| nil, |
| cty.MapVal(map[string]cty.Value{ |
| "hello": cty.StringVal("true"), |
| "goodbye": cty.StringVal("5"), |
| }), |
| 0, |
| }, |
| { |
| ``, |
| &BlockAttrsSpec{ |
| TypeName: "b", |
| ElementType: cty.String, |
| }, |
| nil, |
| cty.NullVal(cty.Map(cty.String)), |
| 0, |
| }, |
| { |
| ``, |
| &BlockAttrsSpec{ |
| TypeName: "b", |
| ElementType: cty.String, |
| Required: true, |
| }, |
| nil, |
| cty.NullVal(cty.Map(cty.String)), |
| 1, // missing b block |
| }, |
| { |
| ` |
| b { |
| } |
| b { |
| } |
| `, |
| &BlockAttrsSpec{ |
| TypeName: "b", |
| ElementType: cty.String, |
| }, |
| nil, |
| cty.MapValEmpty(cty.String), |
| 1, // duplicate b block |
| }, |
| { |
| ` |
| b { |
| } |
| b { |
| } |
| `, |
| &BlockAttrsSpec{ |
| TypeName: "b", |
| ElementType: cty.String, |
| Required: true, |
| }, |
| nil, |
| cty.MapValEmpty(cty.String), |
| 1, // duplicate b block |
| }, |
| { |
| ` |
| b {} |
| b {} |
| `, |
| &BlockListSpec{ |
| TypeName: "b", |
| Nested: ObjectSpec{}, |
| }, |
| nil, |
| cty.ListVal([]cty.Value{cty.EmptyObjectVal, cty.EmptyObjectVal}), |
| 0, |
| }, |
| { |
| ``, |
| &BlockListSpec{ |
| TypeName: "b", |
| Nested: ObjectSpec{}, |
| }, |
| nil, |
| cty.ListValEmpty(cty.EmptyObject), |
| 0, |
| }, |
| { |
| ` |
| b "foo" {} |
| b "bar" {} |
| `, |
| &BlockListSpec{ |
| TypeName: "b", |
| Nested: &BlockLabelSpec{ |
| Name: "name", |
| Index: 0, |
| }, |
| }, |
| nil, |
| cty.ListVal([]cty.Value{cty.StringVal("foo"), cty.StringVal("bar")}), |
| 0, |
| }, |
| { |
| ` |
| b {} |
| b {} |
| b {} |
| `, |
| &BlockListSpec{ |
| TypeName: "b", |
| Nested: ObjectSpec{}, |
| MaxItems: 2, |
| }, |
| nil, |
| cty.ListVal([]cty.Value{cty.EmptyObjectVal, cty.EmptyObjectVal, cty.EmptyObjectVal}), |
| 1, // too many b blocks |
| }, |
| { |
| ` |
| b {} |
| b {} |
| `, |
| &BlockListSpec{ |
| TypeName: "b", |
| Nested: ObjectSpec{}, |
| MinItems: 10, |
| }, |
| nil, |
| cty.ListVal([]cty.Value{cty.EmptyObjectVal, cty.EmptyObjectVal}), |
| 1, // insufficient b blocks |
| }, |
| { |
| ` |
| b { |
| a = true |
| } |
| b { |
| a = 1 |
| } |
| `, |
| &BlockListSpec{ |
| TypeName: "b", |
| Nested: &AttrSpec{ |
| Name: "a", |
| Type: cty.DynamicPseudoType, |
| }, |
| }, |
| nil, |
| cty.DynamicVal, |
| 1, // Unconsistent argument types in b blocks |
| }, |
| { |
| ` |
| b { |
| a = true |
| } |
| b { |
| a = "not a bool" |
| } |
| `, |
| &BlockListSpec{ |
| TypeName: "b", |
| Nested: &AttrSpec{ |
| Name: "a", |
| Type: cty.DynamicPseudoType, |
| }, |
| }, |
| nil, |
| cty.ListVal([]cty.Value{ |
| cty.StringVal("true"), // type unification generalizes all the values to strings |
| cty.StringVal("not a bool"), |
| }), |
| 0, |
| }, |
| { |
| ` |
| b {} |
| b {} |
| `, |
| &BlockSetSpec{ |
| TypeName: "b", |
| Nested: ObjectSpec{}, |
| MaxItems: 2, |
| }, |
| nil, |
| cty.SetVal([]cty.Value{cty.EmptyObjectVal, cty.EmptyObjectVal}), |
| 0, |
| }, |
| { |
| ` |
| b "foo" "bar" {} |
| b "bar" "baz" {} |
| `, |
| &BlockSetSpec{ |
| TypeName: "b", |
| Nested: TupleSpec{ |
| &BlockLabelSpec{ |
| Name: "name", |
| Index: 1, |
| }, |
| &BlockLabelSpec{ |
| Name: "type", |
| Index: 0, |
| }, |
| }, |
| }, |
| nil, |
| cty.SetVal([]cty.Value{ |
| cty.TupleVal([]cty.Value{cty.StringVal("bar"), cty.StringVal("foo")}), |
| cty.TupleVal([]cty.Value{cty.StringVal("baz"), cty.StringVal("bar")}), |
| }), |
| 0, |
| }, |
| { |
| ` |
| b { |
| a = true |
| } |
| b { |
| a = 1 |
| } |
| `, |
| &BlockSetSpec{ |
| TypeName: "b", |
| Nested: &AttrSpec{ |
| Name: "a", |
| Type: cty.DynamicPseudoType, |
| }, |
| }, |
| nil, |
| cty.DynamicVal, |
| 1, // Unconsistent argument types in b blocks |
| }, |
| { |
| ` |
| b { |
| a = true |
| } |
| b { |
| a = "not a bool" |
| } |
| `, |
| &BlockSetSpec{ |
| TypeName: "b", |
| Nested: &AttrSpec{ |
| Name: "a", |
| Type: cty.DynamicPseudoType, |
| }, |
| }, |
| nil, |
| cty.SetVal([]cty.Value{ |
| cty.StringVal("true"), // type unification generalizes all the values to strings |
| cty.StringVal("not a bool"), |
| }), |
| 0, |
| }, |
| { |
| ` |
| b "foo" {} |
| b "bar" {} |
| `, |
| &BlockMapSpec{ |
| TypeName: "b", |
| LabelNames: []string{"key"}, |
| Nested: ObjectSpec{}, |
| }, |
| nil, |
| cty.MapVal(map[string]cty.Value{"foo": cty.EmptyObjectVal, "bar": cty.EmptyObjectVal}), |
| 0, |
| }, |
| { |
| ` |
| b "foo" "bar" {} |
| b "bar" "baz" {} |
| `, |
| &BlockMapSpec{ |
| TypeName: "b", |
| LabelNames: []string{"key1", "key2"}, |
| Nested: ObjectSpec{}, |
| }, |
| nil, |
| cty.MapVal(map[string]cty.Value{ |
| "foo": cty.MapVal(map[string]cty.Value{ |
| "bar": cty.EmptyObjectVal, |
| }), |
| "bar": cty.MapVal(map[string]cty.Value{ |
| "baz": cty.EmptyObjectVal, |
| }), |
| }), |
| 0, |
| }, |
| { |
| ` |
| b "foo" "bar" {} |
| b "bar" "bar" {} |
| `, |
| &BlockMapSpec{ |
| TypeName: "b", |
| LabelNames: []string{"key1", "key2"}, |
| Nested: ObjectSpec{}, |
| }, |
| nil, |
| cty.MapVal(map[string]cty.Value{ |
| "foo": cty.MapVal(map[string]cty.Value{ |
| "bar": cty.EmptyObjectVal, |
| }), |
| "bar": cty.MapVal(map[string]cty.Value{ |
| "bar": cty.EmptyObjectVal, |
| }), |
| }), |
| 0, |
| }, |
| { |
| ` |
| b "foo" "bar" {} |
| b "foo" "baz" {} |
| `, |
| &BlockMapSpec{ |
| TypeName: "b", |
| LabelNames: []string{"key1", "key2"}, |
| Nested: ObjectSpec{}, |
| }, |
| nil, |
| cty.MapVal(map[string]cty.Value{ |
| "foo": cty.MapVal(map[string]cty.Value{ |
| "bar": cty.EmptyObjectVal, |
| "baz": cty.EmptyObjectVal, |
| }), |
| }), |
| 0, |
| }, |
| { |
| ` |
| b "foo" "bar" {} |
| `, |
| &BlockMapSpec{ |
| TypeName: "b", |
| LabelNames: []string{"key"}, |
| Nested: ObjectSpec{}, |
| }, |
| nil, |
| cty.MapValEmpty(cty.EmptyObject), |
| 1, // too many labels |
| }, |
| { |
| ` |
| b "bar" {} |
| `, |
| &BlockMapSpec{ |
| TypeName: "b", |
| LabelNames: []string{"key1", "key2"}, |
| Nested: ObjectSpec{}, |
| }, |
| nil, |
| cty.MapValEmpty(cty.EmptyObject), |
| 1, // not enough labels |
| }, |
| { |
| ` |
| b "foo" {} |
| b "foo" {} |
| `, |
| &BlockMapSpec{ |
| TypeName: "b", |
| LabelNames: []string{"key"}, |
| Nested: ObjectSpec{}, |
| }, |
| nil, |
| cty.MapVal(map[string]cty.Value{"foo": cty.EmptyObjectVal}), |
| 1, // duplicate b block |
| }, |
| { |
| ` |
| b "foo" "bar" {} |
| b "foo" "bar" {} |
| `, |
| &BlockMapSpec{ |
| TypeName: "b", |
| LabelNames: []string{"key1", "key2"}, |
| Nested: ObjectSpec{}, |
| }, |
| nil, |
| cty.MapVal(map[string]cty.Value{"foo": cty.MapVal(map[string]cty.Value{"bar": cty.EmptyObjectVal})}), |
| 1, // duplicate b block |
| }, |
| { |
| ` |
| b "foo" "bar" {} |
| b "bar" "baz" {} |
| `, |
| &BlockMapSpec{ |
| TypeName: "b", |
| LabelNames: []string{"type"}, |
| Nested: &BlockLabelSpec{ |
| Name: "name", |
| Index: 0, |
| }, |
| }, |
| nil, |
| cty.MapVal(map[string]cty.Value{ |
| "foo": cty.StringVal("bar"), |
| "bar": cty.StringVal("baz"), |
| }), |
| 0, |
| }, |
| { |
| ` |
| b "foo" {} |
| `, |
| &BlockMapSpec{ |
| TypeName: "b", |
| LabelNames: []string{"type"}, |
| Nested: &BlockLabelSpec{ |
| Name: "name", |
| Index: 0, |
| }, |
| }, |
| nil, |
| cty.MapValEmpty(cty.String), |
| 1, // missing name |
| }, |
| { |
| ` |
| b {} |
| b {} |
| `, |
| &BlockTupleSpec{ |
| TypeName: "b", |
| Nested: ObjectSpec{}, |
| }, |
| nil, |
| cty.TupleVal([]cty.Value{cty.EmptyObjectVal, cty.EmptyObjectVal}), |
| 0, |
| }, |
| { |
| ``, |
| &BlockTupleSpec{ |
| TypeName: "b", |
| Nested: ObjectSpec{}, |
| }, |
| nil, |
| cty.EmptyTupleVal, |
| 0, |
| }, |
| { |
| ` |
| b "foo" {} |
| b "bar" {} |
| `, |
| &BlockTupleSpec{ |
| TypeName: "b", |
| Nested: &BlockLabelSpec{ |
| Name: "name", |
| Index: 0, |
| }, |
| }, |
| nil, |
| cty.TupleVal([]cty.Value{cty.StringVal("foo"), cty.StringVal("bar")}), |
| 0, |
| }, |
| { |
| ` |
| b {} |
| b {} |
| b {} |
| `, |
| &BlockTupleSpec{ |
| TypeName: "b", |
| Nested: ObjectSpec{}, |
| MaxItems: 2, |
| }, |
| nil, |
| cty.TupleVal([]cty.Value{cty.EmptyObjectVal, cty.EmptyObjectVal, cty.EmptyObjectVal}), |
| 1, // too many b blocks |
| }, |
| { |
| ` |
| b {} |
| b {} |
| `, |
| &BlockTupleSpec{ |
| TypeName: "b", |
| Nested: ObjectSpec{}, |
| MinItems: 10, |
| }, |
| nil, |
| cty.TupleVal([]cty.Value{cty.EmptyObjectVal, cty.EmptyObjectVal}), |
| 1, // insufficient b blocks |
| }, |
| { |
| ` |
| b { |
| a = true |
| } |
| b { |
| a = 1 |
| } |
| `, |
| &BlockTupleSpec{ |
| TypeName: "b", |
| Nested: &AttrSpec{ |
| Name: "a", |
| Type: cty.DynamicPseudoType, |
| }, |
| }, |
| nil, |
| cty.TupleVal([]cty.Value{ |
| cty.True, |
| cty.NumberIntVal(1), |
| }), |
| 0, |
| }, |
| { |
| ` |
| b { |
| a = true |
| } |
| b { |
| a = "not a bool" |
| } |
| `, |
| &BlockTupleSpec{ |
| TypeName: "b", |
| Nested: &AttrSpec{ |
| Name: "a", |
| Type: cty.DynamicPseudoType, |
| }, |
| }, |
| nil, |
| cty.TupleVal([]cty.Value{ |
| cty.True, |
| cty.StringVal("not a bool"), |
| }), |
| 0, |
| }, |
| { |
| ` |
| b "foo" {} |
| b "bar" {} |
| `, |
| &BlockObjectSpec{ |
| TypeName: "b", |
| LabelNames: []string{"key"}, |
| Nested: ObjectSpec{}, |
| }, |
| nil, |
| cty.ObjectVal(map[string]cty.Value{"foo": cty.EmptyObjectVal, "bar": cty.EmptyObjectVal}), |
| 0, |
| }, |
| { |
| ` |
| b "foo" "bar" {} |
| b "bar" "baz" {} |
| `, |
| &BlockObjectSpec{ |
| TypeName: "b", |
| LabelNames: []string{"key1", "key2"}, |
| Nested: ObjectSpec{}, |
| }, |
| nil, |
| cty.ObjectVal(map[string]cty.Value{ |
| "foo": cty.ObjectVal(map[string]cty.Value{ |
| "bar": cty.EmptyObjectVal, |
| }), |
| "bar": cty.ObjectVal(map[string]cty.Value{ |
| "baz": cty.EmptyObjectVal, |
| }), |
| }), |
| 0, |
| }, |
| { |
| ` |
| b "foo" "bar" {} |
| b "bar" "bar" {} |
| `, |
| &BlockObjectSpec{ |
| TypeName: "b", |
| LabelNames: []string{"key1", "key2"}, |
| Nested: ObjectSpec{}, |
| }, |
| nil, |
| cty.ObjectVal(map[string]cty.Value{ |
| "foo": cty.ObjectVal(map[string]cty.Value{ |
| "bar": cty.EmptyObjectVal, |
| }), |
| "bar": cty.ObjectVal(map[string]cty.Value{ |
| "bar": cty.EmptyObjectVal, |
| }), |
| }), |
| 0, |
| }, |
| { |
| ` |
| b "foo" "bar" {} |
| b "foo" "baz" {} |
| `, |
| &BlockObjectSpec{ |
| TypeName: "b", |
| LabelNames: []string{"key1", "key2"}, |
| Nested: ObjectSpec{}, |
| }, |
| nil, |
| cty.ObjectVal(map[string]cty.Value{ |
| "foo": cty.ObjectVal(map[string]cty.Value{ |
| "bar": cty.EmptyObjectVal, |
| "baz": cty.EmptyObjectVal, |
| }), |
| }), |
| 0, |
| }, |
| { |
| ` |
| b "foo" "bar" {} |
| `, |
| &BlockObjectSpec{ |
| TypeName: "b", |
| LabelNames: []string{"key"}, |
| Nested: ObjectSpec{}, |
| }, |
| nil, |
| cty.EmptyObjectVal, |
| 1, // too many labels |
| }, |
| { |
| ` |
| b "bar" {} |
| `, |
| &BlockObjectSpec{ |
| TypeName: "b", |
| LabelNames: []string{"key1", "key2"}, |
| Nested: ObjectSpec{}, |
| }, |
| nil, |
| cty.EmptyObjectVal, |
| 1, // not enough labels |
| }, |
| { |
| ` |
| b "foo" {} |
| b "foo" {} |
| `, |
| &BlockObjectSpec{ |
| TypeName: "b", |
| LabelNames: []string{"key"}, |
| Nested: ObjectSpec{}, |
| }, |
| nil, |
| cty.ObjectVal(map[string]cty.Value{"foo": cty.EmptyObjectVal}), |
| 1, // duplicate b block |
| }, |
| { |
| ` |
| b "foo" "bar" {} |
| b "foo" "bar" {} |
| `, |
| &BlockObjectSpec{ |
| TypeName: "b", |
| LabelNames: []string{"key1", "key2"}, |
| Nested: ObjectSpec{}, |
| }, |
| nil, |
| cty.ObjectVal(map[string]cty.Value{"foo": cty.ObjectVal(map[string]cty.Value{"bar": cty.EmptyObjectVal})}), |
| 1, // duplicate b block |
| }, |
| { |
| ` |
| b "foo" "bar" {} |
| b "bar" "baz" {} |
| `, |
| &BlockObjectSpec{ |
| TypeName: "b", |
| LabelNames: []string{"type"}, |
| Nested: &BlockLabelSpec{ |
| Name: "name", |
| Index: 0, |
| }, |
| }, |
| nil, |
| cty.ObjectVal(map[string]cty.Value{ |
| "foo": cty.StringVal("bar"), |
| "bar": cty.StringVal("baz"), |
| }), |
| 0, |
| }, |
| { |
| ` |
| b "foo" {} |
| `, |
| &BlockObjectSpec{ |
| TypeName: "b", |
| LabelNames: []string{"type"}, |
| Nested: &BlockLabelSpec{ |
| Name: "name", |
| Index: 0, |
| }, |
| }, |
| nil, |
| cty.EmptyObjectVal, |
| 1, // missing name |
| }, |
| { |
| ` |
| b "foo" { |
| arg = true |
| } |
| b "bar" { |
| arg = 1 |
| } |
| `, |
| &BlockObjectSpec{ |
| TypeName: "b", |
| LabelNames: []string{"type"}, |
| Nested: &AttrSpec{ |
| Name: "arg", |
| Type: cty.DynamicPseudoType, |
| }, |
| }, |
| nil, |
| cty.ObjectVal(map[string]cty.Value{ |
| "foo": cty.True, |
| "bar": cty.NumberIntVal(1), |
| }), |
| 0, |
| }, |
| } |
| |
| for i, test := range tests { |
| t.Run(fmt.Sprintf("%02d-%s", i, test.config), func(t *testing.T) { |
| file, parseDiags := hclsyntax.ParseConfig([]byte(test.config), "", hcl.Pos{Line: 1, Column: 1, Byte: 0}) |
| body := file.Body |
| got, valDiags := Decode(body, test.spec, test.ctx) |
| |
| var diags hcl.Diagnostics |
| diags = append(diags, parseDiags...) |
| diags = append(diags, valDiags...) |
| |
| 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.Errorf("wrong result\ngot: %#v\nwant: %#v", got, test.want) |
| } |
| }) |
| } |
| } |
| |
| func TestSourceRange(t *testing.T) { |
| tests := []struct { |
| config string |
| spec Spec |
| want hcl.Range |
| }{ |
| { |
| "a = 1\n", |
| &AttrSpec{ |
| Name: "a", |
| }, |
| hcl.Range{ |
| Start: hcl.Pos{Line: 1, Column: 5, Byte: 4}, |
| End: hcl.Pos{Line: 1, Column: 6, Byte: 5}, |
| }, |
| }, |
| { |
| ` |
| b { |
| a = 1 |
| } |
| `, |
| &BlockSpec{ |
| TypeName: "b", |
| Nested: &AttrSpec{ |
| Name: "a", |
| }, |
| }, |
| hcl.Range{ |
| Start: hcl.Pos{Line: 3, Column: 7, Byte: 11}, |
| End: hcl.Pos{Line: 3, Column: 8, Byte: 12}, |
| }, |
| }, |
| { |
| ` |
| b { |
| c { |
| a = 1 |
| } |
| } |
| `, |
| &BlockSpec{ |
| TypeName: "b", |
| Nested: &BlockSpec{ |
| TypeName: "c", |
| Nested: &AttrSpec{ |
| Name: "a", |
| }, |
| }, |
| }, |
| hcl.Range{ |
| Start: hcl.Pos{Line: 4, Column: 9, Byte: 19}, |
| End: hcl.Pos{Line: 4, Column: 10, Byte: 20}, |
| }, |
| }, |
| } |
| |
| for i, test := range tests { |
| t.Run(fmt.Sprintf("%02d-%s", i, test.config), func(t *testing.T) { |
| file, diags := hclsyntax.ParseConfig([]byte(test.config), "", hcl.Pos{Line: 1, Column: 1, Byte: 0}) |
| if len(diags) != 0 { |
| t.Errorf("wrong number of diagnostics %d; want %d", len(diags), 0) |
| for _, diag := range diags { |
| t.Logf(" - %s", diag.Error()) |
| } |
| } |
| body := file.Body |
| |
| got := SourceRange(body, test.spec) |
| |
| if !reflect.DeepEqual(got, test.want) { |
| t.Errorf("wrong result\ngot: %#v\nwant: %#v", got, test.want) |
| } |
| }) |
| } |
| |
| } |
