github.com/juju/juju@v0.0.0-20240327075706-a90865de2538/api/client/subnets/subnets_test.go (about)

     1  // Copyright 2015 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package subnets_test
     5  
     6  import (
     7  	"github.com/juju/errors"
     8  	"github.com/juju/names/v5"
     9  	jc "github.com/juju/testing/checkers"
    10  	"go.uber.org/mock/gomock"
    11  	gc "gopkg.in/check.v1"
    12  
    13  	basemocks "github.com/juju/juju/api/base/mocks"
    14  	"github.com/juju/juju/api/client/subnets"
    15  	"github.com/juju/juju/rpc/params"
    16  )
    17  
    18  // SubnetsSuite tests the client side subnets API
    19  type SubnetsSuite struct {
    20  }
    21  
    22  var _ = gc.Suite(&SubnetsSuite{})
    23  
    24  // TestNewAPISuccess checks that a new subnets API is created when passed a non-nil caller
    25  func (s *SubnetsSuite) TestNewAPISuccess(c *gc.C) {
    26  	ctrl := gomock.NewController(c)
    27  	defer ctrl.Finish()
    28  
    29  	apiCaller := basemocks.NewMockAPICallCloser(ctrl)
    30  	apiCaller.EXPECT().BestFacadeVersion("Subnets").Return(4)
    31  
    32  	api := subnets.NewAPI(apiCaller)
    33  	c.Check(api, gc.NotNil)
    34  }
    35  
    36  // TestNewAPIWithNilCaller checks that a new subnets API is not created when passed a nil caller
    37  func (s *SubnetsSuite) TestNewAPIWithNilCaller(c *gc.C) {
    38  	panicFunc := func() { subnets.NewAPI(nil) }
    39  	c.Assert(panicFunc, gc.PanicMatches, "caller is nil")
    40  }
    41  
    42  func makeListSubnetsArgs(space *names.SpaceTag, zone string) (params.SubnetsFilters, params.ListSubnetsResults) {
    43  	expectArgs := params.SubnetsFilters{
    44  		SpaceTag: space.String(),
    45  		Zone:     zone,
    46  	}
    47  	return expectArgs, params.ListSubnetsResults{}
    48  }
    49  
    50  func (s *SubnetsSuite) TestListSubnetsNoResults(c *gc.C) {
    51  	ctrl := gomock.NewController(c)
    52  	defer ctrl.Finish()
    53  
    54  	space := names.NewSpaceTag("foo")
    55  	zone := "bar"
    56  	args, results := makeListSubnetsArgs(&space, zone)
    57  	result := new(params.ListSubnetsResults)
    58  
    59  	mockFacadeCaller := basemocks.NewMockFacadeCaller(ctrl)
    60  	mockFacadeCaller.EXPECT().FacadeCall("ListSubnets", args, result).SetArg(2, results).Return(nil)
    61  	client := subnets.NewAPIFromCaller(mockFacadeCaller)
    62  
    63  	obtainedResults, err := client.ListSubnets(&space, zone)
    64  
    65  	c.Assert(err, jc.ErrorIsNil)
    66  
    67  	var expectedResults []params.Subnet
    68  	c.Assert(obtainedResults, jc.DeepEquals, expectedResults)
    69  }
    70  
    71  func (s *SubnetsSuite) TestListSubnetsFails(c *gc.C) {
    72  	ctrl := gomock.NewController(c)
    73  	defer ctrl.Finish()
    74  
    75  	space := names.NewSpaceTag("foo")
    76  	zone := "bar"
    77  	args, results := makeListSubnetsArgs(&space, zone)
    78  	result := new(params.ListSubnetsResults)
    79  
    80  	mockFacadeCaller := basemocks.NewMockFacadeCaller(ctrl)
    81  	mockFacadeCaller.EXPECT().FacadeCall("ListSubnets", args, result).SetArg(2, results).Return(errors.New("bang"))
    82  	client := subnets.NewAPIFromCaller(mockFacadeCaller)
    83  
    84  	obtainedResults, err := client.ListSubnets(&space, zone)
    85  	c.Assert(err, gc.ErrorMatches, "bang")
    86  
    87  	var expectedResults []params.Subnet
    88  	c.Assert(obtainedResults, jc.DeepEquals, expectedResults)
    89  }
    90  
    91  func (s *SubnetsSuite) testSubnetsByCIDR(c *gc.C,
    92  	ctrl *gomock.Controller,
    93  	cidrs []string,
    94  	results []params.SubnetsResult,
    95  	err error, expectErr string,
    96  ) {
    97  	var expectedResults params.SubnetsResults
    98  	if results != nil {
    99  		expectedResults.Results = results
   100  	}
   101  	args := params.CIDRParams{CIDRS: cidrs}
   102  
   103  	result := new(params.SubnetsResults)
   104  	mockFacadeCaller := basemocks.NewMockFacadeCaller(ctrl)
   105  	mockFacadeCaller.EXPECT().FacadeCall("SubnetsByCIDR", args, result).SetArg(2, expectedResults).Return(err)
   106  	client := subnets.NewAPIFromCaller(mockFacadeCaller)
   107  
   108  	gotResult, gotErr := client.SubnetsByCIDR(cidrs)
   109  	c.Assert(gotResult, jc.DeepEquals, results)
   110  
   111  	if expectErr != "" {
   112  		c.Assert(gotErr, gc.ErrorMatches, expectErr)
   113  		return
   114  	}
   115  
   116  	if err != nil {
   117  		c.Assert(gotErr, jc.DeepEquals, err)
   118  	} else {
   119  		c.Assert(gotErr, jc.ErrorIsNil)
   120  	}
   121  }
   122  
   123  func (s *SubnetsSuite) TestSubnetsByCIDRWithNoCIDRs(c *gc.C) {
   124  	ctrl := gomock.NewController(c)
   125  	defer ctrl.Finish()
   126  
   127  	var cidrs []string
   128  
   129  	s.testSubnetsByCIDR(c, ctrl, cidrs, []params.SubnetsResult{}, nil, "")
   130  }
   131  
   132  func (s *SubnetsSuite) TestSubnetsByCIDRWithNoResults(c *gc.C) {
   133  	ctrl := gomock.NewController(c)
   134  	defer ctrl.Finish()
   135  
   136  	cidrs := []string{"10.0.1.10/24"}
   137  
   138  	s.testSubnetsByCIDR(c, ctrl, cidrs, []params.SubnetsResult{}, nil, "")
   139  }
   140  
   141  func (s *SubnetsSuite) TestSubnetsByCIDRWithResults(c *gc.C) {
   142  	ctrl := gomock.NewController(c)
   143  	defer ctrl.Finish()
   144  
   145  	cidrs := []string{"10.0.1.10/24"}
   146  
   147  	s.testSubnetsByCIDR(c, ctrl, cidrs, []params.SubnetsResult{{
   148  		Subnets: []params.SubnetV2{{
   149  			ID: "aaabbb",
   150  			Subnet: params.Subnet{
   151  				CIDR: "10.0.1.10/24",
   152  			},
   153  		}},
   154  	}}, nil, "")
   155  }