← Back to branch summary

~nskaggs/+junk/xenial-test

« back to all changes in this revision

Viewing changes to src/github.com/juju/juju/apiserver/facade/registry_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/apiserver/facade/registry_test.go
 
1
// Copyright 2014-2016 Canonical Ltd.
 
2
// Licensed under the AGPLv3, see LICENCE file for details.
 
3
 
 
4
package facade_test
 
5
 
 
6
import (
 
7
        "reflect"
 
8
 
 
9
        "github.com/juju/errors"
 
10
        jc "github.com/juju/testing/checkers"
 
11
        gc "gopkg.in/check.v1"
 
12
 
 
13
        "github.com/juju/juju/apiserver/facade"
 
14
        "github.com/juju/juju/testing"
 
15
)
 
16
 
 
17
type RegistrySuite struct {
 
18
        testing.BaseSuite
 
19
}
 
20
 
 
21
var _ = gc.Suite(&RegistrySuite{})
 
22
 
 
23
func (s *RegistrySuite) TestRegister(c *gc.C) {
 
24
        registry := &facade.Registry{}
 
25
        var v interface{}
 
26
        facadeType := reflect.TypeOf(&v).Elem()
 
27
        err := registry.Register("myfacade", 123, testFacade, facadeType, "")
 
28
        c.Assert(err, jc.ErrorIsNil)
 
29
 
 
30
        factory, err := registry.GetFactory("myfacade", 123)
 
31
        c.Assert(err, jc.ErrorIsNil)
 
32
        val, err := factory(nil)
 
33
        c.Assert(err, jc.ErrorIsNil)
 
34
        c.Check(val, gc.Equals, "myobject")
 
35
}
 
36
 
 
37
func (*RegistrySuite) TestGetFactoryUnknown(c *gc.C) {
 
38
        registry := &facade.Registry{}
 
39
        factory, err := registry.GetFactory("name", 0)
 
40
        c.Check(err, jc.Satisfies, errors.IsNotFound)
 
41
        c.Check(err, gc.ErrorMatches, `name\(0\) not found`)
 
42
        c.Check(factory, gc.IsNil)
 
43
}
 
44
 
 
45
func (*RegistrySuite) TestGetFactoryUnknownVersion(c *gc.C) {
 
46
        registry := &facade.Registry{}
 
47
        assertRegister(c, registry, "name", 0)
 
48
 
 
49
        factory, err := registry.GetFactory("name", 1)
 
50
        c.Check(err, jc.Satisfies, errors.IsNotFound)
 
51
        c.Check(err, gc.ErrorMatches, `name\(1\) not found`)
 
52
        c.Check(factory, gc.IsNil)
 
53
}
 
54
 
 
55
func (*RegistrySuite) TestRegisterAndList(c *gc.C) {
 
56
        registry := &facade.Registry{}
 
57
        assertRegister(c, registry, "name", 0)
 
58
 
 
59
        c.Check(registry.List(), jc.DeepEquals, []facade.Description{
 
60
                {Name: "name", Versions: []int{0}},
 
61
        })
 
62
}
 
63
 
 
64
func (*RegistrySuite) TestRegisterAndListSorted(c *gc.C) {
 
65
        registry := &facade.Registry{}
 
66
        assertRegister(c, registry, "name", 10)
 
67
        assertRegister(c, registry, "name", 0)
 
68
        assertRegister(c, registry, "name", 101)
 
69
 
 
70
        c.Check(registry.List(), jc.DeepEquals, []facade.Description{
 
71
                {Name: "name", Versions: []int{0, 10, 101}},
 
72
        })
 
73
}
 
74
 
 
75
func (*RegistrySuite) TestRegisterAndListMultiple(c *gc.C) {
 
76
        registry := &facade.Registry{}
 
77
        assertRegister(c, registry, "other", 0)
 
78
        assertRegister(c, registry, "name", 0)
 
79
        assertRegister(c, registry, "third", 2)
 
80
        assertRegister(c, registry, "third", 3)
 
81
 
 
82
        c.Check(registry.List(), jc.DeepEquals, []facade.Description{
 
83
                {Name: "name", Versions: []int{0}},
 
84
                {Name: "other", Versions: []int{0}},
 
85
                {Name: "third", Versions: []int{2, 3}},
 
86
        })
 
87
}
 
88
 
 
89
func (s *RegistrySuite) TestRegisterAndListMultipleWithFeatures(c *gc.C) {
 
90
        registry := &facade.Registry{}
 
91
        assertRegisterFlag(c, registry, "other", 0, "special")
 
92
        assertRegister(c, registry, "name", 0)
 
93
        assertRegisterFlag(c, registry, "name", 1, "special")
 
94
        assertRegister(c, registry, "third", 2)
 
95
        assertRegisterFlag(c, registry, "third", 3, "magic")
 
96
 
 
97
        s.SetFeatureFlags("magic")
 
98
        c.Check(registry.List(), jc.DeepEquals, []facade.Description{
 
99
                {Name: "name", Versions: []int{0}},
 
100
                {Name: "third", Versions: []int{2, 3}},
 
101
        })
 
102
}
 
103
 
 
104
func (*RegistrySuite) TestRegisterAlreadyPresent(c *gc.C) {
 
105
        registry := &facade.Registry{}
 
106
        assertRegister(c, registry, "name", 0)
 
107
        secondIdFactory := func(context facade.Context) (facade.Facade, error) {
 
108
                var i = 200
 
109
                return &i, nil
 
110
        }
 
111
        err := registry.Register("name", 0, secondIdFactory, intPtrType, "")
 
112
        c.Assert(err, gc.ErrorMatches, `object "name\(0\)" already registered`)
 
113
 
 
114
        factory, err := registry.GetFactory("name", 0)
 
115
        c.Assert(err, jc.ErrorIsNil)
 
116
        c.Assert(factory, gc.NotNil)
 
117
        val, err := factory(nil)
 
118
        c.Assert(err, jc.ErrorIsNil)
 
119
        asIntPtr := val.(*int)
 
120
        c.Check(*asIntPtr, gc.Equals, 100)
 
121
}
 
122
 
 
123
func (*RegistrySuite) TestGetFactory(c *gc.C) {
 
124
        registry := &facade.Registry{}
 
125
        assertRegister(c, registry, "name", 0)
 
126
 
 
127
        factory, err := registry.GetFactory("name", 0)
 
128
        c.Assert(err, jc.ErrorIsNil)
 
129
        c.Assert(factory, gc.NotNil)
 
130
        res, err := factory(nil)
 
131
        c.Assert(err, jc.ErrorIsNil)
 
132
        c.Assert(res, gc.NotNil)
 
133
        asIntPtr := res.(*int)
 
134
        c.Check(*asIntPtr, gc.Equals, 100)
 
135
}
 
136
 
 
137
func (*RegistrySuite) TestGetType(c *gc.C) {
 
138
        registry := &facade.Registry{}
 
139
        assertRegister(c, registry, "name", 0)
 
140
 
 
141
        typ, err := registry.GetType("name", 0)
 
142
        c.Assert(err, jc.ErrorIsNil)
 
143
        c.Check(typ, gc.Equals, intPtrType)
 
144
}
 
145
 
 
146
func (*RegistrySuite) TestDiscardHandlesNotPresent(c *gc.C) {
 
147
        registry := &facade.Registry{}
 
148
        registry.Discard("name", 1)
 
149
}
 
150
 
 
151
func (*RegistrySuite) TestDiscardRemovesEntry(c *gc.C) {
 
152
        registry := &facade.Registry{}
 
153
        assertRegister(c, registry, "name", 0)
 
154
        _, err := registry.GetFactory("name", 0)
 
155
        c.Assert(err, jc.ErrorIsNil)
 
156
 
 
157
        registry.Discard("name", 0)
 
158
        factory, err := registry.GetFactory("name", 0)
 
159
        c.Check(err, jc.Satisfies, errors.IsNotFound)
 
160
        c.Check(err, gc.ErrorMatches, `name\(0\) not found`)
 
161
        c.Check(factory, gc.IsNil)
 
162
        c.Check(registry.List(), jc.DeepEquals, []facade.Description{})
 
163
}
 
164
 
 
165
func (*RegistrySuite) TestDiscardLeavesOtherVersions(c *gc.C) {
 
166
        registry := &facade.Registry{}
 
167
        assertRegister(c, registry, "name", 0)
 
168
        assertRegister(c, registry, "name", 1)
 
169
 
 
170
        registry.Discard("name", 0)
 
171
        _, err := registry.GetFactory("name", 1)
 
172
        c.Check(err, jc.ErrorIsNil)
 
173
        c.Check(registry.List(), jc.DeepEquals, []facade.Description{
 
174
                {Name: "name", Versions: []int{1}},
 
175
        })
 
176
}
 
177
 
 
178
func testFacade(facade.Context) (facade.Facade, error) {
 
179
        return "myobject", nil
 
180
}
 
181
 
 
182
func validIdFactory(facade.Context) (facade.Facade, error) {
 
183
        var i = 100
 
184
        return &i, nil
 
185
}
 
186
 
 
187
var intPtr = new(int)
 
188
var intPtrType = reflect.TypeOf(&intPtr).Elem()
 
189
 
 
190
func assertRegister(c *gc.C, registry *facade.Registry, name string, version int) {
 
191
        assertRegisterFlag(c, registry, name, version, "")
 
192
}
 
193
 
 
194
func assertRegisterFlag(c *gc.C, registry *facade.Registry, name string, version int, flag string) {
 
195
 
 
196
        err := registry.Register(name, version, validIdFactory, intPtrType, flag)
 
197
        c.Assert(err, gc.IsNil)
 
198
}