Merge lp:~pedronis/ubuntu-push/acceptance-flex-1 into lp:ubuntu-push
- acceptance-flex-1
- Merge into trunk
Proposed by
Samuele Pedroni
Status: | Merged |
---|---|
Approved by: | Samuele Pedroni |
Approved revision: | 68 |
Merged at revision: | 64 |
Proposed branch: | lp:~pedronis/ubuntu-push/acceptance-flex-1 |
Merge into: | lp:ubuntu-push |
Diff against target: |
501 lines (+203/-143) 2 files modified
server/acceptance/acceptance_helpers.go (+156/-0) server/acceptance/acceptance_test.go (+47/-143) |
To merge this branch: | bzr merge lp:~pedronis/ubuntu-push/acceptance-flex-1 |
Related bugs: |
Reviewer | Review Type | Date Requested | Status |
---|---|---|---|
John Lenton (community) | Approve | ||
Review via email: mp+205846@code.launchpad.net |
Commit message
starting splitting out helpers in the acceptance tests
Description of the change
in preparation of restructuring acceptance tests as reusable suites: starting splitting out helpers
To post a comment you must log in.
Revision history for this message
John Lenton (chipaca) : | # |
review:
Approve
Preview Diff
[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk
1 | === added file 'server/acceptance/acceptance_helpers.go' | |||
2 | --- server/acceptance/acceptance_helpers.go 1970-01-01 00:00:00 +0000 | |||
3 | +++ server/acceptance/acceptance_helpers.go 2014-02-11 20:38:55 +0000 | |||
4 | @@ -0,0 +1,156 @@ | |||
5 | 1 | /* | ||
6 | 2 | Copyright 2013-2014 Canonical Ltd. | ||
7 | 3 | |||
8 | 4 | This program is free software: you can redistribute it and/or modify it | ||
9 | 5 | under the terms of the GNU General Public License version 3, as published | ||
10 | 6 | by the Free Software Foundation. | ||
11 | 7 | |||
12 | 8 | This program is distributed in the hope that it will be useful, but | ||
13 | 9 | WITHOUT ANY WARRANTY; without even the implied warranties of | ||
14 | 10 | MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR | ||
15 | 11 | PURPOSE. See the GNU General Public License for more details. | ||
16 | 12 | |||
17 | 13 | You should have received a copy of the GNU General Public License along | ||
18 | 14 | with this program. If not, see <http://www.gnu.org/licenses/>. | ||
19 | 15 | */ | ||
20 | 16 | |||
21 | 17 | package acceptance | ||
22 | 18 | |||
23 | 19 | import ( | ||
24 | 20 | "bufio" | ||
25 | 21 | "encoding/json" | ||
26 | 22 | "fmt" | ||
27 | 23 | "io/ioutil" | ||
28 | 24 | "os" | ||
29 | 25 | "os/exec" | ||
30 | 26 | "path/filepath" | ||
31 | 27 | "regexp" | ||
32 | 28 | "strings" | ||
33 | 29 | "time" | ||
34 | 30 | |||
35 | 31 | . "launchpad.net/gocheck" | ||
36 | 32 | |||
37 | 33 | helpers "launchpad.net/ubuntu-push/testing" | ||
38 | 34 | ) | ||
39 | 35 | |||
40 | 36 | // FillConfig fills cfg from values. | ||
41 | 37 | func FillConfig(cfg, values map[string]interface{}) { | ||
42 | 38 | for k, v := range values { | ||
43 | 39 | cfg[k] = v | ||
44 | 40 | } | ||
45 | 41 | } | ||
46 | 42 | |||
47 | 43 | // FillServerConfig fills cfg with default server values and "addr": addr. | ||
48 | 44 | func FillServerConfig(cfg map[string]interface{}, addr string) { | ||
49 | 45 | FillConfig(cfg, map[string]interface{}{ | ||
50 | 46 | "exchange_timeout": "0.1s", | ||
51 | 47 | "ping_interval": "0.5s", | ||
52 | 48 | "session_queue_size": 10, | ||
53 | 49 | "broker_queue_size": 100, | ||
54 | 50 | "addr": addr, | ||
55 | 51 | "key_pem_file": helpers.SourceRelative("config/testing.key"), | ||
56 | 52 | "cert_pem_file": helpers.SourceRelative("config/testing.cert"), | ||
57 | 53 | }) | ||
58 | 54 | } | ||
59 | 55 | |||
60 | 56 | // FillHttpServerConfig fills cfg with default http server values and | ||
61 | 57 | // "http_addr": httpAddr. | ||
62 | 58 | func FillHTTPServerConfig(cfg map[string]interface{}, httpAddr string) { | ||
63 | 59 | FillConfig(cfg, map[string]interface{}{ | ||
64 | 60 | "http_addr": httpAddr, | ||
65 | 61 | "http_read_timeout": "1s", | ||
66 | 62 | "http_write_timeout": "1s", | ||
67 | 63 | }) | ||
68 | 64 | } | ||
69 | 65 | |||
70 | 66 | // WriteConfig writes out a config and returns the written filepath. | ||
71 | 67 | func WriteConfig(c *C, dir, filename string, cfg map[string]interface{}) string { | ||
72 | 68 | cfgFpath := filepath.Join(dir, filename) | ||
73 | 69 | cfgJson, err := json.Marshal(cfg) | ||
74 | 70 | if err != nil { | ||
75 | 71 | c.Fatal(err) | ||
76 | 72 | } | ||
77 | 73 | err = ioutil.WriteFile(cfgFpath, cfgJson, os.ModePerm) | ||
78 | 74 | if err != nil { | ||
79 | 75 | c.Fatal(err) | ||
80 | 76 | } | ||
81 | 77 | return cfgFpath | ||
82 | 78 | } | ||
83 | 79 | |||
84 | 80 | var rxLineInfo = regexp.MustCompile("^.*? ([[:alpha:]].*)\n") | ||
85 | 81 | |||
86 | 82 | // RunAndObserve runs cmdName and returns a channel that will receive | ||
87 | 83 | // cmdName stderr logging and a function to kill the process. | ||
88 | 84 | func RunAndObserve(c *C, cmdName string, arg ...string) (<-chan string, func()) { | ||
89 | 85 | cmd := exec.Command(cmdName, arg...) | ||
90 | 86 | stderr, err := cmd.StderrPipe() | ||
91 | 87 | if err != nil { | ||
92 | 88 | c.Fatal(err) | ||
93 | 89 | } | ||
94 | 90 | err = cmd.Start() | ||
95 | 91 | if err != nil { | ||
96 | 92 | c.Fatal(err) | ||
97 | 93 | } | ||
98 | 94 | bufErr := bufio.NewReaderSize(stderr, 5000) | ||
99 | 95 | getLineInfo := func() (string, error) { | ||
100 | 96 | for { | ||
101 | 97 | line, err := bufErr.ReadString('\n') | ||
102 | 98 | if err != nil { | ||
103 | 99 | return "", err | ||
104 | 100 | } | ||
105 | 101 | extracted := rxLineInfo.FindStringSubmatch(line) | ||
106 | 102 | if extracted == nil { | ||
107 | 103 | return "", fmt.Errorf("unexpected line: %#v", line) | ||
108 | 104 | } | ||
109 | 105 | info := extracted[1] | ||
110 | 106 | return info, nil | ||
111 | 107 | } | ||
112 | 108 | } | ||
113 | 109 | logs := make(chan string, 10) | ||
114 | 110 | go func() { | ||
115 | 111 | for { | ||
116 | 112 | info, err := getLineInfo() | ||
117 | 113 | if err != nil { | ||
118 | 114 | logs <- fmt.Sprintf("%s capture: %v", cmdName, err) | ||
119 | 115 | close(logs) | ||
120 | 116 | return | ||
121 | 117 | } | ||
122 | 118 | logs <- info | ||
123 | 119 | } | ||
124 | 120 | }() | ||
125 | 121 | return logs, func() { cmd.Process.Kill() } | ||
126 | 122 | } | ||
127 | 123 | |||
128 | 124 | const ( | ||
129 | 125 | DevListeningOnPat = "INFO listening for devices on " | ||
130 | 126 | HTTPListeningOnPat = "INFO listening for http on " | ||
131 | 127 | debugPrefix = "DEBUG " | ||
132 | 128 | ) | ||
133 | 129 | |||
134 | 130 | // ExtractListeningAddr goes over logs ignoring DEBUG lines | ||
135 | 131 | // until a line starting with pat and returns the rest of that line. | ||
136 | 132 | func ExtractListeningAddr(c *C, logs <-chan string, pat string) string { | ||
137 | 133 | for line := range logs { | ||
138 | 134 | if strings.HasPrefix(line, debugPrefix) { | ||
139 | 135 | continue | ||
140 | 136 | } | ||
141 | 137 | if !strings.HasPrefix(line, pat) { | ||
142 | 138 | c.Fatalf("matching %v: %v", pat, line) | ||
143 | 139 | } | ||
144 | 140 | return line[len(pat):] | ||
145 | 141 | } | ||
146 | 142 | panic(fmt.Errorf("logs closed unexpectedly marching %v", pat)) | ||
147 | 143 | } | ||
148 | 144 | |||
149 | 145 | // NextEvent receives an event from given string channel with a 5s timeout, | ||
150 | 146 | // or from a channel for errors. | ||
151 | 147 | func NextEvent(events <-chan string, errCh <-chan error) string { | ||
152 | 148 | select { | ||
153 | 149 | case <-time.After(5 * time.Second): | ||
154 | 150 | panic("too long stuck waiting for next event") | ||
155 | 151 | case err := <-errCh: | ||
156 | 152 | return err.Error() // will fail comparison typically | ||
157 | 153 | case evStr := <-events: | ||
158 | 154 | return evStr | ||
159 | 155 | } | ||
160 | 156 | } | ||
161 | 0 | 157 | ||
162 | === modified file 'server/acceptance/acceptance_test.go' | |||
163 | --- server/acceptance/acceptance_test.go 2014-02-10 23:50:29 +0000 | |||
164 | +++ server/acceptance/acceptance_test.go 2014-02-11 20:38:55 +0000 | |||
165 | @@ -17,7 +17,6 @@ | |||
166 | 17 | package acceptance | 17 | package acceptance |
167 | 18 | 18 | ||
168 | 19 | import ( | 19 | import ( |
169 | 20 | "bufio" | ||
170 | 21 | "bytes" | 20 | "bytes" |
171 | 22 | "encoding/json" | 21 | "encoding/json" |
172 | 23 | "flag" | 22 | "flag" |
173 | @@ -25,10 +24,6 @@ | |||
174 | 25 | "io/ioutil" | 24 | "io/ioutil" |
175 | 26 | "net" | 25 | "net" |
176 | 27 | "net/http" | 26 | "net/http" |
177 | 28 | "os" | ||
178 | 29 | "os/exec" | ||
179 | 30 | "path/filepath" | ||
180 | 31 | "regexp" | ||
181 | 32 | "runtime" | 27 | "runtime" |
182 | 33 | "strings" | 28 | "strings" |
183 | 34 | "testing" | 29 | "testing" |
184 | @@ -44,7 +39,7 @@ | |||
185 | 44 | func TestAcceptance(t *testing.T) { TestingT(t) } | 39 | func TestAcceptance(t *testing.T) { TestingT(t) } |
186 | 45 | 40 | ||
187 | 46 | type acceptanceSuite struct { | 41 | type acceptanceSuite struct { |
189 | 47 | server *exec.Cmd | 42 | serverKill func() |
190 | 48 | serverAddr string | 43 | serverAddr string |
191 | 49 | serverURL string | 44 | serverURL string |
192 | 50 | serverEvents <-chan string | 45 | serverEvents <-chan string |
193 | @@ -57,18 +52,9 @@ | |||
194 | 57 | var serverAuxCfg = flag.String("auxcfg", "", "auxiliary config for the server") | 52 | var serverAuxCfg = flag.String("auxcfg", "", "auxiliary config for the server") |
195 | 58 | 53 | ||
196 | 59 | func testServerConfig(addr, httpAddr string) map[string]interface{} { | 54 | func testServerConfig(addr, httpAddr string) map[string]interface{} { |
209 | 60 | cfg := map[string]interface{}{ | 55 | cfg := make(map[string]interface{}) |
210 | 61 | "exchange_timeout": "0.1s", | 56 | FillServerConfig(cfg, addr) |
211 | 62 | "ping_interval": "0.5s", | 57 | FillHTTPServerConfig(cfg, httpAddr) |
200 | 63 | "session_queue_size": 10, | ||
201 | 64 | "broker_queue_size": 100, | ||
202 | 65 | "addr": addr, | ||
203 | 66 | "key_pem_file": helpers.SourceRelative("config/testing.key"), | ||
204 | 67 | "cert_pem_file": helpers.SourceRelative("config/testing.cert"), | ||
205 | 68 | "http_addr": httpAddr, | ||
206 | 69 | "http_read_timeout": "1s", | ||
207 | 70 | "http_write_timeout": "1s", | ||
208 | 71 | } | ||
212 | 72 | return cfg | 58 | return cfg |
213 | 73 | } | 59 | } |
214 | 74 | 60 | ||
215 | @@ -86,109 +72,27 @@ | |||
216 | 86 | } | 72 | } |
217 | 87 | } | 73 | } |
218 | 88 | 74 | ||
219 | 89 | const ( | ||
220 | 90 | devListeningOnPat = "INFO listening for devices on " | ||
221 | 91 | httpListeningOnPat = "INFO listening for http on " | ||
222 | 92 | debugPrefix = "DEBUG " | ||
223 | 93 | ) | ||
224 | 94 | |||
225 | 95 | var rxLineInfo = regexp.MustCompile("^.*? ([[:alpha:]].*)\n") | ||
226 | 96 | |||
227 | 97 | func extractListeningAddr(c *C, pat, line string) string { | ||
228 | 98 | if !strings.HasPrefix(line, pat) { | ||
229 | 99 | c.Fatalf("server: %v", line) | ||
230 | 100 | } | ||
231 | 101 | return line[len(pat):] | ||
232 | 102 | } | ||
233 | 103 | |||
234 | 104 | // start a new server for each test | 75 | // start a new server for each test |
235 | 105 | func (s *acceptanceSuite) SetUpTest(c *C) { | 76 | func (s *acceptanceSuite) SetUpTest(c *C) { |
236 | 106 | if *serverCmd == "" { | 77 | if *serverCmd == "" { |
237 | 107 | c.Skip("executable server not specified") | 78 | c.Skip("executable server not specified") |
238 | 108 | } | 79 | } |
239 | 109 | tmpDir := c.MkDir() | 80 | tmpDir := c.MkDir() |
249 | 110 | cfgFilename := filepath.Join(tmpDir, "config.json") | 81 | cfg := testServerConfig("127.0.0.1:0", "127.0.0.1:0") |
250 | 111 | cfgJson, err := json.Marshal(testServerConfig("127.0.0.1:0", "127.0.0.1:0")) | 82 | cfgFilename := WriteConfig(c, tmpDir, "config.json", cfg) |
242 | 112 | if err != nil { | ||
243 | 113 | c.Fatal(err) | ||
244 | 114 | } | ||
245 | 115 | err = ioutil.WriteFile(cfgFilename, cfgJson, os.ModePerm) | ||
246 | 116 | if err != nil { | ||
247 | 117 | c.Fatal(err) | ||
248 | 118 | } | ||
251 | 119 | cfgs := append(strings.Fields(*serverAuxCfg), cfgFilename) | 83 | cfgs := append(strings.Fields(*serverAuxCfg), cfgFilename) |
285 | 120 | server := exec.Command(*serverCmd, cfgs...) | 84 | serverEvents, killServer := RunAndObserve(c, *serverCmd, cfgs...) |
286 | 121 | stderr, err := server.StderrPipe() | 85 | s.serverKill = killServer |
287 | 122 | if err != nil { | 86 | serverHTTPAddr := ExtractListeningAddr(c, serverEvents, HTTPListeningOnPat) |
255 | 123 | c.Fatal(err) | ||
256 | 124 | } | ||
257 | 125 | err = server.Start() | ||
258 | 126 | if err != nil { | ||
259 | 127 | c.Fatal(err) | ||
260 | 128 | } | ||
261 | 129 | bufErr := bufio.NewReaderSize(stderr, 5000) | ||
262 | 130 | getLineInfo := func(ignoreDebug bool) (string, error) { | ||
263 | 131 | for { | ||
264 | 132 | line, err := bufErr.ReadString('\n') | ||
265 | 133 | if err != nil { | ||
266 | 134 | return "", err | ||
267 | 135 | } | ||
268 | 136 | extracted := rxLineInfo.FindStringSubmatch(line) | ||
269 | 137 | if extracted == nil { | ||
270 | 138 | return "", fmt.Errorf("unexpected server line: %#v", line) | ||
271 | 139 | } | ||
272 | 140 | info := extracted[1] | ||
273 | 141 | if ignoreDebug && strings.HasPrefix(info, debugPrefix) { | ||
274 | 142 | // don't report DEBUG lines | ||
275 | 143 | continue | ||
276 | 144 | } | ||
277 | 145 | return info, nil | ||
278 | 146 | } | ||
279 | 147 | } | ||
280 | 148 | infoHTTP, err := getLineInfo(true) | ||
281 | 149 | if err != nil { | ||
282 | 150 | c.Fatal(err) | ||
283 | 151 | } | ||
284 | 152 | serverHTTPAddr := extractListeningAddr(c, httpListeningOnPat, infoHTTP) | ||
288 | 153 | s.serverURL = fmt.Sprintf("http://%s", serverHTTPAddr) | 87 | s.serverURL = fmt.Sprintf("http://%s", serverHTTPAddr) |
296 | 154 | info, err := getLineInfo(true) | 88 | s.serverAddr = ExtractListeningAddr(c, serverEvents, DevListeningOnPat) |
290 | 155 | if err != nil { | ||
291 | 156 | c.Fatal(err) | ||
292 | 157 | } | ||
293 | 158 | s.serverAddr = extractListeningAddr(c, devListeningOnPat, info) | ||
294 | 159 | s.server = server | ||
295 | 160 | serverEvents := make(chan string, 5) | ||
297 | 161 | s.serverEvents = serverEvents | 89 | s.serverEvents = serverEvents |
298 | 162 | go func() { | ||
299 | 163 | for { | ||
300 | 164 | info, err := getLineInfo(false) | ||
301 | 165 | if err != nil { | ||
302 | 166 | serverEvents <- fmt.Sprintf("ERROR: %v", err) | ||
303 | 167 | close(serverEvents) | ||
304 | 168 | return | ||
305 | 169 | } | ||
306 | 170 | serverEvents <- info | ||
307 | 171 | } | ||
308 | 172 | }() | ||
309 | 173 | s.httpClient = &http.Client{} | 90 | s.httpClient = &http.Client{} |
310 | 174 | } | 91 | } |
311 | 175 | 92 | ||
312 | 176 | func (s *acceptanceSuite) TearDownTest(c *C) { | 93 | func (s *acceptanceSuite) TearDownTest(c *C) { |
328 | 177 | if s.server != nil { | 94 | if s.serverKill != nil { |
329 | 178 | s.server.Process.Kill() | 95 | s.serverKill() |
315 | 179 | s.server = nil | ||
316 | 180 | } | ||
317 | 181 | } | ||
318 | 182 | |||
319 | 183 | // nextEvent receives an event from given channel with a 5s timeout | ||
320 | 184 | func nextEvent(events <-chan string, errCh <-chan error) string { | ||
321 | 185 | select { | ||
322 | 186 | case <-time.After(5 * time.Second): | ||
323 | 187 | panic("too long stuck waiting for next event") | ||
324 | 188 | case err := <-errCh: | ||
325 | 189 | return err.Error() // will fail comparison typically | ||
326 | 190 | case evStr := <-events: | ||
327 | 191 | return evStr | ||
330 | 192 | } | 96 | } |
331 | 193 | } | 97 | } |
332 | 194 | 98 | ||
333 | @@ -256,19 +160,19 @@ | |||
334 | 256 | go func() { | 160 | go func() { |
335 | 257 | errCh <- sess.Run(events) | 161 | errCh <- sess.Run(events) |
336 | 258 | }() | 162 | }() |
340 | 259 | connectCli := nextEvent(events, errCh) | 163 | connectCli := NextEvent(events, errCh) |
341 | 260 | connectSrv := nextEvent(s.serverEvents, nil) | 164 | connectSrv := NextEvent(s.serverEvents, nil) |
342 | 261 | registeredSrv := nextEvent(s.serverEvents, nil) | 165 | registeredSrv := NextEvent(s.serverEvents, nil) |
343 | 262 | tconnect := time.Now() | 166 | tconnect := time.Now() |
344 | 263 | c.Assert(connectSrv, Matches, ".*session.* connected .*") | 167 | c.Assert(connectSrv, Matches, ".*session.* connected .*") |
345 | 264 | c.Assert(registeredSrv, Matches, ".*session.* registered DEVA") | 168 | c.Assert(registeredSrv, Matches, ".*session.* registered DEVA") |
346 | 265 | c.Assert(strings.HasSuffix(connectSrv, connectCli), Equals, true) | 169 | c.Assert(strings.HasSuffix(connectSrv, connectCli), Equals, true) |
348 | 266 | c.Assert(nextEvent(events, errCh), Equals, "Ping") | 170 | c.Assert(NextEvent(events, errCh), Equals, "Ping") |
349 | 267 | elapsedOfPing := float64(time.Since(tconnect)) / float64(500*time.Millisecond) | 171 | elapsedOfPing := float64(time.Since(tconnect)) / float64(500*time.Millisecond) |
350 | 268 | c.Check(elapsedOfPing >= 1.0, Equals, true) | 172 | c.Check(elapsedOfPing >= 1.0, Equals, true) |
351 | 269 | c.Check(elapsedOfPing < 1.05, Equals, true) | 173 | c.Check(elapsedOfPing < 1.05, Equals, true) |
354 | 270 | c.Assert(nextEvent(events, errCh), Equals, "Ping") | 174 | c.Assert(NextEvent(events, errCh), Equals, "Ping") |
355 | 271 | c.Assert(nextEvent(s.serverEvents, nil), Matches, ".*session.* ended with: EOF") | 175 | c.Assert(NextEvent(s.serverEvents, nil), Matches, ".*session.* ended with: EOF") |
356 | 272 | c.Check(len(errCh), Equals, 0) | 176 | c.Check(len(errCh), Equals, 0) |
357 | 273 | } | 177 | } |
358 | 274 | 178 | ||
359 | @@ -291,11 +195,11 @@ | |||
360 | 291 | go func() { | 195 | go func() { |
361 | 292 | errCh <- sess.Run(events) | 196 | errCh <- sess.Run(events) |
362 | 293 | }() | 197 | }() |
368 | 294 | c.Assert(nextEvent(events, errCh), Matches, "connected .*") | 198 | c.Assert(NextEvent(events, errCh), Matches, "connected .*") |
369 | 295 | c.Assert(nextEvent(s.serverEvents, nil), Matches, ".*session.* connected .*") | 199 | c.Assert(NextEvent(s.serverEvents, nil), Matches, ".*session.* connected .*") |
370 | 296 | c.Assert(nextEvent(s.serverEvents, nil), Matches, ".*session.* registered .*") | 200 | c.Assert(NextEvent(s.serverEvents, nil), Matches, ".*session.* registered .*") |
371 | 297 | c.Assert(nextEvent(events, errCh), Equals, "Ping") | 201 | c.Assert(NextEvent(events, errCh), Equals, "Ping") |
372 | 298 | c.Assert(nextEvent(s.serverEvents, nil), Matches, `.* ended with:.*timeout`) | 202 | c.Assert(NextEvent(s.serverEvents, nil), Matches, `.* ended with:.*timeout`) |
373 | 299 | c.Check(len(errCh), Equals, 0) | 203 | c.Check(len(errCh), Equals, 0) |
374 | 300 | } | 204 | } |
375 | 301 | 205 | ||
376 | @@ -335,9 +239,9 @@ | |||
377 | 335 | go func() { | 239 | go func() { |
378 | 336 | errCh <- sess.Run(events) | 240 | errCh <- sess.Run(events) |
379 | 337 | }() | 241 | }() |
383 | 338 | c.Assert(nextEvent(events, errCh), Matches, "connected .*") | 242 | c.Assert(NextEvent(events, errCh), Matches, "connected .*") |
384 | 339 | c.Assert(nextEvent(s.serverEvents, nil), Matches, ".*session.* connected .*") | 243 | c.Assert(NextEvent(s.serverEvents, nil), Matches, ".*session.* connected .*") |
385 | 340 | c.Assert(nextEvent(s.serverEvents, nil), Matches, ".*session.* registered "+devId) | 244 | c.Assert(NextEvent(s.serverEvents, nil), Matches, ".*session.* registered "+devId) |
386 | 341 | return events, errCh | 245 | return events, errCh |
387 | 342 | } | 246 | } |
388 | 343 | 247 | ||
389 | @@ -359,9 +263,9 @@ | |||
390 | 359 | }) | 263 | }) |
391 | 360 | c.Assert(err, IsNil) | 264 | c.Assert(err, IsNil) |
392 | 361 | c.Assert(got, Matches, ".*ok.*") | 265 | c.Assert(got, Matches, ".*ok.*") |
394 | 362 | c.Check(nextEvent(events, errCh), Equals, `broadcast chan:0 app: topLevel:1 payloads:[{"n":42}]`) | 266 | c.Check(NextEvent(events, errCh), Equals, `broadcast chan:0 app: topLevel:1 payloads:[{"n":42}]`) |
395 | 363 | clientShutdown <- true | 267 | clientShutdown <- true |
397 | 364 | c.Assert(nextEvent(s.serverEvents, nil), Matches, `.* ended with:.*EOF`) | 268 | c.Assert(NextEvent(s.serverEvents, nil), Matches, `.* ended with:.*EOF`) |
398 | 365 | c.Check(len(errCh), Equals, 0) | 269 | c.Check(len(errCh), Equals, 0) |
399 | 366 | } | 270 | } |
400 | 367 | 271 | ||
401 | @@ -386,9 +290,9 @@ | |||
402 | 386 | } | 290 | } |
403 | 387 | events, errCh := s.startClient(c, "DEVB", intercept, nil) | 291 | events, errCh := s.startClient(c, "DEVB", intercept, nil) |
404 | 388 | // gettting pending on connect | 292 | // gettting pending on connect |
406 | 389 | c.Check(nextEvent(events, errCh), Equals, `broadcast chan:0 app: topLevel:1 payloads:[{"b":1}]`) | 293 | c.Check(NextEvent(events, errCh), Equals, `broadcast chan:0 app: topLevel:1 payloads:[{"b":1}]`) |
407 | 390 | clientShutdown <- true | 294 | clientShutdown <- true |
409 | 391 | c.Assert(nextEvent(s.serverEvents, nil), Matches, `.* ended with:.*EOF`) | 295 | c.Assert(NextEvent(s.serverEvents, nil), Matches, `.* ended with:.*EOF`) |
410 | 392 | c.Check(len(errCh), Equals, 0) | 296 | c.Check(len(errCh), Equals, 0) |
411 | 393 | } | 297 | } |
412 | 394 | 298 | ||
413 | @@ -416,10 +320,10 @@ | |||
414 | 416 | } | 320 | } |
415 | 417 | events, errCh := s.startClient(c, "DEVC", intercept, nil) | 321 | events, errCh := s.startClient(c, "DEVC", intercept, nil) |
416 | 418 | // gettting pending on connect | 322 | // gettting pending on connect |
419 | 419 | c.Check(nextEvent(events, errCh), Matches, `broadcast chan:0 app: topLevel:30 payloads:\[{"b":0,.*`) | 323 | c.Check(NextEvent(events, errCh), Matches, `broadcast chan:0 app: topLevel:30 payloads:\[{"b":0,.*`) |
420 | 420 | c.Check(nextEvent(events, errCh), Matches, `broadcast chan:0 app: topLevel:32 payloads:\[.*`) | 324 | c.Check(NextEvent(events, errCh), Matches, `broadcast chan:0 app: topLevel:32 payloads:\[.*`) |
421 | 421 | clientShutdown <- true | 325 | clientShutdown <- true |
423 | 422 | c.Assert(nextEvent(s.serverEvents, nil), Matches, `.* ended with:.*EOF`) | 326 | c.Assert(NextEvent(s.serverEvents, nil), Matches, `.* ended with:.*EOF`) |
424 | 423 | c.Check(len(errCh), Equals, 0) | 327 | c.Check(len(errCh), Equals, 0) |
425 | 424 | } | 328 | } |
426 | 425 | 329 | ||
427 | @@ -445,11 +349,11 @@ | |||
428 | 445 | }) | 349 | }) |
429 | 446 | c.Assert(err, IsNil) | 350 | c.Assert(err, IsNil) |
430 | 447 | c.Assert(got, Matches, ".*ok.*") | 351 | c.Assert(got, Matches, ".*ok.*") |
433 | 448 | c.Check(nextEvent(events1, errCh1), Equals, `broadcast chan:0 app: topLevel:1 payloads:[{"n":42}]`) | 352 | c.Check(NextEvent(events1, errCh1), Equals, `broadcast chan:0 app: topLevel:1 payloads:[{"n":42}]`) |
434 | 449 | c.Check(nextEvent(events2, errCh2), Equals, `broadcast chan:0 app: topLevel:1 payloads:[{"n":42}]`) | 353 | c.Check(NextEvent(events2, errCh2), Equals, `broadcast chan:0 app: topLevel:1 payloads:[{"n":42}]`) |
435 | 450 | clientShutdown <- true | 354 | clientShutdown <- true |
438 | 451 | c.Assert(nextEvent(s.serverEvents, nil), Matches, `.* ended with:.*EOF`) | 355 | c.Assert(NextEvent(s.serverEvents, nil), Matches, `.* ended with:.*EOF`) |
439 | 452 | c.Assert(nextEvent(s.serverEvents, nil), Matches, `.* ended with:.*EOF`) | 356 | c.Assert(NextEvent(s.serverEvents, nil), Matches, `.* ended with:.*EOF`) |
440 | 453 | c.Check(len(errCh1), Equals, 0) | 357 | c.Check(len(errCh1), Equals, 0) |
441 | 454 | c.Check(len(errCh2), Equals, 0) | 358 | c.Check(len(errCh2), Equals, 0) |
442 | 455 | } | 359 | } |
443 | @@ -472,9 +376,9 @@ | |||
444 | 472 | }) | 376 | }) |
445 | 473 | c.Assert(err, IsNil) | 377 | c.Assert(err, IsNil) |
446 | 474 | c.Assert(got, Matches, ".*ok.*") | 378 | c.Assert(got, Matches, ".*ok.*") |
448 | 475 | c.Check(nextEvent(events, errCh), Equals, `broadcast chan:0 app: topLevel:1 payloads:[{"b":1}]`) | 379 | c.Check(NextEvent(events, errCh), Equals, `broadcast chan:0 app: topLevel:1 payloads:[{"b":1}]`) |
449 | 476 | clientShutdown <- true | 380 | clientShutdown <- true |
451 | 477 | c.Assert(nextEvent(s.serverEvents, nil), Matches, `.* ended with:.*EOF`) | 381 | c.Assert(NextEvent(s.serverEvents, nil), Matches, `.* ended with:.*EOF`) |
452 | 478 | c.Check(len(errCh), Equals, 0) | 382 | c.Check(len(errCh), Equals, 0) |
453 | 479 | // another broadcast | 383 | // another broadcast |
454 | 480 | got, err = s.postRequest("/broadcast", &api.Broadcast{ | 384 | got, err = s.postRequest("/broadcast", &api.Broadcast{ |
455 | @@ -489,9 +393,9 @@ | |||
456 | 489 | events, errCh = s.startClient(c, "DEVD", intercept, map[string]int64{ | 393 | events, errCh = s.startClient(c, "DEVD", intercept, map[string]int64{ |
457 | 490 | protocol.SystemChannelId: 1, | 394 | protocol.SystemChannelId: 1, |
458 | 491 | }) | 395 | }) |
460 | 492 | c.Check(nextEvent(events, errCh), Equals, `broadcast chan:0 app: topLevel:2 payloads:[{"b":2}]`) | 396 | c.Check(NextEvent(events, errCh), Equals, `broadcast chan:0 app: topLevel:2 payloads:[{"b":2}]`) |
461 | 493 | clientShutdown <- true | 397 | clientShutdown <- true |
463 | 494 | c.Assert(nextEvent(s.serverEvents, nil), Matches, `.* ended with:.*EOF`) | 398 | c.Assert(NextEvent(s.serverEvents, nil), Matches, `.* ended with:.*EOF`) |
464 | 495 | c.Check(len(errCh), Equals, 0) | 399 | c.Check(len(errCh), Equals, 0) |
465 | 496 | } | 400 | } |
466 | 497 | 401 | ||
467 | @@ -525,9 +429,9 @@ | |||
468 | 525 | protocol.SystemChannelId: 10, | 429 | protocol.SystemChannelId: 10, |
469 | 526 | }) | 430 | }) |
470 | 527 | // gettting last one pending on connect | 431 | // gettting last one pending on connect |
472 | 528 | c.Check(nextEvent(events, errCh), Equals, `broadcast chan:0 app: topLevel:2 payloads:[{"b":2}]`) | 432 | c.Check(NextEvent(events, errCh), Equals, `broadcast chan:0 app: topLevel:2 payloads:[{"b":2}]`) |
473 | 529 | clientShutdown <- true | 433 | clientShutdown <- true |
475 | 530 | c.Assert(nextEvent(s.serverEvents, nil), Matches, `.* ended with:.*EOF`) | 434 | c.Assert(NextEvent(s.serverEvents, nil), Matches, `.* ended with:.*EOF`) |
476 | 531 | c.Check(len(errCh), Equals, 0) | 435 | c.Check(len(errCh), Equals, 0) |
477 | 532 | } | 436 | } |
478 | 533 | 437 | ||
479 | @@ -546,9 +450,9 @@ | |||
480 | 546 | protocol.SystemChannelId: 10, | 450 | protocol.SystemChannelId: 10, |
481 | 547 | }) | 451 | }) |
482 | 548 | // gettting empty pending on connect | 452 | // gettting empty pending on connect |
484 | 549 | c.Check(nextEvent(events, errCh), Equals, `broadcast chan:0 app: topLevel:0 payloads:null`) | 453 | c.Check(NextEvent(events, errCh), Equals, `broadcast chan:0 app: topLevel:0 payloads:null`) |
485 | 550 | clientShutdown <- true | 454 | clientShutdown <- true |
487 | 551 | c.Assert(nextEvent(s.serverEvents, nil), Matches, `.* ended with:.*EOF`) | 455 | c.Assert(NextEvent(s.serverEvents, nil), Matches, `.* ended with:.*EOF`) |
488 | 552 | c.Check(len(errCh), Equals, 0) | 456 | c.Check(len(errCh), Equals, 0) |
489 | 553 | } | 457 | } |
490 | 554 | 458 | ||
491 | @@ -582,8 +486,8 @@ | |||
492 | 582 | protocol.SystemChannelId: -10, | 486 | protocol.SystemChannelId: -10, |
493 | 583 | }) | 487 | }) |
494 | 584 | // gettting pending on connect | 488 | // gettting pending on connect |
496 | 585 | c.Check(nextEvent(events, errCh), Equals, `broadcast chan:0 app: topLevel:2 payloads:[{"b":1},{"b":2}]`) | 489 | c.Check(NextEvent(events, errCh), Equals, `broadcast chan:0 app: topLevel:2 payloads:[{"b":1},{"b":2}]`) |
497 | 586 | clientShutdown <- true | 490 | clientShutdown <- true |
499 | 587 | c.Assert(nextEvent(s.serverEvents, nil), Matches, `.* ended with:.*EOF`) | 491 | c.Assert(NextEvent(s.serverEvents, nil), Matches, `.* ended with:.*EOF`) |
500 | 588 | c.Check(len(errCh), Equals, 0) | 492 | c.Check(len(errCh), Equals, 0) |
501 | 589 | } | 493 | } |