159 lines
3.4 KiB
Go
159 lines
3.4 KiB
Go
package aws
|
|
|
|
import (
|
|
"reflect"
|
|
"testing"
|
|
|
|
"github.com/aws/aws-sdk-go/aws"
|
|
"github.com/aws/aws-sdk-go/service/ec2"
|
|
|
|
"github.com/hashicorp/terraform/helper/schema"
|
|
)
|
|
|
|
func TestBuildEC2AttributeFilterList(t *testing.T) {
|
|
type TestCase struct {
|
|
Attrs map[string]string
|
|
Expected []*ec2.Filter
|
|
}
|
|
testCases := []TestCase{
|
|
{
|
|
map[string]string{
|
|
"foo": "bar",
|
|
"baz": "boo",
|
|
},
|
|
[]*ec2.Filter{
|
|
{
|
|
Name: aws.String("baz"),
|
|
Values: []*string{aws.String("boo")},
|
|
},
|
|
{
|
|
Name: aws.String("foo"),
|
|
Values: []*string{aws.String("bar")},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
map[string]string{
|
|
"foo": "bar",
|
|
"baz": "",
|
|
},
|
|
[]*ec2.Filter{
|
|
{
|
|
Name: aws.String("foo"),
|
|
Values: []*string{aws.String("bar")},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
for i, testCase := range testCases {
|
|
result := buildEC2AttributeFilterList(testCase.Attrs)
|
|
|
|
if !reflect.DeepEqual(result, testCase.Expected) {
|
|
t.Errorf(
|
|
"test case %d: got %#v, but want %#v",
|
|
i, result, testCase.Expected,
|
|
)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestBuildEC2TagFilterList(t *testing.T) {
|
|
type TestCase struct {
|
|
Tags []*ec2.Tag
|
|
Expected []*ec2.Filter
|
|
}
|
|
testCases := []TestCase{
|
|
{
|
|
[]*ec2.Tag{
|
|
{
|
|
Key: aws.String("foo"),
|
|
Value: aws.String("bar"),
|
|
},
|
|
{
|
|
Key: aws.String("baz"),
|
|
Value: aws.String("boo"),
|
|
},
|
|
},
|
|
[]*ec2.Filter{
|
|
{
|
|
Name: aws.String("tag:foo"),
|
|
Values: []*string{aws.String("bar")},
|
|
},
|
|
{
|
|
Name: aws.String("tag:baz"),
|
|
Values: []*string{aws.String("boo")},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
for i, testCase := range testCases {
|
|
result := buildEC2TagFilterList(testCase.Tags)
|
|
|
|
if !reflect.DeepEqual(result, testCase.Expected) {
|
|
t.Errorf(
|
|
"test case %d: got %#v, but want %#v",
|
|
i, result, testCase.Expected,
|
|
)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestBuildEC2CustomFilterList(t *testing.T) {
|
|
|
|
// We need to get a set with the appropriate hash function,
|
|
// so we'll use the schema to help us produce what would
|
|
// be produced in the normal case.
|
|
filtersSchema := ec2CustomFiltersSchema()
|
|
|
|
// The zero value of this schema will be an interface{}
|
|
// referring to a new, empty *schema.Set with the
|
|
// appropriate hash function configured.
|
|
filters := filtersSchema.ZeroValue().(*schema.Set)
|
|
|
|
// We also need an appropriately-configured set for
|
|
// the list of values.
|
|
valuesSchema := filtersSchema.Elem.(*schema.Resource).Schema["values"]
|
|
valuesSet := func(vals ...string) *schema.Set {
|
|
ret := valuesSchema.ZeroValue().(*schema.Set)
|
|
for _, val := range vals {
|
|
ret.Add(val)
|
|
}
|
|
return ret
|
|
}
|
|
|
|
filters.Add(map[string]interface{}{
|
|
"name": "foo",
|
|
"values": valuesSet("bar", "baz"),
|
|
})
|
|
filters.Add(map[string]interface{}{
|
|
"name": "pizza",
|
|
"values": valuesSet("cheese"),
|
|
})
|
|
|
|
expected := []*ec2.Filter{
|
|
// These are produced in the deterministic order guaranteed
|
|
// by schema.Set.List(), which happens to produce them in
|
|
// the following order for our current input. If this test
|
|
// evolves with different input data in future then they
|
|
// will likely be emitted in a different order, which is fine.
|
|
{
|
|
Name: aws.String("pizza"),
|
|
Values: []*string{aws.String("cheese")},
|
|
},
|
|
{
|
|
Name: aws.String("foo"),
|
|
Values: []*string{aws.String("bar"), aws.String("baz")},
|
|
},
|
|
}
|
|
result := buildEC2CustomFilterList(filters)
|
|
|
|
if !reflect.DeepEqual(result, expected) {
|
|
t.Errorf(
|
|
"got %#v, but want %#v",
|
|
result, expected,
|
|
)
|
|
}
|
|
}
|