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

     1  // Copyright 2015 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package discoverspaces_test
     5  
     6  import (
     7  	"errors"
     8  
     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/discoverspaces"
    15  	"github.com/juju/juju/apiserver/params"
    16  	"github.com/juju/juju/environs/config"
    17  	coretesting "github.com/juju/juju/testing"
    18  )
    19  
    20  type DiscoverSpacesSuite struct {
    21  	coretesting.BaseSuite
    22  }
    23  
    24  var _ = gc.Suite(&DiscoverSpacesSuite{})
    25  
    26  func (s *DiscoverSpacesSuite) TestNewAPI(c *gc.C) {
    27  	var called int
    28  	apiCaller := clientErrorAPICaller(c, "ListSpaces", nil, &called)
    29  	api := discoverspaces.NewAPI(apiCaller)
    30  	c.Check(api, gc.NotNil)
    31  	c.Check(called, gc.Equals, 0)
    32  
    33  	// Make a call so that an error will be returned.
    34  	_, err := api.ListSpaces()
    35  	c.Assert(err, gc.ErrorMatches, "client error!")
    36  	c.Assert(called, gc.Equals, 1)
    37  }
    38  
    39  func clientErrorAPICaller(c *gc.C, method string, expectArgs interface{}, numCalls *int) base.APICaller {
    40  	args := &apitesting.CheckArgs{
    41  		Facade:        "DiscoverSpaces",
    42  		VersionIsZero: true,
    43  		IdIsEmpty:     true,
    44  		Method:        method,
    45  		Args:          expectArgs,
    46  	}
    47  	return apitesting.CheckingAPICaller(c, args, numCalls, errors.New("client error!"))
    48  }
    49  
    50  func successAPICaller(c *gc.C, method string, expectArgs, useResults interface{}, numCalls *int) base.APICaller {
    51  	args := &apitesting.CheckArgs{
    52  		Facade:        "DiscoverSpaces",
    53  		VersionIsZero: true,
    54  		IdIsEmpty:     true,
    55  		Method:        method,
    56  		Args:          expectArgs,
    57  		Results:       useResults,
    58  	}
    59  	return apitesting.CheckingAPICaller(c, args, numCalls, nil)
    60  }
    61  
    62  func (s *DiscoverSpacesSuite) TestNewAPIWithNilCaller(c *gc.C) {
    63  	panicFunc := func() { discoverspaces.NewAPI(nil) }
    64  	c.Assert(panicFunc, gc.PanicMatches, "caller is nil")
    65  }
    66  
    67  func (s *DiscoverSpacesSuite) TestListSpaces(c *gc.C) {
    68  	var called int
    69  	expectedResult := params.DiscoverSpacesResults{
    70  		Results: []params.ProviderSpace{{Name: "foobar"}},
    71  	}
    72  	apiCaller := successAPICaller(c, "ListSpaces", nil, expectedResult, &called)
    73  	api := discoverspaces.NewAPI(apiCaller)
    74  
    75  	result, err := api.ListSpaces()
    76  	c.Assert(err, jc.ErrorIsNil)
    77  	c.Assert(result, jc.DeepEquals, expectedResult)
    78  	c.Assert(called, gc.Equals, 1)
    79  }
    80  
    81  func (s *DiscoverSpacesSuite) TestAddSubnets(c *gc.C) {
    82  	var called int
    83  	expectedResult := params.ErrorResults{
    84  		Results: []params.ErrorResult{{}},
    85  	}
    86  	expectedArgs := params.AddSubnetsParams{
    87  		Subnets: []params.AddSubnetParams{{SubnetTag: "foo"}},
    88  	}
    89  	apiCaller := successAPICaller(c, "AddSubnets", expectedArgs, expectedResult, &called)
    90  	api := discoverspaces.NewAPI(apiCaller)
    91  
    92  	result, err := api.AddSubnets(expectedArgs)
    93  	c.Assert(err, jc.ErrorIsNil)
    94  	c.Assert(result, jc.DeepEquals, expectedResult)
    95  	c.Assert(called, gc.Equals, 1)
    96  }
    97  
    98  func (s *DiscoverSpacesSuite) TestCreateSpaces(c *gc.C) {
    99  	var called int
   100  	expectedResult := params.ErrorResults{
   101  		Results: []params.ErrorResult{{}},
   102  	}
   103  	expectedArgs := params.CreateSpacesParams{
   104  		Spaces: []params.CreateSpaceParams{{SpaceTag: "foo"}},
   105  	}
   106  	apiCaller := successAPICaller(c, "CreateSpaces", expectedArgs, expectedResult, &called)
   107  	api := discoverspaces.NewAPI(apiCaller)
   108  
   109  	result, err := api.CreateSpaces(expectedArgs)
   110  	c.Assert(err, jc.ErrorIsNil)
   111  	c.Assert(result, jc.DeepEquals, expectedResult)
   112  	c.Assert(called, gc.Equals, 1)
   113  }
   114  
   115  func (s *DiscoverSpacesSuite) TestModelConfig(c *gc.C) {
   116  	var called int
   117  	cfg, err := config.New(config.UseDefaults, coretesting.FakeConfig())
   118  	c.Assert(err, jc.ErrorIsNil)
   119  	expectedResult := params.ModelConfigResult{
   120  		Config: cfg.AllAttrs(),
   121  	}
   122  	apiCaller := successAPICaller(c, "ModelConfig", nil, expectedResult, &called)
   123  	api := discoverspaces.NewAPI(apiCaller)
   124  
   125  	result, err := api.ModelConfig()
   126  	c.Assert(err, jc.ErrorIsNil)
   127  	c.Assert(result, jc.DeepEquals, cfg)
   128  	c.Assert(called, gc.Equals, 1)
   129  }