func (s *APIAddresserTests) TestWatchAPIHostPorts(c *gc.C) {
expectServerAddrs := [][]instance.HostPort{{{
Address: instance.NewAddress("0.1.2.3", instance.NetworkUnknown),
Port: 1234,
}}}
err := s.state.SetAPIHostPorts(expectServerAddrs)
c.Assert(err, gc.IsNil)
w, err := s.facade.WatchAPIHostPorts()
c.Assert(err, gc.IsNil)
defer statetesting.AssertStop(c, w)
wc := statetesting.NewNotifyWatcherC(c, s.state, w)
// Initial event.
wc.AssertOneChange()
// Change the state addresses and check that we get a notification
expectServerAddrs[0][0].Value = "0.1.99.99"
err = s.state.SetAPIHostPorts(expectServerAddrs)
c.Assert(err, gc.IsNil)
wc.AssertOneChange()
statetesting.AssertStop(c, w)
wc.AssertClosed()
}
func (s *unitSuite) TestWatch(c *gc.C) {
c.Assert(s.apiUnit.Life(), gc.Equals, params.Alive)
w, err := s.apiUnit.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 life cycle and make sure it's
// not detected.
err = s.units[0].SetStatus(params.StatusStarted, "not really", nil)
c.Assert(err, gc.IsNil)
wc.AssertNoChange()
// Make the unit dead and check it's detected.
err = s.units[0].EnsureDead()
c.Assert(err, gc.IsNil)
wc.AssertOneChange()
statetesting.AssertStop(c, w)
wc.AssertClosed()
}
func (s *workerJujuConnSuite) TestPublisherSetsAPIHostPorts(c *gc.C) {
st := newFakeState()
initState(c, st, 3)
watcher := s.State.WatchAPIHostPorts()
cwatch := statetesting.NewNotifyWatcherC(c, s.State, watcher)
cwatch.AssertOneChange()
statePublish := newPublisher(s.State)
// Wrap the publisher so that we can call StartSync immediately
// after the publishAPIServers method is called.
publish := func(apiServers [][]instance.HostPort, instanceIds []instance.Id) error {
err := statePublish.publishAPIServers(apiServers, instanceIds)
s.State.StartSync()
return err
}
w := newWorker(st, publisherFunc(publish))
defer func() {
c.Check(worker.Stop(w), gc.IsNil)
}()
cwatch.AssertOneChange()
hps, err := s.State.APIHostPorts()
c.Assert(err, gc.IsNil)
assertAPIHostPorts(c, hps, expectedAPIHostPorts(3))
}
func (s *machinerSuite) TestWatch(c *gc.C) {
c.Assert(s.resources.Count(), gc.Equals, 0)
args := params.Entities{Entities: []params.Entity{
{Tag: "machine-1"},
{Tag: "machine-0"},
{Tag: "machine-42"},
}}
result, err := s.machiner.Watch(args)
c.Assert(err, gc.IsNil)
c.Assert(result, gc.DeepEquals, params.NotifyWatchResults{
Results: []params.NotifyWatchResult{
{NotifyWatcherId: "1"},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.ErrUnauthorized},
},
})
// Verify the resource was registered and stop when done
c.Assert(s.resources.Count(), gc.Equals, 1)
c.Assert(result.Results[0].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 *authorisedKeysSuite) TestWatchAuthorisedKeys(c *gc.C) {
args := params.Entities{
Entities: []params.Entity{
{Tag: s.rawMachine.Tag()},
{Tag: s.unrelatedMachine.Tag()},
{Tag: "machine-42"},
},
}
results, err := s.keyupdater.WatchAuthorisedKeys(args)
c.Assert(err, gc.IsNil)
c.Assert(results, gc.DeepEquals, params.NotifyWatchResults{
Results: []params.NotifyWatchResult{
{NotifyWatcherId: "1"},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.ErrUnauthorized},
},
})
c.Assert(results.Results[0].NotifyWatcherId, gc.Not(gc.Equals), "")
c.Assert(results.Results[0].Error, gc.IsNil)
resource := s.resources.Get(results.Results[0].NotifyWatcherId)
c.Assert(resource, gc.NotNil)
w := resource.(state.NotifyWatcher)
wc := statetesting.NewNotifyWatcherC(c, s.State, w)
wc.AssertNoChange()
s.setAuthorizedKeys(c, "key1\nkey2")
wc.AssertOneChange()
statetesting.AssertStop(c, w)
wc.AssertClosed()
}
func (s *firewallerSuite) TestWatch(c *gc.C) {
c.Assert(s.resources.Count(), gc.Equals, 0)
args := addFakeEntities(params.Entities{Entities: []params.Entity{
{Tag: s.machines[0].Tag()},
{Tag: s.service.Tag()},
{Tag: s.units[0].Tag()},
}})
result, err := s.firewaller.Watch(args)
c.Assert(err, gc.IsNil)
c.Assert(result, jc.DeepEquals, params.NotifyWatchResults{
Results: []params.NotifyWatchResult{
{Error: apiservertesting.ErrUnauthorized},
{NotifyWatcherId: "1"},
{NotifyWatcherId: "2"},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.NotFoundError(`unit "foo/0"`)},
{Error: apiservertesting.NotFoundError(`service "bar"`)},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.ErrUnauthorized},
},
})
// Verify the resources were registered and stop when done.
c.Assert(s.resources.Count(), gc.Equals, 2)
c.Assert(result.Results[1].NotifyWatcherId, gc.Equals, "1")
watcher1 := s.resources.Get("1")
defer statetesting.AssertStop(c, watcher1)
c.Assert(result.Results[2].NotifyWatcherId, gc.Equals, "2")
watcher2 := s.resources.Get("2")
defer statetesting.AssertStop(c, watcher2)
// Check that the Watch has consumed the initial event ("returned" in
// the Watch call)
wc1 := statetesting.NewNotifyWatcherC(c, s.State, watcher1.(state.NotifyWatcher))
wc1.AssertNoChange()
wc2 := statetesting.NewNotifyWatcherC(c, s.State, watcher2.(state.NotifyWatcher))
wc2.AssertNoChange()
}
func (s *unitSuite) TestWatchConfigSettings(c *gc.C) {
// Make sure WatchConfigSettings returns an error when
// no charm URL is set, as its state counterpart does.
w, err := s.apiUnit.WatchConfigSettings()
c.Assert(err, gc.ErrorMatches, "unit charm not set")
// Now set the charm and try again.
err = s.apiUnit.SetCharmURL(s.wordpressCharm.URL())
c.Assert(err, gc.IsNil)
w, err = s.apiUnit.WatchConfigSettings()
defer statetesting.AssertStop(c, w)
wc := statetesting.NewNotifyWatcherC(c, s.BackingState, w)
// Initial event.
wc.AssertOneChange()
// Update config a couple of times, check a single event.
err = s.wordpressService.UpdateConfigSettings(charm.Settings{
"blog-title": "superhero paparazzi",
})
c.Assert(err, gc.IsNil)
err = s.wordpressService.UpdateConfigSettings(charm.Settings{
"blog-title": "sauceror central",
})
c.Assert(err, gc.IsNil)
wc.AssertOneChange()
// Non-change is not reported.
err = s.wordpressService.UpdateConfigSettings(charm.Settings{
"blog-title": "sauceror central",
})
c.Assert(err, gc.IsNil)
wc.AssertNoChange()
// NOTE: This test is not as exhaustive as the one in state,
// because the watcher is already tested there. Here we just
// ensure we get the events when we expect them and don't get
// them when they're not expected.
statetesting.AssertStop(c, w)
wc.AssertClosed()
}
func (s *unitUpgraderSuite) TestWatchAPIVersion(c *gc.C) {
w, err := s.st.WatchAPIVersion(s.rawUnit.Tag())
c.Assert(err, gc.IsNil)
defer statetesting.AssertStop(c, w)
wc := statetesting.NewNotifyWatcherC(c, s.BackingState, w)
// Initial event
wc.AssertOneChange()
vers := version.MustParseBinary("10.20.34-quantal-amd64")
err = s.rawMachine.SetAgentVersion(vers)
c.Assert(err, gc.IsNil)
// One change noticing the new version
wc.AssertOneChange()
vers = version.MustParseBinary("10.20.35-quantal-amd64")
err = s.rawMachine.SetAgentVersion(vers)
c.Assert(err, gc.IsNil)
wc.AssertOneChange()
statetesting.AssertStop(c, w)
wc.AssertClosed()
}
func (s *EnvironWatcherTest) TestWatchForEnvironConfigChanges(c *gc.C) {
c.Assert(s.resources.Count(), gc.Equals, 0)
result, err := s.envWatcher.WatchForEnvironConfigChanges()
c.Assert(err, gc.IsNil)
c.Assert(result, gc.DeepEquals, params.NotifyWatchResult{
NotifyWatcherId: "1",
})
// Verify the resources were registered and stop them when done.
c.Assert(s.resources.Count(), 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.st, resource.(state.NotifyWatcher))
wc.AssertNoChange()
}
func (s *keyupdaterSuite) TestWatchAuthorisedKeys(c *gc.C) {
watcher, err := s.keyupdater.WatchAuthorisedKeys(s.rawMachine.Tag())
c.Assert(err, gc.IsNil)
defer testing.AssertStop(c, watcher)
wc := testing.NewNotifyWatcherC(c, s.BackingState, watcher)
// Initial event
wc.AssertOneChange()
s.setAuthorisedKeys(c, "key1\nkey2")
// One change noticing the new version
wc.AssertOneChange()
// Setting the version to the same value doesn't trigger a change
s.setAuthorisedKeys(c, "key1\nkey2")
wc.AssertNoChange()
s.setAuthorisedKeys(c, "key1\nkey2\nkey3")
wc.AssertOneChange()
testing.AssertStop(c, watcher)
wc.AssertClosed()
}
func (s *unitUpgraderSuite) TestWatchAPIVersion(c *gc.C) {
args := params.Entities{
Entities: []params.Entity{{Tag: s.rawUnit.Tag()}},
}
results, err := s.upgrader.WatchAPIVersion(args)
c.Assert(err, gc.IsNil)
c.Check(results.Results, gc.HasLen, 1)
c.Check(results.Results[0].NotifyWatcherId, gc.Not(gc.Equals), "")
c.Check(results.Results[0].Error, gc.IsNil)
resource := s.resources.Get(results.Results[0].NotifyWatcherId)
c.Check(resource, gc.NotNil)
w := resource.(state.NotifyWatcher)
wc := statetesting.NewNotifyWatcherC(c, s.State, w)
wc.AssertNoChange()
err = s.rawMachine.SetAgentVersion(version.MustParseBinary("3.4.567.8-quantal-amd64"))
c.Assert(err, gc.IsNil)
wc.AssertOneChange()
statetesting.AssertStop(c, w)
wc.AssertClosed()
}
func (s *EnvironWatcherTests) TestWatchForEnvironConfigChanges(c *gc.C) {
envConfig, err := s.state.EnvironConfig()
c.Assert(err, gc.IsNil)
w, err := s.facade.WatchForEnvironConfigChanges()
c.Assert(err, gc.IsNil)
defer statetesting.AssertStop(c, w)
wc := statetesting.NewNotifyWatcherC(c, s.state, w)
// Initial event.
wc.AssertOneChange()
// Change the environment configuration by updating an existing attribute, check it's detected.
newAttrs := map[string]interface{}{"logging-config": "juju=ERROR"}
err = s.state.UpdateEnvironConfig(newAttrs, nil, nil)
c.Assert(err, gc.IsNil)
wc.AssertOneChange()
// Change the environment configuration by adding a new attribute, check it's detected.
newAttrs = map[string]interface{}{"foo": "bar"}
err = s.state.UpdateEnvironConfig(newAttrs, nil, nil)
c.Assert(err, gc.IsNil)
wc.AssertOneChange()
// Change the environment configuration by removing an attribute, check it's detected.
err = s.state.UpdateEnvironConfig(map[string]interface{}{}, []string{"foo"}, nil)
c.Assert(err, gc.IsNil)
wc.AssertOneChange()
// Change it back to the original config.
oldAttrs := map[string]interface{}{"logging-config": envConfig.AllAttrs()["logging-config"]}
err = s.state.UpdateEnvironConfig(oldAttrs, nil, nil)
c.Assert(err, gc.IsNil)
wc.AssertOneChange()
statetesting.AssertStop(c, w)
wc.AssertClosed()
}
func (s *machineUpgraderSuite) TestWatchAPIVersion(c *gc.C) {
w, err := s.st.WatchAPIVersion(s.rawMachine.Tag())
c.Assert(err, gc.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, gc.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, gc.IsNil)
wc.AssertNoChange()
vers = version.MustParse("10.20.35")
err = statetesting.SetAgentVersion(s.BackingState, vers)
c.Assert(err, gc.IsNil)
wc.AssertOneChange()
statetesting.AssertStop(c, w)
wc.AssertClosed()
}
func (s *serviceSuite) TestWatch(c *gc.C) {
c.Assert(s.apiService.Life(), gc.Equals, params.Alive)
w, err := s.apiService.Watch()
c.Assert(err, gc.IsNil)
defer statetesting.AssertStop(c, w)
wc := statetesting.NewNotifyWatcherC(c, s.BackingState, w)
// Initial event.
wc.AssertOneChange()
// Change something and check it's detected.
err = s.service.SetExposed()
c.Assert(err, gc.IsNil)
wc.AssertOneChange()
// Destroy the service and check it's detected.
err = s.service.Destroy()
c.Assert(err, gc.IsNil)
wc.AssertOneChange()
statetesting.AssertStop(c, w)
wc.AssertClosed()
}
