terraform/config/raw_config_test.go

199 lines
3.6 KiB
Go
Raw Normal View History

package config
2014-06-13 02:24:55 +02:00
import (
"encoding/gob"
2014-06-13 02:24:55 +02:00
"reflect"
"testing"
2015-01-14 19:40:43 +01:00
"github.com/hashicorp/terraform/config/lang/ast"
2014-06-13 02:24:55 +02:00
)
func TestNewRawConfig(t *testing.T) {
raw := map[string]interface{}{
"foo": "${var.bar}",
"bar": `${file("boom.txt")}`,
2014-06-13 02:24:55 +02:00
}
rc, err := NewRawConfig(raw)
if err != nil {
t.Fatalf("err: %s", err)
}
if len(rc.Interpolations) != 2 {
t.Fatalf("bad: %#v", rc.Interpolations)
}
2014-06-13 02:24:55 +02:00
if len(rc.Variables) != 1 {
t.Fatalf("bad: %#v", rc.Variables)
}
}
func TestRawConfig(t *testing.T) {
raw := map[string]interface{}{
"foo": "${var.bar}",
}
rc, err := NewRawConfig(raw)
if err != nil {
t.Fatalf("err: %s", err)
}
// Before interpolate, Config() should be the raw
if !reflect.DeepEqual(rc.Config(), raw) {
t.Fatalf("bad: %#v", rc.Config())
}
2015-01-15 07:01:42 +01:00
vars := map[string]ast.Variable{
"var.bar": ast.Variable{
2015-01-14 19:40:43 +01:00
Value: "baz",
Type: ast.TypeString,
},
}
2014-06-13 02:24:55 +02:00
if err := rc.Interpolate(vars); err != nil {
t.Fatalf("err: %s", err)
}
actual := rc.Config()
expected := map[string]interface{}{
"foo": "baz",
}
if !reflect.DeepEqual(actual, expected) {
t.Fatalf("bad: %#v", actual)
}
if len(rc.UnknownKeys()) != 0 {
t.Fatalf("bad: %#v", rc.UnknownKeys())
}
}
2014-06-13 02:26:05 +02:00
func TestRawConfig_double(t *testing.T) {
raw := map[string]interface{}{
"foo": "${var.bar}",
}
rc, err := NewRawConfig(raw)
if err != nil {
t.Fatalf("err: %s", err)
}
2015-01-15 07:01:42 +01:00
vars := map[string]ast.Variable{
"var.bar": ast.Variable{
2015-01-14 19:40:43 +01:00
Value: "baz",
Type: ast.TypeString,
},
}
2014-06-13 02:26:05 +02:00
if err := rc.Interpolate(vars); err != nil {
t.Fatalf("err: %s", err)
}
actual := rc.Config()
expected := map[string]interface{}{
"foo": "baz",
}
if !reflect.DeepEqual(actual, expected) {
t.Fatalf("bad: %#v", actual)
}
2015-01-15 07:01:42 +01:00
vars = map[string]ast.Variable{
"var.bar": ast.Variable{
2015-01-14 19:40:43 +01:00
Value: "what",
Type: ast.TypeString,
},
}
2014-06-13 02:26:05 +02:00
if err := rc.Interpolate(vars); err != nil {
t.Fatalf("err: %s", err)
}
actual = rc.Config()
expected = map[string]interface{}{
"foo": "what",
}
if !reflect.DeepEqual(actual, expected) {
t.Fatalf("bad: %#v", actual)
}
}
2015-01-14 19:40:43 +01:00
func TestRawConfig_syntax(t *testing.T) {
raw := map[string]interface{}{
"foo": "${var",
}
if _, err := NewRawConfig(raw); err == nil {
t.Fatal("should error")
}
}
2014-06-13 02:24:55 +02:00
func TestRawConfig_unknown(t *testing.T) {
raw := map[string]interface{}{
"foo": "${var.bar}",
}
rc, err := NewRawConfig(raw)
if err != nil {
t.Fatalf("err: %s", err)
}
2015-01-15 07:01:42 +01:00
vars := map[string]ast.Variable{
"var.bar": ast.Variable{
2015-01-14 19:40:43 +01:00
Value: UnknownVariableValue,
Type: ast.TypeString,
},
}
2014-06-13 02:24:55 +02:00
if err := rc.Interpolate(vars); err != nil {
t.Fatalf("err: %s", err)
}
actual := rc.Config()
expected := map[string]interface{}{}
if !reflect.DeepEqual(actual, expected) {
t.Fatalf("bad: %#v", actual)
}
expectedKeys := []string{"foo"}
if !reflect.DeepEqual(rc.UnknownKeys(), expectedKeys) {
t.Fatalf("bad: %#v", rc.UnknownKeys())
}
}
func TestRawConfigValue(t *testing.T) {
raw := map[string]interface{}{
"foo": "${var.bar}",
}
rc, err := NewRawConfig(raw)
if err != nil {
t.Fatalf("err: %s", err)
}
rc.Key = ""
if rc.Value() != nil {
t.Fatalf("bad: %#v", rc.Value())
}
rc.Key = "foo"
if rc.Value() != "${var.bar}" {
t.Fatalf("err: %#v", rc.Value())
}
2015-01-15 07:01:42 +01:00
vars := map[string]ast.Variable{
"var.bar": ast.Variable{
2015-01-14 19:40:43 +01:00
Value: "baz",
Type: ast.TypeString,
},
}
if err := rc.Interpolate(vars); err != nil {
t.Fatalf("err: %s", err)
}
if rc.Value() != "baz" {
t.Fatalf("bad: %#v", rc.Value())
}
}
func TestRawConfig_implGob(t *testing.T) {
var _ gob.GobDecoder = new(RawConfig)
var _ gob.GobEncoder = new(RawConfig)
}