environs/jujutest: use AttemptStrategy

environs/jujutest/livetests.go

 package jujutest
 
 import (
         "fmt"
         . "launchpad.net/gocheck"
         "launchpad.net/juju-core/charm"
         "launchpad.net/juju-core/environs"
         "launchpad.net/juju-core/environs/config"
         "launchpad.net/juju-core/juju"
         "launchpad.net/juju-core/juju/testing"
@@ skipping 105 matching lines @@
 
         insts, err = t.Env.Instances([]string{id0, ""})
         c.Assert(err, Equals, environs.ErrPartialInstances)
         c.Assert(insts, HasLen, 2)
         c.Check(insts[0].Id(), Equals, id0)
         c.Check(insts[1], IsNil)
 
         err = t.Env.StopInstances([]environs.Instance{inst})
         c.Assert(err, IsNil)
 
-        // Stopping may not be noticed at first due to eventual
-        // consistency. Repeat a few times to ensure we get the error.
+        // The machine may not be marked as shutting down
+        // immediately. Repeat a few times to ensure we get the error.
         for a := t.Attempt.Start(); a.Next(); {
                 insts, err = t.Env.Instances([]string{id0})
                 if err != nil {
                         break
                 }
         }
         c.Assert(err, Equals, environs.ErrNoInstances)
         c.Assert(insts, HasLen, 0)
 }
 
@@ skipping 66 matching lines @@
         err = inst1.ClosePorts(1, []state.Port{{"tcp", 45}, {"udp", 67}})
         c.Assert(err, IsNil)
         ports, err = inst1.Ports(1)
         c.Assert(ports, HasLen, 0)
 
         // Check that we can close ports that aren't there.
         err = inst2.ClosePorts(2, []state.Port{{"tcp", 111}, {"udp", 222}})
         c.Assert(err, IsNil)
         ports, err = inst2.Ports(2)
         c.Assert(ports, DeepEquals, []state.Port{{"tcp", 89}})
+
+        // Check errors when acting on environment.
+        err = t.Env.OpenPorts([]state.Port{{"tcp", 80}})
+        c.Assert(err, ErrorMatches, `invalid firewall mode for opening ports on environment: "instance"`)
+
+        err = t.Env.ClosePorts([]state.Port{{"tcp", 80}})
+        c.Assert(err, ErrorMatches, `invalid firewall mode for closing ports on environment: "instance"`)
+
+        _, err = t.Env.Ports()
+        c.Assert(err, ErrorMatches, `invalid firewall mode for retrieving ports from environment: "instance"`)
 }
 
 func (t *LiveTests) TestGlobalPorts(c *C) {
         // Change configuration.
         oldConfig := t.Env.Config()
         defer func() {
                 err := t.Env.SetConfig(oldConfig)
                 c.Assert(err, IsNil)
         }()
 
@@ skipping 34 matching lines @@
         c.Assert(err, IsNil)
         c.Assert(ports, DeepEquals, []state.Port{{"tcp", 45}, {"tcp", 89}})
 
         // Check that we can close ports that aren't there.
         err = t.Env.ClosePorts([]state.Port{{"tcp", 111}, {"udp", 222}})
         c.Assert(err, IsNil)
 
         ports, err = t.Env.Ports()
         c.Assert(err, IsNil)
         c.Assert(ports, DeepEquals, []state.Port{{"tcp", 45}, {"tcp", 89}})
+
+        // Check errors when acting on instances.
+        err = inst1.OpenPorts(1, []state.Port{{"tcp", 80}})
+        c.Assert(err, ErrorMatches, `invalid firewall mode for opening ports on instance: "global"`)
+
+        err = inst1.ClosePorts(1, []state.Port{{"tcp", 80}})
+        c.Assert(err, ErrorMatches, `invalid firewall mode for closing ports on instance: "global"`)
+
+        _, err = inst1.Ports(1)
+        c.Assert(err, ErrorMatches, `invalid firewall mode for retrieving ports from instance: "global"`)
 }
 
 func (t *LiveTests) TestBootstrapMultiple(c *C) {
         t.BootstrapOnce(c)
 
-        var err error
-        for a := t.Attempt.Start(); a.Next(); {
-                if err = t.Env.Bootstrap(false); err != nil {
-                        break
-                }
-        }
+        err := t.Env.Bootstrap(false)
         c.Assert(err, ErrorMatches, "environment is already bootstrapped")
 
         c.Logf("destroy env")
         t.Destroy(c)
         t.Destroy(c) // Again, should work fine and do nothing.
 
         // check that we can bootstrap after destroy
         t.BootstrapOnce(c)
 }
 
@@ skipping 347 matching lines @@
         }
 
         inst, err := t.Env.StartInstance(4, testing.InvalidStateInfo(4), tools)
         if inst != nil {
                 err := t.Env.StopInstances([]environs.Instance{inst})
                 c.Check(err, IsNil)
         }
         c.Assert(inst, IsNil)
         c.Assert(err, ErrorMatches, "cannot find image.*")
 }