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