cmd/jujud: do not change password

environs/ec2/live_test.go

 // Copyright 2011, 2012, 2013 Canonical Ltd.
 // Licensed under the AGPLv3, see LICENCE file for details.
 
 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/config"
         "launchpad.net/juju-core/environs/ec2"
         "launchpad.net/juju-core/environs/jujutest"
         envtesting "launchpad.net/juju-core/environs/testing"
         "launchpad.net/juju-core/errors"
+        "launchpad.net/juju-core/instance"
         "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 74 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 := testing.StartInstance(c, t.Env, "30")
-        defer t.Env.StopInstances([]environs.Instance{inst})
+        defer t.Env.StopInstances([]instance.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()})
+        insts, err := t.Env.Instances([]instance.Id{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 := constraints.MustParse("mem=2G")
-        inst, err := t.Env.StartInstance("31", "fake_nonce", config.DefaultSeries, cons, testing.InvalidStateInfo("31"), testing.InvalidAPIInfo("31"))
+        inst, err := t.Env.StartInstance("31", "fake_nonce", config.DefaultSeries, cons, testing.FakeStateInfo("31"), testing.FakeAPIInfo("31"))
         c.Assert(err, IsNil)
-        defer t.Env.StopInstances([]environs.Instance{inst})
+        defer t.Env.StopInstances([]instance.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(
                 ec2.JujuGroupName(t.Env),
                 ec2.MachineGroupName(t.Env, "98"),
@@ skipping 20 matching lines @@
                         {
                                 Protocol:  "udp",
                                 FromPort:  4321,
                                 ToPort:    4322,
                                 SourceIPs: []string{"3.4.5.6/32"},
                         },
                 })
         c.Assert(err, IsNil)
 
         inst0 := testing.StartInstance(c, t.Env, "98")
-        defer t.Env.StopInstances([]environs.Instance{inst0})
+        defer t.Env.StopInstances([]instance.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 := testing.StartInstance(c, t.Env, "99")
-        defer t.Env.StopInstances([]environs.Instance{inst1})
+        defer t.Env.StopInstances([]instance.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 {
                         if g.Name == group.Name {
@@ skipping 28 matching lines @@
         // Check that each instance is part of the correct groups.
         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 state.InstanceId(inst.InstanceId) {
+                switch instance.Id(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 64 matching lines @@
 }
 
 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 := testing.StartInstance(c, t.Env, "40")
         inst1 := ec2.FabricateInstance(inst0, "i-aaaaaaaa")
         inst2 := testing.StartInstance(c, t.Env, "41")
 
-        err := t.Env.StopInstances([]environs.Instance{inst0, inst1, inst2})
+        err := t.Env.StopInstances([]instance.Instance{inst0, inst1, inst2})
         c.Check(err, IsNil)
 
-        var insts []environs.Instance
+        var insts []instance.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()})
+                insts, err = t.Env.Instances([]instance.Id{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
 }