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, jc.ErrorIsNil)
s.setAssignedMachineAddresses(c, unit)
wc.AssertOneChange()
// Make two changes, check one event.
err = unit.SetPassword("arble-farble-dying-yarble")
c.Assert(err, jc.ErrorIsNil)
err = unit.Destroy()
c.Assert(err, jc.ErrorIsNil)
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, jc.ErrorIsNil)
err = unit.Remove()
c.Assert(err, jc.ErrorIsNil)
w = s.unit.Watch()
defer testing.AssertStop(c, w)
testing.NewNotifyWatcherC(c, s.State, w).AssertOneChange()
}
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 *RebootSuite) SetUpTest(c *gc.C) {
s.ConnSuite.SetUpTest(c)
var err error
// Add machine
s.machine, err = s.State.AddMachine("quantal", state.JobManageModel)
c.Assert(err, jc.ErrorIsNil)
// Add first container
s.c1, err = s.State.AddMachineInsideMachine(state.MachineTemplate{
Series: "quantal",
Jobs: []state.MachineJob{state.JobHostUnits},
}, s.machine.Id(), instance.LXC)
c.Assert(err, jc.ErrorIsNil)
// Add second container
s.c2, err = s.State.AddMachineInsideMachine(state.MachineTemplate{
Series: "quantal",
Jobs: []state.MachineJob{state.JobHostUnits},
}, s.c1.Id(), instance.LXC)
c.Assert(err, jc.ErrorIsNil)
// Add container on the same level as the first container.
s.c3, err = s.State.AddMachineInsideMachine(state.MachineTemplate{
Series: "quantal",
Jobs: []state.MachineJob{state.JobHostUnits},
}, s.machine.Id(), instance.LXC)
c.Assert(err, jc.ErrorIsNil)
s.w, err = s.machine.WatchForRebootEvent()
c.Assert(err, jc.ErrorIsNil)
s.wc = statetesting.NewNotifyWatcherC(c, s.State, s.w)
s.wc.AssertOneChange()
s.wC1, err = s.c1.WatchForRebootEvent()
c.Assert(err, jc.ErrorIsNil)
// Initial event on container 1.
s.wcC1 = statetesting.NewNotifyWatcherC(c, s.State, s.wC1)
s.wcC1.AssertOneChange()
// Get reboot watcher on container 2
s.wC2, err = s.c2.WatchForRebootEvent()
c.Assert(err, jc.ErrorIsNil)
// Initial event on container 2.
s.wcC2 = statetesting.NewNotifyWatcherC(c, s.State, s.wC2)
s.wcC2.AssertOneChange()
// Get reboot watcher on container 3
s.wC3, err = s.c3.WatchForRebootEvent()
c.Assert(err, jc.ErrorIsNil)
// Initial event on container 3.
s.wcC3 = statetesting.NewNotifyWatcherC(c, s.State, s.wC3)
s.wcC3.AssertOneChange()
}
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 *retryStrategySuite) TestWatchRetryStrategy(c *gc.C) {
c.Assert(s.resources.Count(), gc.Equals, 0)
args := params.Entities{Entities: []params.Entity{
{Tag: s.unit.UnitTag().String()},
{Tag: "unit-foo-42"},
}}
r, err := s.strategy.WatchRetryStrategy(args)
c.Assert(err, jc.ErrorIsNil)
c.Assert(r, gc.DeepEquals, params.NotifyWatchResults{
Results: []params.NotifyWatchResult{
{NotifyWatcherId: "1"},
{Error: apiservertesting.ErrUnauthorized},
},
})
c.Assert(s.resources.Count(), gc.Equals, 1)
resource := s.resources.Get("1")
defer statetesting.AssertStop(c, resource)
wc := statetesting.NewNotifyWatcherC(c, s.State, resource.(state.NotifyWatcher))
wc.AssertNoChange()
s.setRetryStrategy(c, false)
c.Assert(err, jc.ErrorIsNil)
wc.AssertOneChange()
}
func (s *CloudCredentialsSuite) createCredentialWatcher(c *gc.C, st *state.State, cred names.CloudCredentialTag) (
state.NotifyWatcher, statetesting.NotifyWatcherC,
) {
w := st.WatchCredential(cred)
s.AddCleanup(func(c *gc.C) { statetesting.AssertStop(c, w) })
return w, statetesting.NewNotifyWatcherC(c, st, w)
}
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 [][]network.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 *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 *VolumeStateSuite) TestWatchVolumeAttachment(c *gc.C) {
_, u, storageTag := s.setupSingleStorage(c, "block", "loop-pool")
err := s.State.AssignUnit(u, state.AssignCleanEmpty)
c.Assert(err, jc.ErrorIsNil)
assignedMachineId, err := u.AssignedMachineId()
c.Assert(err, jc.ErrorIsNil)
machineTag := names.NewMachineTag(assignedMachineId)
volume := s.storageInstanceVolume(c, storageTag)
volumeTag := volume.VolumeTag()
w := s.State.WatchVolumeAttachment(machineTag, volumeTag)
defer testing.AssertStop(c, w)
wc := testing.NewNotifyWatcherC(c, s.State, w)
wc.AssertOneChange()
machine, err := s.State.Machine(assignedMachineId)
c.Assert(err, jc.ErrorIsNil)
err = machine.SetProvisioned("inst-id", "fake_nonce", nil)
c.Assert(err, jc.ErrorIsNil)
// volume attachment will NOT react to volume changes
err = s.State.SetVolumeInfo(volumeTag, state.VolumeInfo{VolumeId: "vol-123"})
c.Assert(err, jc.ErrorIsNil)
wc.AssertNoChange()
err = s.State.SetVolumeAttachmentInfo(
machineTag, volumeTag, state.VolumeAttachmentInfo{
DeviceName: "xvdf1",
},
)
c.Assert(err, jc.ErrorIsNil)
wc.AssertOneChange()
}
// TestWatchMeterStatus tests the meter status watcher functionality.
func TestWatchMeterStatus(c *gc.C, status meterstatus.MeterStatus, unit *jujustate.Unit, state *jujustate.State, resources *common.Resources) {
c.Assert(resources.Count(), gc.Equals, 0)
args := params.Entities{Entities: []params.Entity{
{Tag: unit.UnitTag().String()},
{Tag: "unit-foo-42"},
}}
result, err := status.WatchMeterStatus(args)
c.Assert(err, jc.ErrorIsNil)
c.Assert(result, gc.DeepEquals, params.NotifyWatchResults{
Results: []params.NotifyWatchResult{
{NotifyWatcherId: "1"},
{Error: apiservertesting.ErrUnauthorized},
},
})
// Verify the resource was registered and stop when done
c.Assert(resources.Count(), gc.Equals, 1)
resource := 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, state, resource.(jujustate.NotifyWatcher))
wc.AssertNoChange()
err = unit.SetMeterStatus("GREEN", "No additional information.")
c.Assert(err, jc.ErrorIsNil)
wc.AssertOneChange()
}
func (s *UpgradeSuite) TestWatch(c *gc.C) {
v111 := vers("1.1.1")
v123 := vers("1.2.3")
serverIdB, serverIdC := s.addControllers(c)
s.provision(c, serverIdB, serverIdC)
w := s.State.WatchUpgradeInfo()
defer statetesting.AssertStop(c, w)
// initial event
wc := statetesting.NewNotifyWatcherC(c, s.State, w)
wc.AssertOneChange()
// single change is reported
_, err := s.State.EnsureUpgradeInfo(s.serverIdA, v111, v123)
c.Assert(err, jc.ErrorIsNil)
wc.AssertOneChange()
// non-change is not reported
_, err = s.State.EnsureUpgradeInfo(s.serverIdA, v111, v123)
c.Assert(err, jc.ErrorIsNil)
wc.AssertNoChange()
// changes are coalesced
_, err = s.State.EnsureUpgradeInfo(serverIdB, v111, v123)
c.Assert(err, jc.ErrorIsNil)
_, err = s.State.EnsureUpgradeInfo(serverIdC, v111, v123)
c.Assert(err, jc.ErrorIsNil)
wc.AssertOneChange()
// closed on stop
statetesting.AssertStop(c, w)
wc.AssertClosed()
}
func (s *APIAddresserTests) TestWatchAPIHostPorts(c *gc.C) {
expectServerAddrs := [][]network.HostPort{{{
Address: network.NewAddress("0.1.2.3", network.ScopeUnknown),
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 *machinerSuite) TestWatch(c *gc.C) {
machine, err := s.machiner.Machine(names.NewMachineTag("1"))
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", nil)
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 *ServiceLeaderSuite) TestWatchInitialEvent(c *gc.C) {
w := s.service.WatchLeaderSettings()
defer testing.AssertStop(c, w)
wc := testing.NewNotifyWatcherC(c, s.State, w)
wc.AssertOneChange()
}
func (s *authorisedKeysSuite) TestWatchAuthorisedKeys(c *gc.C) {
args := params.Entities{
Entities: []params.Entity{
{Tag: s.rawMachine.Tag().String()},
{Tag: s.unrelatedMachine.Tag().String()},
{Tag: "machine-42"},
},
}
results, err := s.keyupdater.WatchAuthorisedKeys(args)
c.Assert(err, jc.ErrorIsNil)
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 *unitSuite) TestWatchAddresses(c *gc.C) {
w, err := s.apiUnit.WatchAddresses()
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.wordpressMachine.SetAddresses(network.NewAddress("0.1.2.3", network.ScopeUnknown))
c.Assert(err, gc.IsNil)
err = s.wordpressMachine.SetAddresses(network.NewAddress("0.1.2.4", network.ScopeUnknown))
c.Assert(err, gc.IsNil)
wc.AssertOneChange()
// Non-change is not reported.
err = s.wordpressMachine.SetAddresses(network.NewAddress("0.1.2.4", network.ScopeUnknown))
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 *networkerSuite) TestWatchInterfaces(c *gc.C) {
c.Assert(s.resources.Count(), gc.Equals, 0)
args := params.Entities{Entities: []params.Entity{
{Tag: "machine-0"},
{Tag: "machine-0-lxc-0"},
{Tag: "machine-0-lxc-0-lxc-0"},
}}
result, err := s.networker.WatchInterfaces(args)
c.Assert(err, gc.IsNil)
c.Assert(result, gc.DeepEquals, params.NotifyWatchResults{
Results: []params.NotifyWatchResult{
{NotifyWatcherId: "1"},
{NotifyWatcherId: "2"},
{NotifyWatcherId: "3"},
},
})
// Verify the resource was registered and stop when done
c.Assert(s.resources.Count(), gc.Equals, 3)
for _, watcherId := range []string{"1", "2", "3"} {
resource := s.resources.Get(watcherId)
defer statetesting.AssertStop(c, resource)
// Check that the WatchInterfaces has consumed the initial event ("returned" in
// the Watch call)
wc := statetesting.NewNotifyWatcherC(c, s.State, resource.(state.NotifyWatcher))
wc.AssertNoChange()
}
}
func (s *MigrationSuite) createStatusWatcher(c *gc.C, st *state.State) (
state.NotifyWatcher, statetesting.NotifyWatcherC,
) {
w := st.WatchMigrationStatus()
s.AddCleanup(func(c *gc.C) { statetesting.AssertStop(c, w) })
return w, statetesting.NewNotifyWatcherC(c, st, w)
}
func (s *MachineRemovalSuite) createRemovalWatcher(c *gc.C, st *state.State) (
state.NotifyWatcher, testing.NotifyWatcherC,
) {
w := st.WatchMachineRemovals()
s.AddCleanup(func(c *gc.C) { workertest.CleanKill(c, w) })
return w, testing.NewNotifyWatcherC(c, st, w)
}
func (s *unitSuite) TestWatchMeterStatus(c *gc.C) {
w, err := s.apiUnit.WatchMeterStatus()
defer statetesting.AssertStop(c, w)
wc := statetesting.NewNotifyWatcherC(c, s.BackingState, w)
// Initial event.
wc.AssertOneChange()
err = s.wordpressUnit.SetMeterStatus("GREEN", "ok")
c.Assert(err, jc.ErrorIsNil)
err = s.wordpressUnit.SetMeterStatus("AMBER", "ok")
c.Assert(err, jc.ErrorIsNil)
wc.AssertOneChange()
// Non-change is not reported.
err = s.wordpressUnit.SetMeterStatus("AMBER", "ok")
c.Assert(err, jc.ErrorIsNil)
wc.AssertNoChange()
mm, err := s.State.MetricsManager()
c.Assert(err, jc.ErrorIsNil)
err = mm.SetLastSuccessfulSend(time.Now())
c.Assert(err, jc.ErrorIsNil)
for i := 0; i < 3; i++ {
err := mm.IncrementConsecutiveErrors()
c.Assert(err, jc.ErrorIsNil)
}
status := mm.MeterStatus()
c.Assert(status.Code, gc.Equals, state.MeterAmber) // Confirm meter status has changed
wc.AssertOneChange()
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 *ModelMigrationSuite) createStatusWatcher(c *gc.C, st *state.State) (
state.NotifyWatcher, statetesting.NotifyWatcherC,
) {
w, err := st.WatchMigrationStatus()
c.Assert(err, jc.ErrorIsNil)
s.AddCleanup(func(c *gc.C) { statetesting.AssertStop(c, w) })
return w, statetesting.NewNotifyWatcherC(c, st, w)
}
func (*multiNotifyWatcherSuite) TestMultiNotifyWatcherStop(c *gc.C) {
w0 := apiservertesting.NewFakeNotifyWatcher()
w1 := apiservertesting.NewFakeNotifyWatcher()
mw := common.NewMultiNotifyWatcher(w0, w1)
wc := statetesting.NewNotifyWatcherC(c, nopSyncStarter{}, mw)
wc.AssertOneChange()
statetesting.AssertCanStopWhenSending(c, mw)
wc.AssertClosed()
}
func (s *ServiceLeaderSuite) TestWatchDetectChange(c *gc.C) {
w := s.service.WatchLeaderSettings()
defer testing.AssertStop(c, w)
wc := testing.NewNotifyWatcherC(c, s.State, w)
wc.AssertOneChange()
err := s.service.UpdateLeaderSettings(&fakeToken{}, map[string]string{
"something": "changed",
})
c.Assert(err, jc.ErrorIsNil)
wc.AssertOneChange()
}
func (*multiNotifyWatcherSuite) TestMultiNotifyWatcherStop(c *gc.C) {
w0 := &fakeNotifyWatcher{changes: make(chan struct{}, 1)}
w1 := &fakeNotifyWatcher{changes: make(chan struct{}, 1)}
w0.changes <- struct{}{}
w1.changes <- struct{}{}
mw := common.NewMultiNotifyWatcher(w0, w1)
wc := statetesting.NewNotifyWatcherC(c, nopSyncStarter{}, mw)
wc.AssertOneChange()
statetesting.AssertCanStopWhenSending(c, mw)
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().String()},
{Tag: s.service.Tag().String()},
{Tag: s.units[0].Tag().String()},
}})
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 *watchStorageAttachmentSuite) testWatchStorageAttachment(c *gc.C, change func()) {
w, err := storagecommon.WatchStorageAttachment(
s.st,
s.storageTag,
s.machineTag,
s.unitTag,
)
c.Assert(err, jc.ErrorIsNil)
wc := statetesting.NewNotifyWatcherC(c, nopSyncStarter{}, w)
wc.AssertOneChange()
change()
wc.AssertOneChange()
}
func (s *MigrationSuite) createMigAndWatchReports(c *gc.C, st *state.State) (
state.ModelMigration, statetesting.NotifyWatcherC,
) {
mig, err := st.CreateMigration(s.stdSpec)
c.Assert(err, jc.ErrorIsNil)
w, err := mig.WatchMinionReports()
c.Assert(err, jc.ErrorIsNil)
s.AddCleanup(func(*gc.C) { statetesting.AssertStop(c, w) })
wc := statetesting.NewNotifyWatcherC(c, st, w)
return mig, wc
}
func (s *undertakerSuite) TestWatchEnvironResources(c *gc.C) {
undertakerClient, otherSt := s.hostedAPI(c)
defer otherSt.Close()
w, err := undertakerClient.WatchEnvironResources()
c.Assert(err, jc.ErrorIsNil)
defer statetesting.AssertStop(c, w)
wc := statetesting.NewNotifyWatcherC(c, s.State, w)
wc.AssertOneChange()
statetesting.AssertStop(c, w)
wc.AssertClosed()
}
