func TestNodeAddresses(t *testing.T) {
// Note these instances have the same name
// (we test that this produces an error)
var instance0 ec2.Instance
var instance1 ec2.Instance
//0
instance0.PrivateDNSName = aws.String("instance1")
instance0.PrivateIPAddress = aws.String("192.168.0.1")
instance0.PublicIPAddress = aws.String("1.2.3.4")
instance0.InstanceType = aws.String("c3.large")
state0 := ec2.InstanceState{
Name: aws.String("running"),
}
instance0.State = &state0
//1
instance1.PrivateDNSName = aws.String("instance1")
instance1.PrivateIPAddress = aws.String("192.168.0.2")
instance1.InstanceType = aws.String("c3.large")
state1 := ec2.InstanceState{
Name: aws.String("running"),
}
instance1.State = &state1
instances := []*ec2.Instance{&instance0, &instance1}
aws1 := mockInstancesResp([]*ec2.Instance{})
_, err1 := aws1.NodeAddresses("instance")
if err1 == nil {
t.Errorf("Should error when no instance found")
}
aws2 := mockInstancesResp(instances)
_, err2 := aws2.NodeAddresses("instance1")
if err2 == nil {
t.Errorf("Should error when multiple instances found")
}
aws3 := mockInstancesResp(instances[0:1])
addrs3, err3 := aws3.NodeAddresses("instance1")
if err3 != nil {
t.Errorf("Should not error when instance found")
}
if len(addrs3) != 3 {
t.Errorf("Should return exactly 3 NodeAddresses")
}
testHasNodeAddress(t, addrs3, api.NodeInternalIP, "192.168.0.1")
testHasNodeAddress(t, addrs3, api.NodeLegacyHostIP, "192.168.0.1")
testHasNodeAddress(t, addrs3, api.NodeExternalIP, "1.2.3.4")
}
func TestGetResources(t *testing.T) {
var instance0 ec2.Instance
var instance1 ec2.Instance
var instance2 ec2.Instance
//0
instance0.PrivateDNSName = aws.String("m3.medium")
instance0.InstanceType = aws.String("m3.medium")
state0 := ec2.InstanceState{
Name: aws.String("running"),
}
instance0.State = &state0
//1
instance1.PrivateDNSName = aws.String("r3.8xlarge")
instance1.InstanceType = aws.String("r3.8xlarge")
state1 := ec2.InstanceState{
Name: aws.String("running"),
}
instance1.State = &state1
//2
instance2.PrivateDNSName = aws.String("unknown.type")
instance2.InstanceType = aws.String("unknown.type")
state2 := ec2.InstanceState{
Name: aws.String("running"),
}
instance2.State = &state2
instances := []*ec2.Instance{&instance0, &instance1, &instance2}
aws1 := mockInstancesResp(instances)
res1, err1 := aws1.GetNodeResources("m3.medium")
if err1 != nil {
t.Errorf("Should not error when instance type found: %v", err1)
}
e1 := &api.NodeResources{
Capacity: api.ResourceList{
api.ResourceCPU: *resource.NewMilliQuantity(int64(3.0*1000), resource.DecimalSI),
api.ResourceMemory: *resource.NewQuantity(int64(3.75*1024*1024*1024), resource.BinarySI),
},
}
if !reflect.DeepEqual(e1, res1) {
t.Errorf("Expected %v, got %v", e1, res1)
}
res2, err2 := aws1.GetNodeResources("r3.8xlarge")
if err2 != nil {
t.Errorf("Should not error when instance type found: %v", err2)
}
e2 := &api.NodeResources{
Capacity: api.ResourceList{
api.ResourceCPU: *resource.NewMilliQuantity(int64(104.0*1000), resource.DecimalSI),
api.ResourceMemory: *resource.NewQuantity(int64(244.0*1024*1024*1024), resource.BinarySI),
},
}
if !reflect.DeepEqual(e2, res2) {
t.Errorf("Expected %v, got %v", e2, res2)
}
res3, err3 := aws1.GetNodeResources("unknown.type")
if err3 != nil {
t.Errorf("Should not error when unknown instance type")
}
if res3 != nil {
t.Errorf("Should return nil resources when unknown instance type")
}
}
func TestList(t *testing.T) {
// TODO this setup is not very clean and could probably be improved
var instance0 ec2.Instance
var instance1 ec2.Instance
var instance2 ec2.Instance
var instance3 ec2.Instance
//0
tag0 := ec2.Tag{
Key: aws.String("Name"),
Value: aws.String("foo"),
}
instance0.Tags = []*ec2.Tag{&tag0}
instance0.PrivateDNSName = aws.String("instance1")
state0 := ec2.InstanceState{
Name: aws.String("running"),
}
instance0.State = &state0
//1
tag1 := ec2.Tag{
Key: aws.String("Name"),
Value: aws.String("bar"),
}
instance1.Tags = []*ec2.Tag{&tag1}
instance1.PrivateDNSName = aws.String("instance2")
state1 := ec2.InstanceState{
Name: aws.String("running"),
}
instance1.State = &state1
//2
tag2 := ec2.Tag{
Key: aws.String("Name"),
Value: aws.String("baz"),
}
instance2.Tags = []*ec2.Tag{&tag2}
instance2.PrivateDNSName = aws.String("instance3")
state2 := ec2.InstanceState{
Name: aws.String("running"),
}
instance2.State = &state2
//3
tag3 := ec2.Tag{
Key: aws.String("Name"),
Value: aws.String("quux"),
}
instance3.Tags = []*ec2.Tag{&tag3}
instance3.PrivateDNSName = aws.String("instance4")
state3 := ec2.InstanceState{
Name: aws.String("running"),
}
instance3.State = &state3
instances := []*ec2.Instance{&instance0, &instance1, &instance2, &instance3}
aws := mockInstancesResp(instances)
table := []struct {
input string
expect []string
}{
{"blahonga", []string{}},
{"quux", []string{"instance4"}},
{"a", []string{"instance2", "instance3"}},
}
for _, item := range table {
result, err := aws.List(item.input)
if err != nil {
t.Errorf("Expected call with %v to succeed, failed with %s", item.input, err)
}
if e, a := item.expect, result; !reflect.DeepEqual(e, a) {
t.Errorf("Expected %v, got %v", e, a)
}
}
}