environs/ec2: respect default series

environs/ec2/live_test.go

 package ec2_test
 
 import (
         "crypto/rand"
         "fmt"
         "io"
         "io/ioutil"
         amzec2 "launchpad.net/goamz/ec2"
         . "launchpad.net/gocheck"
         "launchpad.net/juju-core/environs"
         "launchpad.net/juju-core/environs/ec2"
         "launchpad.net/juju-core/environs/jujutest"
         "launchpad.net/juju-core/juju/testing"
+        "launchpad.net/juju-core/state"
         coretesting "launchpad.net/juju-core/testing"
         "strings"
 )
 
 // uniqueName is generated afresh for every test run, so that
 // we are not polluted by previous test state.
 var uniqueName = randomName()
 
 func randomName() string {
         buf := make([]byte, 8)
         _, err := io.ReadFull(rand.Reader, buf)
         if err != nil {
                 panic(fmt.Sprintf("error from crypto rand: %v", err))
         }
         return fmt.Sprintf("%x", buf)
 }
 
 func registerAmazonTests() {
         // The following attributes hold the environment configuration
         // for running the amazon EC2 integration tests.
         //
         // This is missing keys for security reasons; set the following
         // environment variables to make the Amazon testing work:
         //  access-key: $AWS_ACCESS_KEY_ID
         //  secret-key: $AWS_SECRET_ACCESS_KEY
         //
         // default-series must not be specified, hence defaulting to the
         // series of the machine running the tests. This behavior is
         // required because --upload-tools will not create tools for
-        // other series'.

[rog, 2012/11/21 10:27:05]

s/'//

[dave_cheney.net, 2012/11/21 11:42:48]

Done.

+        // other series.
         attrs := map[string]interface{}{
                 "name":           "sample-" + uniqueName,
                 "type":           "ec2",
                 "control-bucket": "juju-test-" + uniqueName,
                 "public-bucket":  "juju-public-test-" + uniqueName,
                 "admin-secret":   "for real",
+                "ca-cert":        coretesting.CACert,
+                "ca-private-key": coretesting.CAKey,
         }
         Suite(&LiveTests{
                 LiveTests: jujutest.LiveTests{
                         Config:         attrs,
                         Attempt:        *ec2.ShortAttempt,
                         CanOpenState:   true,
                         HasProvisioner: true,
                 },
         })
 }
@@ skipping 33 matching lines @@
 }
 
 func (t *LiveTests) TearDownTest(c *C) {
         t.LiveTests.TearDownTest(c)
         t.LoggingSuite.TearDownTest(c)
 }
 
 // TODO(niemeyer): Looks like many of those tests should be moved to jujutest.LiveTests.
 
 func (t *LiveTests) TestInstanceDNSName(c *C) {
-        inst, err := t.Env.StartInstance(30, testing.InvalidStateInfo(30), nil)
+        inst, err := t.Env.StartInstance("30", testing.InvalidStateInfo("30"), nil)
         c.Assert(err, IsNil)
         defer t.Env.StopInstances([]environs.Instance{inst})
         dns, err := inst.WaitDNSName()
         // TODO(niemeyer): This assert sometimes fails with "no instances found"
         c.Assert(err, IsNil)
         c.Assert(dns, Not(Equals), "")
 
-        insts, err := t.Env.Instances([]string{inst.Id()})
+        insts, err := t.Env.Instances([]state.InstanceId{inst.Id()})
         c.Assert(err, IsNil)
         c.Assert(len(insts), Equals, 1)
 
         ec2inst := ec2.InstanceEC2(insts[0])
         c.Assert(ec2inst.DNSName, Equals, dns)
 }
 
 func (t *LiveTests) TestInstanceGroups(c *C) {
         ec2conn := ec2.EnvironEC2(t.Env)
 
         groups := amzec2.SecurityGroupNames(
                 ec2.JujuGroupName(t.Env),
-                ec2.MachineGroupName(t.Env, 98),
-                ec2.MachineGroupName(t.Env, 99),
+                ec2.MachineGroupName(t.Env, "98"),
+                ec2.MachineGroupName(t.Env, "99"),
         )
         info := make([]amzec2.SecurityGroupInfo, len(groups))
 
         // Create a group with the same name as the juju group
         // but with different permissions, to check that it's deleted
         // and recreated correctly.
         oldJujuGroup := createGroup(c, ec2conn, groups[0].Name, "old juju group")
 
         // Add two permissions: one is required and should be left alone;
         // the other is not and should be deleted.
         // N.B. this is unfortunately sensitive to the actual set of permissions used.
         _, err := ec2conn.AuthorizeSecurityGroup(oldJujuGroup,
                 []amzec2.IPPerm{
                         {
                                 Protocol:  "tcp",
                                 FromPort:  22,
                                 ToPort:    22,
                                 SourceIPs: []string{"0.0.0.0/0"},
                         },
                         {
                                 Protocol:  "udp",
                                 FromPort:  4321,
                                 ToPort:    4322,
                                 SourceIPs: []string{"3.4.5.6/32"},
                         },
                 })
         c.Assert(err, IsNil)
 
-        inst0, err := t.Env.StartInstance(98, testing.InvalidStateInfo(98), nil)
+        inst0, err := t.Env.StartInstance("98", testing.InvalidStateInfo("98"), nil)
         c.Assert(err, IsNil)
         defer t.Env.StopInstances([]environs.Instance{inst0})
 
         // Create a same-named group for the second instance
         // before starting it, to check that it's reused correctly.
         oldMachineGroup := createGroup(c, ec2conn, groups[2].Name, "old machine group")
 
-        inst1, err := t.Env.StartInstance(99, testing.InvalidStateInfo(99), nil)
+        inst1, err := t.Env.StartInstance("99", testing.InvalidStateInfo("99"), nil)
         c.Assert(err, IsNil)
         defer t.Env.StopInstances([]environs.Instance{inst1})
 
         groupsResp, err := ec2conn.SecurityGroups(groups, nil)
         c.Assert(err, IsNil)
         c.Assert(groupsResp.Groups, HasLen, len(groups))
 
         // For each group, check that it exists and record its id.
         for i, group := range groups {
                 found := false
@@ skipping 11 matching lines @@
         }
 
         // The old juju group should have been reused.
         c.Check(groups[0].Id, Equals, oldJujuGroup.Id)
 
         // Check that it authorizes the correct ports and there
         // are no extra permissions (in particular we are checking
         // that the unneeded permission that we added earlier
         // has been deleted).
         perms := info[0].IPPerms
-        c.Assert(perms, HasLen, 4)
-        checkPortAllowed(c, perms, 22)
+        c.Assert(perms, HasLen, 5)
+        checkPortAllowed(c, perms, 22)    // SSH
+        checkPortAllowed(c, perms, 37017) // MongoDB
         checkSecurityGroupAllowed(c, perms, groups[0])
 
         // The old machine group should have been reused also.
         c.Check(groups[2].Id, Equals, oldMachineGroup.Id)
 
         // Check that each instance is part of the correct groups.
-        resp, err := ec2conn.Instances([]string{inst0.Id(), inst1.Id()}, nil)
+        resp, err := ec2conn.Instances([]string{string(inst0.Id()), string(inst1.Id())}, nil)
         c.Assert(err, IsNil)
         c.Assert(resp.Reservations, HasLen, 2)
         for _, r := range resp.Reservations {
                 c.Assert(r.Instances, HasLen, 1)
                 // each instance must be part of the general juju group.
                 msg := Commentf("reservation %#v", r)
                 c.Assert(hasSecurityGroup(r, groups[0]), Equals, true, msg)
                 inst := r.Instances[0]
-                switch inst.InstanceId {
+                switch state.InstanceId(inst.InstanceId) {
                 case inst0.Id():
                         c.Assert(hasSecurityGroup(r, groups[1]), Equals, true, msg)
                         c.Assert(hasSecurityGroup(r, groups[2]), Equals, false, msg)
                 case inst1.Id():
                         c.Assert(hasSecurityGroup(r, groups[2]), Equals, true, msg)
                         c.Assert(hasSecurityGroup(r, groups[1]), Equals, false, msg)
                 default:
                         c.Errorf("unknown instance found: %v", inst)
                 }
         }
@@ skipping 60 matching lines @@
         }
         if len(protos) > 0 {
                 c.Errorf("%d security group permission not found for %#v in %#v", len(protos), g, perms)
         }
 }
 
 func (t *LiveTests) TestStopInstances(c *C) {
         // It would be nice if this test was in jujutest, but
         // there's no way for jujutest to fabricate a valid-looking
         // instance id.
-        inst0, err := t.Env.StartInstance(40, testing.InvalidStateInfo(40), nil)
+        inst0, err := t.Env.StartInstance("40", testing.InvalidStateInfo("40"), nil)
         c.Assert(err, IsNil)
 
         inst1 := ec2.FabricateInstance(inst0, "i-aaaaaaaa")
 
-        inst2, err := t.Env.StartInstance(41, testing.InvalidStateInfo(41), nil)
+        inst2, err := t.Env.StartInstance("41", testing.InvalidStateInfo("41"), nil)
         c.Assert(err, IsNil)
 
         err = t.Env.StopInstances([]environs.Instance{inst0, inst1, inst2})
         c.Check(err, IsNil)
 
         var insts []environs.Instance
 
         // We need the retry logic here because we are waiting
         // for Instances to return an error, and it will not retry
         // if it succeeds.
         gone := false
         for a := ec2.ShortAttempt.Start(); a.Next(); {
-                insts, err = t.Env.Instances([]string{inst0.Id(), inst2.Id()})
+                insts, err = t.Env.Instances([]state.InstanceId{inst0.Id(), inst2.Id()})
                 if err == environs.ErrPartialInstances {
                         // instances not gone yet.
                         continue
                 }
                 if err == environs.ErrNoInstances {
                         gone = true
                         break
                 }
                 c.Fatalf("error getting instances: %v", err)
         }
@@ skipping 71 matching lines @@
 }
 
 func hasSecurityGroup(r amzec2.Reservation, g amzec2.SecurityGroup) bool {
         for _, rg := range r.SecurityGroups {
                 if rg.Id == g.Id {
                         return true
                 }
         }
         return false
 }