github.com/altoros/juju-vmware@v0.0.0-20150312064031-f19ae857ccca/api/facadeversions_test.go (about)

     1  // Copyright 2014 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package api_test
     5  
     6  import (
     7  	"strings"
     8  
     9  	"github.com/juju/utils/set"
    10  	gc "gopkg.in/check.v1"
    11  
    12  	"github.com/juju/juju/api"
    13  	"github.com/juju/juju/apiserver/common"
    14  	"github.com/juju/juju/feature"
    15  	coretesting "github.com/juju/juju/testing"
    16  )
    17  
    18  type facadeVersionSuite struct {
    19  	coretesting.BaseSuite
    20  }
    21  
    22  var _ = gc.Suite(&facadeVersionSuite{})
    23  
    24  func (s *facadeVersionSuite) TestFacadeVersionsMatchServerVersions(c *gc.C) {
    25  	// Enable feature flags so we can see them all.
    26  	devFeatures := []string{feature.MESS, feature.Storage}
    27  	s.SetFeatureFlags(strings.Join(devFeatures, ","))
    28  	// The client side code doesn't want to directly import the server side
    29  	// code just to list out what versions are available. However, we do
    30  	// want to make sure that the two sides are kept in sync.
    31  	clientFacadeNames := set.NewStrings()
    32  	for name := range *api.FacadeVersions {
    33  		clientFacadeNames.Add(name)
    34  	}
    35  	allServerFacades := common.Facades.List()
    36  	serverFacadeNames := set.NewStrings()
    37  	serverFacadeBestVersions := make(map[string]int, len(allServerFacades))
    38  	for _, facade := range allServerFacades {
    39  		serverFacadeNames.Add(facade.Name)
    40  		serverFacadeBestVersions[facade.Name] = facade.Versions[len(facade.Versions)-1]
    41  	}
    42  	// First check that both sides know about all the same versions
    43  	c.Check(serverFacadeNames.Difference(clientFacadeNames).SortedValues(), gc.HasLen, 0)
    44  	c.Check(clientFacadeNames.Difference(serverFacadeNames).SortedValues(), gc.HasLen, 0)
    45  	// Next check that the best versions match
    46  	c.Check(*api.FacadeVersions, gc.DeepEquals, serverFacadeBestVersions)
    47  }
    48  
    49  func checkBestVersion(c *gc.C, desiredVersion int, versions []int, expectedVersion int) {
    50  	resultVersion := api.BestVersion(desiredVersion, versions)
    51  	c.Check(resultVersion, gc.Equals, expectedVersion)
    52  }
    53  
    54  func (*facadeVersionSuite) TestBestVersionDesiredAvailable(c *gc.C) {
    55  	checkBestVersion(c, 0, []int{0, 1, 2}, 0)
    56  	checkBestVersion(c, 1, []int{0, 1, 2}, 1)
    57  	checkBestVersion(c, 2, []int{0, 1, 2}, 2)
    58  }
    59  
    60  func (*facadeVersionSuite) TestBestVersionDesiredNewer(c *gc.C) {
    61  	checkBestVersion(c, 3, []int{0}, 0)
    62  	checkBestVersion(c, 3, []int{0, 1, 2}, 2)
    63  }
    64  
    65  func (*facadeVersionSuite) TestBestVersionDesiredGap(c *gc.C) {
    66  	checkBestVersion(c, 1, []int{0, 2}, 0)
    67  }
    68  
    69  func (*facadeVersionSuite) TestBestVersionNoVersions(c *gc.C) {
    70  	checkBestVersion(c, 0, []int{}, 0)
    71  	checkBestVersion(c, 1, []int{}, 0)
    72  	checkBestVersion(c, 0, []int(nil), 0)
    73  	checkBestVersion(c, 1, []int(nil), 0)
    74  }
    75  
    76  func (*facadeVersionSuite) TestBestVersionNotSorted(c *gc.C) {
    77  	checkBestVersion(c, 0, []int{0, 3, 1, 2}, 0)
    78  	checkBestVersion(c, 3, []int{0, 3, 1, 2}, 3)
    79  	checkBestVersion(c, 1, []int{0, 3, 1, 2}, 1)
    80  	checkBestVersion(c, 2, []int{0, 3, 1, 2}, 2)
    81  }
    82  
    83  func (s *facadeVersionSuite) TestBestFacadeVersionExactMatch(c *gc.C) {
    84  	s.PatchValue(api.FacadeVersions, map[string]int{"Client": 1})
    85  	st := api.NewTestingState(api.TestingStateParams{
    86  		FacadeVersions: map[string][]int{
    87  			"Client": {0, 1},
    88  		}})
    89  	c.Check(st.BestFacadeVersion("Client"), gc.Equals, 1)
    90  }
    91  
    92  func (s *facadeVersionSuite) TestBestFacadeVersionNewerServer(c *gc.C) {
    93  	s.PatchValue(api.FacadeVersions, map[string]int{"Client": 1})
    94  	st := api.NewTestingState(api.TestingStateParams{
    95  		FacadeVersions: map[string][]int{
    96  			"Client": {0, 1, 2},
    97  		}})
    98  	c.Check(st.BestFacadeVersion("Client"), gc.Equals, 1)
    99  }
   100  
   101  func (s *facadeVersionSuite) TestBestFacadeVersionNewerClient(c *gc.C) {
   102  	s.PatchValue(api.FacadeVersions, map[string]int{"Client": 2})
   103  	st := api.NewTestingState(api.TestingStateParams{
   104  		FacadeVersions: map[string][]int{
   105  			"Client": {0, 1},
   106  		}})
   107  	c.Check(st.BestFacadeVersion("Client"), gc.Equals, 1)
   108  }
   109  
   110  func (s *facadeVersionSuite) TestBestFacadeVersionServerUnknown(c *gc.C) {
   111  	s.PatchValue(api.FacadeVersions, map[string]int{"TestingAPI": 2})
   112  	st := api.NewTestingState(api.TestingStateParams{
   113  		FacadeVersions: map[string][]int{
   114  			"Client": {0, 1},
   115  		}})
   116  	c.Check(st.BestFacadeVersion("TestingAPI"), gc.Equals, 0)
   117  }