state: drop RelationUnit.Pinger; consequences

state/relation_test.go

 package state_test
 
 import (
         "fmt"
         . "launchpad.net/gocheck"
         "launchpad.net/juju-core/charm"
         "launchpad.net/juju-core/state"
         "sort"
         "strings"
         "time"
@@ skipping 692 matching lines @@
 
         // ...and check that the first relation unit sees the change.
         s1, err := ru1.Settings()
         c.Assert(err, IsNil)
         expectChanged := map[string]map[string]interface{}{
                 "peer/1": s1.Map(),
         }
         s.assertChange(c, w0, []string{"peer/1"}, expectChanged, nil)
         s.assertNoChange(c, w0)
 
+        // Join again, check it's a no-op.
+        err = ru1.EnterScope()
+        c.Assert(err, IsNil)
+        s.assertNoChange(c, w0)
+
         // Start watching the relation from the perspective of the second unit,
         // and check that it sees the right state.
         w1 := ru1.Watch()
         defer stop(c, w1)
         expectChanged = map[string]map[string]interface{}{
                 "peer/0": s0.Map(),
         }
         s.assertChange(c, w1, []string{"peer/0"}, expectChanged, nil)
         s.assertNoChange(c, w1)
 
@@ skipping 140 matching lines @@
         c.Assert(err, IsNil)
         reqs0, err := reqru0.Settings()
         c.Assert(err, IsNil)
         expectJoined = []string{"req/0"}
         expectChanged = map[string]map[string]interface{}{
                 "req/0": reqs0.Map(),
         }
         s.assertChange(c, prow0, expectJoined, expectChanged, nil)
         s.assertNoChange(c, prow0)
         s.assertChange(c, prow1, expectJoined, expectChanged, nil)
+        s.assertNoChange(c, prow1)
+
+        // Join again, check no-op.
+        err = reqru0.EnterScope()
+        c.Assert(err, IsNil)
+        s.assertNoChange(c, prow0)
         s.assertNoChange(c, prow1)
 
         // Join the second requirer, and check the provider units see the change.
         err = reqru1.EnterScope()
         c.Assert(err, IsNil)
         reqs1, err := reqru1.Settings()
         c.Assert(err, IsNil)
         expectJoined = []string{"req/1"}
         expectChanged = map[string]map[string]interface{}{
                 "req/1": reqs1.Map(),
@@ skipping 231 matching lines @@
 }
 
 func (s *OriginalRelationUnitSuite) assertNoChange(c *C, w *state.RelationUnitsWatcher) {
         s.State.StartSync()
         select {
         case ch := <-w.Changes():
                 c.Fatalf("got %#v, expected nothing", ch)
         case <-time.After(50 * time.Millisecond):
         }
 }