450 lines
12 KiB
Go
450 lines
12 KiB
Go
package integrationtest
|
|
|
|
import (
|
|
"reflect"
|
|
"sort"
|
|
"testing"
|
|
|
|
"github.com/davecgh/go-spew/spew"
|
|
"github.com/hashicorp/hcl/v2"
|
|
"github.com/hashicorp/hcl/v2/ext/dynblock"
|
|
"github.com/hashicorp/hcl/v2/gohcl"
|
|
"github.com/hashicorp/hcl/v2/hcldec"
|
|
"github.com/hashicorp/hcl/v2/hclsyntax"
|
|
"github.com/hashicorp/hcl/v2/json"
|
|
"github.com/zclconf/go-cty/cty"
|
|
)
|
|
|
|
// TestTerraformLike parses both a native syntax and a JSON representation
|
|
// of the same HashiCorp Terraform-like configuration structure and then makes
|
|
// assertions against the result of each.
|
|
//
|
|
// Terraform exercises a lot of different HCL codepaths, so this is not
|
|
// exhaustive but tries to cover a variety of different relevant scenarios.
|
|
func TestTerraformLike(t *testing.T) {
|
|
tests := map[string]func() (*hcl.File, hcl.Diagnostics){
|
|
"native syntax": func() (*hcl.File, hcl.Diagnostics) {
|
|
return hclsyntax.ParseConfig(
|
|
[]byte(terraformLikeNativeSyntax),
|
|
"config.tf", hcl.Pos{Line: 1, Column: 1},
|
|
)
|
|
},
|
|
"JSON": func() (*hcl.File, hcl.Diagnostics) {
|
|
return json.Parse(
|
|
[]byte(terraformLikeJSON),
|
|
"config.tf.json",
|
|
)
|
|
},
|
|
}
|
|
|
|
type Variable struct {
|
|
Name string `hcl:"name,label"`
|
|
}
|
|
type Resource struct {
|
|
Type string `hcl:"type,label"`
|
|
Name string `hcl:"name,label"`
|
|
Config hcl.Body `hcl:",remain"`
|
|
DependsOn hcl.Expression `hcl:"depends_on,attr"`
|
|
}
|
|
type Module struct {
|
|
Name string `hcl:"name,label"`
|
|
Providers hcl.Expression `hcl:"providers"`
|
|
}
|
|
type Root struct {
|
|
Variables []*Variable `hcl:"variable,block"`
|
|
Resources []*Resource `hcl:"resource,block"`
|
|
Modules []*Module `hcl:"module,block"`
|
|
}
|
|
instanceDecode := &hcldec.ObjectSpec{
|
|
"image_id": &hcldec.AttrSpec{
|
|
Name: "image_id",
|
|
Required: true,
|
|
Type: cty.String,
|
|
},
|
|
"instance_type": &hcldec.AttrSpec{
|
|
Name: "instance_type",
|
|
Required: true,
|
|
Type: cty.String,
|
|
},
|
|
"tags": &hcldec.AttrSpec{
|
|
Name: "tags",
|
|
Required: false,
|
|
Type: cty.Map(cty.String),
|
|
},
|
|
}
|
|
securityGroupDecode := &hcldec.ObjectSpec{
|
|
"ingress": &hcldec.BlockListSpec{
|
|
TypeName: "ingress",
|
|
Nested: &hcldec.ObjectSpec{
|
|
"cidr_block": &hcldec.AttrSpec{
|
|
Name: "cidr_block",
|
|
Required: true,
|
|
Type: cty.String,
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
for name, loadFunc := range tests {
|
|
t.Run(name, func(t *testing.T) {
|
|
file, diags := loadFunc()
|
|
if len(diags) != 0 {
|
|
t.Errorf("unexpected diagnostics during parse")
|
|
for _, diag := range diags {
|
|
t.Logf("- %s", diag)
|
|
}
|
|
return
|
|
}
|
|
|
|
body := file.Body
|
|
|
|
var root Root
|
|
diags = gohcl.DecodeBody(body, nil, &root)
|
|
if len(diags) != 0 {
|
|
t.Errorf("unexpected diagnostics during root eval")
|
|
for _, diag := range diags {
|
|
t.Logf("- %s", diag)
|
|
}
|
|
return
|
|
}
|
|
|
|
wantVars := []*Variable{
|
|
{
|
|
Name: "image_id",
|
|
},
|
|
}
|
|
if gotVars := root.Variables; !reflect.DeepEqual(gotVars, wantVars) {
|
|
t.Errorf("wrong Variables\ngot: %swant: %s", spew.Sdump(gotVars), spew.Sdump(wantVars))
|
|
}
|
|
|
|
if got, want := len(root.Resources), 3; got != want {
|
|
t.Fatalf("wrong number of Resources %d; want %d", got, want)
|
|
}
|
|
|
|
sort.Slice(root.Resources, func(i, j int) bool {
|
|
return root.Resources[i].Name < root.Resources[j].Name
|
|
})
|
|
|
|
t.Run("resource 0", func(t *testing.T) {
|
|
r := root.Resources[0]
|
|
if got, want := r.Type, "happycloud_security_group"; got != want {
|
|
t.Errorf("wrong type %q; want %q", got, want)
|
|
}
|
|
if got, want := r.Name, "private"; got != want {
|
|
t.Errorf("wrong type %q; want %q", got, want)
|
|
}
|
|
|
|
// For this one we're including support for the dynamic block
|
|
// extension, since Terraform uses this to allow dynamic
|
|
// generation of blocks within resource configuration.
|
|
forEachCtx := &hcl.EvalContext{
|
|
Variables: map[string]cty.Value{
|
|
"var": cty.ObjectVal(map[string]cty.Value{
|
|
"extra_private_cidr_blocks": cty.ListVal([]cty.Value{
|
|
cty.StringVal("172.16.0.0/12"),
|
|
cty.StringVal("169.254.0.0/16"),
|
|
}),
|
|
}),
|
|
},
|
|
}
|
|
dynBody := dynblock.Expand(r.Config, forEachCtx)
|
|
|
|
cfg, diags := hcldec.Decode(dynBody, securityGroupDecode, nil)
|
|
if len(diags) != 0 {
|
|
t.Errorf("unexpected diagnostics decoding Config")
|
|
for _, diag := range diags {
|
|
t.Logf("- %s", diag)
|
|
}
|
|
return
|
|
}
|
|
wantCfg := cty.ObjectVal(map[string]cty.Value{
|
|
"ingress": cty.ListVal([]cty.Value{
|
|
cty.ObjectVal(map[string]cty.Value{
|
|
"cidr_block": cty.StringVal("10.0.0.0/8"),
|
|
}),
|
|
cty.ObjectVal(map[string]cty.Value{
|
|
"cidr_block": cty.StringVal("192.168.0.0/16"),
|
|
}),
|
|
cty.ObjectVal(map[string]cty.Value{
|
|
"cidr_block": cty.StringVal("172.16.0.0/12"),
|
|
}),
|
|
cty.ObjectVal(map[string]cty.Value{
|
|
"cidr_block": cty.StringVal("169.254.0.0/16"),
|
|
}),
|
|
}),
|
|
})
|
|
if !cfg.RawEquals(wantCfg) {
|
|
t.Errorf("wrong config\ngot: %#v\nwant: %#v", cfg, wantCfg)
|
|
}
|
|
})
|
|
|
|
t.Run("resource 1", func(t *testing.T) {
|
|
r := root.Resources[1]
|
|
if got, want := r.Type, "happycloud_security_group"; got != want {
|
|
t.Errorf("wrong type %q; want %q", got, want)
|
|
}
|
|
if got, want := r.Name, "public"; got != want {
|
|
t.Errorf("wrong type %q; want %q", got, want)
|
|
}
|
|
|
|
cfg, diags := hcldec.Decode(r.Config, securityGroupDecode, nil)
|
|
if len(diags) != 0 {
|
|
t.Errorf("unexpected diagnostics decoding Config")
|
|
for _, diag := range diags {
|
|
t.Logf("- %s", diag)
|
|
}
|
|
return
|
|
}
|
|
wantCfg := cty.ObjectVal(map[string]cty.Value{
|
|
"ingress": cty.ListVal([]cty.Value{
|
|
cty.ObjectVal(map[string]cty.Value{
|
|
"cidr_block": cty.StringVal("0.0.0.0/0"),
|
|
}),
|
|
}),
|
|
})
|
|
if !cfg.RawEquals(wantCfg) {
|
|
t.Errorf("wrong config\ngot: %#v\nwant: %#v", cfg, wantCfg)
|
|
}
|
|
})
|
|
|
|
t.Run("resource 2", func(t *testing.T) {
|
|
r := root.Resources[2]
|
|
if got, want := r.Type, "happycloud_instance"; got != want {
|
|
t.Errorf("wrong type %q; want %q", got, want)
|
|
}
|
|
if got, want := r.Name, "test"; got != want {
|
|
t.Errorf("wrong type %q; want %q", got, want)
|
|
}
|
|
|
|
vars := hcldec.Variables(r.Config, &hcldec.AttrSpec{
|
|
Name: "image_id",
|
|
Type: cty.String,
|
|
})
|
|
if got, want := len(vars), 1; got != want {
|
|
t.Errorf("wrong number of variables in image_id %#v; want %#v", got, want)
|
|
}
|
|
if got, want := vars[0].RootName(), "var"; got != want {
|
|
t.Errorf("wrong image_id variable RootName %#v; want %#v", got, want)
|
|
}
|
|
|
|
ctx := &hcl.EvalContext{
|
|
Variables: map[string]cty.Value{
|
|
"var": cty.ObjectVal(map[string]cty.Value{
|
|
"image_id": cty.StringVal("image-1234"),
|
|
}),
|
|
},
|
|
}
|
|
cfg, diags := hcldec.Decode(r.Config, instanceDecode, ctx)
|
|
if len(diags) != 0 {
|
|
t.Errorf("unexpected diagnostics decoding Config")
|
|
for _, diag := range diags {
|
|
t.Logf("- %s", diag)
|
|
}
|
|
return
|
|
}
|
|
wantCfg := cty.ObjectVal(map[string]cty.Value{
|
|
"instance_type": cty.StringVal("z3.weedy"),
|
|
"image_id": cty.StringVal("image-1234"),
|
|
"tags": cty.MapVal(map[string]cty.Value{
|
|
"Name": cty.StringVal("foo"),
|
|
"Environment": cty.StringVal("prod"),
|
|
}),
|
|
})
|
|
if !cfg.RawEquals(wantCfg) {
|
|
t.Errorf("wrong config\ngot: %#v\nwant: %#v", cfg, wantCfg)
|
|
}
|
|
|
|
exprs, diags := hcl.ExprList(r.DependsOn)
|
|
if len(diags) != 0 {
|
|
t.Errorf("unexpected diagnostics extracting depends_on")
|
|
for _, diag := range diags {
|
|
t.Logf("- %s", diag)
|
|
}
|
|
return
|
|
}
|
|
if got, want := len(exprs), 1; got != want {
|
|
t.Errorf("wrong number of depends_on exprs %#v; want %#v", got, want)
|
|
}
|
|
|
|
traversal, diags := hcl.AbsTraversalForExpr(exprs[0])
|
|
if len(diags) != 0 {
|
|
t.Errorf("unexpected diagnostics decoding depends_on[0]")
|
|
for _, diag := range diags {
|
|
t.Logf("- %s", diag)
|
|
}
|
|
return
|
|
}
|
|
if got, want := len(traversal), 2; got != want {
|
|
t.Errorf("wrong number of depends_on traversal steps %#v; want %#v", got, want)
|
|
}
|
|
if got, want := traversal.RootName(), "happycloud_security_group"; got != want {
|
|
t.Errorf("wrong depends_on traversal RootName %#v; want %#v", got, want)
|
|
}
|
|
})
|
|
|
|
t.Run("module", func(t *testing.T) {
|
|
if got, want := len(root.Modules), 1; got != want {
|
|
t.Fatalf("wrong number of Modules %d; want %d", got, want)
|
|
}
|
|
mod := root.Modules[0]
|
|
if got, want := mod.Name, "foo"; got != want {
|
|
t.Errorf("wrong module name %q; want %q", got, want)
|
|
}
|
|
|
|
pExpr := mod.Providers
|
|
pairs, diags := hcl.ExprMap(pExpr)
|
|
if len(diags) != 0 {
|
|
t.Errorf("unexpected diagnostics extracting providers")
|
|
for _, diag := range diags {
|
|
t.Logf("- %s", diag)
|
|
}
|
|
}
|
|
if got, want := len(pairs), 1; got != want {
|
|
t.Fatalf("wrong number of key/value pairs in providers %d; want %d", got, want)
|
|
}
|
|
|
|
pair := pairs[0]
|
|
kt, diags := hcl.AbsTraversalForExpr(pair.Key)
|
|
if len(diags) != 0 {
|
|
t.Errorf("unexpected diagnostics extracting providers key %#v", pair.Key)
|
|
for _, diag := range diags {
|
|
t.Logf("- %s", diag)
|
|
}
|
|
}
|
|
vt, diags := hcl.AbsTraversalForExpr(pair.Value)
|
|
if len(diags) != 0 {
|
|
t.Errorf("unexpected diagnostics extracting providers value %#v", pair.Value)
|
|
for _, diag := range diags {
|
|
t.Logf("- %s", diag)
|
|
}
|
|
}
|
|
|
|
if got, want := len(kt), 1; got != want {
|
|
t.Fatalf("wrong number of key traversal steps %d; want %d", got, want)
|
|
}
|
|
if got, want := len(vt), 2; got != want {
|
|
t.Fatalf("wrong number of value traversal steps %d; want %d", got, want)
|
|
}
|
|
|
|
if got, want := kt.RootName(), "null"; got != want {
|
|
t.Errorf("wrong number key traversal root %s; want %s", got, want)
|
|
}
|
|
if got, want := vt.RootName(), "null"; got != want {
|
|
t.Errorf("wrong number value traversal root %s; want %s", got, want)
|
|
}
|
|
if at, ok := vt[1].(hcl.TraverseAttr); ok {
|
|
if got, want := at.Name, "foo"; got != want {
|
|
t.Errorf("wrong number value traversal attribute name %s; want %s", got, want)
|
|
}
|
|
} else {
|
|
t.Errorf("wrong value traversal [1] type %T; want hcl.TraverseAttr", vt[1])
|
|
}
|
|
})
|
|
})
|
|
}
|
|
}
|
|
|
|
const terraformLikeNativeSyntax = `
|
|
|
|
variable "image_id" {
|
|
}
|
|
|
|
resource "happycloud_instance" "test" {
|
|
instance_type = "z3.weedy"
|
|
image_id = var.image_id
|
|
|
|
tags = {
|
|
"Name" = "foo"
|
|
"${"Environment"}" = "prod"
|
|
}
|
|
|
|
depends_on = [
|
|
happycloud_security_group.public,
|
|
]
|
|
}
|
|
|
|
resource "happycloud_security_group" "public" {
|
|
ingress {
|
|
cidr_block = "0.0.0.0/0"
|
|
}
|
|
}
|
|
|
|
resource "happycloud_security_group" "private" {
|
|
ingress {
|
|
cidr_block = "10.0.0.0/8"
|
|
}
|
|
ingress {
|
|
cidr_block = "192.168.0.0/16"
|
|
}
|
|
dynamic "ingress" {
|
|
for_each = var.extra_private_cidr_blocks
|
|
content {
|
|
cidr_block = ingress.value
|
|
}
|
|
}
|
|
}
|
|
|
|
module "foo" {
|
|
providers = {
|
|
null = null.foo
|
|
}
|
|
}
|
|
|
|
`
|
|
|
|
const terraformLikeJSON = `
|
|
{
|
|
"variable": {
|
|
"image_id": {}
|
|
},
|
|
"resource": {
|
|
"happycloud_instance": {
|
|
"test": {
|
|
"instance_type": "z3.weedy",
|
|
"image_id": "${var.image_id}",
|
|
"tags": {
|
|
"Name": "foo",
|
|
"${\"Environment\"}": "prod"
|
|
},
|
|
"depends_on": [
|
|
"happycloud_security_group.public"
|
|
]
|
|
}
|
|
},
|
|
"happycloud_security_group": {
|
|
"public": {
|
|
"ingress": {
|
|
"cidr_block": "0.0.0.0/0"
|
|
}
|
|
},
|
|
"private": {
|
|
"ingress": [
|
|
{
|
|
"cidr_block": "10.0.0.0/8"
|
|
},
|
|
{
|
|
"cidr_block": "192.168.0.0/16"
|
|
}
|
|
],
|
|
"dynamic": {
|
|
"ingress": {
|
|
"for_each": "${var.extra_private_cidr_blocks}",
|
|
"iterator": "block",
|
|
"content": {
|
|
"cidr_block": "${block.value}"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
},
|
|
"module": {
|
|
"foo": {
|
|
"providers": {
|
|
"null": "null.foo"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
`
|