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

     1  // Copyright 2015 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package block_test
     5  
     6  import (
     7  	"github.com/juju/errors"
     8  	jc "github.com/juju/testing/checkers"
     9  	gc "gopkg.in/check.v1"
    10  
    11  	basetesting "github.com/juju/juju/api/base/testing"
    12  	"github.com/juju/juju/api/block"
    13  	"github.com/juju/juju/apiserver/common"
    14  	"github.com/juju/juju/apiserver/params"
    15  	"github.com/juju/juju/state"
    16  	coretesting "github.com/juju/juju/testing"
    17  )
    18  
    19  type blockMockSuite struct {
    20  	coretesting.BaseSuite
    21  	blockClient *block.Client
    22  }
    23  
    24  var _ = gc.Suite(&blockMockSuite{})
    25  
    26  func (s *blockMockSuite) TestSwitchBlockOn(c *gc.C) {
    27  	called := false
    28  	blockType := state.DestroyBlock.String()
    29  	msg := "for test switch block on"
    30  
    31  	apiCaller := basetesting.APICallerFunc(
    32  		func(objType string,
    33  			version int,
    34  			id, request string,
    35  			a, response interface{},
    36  		) error {
    37  			called = true
    38  			c.Check(objType, gc.Equals, "Block")
    39  			c.Check(id, gc.Equals, "")
    40  			c.Check(request, gc.Equals, "SwitchBlockOn")
    41  
    42  			args, ok := a.(params.BlockSwitchParams)
    43  			c.Assert(ok, jc.IsTrue)
    44  			c.Assert(args.Message, gc.DeepEquals, msg)
    45  			c.Assert(args.Type, gc.DeepEquals, blockType)
    46  
    47  			_, ok = response.(*params.ErrorResult)
    48  			c.Assert(ok, jc.IsTrue)
    49  
    50  			return nil
    51  		})
    52  	blockClient := block.NewClient(apiCaller)
    53  	err := blockClient.SwitchBlockOn(blockType, msg)
    54  	c.Assert(called, jc.IsTrue)
    55  	c.Assert(err, gc.IsNil)
    56  }
    57  
    58  func (s *blockMockSuite) TestSwitchBlockOnError(c *gc.C) {
    59  	called := false
    60  	errmsg := "test error"
    61  	apiCaller := basetesting.APICallerFunc(
    62  		func(objType string,
    63  			version int,
    64  			id, request string,
    65  			a, response interface{},
    66  		) error {
    67  			called = true
    68  			result, ok := response.(*params.ErrorResult)
    69  			c.Assert(ok, jc.IsTrue)
    70  			result.Error = common.ServerError(errors.New(errmsg))
    71  
    72  			return nil
    73  		})
    74  	blockClient := block.NewClient(apiCaller)
    75  	err := blockClient.SwitchBlockOn("", "")
    76  	c.Assert(called, jc.IsTrue)
    77  	c.Assert(errors.Cause(err), gc.ErrorMatches, errmsg)
    78  }
    79  
    80  func (s *blockMockSuite) TestSwitchBlockOff(c *gc.C) {
    81  	called := false
    82  	blockType := state.DestroyBlock.String()
    83  
    84  	apiCaller := basetesting.APICallerFunc(
    85  		func(objType string,
    86  			version int,
    87  			id, request string,
    88  			a, response interface{},
    89  		) error {
    90  			called = true
    91  			c.Check(objType, gc.Equals, "Block")
    92  			c.Check(id, gc.Equals, "")
    93  			c.Check(request, gc.Equals, "SwitchBlockOff")
    94  
    95  			args, ok := a.(params.BlockSwitchParams)
    96  			c.Assert(ok, jc.IsTrue)
    97  			// message is never sent, so this argument should
    98  			// always be empty string.
    99  			c.Assert(args.Message, gc.DeepEquals, "")
   100  			c.Assert(args.Type, gc.DeepEquals, blockType)
   101  
   102  			_, ok = response.(*params.ErrorResult)
   103  			c.Assert(ok, jc.IsTrue)
   104  
   105  			return nil
   106  		})
   107  	blockClient := block.NewClient(apiCaller)
   108  	err := blockClient.SwitchBlockOff(blockType)
   109  	c.Assert(called, jc.IsTrue)
   110  	c.Assert(err, gc.IsNil)
   111  }
   112  
   113  func (s *blockMockSuite) TestSwitchBlockOffError(c *gc.C) {
   114  	called := false
   115  	errmsg := "test error"
   116  	apiCaller := basetesting.APICallerFunc(
   117  		func(objType string,
   118  			version int,
   119  			id, request string,
   120  			a, response interface{},
   121  		) error {
   122  			called = true
   123  			result, ok := response.(*params.ErrorResult)
   124  			c.Assert(ok, jc.IsTrue)
   125  			result.Error = common.ServerError(errors.New(errmsg))
   126  
   127  			return nil
   128  		})
   129  	blockClient := block.NewClient(apiCaller)
   130  	err := blockClient.SwitchBlockOff("")
   131  	c.Assert(called, jc.IsTrue)
   132  	c.Assert(errors.Cause(err), gc.ErrorMatches, errmsg)
   133  }
   134  
   135  func (s *blockMockSuite) TestList(c *gc.C) {
   136  	var called bool
   137  	one := params.BlockResult{
   138  		Result: params.Block{
   139  			Id:      "-42",
   140  			Type:    state.DestroyBlock.String(),
   141  			Message: "for test switch on",
   142  			Tag:     "some valid tag, right?",
   143  		},
   144  	}
   145  	errmsg := "another test error"
   146  	two := params.BlockResult{
   147  		Error: common.ServerError(errors.New(errmsg)),
   148  	}
   149  	apiCaller := basetesting.APICallerFunc(
   150  		func(
   151  			objType string,
   152  			version int,
   153  			id, request string,
   154  			a, response interface{}) error {
   155  			called = true
   156  			c.Check(objType, gc.Equals, "Block")
   157  			c.Check(id, gc.Equals, "")
   158  			c.Check(request, gc.Equals, "List")
   159  			c.Assert(a, gc.IsNil)
   160  
   161  			result := response.(*params.BlockResults)
   162  			result.Results = []params.BlockResult{one, two}
   163  			return nil
   164  		})
   165  	blockClient := block.NewClient(apiCaller)
   166  	found, err := blockClient.List()
   167  	c.Assert(called, jc.IsTrue)
   168  	c.Assert(errors.Cause(err), gc.ErrorMatches, errmsg)
   169  	c.Assert(found, gc.HasLen, 1)
   170  }