| // Copyright 2009 The Go Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| package websocket |
| |
| import ( |
| "bytes" |
| "crypto/rand" |
| "fmt" |
| "io" |
| "log" |
| "net" |
| "net/http" |
| "net/http/httptest" |
| "net/url" |
| "reflect" |
| "runtime" |
| "strings" |
| "sync" |
| "testing" |
| "time" |
| ) |
| |
| var serverAddr string |
| var once sync.Once |
| |
| func echoServer(ws *Conn) { |
| defer ws.Close() |
| io.Copy(ws, ws) |
| } |
| |
| type Count struct { |
| S string |
| N int |
| } |
| |
| func countServer(ws *Conn) { |
| defer ws.Close() |
| for { |
| var count Count |
| err := JSON.Receive(ws, &count) |
| if err != nil { |
| return |
| } |
| count.N++ |
| count.S = strings.Repeat(count.S, count.N) |
| err = JSON.Send(ws, count) |
| if err != nil { |
| return |
| } |
| } |
| } |
| |
| type testCtrlAndDataHandler struct { |
| hybiFrameHandler |
| } |
| |
| func (h *testCtrlAndDataHandler) WritePing(b []byte) (int, error) { |
| h.hybiFrameHandler.conn.wio.Lock() |
| defer h.hybiFrameHandler.conn.wio.Unlock() |
| w, err := h.hybiFrameHandler.conn.frameWriterFactory.NewFrameWriter(PingFrame) |
| if err != nil { |
| return 0, err |
| } |
| n, err := w.Write(b) |
| w.Close() |
| return n, err |
| } |
| |
| func ctrlAndDataServer(ws *Conn) { |
| defer ws.Close() |
| h := &testCtrlAndDataHandler{hybiFrameHandler: hybiFrameHandler{conn: ws}} |
| ws.frameHandler = h |
| |
| go func() { |
| for i := 0; ; i++ { |
| var b []byte |
| if i%2 != 0 { // with or without payload |
| b = []byte(fmt.Sprintf("#%d-CONTROL-FRAME-FROM-SERVER", i)) |
| } |
| if _, err := h.WritePing(b); err != nil { |
| break |
| } |
| if _, err := h.WritePong(b); err != nil { // unsolicited pong |
| break |
| } |
| time.Sleep(10 * time.Millisecond) |
| } |
| }() |
| |
| b := make([]byte, 128) |
| for { |
| n, err := ws.Read(b) |
| if err != nil { |
| break |
| } |
| if _, err := ws.Write(b[:n]); err != nil { |
| break |
| } |
| } |
| } |
| |
| func subProtocolHandshake(config *Config, req *http.Request) error { |
| for _, proto := range config.Protocol { |
| if proto == "chat" { |
| config.Protocol = []string{proto} |
| return nil |
| } |
| } |
| return ErrBadWebSocketProtocol |
| } |
| |
| func subProtoServer(ws *Conn) { |
| for _, proto := range ws.Config().Protocol { |
| io.WriteString(ws, proto) |
| } |
| } |
| |
| func startServer() { |
| http.Handle("/echo", Handler(echoServer)) |
| http.Handle("/count", Handler(countServer)) |
| http.Handle("/ctrldata", Handler(ctrlAndDataServer)) |
| subproto := Server{ |
| Handshake: subProtocolHandshake, |
| Handler: Handler(subProtoServer), |
| } |
| http.Handle("/subproto", subproto) |
| server := httptest.NewServer(nil) |
| serverAddr = server.Listener.Addr().String() |
| log.Print("Test WebSocket server listening on ", serverAddr) |
| } |
| |
| func newConfig(t *testing.T, path string) *Config { |
| config, _ := NewConfig(fmt.Sprintf("ws://%s%s", serverAddr, path), "http://localhost") |
| return config |
| } |
| |
| func TestEcho(t *testing.T) { |
| once.Do(startServer) |
| |
| // websocket.Dial() |
| client, err := net.Dial("tcp", serverAddr) |
| if err != nil { |
| t.Fatal("dialing", err) |
| } |
| conn, err := NewClient(newConfig(t, "/echo"), client) |
| if err != nil { |
| t.Errorf("WebSocket handshake error: %v", err) |
| return |
| } |
| |
| msg := []byte("hello, world\n") |
| if _, err := conn.Write(msg); err != nil { |
| t.Errorf("Write: %v", err) |
| } |
| var actual_msg = make([]byte, 512) |
| n, err := conn.Read(actual_msg) |
| if err != nil { |
| t.Errorf("Read: %v", err) |
| } |
| actual_msg = actual_msg[0:n] |
| if !bytes.Equal(msg, actual_msg) { |
| t.Errorf("Echo: expected %q got %q", msg, actual_msg) |
| } |
| conn.Close() |
| } |
| |
| func TestAddr(t *testing.T) { |
| once.Do(startServer) |
| |
| // websocket.Dial() |
| client, err := net.Dial("tcp", serverAddr) |
| if err != nil { |
| t.Fatal("dialing", err) |
| } |
| conn, err := NewClient(newConfig(t, "/echo"), client) |
| if err != nil { |
| t.Errorf("WebSocket handshake error: %v", err) |
| return |
| } |
| |
| ra := conn.RemoteAddr().String() |
| if !strings.HasPrefix(ra, "ws://") || !strings.HasSuffix(ra, "/echo") { |
| t.Errorf("Bad remote addr: %v", ra) |
| } |
| la := conn.LocalAddr().String() |
| if !strings.HasPrefix(la, "http://") { |
| t.Errorf("Bad local addr: %v", la) |
| } |
| conn.Close() |
| } |
| |
| func TestCount(t *testing.T) { |
| once.Do(startServer) |
| |
| // websocket.Dial() |
| client, err := net.Dial("tcp", serverAddr) |
| if err != nil { |
| t.Fatal("dialing", err) |
| } |
| conn, err := NewClient(newConfig(t, "/count"), client) |
| if err != nil { |
| t.Errorf("WebSocket handshake error: %v", err) |
| return |
| } |
| |
| var count Count |
| count.S = "hello" |
| if err := JSON.Send(conn, count); err != nil { |
| t.Errorf("Write: %v", err) |
| } |
| if err := JSON.Receive(conn, &count); err != nil { |
| t.Errorf("Read: %v", err) |
| } |
| if count.N != 1 { |
| t.Errorf("count: expected %d got %d", 1, count.N) |
| } |
| if count.S != "hello" { |
| t.Errorf("count: expected %q got %q", "hello", count.S) |
| } |
| if err := JSON.Send(conn, count); err != nil { |
| t.Errorf("Write: %v", err) |
| } |
| if err := JSON.Receive(conn, &count); err != nil { |
| t.Errorf("Read: %v", err) |
| } |
| if count.N != 2 { |
| t.Errorf("count: expected %d got %d", 2, count.N) |
| } |
| if count.S != "hellohello" { |
| t.Errorf("count: expected %q got %q", "hellohello", count.S) |
| } |
| conn.Close() |
| } |
| |
| func TestWithQuery(t *testing.T) { |
| once.Do(startServer) |
| |
| client, err := net.Dial("tcp", serverAddr) |
| if err != nil { |
| t.Fatal("dialing", err) |
| } |
| |
| config := newConfig(t, "/echo") |
| config.Location, err = url.ParseRequestURI(fmt.Sprintf("ws://%s/echo?q=v", serverAddr)) |
| if err != nil { |
| t.Fatal("location url", err) |
| } |
| |
| ws, err := NewClient(config, client) |
| if err != nil { |
| t.Errorf("WebSocket handshake: %v", err) |
| return |
| } |
| ws.Close() |
| } |
| |
| func testWithProtocol(t *testing.T, subproto []string) (string, error) { |
| once.Do(startServer) |
| |
| client, err := net.Dial("tcp", serverAddr) |
| if err != nil { |
| t.Fatal("dialing", err) |
| } |
| |
| config := newConfig(t, "/subproto") |
| config.Protocol = subproto |
| |
| ws, err := NewClient(config, client) |
| if err != nil { |
| return "", err |
| } |
| msg := make([]byte, 16) |
| n, err := ws.Read(msg) |
| if err != nil { |
| return "", err |
| } |
| ws.Close() |
| return string(msg[:n]), nil |
| } |
| |
| func TestWithProtocol(t *testing.T) { |
| proto, err := testWithProtocol(t, []string{"chat"}) |
| if err != nil { |
| t.Errorf("SubProto: unexpected error: %v", err) |
| } |
| if proto != "chat" { |
| t.Errorf("SubProto: expected %q, got %q", "chat", proto) |
| } |
| } |
| |
| func TestWithTwoProtocol(t *testing.T) { |
| proto, err := testWithProtocol(t, []string{"test", "chat"}) |
| if err != nil { |
| t.Errorf("SubProto: unexpected error: %v", err) |
| } |
| if proto != "chat" { |
| t.Errorf("SubProto: expected %q, got %q", "chat", proto) |
| } |
| } |
| |
| func TestWithBadProtocol(t *testing.T) { |
| _, err := testWithProtocol(t, []string{"test"}) |
| if err != ErrBadStatus { |
| t.Errorf("SubProto: expected %v, got %v", ErrBadStatus, err) |
| } |
| } |
| |
| func TestHTTP(t *testing.T) { |
| once.Do(startServer) |
| |
| // If the client did not send a handshake that matches the protocol |
| // specification, the server MUST return an HTTP response with an |
| // appropriate error code (such as 400 Bad Request) |
| resp, err := http.Get(fmt.Sprintf("http://%s/echo", serverAddr)) |
| if err != nil { |
| t.Errorf("Get: error %#v", err) |
| return |
| } |
| if resp == nil { |
| t.Error("Get: resp is null") |
| return |
| } |
| if resp.StatusCode != http.StatusBadRequest { |
| t.Errorf("Get: expected %q got %q", http.StatusBadRequest, resp.StatusCode) |
| } |
| } |
| |
| func TestTrailingSpaces(t *testing.T) { |
| // http://code.google.com/p/go/issues/detail?id=955 |
| // The last runs of this create keys with trailing spaces that should not be |
| // generated by the client. |
| once.Do(startServer) |
| config := newConfig(t, "/echo") |
| for i := 0; i < 30; i++ { |
| // body |
| ws, err := DialConfig(config) |
| if err != nil { |
| t.Errorf("Dial #%d failed: %v", i, err) |
| break |
| } |
| ws.Close() |
| } |
| } |
| |
| func TestDialConfigBadVersion(t *testing.T) { |
| once.Do(startServer) |
| config := newConfig(t, "/echo") |
| config.Version = 1234 |
| |
| _, err := DialConfig(config) |
| |
| if dialerr, ok := err.(*DialError); ok { |
| if dialerr.Err != ErrBadProtocolVersion { |
| t.Errorf("dial expected err %q but got %q", ErrBadProtocolVersion, dialerr.Err) |
| } |
| } |
| } |
| |
| func TestDialConfigWithDialer(t *testing.T) { |
| once.Do(startServer) |
| config := newConfig(t, "/echo") |
| config.Dialer = &net.Dialer{ |
| Deadline: time.Now().Add(-time.Minute), |
| } |
| _, err := DialConfig(config) |
| dialerr, ok := err.(*DialError) |
| if !ok { |
| t.Fatalf("DialError expected, got %#v", err) |
| } |
| neterr, ok := dialerr.Err.(*net.OpError) |
| if !ok { |
| t.Fatalf("net.OpError error expected, got %#v", dialerr.Err) |
| } |
| if !neterr.Timeout() { |
| t.Fatalf("expected timeout error, got %#v", neterr) |
| } |
| } |
| |
| func TestSmallBuffer(t *testing.T) { |
| // http://code.google.com/p/go/issues/detail?id=1145 |
| // Read should be able to handle reading a fragment of a frame. |
| once.Do(startServer) |
| |
| // websocket.Dial() |
| client, err := net.Dial("tcp", serverAddr) |
| if err != nil { |
| t.Fatal("dialing", err) |
| } |
| conn, err := NewClient(newConfig(t, "/echo"), client) |
| if err != nil { |
| t.Errorf("WebSocket handshake error: %v", err) |
| return |
| } |
| |
| msg := []byte("hello, world\n") |
| if _, err := conn.Write(msg); err != nil { |
| t.Errorf("Write: %v", err) |
| } |
| var small_msg = make([]byte, 8) |
| n, err := conn.Read(small_msg) |
| if err != nil { |
| t.Errorf("Read: %v", err) |
| } |
| if !bytes.Equal(msg[:len(small_msg)], small_msg) { |
| t.Errorf("Echo: expected %q got %q", msg[:len(small_msg)], small_msg) |
| } |
| var second_msg = make([]byte, len(msg)) |
| n, err = conn.Read(second_msg) |
| if err != nil { |
| t.Errorf("Read: %v", err) |
| } |
| second_msg = second_msg[0:n] |
| if !bytes.Equal(msg[len(small_msg):], second_msg) { |
| t.Errorf("Echo: expected %q got %q", msg[len(small_msg):], second_msg) |
| } |
| conn.Close() |
| } |
| |
| var parseAuthorityTests = []struct { |
| in *url.URL |
| out string |
| }{ |
| { |
| &url.URL{ |
| Scheme: "ws", |
| Host: "www.google.com", |
| }, |
| "www.google.com:80", |
| }, |
| { |
| &url.URL{ |
| Scheme: "wss", |
| Host: "www.google.com", |
| }, |
| "www.google.com:443", |
| }, |
| { |
| &url.URL{ |
| Scheme: "ws", |
| Host: "www.google.com:80", |
| }, |
| "www.google.com:80", |
| }, |
| { |
| &url.URL{ |
| Scheme: "wss", |
| Host: "www.google.com:443", |
| }, |
| "www.google.com:443", |
| }, |
| // some invalid ones for parseAuthority. parseAuthority doesn't |
| // concern itself with the scheme unless it actually knows about it |
| { |
| &url.URL{ |
| Scheme: "http", |
| Host: "www.google.com", |
| }, |
| "www.google.com", |
| }, |
| { |
| &url.URL{ |
| Scheme: "http", |
| Host: "www.google.com:80", |
| }, |
| "www.google.com:80", |
| }, |
| { |
| &url.URL{ |
| Scheme: "asdf", |
| Host: "127.0.0.1", |
| }, |
| "127.0.0.1", |
| }, |
| { |
| &url.URL{ |
| Scheme: "asdf", |
| Host: "www.google.com", |
| }, |
| "www.google.com", |
| }, |
| } |
| |
| func TestParseAuthority(t *testing.T) { |
| for _, tt := range parseAuthorityTests { |
| out := parseAuthority(tt.in) |
| if out != tt.out { |
| t.Errorf("got %v; want %v", out, tt.out) |
| } |
| } |
| } |
| |
| type closerConn struct { |
| net.Conn |
| closed int // count of the number of times Close was called |
| } |
| |
| func (c *closerConn) Close() error { |
| c.closed++ |
| return c.Conn.Close() |
| } |
| |
| func TestClose(t *testing.T) { |
| if runtime.GOOS == "plan9" { |
| t.Skip("see golang.org/issue/11454") |
| } |
| |
| once.Do(startServer) |
| |
| conn, err := net.Dial("tcp", serverAddr) |
| if err != nil { |
| t.Fatal("dialing", err) |
| } |
| |
| cc := closerConn{Conn: conn} |
| |
| client, err := NewClient(newConfig(t, "/echo"), &cc) |
| if err != nil { |
| t.Fatalf("WebSocket handshake: %v", err) |
| } |
| |
| // set the deadline to ten minutes ago, which will have expired by the time |
| // client.Close sends the close status frame. |
| conn.SetDeadline(time.Now().Add(-10 * time.Minute)) |
| |
| if err := client.Close(); err == nil { |
| t.Errorf("ws.Close(): expected error, got %v", err) |
| } |
| if cc.closed < 1 { |
| t.Fatalf("ws.Close(): expected underlying ws.rwc.Close to be called > 0 times, got: %v", cc.closed) |
| } |
| } |
| |
| var originTests = []struct { |
| req *http.Request |
| origin *url.URL |
| }{ |
| { |
| req: &http.Request{ |
| Header: http.Header{ |
| "Origin": []string{"http://www.example.com"}, |
| }, |
| }, |
| origin: &url.URL{ |
| Scheme: "http", |
| Host: "www.example.com", |
| }, |
| }, |
| { |
| req: &http.Request{}, |
| }, |
| } |
| |
| func TestOrigin(t *testing.T) { |
| conf := newConfig(t, "/echo") |
| conf.Version = ProtocolVersionHybi13 |
| for i, tt := range originTests { |
| origin, err := Origin(conf, tt.req) |
| if err != nil { |
| t.Error(err) |
| continue |
| } |
| if !reflect.DeepEqual(origin, tt.origin) { |
| t.Errorf("#%d: got origin %v; want %v", i, origin, tt.origin) |
| continue |
| } |
| } |
| } |
| |
| func TestCtrlAndData(t *testing.T) { |
| once.Do(startServer) |
| |
| c, err := net.Dial("tcp", serverAddr) |
| if err != nil { |
| t.Fatal(err) |
| } |
| ws, err := NewClient(newConfig(t, "/ctrldata"), c) |
| if err != nil { |
| t.Fatal(err) |
| } |
| defer ws.Close() |
| |
| h := &testCtrlAndDataHandler{hybiFrameHandler: hybiFrameHandler{conn: ws}} |
| ws.frameHandler = h |
| |
| b := make([]byte, 128) |
| for i := 0; i < 2; i++ { |
| data := []byte(fmt.Sprintf("#%d-DATA-FRAME-FROM-CLIENT", i)) |
| if _, err := ws.Write(data); err != nil { |
| t.Fatalf("#%d: %v", i, err) |
| } |
| var ctrl []byte |
| if i%2 != 0 { // with or without payload |
| ctrl = []byte(fmt.Sprintf("#%d-CONTROL-FRAME-FROM-CLIENT", i)) |
| } |
| if _, err := h.WritePing(ctrl); err != nil { |
| t.Fatalf("#%d: %v", i, err) |
| } |
| n, err := ws.Read(b) |
| if err != nil { |
| t.Fatalf("#%d: %v", i, err) |
| } |
| if !bytes.Equal(b[:n], data) { |
| t.Fatalf("#%d: got %v; want %v", i, b[:n], data) |
| } |
| } |
| } |
| |
| func TestCodec_ReceiveLimited(t *testing.T) { |
| const limit = 2048 |
| var payloads [][]byte |
| for _, size := range []int{ |
| 1024, |
| 2048, |
| 4096, // receive of this message would be interrupted due to limit |
| 2048, // this one is to make sure next receive recovers discarding leftovers |
| } { |
| b := make([]byte, size) |
| rand.Read(b) |
| payloads = append(payloads, b) |
| } |
| handlerDone := make(chan struct{}) |
| limitedHandler := func(ws *Conn) { |
| defer close(handlerDone) |
| ws.MaxPayloadBytes = limit |
| defer ws.Close() |
| for i, p := range payloads { |
| t.Logf("payload #%d (size %d, exceeds limit: %v)", i, len(p), len(p) > limit) |
| var recv []byte |
| err := Message.Receive(ws, &recv) |
| switch err { |
| case nil: |
| case ErrFrameTooLarge: |
| if len(p) <= limit { |
| t.Fatalf("unexpected frame size limit: expected %d bytes of payload having limit at %d", len(p), limit) |
| } |
| continue |
| default: |
| t.Fatalf("unexpected error: %v (want either nil or ErrFrameTooLarge)", err) |
| } |
| if len(recv) > limit { |
| t.Fatalf("received %d bytes of payload having limit at %d", len(recv), limit) |
| } |
| if !bytes.Equal(p, recv) { |
| t.Fatalf("received payload differs:\ngot:\t%v\nwant:\t%v", recv, p) |
| } |
| } |
| } |
| server := httptest.NewServer(Handler(limitedHandler)) |
| defer server.CloseClientConnections() |
| defer server.Close() |
| addr := server.Listener.Addr().String() |
| ws, err := Dial("ws://"+addr+"/", "", "http://localhost/") |
| if err != nil { |
| t.Fatal(err) |
| } |
| defer ws.Close() |
| for i, p := range payloads { |
| if err := Message.Send(ws, p); err != nil { |
| t.Fatalf("payload #%d (size %d): %v", i, len(p), err) |
| } |
| } |
| <-handlerDone |
| } |
