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() }