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

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