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 *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"}) assertJoined(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) assertJoined(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) assertJoined(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) assertJoined(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. assertJoined(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 *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 *stateSuite) TestWatchEnvironMachines(c *gc.C) { w, err := s.firewaller.WatchEnvironMachines() c.Assert(err, gc.IsNil) defer statetesting.AssertStop(c, w) wc := statetesting.NewStringsWatcherC(c, s.BackingState, w) // Initial event. wc.AssertChange(s.machines[0].Id(), s.machines[1].Id(), s.machines[2].Id()) // Add another machine make sure they are detected. otherMachine, err := s.State.AddMachine("quantal", state.JobHostUnits) c.Assert(err, gc.IsNil) wc.AssertChange(otherMachine.Id()) // Change the life cycle of last machine. err = otherMachine.EnsureDead() c.Assert(err, gc.IsNil) wc.AssertChange(otherMachine.Id()) // 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.machines[0].Id(), instance.LXC) c.Assert(err, gc.IsNil) wc.AssertNoChange() 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 *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 *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 *RelationUnitSuite) TestCoalesceWatchScope(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) // ru1 and ru2 enter; check changes observed together. err := pr.ru1.EnterScope(nil) c.Assert(err, gc.IsNil) err = pr.ru2.EnterScope(nil) c.Assert(err, gc.IsNil) s.assertScopeChange(c, w0, []string{"riak/1", "riak/2"}, nil) s.assertNoScopeChange(c, w0) // ru1 leaves and re-enters; check no change observed. err = pr.ru1.LeaveScope() c.Assert(err, gc.IsNil) err = pr.ru1.EnterScope(nil) c.Assert(err, gc.IsNil) s.assertNoScopeChange(c, w0) // ru1 and ru2 leave; check changes observed together. err = pr.ru1.LeaveScope() c.Assert(err, gc.IsNil) err = pr.ru2.LeaveScope() c.Assert(err, gc.IsNil) s.assertScopeChange(c, w0, nil, []string{"riak/1", "riak/2"}) s.assertNoScopeChange(c, w0) }
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 *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 *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 *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 *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() }
func (s *RelationUnitSuite) TestPrepareLeaveScope(c *gc.C) { prr := NewProReqRelation(c, &s.ConnSuite, charm.ScopeGlobal) // Test empty initial event. w0 := prr.pru0.WatchScope() defer testing.AssertStop(c, w0) s.assertScopeChange(c, w0, nil, nil) s.assertNoScopeChange(c, w0) // rru0 and rru1 enter; check changes. err := prr.rru0.EnterScope(nil) c.Assert(err, gc.IsNil) err = prr.rru1.EnterScope(nil) c.Assert(err, gc.IsNil) s.assertScopeChange(c, w0, []string{"wordpress/0", "wordpress/1"}, nil) s.assertNoScopeChange(c, w0) // rru0 notifies that it will leave soon; it's reported as departed by the // watcher, but InScope remains accurate. err = prr.rru0.PrepareLeaveScope() c.Assert(err, gc.IsNil) s.assertScopeChange(c, w0, nil, []string{"wordpress/0"}) s.assertNoScopeChange(c, w0) assertInScope(c, prr.rru0) assertNotJoined(c, prr.rru0) // rru1 leaves, and the relation is destroyed; it's not removed, because // rru0 keeps it alive until it really leaves scope. err = prr.rru1.LeaveScope() c.Assert(err, gc.IsNil) s.assertScopeChange(c, w0, nil, []string{"wordpress/1"}) s.assertNoScopeChange(c, w0) err = prr.rel.Destroy() c.Assert(err, gc.IsNil) err = prr.rel.Refresh() c.Assert(err, gc.IsNil) // rru0 really leaves; the relation is cleaned up. err = prr.rru0.LeaveScope() c.Assert(err, gc.IsNil) err = prr.rel.Destroy() c.Assert(err, gc.IsNil) s.assertNoScopeChange(c, w0) err = prr.rel.Refresh() c.Assert(err, jc.Satisfies, errors.IsNotFound) }
func (s *UpgraderSuite) TestUpgraderSetsTools(c *gc.C) { vers := version.MustParseBinary("5.4.3-precise-amd64") err := statetesting.SetAgentVersion(s.State, vers.Number) c.Assert(err, gc.IsNil) stor := s.Conn.Environ.Storage() agentTools := envtesting.PrimeTools(c, stor, s.DataDir(), vers) s.PatchValue(&version.Current, agentTools.Version) err = envtools.MergeAndWriteMetadata(stor, coretools.List{agentTools}, envtools.DoNotWriteMirrors) _, err = s.machine.AgentTools() c.Assert(err, jc.Satisfies, errors.IsNotFound) u := s.makeUpgrader() statetesting.AssertStop(c, u) s.machine.Refresh() gotTools, err := s.machine.AgentTools() c.Assert(err, gc.IsNil) envtesting.CheckTools(c, gotTools, agentTools) }
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 *UpgraderSuite) TestUpgraderSetVersion(c *gc.C) { vers := version.MustParseBinary("5.4.3-precise-amd64") agentTools := envtesting.PrimeTools(c, s.Conn.Environ.Storage(), s.DataDir(), vers) s.PatchValue(&version.Current, agentTools.Version) err := os.RemoveAll(filepath.Join(s.DataDir(), "tools")) c.Assert(err, gc.IsNil) _, err = s.machine.AgentTools() c.Assert(err, jc.Satisfies, errors.IsNotFound) err = statetesting.SetAgentVersion(s.State, vers.Number) c.Assert(err, gc.IsNil) u := s.makeUpgrader() statetesting.AssertStop(c, u) s.machine.Refresh() gotTools, err := s.machine.AgentTools() c.Assert(err, gc.IsNil) c.Assert(gotTools, gc.DeepEquals, &coretools.Tools{Version: version.Current}) }
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 *firewallerSuite) TestWatchEnvironMachines(c *gc.C) { c.Assert(s.resources.Count(), gc.Equals, 0) got, err := s.firewaller.WatchEnvironMachines() c.Assert(err, gc.IsNil) want := params.StringsWatchResult{ StringsWatcherId: "1", Changes: []string{"0", "1", "2"}, } 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() }
func (s *FilterSuite) TestRelationsEvents(c *gc.C) { f, err := newFilter(s.uniter, s.unit.Tag()) c.Assert(err, gc.IsNil) defer statetesting.AssertStop(c, f) assertNoChange := func() { s.BackingState.StartSync() select { case ids := <-f.RelationsEvents(): c.Fatalf("unexpected relations event %#v", ids) case <-time.After(coretesting.ShortWait): } } assertNoChange() // Add a couple of relations; check the event. rel0 := s.addRelation(c) rel1 := s.addRelation(c) assertChange := func(expect []int) { s.BackingState.StartSync() select { case got := <-f.RelationsEvents(): c.Assert(got, gc.DeepEquals, expect) case <-time.After(coretesting.LongWait): c.Fatalf("timed out") } assertNoChange() } assertChange([]int{0, 1}) // Add another relation, and change another's Life (by entering scope before // Destroy, thereby setting the relation to Dying); check event. s.addRelation(c) ru0, err := rel0.Unit(s.unit) c.Assert(err, gc.IsNil) err = ru0.EnterScope(nil) c.Assert(err, gc.IsNil) err = rel0.Destroy() c.Assert(err, gc.IsNil) assertChange([]int{0, 2}) // Remove a relation completely; check no event, because the relation // could not have been removed if the unit was in scope, and therefore // the uniter never needs to hear about it. err = rel1.Destroy() c.Assert(err, gc.IsNil) assertNoChange() err = f.Stop() c.Assert(err, gc.IsNil) // Start a new filter, check initial event. f, err = newFilter(s.uniter, s.unit.Tag()) c.Assert(err, gc.IsNil) defer statetesting.AssertStop(c, f) assertChange([]int{0, 2}) // Check setting the charm URL generates all new relation events. err = f.SetCharm(s.wpcharm.URL()) c.Assert(err, gc.IsNil) assertChange([]int{0, 2}) }
func (s *FilterSuite) TestConfigEvents(c *gc.C) { f, err := newFilter(s.uniter, s.unit.Tag()) c.Assert(err, gc.IsNil) defer statetesting.AssertStop(c, f) // Test no changes before the charm URL is set. assertNoChange := func() { s.BackingState.StartSync() select { case <-f.ConfigEvents(): c.Fatalf("unexpected config event") case <-time.After(coretesting.ShortWait): } } assertNoChange() // Set the charm URL to trigger config events. err = f.SetCharm(s.wpcharm.URL()) c.Assert(err, gc.IsNil) assertChange := func() { s.BackingState.StartSync() select { case _, ok := <-f.ConfigEvents(): c.Assert(ok, gc.Equals, true) case <-time.After(coretesting.LongWait): c.Fatalf("timed out") } assertNoChange() } assertChange() // Change the config; new event received. changeConfig := func(title interface{}) { err := s.wordpress.UpdateConfigSettings(charm.Settings{ "blog-title": title, }) c.Assert(err, gc.IsNil) } changeConfig("20,000 leagues in the cloud") assertChange() // Change the config a few more times, then reset the events. We sync to // make sure the events have arrived in the watcher -- and then wait a // little longer, to allow for the delay while the events are coalesced // -- before we tell it to discard all received events. This would be // much better tested by controlling a mocked-out watcher directly, but // that's a bit inconvenient for this change. changeConfig(nil) changeConfig("the curious incident of the dog in the cloud") s.BackingState.StartSync() time.Sleep(250 * time.Millisecond) f.DiscardConfigEvent() assertNoChange() // Check that a filter's initial event works with DiscardConfigEvent // as expected. f, err = newFilter(s.uniter, s.unit.Tag()) c.Assert(err, gc.IsNil) defer statetesting.AssertStop(c, f) s.BackingState.StartSync() f.DiscardConfigEvent() assertNoChange() // Further changes are still collapsed as appropriate. changeConfig("forsooth") changeConfig("imagination failure") assertChange() }
func (s *FilterSuite) TestCharmUpgradeEvents(c *gc.C) { oldCharm := s.AddTestingCharm(c, "upgrade1") svc := s.AddTestingService(c, "upgradetest", oldCharm) unit, err := svc.AddUnit() c.Assert(err, gc.IsNil) s.APILogin(c, unit) f, err := newFilter(s.uniter, unit.Tag()) c.Assert(err, gc.IsNil) defer statetesting.AssertStop(c, f) // No initial event is sent. assertNoChange := func() { s.BackingState.StartSync() select { case sch := <-f.UpgradeEvents(): c.Fatalf("unexpected %#v", sch) case <-time.After(coretesting.ShortWait): } } assertNoChange() // Setting a charm generates no new events if it already matches. err = f.SetCharm(oldCharm.URL()) c.Assert(err, gc.IsNil) assertNoChange() // Explicitly request an event relative to the existing state; nothing. f.WantUpgradeEvent(false) assertNoChange() // Change the service in an irrelevant way; no events. err = svc.SetExposed() c.Assert(err, gc.IsNil) assertNoChange() // Change the service's charm; new event received. newCharm := s.AddTestingCharm(c, "upgrade2") err = svc.SetCharm(newCharm, false) c.Assert(err, gc.IsNil) assertChange := func(url *charm.URL) { s.BackingState.StartSync() select { case upgradeCharm := <-f.UpgradeEvents(): c.Assert(upgradeCharm, gc.DeepEquals, url) case <-time.After(coretesting.LongWait): c.Fatalf("timed out") } } assertChange(newCharm.URL()) assertNoChange() // Request a new upgrade *unforced* upgrade event, we should see one. f.WantUpgradeEvent(false) assertChange(newCharm.URL()) assertNoChange() // Request only *forced* upgrade events; nothing. f.WantUpgradeEvent(true) assertNoChange() // But when we have a forced upgrade to the same URL, no new event. err = svc.SetCharm(oldCharm, true) c.Assert(err, gc.IsNil) assertNoChange() // ...but a *forced* change to a different URL should generate an event. err = svc.SetCharm(newCharm, true) assertChange(newCharm.URL()) assertNoChange() }
func (s *WatchScopeSuite) TestProviderRequirerGlobal(c *gc.C) { // Create a pair of services and a relation between them. mysql := s.AddTestingService(c, "mysql", s.AddTestingCharm(c, "mysql")) mysqlEP, err := mysql.Endpoint("server") c.Assert(err, gc.IsNil) wordpress := s.AddTestingService(c, "wordpress", s.AddTestingCharm(c, "wordpress")) wordpressEP, err := wordpress.Endpoint("db") c.Assert(err, gc.IsNil) rel, err := s.State.AddRelation(mysqlEP, wordpressEP) c.Assert(err, gc.IsNil) // Add some units to the services and set their private addresses. addUnit := func(srv *state.Service, sub string, ep state.Endpoint) *state.RelationUnit { unit, err := srv.AddUnit() c.Assert(err, gc.IsNil) ru, err := rel.Unit(unit) c.Assert(err, gc.IsNil) c.Assert(ru.Endpoint(), gc.Equals, ep) return ru } msru0 := addUnit(mysql, "ms0", mysqlEP) msru1 := addUnit(mysql, "ms1", mysqlEP) wpru0 := addUnit(wordpress, "wp0", wordpressEP) wpru1 := addUnit(wordpress, "wp1", wordpressEP) // ---------- Single role active ---------- // Watch the relation from the perspective of the first provider unit and // check initial event. msw0 := msru0.Watch() defer testing.AssertStop(c, msw0) msw0c := testing.NewRelationUnitsWatcherC(c, s.State, msw0) msw0c.AssertChange(nil, nil) msw0c.AssertNoChange() // Join the unit to the relation, change its settings, and check that // nothing apparently happens. err = msru0.EnterScope(nil) c.Assert(err, gc.IsNil) changeSettings(c, msru0) msw0c.AssertNoChange() // Join the second provider unit, start its watch, and check what it thinks the // state of the relation is. err = msru1.EnterScope(nil) c.Assert(err, gc.IsNil) msw1 := msru1.Watch() defer testing.AssertStop(c, msw1) msw1c := testing.NewRelationUnitsWatcherC(c, s.State, msw1) msw1c.AssertChange(nil, nil) msw1c.AssertNoChange() // Change the unit's settings, and check that neither provider unit // observes any change. changeSettings(c, msru1) msw1c.AssertNoChange() msw0c.AssertNoChange() // ---------- Two roles active ---------- // Start watches from both requirer units' perspectives, and check that // they see the provider units. expectChanged := []string{"mysql/0", "mysql/1"} wpw0 := wpru0.Watch() defer testing.AssertStop(c, wpw0) wpw0c := testing.NewRelationUnitsWatcherC(c, s.State, wpw0) wpw0c.AssertChange(expectChanged, nil) wpw0c.AssertNoChange() wpw1 := wpru1.Watch() defer testing.AssertStop(c, wpw1) wpw1c := testing.NewRelationUnitsWatcherC(c, s.State, wpw1) wpw1c.AssertChange(expectChanged, nil) wpw1c.AssertNoChange() // Join the first requirer unit, and check the provider units see it. err = wpru0.EnterScope(nil) c.Assert(err, gc.IsNil) expectChanged = []string{"wordpress/0"} msw0c.AssertChange(expectChanged, nil) msw0c.AssertNoChange() msw1c.AssertChange(expectChanged, nil) msw1c.AssertNoChange() // Join again, check no-op. err = wpru0.EnterScope(nil) c.Assert(err, gc.IsNil) msw0c.AssertNoChange() msw1c.AssertNoChange() // Join the second requirer, and check the provider units see the change. err = wpru1.EnterScope(nil) c.Assert(err, gc.IsNil) expectChanged = []string{"wordpress/1"} msw0c.AssertChange(expectChanged, nil) msw0c.AssertNoChange() msw1c.AssertChange(expectChanged, nil) msw1c.AssertNoChange() // Verify that neither requirer has observed any change to the relation. wpw0c.AssertNoChange() wpw1c.AssertNoChange() // Change settings for the first requirer, check providers see it... changeSettings(c, wpru0) expectChanged = []string{"wordpress/0"} msw0c.AssertChange(expectChanged, nil) msw0c.AssertNoChange() msw1c.AssertChange(expectChanged, nil) msw1c.AssertNoChange() // ...and requirers don't. wpw0c.AssertNoChange() wpw1c.AssertNoChange() // Depart the second requirer and check the providers see it... err = wpru1.LeaveScope() c.Assert(err, gc.IsNil) expectDeparted := []string{"wordpress/1"} msw0c.AssertChange(nil, expectDeparted) msw0c.AssertNoChange() msw1c.AssertChange(nil, expectDeparted) msw1c.AssertNoChange() // ...and the requirers don't. wpw0c.AssertNoChange() wpw1c.AssertNoChange() // Cleanup handled by defers as before. }