Merge lp:~fwereade/juju-core/reinstate-relation-watch-tests into lp:~go-bot/juju-core/trunk

[William Reade]

state: reinstate accidentally-dropped tests

Aside from removal of the tests for the Joined field (which is no longer sent,
because it's redundant (preexisting change)), this was a mechanical rename
job from the original. It's reassuring to observe that behaviour had not
otherwise changed detectably in the interim.

https://codereview.appspot.com/13401045/

state: reinstate accidentally-dropped tests

Aside from removal of the tests for the Joined field (which is no longer sent,
because it's redundant (preexisting change)), this was a mechanical rename
job from the original. It's reassuring to observe that behaviour had not
otherwise changed detectably in the interim.

https://codereview.appspot.com/13401045/

[William Reade (fwereade)]

Reviewers: mp+183189_code.launchpad.net,

Message:
Please take a look.

Description:
state: reinstate accidentally-dropped tests

Aside from removal of the tests for the Joined field (which is no longer
sent,
because it's redundant (preexisting change)), this was a mechanical
rename
job from the original. It's reassuring to observe that behaviour had not
otherwise changed detectably in the interim.

https://code.launchpad.net/~fwereade/juju-core/reinstate-relation-watch-tests/+merge/183189

(do not edit description out of merge proposal)

Please review this at https://codereview.appspot.com/13401045/

Affected files:
   A [revision details]
   M state/relationunit_test.go

[Roger Peppe (rogpeppe)]

On 2013/08/30 14:30:20, fwereade wrote:
> Please take a look.

assuming this is mechanical and pre-reviewed, LGTM.

https://codereview.appspot.com/13401045/

=== modified file 'state/relationunit_test.go'
--- state/relationunit_test.go	2013-08-20 15:29:55 +0000
+++ state/relationunit_test.go	2013-08-30 14:19:19 +0000
@@ -4,7 +4,9 @@
 package state_test
 
 import (
+	"fmt"
 	"sort"
+	"strconv"
 	"time"
 
 	gc "launchpad.net/gocheck"
@@ -14,9 +16,11 @@
 	"launchpad.net/juju-core/state"
 	"launchpad.net/juju-core/state/testing"
 	coretesting "launchpad.net/juju-core/testing"
-	"launchpad.net/juju-core/testing/checkers"
+	jc "launchpad.net/juju-core/testing/checkers"
 )
 
+type RUs []*state.RelationUnit
+
 type RelationUnitSuite struct {
 	ConnSuite
 }
@@ -325,7 +329,7 @@
 	c.Assert(err, gc.IsNil)
 	s.assertInScope(c, pr.ru1, false)
 	err = rel.Refresh()
-	c.Assert(err, checkers.Satisfies, errors.IsNotFoundError)
+	c.Assert(err, jc.Satisfies, errors.IsNotFoundError)
 
 	// The settings were not themselves actually deleted yet...
 	assertSettings()
@@ -741,4 +745,481 @@
 	return u, ru
 }
 
-type RUs []*state.RelationUnit
+type WatchScopeSuite struct {
+	ConnSuite
+}
+
+var _ = gc.Suite(&WatchScopeSuite{})
+
+func (s *WatchScopeSuite) TestPeer(c *gc.C) {
+	// Create a service and get a peer relation.
+	riak, err := s.State.AddService("riak", s.AddTestingCharm(c, "riak"))
+	c.Assert(err, gc.IsNil)
+	riakEP, err := riak.Endpoint("ring")
+	c.Assert(err, gc.IsNil)
+	rels, err := riak.Relations()
+	c.Assert(err, gc.IsNil)
+	c.Assert(rels, gc.HasLen, 1)
+	rel := rels[0]
+
+	// Add some units to the service and set their private addresses; get
+	// the relevant RelationUnits.
+	// (Private addresses should be set by their unit agents on
+	// startup; this test does not include that, but Join expects
+	// the information to be available, and uses it to populate the
+	// relation settings node.)
+	addUnit := func(i int) *state.RelationUnit {
+		unit, err := riak.AddUnit()
+		c.Assert(err, gc.IsNil)
+		err = unit.SetPrivateAddress(fmt.Sprintf("riak%d.example.com", i))
+		c.Assert(err, gc.IsNil)
+		ru, err := rel.Unit(unit)
+		c.Assert(err, gc.IsNil)
+		c.Assert(ru.Endpoint(), gc.Equals, riakEP)
+		return ru
+	}
+	ru0 := addUnit(0)
+	ru1 := addUnit(1)
+	ru2 := addUnit(2)
+
+	// ---------- Single unit ----------
+
+	// Start watching the relation from the perspective of the first unit.
+	w0 := ru0.Watch()
+	defer testing.AssertStop(c, w0)
+	s.assertChange(c, w0, nil, nil)
+	s.assertNoChange(c, w0)
+
+	// Join the first unit to the relation, and change the settings, and
+	// check that nothing apparently happens.
+	err = ru0.EnterScope(nil)
+	c.Assert(err, gc.IsNil)
+	s0 := changeSettings(c, ru0)
+	s.assertNoChange(c, w0)
+
+	// ---------- Two units ----------
+
+	// Now join another unit to the relation...
+	err = ru1.EnterScope(nil)
+	c.Assert(err, gc.IsNil)
+
+	// ...and check that the first relation unit sees the change.
+	s1, err := ru1.Settings()
+	c.Assert(err, gc.IsNil)
+	expectChanged := map[string]map[string]interface{}{
+		"riak/1": s1.Map(),
+	}
+	s.assertChange(c, w0, expectChanged, nil)
+	s.assertNoChange(c, w0)
+
+	// Join again, check it's a no-op.
+	err = ru1.EnterScope(nil)
+	c.Assert(err, gc.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 testing.AssertStop(c, w1)
+	expectChanged = map[string]map[string]interface{}{
+		"riak/0": s0.Map(),
+	}
+	s.assertChange(c, w1, expectChanged, nil)
+	s.assertNoChange(c, w1)
+
+	// ---------- Three units ----------
+
+	// Whoa, it works. Ok, check the third unit's opinion of the state.
+	w2 := ru2.Watch()
+	defer testing.AssertStop(c, w2)
+	expectChanged = map[string]map[string]interface{}{
+		"riak/0": s0.Map(),
+		"riak/1": s1.Map(),
+	}
+	s.assertChange(c, w2, expectChanged, nil)
+	s.assertNoChange(c, w2)
+
+	// Join the third unit, and check the first and second units see it.
+	err = ru2.EnterScope(nil)
+	c.Assert(err, gc.IsNil)
+	s2, err := ru2.Settings()
+	c.Assert(err, gc.IsNil)
+	expectChanged = map[string]map[string]interface{}{
+		"riak/2": s2.Map(),
+	}
+	s.assertChange(c, w0, expectChanged, nil)
+	s.assertNoChange(c, w0)
+	s.assertChange(c, w1, expectChanged, nil)
+	s.assertNoChange(c, w1)
+
+	// Change the second unit's settings, and check that only
+	// the first and third see changes.
+	s1 = changeSettings(c, ru1)
+	s.assertNoChange(c, w1)
+	expectChanged = map[string]map[string]interface{}{
+		"riak/1": s1.Map(),
+	}
+	s.assertChange(c, w0, expectChanged, nil)
+	s.assertNoChange(c, w0)
+	s.assertChange(c, w2, expectChanged, nil)
+	s.assertNoChange(c, w2)
+
+	// ---------- Two units again ----------
+
+	// Depart the second unit, and check that the first and third detect it.
+	err = ru1.LeaveScope()
+	c.Assert(err, gc.IsNil)
+	expectDeparted := []string{"riak/1"}
+	s.assertChange(c, w0, nil, expectDeparted)
+	s.assertNoChange(c, w0)
+	s.assertChange(c, w2, nil, expectDeparted)
+	s.assertNoChange(c, w2)
+
+	// Change its settings, and check the others don't observe anything.
+	s1 = changeSettings(c, ru1)
+	s.assertNoChange(c, w0)
+	s.assertNoChange(c, w2)
+
+	// Check no spurious events showed up on the second unit's watch, and check
+	// it closes cleanly.
+	s.assertNoChange(c, w1)
+	testing.AssertStop(c, w1)
+
+	// OK, we're done here. Cleanup, and error detection during same,
+	// will be handled by the deferred kill/stop calls. Phew.
+}
+
+func (s *WatchScopeSuite) TestProviderRequirerGlobal(c *gc.C) {
+	// Create a pair of services and a relation between them.
+	mysql, err := s.State.AddService("mysql", s.AddTestingCharm(c, "mysql"))
+	c.Assert(err, gc.IsNil)
+	mysqlEP, err := mysql.Endpoint("server")
+	c.Assert(err, gc.IsNil)
+	wordpress, err := s.State.AddService("wordpress", s.AddTestingCharm(c, "wordpress"))
+	c.Assert(err, gc.IsNil)
+	wordpressEP, err := wordpress.Endpoint("db")
+	c.Assert(err, gc.IsNil)
+	rel, err := s.State.AddRelation(mysqlEP, wordpressEP)
+	c.Assert(err, gc.IsNil)
+
+	// Add some units to the services and set their private addresses.
+	addUnit := func(srv *state.Service, sub string, ep state.Endpoint) *state.RelationUnit {
+		unit, err := srv.AddUnit()
+		c.Assert(err, gc.IsNil)
+		ru, err := rel.Unit(unit)
+		c.Assert(err, gc.IsNil)
+		c.Assert(ru.Endpoint(), gc.Equals, ep)
+		return ru
+	}
+	msru0 := addUnit(mysql, "ms0", mysqlEP)
+	msru1 := addUnit(mysql, "ms1", mysqlEP)
+	wpru0 := addUnit(wordpress, "wp0", wordpressEP)
+	wpru1 := addUnit(wordpress, "wp1", wordpressEP)
+
+	// ---------- Single role active ----------
+
+	// Watch the relation from the perspective of the first provider unit and
+	// check initial event.
+	msw0 := msru0.Watch()
+	defer testing.AssertStop(c, msw0)
+	s.assertChange(c, msw0, nil, nil)
+	s.assertNoChange(c, msw0)
+
+	// Join the unit to the relation, change its settings, and check that
+	// nothing apparently happens.
+	err = msru0.EnterScope(nil)
+	c.Assert(err, gc.IsNil)
+	mss0 := changeSettings(c, msru0)
+	s.assertNoChange(c, msw0)
+
+	// Join the second provider unit, start its watch, and check what it thinks the
+	// state of the relation is.
+	err = msru1.EnterScope(nil)
+	c.Assert(err, gc.IsNil)
+	msw1 := msru1.Watch()
+	defer testing.AssertStop(c, msw1)
+	s.assertChange(c, msw1, nil, nil)
+	s.assertNoChange(c, msw1)
+
+	// Change the unit's settings, and check that neither provider unit
+	// observes any change.
+	mss1 := changeSettings(c, msru1)
+	s.assertNoChange(c, msw1)
+	s.assertNoChange(c, msw0)
+
+	// ---------- Two roles active ----------
+
+	// Start watches from both requirer units' perspectives, and check that
+	// they see the provider units.
+	expectChanged := map[string]map[string]interface{}{
+		"mysql/0": mss0.Map(),
+		"mysql/1": mss1.Map(),
+	}
+	wpw0 := wpru0.Watch()
+	defer testing.AssertStop(c, wpw0)
+	s.assertChange(c, wpw0, expectChanged, nil)
+	s.assertNoChange(c, wpw0)
+	wpw1 := wpru1.Watch()
+	defer testing.AssertStop(c, wpw1)
+	s.assertChange(c, wpw1, expectChanged, nil)
+	s.assertNoChange(c, wpw1)
+
+	// Join the first requirer unit, and check the provider units see it.
+	err = wpru0.EnterScope(nil)
+	c.Assert(err, gc.IsNil)
+	wps0, err := wpru0.Settings()
+	c.Assert(err, gc.IsNil)
+	expectChanged = map[string]map[string]interface{}{
+		"wordpress/0": wps0.Map(),
+	}
+	s.assertChange(c, msw0, expectChanged, nil)
+	s.assertNoChange(c, msw0)
+	s.assertChange(c, msw1, expectChanged, nil)
+	s.assertNoChange(c, msw1)
+
+	// Join again, check no-op.
+	err = wpru0.EnterScope(nil)
+	c.Assert(err, gc.IsNil)
+	s.assertNoChange(c, msw0)
+	s.assertNoChange(c, msw1)
+
+	// Join the second requirer, and check the provider units see the change.
+	err = wpru1.EnterScope(nil)
+	c.Assert(err, gc.IsNil)
+	wps1, err := wpru1.Settings()
+	c.Assert(err, gc.IsNil)
+	expectChanged = map[string]map[string]interface{}{
+		"wordpress/1": wps1.Map(),
+	}
+	s.assertChange(c, msw0, expectChanged, nil)
+	s.assertNoChange(c, msw0)
+	s.assertChange(c, msw1, expectChanged, nil)
+	s.assertNoChange(c, msw1)
+
+	// Verify that neither requirer has observed any change to the relation.
+	s.assertNoChange(c, wpw0)
+	s.assertNoChange(c, wpw1)
+
+	// Change settings for the first requirer, check providers see it...
+	wps0 = changeSettings(c, wpru0)
+	expectChanged = map[string]map[string]interface{}{
+		"wordpress/0": wps0.Map(),
+	}
+	s.assertChange(c, msw0, expectChanged, nil)
+	s.assertNoChange(c, msw0)
+	s.assertChange(c, msw1, expectChanged, nil)
+	s.assertNoChange(c, msw1)
+
+	// ...and requirers don't.
+	s.assertNoChange(c, wpw0)
+	s.assertNoChange(c, wpw1)
+
+	// Depart the second requirer and check the providers see it...
+	err = wpru1.LeaveScope()
+	c.Assert(err, gc.IsNil)
+	expectDeparted := []string{"wordpress/1"}
+	s.assertChange(c, msw0, nil, expectDeparted)
+	s.assertNoChange(c, msw0)
+	s.assertChange(c, msw1, nil, expectDeparted)
+	s.assertNoChange(c, msw1)
+
+	// ...and the requirers don't.
+	s.assertNoChange(c, wpw0)
+	s.assertNoChange(c, wpw1)
+
+	// Cleanup handled by defers as before.
+}
+
+func (s *WatchScopeSuite) TestProviderRequirerContainer(c *gc.C) {
+	// Create a pair of services and a relation between them.
+	mysql, err := s.State.AddService("mysql", s.AddTestingCharm(c, "mysql"))
+	c.Assert(err, gc.IsNil)
+	mysqlEP, err := mysql.Endpoint("juju-info")
+	c.Assert(err, gc.IsNil)
+	logging, err := s.State.AddService("logging", s.AddTestingCharm(c, "logging"))
+	c.Assert(err, gc.IsNil)
+	loggingEP, err := logging.Endpoint("info")
+	c.Assert(err, gc.IsNil)
+	rel, err := s.State.AddRelation(mysqlEP, loggingEP)
+	c.Assert(err, gc.IsNil)
+
+	// Change mysqlEP to match the endpoint that will actually be used by the relation.
+	mysqlEP.Scope = charm.ScopeContainer
+
+	// Add some units to the services and set their private addresses.
+	addUnits := func(i int) (*state.RelationUnit, *state.RelationUnit) {
+		msu, err := mysql.AddUnit()
+		c.Assert(err, gc.IsNil)
+		msru, err := rel.Unit(msu)
+		c.Assert(err, gc.IsNil)
+		c.Assert(msru.Endpoint(), gc.Equals, mysqlEP)
+		err = msru.EnterScope(nil)
+		c.Assert(err, gc.IsNil)
+		err = msru.LeaveScope()
+		c.Assert(err, gc.IsNil)
+		lgu, err := s.State.Unit("logging/" + strconv.Itoa(i))
+		c.Assert(err, gc.IsNil)
+		lgru, err := rel.Unit(lgu)
+		c.Assert(err, gc.IsNil)
+		c.Assert(lgru.Endpoint(), gc.Equals, loggingEP)
+		return msru, lgru
+	}
+	msru0, lgru0 := addUnits(0)
+	msru1, lgru1 := addUnits(1)
+
+	// ---------- Single role active ----------
+
+	// Start watching the relation from the perspective of the first unit, and
+	// check the initial event.
+	msw0 := msru0.Watch()
+	defer testing.AssertStop(c, msw0)
+	s.assertChange(c, msw0, nil, nil)
+	s.assertNoChange(c, msw0)
+
+	// Join the unit to the relation, change its settings, and check that
+	// nothing apparently happens.
+	err = msru0.EnterScope(nil)
+	c.Assert(err, gc.IsNil)
+	mss0 := changeSettings(c, msru0)
+	s.assertNoChange(c, msw0)
+
+	// Watch the relation from the perspective of the second provider, and
+	// check initial event.
+	msw1 := msru1.Watch()
+	defer testing.AssertStop(c, msw1)
+	s.assertChange(c, msw1, nil, nil)
+	s.assertNoChange(c, msw1)
+
+	// Join the second provider unit to the relation, and check that neither
+	// watching unit observes any change.
+	err = msru1.EnterScope(nil)
+	c.Assert(err, gc.IsNil)
+	s.assertNoChange(c, msw1)
+	s.assertNoChange(c, msw0)
+
+	// Change the unit's settings, and check that nothing apparently happens.
+	mss1 := changeSettings(c, msru1)
+	s.assertNoChange(c, msw1)
+	s.assertNoChange(c, msw0)
+
+	// ---------- Two roles active ----------
+
+	// Start a watch from the first requirer unit's perspective, and check it
+	// only sees the first provider (with which it shares a container).
+	lgw0 := lgru0.Watch()
+	defer testing.AssertStop(c, lgw0)
+	expectChanged := map[string]map[string]interface{}{
+		"mysql/0": mss0.Map(),
+	}
+	s.assertChange(c, lgw0, expectChanged, nil)
+	s.assertNoChange(c, lgw0)
+
+	// Join the first requirer unit, and check that only the first provider
+	// observes the change.
+	err = lgru0.EnterScope(nil)
+	c.Assert(err, gc.IsNil)
+	lgs0, err := lgru0.Settings()
+	c.Assert(err, gc.IsNil)
+	expectChanged = map[string]map[string]interface{}{
+		"logging/0": lgs0.Map(),
+	}
+	s.assertChange(c, msw0, expectChanged, nil)
+	s.assertNoChange(c, msw0)
+	s.assertNoChange(c, msw1)
+	s.assertNoChange(c, lgw0)
+
+	// Watch from the second requirer's perspective, and check it only sees the
+	// second provider.
+	lgw1 := lgru1.Watch()
+	defer testing.AssertStop(c, lgw1)
+	expectChanged = map[string]map[string]interface{}{
+		"mysql/1": mss1.Map(),
+	}
+	s.assertChange(c, lgw1, expectChanged, nil)
+	s.assertNoChange(c, lgw1)
+
+	// Join the second requirer, and check that the first provider observes it...
+	err = lgru1.EnterScope(nil)
+	c.Assert(err, gc.IsNil)
+	lgs1, err := lgru1.Settings()
+	c.Assert(err, gc.IsNil)
+	expectChanged = map[string]map[string]interface{}{
+		"logging/1": lgs1.Map(),
+	}
+	s.assertChange(c, msw1, expectChanged, nil)
+	s.assertNoChange(c, msw1)
+
+	// ...and that nothing else sees anything.
+	s.assertNoChange(c, msw0)
+	s.assertNoChange(c, lgw0)
+	s.assertNoChange(c, lgw1)
+
+	// Change the second provider's settings and check that the second
+	// requirer notices...
+	mss1 = changeSettings(c, msru1)
+	expectChanged = map[string]map[string]interface{}{
+		"mysql/1": mss1.Map(),
+	}
+	s.assertChange(c, lgw1, expectChanged, nil)
+	s.assertNoChange(c, lgw1)
+
+	// ...but that nothing else does.
+	s.assertNoChange(c, msw0)
+	s.assertNoChange(c, msw1)
+	s.assertNoChange(c, msw0)
+
+	// Finally, depart the first provider, and check that only the first
+	// requirer observes any change.
+	err = msru0.LeaveScope()
+	c.Assert(err, gc.IsNil)
+	expectDeparted := []string{"mysql/0"}
+	s.assertChange(c, lgw0, nil, expectDeparted)
+	s.assertNoChange(c, lgw0)
+	s.assertNoChange(c, lgw1)
+	s.assertNoChange(c, msw0)
+	s.assertNoChange(c, msw1)
+
+	// Again, I think we're done, and can be comfortable that the appropriate
+	// connections are in place.
+}
+
+func changeSettings(c *gc.C, ru *state.RelationUnit) *state.Settings {
+	node, err := ru.Settings()
+	c.Assert(err, gc.IsNil)
+	value, _ := node.Get("value")
+	v, _ := value.(int)
+	node.Set("value", v+1)
+	_, err = node.Write()
+	c.Assert(err, gc.IsNil)
+	return node
+}
+
+func (s *WatchScopeSuite) assertChange(
+	c *gc.C, w *state.RelationUnitsWatcher,
+	changed map[string]map[string]interface{},
+	departed []string,
+) {
+	s.State.StartSync()
+	select {
+	case ch, ok := <-w.Changes():
+		if !ok {
+			c.Fatalf("channel closed; watcher error: %#v", w.Err())
+		}
+		c.Assert(ch.Changed, gc.HasLen, len(changed))
+		for name, m := range changed {
+			c.Assert(ch.Changed[name].Settings, gc.DeepEquals, m)
+		}
+		c.Assert(departed, jc.SameContents, ch.Departed)
+	case <-time.After(5 * time.Second):
+		c.Fatalf("expected changed %#v, departed %#v; got nothing", changed, departed)
+	}
+}
+
+func (s *WatchScopeSuite) assertNoChange(c *gc.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):
+	}
+}