func (s *serviceSuite) TestWatchRelations(c *gc.C) {
w, err := s.apiService.WatchRelations()
c.Assert(err, gc.IsNil)
defer statetesting.AssertStop(c, w)
wc := statetesting.NewStringsWatcherC(c, s.BackingState, w)
// Initial event.
wc.AssertChange()
wc.AssertNoChange()
// Change something other than the lifecycle and make sure it's
// not detected.
err = s.wordpressService.SetExposed()
c.Assert(err, gc.IsNil)
wc.AssertNoChange()
// Add another service and relate it to wordpress,
// check it's detected.
s.addMachineServiceCharmAndUnit(c, "mysql")
rel := s.addRelation(c, "wordpress", "mysql")
wc.AssertChange(rel.String())
// Destroy the relation and check it's detected.
err = rel.Destroy()
c.Assert(err, gc.IsNil)
wc.AssertChange(rel.String())
wc.AssertNoChange()
statetesting.AssertStop(c, w)
wc.AssertClosed()
}
func (s *UnitSuite) TestWatchUnit(c *gc.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, gc.IsNil)
s.setAssignedMachineAddresses(c, unit)
wc.AssertOneChange()
// Make two changes, check one event.
err = unit.SetPassword("arble-farble-dying-yarble")
c.Assert(err, gc.IsNil)
err = unit.Destroy()
c.Assert(err, gc.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, gc.IsNil)
err = unit.Remove()
c.Assert(err, gc.IsNil)
w = s.unit.Watch()
defer testing.AssertStop(c, w)
testing.NewNotifyWatcherC(c, s.State, w).AssertOneChange()
}
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 *machineSuite) TestWatchUnits(c *gc.C) {
w, err := s.apiMachine.WatchUnits()
c.Assert(err, gc.IsNil)
defer statetesting.AssertStop(c, w)
wc := statetesting.NewStringsWatcherC(c, s.BackingState, w)
// Initial event.
wc.AssertChange("wordpress/0")
wc.AssertNoChange()
// Change something other than the life cycle and make sure it's
// not detected.
err = s.machines[0].SetPassword("foo")
c.Assert(err, gc.ErrorMatches, "password is only 3 bytes long, and is not a valid Agent password")
wc.AssertNoChange()
err = s.machines[0].SetPassword("foo-12345678901234567890")
c.Assert(err, gc.IsNil)
wc.AssertNoChange()
// Unassign unit 0 from the machine and check it's detected.
err = s.units[0].UnassignFromMachine()
c.Assert(err, gc.IsNil)
wc.AssertChange("wordpress/0")
wc.AssertNoChange()
statetesting.AssertStop(c, w)
wc.AssertClosed()
}
func (s *deployerSuite) TestWatchUnits(c *gc.C) {
machine, err := s.st.Machine(s.machine.Tag())
c.Assert(err, gc.IsNil)
w, err := machine.WatchUnits()
c.Assert(err, gc.IsNil)
defer statetesting.AssertStop(c, w)
wc := statetesting.NewStringsWatcherC(c, s.BackingState, w)
// Initial event.
wc.AssertChange("mysql/0", "logging/0")
wc.AssertNoChange()
// Change something other than the lifecycle and make sure it's
// not detected.
err = s.subordinate.SetPassword("foo")
c.Assert(err, gc.ErrorMatches, "password is only 3 bytes long, and is not a valid Agent password")
wc.AssertNoChange()
err = s.subordinate.SetPassword("foo-12345678901234567890")
c.Assert(err, gc.IsNil)
wc.AssertNoChange()
// Make the subordinate dead and check it's detected.
err = s.subordinate.EnsureDead()
c.Assert(err, gc.IsNil)
wc.AssertChange("logging/0")
wc.AssertNoChange()
statetesting.AssertStop(c, w)
wc.AssertClosed()
}
func (s *ServiceSuite) TestWatchService(c *gc.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, gc.IsNil)
err = service.SetExposed()
c.Assert(err, gc.IsNil)
wc.AssertOneChange()
// Make two changes, check one event.
err = service.ClearExposed()
c.Assert(err, gc.IsNil)
err = service.SetCharm(s.charm, true)
c.Assert(err, gc.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, gc.IsNil)
w = s.mysql.Watch()
defer testing.AssertStop(c, w)
testing.NewNotifyWatcherC(c, s.State, w).AssertOneChange()
}
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 *RelationUnitSuite) TestPeerWatchScope(c *gc.C) {
pr := NewPeerRelation(c, s.State)
// Test empty initial event.
w0 := pr.ru0.WatchScope()
defer testing.AssertStop(c, w0)
s.assertScopeChange(c, w0, nil, nil)
s.assertNoScopeChange(c, w0)
// ru0 enters; check no change, but settings written.
assertNotInScope(c, pr.ru0)
err := pr.ru0.EnterScope(map[string]interface{}{"foo": "bar"})
c.Assert(err, gc.IsNil)
s.assertNoScopeChange(c, w0)
node, err := pr.ru0.Settings()
c.Assert(err, gc.IsNil)
c.Assert(node.Map(), gc.DeepEquals, map[string]interface{}{"foo": "bar"})
assertInScope(c, pr.ru0)
// ru1 enters; check change is observed.
assertNotInScope(c, pr.ru1)
err = pr.ru1.EnterScope(nil)
c.Assert(err, gc.IsNil)
s.assertScopeChange(c, w0, []string{"riak/1"}, nil)
s.assertNoScopeChange(c, w0)
assertInScope(c, pr.ru1)
// ru1 enters again, check no problems and no changes.
err = pr.ru1.EnterScope(nil)
c.Assert(err, gc.IsNil)
s.assertNoScopeChange(c, w0)
assertInScope(c, pr.ru1)
// Stop watching; ru2 enters.
testing.AssertStop(c, w0)
assertNotInScope(c, pr.ru2)
err = pr.ru2.EnterScope(nil)
c.Assert(err, gc.IsNil)
assertInScope(c, pr.ru2)
// Start watch again, check initial event.
w0 = pr.ru0.WatchScope()
defer testing.AssertStop(c, w0)
s.assertScopeChange(c, w0, []string{"riak/1", "riak/2"}, nil)
s.assertNoScopeChange(c, w0)
// ru1 leaves; check event.
assertInScope(c, pr.ru1)
err = pr.ru1.LeaveScope()
c.Assert(err, gc.IsNil)
s.assertScopeChange(c, w0, nil, []string{"riak/1"})
s.assertNoScopeChange(c, w0)
assertNotInScope(c, pr.ru1)
// ru1 leaves again; check no problems and no changes.
err = pr.ru1.LeaveScope()
c.Assert(err, gc.IsNil)
s.assertNoScopeChange(c, w0)
assertNotInScope(c, pr.ru1)
}
func (s *provisionerSuite) TestWatchEnvironMachines(c *gc.C) {
w, err := s.provisioner.WatchEnvironMachines()
c.Assert(err, gc.IsNil)
defer statetesting.AssertStop(c, w)
wc := statetesting.NewStringsWatcherC(c, s.BackingState, w)
// Initial event.
wc.AssertChange(s.machine.Id())
// Add another 2 machines make sure they are detected.
otherMachine, err := s.State.AddMachine("quantal", state.JobHostUnits)
c.Assert(err, gc.IsNil)
otherMachine, err = s.State.AddMachine("quantal", state.JobHostUnits)
c.Assert(err, gc.IsNil)
wc.AssertChange("1", "2")
// Change the lifecycle of last machine.
err = otherMachine.EnsureDead()
c.Assert(err, gc.IsNil)
wc.AssertChange("2")
// Add a container and make sure it's not detected.
template := state.MachineTemplate{
Series: "quantal",
Jobs: []state.MachineJob{state.JobHostUnits},
}
_, err = s.State.AddMachineInsideMachine(template, s.machine.Id(), instance.LXC)
c.Assert(err, gc.IsNil)
wc.AssertNoChange()
statetesting.AssertStop(c, w)
wc.AssertClosed()
}
func (s *withoutStateServerSuite) TestWatchMachineErrorRetry(c *gc.C) {
s.PatchValue(&provisioner.ErrorRetryWaitDelay, 2*coretesting.ShortWait)
c.Assert(s.resources.Count(), gc.Equals, 0)
_, err := s.provisioner.WatchMachineErrorRetry()
c.Assert(err, gc.IsNil)
// 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.State, resource.(state.NotifyWatcher))
wc.AssertNoChange()
// We should now get a time triggered change.
wc.AssertOneChange()
// Make sure WatchMachineErrorRetry fails with a machine agent login.
anAuthorizer := s.authorizer
anAuthorizer.MachineAgent = true
anAuthorizer.EnvironManager = false
aProvisioner, err := provisioner.NewProvisionerAPI(s.State, s.resources, anAuthorizer)
c.Assert(err, gc.IsNil)
result, err := aProvisioner.WatchMachineErrorRetry()
c.Assert(err, gc.ErrorMatches, "permission denied")
c.Assert(result, gc.DeepEquals, params.NotifyWatchResult{})
}
func (s *FilterSuite) TestServiceDeath(c *gc.C) {
f, err := newFilter(s.uniter, s.unit.Tag())
c.Assert(err, gc.IsNil)
defer statetesting.AssertStop(c, f)
dyingAsserter := coretesting.NotifyAsserterC{
C: c,
Precond: func() { s.BackingState.StartSync() },
Chan: f.UnitDying(),
}
dyingAsserter.AssertNoReceive()
err = s.unit.SetStatus(params.StatusStarted, "", nil)
c.Assert(err, gc.IsNil)
err = s.wordpress.Destroy()
c.Assert(err, gc.IsNil)
timeout := time.After(coretesting.LongWait)
loop:
for {
select {
case <-f.UnitDying():
break loop
case <-time.After(coretesting.ShortWait):
s.BackingState.StartSync()
case <-timeout:
c.Fatalf("dead not detected")
}
}
err = s.unit.Refresh()
c.Assert(err, gc.IsNil)
c.Assert(s.unit.Life(), gc.Equals, state.Dying)
// Can't set s.wordpress to Dead while it still has units.
}
func (s *uniterSuite) TestWatchConfigSettings(c *gc.C) {
err := s.wordpressUnit.SetCharmURL(s.wpCharm.URL())
c.Assert(err, gc.IsNil)
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.WatchConfigSettings(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)
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 *deployerSuite) TestWatchUnits(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.deployer.WatchUnits(args)
c.Assert(err, gc.IsNil)
sort.Strings(result.Results[0].Changes)
c.Assert(result, gc.DeepEquals, params.StringsWatchResults{
Results: []params.StringsWatchResult{
{Changes: []string{"logging/0", "mysql/0"}, StringsWatcherId: "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].StringsWatcherId, 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.NewStringsWatcherC(c, s.State, resource.(state.StringsWatcher))
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 *withoutStateServerSuite) TestWatchEnvironMachines(c *gc.C) {
c.Assert(s.resources.Count(), gc.Equals, 0)
got, err := s.provisioner.WatchEnvironMachines()
c.Assert(err, gc.IsNil)
want := params.StringsWatchResult{
StringsWatcherId: "1",
Changes: []string{"0", "1", "2", "3", "4"},
}
c.Assert(got.StringsWatcherId, gc.Equals, want.StringsWatcherId)
c.Assert(got.Changes, jc.SameContents, want.Changes)
// 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.NewStringsWatcherC(c, s.State, resource.(state.StringsWatcher))
wc.AssertNoChange()
// Make sure WatchEnvironMachines fails with a machine agent login.
anAuthorizer := s.authorizer
anAuthorizer.MachineAgent = true
anAuthorizer.EnvironManager = false
aProvisioner, err := provisioner.NewProvisionerAPI(s.State, s.resources, anAuthorizer)
c.Assert(err, gc.IsNil)
result, err := aProvisioner.WatchEnvironMachines()
c.Assert(err, gc.ErrorMatches, "permission denied")
c.Assert(result, gc.DeepEquals, params.StringsWatchResult{})
}
func (s *firewallerSuite) TestWatchUnits(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.WatchUnits(args)
c.Assert(err, gc.IsNil)
c.Assert(result, jc.DeepEquals, params.StringsWatchResults{
Results: []params.StringsWatchResult{
{Changes: []string{"wordpress/0"}, StringsWatcherId: "1"},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.NotFoundError("machine 42")},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.ErrUnauthorized},
{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].StringsWatcherId, 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.NewStringsWatcherC(c, s.State, resource.(state.StringsWatcher))
wc.AssertNoChange()
}
func (s *watcherSuite) TestWatchUnitsKeepsEvents(c *gc.C) {
// Create two services, relate them, and add one unit to each - a
// principal and a subordinate.
mysql := s.AddTestingService(c, "mysql", s.AddTestingCharm(c, "mysql"))
logging := s.AddTestingService(c, "logging", s.AddTestingCharm(c, "logging"))
eps, err := s.State.InferEndpoints([]string{"mysql", "logging"})
c.Assert(err, gc.IsNil)
rel, err := s.State.AddRelation(eps...)
c.Assert(err, gc.IsNil)
principal, err := mysql.AddUnit()
c.Assert(err, gc.IsNil)
err = principal.AssignToMachine(s.rawMachine)
c.Assert(err, gc.IsNil)
relUnit, err := rel.Unit(principal)
c.Assert(err, gc.IsNil)
err = relUnit.EnterScope(nil)
c.Assert(err, gc.IsNil)
subordinate, err := logging.Unit("logging/0")
c.Assert(err, gc.IsNil)
// Call the Deployer facade's WatchUnits for machine-0.
var results params.StringsWatchResults
args := params.Entities{Entities: []params.Entity{{Tag: s.rawMachine.Tag()}}}
err = s.stateAPI.Call("Deployer", "", "WatchUnits", args, &results)
c.Assert(err, gc.IsNil)
c.Assert(results.Results, gc.HasLen, 1)
result := results.Results[0]
c.Assert(result.Error, gc.IsNil)
// Start a StringsWatcher and check the initial event.
w := watcher.NewStringsWatcher(s.stateAPI, result)
wc := statetesting.NewStringsWatcherC(c, s.State, w)
wc.AssertChange("mysql/0", "logging/0")
wc.AssertNoChange()
// Now, without reading any changes advance the lifecycle of both
// units, inducing an update server-side after each two changes to
// ensure they're reported as separate events over the API.
err = subordinate.EnsureDead()
c.Assert(err, gc.IsNil)
s.BackingState.StartSync()
err = subordinate.Remove()
c.Assert(err, gc.IsNil)
err = principal.EnsureDead()
c.Assert(err, gc.IsNil)
s.BackingState.StartSync()
// Expect these changes as 2 separate events, so that
// nothing gets lost.
wc.AssertChange("logging/0")
wc.AssertChange("mysql/0")
wc.AssertNoChange()
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 *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 *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 *relationUnitSuite) TestWatchRelationUnits(c *gc.C) {
// Enter scope with mysqlUnit.
myRelUnit, err := s.stateRelation.Unit(s.mysqlUnit)
c.Assert(err, gc.IsNil)
err = myRelUnit.EnterScope(nil)
c.Assert(err, gc.IsNil)
s.assertInScope(c, myRelUnit, true)
apiRel, err := s.uniter.Relation(s.stateRelation.Tag())
c.Assert(err, gc.IsNil)
apiUnit, err := s.uniter.Unit("unit-wordpress-0")
c.Assert(err, gc.IsNil)
apiRelUnit, err := apiRel.Unit(apiUnit)
c.Assert(err, gc.IsNil)
w, err := apiRelUnit.Watch()
defer statetesting.AssertStop(c, w)
wc := statetesting.NewRelationUnitsWatcherC(c, s.BackingState, w)
// Initial event.
wc.AssertChange([]string{"mysql/0"}, nil)
// Leave scope with mysqlUnit, check it's detected.
err = myRelUnit.LeaveScope()
c.Assert(err, gc.IsNil)
s.assertInScope(c, myRelUnit, false)
wc.AssertChange(nil, []string{"mysql/0"})
// Non-change is not reported.
err = myRelUnit.LeaveScope()
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 *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 *FilterSuite) TestResolvedEvents(c *gc.C) {
f, err := newFilter(s.uniter, s.unit.Tag())
c.Assert(err, gc.IsNil)
defer statetesting.AssertStop(c, f)
resolvedAsserter := coretesting.ContentAsserterC{
C: c,
Precond: func() { s.BackingState.StartSync() },
Chan: f.ResolvedEvents(),
}
resolvedAsserter.AssertNoReceive()
// Request an event; no interesting event is available.
f.WantResolvedEvent()
resolvedAsserter.AssertNoReceive()
// Change the unit in an irrelevant way; no events.
err = s.unit.SetStatus(params.StatusError, "blarg", nil)
c.Assert(err, gc.IsNil)
resolvedAsserter.AssertNoReceive()
// Change the unit's resolved to an interesting value; new event received.
err = s.unit.SetResolved(state.ResolvedRetryHooks)
c.Assert(err, gc.IsNil)
assertChange := func(expect params.ResolvedMode) {
rm := resolvedAsserter.AssertOneReceive().(params.ResolvedMode)
c.Assert(rm, gc.Equals, expect)
}
assertChange(params.ResolvedRetryHooks)
// Ask for the event again, and check it's resent.
f.WantResolvedEvent()
assertChange(params.ResolvedRetryHooks)
// Clear the resolved status *via the filter*; check not resent...
err = f.ClearResolved()
c.Assert(err, gc.IsNil)
resolvedAsserter.AssertNoReceive()
// ...even when requested.
f.WantResolvedEvent()
resolvedAsserter.AssertNoReceive()
// Induce several events; only latest state is reported.
err = s.unit.SetResolved(state.ResolvedRetryHooks)
c.Assert(err, gc.IsNil)
err = f.ClearResolved()
c.Assert(err, gc.IsNil)
err = s.unit.SetResolved(state.ResolvedNoHooks)
c.Assert(err, gc.IsNil)
assertChange(params.ResolvedNoHooks)
}
func (s *provisionerSuite) TestWatchContainers(c *gc.C) {
apiMachine, err := s.provisioner.Machine(s.machine.Tag())
c.Assert(err, gc.IsNil)
// Add one LXC container.
template := state.MachineTemplate{
Series: "quantal",
Jobs: []state.MachineJob{state.JobHostUnits},
}
container, err := s.State.AddMachineInsideMachine(template, s.machine.Id(), instance.LXC)
c.Assert(err, gc.IsNil)
w, err := apiMachine.WatchContainers(instance.LXC)
c.Assert(err, gc.IsNil)
defer statetesting.AssertStop(c, w)
wc := statetesting.NewStringsWatcherC(c, s.BackingState, w)
// Initial event.
wc.AssertChange(container.Id())
// Change something other than the containers and make sure it's
// not detected.
err = apiMachine.SetStatus(params.StatusStarted, "not really", nil)
c.Assert(err, gc.IsNil)
wc.AssertNoChange()
// Add a KVM container and make sure it's not detected.
container, err = s.State.AddMachineInsideMachine(template, s.machine.Id(), instance.KVM)
c.Assert(err, gc.IsNil)
wc.AssertNoChange()
// Add another LXC container and make sure it's detected.
container, err = s.State.AddMachineInsideMachine(template, s.machine.Id(), instance.LXC)
c.Assert(err, gc.IsNil)
wc.AssertChange(container.Id())
statetesting.AssertStop(c, w)
wc.AssertClosed()
}
func (s *loggerSuite) TestWatchLoggingConfig(c *gc.C) {
watcher, err := s.logger.WatchLoggingConfig(s.rawMachine.Tag())
c.Assert(err, gc.IsNil)
defer testing.AssertStop(c, watcher)
wc := testing.NewNotifyWatcherC(c, s.BackingState, watcher)
// Initial event
wc.AssertOneChange()
loggingConfig := "<root>=WARN;juju.log.test=DEBUG"
s.setLoggingConfig(c, loggingConfig)
// One change noticing the new version
wc.AssertOneChange()
// Setting the version to the same value doesn't trigger a change
s.setLoggingConfig(c, loggingConfig)
wc.AssertNoChange()
loggingConfig = loggingConfig + ";wibble=DEBUG"
s.setLoggingConfig(c, loggingConfig)
wc.AssertOneChange()
testing.AssertStop(c, watcher)
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 *withoutStateServerSuite) TestWatchAllContainers(c *gc.C) {
c.Assert(s.resources.Count(), gc.Equals, 0)
args := params.WatchContainers{Params: []params.WatchContainer{
{MachineTag: s.machines[0].Tag()},
{MachineTag: s.machines[1].Tag()},
{MachineTag: "machine-42"},
{MachineTag: "unit-foo-0"},
{MachineTag: "service-bar"},
}}
result, err := s.provisioner.WatchAllContainers(args)
c.Assert(err, gc.IsNil)
c.Assert(result, gc.DeepEquals, params.StringsWatchResults{
Results: []params.StringsWatchResult{
{StringsWatcherId: "1", Changes: []string{}},
{StringsWatcherId: "2", Changes: []string{}},
{Error: apiservertesting.NotFoundError("machine 42")},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.ErrUnauthorized},
},
})
// Verify the resources were registered and stop them when done.
c.Assert(s.resources.Count(), gc.Equals, 2)
m0Watcher := s.resources.Get("1")
defer statetesting.AssertStop(c, m0Watcher)
m1Watcher := s.resources.Get("2")
defer statetesting.AssertStop(c, m1Watcher)
// Check that the Watch has consumed the initial event ("returned"
// in the Watch call)
wc0 := statetesting.NewStringsWatcherC(c, s.State, m0Watcher.(state.StringsWatcher))
wc0.AssertNoChange()
wc1 := statetesting.NewStringsWatcherC(c, s.State, m1Watcher.(state.StringsWatcher))
wc1.AssertNoChange()
}
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.wordpressService.SetExposed()
c.Assert(err, gc.IsNil)
wc.AssertOneChange()
// Destroy the service and check it's detected.
err = s.wordpressService.Destroy()
c.Assert(err, gc.IsNil)
wc.AssertOneChange()
statetesting.AssertStop(c, w)
wc.AssertClosed()
}
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()
}
