func (s *APISuite) TestRescaleCallError(c *gc.C) {
caller := apiCaller(c, func(_ string, _, _ interface{}) error {
return errors.New("snorble flip")
})
api := servicescaler.NewAPI(caller, nil)
err := api.Rescale(nil)
c.Check(err, gc.ErrorMatches, "snorble flip")
}
func (s *APISuite) TestRescaleNoError(c *gc.C) {
caller := apiCaller(c, func(_ string, _, _ interface{}) error {
return nil
})
api := servicescaler.NewAPI(caller, nil)
err := api.Rescale(nil)
c.Check(err, jc.ErrorIsNil)
}
func (s *APISuite) TestRescaleBadArgs(c *gc.C) {
caller := apiCaller(c, func(_ string, _, _ interface{}) error {
panic("should not be called")
})
api := servicescaler.NewAPI(caller, nil)
err := api.Rescale([]string{"good-name", "bad/name"})
c.Check(err, gc.ErrorMatches, `service name "bad/name" not valid`)
c.Check(err, jc.Satisfies, errors.IsNotValid)
}
func (s *APISuite) TestRescaleMethodName(c *gc.C) {
var called bool
caller := apiCaller(c, func(request string, _, _ interface{}) error {
called = true
c.Check(request, gc.Equals, "Rescale")
return nil
})
api := servicescaler.NewAPI(caller, nil)
api.Rescale(nil)
c.Check(called, jc.IsTrue)
}
func (s *APISuite) TestWatchMethodName(c *gc.C) {
var called bool
caller := apiCaller(c, func(request string, _, _ interface{}) error {
called = true
c.Check(request, gc.Equals, "Watch")
return errors.New("irrelevant")
})
api := servicescaler.NewAPI(caller, nil)
api.Watch()
c.Check(called, jc.IsTrue)
}
func (s *APISuite) TestWatchError(c *gc.C) {
var called bool
caller := apiCaller(c, func(request string, _, _ interface{}) error {
called = true
c.Check(request, gc.Equals, "Watch")
return errors.New("blam pow")
})
api := servicescaler.NewAPI(caller, nil)
watcher, err := api.Watch()
c.Check(watcher, gc.IsNil)
c.Check(err, gc.ErrorMatches, "blam pow")
c.Check(called, jc.IsTrue)
}
func (s *APISuite) TestRescaleConvertArgs(c *gc.C) {
var called bool
caller := apiCaller(c, func(_ string, arg, _ interface{}) error {
called = true
c.Check(arg, gc.DeepEquals, params.Entities{
Entities: []params.Entity{{
"service-foo",
}, {
"service-bar-baz",
}},
})
return nil
})
api := servicescaler.NewAPI(caller, nil)
api.Rescale([]string{"foo", "bar-baz"})
c.Check(called, jc.IsTrue)
}
func (s *APISuite) TestRescaleFirstError(c *gc.C) {
caller := apiCaller(c, func(_ string, _, result interface{}) error {
resultPtr, ok := result.(*params.ErrorResults)
c.Assert(ok, jc.IsTrue)
*resultPtr = params.ErrorResults{Results: []params.ErrorResult{{
nil,
}, {
¶ms.Error{Message: "expect this error"},
}, {
¶ms.Error{Message: "not this one"},
}, {
nil,
}}}
return nil
})
api := servicescaler.NewAPI(caller, nil)
err := api.Rescale(nil)
c.Check(err, gc.ErrorMatches, "expect this error")
}
func (s *APISuite) TestWatchSuccess(c *gc.C) {
expectResult := params.StringsWatchResult{
StringsWatcherId: "123",
Changes: []string{"ping", "pong", "pung"},
}
caller := apiCaller(c, func(_ string, _, result interface{}) error {
resultPtr, ok := result.(*params.StringsWatchResult)
c.Assert(ok, jc.IsTrue)
*resultPtr = expectResult
return nil
})
expectWatcher := &stubWatcher{}
newWatcher := func(gotCaller base.APICaller, gotResult params.StringsWatchResult) watcher.StringsWatcher {
c.Check(gotCaller, gc.NotNil) // uncomparable
c.Check(gotResult, jc.DeepEquals, expectResult)
return expectWatcher
}
api := servicescaler.NewAPI(caller, newWatcher)
watcher, err := api.Watch()
c.Check(watcher, gc.Equals, expectWatcher)
c.Check(err, jc.ErrorIsNil)
}
// NewFacade creates a Facade from a base.APICaller.
// It's a sensible value for ManifoldConfig.NewFacade.
func NewFacade(apiCaller base.APICaller) (Facade, error) {
return servicescaler.NewAPI(
apiCaller,
watcher.NewStringsWatcher,
), nil
}
