github.com/wuhuizuo/gomplate@v3.5.0+incompatible/aws/ec2info_test.go (about)

     1  package aws
     2  
     3  import (
     4  	"os"
     5  	"sync"
     6  	"testing"
     7  	"time"
     8  
     9  	"github.com/aws/aws-sdk-go/aws"
    10  	"github.com/aws/aws-sdk-go/service/ec2"
    11  	"github.com/stretchr/testify/assert"
    12  )
    13  
    14  func TestTag_MissingKey(t *testing.T) {
    15  	server, ec2meta := MockServer(200, `"i-1234"`)
    16  	defer server.Close()
    17  	client := DummyInstanceDescriber{
    18  		tags: []*ec2.Tag{
    19  			{
    20  				Key:   aws.String("foo"),
    21  				Value: aws.String("bar"),
    22  			},
    23  			{
    24  				Key:   aws.String("baz"),
    25  				Value: aws.String("qux"),
    26  			},
    27  		},
    28  	}
    29  	e := &Ec2Info{
    30  		describer: func() (InstanceDescriber, error) {
    31  			return client, nil
    32  		},
    33  		metaClient: ec2meta,
    34  		cache:      make(map[string]interface{}),
    35  	}
    36  
    37  	assert.Empty(t, must(e.Tag("missing")))
    38  	assert.Equal(t, "default", must(e.Tag("missing", "default")))
    39  }
    40  
    41  func TestTag_ValidKey(t *testing.T) {
    42  	server, ec2meta := MockServer(200, `"i-1234"`)
    43  	defer server.Close()
    44  	client := DummyInstanceDescriber{
    45  		tags: []*ec2.Tag{
    46  			{
    47  				Key:   aws.String("foo"),
    48  				Value: aws.String("bar"),
    49  			},
    50  			{
    51  				Key:   aws.String("baz"),
    52  				Value: aws.String("qux"),
    53  			},
    54  		},
    55  	}
    56  	e := &Ec2Info{
    57  		describer: func() (InstanceDescriber, error) {
    58  			return client, nil
    59  		},
    60  		metaClient: ec2meta,
    61  		cache:      make(map[string]interface{}),
    62  	}
    63  
    64  	assert.Equal(t, "bar", must(e.Tag("foo")))
    65  	assert.Equal(t, "bar", must(e.Tag("foo", "default")))
    66  }
    67  
    68  func TestTag_NonEC2(t *testing.T) {
    69  	server, ec2meta := MockServer(404, "")
    70  	ec2meta.nonAWS = true
    71  	defer server.Close()
    72  	client := DummyInstanceDescriber{}
    73  	e := &Ec2Info{
    74  		describer: func() (InstanceDescriber, error) {
    75  			return client, nil
    76  		},
    77  		metaClient: ec2meta,
    78  		cache:      make(map[string]interface{}),
    79  	}
    80  
    81  	assert.Equal(t, "", must(e.Tag("foo")))
    82  	assert.Equal(t, "default", must(e.Tag("foo", "default")))
    83  }
    84  
    85  func TestNewEc2Info(t *testing.T) {
    86  	server, ec2meta := MockServer(200, `"i-1234"`)
    87  	defer server.Close()
    88  	client := DummyInstanceDescriber{
    89  		tags: []*ec2.Tag{
    90  			{
    91  				Key:   aws.String("foo"),
    92  				Value: aws.String("bar"),
    93  			},
    94  			{
    95  				Key:   aws.String("baz"),
    96  				Value: aws.String("qux"),
    97  			},
    98  		},
    99  	}
   100  	e := NewEc2Info(ClientOptions{})
   101  	e.describer = func() (InstanceDescriber, error) {
   102  		return client, nil
   103  	}
   104  	e.metaClient = ec2meta
   105  
   106  	assert.Equal(t, "bar", must(e.Tag("foo")))
   107  	assert.Equal(t, "bar", must(e.Tag("foo", "default")))
   108  }
   109  
   110  func TestGetRegion(t *testing.T) {
   111  	oldReg, ok := os.LookupEnv("AWS_REGION")
   112  	if ok {
   113  		defer os.Setenv("AWS_REGION", oldReg)
   114  	}
   115  	oldDefReg, ok := os.LookupEnv("AWS_DEFAULT_REGION")
   116  	if ok {
   117  		defer os.Setenv("AWS_REGION", oldDefReg)
   118  	}
   119  
   120  	os.Setenv("AWS_REGION", "kalamazoo")
   121  	os.Unsetenv("AWS_DEFAULT_REGION")
   122  	region, err := getRegion()
   123  	assert.NoError(t, err)
   124  	assert.Empty(t, region)
   125  
   126  	os.Setenv("AWS_DEFAULT_REGION", "kalamazoo")
   127  	os.Unsetenv("AWS_REGION")
   128  	region, err = getRegion()
   129  	assert.NoError(t, err)
   130  	assert.Empty(t, region)
   131  
   132  	os.Unsetenv("AWS_DEFAULT_REGION")
   133  	metaClient := NewDummyEc2Meta()
   134  	region, err = getRegion(metaClient)
   135  	assert.NoError(t, err)
   136  	assert.Equal(t, "unknown", region)
   137  
   138  	server, ec2meta := MockServer(200, `{"region":"us-east-1"}`)
   139  	defer server.Close()
   140  	region, err = getRegion(ec2meta)
   141  	assert.NoError(t, err)
   142  	assert.Equal(t, "us-east-1", region)
   143  }
   144  
   145  func TestGetClientOptions(t *testing.T) {
   146  	oldVar, ok := os.LookupEnv("AWS_TIMEOUT")
   147  	if ok {
   148  		defer os.Setenv("AWS_TIMEOUT", oldVar)
   149  	}
   150  
   151  	co := GetClientOptions()
   152  	assert.Equal(t, ClientOptions{Timeout: 500 * time.Millisecond}, co)
   153  
   154  	os.Setenv("AWS_TIMEOUT", "42")
   155  	// reset the Once
   156  	coInit = sync.Once{}
   157  	co = GetClientOptions()
   158  	assert.Equal(t, ClientOptions{Timeout: 42 * time.Millisecond}, co)
   159  
   160  	os.Setenv("AWS_TIMEOUT", "123")
   161  	// without resetting the Once, expect to be reused
   162  	co = GetClientOptions()
   163  	assert.Equal(t, ClientOptions{Timeout: 42 * time.Millisecond}, co)
   164  
   165  	os.Setenv("AWS_TIMEOUT", "foo")
   166  	// reset the Once
   167  	coInit = sync.Once{}
   168  	assert.Panics(t, func() {
   169  		GetClientOptions()
   170  	})
   171  }