2469 lines
43 KiB
Go
2469 lines
43 KiB
Go
package config
|
|
|
|
import (
|
|
"fmt"
|
|
"io/ioutil"
|
|
"os"
|
|
"reflect"
|
|
"testing"
|
|
"time"
|
|
|
|
"path/filepath"
|
|
|
|
"github.com/hashicorp/hil"
|
|
"github.com/hashicorp/hil/ast"
|
|
"github.com/mitchellh/go-homedir"
|
|
"golang.org/x/crypto/bcrypt"
|
|
)
|
|
|
|
func TestInterpolateFuncZipMap(t *testing.T) {
|
|
testFunction(t, testFunctionConfig{
|
|
Cases: []testFunctionCase{
|
|
{
|
|
`${zipmap(var.list, var.list2)}`,
|
|
map[string]interface{}{
|
|
"Hello": "bar",
|
|
"World": "baz",
|
|
},
|
|
false,
|
|
},
|
|
{
|
|
`${zipmap(var.list, var.nonstrings)}`,
|
|
map[string]interface{}{
|
|
"Hello": []interface{}{"bar", "baz"},
|
|
"World": []interface{}{"boo", "foo"},
|
|
},
|
|
false,
|
|
},
|
|
{
|
|
`${zipmap(var.nonstrings, var.list2)}`,
|
|
nil,
|
|
true,
|
|
},
|
|
{
|
|
`${zipmap(var.list, var.differentlengthlist)}`,
|
|
nil,
|
|
true,
|
|
},
|
|
},
|
|
Vars: map[string]ast.Variable{
|
|
"var.list": {
|
|
Type: ast.TypeList,
|
|
Value: []ast.Variable{
|
|
{
|
|
Type: ast.TypeString,
|
|
Value: "Hello",
|
|
},
|
|
{
|
|
Type: ast.TypeString,
|
|
Value: "World",
|
|
},
|
|
},
|
|
},
|
|
"var.list2": {
|
|
Type: ast.TypeList,
|
|
Value: []ast.Variable{
|
|
{
|
|
Type: ast.TypeString,
|
|
Value: "bar",
|
|
},
|
|
{
|
|
Type: ast.TypeString,
|
|
Value: "baz",
|
|
},
|
|
},
|
|
},
|
|
"var.differentlengthlist": {
|
|
Type: ast.TypeList,
|
|
Value: []ast.Variable{
|
|
{
|
|
Type: ast.TypeString,
|
|
Value: "bar",
|
|
},
|
|
{
|
|
Type: ast.TypeString,
|
|
Value: "baz",
|
|
},
|
|
{
|
|
Type: ast.TypeString,
|
|
Value: "boo",
|
|
},
|
|
},
|
|
},
|
|
"var.nonstrings": {
|
|
Type: ast.TypeList,
|
|
Value: []ast.Variable{
|
|
{
|
|
Type: ast.TypeList,
|
|
Value: []ast.Variable{
|
|
{
|
|
Type: ast.TypeString,
|
|
Value: "bar",
|
|
},
|
|
{
|
|
Type: ast.TypeString,
|
|
Value: "baz",
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Type: ast.TypeList,
|
|
Value: []ast.Variable{
|
|
{
|
|
Type: ast.TypeString,
|
|
Value: "boo",
|
|
},
|
|
{
|
|
Type: ast.TypeString,
|
|
Value: "foo",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
})
|
|
}
|
|
|
|
func TestInterpolateFuncList(t *testing.T) {
|
|
testFunction(t, testFunctionConfig{
|
|
Cases: []testFunctionCase{
|
|
// empty input returns empty list
|
|
{
|
|
`${list()}`,
|
|
[]interface{}{},
|
|
false,
|
|
},
|
|
|
|
// single input returns list of length 1
|
|
{
|
|
`${list("hello")}`,
|
|
[]interface{}{"hello"},
|
|
false,
|
|
},
|
|
|
|
// two inputs returns list of length 2
|
|
{
|
|
`${list("hello", "world")}`,
|
|
[]interface{}{"hello", "world"},
|
|
false,
|
|
},
|
|
|
|
// not a string input gives error
|
|
{
|
|
`${list("hello", 42)}`,
|
|
nil,
|
|
true,
|
|
},
|
|
|
|
// list of lists
|
|
{
|
|
`${list("${var.list}", "${var.list2}")}`,
|
|
[]interface{}{[]interface{}{"Hello", "World"}, []interface{}{"bar", "baz"}},
|
|
false,
|
|
},
|
|
|
|
// list of maps
|
|
{
|
|
`${list("${var.map}", "${var.map2}")}`,
|
|
[]interface{}{map[string]interface{}{"key": "bar"}, map[string]interface{}{"key2": "baz"}},
|
|
false,
|
|
},
|
|
|
|
// error on a heterogeneous list
|
|
{
|
|
`${list("first", "${var.list}")}`,
|
|
nil,
|
|
true,
|
|
},
|
|
},
|
|
Vars: map[string]ast.Variable{
|
|
"var.list": {
|
|
Type: ast.TypeList,
|
|
Value: []ast.Variable{
|
|
{
|
|
Type: ast.TypeString,
|
|
Value: "Hello",
|
|
},
|
|
{
|
|
Type: ast.TypeString,
|
|
Value: "World",
|
|
},
|
|
},
|
|
},
|
|
"var.list2": {
|
|
Type: ast.TypeList,
|
|
Value: []ast.Variable{
|
|
{
|
|
Type: ast.TypeString,
|
|
Value: "bar",
|
|
},
|
|
{
|
|
Type: ast.TypeString,
|
|
Value: "baz",
|
|
},
|
|
},
|
|
},
|
|
|
|
"var.map": {
|
|
Type: ast.TypeMap,
|
|
Value: map[string]ast.Variable{
|
|
"key": {
|
|
Type: ast.TypeString,
|
|
Value: "bar",
|
|
},
|
|
},
|
|
},
|
|
"var.map2": {
|
|
Type: ast.TypeMap,
|
|
Value: map[string]ast.Variable{
|
|
"key2": {
|
|
Type: ast.TypeString,
|
|
Value: "baz",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
})
|
|
}
|
|
|
|
func TestInterpolateFuncMax(t *testing.T) {
|
|
testFunction(t, testFunctionConfig{
|
|
Cases: []testFunctionCase{
|
|
{
|
|
`${max()}`,
|
|
nil,
|
|
true,
|
|
},
|
|
|
|
{
|
|
`${max("")}`,
|
|
nil,
|
|
true,
|
|
},
|
|
|
|
{
|
|
`${max(-1, 0, 1)}`,
|
|
"1",
|
|
false,
|
|
},
|
|
|
|
{
|
|
`${max(1, 0, -1)}`,
|
|
"1",
|
|
false,
|
|
},
|
|
|
|
{
|
|
`${max(-1, -2)}`,
|
|
"-1",
|
|
false,
|
|
},
|
|
|
|
{
|
|
`${max(-1)}`,
|
|
"-1",
|
|
false,
|
|
},
|
|
},
|
|
})
|
|
}
|
|
|
|
func TestInterpolateFuncMin(t *testing.T) {
|
|
testFunction(t, testFunctionConfig{
|
|
Cases: []testFunctionCase{
|
|
{
|
|
`${min()}`,
|
|
nil,
|
|
true,
|
|
},
|
|
|
|
{
|
|
`${min("")}`,
|
|
nil,
|
|
true,
|
|
},
|
|
|
|
{
|
|
`${min(-1, 0, 1)}`,
|
|
"-1",
|
|
false,
|
|
},
|
|
|
|
{
|
|
`${min(1, 0, -1)}`,
|
|
"-1",
|
|
false,
|
|
},
|
|
|
|
{
|
|
`${min(-1, -2)}`,
|
|
"-2",
|
|
false,
|
|
},
|
|
|
|
{
|
|
`${min(-1)}`,
|
|
"-1",
|
|
false,
|
|
},
|
|
},
|
|
})
|
|
}
|
|
|
|
func TestInterpolateFuncPow(t *testing.T) {
|
|
testFunction(t, testFunctionConfig{
|
|
Cases: []testFunctionCase{
|
|
{
|
|
`${pow(1, 0)}`,
|
|
"1",
|
|
false,
|
|
},
|
|
{
|
|
`${pow(1, 1)}`,
|
|
"1",
|
|
false,
|
|
},
|
|
|
|
{
|
|
`${pow(2, 0)}`,
|
|
"1",
|
|
false,
|
|
},
|
|
{
|
|
`${pow(2, 1)}`,
|
|
"2",
|
|
false,
|
|
},
|
|
{
|
|
`${pow(3, 2)}`,
|
|
"9",
|
|
false,
|
|
},
|
|
{
|
|
`${pow(-3, 2)}`,
|
|
"9",
|
|
false,
|
|
},
|
|
{
|
|
`${pow(2, -2)}`,
|
|
"0.25",
|
|
false,
|
|
},
|
|
{
|
|
`${pow(0, 2)}`,
|
|
"0",
|
|
false,
|
|
},
|
|
{
|
|
`${pow("invalid-input", 2)}`,
|
|
nil,
|
|
true,
|
|
},
|
|
{
|
|
`${pow(2, "invalid-input")}`,
|
|
nil,
|
|
true,
|
|
},
|
|
{
|
|
`${pow(2)}`,
|
|
nil,
|
|
true,
|
|
},
|
|
},
|
|
})
|
|
}
|
|
|
|
func TestInterpolateFuncFloor(t *testing.T) {
|
|
testFunction(t, testFunctionConfig{
|
|
Cases: []testFunctionCase{
|
|
{
|
|
`${floor()}`,
|
|
nil,
|
|
true,
|
|
},
|
|
|
|
{
|
|
`${floor("")}`,
|
|
nil,
|
|
true,
|
|
},
|
|
|
|
{
|
|
`${floor("-1.3")}`, // there appears to be a AST bug where the parsed argument ends up being -1 without the "s
|
|
"-2",
|
|
false,
|
|
},
|
|
|
|
{
|
|
`${floor(1.7)}`,
|
|
"1",
|
|
false,
|
|
},
|
|
},
|
|
})
|
|
}
|
|
|
|
func TestInterpolateFuncCeil(t *testing.T) {
|
|
testFunction(t, testFunctionConfig{
|
|
Cases: []testFunctionCase{
|
|
{
|
|
`${ceil()}`,
|
|
nil,
|
|
true,
|
|
},
|
|
|
|
{
|
|
`${ceil("")}`,
|
|
nil,
|
|
true,
|
|
},
|
|
|
|
{
|
|
`${ceil(-1.8)}`,
|
|
"-1",
|
|
false,
|
|
},
|
|
|
|
{
|
|
`${ceil(1.2)}`,
|
|
"2",
|
|
false,
|
|
},
|
|
},
|
|
})
|
|
}
|
|
|
|
func TestInterpolateFuncLog(t *testing.T) {
|
|
testFunction(t, testFunctionConfig{
|
|
Cases: []testFunctionCase{
|
|
{
|
|
`${log(1, 10)}`,
|
|
"0",
|
|
false,
|
|
},
|
|
{
|
|
`${log(10, 10)}`,
|
|
"1",
|
|
false,
|
|
},
|
|
|
|
{
|
|
`${log(0, 10)}`,
|
|
"-Inf",
|
|
false,
|
|
},
|
|
{
|
|
`${log(10, 0)}`,
|
|
"-0",
|
|
false,
|
|
},
|
|
},
|
|
})
|
|
}
|
|
|
|
func TestInterpolateFuncChomp(t *testing.T) {
|
|
testFunction(t, testFunctionConfig{
|
|
Cases: []testFunctionCase{
|
|
{
|
|
`${chomp()}`,
|
|
nil,
|
|
true,
|
|
},
|
|
|
|
{
|
|
`${chomp("hello world")}`,
|
|
"hello world",
|
|
false,
|
|
},
|
|
|
|
{
|
|
fmt.Sprintf(`${chomp("%s")}`, "goodbye\ncruel\nworld"),
|
|
"goodbye\ncruel\nworld",
|
|
false,
|
|
},
|
|
|
|
{
|
|
fmt.Sprintf(`${chomp("%s")}`, "goodbye\r\nwindows\r\nworld"),
|
|
"goodbye\r\nwindows\r\nworld",
|
|
false,
|
|
},
|
|
|
|
{
|
|
fmt.Sprintf(`${chomp("%s")}`, "goodbye\ncruel\nworld\n"),
|
|
"goodbye\ncruel\nworld",
|
|
false,
|
|
},
|
|
|
|
{
|
|
fmt.Sprintf(`${chomp("%s")}`, "goodbye\ncruel\nworld\n\n\n\n"),
|
|
"goodbye\ncruel\nworld",
|
|
false,
|
|
},
|
|
|
|
{
|
|
fmt.Sprintf(`${chomp("%s")}`, "goodbye\r\nwindows\r\nworld\r\n"),
|
|
"goodbye\r\nwindows\r\nworld",
|
|
false,
|
|
},
|
|
|
|
{
|
|
fmt.Sprintf(`${chomp("%s")}`, "goodbye\r\nwindows\r\nworld\r\n\r\n\r\n\r\n"),
|
|
"goodbye\r\nwindows\r\nworld",
|
|
false,
|
|
},
|
|
},
|
|
})
|
|
}
|
|
|
|
func TestInterpolateFuncMap(t *testing.T) {
|
|
testFunction(t, testFunctionConfig{
|
|
Cases: []testFunctionCase{
|
|
// empty input returns empty map
|
|
{
|
|
`${map()}`,
|
|
map[string]interface{}{},
|
|
false,
|
|
},
|
|
|
|
// odd args is error
|
|
{
|
|
`${map("odd")}`,
|
|
nil,
|
|
true,
|
|
},
|
|
|
|
// two args returns map w/ one k/v
|
|
{
|
|
`${map("hello", "world")}`,
|
|
map[string]interface{}{"hello": "world"},
|
|
false,
|
|
},
|
|
|
|
// four args get two k/v
|
|
{
|
|
`${map("hello", "world", "what's", "up?")}`,
|
|
map[string]interface{}{"hello": "world", "what's": "up?"},
|
|
false,
|
|
},
|
|
|
|
// map of lists is okay
|
|
{
|
|
`${map("hello", list("world"), "what's", list("up?"))}`,
|
|
map[string]interface{}{
|
|
"hello": []interface{}{"world"},
|
|
"what's": []interface{}{"up?"},
|
|
},
|
|
false,
|
|
},
|
|
|
|
// map of maps is okay
|
|
{
|
|
`${map("hello", map("there", "world"), "what's", map("really", "up?"))}`,
|
|
map[string]interface{}{
|
|
"hello": map[string]interface{}{"there": "world"},
|
|
"what's": map[string]interface{}{"really": "up?"},
|
|
},
|
|
false,
|
|
},
|
|
|
|
// keys have to be strings
|
|
{
|
|
`${map(list("listkey"), "val")}`,
|
|
nil,
|
|
true,
|
|
},
|
|
|
|
// types have to match
|
|
{
|
|
`${map("some", "strings", "also", list("lists"))}`,
|
|
nil,
|
|
true,
|
|
},
|
|
|
|
// duplicate keys are an error
|
|
{
|
|
`${map("key", "val", "key", "again")}`,
|
|
nil,
|
|
true,
|
|
},
|
|
},
|
|
})
|
|
}
|
|
|
|
func TestInterpolateFuncCompact(t *testing.T) {
|
|
testFunction(t, testFunctionConfig{
|
|
Cases: []testFunctionCase{
|
|
// empty string within array
|
|
{
|
|
`${compact(split(",", "a,,b"))}`,
|
|
[]interface{}{"a", "b"},
|
|
false,
|
|
},
|
|
|
|
// empty string at the end of array
|
|
{
|
|
`${compact(split(",", "a,b,"))}`,
|
|
[]interface{}{"a", "b"},
|
|
false,
|
|
},
|
|
|
|
// single empty string
|
|
{
|
|
`${compact(split(",", ""))}`,
|
|
[]interface{}{},
|
|
false,
|
|
},
|
|
|
|
// errrors on list of lists
|
|
{
|
|
`${compact(list(list("a"), list("b")))}`,
|
|
nil,
|
|
true,
|
|
},
|
|
},
|
|
})
|
|
}
|
|
|
|
func TestInterpolateFuncCidrHost(t *testing.T) {
|
|
testFunction(t, testFunctionConfig{
|
|
Cases: []testFunctionCase{
|
|
{
|
|
`${cidrhost("192.168.1.0/24", 5)}`,
|
|
"192.168.1.5",
|
|
false,
|
|
},
|
|
{
|
|
`${cidrhost("192.168.1.0/24", -5)}`,
|
|
"192.168.1.251",
|
|
false,
|
|
},
|
|
{
|
|
`${cidrhost("192.168.1.0/24", -256)}`,
|
|
"192.168.1.0",
|
|
false,
|
|
},
|
|
{
|
|
`${cidrhost("192.168.1.0/30", 255)}`,
|
|
nil,
|
|
true, // 255 doesn't fit in two bits
|
|
},
|
|
{
|
|
`${cidrhost("192.168.1.0/30", -255)}`,
|
|
nil,
|
|
true, // 255 doesn't fit in two bits
|
|
},
|
|
{
|
|
`${cidrhost("not-a-cidr", 6)}`,
|
|
nil,
|
|
true, // not a valid CIDR mask
|
|
},
|
|
{
|
|
`${cidrhost("10.256.0.0/8", 6)}`,
|
|
nil,
|
|
true, // can't have an octet >255
|
|
},
|
|
},
|
|
})
|
|
}
|
|
|
|
func TestInterpolateFuncCidrNetmask(t *testing.T) {
|
|
testFunction(t, testFunctionConfig{
|
|
Cases: []testFunctionCase{
|
|
{
|
|
`${cidrnetmask("192.168.1.0/24")}`,
|
|
"255.255.255.0",
|
|
false,
|
|
},
|
|
{
|
|
`${cidrnetmask("192.168.1.0/32")}`,
|
|
"255.255.255.255",
|
|
false,
|
|
},
|
|
{
|
|
`${cidrnetmask("0.0.0.0/0")}`,
|
|
"0.0.0.0",
|
|
false,
|
|
},
|
|
{
|
|
// This doesn't really make sense for IPv6 networks
|
|
// but it ought to do something sensible anyway.
|
|
`${cidrnetmask("1::/64")}`,
|
|
"ffff:ffff:ffff:ffff::",
|
|
false,
|
|
},
|
|
{
|
|
`${cidrnetmask("not-a-cidr")}`,
|
|
nil,
|
|
true, // not a valid CIDR mask
|
|
},
|
|
{
|
|
`${cidrnetmask("10.256.0.0/8")}`,
|
|
nil,
|
|
true, // can't have an octet >255
|
|
},
|
|
},
|
|
})
|
|
}
|
|
|
|
func TestInterpolateFuncCidrSubnet(t *testing.T) {
|
|
testFunction(t, testFunctionConfig{
|
|
Cases: []testFunctionCase{
|
|
{
|
|
`${cidrsubnet("192.168.2.0/20", 4, 6)}`,
|
|
"192.168.6.0/24",
|
|
false,
|
|
},
|
|
{
|
|
`${cidrsubnet("fe80::/48", 16, 6)}`,
|
|
"fe80:0:0:6::/64",
|
|
false,
|
|
},
|
|
{
|
|
// IPv4 address encoded in IPv6 syntax gets normalized
|
|
`${cidrsubnet("::ffff:192.168.0.0/112", 8, 6)}`,
|
|
"192.168.6.0/24",
|
|
false,
|
|
},
|
|
{
|
|
`${cidrsubnet("192.168.0.0/30", 4, 6)}`,
|
|
nil,
|
|
true, // not enough bits left
|
|
},
|
|
{
|
|
`${cidrsubnet("192.168.0.0/16", 2, 16)}`,
|
|
nil,
|
|
true, // can't encode 16 in 2 bits
|
|
},
|
|
{
|
|
`${cidrsubnet("not-a-cidr", 4, 6)}`,
|
|
nil,
|
|
true, // not a valid CIDR mask
|
|
},
|
|
{
|
|
`${cidrsubnet("10.256.0.0/8", 4, 6)}`,
|
|
nil,
|
|
true, // can't have an octet >255
|
|
},
|
|
},
|
|
})
|
|
}
|
|
|
|
func TestInterpolateFuncCoalesce(t *testing.T) {
|
|
testFunction(t, testFunctionConfig{
|
|
Cases: []testFunctionCase{
|
|
{
|
|
`${coalesce("first", "second", "third")}`,
|
|
"first",
|
|
false,
|
|
},
|
|
{
|
|
`${coalesce("", "second", "third")}`,
|
|
"second",
|
|
false,
|
|
},
|
|
{
|
|
`${coalesce("", "", "")}`,
|
|
"",
|
|
false,
|
|
},
|
|
{
|
|
`${coalesce("foo")}`,
|
|
nil,
|
|
true,
|
|
},
|
|
},
|
|
})
|
|
}
|
|
|
|
func TestInterpolateFuncCoalesceList(t *testing.T) {
|
|
testFunction(t, testFunctionConfig{
|
|
Cases: []testFunctionCase{
|
|
{
|
|
`${coalescelist(list("first"), list("second"), list("third"))}`,
|
|
[]interface{}{"first"},
|
|
false,
|
|
},
|
|
{
|
|
`${coalescelist(list(), list("second"), list("third"))}`,
|
|
[]interface{}{"second"},
|
|
false,
|
|
},
|
|
{
|
|
`${coalescelist(list(), list(), list())}`,
|
|
[]interface{}{},
|
|
false,
|
|
},
|
|
{
|
|
`${coalescelist(list("foo"))}`,
|
|
nil,
|
|
true,
|
|
},
|
|
},
|
|
})
|
|
}
|
|
|
|
func TestInterpolateFuncConcat(t *testing.T) {
|
|
testFunction(t, testFunctionConfig{
|
|
Cases: []testFunctionCase{
|
|
// String + list
|
|
// no longer supported, now returns an error
|
|
{
|
|
`${concat("a", split(",", "b,c"))}`,
|
|
nil,
|
|
true,
|
|
},
|
|
|
|
// List + string
|
|
// no longer supported, now returns an error
|
|
{
|
|
`${concat(split(",", "a,b"), "c")}`,
|
|
nil,
|
|
true,
|
|
},
|
|
|
|
// Single list
|
|
{
|
|
`${concat(split(",", ",foo,"))}`,
|
|
[]interface{}{"", "foo", ""},
|
|
false,
|
|
},
|
|
{
|
|
`${concat(split(",", "a,b,c"))}`,
|
|
[]interface{}{"a", "b", "c"},
|
|
false,
|
|
},
|
|
|
|
// Two lists
|
|
{
|
|
`${concat(split(",", "a,b,c"), split(",", "d,e"))}`,
|
|
[]interface{}{"a", "b", "c", "d", "e"},
|
|
false,
|
|
},
|
|
// Two lists with different separators
|
|
{
|
|
`${concat(split(",", "a,b,c"), split(" ", "d e"))}`,
|
|
[]interface{}{"a", "b", "c", "d", "e"},
|
|
false,
|
|
},
|
|
|
|
// More lists
|
|
{
|
|
`${concat(split(",", "a,b"), split(",", "c,d"), split(",", "e,f"), split(",", "0,1"))}`,
|
|
[]interface{}{"a", "b", "c", "d", "e", "f", "0", "1"},
|
|
false,
|
|
},
|
|
|
|
// list vars
|
|
{
|
|
`${concat("${var.list}", "${var.list}")}`,
|
|
[]interface{}{"a", "b", "a", "b"},
|
|
false,
|
|
},
|
|
// lists of lists
|
|
{
|
|
`${concat("${var.lists}", "${var.lists}")}`,
|
|
[]interface{}{[]interface{}{"c", "d"}, []interface{}{"c", "d"}},
|
|
false,
|
|
},
|
|
|
|
// lists of maps
|
|
{
|
|
`${concat("${var.maps}", "${var.maps}")}`,
|
|
[]interface{}{map[string]interface{}{"key1": "a", "key2": "b"}, map[string]interface{}{"key1": "a", "key2": "b"}},
|
|
false,
|
|
},
|
|
|
|
// multiple strings
|
|
// no longer supported, now returns an error
|
|
{
|
|
`${concat("string1", "string2")}`,
|
|
nil,
|
|
true,
|
|
},
|
|
|
|
// mismatched types
|
|
{
|
|
`${concat("${var.lists}", "${var.maps}")}`,
|
|
nil,
|
|
true,
|
|
},
|
|
},
|
|
Vars: map[string]ast.Variable{
|
|
"var.list": {
|
|
Type: ast.TypeList,
|
|
Value: []ast.Variable{
|
|
{
|
|
Type: ast.TypeString,
|
|
Value: "a",
|
|
},
|
|
{
|
|
Type: ast.TypeString,
|
|
Value: "b",
|
|
},
|
|
},
|
|
},
|
|
"var.lists": {
|
|
Type: ast.TypeList,
|
|
Value: []ast.Variable{
|
|
{
|
|
Type: ast.TypeList,
|
|
Value: []ast.Variable{
|
|
{
|
|
Type: ast.TypeString,
|
|
Value: "c",
|
|
},
|
|
{
|
|
Type: ast.TypeString,
|
|
Value: "d",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
"var.maps": {
|
|
Type: ast.TypeList,
|
|
Value: []ast.Variable{
|
|
{
|
|
Type: ast.TypeMap,
|
|
Value: map[string]ast.Variable{
|
|
"key1": {
|
|
Type: ast.TypeString,
|
|
Value: "a",
|
|
},
|
|
"key2": {
|
|
Type: ast.TypeString,
|
|
Value: "b",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
})
|
|
}
|
|
|
|
func TestInterpolateFuncMerge(t *testing.T) {
|
|
testFunction(t, testFunctionConfig{
|
|
Cases: []testFunctionCase{
|
|
// basic merge
|
|
{
|
|
`${merge(map("a", "b"), map("c", "d"))}`,
|
|
map[string]interface{}{"a": "b", "c": "d"},
|
|
false,
|
|
},
|
|
|
|
// merge with conflicts is ok, last in wins.
|
|
{
|
|
`${merge(map("a", "b", "c", "X"), map("c", "d"))}`,
|
|
map[string]interface{}{"a": "b", "c": "d"},
|
|
false,
|
|
},
|
|
|
|
// merge variadic
|
|
{
|
|
`${merge(map("a", "b"), map("c", "d"), map("e", "f"))}`,
|
|
map[string]interface{}{"a": "b", "c": "d", "e": "f"},
|
|
false,
|
|
},
|
|
|
|
// merge with variables
|
|
{
|
|
`${merge(var.maps[0], map("c", "d"))}`,
|
|
map[string]interface{}{"key1": "a", "key2": "b", "c": "d"},
|
|
false,
|
|
},
|
|
|
|
// only accept maps
|
|
{
|
|
`${merge(map("a", "b"), list("c", "d"))}`,
|
|
nil,
|
|
true,
|
|
},
|
|
|
|
// merge maps of maps
|
|
{
|
|
`${merge(map("a", var.maps[0]), map("b", var.maps[1]))}`,
|
|
map[string]interface{}{
|
|
"b": map[string]interface{}{"key3": "d", "key4": "c"},
|
|
"a": map[string]interface{}{"key1": "a", "key2": "b"},
|
|
},
|
|
false,
|
|
},
|
|
// merge maps of lists
|
|
{
|
|
`${merge(map("a", list("b")), map("c", list("d", "e")))}`,
|
|
map[string]interface{}{"a": []interface{}{"b"}, "c": []interface{}{"d", "e"}},
|
|
false,
|
|
},
|
|
// merge map of various kinds
|
|
{
|
|
`${merge(map("a", var.maps[0]), map("b", list("c", "d")))}`,
|
|
map[string]interface{}{"a": map[string]interface{}{"key1": "a", "key2": "b"}, "b": []interface{}{"c", "d"}},
|
|
false,
|
|
},
|
|
},
|
|
Vars: map[string]ast.Variable{
|
|
"var.maps": {
|
|
Type: ast.TypeList,
|
|
Value: []ast.Variable{
|
|
{
|
|
Type: ast.TypeMap,
|
|
Value: map[string]ast.Variable{
|
|
"key1": {
|
|
Type: ast.TypeString,
|
|
Value: "a",
|
|
},
|
|
"key2": {
|
|
Type: ast.TypeString,
|
|
Value: "b",
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Type: ast.TypeMap,
|
|
Value: map[string]ast.Variable{
|
|
"key3": {
|
|
Type: ast.TypeString,
|
|
Value: "d",
|
|
},
|
|
"key4": {
|
|
Type: ast.TypeString,
|
|
Value: "c",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
})
|
|
|
|
}
|
|
|
|
func TestInterpolateFuncDirname(t *testing.T) {
|
|
testFunction(t, testFunctionConfig{
|
|
Cases: []testFunctionCase{
|
|
{
|
|
`${dirname("/foo/bar/baz")}`,
|
|
"/foo/bar",
|
|
false,
|
|
},
|
|
},
|
|
})
|
|
}
|
|
|
|
func TestInterpolateFuncDistinct(t *testing.T) {
|
|
testFunction(t, testFunctionConfig{
|
|
Cases: []testFunctionCase{
|
|
// 3 duplicates
|
|
{
|
|
`${distinct(concat(split(",", "user1,user2,user3"), split(",", "user1,user2,user3")))}`,
|
|
[]interface{}{"user1", "user2", "user3"},
|
|
false,
|
|
},
|
|
// 1 duplicate
|
|
{
|
|
`${distinct(concat(split(",", "user1,user2,user3"), split(",", "user1,user4")))}`,
|
|
[]interface{}{"user1", "user2", "user3", "user4"},
|
|
false,
|
|
},
|
|
// too many args
|
|
{
|
|
`${distinct(concat(split(",", "user1,user2,user3"), split(",", "user1,user4")), "foo")}`,
|
|
nil,
|
|
true,
|
|
},
|
|
// non-flat list is an error
|
|
{
|
|
`${distinct(list(list("a"), list("a")))}`,
|
|
nil,
|
|
true,
|
|
},
|
|
},
|
|
})
|
|
}
|
|
|
|
func TestInterpolateFuncMatchKeys(t *testing.T) {
|
|
testFunction(t, testFunctionConfig{
|
|
Cases: []testFunctionCase{
|
|
// normal usage
|
|
{
|
|
`${matchkeys(list("a", "b", "c"), list("ref1", "ref2", "ref3"), list("ref2"))}`,
|
|
[]interface{}{"b"},
|
|
false,
|
|
},
|
|
// normal usage 2, check the order
|
|
{
|
|
`${matchkeys(list("a", "b", "c"), list("ref1", "ref2", "ref3"), list("ref2", "ref1"))}`,
|
|
[]interface{}{"a", "b"},
|
|
false,
|
|
},
|
|
// duplicate item in searchset
|
|
{
|
|
`${matchkeys(list("a", "b", "c"), list("ref1", "ref2", "ref3"), list("ref2", "ref2"))}`,
|
|
[]interface{}{"b"},
|
|
false,
|
|
},
|
|
// no matches
|
|
{
|
|
`${matchkeys(list("a", "b", "c"), list("ref1", "ref2", "ref3"), list("ref4"))}`,
|
|
[]interface{}{},
|
|
false,
|
|
},
|
|
// no matches 2
|
|
{
|
|
`${matchkeys(list("a", "b", "c"), list("ref1", "ref2", "ref3"), list())}`,
|
|
[]interface{}{},
|
|
false,
|
|
},
|
|
// zero case
|
|
{
|
|
`${matchkeys(list(), list(), list("nope"))}`,
|
|
[]interface{}{},
|
|
false,
|
|
},
|
|
// complex values
|
|
{
|
|
`${matchkeys(list(list("a", "a")), list("a"), list("a"))}`,
|
|
[]interface{}{[]interface{}{"a", "a"}},
|
|
false,
|
|
},
|
|
// errors
|
|
// different types
|
|
{
|
|
`${matchkeys(list("a"), list(1), list("a"))}`,
|
|
nil,
|
|
true,
|
|
},
|
|
// different types
|
|
{
|
|
`${matchkeys(list("a"), list(list("a"), list("a")), list("a"))}`,
|
|
nil,
|
|
true,
|
|
},
|
|
// lists of different length is an error
|
|
{
|
|
`${matchkeys(list("a"), list("a", "b"), list("a"))}`,
|
|
nil,
|
|
true,
|
|
},
|
|
},
|
|
})
|
|
}
|
|
|
|
func TestInterpolateFuncFile(t *testing.T) {
|
|
tf, err := ioutil.TempFile("", "tf")
|
|
if err != nil {
|
|
t.Fatalf("err: %s", err)
|
|
}
|
|
path := tf.Name()
|
|
tf.Write([]byte("foo"))
|
|
tf.Close()
|
|
defer os.Remove(path)
|
|
|
|
testFunction(t, testFunctionConfig{
|
|
Cases: []testFunctionCase{
|
|
{
|
|
fmt.Sprintf(`${file("%s")}`, path),
|
|
"foo",
|
|
false,
|
|
},
|
|
|
|
// Invalid path
|
|
{
|
|
`${file("/i/dont/exist")}`,
|
|
nil,
|
|
true,
|
|
},
|
|
|
|
// Too many args
|
|
{
|
|
`${file("foo", "bar")}`,
|
|
nil,
|
|
true,
|
|
},
|
|
},
|
|
})
|
|
}
|
|
|
|
func TestInterpolateFuncFormat(t *testing.T) {
|
|
testFunction(t, testFunctionConfig{
|
|
Cases: []testFunctionCase{
|
|
{
|
|
`${format("hello")}`,
|
|
"hello",
|
|
false,
|
|
},
|
|
|
|
{
|
|
`${format("hello %s", "world")}`,
|
|
"hello world",
|
|
false,
|
|
},
|
|
|
|
{
|
|
`${format("hello %d", 42)}`,
|
|
"hello 42",
|
|
false,
|
|
},
|
|
|
|
{
|
|
`${format("hello %05d", 42)}`,
|
|
"hello 00042",
|
|
false,
|
|
},
|
|
|
|
{
|
|
`${format("hello %05d", 12345)}`,
|
|
"hello 12345",
|
|
false,
|
|
},
|
|
},
|
|
})
|
|
}
|
|
|
|
func TestInterpolateFuncFormatList(t *testing.T) {
|
|
testFunction(t, testFunctionConfig{
|
|
Cases: []testFunctionCase{
|
|
// formatlist requires at least one list
|
|
{
|
|
`${formatlist("hello")}`,
|
|
nil,
|
|
true,
|
|
},
|
|
{
|
|
`${formatlist("hello %s", "world")}`,
|
|
nil,
|
|
true,
|
|
},
|
|
// formatlist applies to each list element in turn
|
|
{
|
|
`${formatlist("<%s>", split(",", "A,B"))}`,
|
|
[]interface{}{"<A>", "<B>"},
|
|
false,
|
|
},
|
|
// formatlist repeats scalar elements
|
|
{
|
|
`${join(", ", formatlist("%s=%s", "x", split(",", "A,B,C")))}`,
|
|
"x=A, x=B, x=C",
|
|
false,
|
|
},
|
|
// Multiple lists are walked in parallel
|
|
{
|
|
`${join(", ", formatlist("%s=%s", split(",", "A,B,C"), split(",", "1,2,3")))}`,
|
|
"A=1, B=2, C=3",
|
|
false,
|
|
},
|
|
// Mismatched list lengths generate an error
|
|
{
|
|
`${formatlist("%s=%2s", split(",", "A,B,C,D"), split(",", "1,2,3"))}`,
|
|
nil,
|
|
true,
|
|
},
|
|
// Works with lists of length 1 [GH-2240]
|
|
{
|
|
`${formatlist("%s.id", split(",", "demo-rest-elb"))}`,
|
|
[]interface{}{"demo-rest-elb.id"},
|
|
false,
|
|
},
|
|
// Works with empty lists [GH-7607]
|
|
{
|
|
`${formatlist("%s", var.emptylist)}`,
|
|
[]interface{}{},
|
|
false,
|
|
},
|
|
},
|
|
Vars: map[string]ast.Variable{
|
|
"var.emptylist": {
|
|
Type: ast.TypeList,
|
|
Value: []ast.Variable{},
|
|
},
|
|
},
|
|
})
|
|
}
|
|
|
|
func TestInterpolateFuncIndex(t *testing.T) {
|
|
testFunction(t, testFunctionConfig{
|
|
Vars: map[string]ast.Variable{
|
|
"var.list1": interfaceToVariableSwallowError([]string{"notfoo", "stillnotfoo", "bar"}),
|
|
"var.list2": interfaceToVariableSwallowError([]string{"foo"}),
|
|
"var.list3": interfaceToVariableSwallowError([]string{"foo", "spam", "bar", "eggs"}),
|
|
},
|
|
Cases: []testFunctionCase{
|
|
{
|
|
`${index("test", "")}`,
|
|
nil,
|
|
true,
|
|
},
|
|
|
|
{
|
|
`${index(var.list1, "foo")}`,
|
|
nil,
|
|
true,
|
|
},
|
|
|
|
{
|
|
`${index(var.list2, "foo")}`,
|
|
"0",
|
|
false,
|
|
},
|
|
|
|
{
|
|
`${index(var.list3, "bar")}`,
|
|
"2",
|
|
false,
|
|
},
|
|
},
|
|
})
|
|
}
|
|
|
|
func TestInterpolateFuncJoin(t *testing.T) {
|
|
testFunction(t, testFunctionConfig{
|
|
Vars: map[string]ast.Variable{
|
|
"var.a_list": interfaceToVariableSwallowError([]string{"foo"}),
|
|
"var.a_longer_list": interfaceToVariableSwallowError([]string{"foo", "bar", "baz"}),
|
|
"var.list_of_lists": interfaceToVariableSwallowError([]interface{}{[]string{"foo"}, []string{"bar"}, []string{"baz"}}),
|
|
},
|
|
Cases: []testFunctionCase{
|
|
{
|
|
`${join(",")}`,
|
|
nil,
|
|
true,
|
|
},
|
|
|
|
{
|
|
`${join(",", var.a_list)}`,
|
|
"foo",
|
|
false,
|
|
},
|
|
|
|
{
|
|
`${join(".", var.a_longer_list)}`,
|
|
"foo.bar.baz",
|
|
false,
|
|
},
|
|
|
|
{
|
|
`${join(".", var.list_of_lists)}`,
|
|
nil,
|
|
true,
|
|
},
|
|
{
|
|
`${join(".", list(list("nested")))}`,
|
|
nil,
|
|
true,
|
|
},
|
|
},
|
|
})
|
|
}
|
|
|
|
func TestInterpolateFuncJSONEncode(t *testing.T) {
|
|
testFunction(t, testFunctionConfig{
|
|
Vars: map[string]ast.Variable{
|
|
"easy": ast.Variable{
|
|
Value: "test",
|
|
Type: ast.TypeString,
|
|
},
|
|
"hard": ast.Variable{
|
|
Value: " foo \\ \n \t \" bar ",
|
|
Type: ast.TypeString,
|
|
},
|
|
"list": interfaceToVariableSwallowError([]string{"foo", "bar\tbaz"}),
|
|
// XXX can't use InterfaceToVariable as it converts empty slice into empty
|
|
// map.
|
|
"emptylist": ast.Variable{
|
|
Value: []ast.Variable{},
|
|
Type: ast.TypeList,
|
|
},
|
|
"map": interfaceToVariableSwallowError(map[string]string{
|
|
"foo": "bar",
|
|
"ba \n z": "q\\x",
|
|
}),
|
|
"emptymap": interfaceToVariableSwallowError(map[string]string{}),
|
|
|
|
// Not yet supported (but it would be nice)
|
|
"nestedlist": interfaceToVariableSwallowError([][]string{{"foo"}}),
|
|
"nestedmap": interfaceToVariableSwallowError(map[string][]string{"foo": {"bar"}}),
|
|
},
|
|
Cases: []testFunctionCase{
|
|
{
|
|
`${jsonencode("test")}`,
|
|
`"test"`,
|
|
false,
|
|
},
|
|
{
|
|
`${jsonencode(easy)}`,
|
|
`"test"`,
|
|
false,
|
|
},
|
|
{
|
|
`${jsonencode(hard)}`,
|
|
`" foo \\ \n \t \" bar "`,
|
|
false,
|
|
},
|
|
{
|
|
`${jsonencode("")}`,
|
|
`""`,
|
|
false,
|
|
},
|
|
{
|
|
`${jsonencode()}`,
|
|
nil,
|
|
true,
|
|
},
|
|
{
|
|
`${jsonencode(list)}`,
|
|
`["foo","bar\tbaz"]`,
|
|
false,
|
|
},
|
|
{
|
|
`${jsonencode(emptylist)}`,
|
|
`[]`,
|
|
false,
|
|
},
|
|
{
|
|
`${jsonencode(map)}`,
|
|
`{"ba \n z":"q\\x","foo":"bar"}`,
|
|
false,
|
|
},
|
|
{
|
|
`${jsonencode(emptymap)}`,
|
|
`{}`,
|
|
false,
|
|
},
|
|
{
|
|
`${jsonencode(nestedlist)}`,
|
|
nil,
|
|
true,
|
|
},
|
|
{
|
|
`${jsonencode(nestedmap)}`,
|
|
nil,
|
|
true,
|
|
},
|
|
},
|
|
})
|
|
}
|
|
|
|
func TestInterpolateFuncReplace(t *testing.T) {
|
|
testFunction(t, testFunctionConfig{
|
|
Cases: []testFunctionCase{
|
|
// Regular search and replace
|
|
{
|
|
`${replace("hello", "hel", "bel")}`,
|
|
"bello",
|
|
false,
|
|
},
|
|
|
|
// Search string doesn't match
|
|
{
|
|
`${replace("hello", "nope", "bel")}`,
|
|
"hello",
|
|
false,
|
|
},
|
|
|
|
// Regular expression
|
|
{
|
|
`${replace("hello", "/l/", "L")}`,
|
|
"heLLo",
|
|
false,
|
|
},
|
|
|
|
{
|
|
`${replace("helo", "/(l)/", "$1$1")}`,
|
|
"hello",
|
|
false,
|
|
},
|
|
|
|
// Bad regexp
|
|
{
|
|
`${replace("helo", "/(l/", "$1$1")}`,
|
|
nil,
|
|
true,
|
|
},
|
|
},
|
|
})
|
|
}
|
|
|
|
func TestInterpolateFuncLength(t *testing.T) {
|
|
testFunction(t, testFunctionConfig{
|
|
Cases: []testFunctionCase{
|
|
// Raw strings
|
|
{
|
|
`${length("")}`,
|
|
"0",
|
|
false,
|
|
},
|
|
{
|
|
`${length("a")}`,
|
|
"1",
|
|
false,
|
|
},
|
|
{
|
|
`${length(" ")}`,
|
|
"1",
|
|
false,
|
|
},
|
|
{
|
|
`${length(" a ,")}`,
|
|
"4",
|
|
false,
|
|
},
|
|
{
|
|
`${length("aaa")}`,
|
|
"3",
|
|
false,
|
|
},
|
|
|
|
// Lists
|
|
{
|
|
`${length(split(",", "a"))}`,
|
|
"1",
|
|
false,
|
|
},
|
|
{
|
|
`${length(split(",", "foo,"))}`,
|
|
"2",
|
|
false,
|
|
},
|
|
{
|
|
`${length(split(",", ",foo,"))}`,
|
|
"3",
|
|
false,
|
|
},
|
|
{
|
|
`${length(split(",", "foo,bar"))}`,
|
|
"2",
|
|
false,
|
|
},
|
|
{
|
|
`${length(split(".", "one.two.three.four.five"))}`,
|
|
"5",
|
|
false,
|
|
},
|
|
// Want length 0 if we split an empty string then compact
|
|
{
|
|
`${length(compact(split(",", "")))}`,
|
|
"0",
|
|
false,
|
|
},
|
|
// Works for maps
|
|
{
|
|
`${length(map("k", "v"))}`,
|
|
"1",
|
|
false,
|
|
},
|
|
{
|
|
`${length(map("k1", "v1", "k2", "v2"))}`,
|
|
"2",
|
|
false,
|
|
},
|
|
},
|
|
})
|
|
}
|
|
|
|
func TestInterpolateFuncSignum(t *testing.T) {
|
|
testFunction(t, testFunctionConfig{
|
|
Cases: []testFunctionCase{
|
|
{
|
|
`${signum()}`,
|
|
nil,
|
|
true,
|
|
},
|
|
|
|
{
|
|
`${signum("")}`,
|
|
nil,
|
|
true,
|
|
},
|
|
|
|
{
|
|
`${signum(0)}`,
|
|
"0",
|
|
false,
|
|
},
|
|
|
|
{
|
|
`${signum(15)}`,
|
|
"1",
|
|
false,
|
|
},
|
|
|
|
{
|
|
`${signum(-29)}`,
|
|
"-1",
|
|
false,
|
|
},
|
|
},
|
|
})
|
|
}
|
|
|
|
func TestInterpolateFuncSlice(t *testing.T) {
|
|
testFunction(t, testFunctionConfig{
|
|
Cases: []testFunctionCase{
|
|
// Negative from index
|
|
{
|
|
`${slice(list("a"), -1, 0)}`,
|
|
nil,
|
|
true,
|
|
},
|
|
// From index > to index
|
|
{
|
|
`${slice(list("a", "b", "c"), 2, 1)}`,
|
|
nil,
|
|
true,
|
|
},
|
|
// To index too large
|
|
{
|
|
`${slice(var.list_of_strings, 1, 4)}`,
|
|
nil,
|
|
true,
|
|
},
|
|
// Empty slice
|
|
{
|
|
`${slice(var.list_of_strings, 1, 1)}`,
|
|
[]interface{}{},
|
|
false,
|
|
},
|
|
{
|
|
`${slice(var.list_of_strings, 1, 2)}`,
|
|
[]interface{}{"b"},
|
|
false,
|
|
},
|
|
{
|
|
`${slice(var.list_of_strings, 0, length(var.list_of_strings) - 1)}`,
|
|
[]interface{}{"a", "b"},
|
|
false,
|
|
},
|
|
},
|
|
Vars: map[string]ast.Variable{
|
|
"var.list_of_strings": {
|
|
Type: ast.TypeList,
|
|
Value: []ast.Variable{
|
|
{
|
|
Type: ast.TypeString,
|
|
Value: "a",
|
|
},
|
|
{
|
|
Type: ast.TypeString,
|
|
Value: "b",
|
|
},
|
|
{
|
|
Type: ast.TypeString,
|
|
Value: "c",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
})
|
|
}
|
|
|
|
func TestInterpolateFuncSort(t *testing.T) {
|
|
testFunction(t, testFunctionConfig{
|
|
Vars: map[string]ast.Variable{
|
|
"var.strings": ast.Variable{
|
|
Type: ast.TypeList,
|
|
Value: []ast.Variable{
|
|
{Type: ast.TypeString, Value: "c"},
|
|
{Type: ast.TypeString, Value: "a"},
|
|
{Type: ast.TypeString, Value: "b"},
|
|
},
|
|
},
|
|
"var.notstrings": ast.Variable{
|
|
Type: ast.TypeList,
|
|
Value: []ast.Variable{
|
|
{Type: ast.TypeList, Value: []ast.Variable{}},
|
|
{Type: ast.TypeString, Value: "b"},
|
|
},
|
|
},
|
|
},
|
|
Cases: []testFunctionCase{
|
|
{
|
|
`${sort(var.strings)}`,
|
|
[]interface{}{"a", "b", "c"},
|
|
false,
|
|
},
|
|
{
|
|
`${sort(var.notstrings)}`,
|
|
nil,
|
|
true,
|
|
},
|
|
},
|
|
})
|
|
}
|
|
|
|
func TestInterpolateFuncSplit(t *testing.T) {
|
|
testFunction(t, testFunctionConfig{
|
|
Cases: []testFunctionCase{
|
|
{
|
|
`${split(",")}`,
|
|
nil,
|
|
true,
|
|
},
|
|
|
|
{
|
|
`${split(",", "")}`,
|
|
[]interface{}{""},
|
|
false,
|
|
},
|
|
|
|
{
|
|
`${split(",", "foo")}`,
|
|
[]interface{}{"foo"},
|
|
false,
|
|
},
|
|
|
|
{
|
|
`${split(",", ",,,")}`,
|
|
[]interface{}{"", "", "", ""},
|
|
false,
|
|
},
|
|
|
|
{
|
|
`${split(",", "foo,")}`,
|
|
[]interface{}{"foo", ""},
|
|
false,
|
|
},
|
|
|
|
{
|
|
`${split(",", ",foo,")}`,
|
|
[]interface{}{"", "foo", ""},
|
|
false,
|
|
},
|
|
|
|
{
|
|
`${split(".", "foo.bar.baz")}`,
|
|
[]interface{}{"foo", "bar", "baz"},
|
|
false,
|
|
},
|
|
},
|
|
})
|
|
}
|
|
|
|
func TestInterpolateFuncLookup(t *testing.T) {
|
|
testFunction(t, testFunctionConfig{
|
|
Vars: map[string]ast.Variable{
|
|
"var.foo": {
|
|
Type: ast.TypeMap,
|
|
Value: map[string]ast.Variable{
|
|
"bar": {
|
|
Type: ast.TypeString,
|
|
Value: "baz",
|
|
},
|
|
},
|
|
},
|
|
"var.map_of_lists": ast.Variable{
|
|
Type: ast.TypeMap,
|
|
Value: map[string]ast.Variable{
|
|
"bar": {
|
|
Type: ast.TypeList,
|
|
Value: []ast.Variable{
|
|
{
|
|
Type: ast.TypeString,
|
|
Value: "baz",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
Cases: []testFunctionCase{
|
|
{
|
|
`${lookup(var.foo, "bar")}`,
|
|
"baz",
|
|
false,
|
|
},
|
|
|
|
// Invalid key
|
|
{
|
|
`${lookup(var.foo, "baz")}`,
|
|
nil,
|
|
true,
|
|
},
|
|
|
|
// Supplied default with valid key
|
|
{
|
|
`${lookup(var.foo, "bar", "")}`,
|
|
"baz",
|
|
false,
|
|
},
|
|
|
|
// Supplied default with invalid key
|
|
{
|
|
`${lookup(var.foo, "zip", "")}`,
|
|
"",
|
|
false,
|
|
},
|
|
|
|
// Too many args
|
|
{
|
|
`${lookup(var.foo, "bar", "", "abc")}`,
|
|
nil,
|
|
true,
|
|
},
|
|
|
|
// Cannot lookup into map of lists
|
|
{
|
|
`${lookup(var.map_of_lists, "bar")}`,
|
|
nil,
|
|
true,
|
|
},
|
|
|
|
// Non-empty default
|
|
{
|
|
`${lookup(var.foo, "zap", "xyz")}`,
|
|
"xyz",
|
|
false,
|
|
},
|
|
},
|
|
})
|
|
}
|
|
|
|
func TestInterpolateFuncKeys(t *testing.T) {
|
|
testFunction(t, testFunctionConfig{
|
|
Vars: map[string]ast.Variable{
|
|
"var.foo": ast.Variable{
|
|
Type: ast.TypeMap,
|
|
Value: map[string]ast.Variable{
|
|
"bar": ast.Variable{
|
|
Value: "baz",
|
|
Type: ast.TypeString,
|
|
},
|
|
"qux": ast.Variable{
|
|
Value: "quack",
|
|
Type: ast.TypeString,
|
|
},
|
|
},
|
|
},
|
|
"var.str": ast.Variable{
|
|
Value: "astring",
|
|
Type: ast.TypeString,
|
|
},
|
|
},
|
|
Cases: []testFunctionCase{
|
|
{
|
|
`${keys(var.foo)}`,
|
|
[]interface{}{"bar", "qux"},
|
|
false,
|
|
},
|
|
|
|
// Invalid key
|
|
{
|
|
`${keys(var.not)}`,
|
|
nil,
|
|
true,
|
|
},
|
|
|
|
// Too many args
|
|
{
|
|
`${keys(var.foo, "bar")}`,
|
|
nil,
|
|
true,
|
|
},
|
|
|
|
// Not a map
|
|
{
|
|
`${keys(var.str)}`,
|
|
nil,
|
|
true,
|
|
},
|
|
},
|
|
})
|
|
}
|
|
|
|
// Confirm that keys return in sorted order, and values return in the order of
|
|
// their sorted keys.
|
|
func TestInterpolateFuncKeyValOrder(t *testing.T) {
|
|
testFunction(t, testFunctionConfig{
|
|
Vars: map[string]ast.Variable{
|
|
"var.foo": ast.Variable{
|
|
Type: ast.TypeMap,
|
|
Value: map[string]ast.Variable{
|
|
"D": ast.Variable{
|
|
Value: "2",
|
|
Type: ast.TypeString,
|
|
},
|
|
"C": ast.Variable{
|
|
Value: "Y",
|
|
Type: ast.TypeString,
|
|
},
|
|
"A": ast.Variable{
|
|
Value: "X",
|
|
Type: ast.TypeString,
|
|
},
|
|
"10": ast.Variable{
|
|
Value: "Z",
|
|
Type: ast.TypeString,
|
|
},
|
|
"1": ast.Variable{
|
|
Value: "4",
|
|
Type: ast.TypeString,
|
|
},
|
|
"3": ast.Variable{
|
|
Value: "W",
|
|
Type: ast.TypeString,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
Cases: []testFunctionCase{
|
|
{
|
|
`${keys(var.foo)}`,
|
|
[]interface{}{"1", "10", "3", "A", "C", "D"},
|
|
false,
|
|
},
|
|
|
|
{
|
|
`${values(var.foo)}`,
|
|
[]interface{}{"4", "Z", "W", "X", "Y", "2"},
|
|
false,
|
|
},
|
|
},
|
|
})
|
|
}
|
|
|
|
func TestInterpolateFuncValues(t *testing.T) {
|
|
testFunction(t, testFunctionConfig{
|
|
Vars: map[string]ast.Variable{
|
|
"var.foo": ast.Variable{
|
|
Type: ast.TypeMap,
|
|
Value: map[string]ast.Variable{
|
|
"bar": ast.Variable{
|
|
Value: "quack",
|
|
Type: ast.TypeString,
|
|
},
|
|
"qux": ast.Variable{
|
|
Value: "baz",
|
|
Type: ast.TypeString,
|
|
},
|
|
},
|
|
},
|
|
"var.str": ast.Variable{
|
|
Value: "astring",
|
|
Type: ast.TypeString,
|
|
},
|
|
},
|
|
Cases: []testFunctionCase{
|
|
{
|
|
`${values(var.foo)}`,
|
|
[]interface{}{"quack", "baz"},
|
|
false,
|
|
},
|
|
|
|
// Invalid key
|
|
{
|
|
`${values(var.not)}`,
|
|
nil,
|
|
true,
|
|
},
|
|
|
|
// Too many args
|
|
{
|
|
`${values(var.foo, "bar")}`,
|
|
nil,
|
|
true,
|
|
},
|
|
|
|
// Not a map
|
|
{
|
|
`${values(var.str)}`,
|
|
nil,
|
|
true,
|
|
},
|
|
|
|
// Map of lists
|
|
{
|
|
`${values(map("one", list()))}`,
|
|
nil,
|
|
true,
|
|
},
|
|
},
|
|
})
|
|
}
|
|
|
|
func interfaceToVariableSwallowError(input interface{}) ast.Variable {
|
|
variable, _ := hil.InterfaceToVariable(input)
|
|
return variable
|
|
}
|
|
|
|
func TestInterpolateFuncElement(t *testing.T) {
|
|
testFunction(t, testFunctionConfig{
|
|
Vars: map[string]ast.Variable{
|
|
"var.a_list": interfaceToVariableSwallowError([]string{"foo", "baz"}),
|
|
"var.a_short_list": interfaceToVariableSwallowError([]string{"foo"}),
|
|
"var.empty_list": interfaceToVariableSwallowError([]interface{}{}),
|
|
"var.a_nested_list": interfaceToVariableSwallowError([]interface{}{[]string{"foo"}, []string{"baz"}}),
|
|
},
|
|
Cases: []testFunctionCase{
|
|
{
|
|
`${element(var.a_list, "1")}`,
|
|
"baz",
|
|
false,
|
|
},
|
|
|
|
{
|
|
`${element(var.a_short_list, "0")}`,
|
|
"foo",
|
|
false,
|
|
},
|
|
|
|
// Invalid index should wrap vs. out-of-bounds
|
|
{
|
|
`${element(var.a_list, "2")}`,
|
|
"foo",
|
|
false,
|
|
},
|
|
|
|
// Negative number should fail
|
|
{
|
|
`${element(var.a_short_list, "-1")}`,
|
|
nil,
|
|
true,
|
|
},
|
|
|
|
// Empty list should fail
|
|
{
|
|
`${element(var.empty_list, 0)}`,
|
|
nil,
|
|
true,
|
|
},
|
|
|
|
// Too many args
|
|
{
|
|
`${element(var.a_list, "0", "2")}`,
|
|
nil,
|
|
true,
|
|
},
|
|
|
|
// Only works on single-level lists
|
|
{
|
|
`${element(var.a_nested_list, "0")}`,
|
|
nil,
|
|
true,
|
|
},
|
|
},
|
|
})
|
|
}
|
|
|
|
func TestInterpolateFuncBasename(t *testing.T) {
|
|
testFunction(t, testFunctionConfig{
|
|
Cases: []testFunctionCase{
|
|
{
|
|
`${basename("/foo/bar/baz")}`,
|
|
"baz",
|
|
false,
|
|
},
|
|
},
|
|
})
|
|
}
|
|
|
|
func TestInterpolateFuncBase64Encode(t *testing.T) {
|
|
testFunction(t, testFunctionConfig{
|
|
Cases: []testFunctionCase{
|
|
// Regular base64 encoding
|
|
{
|
|
`${base64encode("abc123!?$*&()'-=@~")}`,
|
|
"YWJjMTIzIT8kKiYoKSctPUB+",
|
|
false,
|
|
},
|
|
},
|
|
})
|
|
}
|
|
|
|
func TestInterpolateFuncBase64Decode(t *testing.T) {
|
|
testFunction(t, testFunctionConfig{
|
|
Cases: []testFunctionCase{
|
|
// Regular base64 decoding
|
|
{
|
|
`${base64decode("YWJjMTIzIT8kKiYoKSctPUB+")}`,
|
|
"abc123!?$*&()'-=@~",
|
|
false,
|
|
},
|
|
|
|
// Invalid base64 data decoding
|
|
{
|
|
`${base64decode("this-is-an-invalid-base64-data")}`,
|
|
nil,
|
|
true,
|
|
},
|
|
},
|
|
})
|
|
}
|
|
|
|
func TestInterpolateFuncLower(t *testing.T) {
|
|
testFunction(t, testFunctionConfig{
|
|
Cases: []testFunctionCase{
|
|
{
|
|
`${lower("HELLO")}`,
|
|
"hello",
|
|
false,
|
|
},
|
|
|
|
{
|
|
`${lower("")}`,
|
|
"",
|
|
false,
|
|
},
|
|
|
|
{
|
|
`${lower()}`,
|
|
nil,
|
|
true,
|
|
},
|
|
},
|
|
})
|
|
}
|
|
|
|
func TestInterpolateFuncUpper(t *testing.T) {
|
|
testFunction(t, testFunctionConfig{
|
|
Cases: []testFunctionCase{
|
|
{
|
|
`${upper("hello")}`,
|
|
"HELLO",
|
|
false,
|
|
},
|
|
|
|
{
|
|
`${upper("")}`,
|
|
"",
|
|
false,
|
|
},
|
|
|
|
{
|
|
`${upper()}`,
|
|
nil,
|
|
true,
|
|
},
|
|
},
|
|
})
|
|
}
|
|
|
|
func TestInterpolateFuncSha1(t *testing.T) {
|
|
testFunction(t, testFunctionConfig{
|
|
Cases: []testFunctionCase{
|
|
{
|
|
`${sha1("test")}`,
|
|
"a94a8fe5ccb19ba61c4c0873d391e987982fbbd3",
|
|
false,
|
|
},
|
|
},
|
|
})
|
|
}
|
|
|
|
func TestInterpolateFuncSha256(t *testing.T) {
|
|
testFunction(t, testFunctionConfig{
|
|
Cases: []testFunctionCase{
|
|
{ // hexadecimal representation of sha256 sum
|
|
`${sha256("test")}`,
|
|
"9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08",
|
|
false,
|
|
},
|
|
},
|
|
})
|
|
}
|
|
|
|
func TestInterpolateFuncSha512(t *testing.T) {
|
|
testFunction(t, testFunctionConfig{
|
|
Cases: []testFunctionCase{
|
|
{
|
|
`${sha512("test")}`,
|
|
"ee26b0dd4af7e749aa1a8ee3c10ae9923f618980772e473f8819a5d4940e0db27ac185f8a0e1d5f84f88bc887fd67b143732c304cc5fa9ad8e6f57f50028a8ff",
|
|
false,
|
|
},
|
|
},
|
|
})
|
|
}
|
|
|
|
func TestInterpolateFuncTitle(t *testing.T) {
|
|
testFunction(t, testFunctionConfig{
|
|
Cases: []testFunctionCase{
|
|
{
|
|
`${title("hello")}`,
|
|
"Hello",
|
|
false,
|
|
},
|
|
|
|
{
|
|
`${title("hello world")}`,
|
|
"Hello World",
|
|
false,
|
|
},
|
|
|
|
{
|
|
`${title("")}`,
|
|
"",
|
|
false,
|
|
},
|
|
|
|
{
|
|
`${title()}`,
|
|
nil,
|
|
true,
|
|
},
|
|
},
|
|
})
|
|
}
|
|
|
|
func TestInterpolateFuncTrimSpace(t *testing.T) {
|
|
testFunction(t, testFunctionConfig{
|
|
Cases: []testFunctionCase{
|
|
{
|
|
`${trimspace(" test ")}`,
|
|
"test",
|
|
false,
|
|
},
|
|
},
|
|
})
|
|
}
|
|
|
|
func TestInterpolateFuncBase64Sha256(t *testing.T) {
|
|
testFunction(t, testFunctionConfig{
|
|
Cases: []testFunctionCase{
|
|
{
|
|
`${base64sha256("test")}`,
|
|
"n4bQgYhMfWWaL+qgxVrQFaO/TxsrC4Is0V1sFbDwCgg=",
|
|
false,
|
|
},
|
|
{ // This will differ because we're base64-encoding hex represantiation, not raw bytes
|
|
`${base64encode(sha256("test"))}`,
|
|
"OWY4NmQwODE4ODRjN2Q2NTlhMmZlYWEwYzU1YWQwMTVhM2JmNGYxYjJiMGI4MjJjZDE1ZDZjMTViMGYwMGEwOA==",
|
|
false,
|
|
},
|
|
},
|
|
})
|
|
}
|
|
|
|
func TestInterpolateFuncBase64Sha512(t *testing.T) {
|
|
testFunction(t, testFunctionConfig{
|
|
Cases: []testFunctionCase{
|
|
{
|
|
`${base64sha512("test")}`,
|
|
"7iaw3Ur350mqGo7jwQrpkj9hiYB3Lkc/iBml1JQODbJ6wYX4oOHV+E+IvIh/1nsUNzLDBMxfqa2Ob1f1ACio/w==",
|
|
false,
|
|
},
|
|
{ // This will differ because we're base64-encoding hex represantiation, not raw bytes
|
|
`${base64encode(sha512("test"))}`,
|
|
"ZWUyNmIwZGQ0YWY3ZTc0OWFhMWE4ZWUzYzEwYWU5OTIzZjYxODk4MDc3MmU0NzNmODgxOWE1ZDQ5NDBlMGRiMjdhYzE4NWY4YTBlMWQ1Zjg0Zjg4YmM4ODdmZDY3YjE0MzczMmMzMDRjYzVmYTlhZDhlNmY1N2Y1MDAyOGE4ZmY=",
|
|
false,
|
|
},
|
|
},
|
|
})
|
|
}
|
|
|
|
func TestInterpolateFuncMd5(t *testing.T) {
|
|
testFunction(t, testFunctionConfig{
|
|
Cases: []testFunctionCase{
|
|
{
|
|
`${md5("tada")}`,
|
|
"ce47d07243bb6eaf5e1322c81baf9bbf",
|
|
false,
|
|
},
|
|
{ // Confirm that we're not trimming any whitespaces
|
|
`${md5(" tada ")}`,
|
|
"aadf191a583e53062de2d02c008141c4",
|
|
false,
|
|
},
|
|
{ // We accept empty string too
|
|
`${md5("")}`,
|
|
"d41d8cd98f00b204e9800998ecf8427e",
|
|
false,
|
|
},
|
|
},
|
|
})
|
|
}
|
|
|
|
func TestInterpolateFuncUUID(t *testing.T) {
|
|
results := make(map[string]bool)
|
|
|
|
for i := 0; i < 100; i++ {
|
|
ast, err := hil.Parse("${uuid()}")
|
|
if err != nil {
|
|
t.Fatalf("err: %s", err)
|
|
}
|
|
|
|
result, err := hil.Eval(ast, langEvalConfig(nil))
|
|
if err != nil {
|
|
t.Fatalf("err: %s", err)
|
|
}
|
|
|
|
if results[result.Value.(string)] {
|
|
t.Fatalf("Got unexpected duplicate uuid: %s", result.Value)
|
|
}
|
|
|
|
results[result.Value.(string)] = true
|
|
}
|
|
}
|
|
|
|
func TestInterpolateFuncTimestamp(t *testing.T) {
|
|
currentTime := time.Now().UTC()
|
|
ast, err := hil.Parse("${timestamp()}")
|
|
if err != nil {
|
|
t.Fatalf("err: %s", err)
|
|
}
|
|
|
|
result, err := hil.Eval(ast, langEvalConfig(nil))
|
|
if err != nil {
|
|
t.Fatalf("err: %s", err)
|
|
}
|
|
resultTime, err := time.Parse(time.RFC3339, result.Value.(string))
|
|
if err != nil {
|
|
t.Fatalf("Error parsing timestamp: %s", err)
|
|
}
|
|
|
|
if resultTime.Sub(currentTime).Seconds() > 10.0 {
|
|
t.Fatalf("Timestamp Diff too large. Expected: %s\nReceived: %s", currentTime.Format(time.RFC3339), result.Value.(string))
|
|
}
|
|
}
|
|
|
|
type testFunctionConfig struct {
|
|
Cases []testFunctionCase
|
|
Vars map[string]ast.Variable
|
|
}
|
|
|
|
type testFunctionCase struct {
|
|
Input string
|
|
Result interface{}
|
|
Error bool
|
|
}
|
|
|
|
func testFunction(t *testing.T, config testFunctionConfig) {
|
|
for i, tc := range config.Cases {
|
|
ast, err := hil.Parse(tc.Input)
|
|
if err != nil {
|
|
t.Fatalf("Case #%d: input: %#v\nerr: %v", i, tc.Input, err)
|
|
}
|
|
|
|
result, err := hil.Eval(ast, langEvalConfig(config.Vars))
|
|
if err != nil != tc.Error {
|
|
t.Fatalf("Case #%d:\ninput: %#v\nerr: %v", i, tc.Input, err)
|
|
}
|
|
|
|
if !reflect.DeepEqual(result.Value, tc.Result) {
|
|
t.Fatalf("%d: bad output for input: %s\n\nOutput: %#v\nExpected: %#v",
|
|
i, tc.Input, result.Value, tc.Result)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestInterpolateFuncPathExpand(t *testing.T) {
|
|
homePath, err := homedir.Dir()
|
|
if err != nil {
|
|
t.Fatalf("Error getting home directory: %v", err)
|
|
}
|
|
testFunction(t, testFunctionConfig{
|
|
Cases: []testFunctionCase{
|
|
{
|
|
`${pathexpand("~/test-file")}`,
|
|
filepath.Join(homePath, "test-file"),
|
|
false,
|
|
},
|
|
{
|
|
`${pathexpand("~/another/test/file")}`,
|
|
filepath.Join(homePath, "another/test/file"),
|
|
false,
|
|
},
|
|
{
|
|
`${pathexpand("/root/file")}`,
|
|
"/root/file",
|
|
false,
|
|
},
|
|
{
|
|
`${pathexpand("/")}`,
|
|
"/",
|
|
false,
|
|
},
|
|
{
|
|
`${pathexpand()}`,
|
|
nil,
|
|
true,
|
|
},
|
|
},
|
|
})
|
|
}
|
|
|
|
func TestInterpolateFuncSubstr(t *testing.T) {
|
|
testFunction(t, testFunctionConfig{
|
|
Cases: []testFunctionCase{
|
|
{
|
|
`${substr("foobar", 0, 0)}`,
|
|
"",
|
|
false,
|
|
},
|
|
{
|
|
`${substr("foobar", 0, -1)}`,
|
|
"foobar",
|
|
false,
|
|
},
|
|
{
|
|
`${substr("foobar", 0, 3)}`,
|
|
"foo",
|
|
false,
|
|
},
|
|
{
|
|
`${substr("foobar", 3, 3)}`,
|
|
"bar",
|
|
false,
|
|
},
|
|
{
|
|
`${substr("foobar", -3, 3)}`,
|
|
"bar",
|
|
false,
|
|
},
|
|
|
|
// empty string
|
|
{
|
|
`${substr("", 0, 0)}`,
|
|
"",
|
|
false,
|
|
},
|
|
|
|
// invalid offset
|
|
{
|
|
`${substr("", 1, 0)}`,
|
|
nil,
|
|
true,
|
|
},
|
|
|
|
// invalid length
|
|
{
|
|
`${substr("", 0, 1)}`,
|
|
nil,
|
|
true,
|
|
},
|
|
{
|
|
`${substr("", 0, -2)}`,
|
|
nil,
|
|
true,
|
|
},
|
|
},
|
|
})
|
|
}
|
|
|
|
func TestInterpolateFuncBcrypt(t *testing.T) {
|
|
node, err := hil.Parse(`${bcrypt("test")}`)
|
|
if err != nil {
|
|
t.Fatalf("err: %s", err)
|
|
}
|
|
|
|
result, err := hil.Eval(node, langEvalConfig(nil))
|
|
if err != nil {
|
|
t.Fatalf("err: %s", err)
|
|
}
|
|
err = bcrypt.CompareHashAndPassword([]byte(result.Value.(string)), []byte("test"))
|
|
|
|
if err != nil {
|
|
t.Fatalf("Error comparing hash and password: %s", err)
|
|
}
|
|
|
|
testFunction(t, testFunctionConfig{
|
|
Cases: []testFunctionCase{
|
|
//Negative test for more than two parameters
|
|
{
|
|
`${bcrypt("test", 15, 12)}`,
|
|
nil,
|
|
true,
|
|
},
|
|
},
|
|
})
|
|
}
|