github.com/niedbalski/juju@v0.0.0-20190215020005-8ff100488e47/api/singular/api_test.go (about)

     1  // Copyright 2015 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package singular_test
     5  
     6  import (
     7  	"time"
     8  
     9  	"github.com/juju/errors"
    10  	"github.com/juju/testing"
    11  	jc "github.com/juju/testing/checkers"
    12  	gc "gopkg.in/check.v1"
    13  	"gopkg.in/juju/names.v2"
    14  
    15  	"github.com/juju/juju/api/base"
    16  	basetesting "github.com/juju/juju/api/base/testing"
    17  	"github.com/juju/juju/api/singular"
    18  	"github.com/juju/juju/apiserver/common"
    19  	"github.com/juju/juju/apiserver/params"
    20  	"github.com/juju/juju/core/lease"
    21  	coretesting "github.com/juju/juju/testing"
    22  )
    23  
    24  type APISuite struct {
    25  	testing.IsolationSuite
    26  }
    27  
    28  var _ = gc.Suite(&APISuite{})
    29  
    30  var machine123 = names.NewMachineTag("123")
    31  
    32  func (s *APISuite) TestBadClaimantTag(c *gc.C) {
    33  	apiCaller := apiCaller(c, nil, nil)
    34  	badTag := names.NewMachineTag("")
    35  	api, err := singular.NewAPI(apiCaller, badTag, nil)
    36  	c.Check(api, gc.IsNil)
    37  	c.Check(err, jc.Satisfies, errors.IsNotValid)
    38  	c.Check(err, gc.ErrorMatches, "claimant tag not valid")
    39  }
    40  
    41  func (s *APISuite) TestBadEntityTag(c *gc.C) {
    42  	apiCaller := apiCaller(c, nil, nil)
    43  
    44  	api, err := singular.NewAPI(apiCaller, machine123, nil)
    45  	c.Check(api, gc.IsNil)
    46  	c.Check(err, gc.ErrorMatches, "nil entity supplied")
    47  
    48  	api, err = singular.NewAPI(apiCaller, machine123, machine123)
    49  	c.Check(api, gc.IsNil)
    50  	c.Check(err, gc.ErrorMatches, `invalid entity kind "machine" for singular API`)
    51  }
    52  
    53  func (s *APISuite) TestNoCalls(c *gc.C) {
    54  	stub := &testing.Stub{}
    55  	apiCaller := apiCaller(c, nil, nil)
    56  	_, err := singular.NewAPI(apiCaller, machine123, coretesting.ControllerTag)
    57  	c.Check(err, jc.ErrorIsNil)
    58  	stub.CheckCallNames(c)
    59  }
    60  
    61  func (s *APISuite) TestClaimSuccess(c *gc.C) {
    62  	stub := &testing.Stub{}
    63  	apiCaller := apiCaller(c, stub, func(result *params.ErrorResults) error {
    64  		result.Results = []params.ErrorResult{{}}
    65  		return nil
    66  	})
    67  	api, err := singular.NewAPI(apiCaller, machine123, coretesting.ModelTag)
    68  	c.Assert(err, jc.ErrorIsNil)
    69  
    70  	err = api.Claim(time.Minute)
    71  	c.Check(err, jc.ErrorIsNil)
    72  	checkCall(c, stub, "Claim", params.SingularClaims{
    73  		Claims: []params.SingularClaim{{
    74  			EntityTag:   "model-deadbeef-0bad-400d-8000-4b1d0d06f00d",
    75  			ClaimantTag: "machine-123",
    76  			Duration:    time.Minute,
    77  		}},
    78  	})
    79  }
    80  
    81  func (s *APISuite) TestClaimDenied(c *gc.C) {
    82  	stub := &testing.Stub{}
    83  	apiCaller := apiCaller(c, stub, func(result *params.ErrorResults) error {
    84  		result.Results = []params.ErrorResult{{
    85  			Error: common.ServerError(lease.ErrClaimDenied),
    86  		}}
    87  		return nil
    88  	})
    89  	api, err := singular.NewAPI(apiCaller, machine123, coretesting.ModelTag)
    90  	c.Assert(err, jc.ErrorIsNil)
    91  
    92  	err = api.Claim(time.Hour)
    93  	c.Check(err, gc.Equals, lease.ErrClaimDenied)
    94  	checkCall(c, stub, "Claim", params.SingularClaims{
    95  		Claims: []params.SingularClaim{{
    96  			EntityTag:   "model-deadbeef-0bad-400d-8000-4b1d0d06f00d",
    97  			ClaimantTag: "machine-123",
    98  			Duration:    time.Hour,
    99  		}},
   100  	})
   101  }
   102  
   103  func (s *APISuite) TestClaimError(c *gc.C) {
   104  	stub := &testing.Stub{}
   105  	apiCaller := apiCaller(c, stub, func(result *params.ErrorResults) error {
   106  		result.Results = []params.ErrorResult{{
   107  			Error: common.ServerError(errors.New("zap pow splat oof")),
   108  		}}
   109  		return nil
   110  	})
   111  	api, err := singular.NewAPI(apiCaller, machine123, coretesting.ModelTag)
   112  	c.Assert(err, jc.ErrorIsNil)
   113  
   114  	err = api.Claim(time.Second)
   115  	c.Check(err, gc.ErrorMatches, "zap pow splat oof")
   116  	checkCall(c, stub, "Claim", params.SingularClaims{
   117  		Claims: []params.SingularClaim{{
   118  			EntityTag:   "model-deadbeef-0bad-400d-8000-4b1d0d06f00d",
   119  			ClaimantTag: "machine-123",
   120  			Duration:    time.Second,
   121  		}},
   122  	})
   123  }
   124  
   125  func (s *APISuite) TestWaitSuccess(c *gc.C) {
   126  	stub := &testing.Stub{}
   127  	apiCaller := apiCaller(c, stub, func(result *params.ErrorResults) error {
   128  		result.Results = []params.ErrorResult{{}}
   129  		return nil
   130  	})
   131  	api, err := singular.NewAPI(apiCaller, machine123, coretesting.ModelTag)
   132  	c.Assert(err, jc.ErrorIsNil)
   133  
   134  	err = api.Wait()
   135  	c.Check(err, jc.ErrorIsNil)
   136  	checkCall(c, stub, "Wait", params.Entities{
   137  		Entities: []params.Entity{{
   138  			Tag: "model-deadbeef-0bad-400d-8000-4b1d0d06f00d",
   139  		}},
   140  	})
   141  }
   142  
   143  func (s *APISuite) TestWaitError(c *gc.C) {
   144  	stub := &testing.Stub{}
   145  	apiCaller := apiCaller(c, stub, func(result *params.ErrorResults) error {
   146  		result.Results = []params.ErrorResult{{
   147  			Error: common.ServerError(errors.New("crunch squelch")),
   148  		}}
   149  		return nil
   150  	})
   151  	api, err := singular.NewAPI(apiCaller, machine123, coretesting.ModelTag)
   152  	c.Assert(err, jc.ErrorIsNil)
   153  
   154  	err = api.Wait()
   155  	c.Check(err, gc.ErrorMatches, "crunch squelch")
   156  	checkCall(c, stub, "Wait", params.Entities{
   157  		Entities: []params.Entity{{
   158  			Tag: "model-deadbeef-0bad-400d-8000-4b1d0d06f00d",
   159  		}},
   160  	})
   161  }
   162  
   163  type setResultFunc func(result *params.ErrorResults) error
   164  
   165  func apiCaller(c *gc.C, stub *testing.Stub, setResult setResultFunc) base.APICaller {
   166  	return basetesting.APICallerFunc(
   167  		func(objType string,
   168  			version int,
   169  			id, request string,
   170  			args, response interface{},
   171  		) error {
   172  			stub.AddCall(objType, version, id, request, args)
   173  			result, ok := response.(*params.ErrorResults)
   174  			c.Assert(ok, jc.IsTrue)
   175  			return setResult(result)
   176  		},
   177  	)
   178  }
   179  
   180  func checkCall(c *gc.C, stub *testing.Stub, method string, args interface{}) {
   181  	stub.CheckCalls(c, []testing.StubCall{{
   182  		FuncName: "Singular",
   183  		Args:     []interface{}{0, "", method, args},
   184  	}})
   185  }