libgo/go/http/spdy/spdy_test.go

   1 // Copyright 2011 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 package spdy
   6
   7 import (
   8         "bytes"
   9         "http"
  10         "io"
  11         "reflect"
  12         "testing"
  13 )
  14
  15 func TestHeaderParsing(t *testing.T) {
  16         headers := http.Header{
  17                 "Url":     []string{"http://www.google.com/"},
  18                 "Method":  []string{"get"},
  19                 "Version": []string{"http/1.1"},
  20         }
  21         var headerValueBlockBuf bytes.Buffer
  22         writeHeaderValueBlock(&headerValueBlockBuf, headers)
  23
  24         const bogusStreamId = 1
  25         newHeaders, err := parseHeaderValueBlock(&headerValueBlockBuf, bogusStreamId)
  26         if err != nil {
  27                 t.Fatal("parseHeaderValueBlock:", err)
  28         }
  29
  30         if !reflect.DeepEqual(headers, newHeaders) {
  31                 t.Fatal("got: ", newHeaders, "\nwant: ", headers)
  32         }
  33 }
  34
  35 func TestCreateParseSynStreamFrame(t *testing.T) {
  36         buffer := new(bytes.Buffer)
  37         framer := &Framer{
  38                 headerCompressionDisabled: true,
  39                 w:                         buffer,
  40                 headerBuf:                 new(bytes.Buffer),
  41                 r:                         buffer,
  42         }
  43         synStreamFrame := SynStreamFrame{
  44                 CFHeader: ControlFrameHeader{
  45                         version:   Version,
  46                         frameType: TypeSynStream,
  47                 },
  48                 Headers: http.Header{
  49                         "Url":     []string{"http://www.google.com/"},
  50                         "Method":  []string{"get"},
  51                         "Version": []string{"http/1.1"},
  52                 },
  53         }
  54         if err := framer.WriteFrame(&synStreamFrame); err != nil {
  55                 t.Fatal("WriteFrame without compression:", err)
  56         }
  57         frame, err := framer.ReadFrame()
  58         if err != nil {
  59                 t.Fatal("ReadFrame without compression:", err)
  60         }
  61         parsedSynStreamFrame, ok := frame.(*SynStreamFrame)
  62         if !ok {
  63                 t.Fatal("Parsed incorrect frame type:", frame)
  64         }
  65         if !reflect.DeepEqual(synStreamFrame, *parsedSynStreamFrame) {
  66                 t.Fatal("got: ", *parsedSynStreamFrame, "\nwant: ", synStreamFrame)
  67         }
  68
  69         // Test again with compression
  70         buffer.Reset()
  71         framer, err = NewFramer(buffer, buffer)
  72         if err != nil {
  73                 t.Fatal("Failed to create new framer:", err)
  74         }
  75         if err := framer.WriteFrame(&synStreamFrame); err != nil {
  76                 t.Fatal("WriteFrame with compression:", err)
  77         }
  78         frame, err = framer.ReadFrame()
  79         if err != nil {
  80                 t.Fatal("ReadFrame with compression:", err)
  81         }
  82         parsedSynStreamFrame, ok = frame.(*SynStreamFrame)
  83         if !ok {
  84                 t.Fatal("Parsed incorrect frame type:", frame)
  85         }
  86         if !reflect.DeepEqual(synStreamFrame, *parsedSynStreamFrame) {
  87                 t.Fatal("got: ", *parsedSynStreamFrame, "\nwant: ", synStreamFrame)
  88         }
  89 }
  90
  91 func TestCreateParseSynReplyFrame(t *testing.T) {
  92         buffer := new(bytes.Buffer)
  93         framer := &Framer{
  94                 headerCompressionDisabled: true,
  95                 w:                         buffer,
  96                 headerBuf:                 new(bytes.Buffer),
  97                 r:                         buffer,
  98         }
  99         synReplyFrame := SynReplyFrame{
 100                 CFHeader: ControlFrameHeader{
 101                         version:   Version,
 102                         frameType: TypeSynReply,
 103                 },
 104                 Headers: http.Header{
 105                         "Url":     []string{"http://www.google.com/"},
 106                         "Method":  []string{"get"},
 107                         "Version": []string{"http/1.1"},
 108                 },
 109         }
 110         if err := framer.WriteFrame(&synReplyFrame); err != nil {
 111                 t.Fatal("WriteFrame without compression:", err)
 112         }
 113         frame, err := framer.ReadFrame()
 114         if err != nil {
 115                 t.Fatal("ReadFrame without compression:", err)
 116         }
 117         parsedSynReplyFrame, ok := frame.(*SynReplyFrame)
 118         if !ok {
 119                 t.Fatal("Parsed incorrect frame type:", frame)
 120         }
 121         if !reflect.DeepEqual(synReplyFrame, *parsedSynReplyFrame) {
 122                 t.Fatal("got: ", *parsedSynReplyFrame, "\nwant: ", synReplyFrame)
 123         }
 124
 125         // Test again with compression
 126         buffer.Reset()
 127         framer, err = NewFramer(buffer, buffer)
 128         if err != nil {
 129                 t.Fatal("Failed to create new framer:", err)
 130         }
 131         if err := framer.WriteFrame(&synReplyFrame); err != nil {
 132                 t.Fatal("WriteFrame with compression:", err)
 133         }
 134         frame, err = framer.ReadFrame()
 135         if err != nil {
 136                 t.Fatal("ReadFrame with compression:", err)
 137         }
 138         parsedSynReplyFrame, ok = frame.(*SynReplyFrame)
 139         if !ok {
 140                 t.Fatal("Parsed incorrect frame type:", frame)
 141         }
 142         if !reflect.DeepEqual(synReplyFrame, *parsedSynReplyFrame) {
 143                 t.Fatal("got: ", *parsedSynReplyFrame, "\nwant: ", synReplyFrame)
 144         }
 145 }
 146
 147 func TestCreateParseRstStream(t *testing.T) {
 148         buffer := new(bytes.Buffer)
 149         framer, err := NewFramer(buffer, buffer)
 150         if err != nil {
 151                 t.Fatal("Failed to create new framer:", err)
 152         }
 153         rstStreamFrame := RstStreamFrame{
 154                 CFHeader: ControlFrameHeader{
 155                         version:   Version,
 156                         frameType: TypeRstStream,
 157                 },
 158                 StreamId: 1,
 159                 Status:   InvalidStream,
 160         }
 161         if err := framer.WriteFrame(&rstStreamFrame); err != nil {
 162                 t.Fatal("WriteFrame:", err)
 163         }
 164         frame, err := framer.ReadFrame()
 165         if err != nil {
 166                 t.Fatal("ReadFrame:", err)
 167         }
 168         parsedRstStreamFrame, ok := frame.(*RstStreamFrame)
 169         if !ok {
 170                 t.Fatal("Parsed incorrect frame type:", frame)
 171         }
 172         if !reflect.DeepEqual(rstStreamFrame, *parsedRstStreamFrame) {
 173                 t.Fatal("got: ", *parsedRstStreamFrame, "\nwant: ", rstStreamFrame)
 174         }
 175 }
 176
 177 func TestCreateParseSettings(t *testing.T) {
 178         buffer := new(bytes.Buffer)
 179         framer, err := NewFramer(buffer, buffer)
 180         if err != nil {
 181                 t.Fatal("Failed to create new framer:", err)
 182         }
 183         settingsFrame := SettingsFrame{
 184                 CFHeader: ControlFrameHeader{
 185                         version:   Version,
 186                         frameType: TypeSettings,
 187                 },
 188                 FlagIdValues: []SettingsFlagIdValue{
 189                         {FlagSettingsPersistValue, SettingsCurrentCwnd, 10},
 190                         {FlagSettingsPersisted, SettingsUploadBandwidth, 1},
 191                 },
 192         }
 193         if err := framer.WriteFrame(&settingsFrame); err != nil {
 194                 t.Fatal("WriteFrame:", err)
 195         }
 196         frame, err := framer.ReadFrame()
 197         if err != nil {
 198                 t.Fatal("ReadFrame:", err)
 199         }
 200         parsedSettingsFrame, ok := frame.(*SettingsFrame)
 201         if !ok {
 202                 t.Fatal("Parsed incorrect frame type:", frame)
 203         }
 204         if !reflect.DeepEqual(settingsFrame, *parsedSettingsFrame) {
 205                 t.Fatal("got: ", *parsedSettingsFrame, "\nwant: ", settingsFrame)
 206         }
 207 }
 208
 209 func TestCreateParseNoop(t *testing.T) {
 210         buffer := new(bytes.Buffer)
 211         framer, err := NewFramer(buffer, buffer)
 212         if err != nil {
 213                 t.Fatal("Failed to create new framer:", err)
 214         }
 215         noopFrame := NoopFrame{
 216                 CFHeader: ControlFrameHeader{
 217                         version:   Version,
 218                         frameType: TypeNoop,
 219                 },
 220         }
 221         if err := framer.WriteFrame(&noopFrame); err != nil {
 222                 t.Fatal("WriteFrame:", err)
 223         }
 224         frame, err := framer.ReadFrame()
 225         if err != nil {
 226                 t.Fatal("ReadFrame:", err)
 227         }
 228         parsedNoopFrame, ok := frame.(*NoopFrame)
 229         if !ok {
 230                 t.Fatal("Parsed incorrect frame type:", frame)
 231         }
 232         if !reflect.DeepEqual(noopFrame, *parsedNoopFrame) {
 233                 t.Fatal("got: ", *parsedNoopFrame, "\nwant: ", noopFrame)
 234         }
 235 }
 236
 237 func TestCreateParsePing(t *testing.T) {
 238         buffer := new(bytes.Buffer)
 239         framer, err := NewFramer(buffer, buffer)
 240         if err != nil {
 241                 t.Fatal("Failed to create new framer:", err)
 242         }
 243         pingFrame := PingFrame{
 244                 CFHeader: ControlFrameHeader{
 245                         version:   Version,
 246                         frameType: TypePing,
 247                 },
 248                 Id: 31337,
 249         }
 250         if err := framer.WriteFrame(&pingFrame); err != nil {
 251                 t.Fatal("WriteFrame:", err)
 252         }
 253         frame, err := framer.ReadFrame()
 254         if err != nil {
 255                 t.Fatal("ReadFrame:", err)
 256         }
 257         parsedPingFrame, ok := frame.(*PingFrame)
 258         if !ok {
 259                 t.Fatal("Parsed incorrect frame type:", frame)
 260         }
 261         if !reflect.DeepEqual(pingFrame, *parsedPingFrame) {
 262                 t.Fatal("got: ", *parsedPingFrame, "\nwant: ", pingFrame)
 263         }
 264 }
 265
 266 func TestCreateParseGoAway(t *testing.T) {
 267         buffer := new(bytes.Buffer)
 268         framer, err := NewFramer(buffer, buffer)
 269         if err != nil {
 270                 t.Fatal("Failed to create new framer:", err)
 271         }
 272         goAwayFrame := GoAwayFrame{
 273                 CFHeader: ControlFrameHeader{
 274                         version:   Version,
 275                         frameType: TypeGoAway,
 276                 },
 277                 LastGoodStreamId: 31337,
 278         }
 279         if err := framer.WriteFrame(&goAwayFrame); err != nil {
 280                 t.Fatal("WriteFrame:", err)
 281         }
 282         frame, err := framer.ReadFrame()
 283         if err != nil {
 284                 t.Fatal("ReadFrame:", err)
 285         }
 286         parsedGoAwayFrame, ok := frame.(*GoAwayFrame)
 287         if !ok {
 288                 t.Fatal("Parsed incorrect frame type:", frame)
 289         }
 290         if !reflect.DeepEqual(goAwayFrame, *parsedGoAwayFrame) {
 291                 t.Fatal("got: ", *parsedGoAwayFrame, "\nwant: ", goAwayFrame)
 292         }
 293 }
 294
 295 func TestCreateParseHeadersFrame(t *testing.T) {
 296         buffer := new(bytes.Buffer)
 297         framer := &Framer{
 298                 headerCompressionDisabled: true,
 299                 w:                         buffer,
 300                 headerBuf:                 new(bytes.Buffer),
 301                 r:                         buffer,
 302         }
 303         headersFrame := HeadersFrame{
 304                 CFHeader: ControlFrameHeader{
 305                         version:   Version,
 306                         frameType: TypeHeaders,
 307                 },
 308         }
 309         headersFrame.Headers = http.Header{
 310                 "Url":     []string{"http://www.google.com/"},
 311                 "Method":  []string{"get"},
 312                 "Version": []string{"http/1.1"},
 313         }
 314         if err := framer.WriteFrame(&headersFrame); err != nil {
 315                 t.Fatal("WriteFrame without compression:", err)
 316         }
 317         frame, err := framer.ReadFrame()
 318         if err != nil {
 319                 t.Fatal("ReadFrame without compression:", err)
 320         }
 321         parsedHeadersFrame, ok := frame.(*HeadersFrame)
 322         if !ok {
 323                 t.Fatal("Parsed incorrect frame type:", frame)
 324         }
 325         if !reflect.DeepEqual(headersFrame, *parsedHeadersFrame) {
 326                 t.Fatal("got: ", *parsedHeadersFrame, "\nwant: ", headersFrame)
 327         }
 328
 329         // Test again with compression
 330         buffer.Reset()
 331         framer, err = NewFramer(buffer, buffer)
 332         if err := framer.WriteFrame(&headersFrame); err != nil {
 333                 t.Fatal("WriteFrame with compression:", err)
 334         }
 335         frame, err = framer.ReadFrame()
 336         if err != nil {
 337                 t.Fatal("ReadFrame with compression:", err)
 338         }
 339         parsedHeadersFrame, ok = frame.(*HeadersFrame)
 340         if !ok {
 341                 t.Fatal("Parsed incorrect frame type:", frame)
 342         }
 343         if !reflect.DeepEqual(headersFrame, *parsedHeadersFrame) {
 344                 t.Fatal("got: ", *parsedHeadersFrame, "\nwant: ", headersFrame)
 345         }
 346 }
 347
 348 func TestCreateParseDataFrame(t *testing.T) {
 349         buffer := new(bytes.Buffer)
 350         framer, err := NewFramer(buffer, buffer)
 351         if err != nil {
 352                 t.Fatal("Failed to create new framer:", err)
 353         }
 354         dataFrame := DataFrame{
 355                 StreamId: 1,
 356                 Data:     []byte{'h', 'e', 'l', 'l', 'o'},
 357         }
 358         if err := framer.WriteFrame(&dataFrame); err != nil {
 359                 t.Fatal("WriteFrame:", err)
 360         }
 361         frame, err := framer.ReadFrame()
 362         if err != nil {
 363                 t.Fatal("ReadFrame:", err)
 364         }
 365         parsedDataFrame, ok := frame.(*DataFrame)
 366         if !ok {
 367                 t.Fatal("Parsed incorrect frame type:", frame)
 368         }
 369         if !reflect.DeepEqual(dataFrame, *parsedDataFrame) {
 370                 t.Fatal("got: ", *parsedDataFrame, "\nwant: ", dataFrame)
 371         }
 372 }
 373
 374 func TestCompressionContextAcrossFrames(t *testing.T) {
 375         buffer := new(bytes.Buffer)
 376         framer, err := NewFramer(buffer, buffer)
 377         if err != nil {
 378                 t.Fatal("Failed to create new framer:", err)
 379         }
 380         headersFrame := HeadersFrame{
 381                 CFHeader: ControlFrameHeader{
 382                         version:   Version,
 383                         frameType: TypeHeaders,
 384                 },
 385                 Headers: http.Header{
 386                         "Url":     []string{"http://www.google.com/"},
 387                         "Method":  []string{"get"},
 388                         "Version": []string{"http/1.1"},
 389                 },
 390         }
 391         if err := framer.WriteFrame(&headersFrame); err != nil {
 392                 t.Fatal("WriteFrame (HEADERS):", err)
 393         }
 394         synStreamFrame := SynStreamFrame{ControlFrameHeader{Version, TypeSynStream, 0, 0}, 0, 0, 0, nil}
 395         synStreamFrame.Headers = http.Header{
 396                 "Url":     []string{"http://www.google.com/"},
 397                 "Method":  []string{"get"},
 398                 "Version": []string{"http/1.1"},
 399         }
 400         if err := framer.WriteFrame(&synStreamFrame); err != nil {
 401                 t.Fatal("WriteFrame (SYN_STREAM):", err)
 402         }
 403         frame, err := framer.ReadFrame()
 404         if err != nil {
 405                 t.Fatal("ReadFrame (HEADERS):", err, buffer.Bytes())
 406         }
 407         parsedHeadersFrame, ok := frame.(*HeadersFrame)
 408         if !ok {
 409                 t.Fatalf("expected HeadersFrame; got %T %v", frame, frame)
 410         }
 411         if !reflect.DeepEqual(headersFrame, *parsedHeadersFrame) {
 412                 t.Fatal("got: ", *parsedHeadersFrame, "\nwant: ", headersFrame)
 413         }
 414         frame, err = framer.ReadFrame()
 415         if err != nil {
 416                 t.Fatal("ReadFrame (SYN_STREAM):", err, buffer.Bytes())
 417         }
 418         parsedSynStreamFrame, ok := frame.(*SynStreamFrame)
 419         if !ok {
 420                 t.Fatalf("expected SynStreamFrame; got %T %v", frame, frame)
 421         }
 422         if !reflect.DeepEqual(synStreamFrame, *parsedSynStreamFrame) {
 423                 t.Fatal("got: ", *parsedSynStreamFrame, "\nwant: ", synStreamFrame)
 424         }
 425 }
 426
 427 func TestMultipleSPDYFrames(t *testing.T) {
 428         // Initialize the framers.
 429         pr1, pw1 := io.Pipe()
 430         pr2, pw2 := io.Pipe()
 431         writer, err := NewFramer(pw1, pr2)
 432         if err != nil {
 433                 t.Fatal("Failed to create writer:", err)
 434         }
 435         reader, err := NewFramer(pw2, pr1)
 436         if err != nil {
 437                 t.Fatal("Failed to create reader:", err)
 438         }
 439
 440         // Set up the frames we're actually transferring.
 441         headersFrame := HeadersFrame{
 442                 CFHeader: ControlFrameHeader{
 443                         version:   Version,
 444                         frameType: TypeHeaders,
 445                 },
 446                 Headers: http.Header{
 447                         "Url":     []string{"http://www.google.com/"},
 448                         "Method":  []string{"get"},
 449                         "Version": []string{"http/1.1"},
 450                 },
 451         }
 452         synStreamFrame := SynStreamFrame{
 453                 CFHeader: ControlFrameHeader{
 454                         version:   Version,
 455                         frameType: TypeSynStream,
 456                 },
 457                 Headers: http.Header{
 458                         "Url":     []string{"http://www.google.com/"},
 459                         "Method":  []string{"get"},
 460                         "Version": []string{"http/1.1"},
 461                 },
 462         }
 463
 464         // Start the goroutines to write the frames.
 465         go func() {
 466                 if err := writer.WriteFrame(&headersFrame); err != nil {
 467                         t.Fatal("WriteFrame (HEADERS): ", err)
 468                 }
 469                 if err := writer.WriteFrame(&synStreamFrame); err != nil {
 470                         t.Fatal("WriteFrame (SYN_STREAM): ", err)
 471                 }
 472         }()
 473
 474         // Read the frames and verify they look as expected.
 475         frame, err := reader.ReadFrame()
 476         if err != nil {
 477                 t.Fatal("ReadFrame (HEADERS): ", err)
 478         }
 479         parsedHeadersFrame, ok := frame.(*HeadersFrame)
 480         if !ok {
 481                 t.Fatal("Parsed incorrect frame type:", frame)
 482         }
 483         if !reflect.DeepEqual(headersFrame, *parsedHeadersFrame) {
 484                 t.Fatal("got: ", *parsedHeadersFrame, "\nwant: ", headersFrame)
 485         }
 486         frame, err = reader.ReadFrame()
 487         if err != nil {
 488                 t.Fatal("ReadFrame (SYN_STREAM):", err)
 489         }
 490         parsedSynStreamFrame, ok := frame.(*SynStreamFrame)
 491         if !ok {
 492                 t.Fatal("Parsed incorrect frame type.")
 493         }
 494         if !reflect.DeepEqual(synStreamFrame, *parsedSynStreamFrame) {
 495                 t.Fatal("got: ", *parsedSynStreamFrame, "\nwant: ", synStreamFrame)
 496         }
 497 }