vendor/github.com/gorilla/websocket/json_test.go

   1 // Copyright 2013 The Gorilla WebSocket 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         "bytes"
   9         "encoding/json"
  10         "io"
  11         "reflect"
  12         "testing"
  13 )
  14
  15 func TestJSON(t *testing.T) {
  16         var buf bytes.Buffer
  17         wc := newTestConn(nil, &buf, true)
  18         rc := newTestConn(&buf, nil, false)
  19
  20         var actual, expect struct {
  21                 A int
  22                 B string
  23         }
  24         expect.A = 1
  25         expect.B = "hello"
  26
  27         if err := wc.WriteJSON(&expect); err != nil {
  28                 t.Fatal("write", err)
  29         }
  30
  31         if err := rc.ReadJSON(&actual); err != nil {
  32                 t.Fatal("read", err)
  33         }
  34
  35         if !reflect.DeepEqual(&actual, &expect) {
  36                 t.Fatal("equal", actual, expect)
  37         }
  38 }
  39
  40 func TestPartialJSONRead(t *testing.T) {
  41         var buf0, buf1 bytes.Buffer
  42         wc := newTestConn(nil, &buf0, true)
  43         rc := newTestConn(&buf0, &buf1, false)
  44
  45         var v struct {
  46                 A int
  47                 B string
  48         }
  49         v.A = 1
  50         v.B = "hello"
  51
  52         messageCount := 0
  53
  54         // Partial JSON values.
  55
  56         data, err := json.Marshal(v)
  57         if err != nil {
  58                 t.Fatal(err)
  59         }
  60         for i := len(data) - 1; i >= 0; i-- {
  61                 if err := wc.WriteMessage(TextMessage, data[:i]); err != nil {
  62                         t.Fatal(err)
  63                 }
  64                 messageCount++
  65         }
  66
  67         // Whitespace.
  68
  69         if err := wc.WriteMessage(TextMessage, []byte(" ")); err != nil {
  70                 t.Fatal(err)
  71         }
  72         messageCount++
  73
  74         // Close.
  75
  76         if err := wc.WriteMessage(CloseMessage, FormatCloseMessage(CloseNormalClosure, "")); err != nil {
  77                 t.Fatal(err)
  78         }
  79
  80         for i := 0; i < messageCount; i++ {
  81                 err := rc.ReadJSON(&v)
  82                 if err != io.ErrUnexpectedEOF {
  83                         t.Error("read", i, err)
  84                 }
  85         }
  86
  87         err = rc.ReadJSON(&v)
  88         if _, ok := err.(*CloseError); !ok {
  89                 t.Error("final", err)
  90         }
  91 }
  92
  93 func TestDeprecatedJSON(t *testing.T) {
  94         var buf bytes.Buffer
  95         wc := newTestConn(nil, &buf, true)
  96         rc := newTestConn(&buf, nil, false)
  97
  98         var actual, expect struct {
  99                 A int
 100                 B string
 101         }
 102         expect.A = 1
 103         expect.B = "hello"
 104
 105         if err := WriteJSON(wc, &expect); err != nil {
 106                 t.Fatal("write", err)
 107         }
 108
 109         if err := ReadJSON(rc, &actual); err != nil {
 110                 t.Fatal("read", err)
 111         }
 112
 113         if !reflect.DeepEqual(&actual, &expect) {
 114                 t.Fatal("equal", actual, expect)
 115         }
 116 }