← Back to branch summary

~nskaggs/+junk/xenial-test

« back to all changes in this revision

Viewing changes to src/github.com/juju/juju/api/facadeversions_test.go

  • Committer: Nicholas Skaggs
  • Date: 2016-10-24 20:56:05 UTC
  • Revision ID: nicholas.skaggs@canonical.com-20161024205605-z8lta0uvuhtxwzwl
Initi with beta15

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/github.com/juju/juju/api/facadeversions_test.go
 
1
// Copyright 2014 Canonical Ltd.
 
2
// Licensed under the AGPLv3, see LICENCE file for details.
 
3
 
 
4
package api_test
 
5
 
 
6
import (
 
7
        jc "github.com/juju/testing/checkers"
 
8
        "github.com/juju/utils/set"
 
9
        gc "gopkg.in/check.v1"
 
10
 
 
11
        "github.com/juju/juju/api"
 
12
        "github.com/juju/juju/apiserver/common"
 
13
        "github.com/juju/juju/component/all"
 
14
        coretesting "github.com/juju/juju/testing"
 
15
)
 
16
 
 
17
type facadeVersionSuite struct {
 
18
        coretesting.BaseSuite
 
19
}
 
20
 
 
21
var _ = gc.Suite(&facadeVersionSuite{})
 
22
 
 
23
func (s *facadeVersionSuite) TestFacadeVersionsMatchServerVersions(c *gc.C) {
 
24
        // The client side code doesn't want to directly import the server side
 
25
        // code just to list out what versions are available. However, we do
 
26
        // want to make sure that the two sides are kept in sync.
 
27
        clientFacadeNames := set.NewStrings()
 
28
        for name, version := range *api.FacadeVersions {
 
29
                clientFacadeNames.Add(name)
 
30
                // All versions should now be non-zero.
 
31
                c.Check(version, jc.GreaterThan, 0)
 
32
        }
 
33
        // Register the components.
 
34
        all.RegisterForServer()
 
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, jc.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
}