Merge lp:~gz/goamz/tests_amazon_region into lp:goamz

[Martin Packman]

Enable running live tests against any EC2 region

There are two stages:
 * Making the test -amazon flag take a region name
 * Looking up real amis with simplestreams and using those in tests

Perhaps leaving the -amazon flag as an enabling bool, and setting a new
flag just for selecting a region that defaults to us-east-1 would be
better.

Both the simplestreams code and required test changes are pretty ugly,
a bigger rewrite would help to clean up the tests.

https://codereview.appspot.com/14930049/

[Martin Packman (gz)]

Reviewers: mp+192269_code.launchpad.net,

Message:
Please take a look.

Description:
Enable running live tests against any EC2 region

There are two stages:
  * Making the test -amazon flag take a region name
  * Looking up real amis with simplestreams and using those in tests

Perhaps leaving the -amazon flag as an enabling bool, and setting a new
flag just for selecting a region that defaults to us-east-1 would be
better.

Both the simplestreams code and required test changes are pretty ugly,
a bigger rewrite would help to clean up the tests.

https://code.launchpad.net/~gz/goamz/tests_amazon_region/+merge/192269

(do not edit description out of merge proposal)

Please review this at https://codereview.appspot.com/14930049/

Affected files (+304, -19 lines):
   A [revision details]
   M ec2/ec2i_test.go
   M ec2/ec2t_test.go
   A testutil/streams.go
   A testutil/streams_test.go
   M testutil/suite.go

[lp:~gz/goamz/tests_amazon_region]

46. By Martin Packman on 2013-10-24

go fmt

[Martin Packman (gz)]

Please take a look.

https://codereview.appspot.com/14930049/

Unmerged revisions

46. By Martin Packman on 2013-10-24

go fmt

45. By Martin Packman on 2013-10-22

Get real ami values for live tests from published simplestreams data

44. By Martin Packman on 2013-10-21

Change -amazon test flag to accept region value for testing against other regions

=== modified file 'ec2/ec2_test.go'
--- ec2/ec2_test.go	2013-10-04 17:05:49 +0000
+++ ec2/ec2_test.go	2013-10-24 00:16:37 +0000
@@ -96,14 +96,14 @@
 		DisableAPITermination: true,
 		ShutdownBehavior:      "terminate",
 		PrivateIPAddress:      "10.0.0.25",
-		BlockDeviceMappings:   []ec2.BlockDeviceMapping{{
-			DeviceName: "device-name",
-			VirtualName: "virtual-name",
-			SnapshotId: "snapshot-id",
-			VolumeType: "volume-type",
-			VolumeSize: 10,
+		BlockDeviceMappings: []ec2.BlockDeviceMapping{{
+			DeviceName:          "device-name",
+			VirtualName:         "virtual-name",
+			SnapshotId:          "snapshot-id",
+			VolumeType:          "volume-type",
+			VolumeSize:          10,
 			DeleteOnTermination: true,
-			IOPS: 1000,
+			IOPS:                1000,
 		}},
 	}
 	resp, err := s.ec2.RunInstances(&options)
 
=== modified file 'ec2/ec2i_test.go'
--- ec2/ec2i_test.go	2013-01-31 14:52:05 +0000
+++ ec2/ec2i_test.go	2013-10-24 00:16:37 +0000
@@ -32,27 +32,35 @@
 }
 
 func (s *AmazonClientSuite) SetUpSuite(c *C) {
-	if !testutil.Amazon {
+	if testutil.AmazonRegion == nil {
 		c.Skip("AmazonClientSuite tests not enabled")
 	}
 	s.srv.SetUp(c)
-	s.ec2 = ec2.New(s.srv.auth, aws.USEast)
+	s.ec2 = ec2.New(s.srv.auth, *testutil.AmazonRegion)
+	s.GetImage = func(version, rootStore string) (string, error) {
+		return testutil.GetImageForRegion(s.ec2.Region, version, rootStore)
+	}
 }
 
+type imageGetter func(string, string) (string, error)
+
 // ClientTests defines integration tests designed to test the client.
 // It is not used as a test suite in itself, but embedded within
 // another type.
 type ClientTests struct {
-	ec2 *ec2.EC2
+	ec2      *ec2.EC2
+	GetImage imageGetter
 }
 
-var imageId = "ami-ccf405a5" // Ubuntu Maverick, i386, EBS store
-
 // Cost: 0.00 USD
 func (s *ClientTests) TestRunInstancesError(c *C) {
+	// Get an image id that used instance store, which can't be used on
+	// t1.micro machines, results in 400 error from RunInstances.
+	imageId, err := s.GetImage("12.04", "instance")
+	c.Assert(err, IsNil)
 	options := ec2.RunInstances{
-		ImageId:      "ami-a6f504cf", // Ubuntu Maverick, i386, instance store
-		InstanceType: "t1.micro",     // Doesn't work with micro, results in 400.
+		ImageId:      imageId,
+		InstanceType: "t1.micro",
 	}
 
 	resp, err := s.ec2.RunInstances(&options)
@@ -70,6 +78,8 @@
 
 // Cost: 0.02 USD
 func (s *ClientTests) TestRunAndTerminate(c *C) {
+	imageId, err := s.GetImage("12.04", "ebs")
+	c.Assert(err, IsNil)
 	options := ec2.RunInstances{
 		ImageId:      imageId,
 		InstanceType: "t1.micro",
 
=== modified file 'ec2/ec2t_test.go'
--- ec2/ec2t_test.go	2013-10-02 21:34:26 +0000
+++ ec2/ec2t_test.go	2013-10-24 00:16:37 +0000
@@ -46,6 +46,11 @@
 	s.srv.SetUp(c)
 	s.ServerTests.ec2 = ec2.New(s.srv.auth, s.srv.region)
 	s.clientTests.ec2 = ec2.New(s.srv.auth, s.srv.region)
+	getFakeImage := func(version, rootStore string) (string, error) {
+		return fmt.Sprintf("ami-fake-%v-%v", version, rootStore), nil
+	}
+	s.ServerTests.GetImage = getFakeImage
+	s.clientTests.GetImage = getFakeImage
 }
 
 func (s *LocalServerSuite) TestRunAndTerminate(c *C) {
@@ -64,7 +69,7 @@
 		data[i] = byte(i)
 	}
 	inst, err := s.ec2.RunInstances(&ec2.RunInstances{
-		ImageId:      imageId,
+		ImageId:      "ami-fakeimage",
 		InstanceType: "t1.micro",
 		UserData:     data,
 	})
@@ -82,7 +87,7 @@
 
 func (s *LocalServerSuite) TestInstanceInfo(c *C) {
 	list, err := s.ec2.RunInstances(&ec2.RunInstances{
-		ImageId:      imageId,
+		ImageId:      "ami-fakeimage",
 		InstanceType: "t1.micro",
 	})
 	c.Assert(err, IsNil)
@@ -113,11 +118,14 @@
 var _ = Suite(&AmazonServerSuite{})
 
 func (s *AmazonServerSuite) SetUpSuite(c *C) {
-	if !testutil.Amazon {
+	if testutil.AmazonRegion == nil {
 		c.Skip("AmazonServerSuite tests not enabled")
 	}
 	s.srv.SetUp(c)
-	s.ServerTests.ec2 = ec2.New(s.srv.auth, aws.USEast)
+	s.ServerTests.ec2 = ec2.New(s.srv.auth, *testutil.AmazonRegion)
+	s.GetImage = func(version string, rootStore string) (string, error) {
+		return testutil.GetImageForRegion(s.ec2.Region, version, rootStore)
+	}
 }
 
 // ServerTests defines a set of tests designed to test
@@ -125,7 +133,8 @@
 // It is not used as a test suite in itself, but embedded within
 // another type.
 type ServerTests struct {
-	ec2 *ec2.EC2
+	ec2      *ec2.EC2
+	GetImage imageGetter
 }
 
 func terminateInstances(c *C, e *ec2.EC2, insts []*ec2.Instance) {
@@ -313,10 +322,12 @@
 	group2 := groupResp.SecurityGroup
 	defer s.ec2.DeleteSecurityGroup(group2)
 
+	imageId1, err := s.GetImage("12.04", "ebs")
+	c.Assert(err, IsNil)
 	insts := make([]*ec2.Instance, 3)
 	inst, err := s.ec2.RunInstances(&ec2.RunInstances{
 		MinCount:       2,
-		ImageId:        imageId,
+		ImageId:        imageId1,
 		InstanceType:   "t1.micro",
 		SecurityGroups: []ec2.SecurityGroup{group1},
 	})
@@ -325,7 +336,8 @@
 	insts[1] = &inst.Instances[1]
 	defer terminateInstances(c, s.ec2, insts)
 
-	imageId2 := "ami-e358958a" // Natty server, i386, EBS store
+	imageId2, err := s.GetImage("13.10", "ebs")
+	c.Assert(err, IsNil)
 	inst, err = s.ec2.RunInstances(&ec2.RunInstances{
 		ImageId:        imageId2,
 		InstanceType:   "t1.micro",
@@ -405,14 +417,14 @@
 		}, {
 			about: "check that filtering on image id works",
 			filters: []filterSpec{
-				{"image-id", []string{imageId}},
+				{"image-id", []string{imageId1}},
 			},
 			resultIds:  ids(0, 1),
 			allowExtra: true,
 		}, {
 			about: "combination filters 1",
 			filters: []filterSpec{
-				{"image-id", []string{imageId, imageId2}},
+				{"image-id", []string{imageId1, imageId2}},
 				{"group-name", []string{group1.Name}},
 			},
 			resultIds: ids(0, 1),
 
=== modified file 'ec2/ec2test/server.go'
--- ec2/ec2test/server.go	2013-10-03 12:10:33 +0000
+++ ec2/ec2test/server.go	2013-10-24 00:16:37 +0000
@@ -66,7 +66,7 @@
 
 // instance holds a simulated ec2 instance
 type Instance struct {
-	seq         int
+	seq int
 	// UserData holds the data that was passed to the RunInstances request
 	// when the instance was started.
 	UserData    []byte
 
=== added file 'testutil/streams.go'
--- testutil/streams.go	1970-01-01 00:00:00 +0000
+++ testutil/streams.go	2013-10-24 00:16:37 +0000
@@ -0,0 +1,91 @@
+package testutil
+
+import (
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"launchpad.net/goamz/aws"
+	"net/http"
+)
+
+var streamsURL = "http://cloud-images.ubuntu.com/releases/streams/v1/com.ubuntu.cloud:released:aws.json"
+
+func fetchStreamsData(result interface{}) error {
+	response, err := http.Get(streamsURL)
+	if err != nil {
+		return fmt.Errorf("failed to fetch streams data: %v", err)
+	}
+	defer response.Body.Close()
+	contents, err := ioutil.ReadAll(response.Body)
+	if err != nil {
+		return fmt.Errorf("failed to read streams data: %v", err)
+	}
+	if response.StatusCode != 200 {
+		return fmt.Errorf("http error fetching streams data: %q", contents)
+	}
+	err = json.Unmarshal(contents, &result)
+	if err != nil {
+		return fmt.Errorf("failed to parse streams data: %v", err)
+	}
+	return nil
+}
+
+// TODO(gz): These structs are based on those in lp:juju-core simplestreams
+// code at environs/simplestreams/simplestreams.go which if split out into a
+// seperate module could be reused here instead.
+
+type CloudMetadata struct {
+	Products map[string]MetadataCatalog `json:"products"`
+	DataType string                     `json:"datatype"`
+}
+
+type MetadataCatalog struct {
+	Series  string `json:"release,omitempty"`
+	Version string `json:"version,omitempty"`
+	Arch    string `json:"arch,omitempty"`
+
+	Versions map[string]ItemCollection `json:"versions"`
+}
+
+type ItemCollection struct {
+	Items map[string]Item `json:"items"`
+}
+
+type Item struct {
+	RootStore string `json:"root_store"`
+	Virt      string `json:"virt"`
+	CRSN      string `json:"crsn"`
+	Id        string `json:"id"`
+}
+
+var streamsData *CloudMetadata
+
+// GetImageForRegion selects an ami string id from the published simplestreams
+// data matching the region, version, and root store values given.
+func GetImageForRegion(region aws.Region, version string, rootStore string) (string, error) {
+	if streamsData == nil {
+		err := fetchStreamsData(&streamsData)
+		if err != nil {
+			return "", err
+		}
+	}
+	for productKey, _ := range streamsData.Products {
+		product := streamsData.Products[productKey]
+		if version != product.Version {
+			continue
+		}
+		for versionsKey, _ := range product.Versions {
+			itemCollection := product.Versions[versionsKey]
+			for itemKey, _ := range itemCollection.Items {
+				item := itemCollection.Items[itemKey]
+				if item.Virt == "hvm" || item.RootStore != rootStore {
+					continue
+				}
+				if item.CRSN == region.Name {
+					return item.Id, nil
+				}
+			}
+		}
+	}
+	return "", fmt.Errorf("no image found for region:%v version:%v root_store:%v", region.Name, version, rootStore)
+}
 
=== added file 'testutil/streams_test.go'
--- testutil/streams_test.go	1970-01-01 00:00:00 +0000
+++ testutil/streams_test.go	2013-10-24 00:16:37 +0000
@@ -0,0 +1,150 @@
+package testutil
+
+import (
+	"encoding/json"
+	"testing"
+
+	gc "launchpad.net/gocheck"
+
+	"launchpad.net/goamz/aws"
+)
+
+func Test(t *testing.T) {
+	gc.TestingT(t)
+}
+
+func init() {
+	gc.Suite(&StreamsServerSuite{NewHTTPServer()})
+	gc.Suite(&StreamsSuite{})
+}
+
+type StreamsSuite struct{}
+
+type StreamsServerSuite struct {
+	Server *HTTPServer
+}
+
+func (s *StreamsServerSuite) SetUpSuite(c *gc.C) {
+	s.Server.Start()
+}
+
+func (s *StreamsServerSuite) TearDownTest(c *gc.C) {
+	s.Server.Flush()
+}
+
+func (s *StreamsServerSuite) TearDownSuite(c *gc.C) {
+	s.Server.Stop()
+}
+
+func (s *StreamsServerSuite) patchStreamsURL() func() {
+	origStreamsURL := streamsURL
+	streamsURL = s.Server.URL
+	return func() {
+		streamsURL = origStreamsURL
+	}
+}
+
+func (s *StreamsServerSuite) TestFetchStreams(c *gc.C) {
+	s.Server.Response(200, nil, "{}")
+
+	defer s.patchStreamsURL()()
+
+	result := make(map[string]interface{})
+	err := fetchStreamsData(&result)
+	c.Assert(err, gc.IsNil)
+	c.Check(result, gc.DeepEquals, map[string]interface{}{})
+}
+
+func (s *StreamsServerSuite) TestFetchStreamsServerError(c *gc.C) {
+	s.Server.Response(500, nil, "Server error")
+
+	defer s.patchStreamsURL()()
+
+	result := make(map[string]interface{})
+	err := fetchStreamsData(&result)
+	c.Assert(err, gc.NotNil)
+	c.Assert(err, gc.ErrorMatches, "http error.*Server error.*")
+}
+
+func (s *StreamsServerSuite) TestFetchStreamsBadJSON(c *gc.C) {
+	s.Server.Response(200, nil, "--junk-- {}")
+
+	defer s.patchStreamsURL()()
+
+	result := make(map[string]interface{})
+	err := fetchStreamsData(&result)
+	c.Assert(err, gc.NotNil)
+	c.Assert(err, gc.ErrorMatches, "failed to parse streams data: .*")
+}
+
+func (s *StreamsSuite) patchStreamsData(data string) func() {
+	cloudData := CloudMetadata{}
+	err := json.Unmarshal([]byte(data), &cloudData)
+	if err != nil {
+		panic(err)
+	}
+	streamsData = &cloudData
+	return func() {
+		streamsData = nil
+	}
+}
+
+var sampleStreamsData = `{
+ "updated": "Sun, 20 Oct 2013 13:48:35 +0000",
+ "format": "products:1.0",
+ "datatype": "image-ids",
+ "products": {
+  "com.ubuntu.cloud:server:13.10:amd64": {
+   "release": "saucy",
+   "version": "13.10",
+   "arch": "amd64",
+   "versions": {
+    "20130808": {
+     "items": {
+      "usww1pe": {
+       "root_store": "ebs",
+       "virt": "pv",
+       "crsn": "us-west-1",
+       "id": "ami-88ffd4cd"
+      },
+      "usww2he": {
+       "root_store": "ebs",
+       "virt": "hvm",
+       "crsn": "us-west-2",
+       "id": "ami-89f964b9"
+      },
+      "apne1pe": {
+       "root_store": "ebs",
+       "virt": "pv",
+       "crsn": "ap-northeast-1",
+       "id": "ami-1139a810"
+      },
+      "usee1pi": {
+       "root_store": "instance",
+       "virt": "pv",
+       "crsn": "us-east-1",
+       "id": "ami-eaafe883"
+      }
+     }
+    }
+   }
+  }
+ }
+}
+`
+
+func (s *StreamsSuite) TestFetchStreamsUSEast(c *gc.C) {
+	defer s.patchStreamsData(sampleStreamsData)()
+
+	imageId, err := GetImageForRegion(aws.USEast, "13.10", "ebs")
+	c.Assert(err, gc.IsNil)
+	c.Assert(imageId, gc.Equals, "ami-eaafe883")
+}
+
+func (s *StreamsSuite) TestFetchStreamsBadJSON(c *gc.C) {
+	defer s.patchStreamsData("{}")()
+
+	_, err := GetImageForRegion(aws.USEast, "13.10", "ebs")
+	c.Assert(err, gc.NotNil)
+	c.Assert(err, gc.ErrorMatches, "no image found for region.*")
+}
 
=== modified file 'testutil/suite.go'
--- testutil/suite.go	2013-01-31 14:52:05 +0000
+++ testutil/suite.go	2013-10-24 00:16:37 +0000
@@ -1,17 +1,36 @@
 package testutil
 
 import (
+	"errors"
 	"flag"
 	"launchpad.net/goamz/aws"
 	. "launchpad.net/gocheck"
 )
 
-// Amazon must be used by all tested packages to determine whether to
-// run functional tests against the real AWS servers.
-var Amazon bool
+// AmazonRegion must be used by all tested packages to determine which region
+// to use when runnong functional tests against the real AWS servers, and
+// disable those tests if nil.
+var AmazonRegion *aws.Region
+
+type amazonRegionValue struct {
+	flag.Value
+}
+
+func (v *amazonRegionValue) String() string {
+	return "REGION"
+}
+
+func (v *amazonRegionValue) Set(val string) error {
+	region, ok := aws.Regions[val]
+	if !ok {
+		return errors.New("not an AWS region")
+	}
+	AmazonRegion = &region
+	return nil
+}
 
 func init() {
-	flag.BoolVar(&Amazon, "amazon", false, "Enable tests against amazon server")
+	flag.Var(&amazonRegionValue{}, "amazon", "Region to enable tests against amazon server")
 }
 
 type LiveSuite struct {
@@ -19,7 +38,7 @@
 }
 
 func (s *LiveSuite) SetUpSuite(c *C) {
-	if !Amazon {
+	if AmazonRegion == nil {
 		c.Skip("amazon tests not enabled (-amazon flag)")
 	}
 	auth, err := aws.EnvAuth()