← Back to branch summary

~ubuntu-branches/ubuntu/saucy/juju-core/saucy-proposed

« back to all changes in this revision

Viewing changes to src/code.google.com/p/go.net/spdy/spdy_test.go

  • Committer: Package Import Robot
  • Author(s): James Page
  • Date: 2013-07-11 17:18:27 UTC
  • mfrom: (1.1.1)
  • Revision ID: package-import@ubuntu.com-20130711171827-vjqkg40r0dlf7ys2
Tags: 1.11.2-0ubuntu1
https://launchpad.net/bugs/1190634
https://launchpad.net/bugs/1172505
* New upstream release.
* Make juju-core the default juju (LP: #1190634):
  - d/control: Add virtual package juju -> juju-core.
  - d/juju-core.postinst.in: Bump priority of alternatives over that of
    python juju packages.
* Enable for all architectures (LP: #1172505):
  - d/control: Version BD on golang-go to >= 2:1.1.1 to ensure CGO
    support for non-x86 archs, make juju-core Arch: any.
  - d/README.source: Dropped - no longer required.
* d/watch: Updated for new upstream tarball naming.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/code.google.com/p/go.net/spdy/spdy_test.go
15
15
        "testing"
16
16
)
17
17
 
 
18
var HeadersFixture = http.Header{
 
19
        "Url":     []string{"http://www.google.com/"},
 
20
        "Method":  []string{"get"},
 
21
        "Version": []string{"http/1.1"},
 
22
}
 
23
 
18
24
func TestHeaderParsing(t *testing.T) {
19
 
        headers := http.Header{
20
 
                "Url":     []string{"http://www.google.com/"},
21
 
                "Method":  []string{"get"},
22
 
                "Version": []string{"http/1.1"},
23
 
        }
24
25
        var headerValueBlockBuf bytes.Buffer
25
 
        writeHeaderValueBlock(&headerValueBlockBuf, headers)
26
 
 
 
26
        writeHeaderValueBlock(&headerValueBlockBuf, HeadersFixture)
27
27
        const bogusStreamId = 1
28
28
        newHeaders, err := parseHeaderValueBlock(&headerValueBlockBuf, bogusStreamId)
29
29
        if err != nil {
30
30
                t.Fatal("parseHeaderValueBlock:", err)
31
31
        }
32
 
 
33
 
        if !reflect.DeepEqual(headers, newHeaders) {
34
 
                t.Fatal("got: ", newHeaders, "\nwant: ", headers)
 
32
        if !reflect.DeepEqual(HeadersFixture, newHeaders) {
 
33
                t.Fatal("got: ", newHeaders, "\nwant: ", HeadersFixture)
35
34
        }
36
35
}
37
36
 
38
 
func TestCreateParseSynStreamFrame(t *testing.T) {
 
37
func TestCreateParseSynStreamFrameCompressionDisable(t *testing.T) {
39
38
        buffer := new(bytes.Buffer)
 
39
        // Fixture framer for no compression test.
40
40
        framer := &Framer{
41
41
                headerCompressionDisabled: true,
42
42
                w:         buffer,
49
49
                        frameType: TypeSynStream,
50
50
                },
51
51
                StreamId: 2,
52
 
                Headers: http.Header{
53
 
                        "Url":     []string{"http://www.google.com/"},
54
 
                        "Method":  []string{"get"},
55
 
                        "Version": []string{"http/1.1"},
56
 
                },
 
52
                Headers:  HeadersFixture,
57
53
        }
58
54
        if err := framer.WriteFrame(&synStreamFrame); err != nil {
59
55
                t.Fatal("WriteFrame without compression:", err)
69
65
        if !reflect.DeepEqual(synStreamFrame, *parsedSynStreamFrame) {
70
66
                t.Fatal("got: ", *parsedSynStreamFrame, "\nwant: ", synStreamFrame)
71
67
        }
 
68
}
72
69
 
73
 
        // Test again with compression
74
 
        buffer.Reset()
75
 
        framer, err = NewFramer(buffer, buffer)
 
70
func TestCreateParseSynStreamFrameCompressionEnable(t *testing.T) {
 
71
        buffer := new(bytes.Buffer)
 
72
        framer, err := NewFramer(buffer, buffer)
 
73
        synStreamFrame := SynStreamFrame{
 
74
                CFHeader: ControlFrameHeader{
 
75
                        version:   Version,
 
76
                        frameType: TypeSynStream,
 
77
                },
 
78
                StreamId: 2,
 
79
                Headers:  HeadersFixture,
 
80
        }
76
81
        if err != nil {
77
82
                t.Fatal("Failed to create new framer:", err)
78
83
        }
79
84
        if err := framer.WriteFrame(&synStreamFrame); err != nil {
80
85
                t.Fatal("WriteFrame with compression:", err)
81
86
        }
82
 
        frame, err = framer.ReadFrame()
 
87
        frame, err := framer.ReadFrame()
83
88
        if err != nil {
84
89
                t.Fatal("ReadFrame with compression:", err)
85
90
        }
86
 
        parsedSynStreamFrame, ok = frame.(*SynStreamFrame)
 
91
        parsedSynStreamFrame, ok := frame.(*SynStreamFrame)
87
92
        if !ok {
88
93
                t.Fatal("Parsed incorrect frame type:", frame)
89
94
        }
92
97
        }
93
98
}
94
99
 
95
 
func TestCreateParseSynReplyFrame(t *testing.T) {
 
100
func TestCreateParseSynReplyFrameCompressionDisable(t *testing.T) {
96
101
        buffer := new(bytes.Buffer)
97
102
        framer := &Framer{
98
103
                headerCompressionDisabled: true,
106
111
                        frameType: TypeSynReply,
107
112
                },
108
113
                StreamId: 2,
109
 
                Headers: http.Header{
110
 
                        "Url":     []string{"http://www.google.com/"},
111
 
                        "Method":  []string{"get"},
112
 
                        "Version": []string{"http/1.1"},
113
 
                },
 
114
                Headers:  HeadersFixture,
114
115
        }
115
116
        if err := framer.WriteFrame(&synReplyFrame); err != nil {
116
117
                t.Fatal("WriteFrame without compression:", err)
126
127
        if !reflect.DeepEqual(synReplyFrame, *parsedSynReplyFrame) {
127
128
                t.Fatal("got: ", *parsedSynReplyFrame, "\nwant: ", synReplyFrame)
128
129
        }
 
130
}
129
131
 
130
 
        // Test again with compression
131
 
        buffer.Reset()
132
 
        framer, err = NewFramer(buffer, buffer)
 
132
func TestCreateParseSynReplyFrameCompressionEnable(t *testing.T) {
 
133
        buffer := new(bytes.Buffer)
 
134
        framer, err := NewFramer(buffer, buffer)
 
135
        synReplyFrame := SynReplyFrame{
 
136
                CFHeader: ControlFrameHeader{
 
137
                        version:   Version,
 
138
                        frameType: TypeSynReply,
 
139
                },
 
140
                StreamId: 2,
 
141
                Headers:  HeadersFixture,
 
142
        }
133
143
        if err != nil {
134
144
                t.Fatal("Failed to create new framer:", err)
135
145
        }
136
146
        if err := framer.WriteFrame(&synReplyFrame); err != nil {
137
147
                t.Fatal("WriteFrame with compression:", err)
138
148
        }
139
 
        frame, err = framer.ReadFrame()
 
149
        frame, err := framer.ReadFrame()
140
150
        if err != nil {
141
151
                t.Fatal("ReadFrame with compression:", err)
142
152
        }
143
 
        parsedSynReplyFrame, ok = frame.(*SynReplyFrame)
 
153
        parsedSynReplyFrame, ok := frame.(*SynReplyFrame)
144
154
        if !ok {
145
155
                t.Fatal("Parsed incorrect frame type:", frame)
146
156
        }
211
221
        }
212
222
}
213
223
 
214
 
func TestCreateParseNoop(t *testing.T) {
215
 
        buffer := new(bytes.Buffer)
216
 
        framer, err := NewFramer(buffer, buffer)
217
 
        if err != nil {
218
 
                t.Fatal("Failed to create new framer:", err)
219
 
        }
220
 
        noopFrame := NoopFrame{
221
 
                CFHeader: ControlFrameHeader{
222
 
                        version:   Version,
223
 
                        frameType: TypeNoop,
224
 
                },
225
 
        }
226
 
        if err := framer.WriteFrame(&noopFrame); err != nil {
227
 
                t.Fatal("WriteFrame:", err)
228
 
        }
229
 
        frame, err := framer.ReadFrame()
230
 
        if err != nil {
231
 
                t.Fatal("ReadFrame:", err)
232
 
        }
233
 
        parsedNoopFrame, ok := frame.(*NoopFrame)
234
 
        if !ok {
235
 
                t.Fatal("Parsed incorrect frame type:", frame)
236
 
        }
237
 
        if !reflect.DeepEqual(noopFrame, *parsedNoopFrame) {
238
 
                t.Fatal("got: ", *parsedNoopFrame, "\nwant: ", noopFrame)
239
 
        }
240
 
}
241
 
 
242
224
func TestCreateParsePing(t *testing.T) {
243
225
        buffer := new(bytes.Buffer)
244
226
        framer, err := NewFramer(buffer, buffer)
255
237
        if err := framer.WriteFrame(&pingFrame); err != nil {
256
238
                t.Fatal("WriteFrame:", err)
257
239
        }
 
240
        if pingFrame.CFHeader.Flags != 0 {
 
241
                t.Fatal("Incorrect frame type:", pingFrame)
 
242
        }
258
243
        frame, err := framer.ReadFrame()
259
244
        if err != nil {
260
245
                t.Fatal("ReadFrame:", err)
263
248
        if !ok {
264
249
                t.Fatal("Parsed incorrect frame type:", frame)
265
250
        }
 
251
        if parsedPingFrame.CFHeader.Flags != 0 {
 
252
                t.Fatal("Parsed incorrect frame type:", parsedPingFrame)
 
253
        }
266
254
        if !reflect.DeepEqual(pingFrame, *parsedPingFrame) {
267
255
                t.Fatal("got: ", *parsedPingFrame, "\nwant: ", pingFrame)
268
256
        }
280
268
                        frameType: TypeGoAway,
281
269
                },
282
270
                LastGoodStreamId: 31337,
 
271
                Status:           1,
283
272
        }
284
273
        if err := framer.WriteFrame(&goAwayFrame); err != nil {
285
274
                t.Fatal("WriteFrame:", err)
286
275
        }
 
276
        if goAwayFrame.CFHeader.Flags != 0 {
 
277
                t.Fatal("Incorrect frame type:", goAwayFrame)
 
278
        }
 
279
        if goAwayFrame.CFHeader.length != 8 {
 
280
                t.Fatal("Incorrect frame type:", goAwayFrame)
 
281
        }
287
282
        frame, err := framer.ReadFrame()
288
283
        if err != nil {
289
284
                t.Fatal("ReadFrame:", err)
292
287
        if !ok {
293
288
                t.Fatal("Parsed incorrect frame type:", frame)
294
289
        }
 
290
        if parsedGoAwayFrame.CFHeader.Flags != 0 {
 
291
                t.Fatal("Incorrect frame type:", parsedGoAwayFrame)
 
292
        }
 
293
        if parsedGoAwayFrame.CFHeader.length != 8 {
 
294
                t.Fatal("Incorrect frame type:", parsedGoAwayFrame)
 
295
        }
295
296
        if !reflect.DeepEqual(goAwayFrame, *parsedGoAwayFrame) {
296
297
                t.Fatal("got: ", *parsedGoAwayFrame, "\nwant: ", goAwayFrame)
297
298
        }
312
313
                },
313
314
                StreamId: 2,
314
315
        }
315
 
        headersFrame.Headers = http.Header{
316
 
                "Url":     []string{"http://www.google.com/"},
317
 
                "Method":  []string{"get"},
318
 
                "Version": []string{"http/1.1"},
319
 
        }
 
316
        headersFrame.Headers = HeadersFixture
320
317
        if err := framer.WriteFrame(&headersFrame); err != nil {
321
318
                t.Fatal("WriteFrame without compression:", err)
322
319
        }
331
328
        if !reflect.DeepEqual(headersFrame, *parsedHeadersFrame) {
332
329
                t.Fatal("got: ", *parsedHeadersFrame, "\nwant: ", headersFrame)
333
330
        }
334
 
 
335
 
        // Test again with compression
336
 
        buffer.Reset()
337
 
        framer, err = NewFramer(buffer, buffer)
 
331
}
 
332
 
 
333
func TestCreateParseHeadersFrameCompressionEnable(t *testing.T) {
 
334
        buffer := new(bytes.Buffer)
 
335
        headersFrame := HeadersFrame{
 
336
                CFHeader: ControlFrameHeader{
 
337
                        version:   Version,
 
338
                        frameType: TypeHeaders,
 
339
                },
 
340
                StreamId: 2,
 
341
        }
 
342
        headersFrame.Headers = HeadersFixture
 
343
 
 
344
        framer, err := NewFramer(buffer, buffer)
338
345
        if err := framer.WriteFrame(&headersFrame); err != nil {
339
346
                t.Fatal("WriteFrame with compression:", err)
340
347
        }
341
 
        frame, err = framer.ReadFrame()
 
348
        frame, err := framer.ReadFrame()
342
349
        if err != nil {
343
350
                t.Fatal("ReadFrame with compression:", err)
344
351
        }
345
 
        parsedHeadersFrame, ok = frame.(*HeadersFrame)
 
352
        parsedHeadersFrame, ok := frame.(*HeadersFrame)
346
353
        if !ok {
347
354
                t.Fatal("Parsed incorrect frame type:", frame)
348
355
        }
351
358
        }
352
359
}
353
360
 
 
361
func TestCreateParseWindowUpdateFrame(t *testing.T) {
 
362
        buffer := new(bytes.Buffer)
 
363
        framer, err := NewFramer(buffer, buffer)
 
364
        if err != nil {
 
365
                t.Fatal("Failed to create new framer:", err)
 
366
        }
 
367
        windowUpdateFrame := WindowUpdateFrame{
 
368
                CFHeader: ControlFrameHeader{
 
369
                        version:   Version,
 
370
                        frameType: TypeWindowUpdate,
 
371
                },
 
372
                StreamId:        31337,
 
373
                DeltaWindowSize: 1,
 
374
        }
 
375
        if err := framer.WriteFrame(&windowUpdateFrame); err != nil {
 
376
                t.Fatal("WriteFrame:", err)
 
377
        }
 
378
        if windowUpdateFrame.CFHeader.Flags != 0 {
 
379
                t.Fatal("Incorrect frame type:", windowUpdateFrame)
 
380
        }
 
381
        if windowUpdateFrame.CFHeader.length != 8 {
 
382
                t.Fatal("Incorrect frame type:", windowUpdateFrame)
 
383
        }
 
384
        frame, err := framer.ReadFrame()
 
385
        if err != nil {
 
386
                t.Fatal("ReadFrame:", err)
 
387
        }
 
388
        parsedWindowUpdateFrame, ok := frame.(*WindowUpdateFrame)
 
389
        if !ok {
 
390
                t.Fatal("Parsed incorrect frame type:", frame)
 
391
        }
 
392
        if parsedWindowUpdateFrame.CFHeader.Flags != 0 {
 
393
                t.Fatal("Incorrect frame type:", parsedWindowUpdateFrame)
 
394
        }
 
395
        if parsedWindowUpdateFrame.CFHeader.length != 8 {
 
396
                t.Fatal("Incorrect frame type:", parsedWindowUpdateFrame)
 
397
        }
 
398
        if !reflect.DeepEqual(windowUpdateFrame, *parsedWindowUpdateFrame) {
 
399
                t.Fatal("got: ", *parsedWindowUpdateFrame, "\nwant: ", windowUpdateFrame)
 
400
        }
 
401
}
 
402
 
354
403
func TestCreateParseDataFrame(t *testing.T) {
355
404
        buffer := new(bytes.Buffer)
356
405
        framer, err := NewFramer(buffer, buffer)
389
438
                        frameType: TypeHeaders,
390
439
                },
391
440
                StreamId: 2,
392
 
                Headers: http.Header{
393
 
                        "Url":     []string{"http://www.google.com/"},
394
 
                        "Method":  []string{"get"},
395
 
                        "Version": []string{"http/1.1"},
396
 
                },
 
441
                Headers:  HeadersFixture,
397
442
        }
398
443
        if err := framer.WriteFrame(&headersFrame); err != nil {
399
444
                t.Fatal("WriteFrame (HEADERS):", err)
400
445
        }
401
 
        synStreamFrame := SynStreamFrame{ControlFrameHeader{Version, TypeSynStream, 0, 0}, 2, 0, 0, nil}
402
 
        synStreamFrame.Headers = http.Header{
403
 
                "Url":     []string{"http://www.google.com/"},
404
 
                "Method":  []string{"get"},
405
 
                "Version": []string{"http/1.1"},
 
446
        synStreamFrame := SynStreamFrame{
 
447
                ControlFrameHeader{
 
448
                        Version,
 
449
                        TypeSynStream,
 
450
                        0, // Flags
 
451
                        0, // length
 
452
                },
 
453
                2,   // StreamId
 
454
                0,   // AssociatedTOStreamID
 
455
                0,   // Priority
 
456
                1,   // Slot
 
457
                nil, // Headers
406
458
        }
 
459
        synStreamFrame.Headers = HeadersFixture
 
460
 
407
461
        if err := framer.WriteFrame(&synStreamFrame); err != nil {
408
462
                t.Fatal("WriteFrame (SYN_STREAM):", err)
409
463
        }
451
505
                        frameType: TypeHeaders,
452
506
                },
453
507
                StreamId: 2,
454
 
                Headers: http.Header{
455
 
                        "Url":     []string{"http://www.google.com/"},
456
 
                        "Method":  []string{"get"},
457
 
                        "Version": []string{"http/1.1"},
458
 
                },
 
508
                Headers:  HeadersFixture,
459
509
        }
460
510
        synStreamFrame := SynStreamFrame{
461
511
                CFHeader: ControlFrameHeader{
463
513
                        frameType: TypeSynStream,
464
514
                },
465
515
                StreamId: 2,
466
 
                Headers: http.Header{
467
 
                        "Url":     []string{"http://www.google.com/"},
468
 
                        "Method":  []string{"get"},
469
 
                        "Version": []string{"http/1.1"},
470
 
                },
 
516
                Headers:  HeadersFixture,
471
517
        }
472
518
 
473
519
        // Start the goroutines to write the frames.
530
576
        }
531
577
}
532
578
 
 
579
// TODO: these tests are too weak for updating SPDY spec. Fix me.
 
580
 
533
581
type zeroStream struct {
534
582
        frame   Frame
535
583
        encoded string
563
611
}
564
612
 
565
613
func TestNoZeroStreamId(t *testing.T) {
 
614
        t.Log("skipping") // TODO: update to work with SPDY3
 
615
        return
 
616
 
566
617
        for name, f := range streamIdZeroFrames {
567
618
                b, err := base64.StdEncoding.DecodeString(f.encoded)
568
619
                if err != nil {