1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
|
// Copyright 2013 Canonical Ltd.
// Licensed under the AGPLv3, see LICENCE file for details.
package addressupdater
import (
"errors"
stdtesting "testing"
"time"
gc "launchpad.net/gocheck"
"launchpad.net/juju-core/state"
coretesting "launchpad.net/juju-core/testing"
jc "launchpad.net/juju-core/testing/checkers"
"launchpad.net/juju-core/testing/testbase"
)
func TestPackage(t *stdtesting.T) {
coretesting.MgoTestPackage(t)
}
var _ = gc.Suite(&updaterSuite{})
type updaterSuite struct {
testbase.LoggingSuite
}
func (*updaterSuite) TestStopsWatcher(c *gc.C) {
context := &testUpdaterContext{
dyingc: make(chan struct{}),
}
expectErr := errors.New("some error")
watcher := &testMachinesWatcher{
changes: make(chan []string),
err: expectErr,
}
done := make(chan error)
go func() {
done <- watchMachinesLoop(context, watcher)
}()
close(context.dyingc)
select {
case err := <-done:
c.Assert(err, gc.ErrorMatches, ".*"+expectErr.Error())
case <-time.After(coretesting.LongWait):
c.Fatalf("timed out waiting for watchMachinesLoop to terminate")
}
c.Assert(watcher.stopped, jc.IsTrue)
}
func (*updaterSuite) TestWatchMachinesWaitsForMachinePollers(c *gc.C) {
// We can't see that the machine pollers are still alive directly,
// but we can make the machine's Refresh method block,
// and test that watchMachinesLoop only terminates
// when it unblocks.
waitRefresh := make(chan struct{})
m := &testMachine{
id: "99",
instanceId: "i1234",
life: state.Alive,
refresh: func() error {
// Signal that we're in Refresh.
waitRefresh <- struct{}{}
// Wait to be unblocked.
<-waitRefresh
return nil
},
}
dyingc := make(chan struct{})
context := &testUpdaterContext{
dyingc: dyingc,
newMachineContextFunc: func() machineContext {
return &testMachineContext{
getAddresses: addressesGetter(c, "i1234", testAddrs, nil),
dyingc: dyingc,
}
},
getMachineFunc: func(id string) (machine, error) {
c.Check(id, gc.Equals, m.id)
return m, nil
},
}
watcher := &testMachinesWatcher{
changes: make(chan []string),
}
done := make(chan error)
go func() {
done <- watchMachinesLoop(context, watcher)
}()
// Send two changes; the first one should start the machineLoop;
// the second should call Refresh.
watcher.changes <- []string{"99"}
watcher.changes <- []string{"99"}
// Wait for the machineLoop to call Refresh
select {
case <-waitRefresh:
c.Logf("poller called Refresh")
case <-time.After(coretesting.LongWait):
c.Fatalf("timed out waiting for machine to be refreshed")
}
close(context.dyingc)
// Wait a little while to be sure that watchMachinesLoop is
// actually waiting for its machine poller to finish.
select {
case err := <-done:
c.Fatalf("watchMachinesLoop terminated prematurely: %v", err)
case <-time.After(coretesting.ShortWait):
}
waitRefresh <- struct{}{}
select {
case err := <-done:
c.Assert(err, gc.IsNil)
case <-time.After(coretesting.LongWait):
c.Fatalf("timed out waiting for watchMachinesLoop to terminate")
}
c.Assert(watcher.stopped, jc.IsTrue)
}
type testUpdaterContext struct {
newMachineContextFunc func() machineContext
getMachineFunc func(id string) (machine, error)
dyingc chan struct{}
}
func (context *testUpdaterContext) newMachineContext() machineContext {
return context.newMachineContextFunc()
}
func (context *testUpdaterContext) getMachine(id string) (machine, error) {
return context.getMachineFunc(id)
}
func (context *testUpdaterContext) dying() <-chan struct{} {
return context.dyingc
}
type testMachinesWatcher struct {
stopped bool
changes chan []string
err error
}
func (w *testMachinesWatcher) Changes() <-chan []string {
return w.changes
}
func (w *testMachinesWatcher) Stop() error {
w.stopped = true
return w.err
}
func (w *testMachinesWatcher) Err() error {
return w.err
}
|