github.com/makyo/juju@v0.0.0-20160425123129-2608902037e9/api/servicescaler/api_test.go (about)

     1  // Copyright 2016 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package servicescaler_test
     5  
     6  import (
     7  	"github.com/juju/errors"
     8  	"github.com/juju/testing"
     9  	jc "github.com/juju/testing/checkers"
    10  	gc "gopkg.in/check.v1"
    11  
    12  	"github.com/juju/juju/api/base"
    13  	apitesting "github.com/juju/juju/api/base/testing"
    14  	"github.com/juju/juju/api/servicescaler"
    15  	"github.com/juju/juju/apiserver/params"
    16  	"github.com/juju/juju/watcher"
    17  )
    18  
    19  type APISuite struct {
    20  	testing.IsolationSuite
    21  }
    22  
    23  var _ = gc.Suite(&APISuite{})
    24  
    25  func (s *APISuite) TestRescaleMethodName(c *gc.C) {
    26  	var called bool
    27  	caller := apiCaller(c, func(request string, _, _ interface{}) error {
    28  		called = true
    29  		c.Check(request, gc.Equals, "Rescale")
    30  		return nil
    31  	})
    32  	api := servicescaler.NewAPI(caller, nil)
    33  
    34  	api.Rescale(nil)
    35  	c.Check(called, jc.IsTrue)
    36  }
    37  
    38  func (s *APISuite) TestRescaleBadArgs(c *gc.C) {
    39  	caller := apiCaller(c, func(_ string, _, _ interface{}) error {
    40  		panic("should not be called")
    41  	})
    42  	api := servicescaler.NewAPI(caller, nil)
    43  
    44  	err := api.Rescale([]string{"good-name", "bad/name"})
    45  	c.Check(err, gc.ErrorMatches, `service name "bad/name" not valid`)
    46  	c.Check(err, jc.Satisfies, errors.IsNotValid)
    47  }
    48  
    49  func (s *APISuite) TestRescaleConvertArgs(c *gc.C) {
    50  	var called bool
    51  	caller := apiCaller(c, func(_ string, arg, _ interface{}) error {
    52  		called = true
    53  		c.Check(arg, gc.DeepEquals, params.Entities{
    54  			Entities: []params.Entity{{
    55  				"service-foo",
    56  			}, {
    57  				"service-bar-baz",
    58  			}},
    59  		})
    60  		return nil
    61  	})
    62  	api := servicescaler.NewAPI(caller, nil)
    63  
    64  	api.Rescale([]string{"foo", "bar-baz"})
    65  	c.Check(called, jc.IsTrue)
    66  }
    67  
    68  func (s *APISuite) TestRescaleCallError(c *gc.C) {
    69  	caller := apiCaller(c, func(_ string, _, _ interface{}) error {
    70  		return errors.New("snorble flip")
    71  	})
    72  	api := servicescaler.NewAPI(caller, nil)
    73  
    74  	err := api.Rescale(nil)
    75  	c.Check(err, gc.ErrorMatches, "snorble flip")
    76  }
    77  
    78  func (s *APISuite) TestRescaleFirstError(c *gc.C) {
    79  	caller := apiCaller(c, func(_ string, _, result interface{}) error {
    80  		resultPtr, ok := result.(*params.ErrorResults)
    81  		c.Assert(ok, jc.IsTrue)
    82  		*resultPtr = params.ErrorResults{Results: []params.ErrorResult{{
    83  			nil,
    84  		}, {
    85  			&params.Error{Message: "expect this error"},
    86  		}, {
    87  			&params.Error{Message: "not this one"},
    88  		}, {
    89  			nil,
    90  		}}}
    91  		return nil
    92  	})
    93  	api := servicescaler.NewAPI(caller, nil)
    94  
    95  	err := api.Rescale(nil)
    96  	c.Check(err, gc.ErrorMatches, "expect this error")
    97  }
    98  
    99  func (s *APISuite) TestRescaleNoError(c *gc.C) {
   100  	caller := apiCaller(c, func(_ string, _, _ interface{}) error {
   101  		return nil
   102  	})
   103  	api := servicescaler.NewAPI(caller, nil)
   104  
   105  	err := api.Rescale(nil)
   106  	c.Check(err, jc.ErrorIsNil)
   107  }
   108  
   109  func (s *APISuite) TestWatchMethodName(c *gc.C) {
   110  	var called bool
   111  	caller := apiCaller(c, func(request string, _, _ interface{}) error {
   112  		called = true
   113  		c.Check(request, gc.Equals, "Watch")
   114  		return errors.New("irrelevant")
   115  	})
   116  	api := servicescaler.NewAPI(caller, nil)
   117  
   118  	api.Watch()
   119  	c.Check(called, jc.IsTrue)
   120  }
   121  
   122  func (s *APISuite) TestWatchError(c *gc.C) {
   123  	var called bool
   124  	caller := apiCaller(c, func(request string, _, _ interface{}) error {
   125  		called = true
   126  		c.Check(request, gc.Equals, "Watch")
   127  		return errors.New("blam pow")
   128  	})
   129  	api := servicescaler.NewAPI(caller, nil)
   130  
   131  	watcher, err := api.Watch()
   132  	c.Check(watcher, gc.IsNil)
   133  	c.Check(err, gc.ErrorMatches, "blam pow")
   134  	c.Check(called, jc.IsTrue)
   135  }
   136  
   137  func (s *APISuite) TestWatchSuccess(c *gc.C) {
   138  	expectResult := params.StringsWatchResult{
   139  		StringsWatcherId: "123",
   140  		Changes:          []string{"ping", "pong", "pung"},
   141  	}
   142  	caller := apiCaller(c, func(_ string, _, result interface{}) error {
   143  		resultPtr, ok := result.(*params.StringsWatchResult)
   144  		c.Assert(ok, jc.IsTrue)
   145  		*resultPtr = expectResult
   146  		return nil
   147  	})
   148  	expectWatcher := &stubWatcher{}
   149  	newWatcher := func(gotCaller base.APICaller, gotResult params.StringsWatchResult) watcher.StringsWatcher {
   150  		c.Check(gotCaller, gc.NotNil) // uncomparable
   151  		c.Check(gotResult, jc.DeepEquals, expectResult)
   152  		return expectWatcher
   153  	}
   154  	api := servicescaler.NewAPI(caller, newWatcher)
   155  
   156  	watcher, err := api.Watch()
   157  	c.Check(watcher, gc.Equals, expectWatcher)
   158  	c.Check(err, jc.ErrorIsNil)
   159  }
   160  
   161  func apiCaller(c *gc.C, check func(request string, arg, result interface{}) error) base.APICaller {
   162  	return apitesting.APICallerFunc(func(facade string, version int, id, request string, arg, result interface{}) error {
   163  		c.Check(facade, gc.Equals, "ServiceScaler")
   164  		c.Check(version, gc.Equals, 0)
   165  		c.Check(id, gc.Equals, "")
   166  		return check(request, arg, result)
   167  	})
   168  }
   169  
   170  type stubWatcher struct {
   171  	watcher.StringsWatcher
   172  }