func (s *InstancePollerSuite) TestWatchEnvironMachinesSuccess(c *gc.C) { // We're not testing the watcher logic here as it's already tested elsewhere. var numFacadeCalls int var numWatcherCalls int expectResult := params.StringsWatchResult{ StringsWatcherId: "42", Changes: []string{"foo", "bar"}, } watcherFunc := func(caller base.APICaller, result params.StringsWatchResult) watcher.StringsWatcher { numWatcherCalls++ c.Check(caller, gc.NotNil) c.Check(result, jc.DeepEquals, expectResult) return nil } s.PatchValue(instancepoller.NewStringsWatcher, watcherFunc) apiCaller := successAPICaller(c, "WatchEnvironMachines", nil, expectResult, &numFacadeCalls) api := instancepoller.NewAPI(apiCaller) w, err := api.WatchEnvironMachines() c.Assert(err, jc.ErrorIsNil) c.Assert(numFacadeCalls, gc.Equals, 1) c.Assert(numWatcherCalls, gc.Equals, 1) c.Assert(w, gc.IsNil) }
func (config ManifoldConfig) start(context dependency.Context) (worker.Worker, error) { var clock clock.Clock if err := context.Get(config.ClockName, &clock); err != nil { return nil, errors.Trace(err) } var environ environs.Environ if err := context.Get(config.EnvironName, &environ); err != nil { return nil, errors.Trace(err) } var apiCaller base.APICaller if err := context.Get(config.APICallerName, &apiCaller); err != nil { return nil, errors.Trace(err) } facade := instancepoller.NewAPI(apiCaller) w, err := NewWorker(Config{ Clock: clock, Delay: config.Delay, Facade: facade, Environ: environ, }) if err != nil { return nil, errors.Trace(err) } return w, nil }
// manifoldStart creates an instancepoller worker, given a base.APICaller. func manifoldStart(apiCaller base.APICaller) (worker.Worker, error) { api := instancepoller.NewAPI(apiCaller) w, err := NewWorker(api) if err != nil { return nil, errors.Trace(err) } return w, nil }
func (s *InstancePollerSuite) TestWatchEnvironMachinesClientError(c *gc.C) { var called int apiCaller := clientErrorAPICaller(c, "WatchEnvironMachines", nil, &called) api := instancepoller.NewAPI(apiCaller) w, err := api.WatchEnvironMachines() c.Assert(err, gc.ErrorMatches, "client error!") c.Assert(w, gc.IsNil) c.Assert(called, gc.Equals, 1) }
func (s *InstancePollerSuite) TestEnvironConfigClientError(c *gc.C) { var called int apiCaller := clientErrorAPICaller(c, "EnvironConfig", nil, &called) api := instancepoller.NewAPI(apiCaller) cfg, err := api.EnvironConfig() c.Assert(err, gc.ErrorMatches, "client error!") c.Assert(cfg, gc.IsNil) c.Assert(called, gc.Equals, 1) }
func (s *InstancePollerSuite) TestWatchForEnvironConfigChangesClientError(c *gc.C) { // We're not testing the success case as we're not patching the // NewNotifyWatcher call the embedded EnvironWatcher is calling. var called int apiCaller := clientErrorAPICaller(c, "WatchForEnvironConfigChanges", nil, &called) api := instancepoller.NewAPI(apiCaller) w, err := api.WatchForEnvironConfigChanges() c.Assert(err, gc.ErrorMatches, "client error!") c.Assert(called, gc.Equals, 1) c.Assert(w, gc.IsNil) }
func (s *InstancePollerSuite) TestWatchEnvironMachinesServerError(c *gc.C) { var called int expectedResults := params.StringsWatchResult{ Error: apiservertesting.ServerError("server boom!"), } apiCaller := successAPICaller(c, "WatchEnvironMachines", nil, expectedResults, &called) api := instancepoller.NewAPI(apiCaller) w, err := api.WatchEnvironMachines() c.Assert(err, gc.ErrorMatches, "server boom!") c.Assert(called, gc.Equals, 1) c.Assert(w, gc.IsNil) }
func (s *InstancePollerSuite) TestNewAPI(c *gc.C) { var called int apiCaller := clientErrorAPICaller(c, "Life", nil, &called) api := instancepoller.NewAPI(apiCaller) c.Check(api, gc.NotNil) c.Check(called, gc.Equals, 0) // Nothing happens until we actually call something else. m, err := api.Machine(names.MachineTag{}) c.Assert(err, gc.ErrorMatches, "client error!") c.Assert(m, gc.IsNil) c.Assert(called, gc.Equals, 1) }
func (s *InstancePollerSuite) TestEnvironConfigServerError(c *gc.C) { var called int expectResults := params.EnvironConfigResult{ Config: params.EnvironConfig{"type": "foo"}, } apiCaller := successAPICaller(c, "EnvironConfig", nil, expectResults, &called) api := instancepoller.NewAPI(apiCaller) cfg, err := api.EnvironConfig() c.Assert(err, gc.NotNil) // the actual error doesn't matter c.Assert(called, gc.Equals, 1) c.Assert(cfg, gc.IsNil) }
func (s *InstancePollerSuite) TestEnvironConfigSuccess(c *gc.C) { var called int expectedConfig := coretesting.EnvironConfig(c) expectedResults := params.EnvironConfigResult{ Config: params.EnvironConfig(expectedConfig.AllAttrs()), } apiCaller := successAPICaller(c, "EnvironConfig", nil, expectedResults, &called) api := instancepoller.NewAPI(apiCaller) cfg, err := api.EnvironConfig() c.Assert(err, jc.ErrorIsNil) c.Assert(called, gc.Equals, 1) c.Assert(cfg, jc.DeepEquals, expectedConfig) }
func (s *InstancePollerSuite) TestMachineCallsLife(c *gc.C) { // We have tested separately the Life method, here we just check // it's called internally. var called int expectedResults := params.LifeResults{ Results: []params.LifeResult{{Life: "working"}}, } apiCaller := successAPICaller(c, "Life", entitiesArgs, expectedResults, &called) api := instancepoller.NewAPI(apiCaller) m, err := api.Machine(names.NewMachineTag("42")) c.Assert(err, jc.ErrorIsNil) c.Assert(called, gc.Equals, 1) c.Assert(m.Life(), gc.Equals, params.Life("working")) c.Assert(m.Id(), gc.Equals, "42") }
// InstancePoller returns access to the InstancePoller API func (st *State) InstancePoller() *instancepoller.API { return instancepoller.NewAPI(st) }
func (s *InstancePollerSuite) TestNewAPIWithNilCaller(c *gc.C) { panicFunc := func() { instancepoller.NewAPI(nil) } c.Assert(panicFunc, gc.PanicMatches, "caller is nil") }