cmd/jujud: do not change password

state/relationunit_test.go

 // Copyright 2013 Canonical Ltd.
 // Licensed under the AGPLv3, see LICENCE file for details.
 
 package state_test
 
 import (
         . "launchpad.net/gocheck"
         "launchpad.net/juju-core/charm"
         "launchpad.net/juju-core/errors"
         "launchpad.net/juju-core/state"
@@ skipping 324 matching lines @@
         c.Assert(err, IsNil)
         err = pr.ru3.EnterScope(nil)
         c.Assert(err, Equals, state.ErrCannotEnterScope)
 }
 
 func (s *RelationUnitSuite) TestPeerWatchScope(c *C) {
         pr := NewPeerRelation(c, &s.ConnSuite)
 
         // Test empty initial event.
         w0 := pr.ru0.WatchScope()
-        defer stop(c, w0)
+        defer AssertStop(c, w0)
         s.assertScopeChange(c, w0, nil, nil)
         s.assertNoScopeChange(c, w0)
 
         // ru0 enters; check no change, but settings written.
         err := pr.ru0.EnterScope(map[string]interface{}{"foo": "bar"})
         c.Assert(err, IsNil)
         s.assertNoScopeChange(c, w0)
         node, err := pr.ru0.Settings()
         c.Assert(err, IsNil)
         c.Assert(node.Map(), DeepEquals, map[string]interface{}{"foo": "bar"})
 
         // ru1 enters; check change is observed.
         err = pr.ru1.EnterScope(nil)
         c.Assert(err, IsNil)
         s.assertScopeChange(c, w0, []string{"riak/1"}, nil)
         s.assertNoScopeChange(c, w0)
 
         // ru1 enters again, check no problems and no changes.
         err = pr.ru1.EnterScope(nil)
         c.Assert(err, IsNil)
         s.assertNoScopeChange(c, w0)
 
         // Stop watching; ru2 enters.
-        stop(c, w0)
+        AssertStop(c, w0)
         err = pr.ru2.EnterScope(nil)
         c.Assert(err, IsNil)
 
         // Start watch again, check initial event.
         w0 = pr.ru0.WatchScope()
-        defer stop(c, w0)
+        defer AssertStop(c, w0)
         s.assertScopeChange(c, w0, []string{"riak/1", "riak/2"}, nil)
         s.assertNoScopeChange(c, w0)
 
         // ru1 leaves; check event.
         err = pr.ru1.LeaveScope()
         c.Assert(err, IsNil)
         s.assertScopeChange(c, w0, nil, []string{"riak/1"})
         s.assertNoScopeChange(c, w0)
 
         // ru1 leaves again; check no problems and no changes.
         err = pr.ru1.LeaveScope()
         c.Assert(err, IsNil)
         s.assertNoScopeChange(c, w0)
 }
 
 func (s *RelationUnitSuite) TestProReqWatchScope(c *C) {
         prr := NewProReqRelation(c, &s.ConnSuite, charm.ScopeGlobal)
 
         // Test empty initial events for all RUs.
         ws := prr.watches()
         for _, w := range ws {
-                defer stop(c, w)
+                defer AssertStop(c, w)
         }
         for _, w := range ws {
                 s.assertScopeChange(c, w, nil, nil)
         }
         s.assertNoScopeChange(c, ws...)
 
         // pru0 enters; check detected only by req RUs.
         err := prr.pru0.EnterScope(nil)
         c.Assert(err, IsNil)
         rws := func() []*state.RelationScopeWatcher {
@@ skipping 10 matching lines @@
         pws := func() []*state.RelationScopeWatcher {
                 return []*state.RelationScopeWatcher{ws[0], ws[1]}
         }
         for _, w := range pws() {
                 s.assertScopeChange(c, w, []string{"wordpress/0"}, nil)
         }
         s.assertNoScopeChange(c, ws...)
 
         // Stop watches; remaining RUs enter.
         for _, w := range ws {
-                stop(c, w)
+                AssertStop(c, w)
         }
         err = prr.pru1.EnterScope(nil)
         c.Assert(err, IsNil)
         err = prr.rru1.EnterScope(nil)
         c.Assert(err, IsNil)
 
         // Start new watches, check initial events.
         ws = prr.watches()
         for _, w := range ws {
-                defer stop(c, w)
+                defer AssertStop(c, w)
         }
         for _, w := range pws() {
                 s.assertScopeChange(c, w, []string{"wordpress/0", "wordpress/1"}, nil)
         }
         for _, w := range rws() {
                 s.assertScopeChange(c, w, []string{"mysql/0", "mysql/1"}, nil)
         }
         s.assertNoScopeChange(c, ws...)
 
         // pru0 leaves; check detected only by req RUs.
@@ skipping 12 matching lines @@
         }
         s.assertNoScopeChange(c, ws...)
 }
 
 func (s *RelationUnitSuite) TestContainerWatchScope(c *C) {
         prr := NewProReqRelation(c, &s.ConnSuite, charm.ScopeContainer)
 
         // Test empty initial events for all RUs.
         ws := prr.watches()
         for _, w := range ws {
-                defer stop(c, w)
+                defer AssertStop(c, w)
         }
         for _, w := range ws {
                 s.assertScopeChange(c, w, nil, nil)
         }
         s.assertNoScopeChange(c, ws...)
 
         // pru0 enters; check detected only by same-container req.
         err := prr.pru0.EnterScope(nil)
         c.Assert(err, IsNil)
         s.assertScopeChange(c, ws[2], []string{"mysql/0"}, nil)
         s.assertNoScopeChange(c, ws...)
 
         // req1 enters; check detected only by same-container pro.
         err = prr.rru1.EnterScope(nil)
         c.Assert(err, IsNil)
         s.assertScopeChange(c, ws[1], []string{"logging/1"}, nil)
         s.assertNoScopeChange(c, ws...)
 
         // Stop watches; remaining RUs enter scope.
         for _, w := range ws {
-                stop(c, w)
+                AssertStop(c, w)
         }
         err = prr.pru1.EnterScope(nil)
         c.Assert(err, IsNil)
         err = prr.rru0.EnterScope(nil)
         c.Assert(err, IsNil)
 
         // Start new watches, check initial events.
         ws = prr.watches()
         for _, w := range ws {
-                defer stop(c, w)
+                defer AssertStop(c, w)
         }
         s.assertScopeChange(c, ws[0], []string{"logging/0"}, nil)
         s.assertScopeChange(c, ws[1], []string{"logging/1"}, nil)
         s.assertScopeChange(c, ws[2], []string{"mysql/0"}, nil)
         s.assertScopeChange(c, ws[3], []string{"mysql/1"}, nil)
         s.assertNoScopeChange(c, ws...)
 
         // pru0 leaves; check detected only by same-container req.
         err = prr.pru0.LeaveScope()
         c.Assert(err, IsNil)
@@ skipping 126 matching lines @@
                                         break
                                 }
                         }
                         if !found {
                                 u = unit
                                 break
                         }
                 }
                 c.Assert(u, NotNil)
         }
+        preventUnitDestroyRemove(c, u)
         ru, err := rel.Unit(u)
         c.Assert(err, IsNil)
         return u, ru
 }
 
 type RUs []*state.RelationUnit
-
-type stopper interface {
-        Stop() error
-}
-
-func stop(c *C, s stopper) {
-        c.Assert(s.Stop(), IsNil)
-}