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

     1  // Copyright 2015 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package spaces_test
     5  
     6  import (
     7  	"errors"
     8  	"fmt"
     9  	"math/rand"
    10  
    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  	apitesting "github.com/juju/juju/api/base/testing"
    17  	"github.com/juju/juju/api/spaces"
    18  	"github.com/juju/juju/apiserver/params"
    19  	coretesting "github.com/juju/juju/testing"
    20  )
    21  
    22  type SpacesSuite struct {
    23  	coretesting.BaseSuite
    24  
    25  	called    int
    26  	apiCaller base.APICallCloser
    27  	api       *spaces.API
    28  }
    29  
    30  var _ = gc.Suite(&SpacesSuite{})
    31  
    32  func (s *SpacesSuite) init(c *gc.C, args *apitesting.CheckArgs, err error) {
    33  	s.called = 0
    34  	s.apiCaller = apitesting.CheckingAPICaller(c, args, &s.called, err)
    35  	s.api = spaces.NewAPI(s.apiCaller)
    36  	c.Check(s.api, gc.NotNil)
    37  	c.Check(s.called, gc.Equals, 0)
    38  }
    39  
    40  func (s *SpacesSuite) TestNewAPISuccess(c *gc.C) {
    41  	var called int
    42  	apiCaller := apitesting.CheckingAPICaller(c, nil, &called, nil)
    43  	api := spaces.NewAPI(apiCaller)
    44  	c.Check(api, gc.NotNil)
    45  	c.Check(called, gc.Equals, 0)
    46  }
    47  
    48  func (s *SpacesSuite) TestNewAPIWithNilCaller(c *gc.C) {
    49  	panicFunc := func() { spaces.NewAPI(nil) }
    50  	c.Assert(panicFunc, gc.PanicMatches, "caller is nil")
    51  }
    52  
    53  func makeArgs(name string, subnets []string) (string, []string, apitesting.CheckArgs) {
    54  	spaceTag := names.NewSpaceTag(name).String()
    55  	subnetTags := []string{}
    56  
    57  	for _, s := range subnets {
    58  		subnetTags = append(subnetTags, names.NewSubnetTag(s).String())
    59  	}
    60  
    61  	expectArgs := params.CreateSpacesParams{
    62  		Spaces: []params.CreateSpaceParams{
    63  			params.CreateSpaceParams{
    64  				SpaceTag:   spaceTag,
    65  				SubnetTags: subnetTags,
    66  				Public:     true,
    67  			}}}
    68  
    69  	expectResults := params.ErrorResults{
    70  		Results: []params.ErrorResult{{}},
    71  	}
    72  
    73  	args := apitesting.CheckArgs{
    74  		Facade:  "Spaces",
    75  		Method:  "CreateSpaces",
    76  		Args:    expectArgs,
    77  		Results: expectResults,
    78  	}
    79  
    80  	return name, subnets, args
    81  }
    82  
    83  func (s *SpacesSuite) testCreateSpace(c *gc.C, name string, subnets []string) {
    84  	_, _, args := makeArgs(name, subnets)
    85  	s.init(c, &args, nil)
    86  	err := s.api.CreateSpace(name, subnets, true)
    87  	c.Assert(s.called, gc.Equals, 1)
    88  	c.Assert(err, jc.ErrorIsNil)
    89  }
    90  
    91  func (s *SpacesSuite) TestCreateSpace(c *gc.C) {
    92  	name := "foo"
    93  	subnets := []string{}
    94  	r := rand.New(rand.NewSource(0xdeadbeef))
    95  	for i := 0; i < 100; i++ {
    96  		for j := 0; j < 10; j++ {
    97  			n := r.Uint32()
    98  			newSubnet := fmt.Sprintf("%d.%d.%d.0/24", uint8(n>>16), uint8(n>>8), uint8(n))
    99  			subnets = append(subnets, newSubnet)
   100  		}
   101  		s.testCreateSpace(c, name, subnets)
   102  	}
   103  }
   104  
   105  func (s *SpacesSuite) TestCreateSpaceEmptyResults(c *gc.C) {
   106  	_, _, args := makeArgs("foo", nil)
   107  	args.Results = params.ErrorResults{}
   108  	s.init(c, &args, nil)
   109  	err := s.api.CreateSpace("foo", nil, true)
   110  	c.Check(s.called, gc.Equals, 1)
   111  	c.Assert(err, gc.ErrorMatches, "expected 1 result, got 0")
   112  }
   113  
   114  func (s *SpacesSuite) TestCreateSpaceFails(c *gc.C) {
   115  	name, subnets, args := makeArgs("foo", []string{"1.1.1.0/24"})
   116  	s.init(c, &args, errors.New("bang"))
   117  	err := s.api.CreateSpace(name, subnets, true)
   118  	c.Check(s.called, gc.Equals, 1)
   119  	c.Assert(err, gc.ErrorMatches, "bang")
   120  }
   121  
   122  func (s *SpacesSuite) testListSpaces(c *gc.C, results []params.Space, err error, expectErr string) {
   123  	var expectResults params.ListSpacesResults
   124  	if results != nil {
   125  		expectResults = params.ListSpacesResults{
   126  			Results: results,
   127  		}
   128  	}
   129  
   130  	args := apitesting.CheckArgs{
   131  		Facade:  "Spaces",
   132  		Method:  "ListSpaces",
   133  		Results: expectResults,
   134  	}
   135  	s.init(c, &args, err)
   136  	gotResults, gotErr := s.api.ListSpaces()
   137  	c.Assert(s.called, gc.Equals, 1)
   138  	c.Assert(gotResults, jc.DeepEquals, results)
   139  	if expectErr != "" {
   140  		c.Assert(gotErr, gc.ErrorMatches, expectErr)
   141  		return
   142  	}
   143  	if err != nil {
   144  		c.Assert(gotErr, jc.DeepEquals, err)
   145  	} else {
   146  		c.Assert(gotErr, jc.ErrorIsNil)
   147  	}
   148  }
   149  
   150  func (s *SpacesSuite) TestListSpacesEmptyResults(c *gc.C) {
   151  	s.testListSpaces(c, []params.Space{}, nil, "")
   152  }
   153  
   154  func (s *SpacesSuite) TestListSpacesManyResults(c *gc.C) {
   155  	spaces := []params.Space{{
   156  		Name: "space1",
   157  		Subnets: []params.Subnet{{
   158  			CIDR: "foo",
   159  		}, {
   160  			CIDR: "bar",
   161  		}},
   162  	}, {
   163  		Name: "space2",
   164  	}, {
   165  		Name:    "space3",
   166  		Subnets: []params.Subnet{},
   167  	}}
   168  	s.testListSpaces(c, spaces, nil, "")
   169  }
   170  
   171  func (s *SpacesSuite) TestListSpacesServerError(c *gc.C) {
   172  	s.testListSpaces(c, nil, errors.New("boom"), "boom")
   173  }