github.com/axw/juju@v0.0.0-20161005053422-4bd6544d08d4/api/meterstatus/client_test.go (about)

     1  // Copyright 2015 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package meterstatus_test
     5  
     6  import (
     7  	"fmt"
     8  
     9  	jc "github.com/juju/testing/checkers"
    10  	gc "gopkg.in/check.v1"
    11  	"gopkg.in/juju/names.v2"
    12  
    13  	"github.com/juju/juju/api/base/testing"
    14  	"github.com/juju/juju/api/meterstatus"
    15  	"github.com/juju/juju/apiserver/params"
    16  	coretesting "github.com/juju/juju/testing"
    17  )
    18  
    19  type meterStatusSuite struct {
    20  	coretesting.BaseSuite
    21  }
    22  
    23  var _ = gc.Suite(&meterStatusSuite{})
    24  
    25  func (s *meterStatusSuite) SetUpTest(c *gc.C) {
    26  	s.BaseSuite.SetUpTest(c)
    27  }
    28  
    29  func (s *meterStatusSuite) TestGetMeterStatus(c *gc.C) {
    30  	tag := names.NewUnitTag("wp/1")
    31  	var called bool
    32  	apiCaller := testing.APICallerFunc(func(objType string, version int, id, request string, arg, response interface{}) error {
    33  		c.Check(objType, gc.Equals, "MeterStatus")
    34  		c.Check(version, gc.Equals, 0)
    35  		c.Check(id, gc.Equals, "")
    36  		c.Check(request, gc.Equals, "GetMeterStatus")
    37  		c.Check(arg, gc.DeepEquals, params.Entities{
    38  			Entities: []params.Entity{{Tag: tag.String()}},
    39  		})
    40  		c.Assert(response, gc.FitsTypeOf, &params.MeterStatusResults{})
    41  		result := response.(*params.MeterStatusResults)
    42  		result.Results = []params.MeterStatusResult{{
    43  			Code: "GREEN",
    44  			Info: "All ok.",
    45  		}}
    46  		called = true
    47  		return nil
    48  	})
    49  	status := meterstatus.NewClient(apiCaller, tag)
    50  	c.Assert(status, gc.NotNil)
    51  
    52  	statusCode, statusInfo, err := status.MeterStatus()
    53  	c.Assert(called, jc.IsTrue)
    54  	c.Assert(err, jc.ErrorIsNil)
    55  	c.Assert(statusCode, gc.Equals, "GREEN")
    56  	c.Assert(statusInfo, gc.Equals, "All ok.")
    57  }
    58  
    59  func (s *meterStatusSuite) TestGetMeterStatusResultError(c *gc.C) {
    60  	tag := names.NewUnitTag("wp/1")
    61  	var called bool
    62  	apiCaller := testing.APICallerFunc(func(objType string, version int, id, request string, arg, response interface{}) error {
    63  		c.Check(objType, gc.Equals, "MeterStatus")
    64  		c.Check(version, gc.Equals, 0)
    65  		c.Check(id, gc.Equals, "")
    66  		c.Check(request, gc.Equals, "GetMeterStatus")
    67  		c.Check(arg, gc.DeepEquals, params.Entities{
    68  			Entities: []params.Entity{{Tag: tag.String()}},
    69  		})
    70  		c.Assert(response, gc.FitsTypeOf, &params.MeterStatusResults{})
    71  		result := response.(*params.MeterStatusResults)
    72  		result.Results = []params.MeterStatusResult{{
    73  			Error: &params.Error{
    74  				Message: "An error in the meter status.",
    75  				Code:    params.CodeNotAssigned,
    76  			},
    77  		}}
    78  		called = true
    79  		return nil
    80  	})
    81  	status := meterstatus.NewClient(apiCaller, tag)
    82  	c.Assert(status, gc.NotNil)
    83  
    84  	statusCode, statusInfo, err := status.MeterStatus()
    85  	c.Assert(called, jc.IsTrue)
    86  	c.Assert(err, gc.ErrorMatches, "An error in the meter status.")
    87  	c.Assert(statusCode, gc.Equals, "")
    88  	c.Assert(statusInfo, gc.Equals, "")
    89  }
    90  
    91  func (s *meterStatusSuite) TestGetMeterStatusReturnsError(c *gc.C) {
    92  	tag := names.NewUnitTag("wp/1")
    93  	var called bool
    94  	apiCaller := testing.APICallerFunc(func(objType string, version int, id, request string, arg, response interface{}) error {
    95  		c.Check(objType, gc.Equals, "MeterStatus")
    96  		c.Check(version, gc.Equals, 0)
    97  		c.Check(id, gc.Equals, "")
    98  		c.Check(request, gc.Equals, "GetMeterStatus")
    99  		c.Check(arg, gc.DeepEquals, params.Entities{
   100  			Entities: []params.Entity{{Tag: tag.String()}},
   101  		})
   102  		c.Assert(response, gc.FitsTypeOf, &params.MeterStatusResults{})
   103  		called = true
   104  		return fmt.Errorf("could not retrieve meter status")
   105  	})
   106  	status := meterstatus.NewClient(apiCaller, tag)
   107  	c.Assert(status, gc.NotNil)
   108  
   109  	statusCode, statusInfo, err := status.MeterStatus()
   110  	c.Assert(called, jc.IsTrue)
   111  	c.Assert(err, gc.ErrorMatches, "could not retrieve meter status")
   112  	c.Assert(statusCode, gc.Equals, "")
   113  	c.Assert(statusInfo, gc.Equals, "")
   114  }
   115  
   116  func (s *meterStatusSuite) TestGetMeterStatusMoreResults(c *gc.C) {
   117  	tag := names.NewUnitTag("wp/1")
   118  	var called bool
   119  	apiCaller := testing.APICallerFunc(func(objType string, version int, id, request string, arg, response interface{}) error {
   120  		c.Check(objType, gc.Equals, "MeterStatus")
   121  		c.Check(version, gc.Equals, 0)
   122  		c.Check(id, gc.Equals, "")
   123  		c.Check(request, gc.Equals, "GetMeterStatus")
   124  		c.Check(arg, gc.DeepEquals, params.Entities{
   125  			Entities: []params.Entity{{Tag: tag.String()}},
   126  		})
   127  		c.Assert(response, gc.FitsTypeOf, &params.MeterStatusResults{})
   128  		result := response.(*params.MeterStatusResults)
   129  		result.Results = make([]params.MeterStatusResult, 2)
   130  		called = true
   131  		return nil
   132  	})
   133  	status := meterstatus.NewClient(apiCaller, tag)
   134  	c.Assert(status, gc.NotNil)
   135  	statusCode, statusInfo, err := status.MeterStatus()
   136  	c.Assert(called, jc.IsTrue)
   137  	c.Assert(err, gc.ErrorMatches, "expected 1 result, got 2")
   138  	c.Assert(statusCode, gc.Equals, "")
   139  	c.Assert(statusInfo, gc.Equals, "")
   140  }
   141  
   142  func (s *meterStatusSuite) TestWatchMeterStatusError(c *gc.C) {
   143  	tag := names.NewUnitTag("wp/1")
   144  	var called bool
   145  	apiCaller := testing.APICallerFunc(func(objType string, version int, id, request string, arg, response interface{}) error {
   146  		c.Check(objType, gc.Equals, "MeterStatus")
   147  		c.Check(version, gc.Equals, 0)
   148  		c.Check(id, gc.Equals, "")
   149  		c.Check(request, gc.Equals, "WatchMeterStatus")
   150  		c.Check(arg, gc.DeepEquals, params.Entities{
   151  			Entities: []params.Entity{{Tag: tag.String()}},
   152  		})
   153  		c.Assert(response, gc.FitsTypeOf, &params.NotifyWatchResults{})
   154  		result := response.(*params.NotifyWatchResults)
   155  		result.Results = make([]params.NotifyWatchResult, 1)
   156  		called = true
   157  		return fmt.Errorf("could not retrieve meter status watcher")
   158  	})
   159  	status := meterstatus.NewClient(apiCaller, tag)
   160  	c.Assert(status, gc.NotNil)
   161  	w, err := status.WatchMeterStatus()
   162  	c.Assert(called, jc.IsTrue)
   163  	c.Assert(err, gc.ErrorMatches, "could not retrieve meter status watcher")
   164  	c.Assert(w, gc.IsNil)
   165  }
   166  
   167  func (s *meterStatusSuite) TestWatchMeterStatusMoreResults(c *gc.C) {
   168  	tag := names.NewUnitTag("wp/1")
   169  	var called bool
   170  	apiCaller := testing.APICallerFunc(func(objType string, version int, id, request string, arg, response interface{}) error {
   171  		c.Check(objType, gc.Equals, "MeterStatus")
   172  		c.Check(version, gc.Equals, 0)
   173  		c.Check(id, gc.Equals, "")
   174  		c.Check(request, gc.Equals, "WatchMeterStatus")
   175  		c.Check(arg, gc.DeepEquals, params.Entities{
   176  			Entities: []params.Entity{{Tag: tag.String()}},
   177  		})
   178  		c.Assert(response, gc.FitsTypeOf, &params.NotifyWatchResults{})
   179  		result := response.(*params.NotifyWatchResults)
   180  		result.Results = make([]params.NotifyWatchResult, 2)
   181  		called = true
   182  		return nil
   183  	})
   184  	status := meterstatus.NewClient(apiCaller, tag)
   185  	c.Assert(status, gc.NotNil)
   186  	w, err := status.WatchMeterStatus()
   187  	c.Assert(called, jc.IsTrue)
   188  	c.Assert(err, gc.ErrorMatches, "expected 1 result, got 2")
   189  	c.Assert(w, gc.IsNil)
   190  }
   191  
   192  func (s *meterStatusSuite) TestWatchMeterStatusResultError(c *gc.C) {
   193  	tag := names.NewUnitTag("wp/1")
   194  	var called bool
   195  	apiCaller := testing.APICallerFunc(func(objType string, version int, id, request string, arg, response interface{}) error {
   196  		c.Check(objType, gc.Equals, "MeterStatus")
   197  		c.Check(version, gc.Equals, 0)
   198  		c.Check(id, gc.Equals, "")
   199  		c.Check(request, gc.Equals, "WatchMeterStatus")
   200  		c.Check(arg, gc.DeepEquals, params.Entities{
   201  			Entities: []params.Entity{{Tag: tag.String()}},
   202  		})
   203  		c.Assert(response, gc.FitsTypeOf, &params.NotifyWatchResults{})
   204  		result := response.(*params.NotifyWatchResults)
   205  		result.Results = []params.NotifyWatchResult{{
   206  			Error: &params.Error{
   207  				Message: "error",
   208  				Code:    params.CodeNotAssigned,
   209  			},
   210  		}}
   211  
   212  		called = true
   213  		return nil
   214  	})
   215  	status := meterstatus.NewClient(apiCaller, tag)
   216  	c.Assert(status, gc.NotNil)
   217  	w, err := status.WatchMeterStatus()
   218  	c.Assert(called, jc.IsTrue)
   219  	c.Assert(err, gc.ErrorMatches, "error")
   220  	c.Assert(w, gc.IsNil)
   221  }