various: use TLS

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)
@@ skipping 66 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 12 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, 5)
-        checkPortAllowed(c, perms, 22)
-        checkPortAllowed(c, perms, ec2.MgoPort)

[niemeyer, 2012/11/28 15:58:37]

37017 should be tested explicitly, otherwise we're testing N against N, without
any idea of what N really is. A mistaken change goes through unnoticed.

[rog, 2012/11/28 18:08:05]

Done.

[niemeyer, 2012/11/28 18:37:51]

Apparently not.

+        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
 }