Function TestHCLDecDecodeToExpr

integrationtest/hcldec_into_expr_test.go:23–134

TestHCLDecDecodeToExpr tests both hcldec's support for types with custom expression decoding rules and the two expression capsule types implemented in ext/customdecode. This mechanism requires cooperation between those two components and cty in order to work, so it's helpful to exercise it in an int

(t *testing.T)

// two components and cty in order to work, so it's helpful to exercise it in
// an integration test.
func TestHCLDecDecodeToExpr(t *testing.T) {
	// Here we're going to capture the structure of two simple expressions
	// without immediately evaluating them.
	const input = `
a = foo
b = foo
c = "hello"
`
	// We'll capture "a" directly as an expression, losing its evaluation
	// context but retaining its structure. We'll capture "b" as a
	// customdecode.ExpressionClosure, which gives us both the expression
	// itself and the evaluation context it was originally evaluated in.
	// We also have "c" here just to make sure we can still decode into a
	// "normal" type via standard expression evaluation.

	f, diags := hclsyntax.ParseConfig([]byte(input), "", hcl.Pos{Line: 1, Column: 1})
	if diags.HasErrors() {
		t.Fatalf("unexpected problems: %s", diags.Error())
	}

	spec := hcldec.ObjectSpec{
		"a": &hcldec.AttrSpec{
			Name:     "a",
			Type:     customdecode.ExpressionType,
			Required: true,
		},
		"b": &hcldec.AttrSpec{
			Name:     "b",
			Type:     customdecode.ExpressionClosureType,
			Required: true,
		},
		"c": &hcldec.AttrSpec{
			Name:     "c",
			Type:     cty.String,
			Required: true,
		},
	}
	ctx := &hcl.EvalContext{
		Variables: map[string]cty.Value{
			"foo": cty.StringVal("foo value"),
		},
	}
	objVal, diags := hcldec.Decode(f.Body, spec, ctx)
	if diags.HasErrors() {
		t.Fatalf("unexpected problems: %s", diags.Error())
	}

	aVal := objVal.GetAttr("a")
	bVal := objVal.GetAttr("b")
	cVal := objVal.GetAttr("c")

	if got, want := aVal.Type(), customdecode.ExpressionType; !got.Equals(want) {
		t.Fatalf("wrong type for 'a'\ngot:  %#v\nwant: %#v", got, want)
	}
	if got, want := bVal.Type(), customdecode.ExpressionClosureType; !got.Equals(want) {
		t.Fatalf("wrong type for 'b'\ngot:  %#v\nwant: %#v", got, want)
	}
	if got, want := cVal.Type(), cty.String; !got.Equals(want) {