func (s *ServiceSuite) TestWatchService(c *C) {
w := s.mysql.Watch()
defer testing.AssertStop(c, w)
// Initial event.
wc := testing.NewNotifyWatcherC(c, s.State, w)
wc.AssertOneChange()
// Make one change (to a separate instance), check one event.
service, err := s.State.Service(s.mysql.Name())
c.Assert(err, IsNil)
err = service.SetExposed()
c.Assert(err, IsNil)
wc.AssertOneChange()
// Make two changes, check one event.
err = service.ClearExposed()
c.Assert(err, IsNil)
err = service.SetCharm(s.charm, true)
c.Assert(err, IsNil)
wc.AssertOneChange()
// Stop, check closed.
testing.AssertStop(c, w)
wc.AssertClosed()
// Remove service, start new watch, check single event.
err = service.Destroy()
c.Assert(err, IsNil)
w = s.mysql.Watch()
defer testing.AssertStop(c, w)
testing.NewNotifyWatcherC(c, s.State, w).AssertOneChange()
}
func (s *uniterSuite) TestWatch(c *gc.C) {
unit, err := s.uniter.Unit("unit-wordpress-0")
c.Assert(err, gc.IsNil)
c.Assert(unit.Life(), gc.Equals, params.Alive)
w, err := unit.Watch()
c.Assert(err, gc.IsNil)
defer statetesting.AssertStop(c, w)
wc := statetesting.NewNotifyWatcherC(c, s.BackingState, w)
// Initial event.
wc.AssertOneChange()
// Change something other than the lifecycle and make sure it's
// not detected.
err = unit.SetStatus(params.StatusStarted, "not really")
c.Assert(err, gc.IsNil)
wc.AssertNoChange()
// Make the unit dead and check it's detected.
err = unit.EnsureDead()
c.Assert(err, gc.IsNil)
wc.AssertOneChange()
statetesting.AssertStop(c, w)
wc.AssertClosed()
}
func (s *uniterSuite) TestWatch(c *gc.C) {
c.Assert(s.resources.Count(), gc.Equals, 0)
args := params.Entities{Entities: []params.Entity{
{Tag: "unit-mysql-0"},
{Tag: "unit-wordpress-0"},
{Tag: "unit-foo-42"},
}}
result, err := s.uniter.Watch(args)
c.Assert(err, gc.IsNil)
c.Assert(result, gc.DeepEquals, params.NotifyWatchResults{
Results: []params.NotifyWatchResult{
{Error: apiservertesting.ErrUnauthorized},
{NotifyWatcherId: "1"},
{Error: apiservertesting.ErrUnauthorized},
},
})
// Verify the resource was registered and stop when done
c.Assert(s.resources.Count(), gc.Equals, 1)
c.Assert(result.Results[1].NotifyWatcherId, gc.Equals, "1")
resource := s.resources.Get("1")
defer statetesting.AssertStop(c, resource)
// Check that the Watch has consumed the initial event ("returned" in
// the Watch call)
wc := statetesting.NewNotifyWatcherC(c, s.State, resource.(state.NotifyWatcher))
wc.AssertNoChange()
}
func (s *machinerSuite) TestWatch(c *gc.C) {
machine, err := s.machiner.Machine("machine-0")
c.Assert(err, gc.IsNil)
c.Assert(machine.Life(), gc.Equals, params.Alive)
w, err := machine.Watch()
c.Assert(err, gc.IsNil)
defer statetesting.AssertStop(c, w)
wc := statetesting.NewNotifyWatcherC(c, s.BackingState, w)
// Initial event.
wc.AssertOneChange()
// Change something other than the lifecycle and make sure it's
// not detected.
err = machine.SetStatus(params.StatusStarted, "not really")
c.Assert(err, gc.IsNil)
wc.AssertNoChange()
// Make the machine dead and check it's detected.
err = machine.EnsureDead()
c.Assert(err, gc.IsNil)
wc.AssertOneChange()
statetesting.AssertStop(c, w)
wc.AssertClosed()
}
func (s *MachineSuite) TestWatchMachine(c *C) {
w := s.machine.Watch()
defer testing.AssertStop(c, w)
// Initial event.
wc := testing.NewNotifyWatcherC(c, s.State, w)
wc.AssertOneChange()
// Make one change (to a separate instance), check one event.
machine, err := s.State.Machine(s.machine.Id())
c.Assert(err, IsNil)
err = machine.SetProvisioned("m-foo", "fake_nonce", nil)
c.Assert(err, IsNil)
wc.AssertOneChange()
// Make two changes, check one event.
err = machine.SetAgentTools(&tools.Tools{
URL: "foo",
Binary: version.MustParseBinary("0.0.3-series-arch"),
})
c.Assert(err, IsNil)
err = machine.Destroy()
c.Assert(err, IsNil)
wc.AssertOneChange()
// Stop, check closed.
testing.AssertStop(c, w)
wc.AssertClosed()
// Remove machine, start new watch, check single event.
err = machine.EnsureDead()
c.Assert(err, IsNil)
err = machine.Remove()
c.Assert(err, IsNil)
w = s.machine.Watch()
defer testing.AssertStop(c, w)
testing.NewNotifyWatcherC(c, s.State, w).AssertOneChange()
}
func (s *UnitSuite) TestWatchUnit(c *C) {
preventUnitDestroyRemove(c, s.unit)
w := s.unit.Watch()
defer testing.AssertStop(c, w)
// Initial event.
wc := testing.NewNotifyWatcherC(c, s.State, w)
wc.AssertOneChange()
// Make one change (to a separate instance), check one event.
unit, err := s.State.Unit(s.unit.Name())
c.Assert(err, IsNil)
err = unit.SetPublicAddress("example.foobar.com")
c.Assert(err, IsNil)
wc.AssertOneChange()
// Make two changes, check one event.
err = unit.SetPrivateAddress("example.foobar")
c.Assert(err, IsNil)
err = unit.Destroy()
c.Assert(err, IsNil)
wc.AssertOneChange()
// Stop, check closed.
testing.AssertStop(c, w)
wc.AssertClosed()
// Remove unit, start new watch, check single event.
err = unit.EnsureDead()
c.Assert(err, IsNil)
err = unit.Remove()
c.Assert(err, IsNil)
w = s.unit.Watch()
defer testing.AssertStop(c, w)
testing.NewNotifyWatcherC(c, s.State, w).AssertOneChange()
}
func (s *watcherSuite) TestWatchMachine(c *gc.C) {
var results params.NotifyWatchResults
args := params.Entities{Entities: []params.Entity{{Tag: s.rawMachine.Tag()}}}
err := s.stateAPI.Call("Machiner", "", "Watch", args, &results)
c.Assert(err, gc.IsNil)
c.Assert(results.Results, gc.HasLen, 1)
result := results.Results[0]
c.Assert(result.Error, gc.IsNil)
// params.NotifyWatcher conforms to the state.NotifyWatcher interface
w := watcher.NewNotifyWatcher(s.stateAPI, result)
wc := statetesting.NewNotifyWatcherC(c, s.State, w)
wc.AssertOneChange()
statetesting.AssertStop(c, w)
wc.AssertClosed()
}
func (s *UnitSuite) TestWatchConfigSettings(c *C) {
err := s.unit.SetCharmURL(s.charm.URL())
c.Assert(err, IsNil)
w, err := s.unit.WatchConfigSettings()
c.Assert(err, IsNil)
defer testing.AssertStop(c, w)
// Initial event.
wc := testing.NewNotifyWatcherC(c, s.State, w)
wc.AssertOneChange()
// Update config a couple of times, check a single event.
err = s.service.UpdateConfigSettings(charm.Settings{
"blog-title": "superhero paparazzi",
})
c.Assert(err, IsNil)
err = s.service.UpdateConfigSettings(charm.Settings{
"blog-title": "sauceror central",
})
c.Assert(err, IsNil)
wc.AssertOneChange()
// Non-change is not reported.
err = s.service.UpdateConfigSettings(charm.Settings{
"blog-title": "sauceror central",
})
c.Assert(err, IsNil)
wc.AssertNoChange()
// Change service's charm; nothing detected.
newCharm := s.AddConfigCharm(c, "wordpress", floatConfig, 123)
err = s.service.SetCharm(newCharm, false)
c.Assert(err, IsNil)
wc.AssertNoChange()
// Change service config for new charm; nothing detected.
err = s.service.UpdateConfigSettings(charm.Settings{
"key": 42.0,
})
c.Assert(err, IsNil)
wc.AssertNoChange()
// NOTE: if we were to change the unit to use the new charm, we'd see
// another event, because the originally-watched document will become
// unreferenced and be removed. But I'm not testing that behaviour
// because it's not very helpful and subject to change.
}
func (s *watcherSuite) TestNotifyWatcherStopsWithPendingSend(c *gc.C) {
var results params.NotifyWatchResults
args := params.Entities{Entities: []params.Entity{{Tag: s.rawMachine.Tag()}}}
err := s.stateAPI.Call("Machiner", "", "Watch", args, &results)
c.Assert(err, gc.IsNil)
c.Assert(results.Results, gc.HasLen, 1)
result := results.Results[0]
c.Assert(result.Error, gc.IsNil)
// params.NotifyWatcher conforms to the state.NotifyWatcher interface
w := watcher.NewNotifyWatcher(s.stateAPI, result)
wc := statetesting.NewNotifyWatcherC(c, s.State, w)
// Now, without reading any changes try stopping the watcher.
statetesting.AssertCanStopWhenSending(c, w)
wc.AssertClosed()
}
func (s *upgraderSuite) TestWatchAPIVersion(c *C) {
args := params.Entities{
Entities: []params.Entity{{Tag: s.rawMachine.Tag()}},
}
results, err := s.upgrader.WatchAPIVersion(args)
c.Assert(err, IsNil)
c.Check(results.Results, HasLen, 1)
c.Check(results.Results[0].NotifyWatcherId, Not(Equals), "")
c.Check(results.Results[0].Error, IsNil)
resource := s.resources.Get(results.Results[0].NotifyWatcherId)
c.Check(resource, NotNil)
w := resource.(state.NotifyWatcher)
wc := statetesting.NewNotifyWatcherC(c, s.State, w)
wc.AssertNoChange()
err = statetesting.SetAgentVersion(s.State, version.MustParse("3.4.567.8"))
c.Assert(err, IsNil)
wc.AssertOneChange()
statetesting.AssertStop(c, w)
wc.AssertClosed()
}
func (s *upgraderSuite) TestWatchAPIVersion(c *C) {
w, err := s.st.WatchAPIVersion(s.rawMachine.Tag())
c.Assert(err, IsNil)
defer statetesting.AssertStop(c, w)
wc := statetesting.NewNotifyWatcherC(c, s.BackingState, w)
// Initial event
wc.AssertOneChange()
vers := version.MustParse("10.20.34")
err = statetesting.SetAgentVersion(s.BackingState, vers)
c.Assert(err, IsNil)
// One change noticing the new version
wc.AssertOneChange()
// Setting the version to the same value doesn't trigger a change
err = statetesting.SetAgentVersion(s.BackingState, vers)
c.Assert(err, IsNil)
wc.AssertNoChange()
vers = version.MustParse("10.20.35")
err = statetesting.SetAgentVersion(s.BackingState, vers)
c.Assert(err, IsNil)
wc.AssertOneChange()
statetesting.AssertStop(c, w)
wc.AssertClosed()
}
