state/api/params: add CharmURL to ServiceInfo

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/constraints"
         "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"
+        "launchpad.net/juju-core/version"
         "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)
@@ skipping 71 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) TestInstanceAttributes(c *C) {
-        inst, err := t.Env.StartInstance("30", constraints.Value{}, testing.InvalidStateInfo("30"), testing.InvalidAPIInfo("30"), nil)
-        c.Assert(err, IsNil)
+        inst := testing.StartInstance(c, t.Env, "30")
         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([]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)
         c.Assert(ec2inst.InstanceType, Equals, "m1.small")
 }
 
 func (t *LiveTests) TestStartInstanceConstraints(c *C) {
         cons, err := constraints.Parse("mem=2G")
         c.Assert(err, IsNil)
-        inst, err := t.Env.StartInstance("31", cons, testing.InvalidStateInfo("31"), testing.InvalidAPIInfo("31"), nil)
+        inst, err := t.Env.StartInstance("31", version.Current.Series, cons, testing.InvalidStateInfo("31"), testing.InvalidAPIInfo("31"))
         c.Assert(err, IsNil)
         defer t.Env.StopInstances([]environs.Instance{inst})
         ec2inst := ec2.InstanceEC2(inst)
         c.Assert(ec2inst.InstanceType, Equals, "m1.medium")
 }
 
 func (t *LiveTests) TestInstanceGroups(c *C) {
         ec2conn := ec2.EnvironEC2(t.Env)
 
         groups := amzec2.SecurityGroupNames(
@@ skipping 21 matching lines @@
                         },
                         {
                                 Protocol:  "udp",
                                 FromPort:  4321,
                                 ToPort:    4322,
                                 SourceIPs: []string{"3.4.5.6/32"},
                         },
                 })
         c.Assert(err, IsNil)
 
-        inst0, err := t.Env.StartInstance("98", constraints.Value{}, testing.InvalidStateInfo("98"), testing.InvalidAPIInfo("98"), nil)
-        c.Assert(err, IsNil)
+        inst0 := testing.StartInstance(c, t.Env, "98")
         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", constraints.Value{}, testing.InvalidStateInfo("99"), testing.InvalidAPIInfo("99"), nil)
-        c.Assert(err, IsNil)
+        inst1 := testing.StartInstance(c, t.Env, "99")
         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
                 for _, g := range groupsResp.Groups {
@@ skipping 110 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", constraints.Value{}, testing.InvalidStateInfo("40"), testing.InvalidAPIInfo("40"), nil)
-        c.Assert(err, IsNil)
-
+        inst0 := testing.StartInstance(c, t.Env, "40")
         inst1 := ec2.FabricateInstance(inst0, "i-aaaaaaaa")
-
-        inst2, err := t.Env.StartInstance("41", constraints.Value{}, testing.InvalidStateInfo("41"), testing.InvalidAPIInfo("41"), nil)
-        c.Assert(err, IsNil)
-
-        err = t.Env.StopInstances([]environs.Instance{inst0, inst1, inst2})
+        inst2 := testing.StartInstance(c, t.Env, "41")
+
+        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([]state.InstanceId{inst0.Id(), inst2.Id()})
@@ skipping 81 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
 }