← Back to branch summary

~nskaggs/+junk/xenial-test

« back to all changes in this revision

Viewing changes to src/github.com/juju/juju/apiserver/common/resource_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/common/resource_test.go
 
1
// Copyright 2013 Canonical Ltd.
 
2
// Licensed under the AGPLv3, see LICENCE file for details.
 
3
 
 
4
package common_test
 
5
 
 
6
import (
 
7
        "sync"
 
8
 
 
9
        jc "github.com/juju/testing/checkers"
 
10
        gc "gopkg.in/check.v1"
 
11
 
 
12
        "github.com/juju/juju/apiserver/common"
 
13
)
 
14
 
 
15
type resourceSuite struct{}
 
16
 
 
17
var _ = gc.Suite(resourceSuite{})
 
18
 
 
19
type fakeResource struct {
 
20
        stopped bool
 
21
}
 
22
 
 
23
func (r *fakeResource) Stop() error {
 
24
        r.stopped = true
 
25
        return nil
 
26
}
 
27
 
 
28
func (resourceSuite) TestRegisterGetCount(c *gc.C) {
 
29
        rs := common.NewResources()
 
30
        r1 := &fakeResource{}
 
31
        id := rs.Register(r1)
 
32
        c.Assert(id, gc.Equals, "1")
 
33
        c.Assert(rs.Get("1"), gc.Equals, r1)
 
34
        c.Assert(rs.Count(), gc.Equals, 1)
 
35
 
 
36
        r2 := &fakeResource{}
 
37
        id = rs.Register(r2)
 
38
        c.Assert(id, gc.Equals, "2")
 
39
        c.Assert(rs.Get("2"), gc.Equals, r2)
 
40
        c.Assert(rs.Count(), gc.Equals, 2)
 
41
}
 
42
 
 
43
func (resourceSuite) TestRegisterNamedGetCount(c *gc.C) {
 
44
        rs := common.NewResources()
 
45
        defer rs.StopAll()
 
46
        r1 := &fakeResource{}
 
47
        err := rs.RegisterNamed("fake1", r1)
 
48
        c.Assert(err, jc.ErrorIsNil)
 
49
        c.Check(rs.Count(), gc.Equals, 1)
 
50
        c.Check(rs.Get("fake1"), gc.Equals, r1)
 
51
}
 
52
 
 
53
func (resourceSuite) TestRegisterNamedRepeatedName(c *gc.C) {
 
54
        rs := common.NewResources()
 
55
        defer rs.StopAll()
 
56
        r1 := &fakeResource{}
 
57
        r2 := &fakeResource{}
 
58
        err := rs.RegisterNamed("fake1", r1)
 
59
        c.Assert(err, jc.ErrorIsNil)
 
60
        c.Check(rs.Count(), gc.Equals, 1)
 
61
        err = rs.RegisterNamed("fake1", r2)
 
62
        c.Check(err, gc.ErrorMatches, `resource "fake1" already registered`)
 
63
        c.Check(rs.Count(), gc.Equals, 1)
 
64
        c.Check(rs.Get("fake1"), gc.Equals, r1)
 
65
}
 
66
 
 
67
func (resourceSuite) TestRegisterNamedIntegerName(c *gc.C) {
 
68
        rs := common.NewResources()
 
69
        defer rs.StopAll()
 
70
        r1 := &fakeResource{}
 
71
        err := rs.RegisterNamed("1", r1)
 
72
        c.Check(err, gc.ErrorMatches, `RegisterNamed does not allow integer names: "1"`)
 
73
        c.Check(rs.Count(), gc.Equals, 0)
 
74
        c.Check(rs.Get("fake1"), gc.IsNil)
 
75
}
 
76
 
 
77
func (resourceSuite) TestRegisterNamedIntegerStart(c *gc.C) {
 
78
        rs := common.NewResources()
 
79
        defer rs.StopAll()
 
80
        r1 := &fakeResource{}
 
81
        err := rs.RegisterNamed("1fake", r1)
 
82
        c.Assert(err, jc.ErrorIsNil)
 
83
        c.Check(rs.Count(), gc.Equals, 1)
 
84
        c.Check(rs.Get("1fake"), gc.Equals, r1)
 
85
}
 
86
 
 
87
func (resourceSuite) TestConcurrency(c *gc.C) {
 
88
        // This test is designed to cause the race detector
 
89
        // to fail if the locking is not done correctly.
 
90
        var wg sync.WaitGroup
 
91
        rs := common.NewResources()
 
92
 
 
93
        start := func(f func()) {
 
94
                wg.Add(1)
 
95
                go func() {
 
96
                        f()
 
97
                        wg.Done()
 
98
                }()
 
99
        }
 
100
        rs.Register(&fakeResource{})
 
101
        start(func() {
 
102
                rs.Register(&fakeResource{})
 
103
        })
 
104
        start(func() {
 
105
                rs.RegisterNamed("named", &fakeResource{})
 
106
        })
 
107
        start(func() {
 
108
                rs.Stop("1")
 
109
        })
 
110
        start(func() {
 
111
                rs.Count()
 
112
        })
 
113
        start(func() {
 
114
                rs.StopAll()
 
115
        })
 
116
        start(func() {
 
117
                rs.Get("2")
 
118
        })
 
119
        start(func() {
 
120
                rs.Get("named")
 
121
        })
 
122
        wg.Wait()
 
123
}
 
124
 
 
125
func (resourceSuite) TestStop(c *gc.C) {
 
126
        rs := common.NewResources()
 
127
        r1 := &fakeResource{}
 
128
        rs.Register(r1)
 
129
        r2 := &fakeResource{}
 
130
        rs.Register(r2)
 
131
        rs.Stop("1")
 
132
        c.Assert(r1.stopped, jc.IsTrue)
 
133
        c.Assert(rs.Get("1"), gc.IsNil)
 
134
        c.Assert(r2.stopped, jc.IsFalse)
 
135
        c.Assert(rs.Get("2"), gc.Equals, r2)
 
136
        c.Assert(rs.Count(), gc.Equals, 1)
 
137
}
 
138
 
 
139
func (resourceSuite) TestStopAll(c *gc.C) {
 
140
        rs := common.NewResources()
 
141
        r1 := &fakeResource{}
 
142
        rs.Register(r1)
 
143
        r2 := &fakeResource{}
 
144
        rs.Register(r2)
 
145
        rs.StopAll()
 
146
 
 
147
        c.Assert(r1.stopped, jc.IsTrue)
 
148
        c.Assert(rs.Get("1"), gc.IsNil)
 
149
        c.Assert(r2.stopped, jc.IsTrue)
 
150
        c.Assert(rs.Get("2"), gc.IsNil)
 
151
 
 
152
        c.Assert(rs.Count(), gc.Equals, 0)
 
153
}
 
154
 
 
155
func (resourceSuite) TestStringResource(c *gc.C) {
 
156
        rs := common.NewResources()
 
157
        r1 := common.StringResource("foobar")
 
158
        id := rs.Register(r1)
 
159
        c.Check(rs.Get(id), gc.Equals, r1)
 
160
        asStr := rs.Get(id).(common.StringResource).String()
 
161
        c.Check(asStr, gc.Equals, "foobar")
 
162
}