libgo/go/websocket/websocket_test.go

   1 // Copyright 2009 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 websocket
   6
   7 import (
   8         "bufio"
   9         "bytes"
  10         "fmt"
  11         "http"
  12         "io"
  13         "log"
  14         "net"
  15         "sync"
  16         "testing"
  17 )
  18
  19 var serverAddr string
  20 var once sync.Once
  21
  22 func echoServer(ws *Conn) { io.Copy(ws, ws) }
  23
  24 func startServer() {
  25         l, e := net.Listen("tcp", "127.0.0.1:0") // any available address
  26         if e != nil {
  27                 log.Exitf("net.Listen tcp :0 %v", e)
  28         }
  29         serverAddr = l.Addr().String()
  30         log.Print("Test WebSocket server listening on ", serverAddr)
  31         http.Handle("/echo", Handler(echoServer))
  32         http.Handle("/echoDraft75", Draft75Handler(echoServer))
  33         go http.Serve(l, nil)
  34 }
  35
  36 // Test the getChallengeResponse function with values from section
  37 // 5.1 of the specification steps 18, 26, and 43 from
  38 // http://www.whatwg.org/specs/web-socket-protocol/
  39 func TestChallenge(t *testing.T) {
  40         var part1 uint32 = 777007543
  41         var part2 uint32 = 114997259
  42         key3 := []byte{0x47, 0x30, 0x22, 0x2D, 0x5A, 0x3F, 0x47, 0x58}
  43         expected := []byte("0st3Rl&q-2ZU^weu")
  44
  45         response, err := getChallengeResponse(part1, part2, key3)
  46         if err != nil {
  47                 t.Errorf("getChallengeResponse: returned error %v", err)
  48                 return
  49         }
  50         if !bytes.Equal(expected, response) {
  51                 t.Errorf("getChallengeResponse: expected %q got %q", expected, response)
  52         }
  53 }
  54
  55 func TestEcho(t *testing.T) {
  56         once.Do(startServer)
  57
  58         // websocket.Dial()
  59         client, err := net.Dial("tcp", "", serverAddr)
  60         if err != nil {
  61                 t.Fatal("dialing", err)
  62         }
  63         ws, err := newClient("/echo", "localhost", "http://localhost",
  64                 "ws://localhost/echo", "", client, handshake)
  65         if err != nil {
  66                 t.Errorf("WebSocket handshake error: %v", err)
  67                 return
  68         }
  69
  70         msg := []byte("hello, world\n")
  71         if _, err := ws.Write(msg); err != nil {
  72                 t.Errorf("Write: %v", err)
  73         }
  74         var actual_msg = make([]byte, 512)
  75         n, err := ws.Read(actual_msg)
  76         if err != nil {
  77                 t.Errorf("Read: %v", err)
  78         }
  79         actual_msg = actual_msg[0:n]
  80         if !bytes.Equal(msg, actual_msg) {
  81                 t.Errorf("Echo: expected %q got %q", msg, actual_msg)
  82         }
  83         ws.Close()
  84 }
  85
  86 func TestEchoDraft75(t *testing.T) {
  87         once.Do(startServer)
  88
  89         // websocket.Dial()
  90         client, err := net.Dial("tcp", "", serverAddr)
  91         if err != nil {
  92                 t.Fatal("dialing", err)
  93         }
  94         ws, err := newClient("/echoDraft75", "localhost", "http://localhost",
  95                 "ws://localhost/echoDraft75", "", client, draft75handshake)
  96         if err != nil {
  97                 t.Errorf("WebSocket handshake: %v", err)
  98                 return
  99         }
 100
 101         msg := []byte("hello, world\n")
 102         if _, err := ws.Write(msg); err != nil {
 103                 t.Errorf("Write: error %v", err)
 104         }
 105         var actual_msg = make([]byte, 512)
 106         n, err := ws.Read(actual_msg)
 107         if err != nil {
 108                 t.Errorf("Read: error %v", err)
 109         }
 110         actual_msg = actual_msg[0:n]
 111         if !bytes.Equal(msg, actual_msg) {
 112                 t.Errorf("Echo: expected %q got %q", msg, actual_msg)
 113         }
 114         ws.Close()
 115 }
 116
 117 func TestWithQuery(t *testing.T) {
 118         once.Do(startServer)
 119
 120         client, err := net.Dial("tcp", "", serverAddr)
 121         if err != nil {
 122                 t.Fatal("dialing", err)
 123         }
 124
 125         ws, err := newClient("/echo?q=v", "localhost", "http://localhost",
 126                 "ws://localhost/echo?q=v", "", client, handshake)
 127         if err != nil {
 128                 t.Errorf("WebSocket handshake: %v", err)
 129                 return
 130         }
 131         ws.Close()
 132 }
 133
 134 func TestWithProtocol(t *testing.T) {
 135         once.Do(startServer)
 136
 137         client, err := net.Dial("tcp", "", serverAddr)
 138         if err != nil {
 139                 t.Fatal("dialing", err)
 140         }
 141
 142         ws, err := newClient("/echo", "localhost", "http://localhost",
 143                 "ws://localhost/echo", "test", client, handshake)
 144         if err != nil {
 145                 t.Errorf("WebSocket handshake: %v", err)
 146                 return
 147         }
 148         ws.Close()
 149 }
 150
 151 func TestHTTP(t *testing.T) {
 152         once.Do(startServer)
 153
 154         // If the client did not send a handshake that matches the protocol
 155         // specification, the server should abort the WebSocket connection.
 156         _, _, err := http.Get(fmt.Sprintf("http://%s/echo", serverAddr))
 157         if err == nil {
 158                 t.Error("Get: unexpected success")
 159                 return
 160         }
 161         urlerr, ok := err.(*http.URLError)
 162         if !ok {
 163                 t.Errorf("Get: not URLError %#v", err)
 164                 return
 165         }
 166         if urlerr.Error != io.ErrUnexpectedEOF {
 167                 t.Errorf("Get: error %#v", err)
 168                 return
 169         }
 170 }
 171
 172 func TestHTTPDraft75(t *testing.T) {
 173         once.Do(startServer)
 174
 175         r, _, err := http.Get(fmt.Sprintf("http://%s/echoDraft75", serverAddr))
 176         if err != nil {
 177                 t.Errorf("Get: error %#v", err)
 178                 return
 179         }
 180         if r.StatusCode != http.StatusBadRequest {
 181                 t.Errorf("Get: got status %d", r.StatusCode)
 182         }
 183 }
 184
 185 func TestTrailingSpaces(t *testing.T) {
 186         // http://code.google.com/p/go/issues/detail?id=955
 187         // The last runs of this create keys with trailing spaces that should not be
 188         // generated by the client.
 189         once.Do(startServer)
 190         for i := 0; i < 30; i++ {
 191                 // body
 192                 _, err := Dial(fmt.Sprintf("ws://%s/echo", serverAddr), "",
 193                         "http://localhost/")
 194                 if err != nil {
 195                         panic("Dial failed: " + err.String())
 196                 }
 197         }
 198 }
 199
 200 func TestSmallBuffer(t *testing.T) {
 201         // http://code.google.com/p/go/issues/detail?id=1145
 202         // Read should be able to handle reading a fragment of a frame.
 203         once.Do(startServer)
 204
 205         // websocket.Dial()
 206         client, err := net.Dial("tcp", "", serverAddr)
 207         if err != nil {
 208                 t.Fatal("dialing", err)
 209         }
 210         ws, err := newClient("/echo", "localhost", "http://localhost",
 211                 "ws://localhost/echo", "", client, handshake)
 212         if err != nil {
 213                 t.Errorf("WebSocket handshake error: %v", err)
 214                 return
 215         }
 216
 217         msg := []byte("hello, world\n")
 218         if _, err := ws.Write(msg); err != nil {
 219                 t.Errorf("Write: %v", err)
 220         }
 221         var small_msg = make([]byte, 8)
 222         n, err := ws.Read(small_msg)
 223         if err != nil {
 224                 t.Errorf("Read: %v", err)
 225         }
 226         if !bytes.Equal(msg[:len(small_msg)], small_msg) {
 227                 t.Errorf("Echo: expected %q got %q", msg[:len(small_msg)], small_msg)
 228         }
 229         var second_msg = make([]byte, len(msg))
 230         n, err = ws.Read(second_msg)
 231         if err != nil {
 232                 t.Errorf("Read: %v", err)
 233         }
 234         second_msg = second_msg[0:n]
 235         if !bytes.Equal(msg[len(small_msg):], second_msg) {
 236                 t.Errorf("Echo: expected %q got %q", msg[len(small_msg):], second_msg)
 237         }
 238         ws.Close()
 239
 240 }
 241
 242 func testSkipLengthFrame(t *testing.T) {
 243         b := []byte{'\x80', '\x01', 'x', 0, 'h', 'e', 'l', 'l', 'o', '\xff'}
 244         buf := bytes.NewBuffer(b)
 245         br := bufio.NewReader(buf)
 246         bw := bufio.NewWriter(buf)
 247         ws := newConn("http://127.0.0.1/", "ws://127.0.0.1/", "", bufio.NewReadWriter(br, bw), nil)
 248         msg := make([]byte, 5)
 249         n, err := ws.Read(msg)
 250         if err != nil {
 251                 t.Errorf("Read: %v", err)
 252         }
 253         if !bytes.Equal(b[4:8], msg[0:n]) {
 254                 t.Errorf("Read: expected %q got %q", msg[4:8], msg[0:n])
 255         }
 256 }
 257
 258 func testSkipNoUTF8Frame(t *testing.T) {
 259         b := []byte{'\x01', 'n', '\xff', 0, 'h', 'e', 'l', 'l', 'o', '\xff'}
 260         buf := bytes.NewBuffer(b)
 261         br := bufio.NewReader(buf)
 262         bw := bufio.NewWriter(buf)
 263         ws := newConn("http://127.0.0.1/", "ws://127.0.0.1/", "", bufio.NewReadWriter(br, bw), nil)
 264         msg := make([]byte, 5)
 265         n, err := ws.Read(msg)
 266         if err != nil {
 267                 t.Errorf("Read: %v", err)
 268         }
 269         if !bytes.Equal(b[4:8], msg[0:n]) {
 270                 t.Errorf("Read: expected %q got %q", msg[4:8], msg[0:n])
 271         }
 272 }