You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

383 lines
9.0 KiB

8 years ago
limit number of /subscribe clients and queries per client (#3269) * limit number of /subscribe clients and queries per client Add the following config variables (under [rpc] section): * max_subscription_clients * max_subscriptions_per_client * timeout_broadcast_tx_commit Fixes #2826 new HTTPClient interface for subscriptions finalize HTTPClient events interface remove EventSubscriber fix data race ``` WARNING: DATA RACE Read at 0x00c000a36060 by goroutine 129: github.com/tendermint/tendermint/rpc/client.(*Local).Subscribe.func1() /go/src/github.com/tendermint/tendermint/rpc/client/localclient.go:168 +0x1f0 Previous write at 0x00c000a36060 by goroutine 132: github.com/tendermint/tendermint/rpc/client.(*Local).Subscribe() /go/src/github.com/tendermint/tendermint/rpc/client/localclient.go:191 +0x4e0 github.com/tendermint/tendermint/rpc/client.WaitForOneEvent() /go/src/github.com/tendermint/tendermint/rpc/client/helpers.go:64 +0x178 github.com/tendermint/tendermint/rpc/client_test.TestTxEventsSentWithBroadcastTxSync.func1() /go/src/github.com/tendermint/tendermint/rpc/client/event_test.go:139 +0x298 testing.tRunner() /usr/local/go/src/testing/testing.go:827 +0x162 Goroutine 129 (running) created at: github.com/tendermint/tendermint/rpc/client.(*Local).Subscribe() /go/src/github.com/tendermint/tendermint/rpc/client/localclient.go:164 +0x4b7 github.com/tendermint/tendermint/rpc/client.WaitForOneEvent() /go/src/github.com/tendermint/tendermint/rpc/client/helpers.go:64 +0x178 github.com/tendermint/tendermint/rpc/client_test.TestTxEventsSentWithBroadcastTxSync.func1() /go/src/github.com/tendermint/tendermint/rpc/client/event_test.go:139 +0x298 testing.tRunner() /usr/local/go/src/testing/testing.go:827 +0x162 Goroutine 132 (running) created at: testing.(*T).Run() /usr/local/go/src/testing/testing.go:878 +0x659 github.com/tendermint/tendermint/rpc/client_test.TestTxEventsSentWithBroadcastTxSync() /go/src/github.com/tendermint/tendermint/rpc/client/event_test.go:119 +0x186 testing.tRunner() /usr/local/go/src/testing/testing.go:827 +0x162 ================== ``` lite client works (tested manually) godoc comments httpclient: do not close the out channel use TimeoutBroadcastTxCommit no timeout for unsubscribe but 1s Local (5s HTTP) timeout for resubscribe format code change Subscribe#out cap to 1 and replace config vars with RPCConfig TimeoutBroadcastTxCommit can't be greater than rpcserver.WriteTimeout rpc: Context as first parameter to all functions reformat code fixes after my own review fixes after Ethan's review add test stubs fix config.toml * fixes after manual testing - rpc: do not recommend to use BroadcastTxCommit because it's slow and wastes Tendermint resources (pubsub) - rpc: better error in Subscribe and BroadcastTxCommit - HTTPClient: do not resubscribe if err = ErrAlreadySubscribed * fixes after Ismail's review * Update rpc/grpc/grpc_test.go Co-Authored-By: melekes <anton.kalyaev@gmail.com>
6 years ago
limit number of /subscribe clients and queries per client (#3269) * limit number of /subscribe clients and queries per client Add the following config variables (under [rpc] section): * max_subscription_clients * max_subscriptions_per_client * timeout_broadcast_tx_commit Fixes #2826 new HTTPClient interface for subscriptions finalize HTTPClient events interface remove EventSubscriber fix data race ``` WARNING: DATA RACE Read at 0x00c000a36060 by goroutine 129: github.com/tendermint/tendermint/rpc/client.(*Local).Subscribe.func1() /go/src/github.com/tendermint/tendermint/rpc/client/localclient.go:168 +0x1f0 Previous write at 0x00c000a36060 by goroutine 132: github.com/tendermint/tendermint/rpc/client.(*Local).Subscribe() /go/src/github.com/tendermint/tendermint/rpc/client/localclient.go:191 +0x4e0 github.com/tendermint/tendermint/rpc/client.WaitForOneEvent() /go/src/github.com/tendermint/tendermint/rpc/client/helpers.go:64 +0x178 github.com/tendermint/tendermint/rpc/client_test.TestTxEventsSentWithBroadcastTxSync.func1() /go/src/github.com/tendermint/tendermint/rpc/client/event_test.go:139 +0x298 testing.tRunner() /usr/local/go/src/testing/testing.go:827 +0x162 Goroutine 129 (running) created at: github.com/tendermint/tendermint/rpc/client.(*Local).Subscribe() /go/src/github.com/tendermint/tendermint/rpc/client/localclient.go:164 +0x4b7 github.com/tendermint/tendermint/rpc/client.WaitForOneEvent() /go/src/github.com/tendermint/tendermint/rpc/client/helpers.go:64 +0x178 github.com/tendermint/tendermint/rpc/client_test.TestTxEventsSentWithBroadcastTxSync.func1() /go/src/github.com/tendermint/tendermint/rpc/client/event_test.go:139 +0x298 testing.tRunner() /usr/local/go/src/testing/testing.go:827 +0x162 Goroutine 132 (running) created at: testing.(*T).Run() /usr/local/go/src/testing/testing.go:878 +0x659 github.com/tendermint/tendermint/rpc/client_test.TestTxEventsSentWithBroadcastTxSync() /go/src/github.com/tendermint/tendermint/rpc/client/event_test.go:119 +0x186 testing.tRunner() /usr/local/go/src/testing/testing.go:827 +0x162 ================== ``` lite client works (tested manually) godoc comments httpclient: do not close the out channel use TimeoutBroadcastTxCommit no timeout for unsubscribe but 1s Local (5s HTTP) timeout for resubscribe format code change Subscribe#out cap to 1 and replace config vars with RPCConfig TimeoutBroadcastTxCommit can't be greater than rpcserver.WriteTimeout rpc: Context as first parameter to all functions reformat code fixes after my own review fixes after Ethan's review add test stubs fix config.toml * fixes after manual testing - rpc: do not recommend to use BroadcastTxCommit because it's slow and wastes Tendermint resources (pubsub) - rpc: better error in Subscribe and BroadcastTxCommit - HTTPClient: do not resubscribe if err = ErrAlreadySubscribed * fixes after Ismail's review * Update rpc/grpc/grpc_test.go Co-Authored-By: melekes <anton.kalyaev@gmail.com>
6 years ago
limit number of /subscribe clients and queries per client (#3269) * limit number of /subscribe clients and queries per client Add the following config variables (under [rpc] section): * max_subscription_clients * max_subscriptions_per_client * timeout_broadcast_tx_commit Fixes #2826 new HTTPClient interface for subscriptions finalize HTTPClient events interface remove EventSubscriber fix data race ``` WARNING: DATA RACE Read at 0x00c000a36060 by goroutine 129: github.com/tendermint/tendermint/rpc/client.(*Local).Subscribe.func1() /go/src/github.com/tendermint/tendermint/rpc/client/localclient.go:168 +0x1f0 Previous write at 0x00c000a36060 by goroutine 132: github.com/tendermint/tendermint/rpc/client.(*Local).Subscribe() /go/src/github.com/tendermint/tendermint/rpc/client/localclient.go:191 +0x4e0 github.com/tendermint/tendermint/rpc/client.WaitForOneEvent() /go/src/github.com/tendermint/tendermint/rpc/client/helpers.go:64 +0x178 github.com/tendermint/tendermint/rpc/client_test.TestTxEventsSentWithBroadcastTxSync.func1() /go/src/github.com/tendermint/tendermint/rpc/client/event_test.go:139 +0x298 testing.tRunner() /usr/local/go/src/testing/testing.go:827 +0x162 Goroutine 129 (running) created at: github.com/tendermint/tendermint/rpc/client.(*Local).Subscribe() /go/src/github.com/tendermint/tendermint/rpc/client/localclient.go:164 +0x4b7 github.com/tendermint/tendermint/rpc/client.WaitForOneEvent() /go/src/github.com/tendermint/tendermint/rpc/client/helpers.go:64 +0x178 github.com/tendermint/tendermint/rpc/client_test.TestTxEventsSentWithBroadcastTxSync.func1() /go/src/github.com/tendermint/tendermint/rpc/client/event_test.go:139 +0x298 testing.tRunner() /usr/local/go/src/testing/testing.go:827 +0x162 Goroutine 132 (running) created at: testing.(*T).Run() /usr/local/go/src/testing/testing.go:878 +0x659 github.com/tendermint/tendermint/rpc/client_test.TestTxEventsSentWithBroadcastTxSync() /go/src/github.com/tendermint/tendermint/rpc/client/event_test.go:119 +0x186 testing.tRunner() /usr/local/go/src/testing/testing.go:827 +0x162 ================== ``` lite client works (tested manually) godoc comments httpclient: do not close the out channel use TimeoutBroadcastTxCommit no timeout for unsubscribe but 1s Local (5s HTTP) timeout for resubscribe format code change Subscribe#out cap to 1 and replace config vars with RPCConfig TimeoutBroadcastTxCommit can't be greater than rpcserver.WriteTimeout rpc: Context as first parameter to all functions reformat code fixes after my own review fixes after Ethan's review add test stubs fix config.toml * fixes after manual testing - rpc: do not recommend to use BroadcastTxCommit because it's slow and wastes Tendermint resources (pubsub) - rpc: better error in Subscribe and BroadcastTxCommit - HTTPClient: do not resubscribe if err = ErrAlreadySubscribed * fixes after Ismail's review * Update rpc/grpc/grpc_test.go Co-Authored-By: melekes <anton.kalyaev@gmail.com>
6 years ago
limit number of /subscribe clients and queries per client (#3269) * limit number of /subscribe clients and queries per client Add the following config variables (under [rpc] section): * max_subscription_clients * max_subscriptions_per_client * timeout_broadcast_tx_commit Fixes #2826 new HTTPClient interface for subscriptions finalize HTTPClient events interface remove EventSubscriber fix data race ``` WARNING: DATA RACE Read at 0x00c000a36060 by goroutine 129: github.com/tendermint/tendermint/rpc/client.(*Local).Subscribe.func1() /go/src/github.com/tendermint/tendermint/rpc/client/localclient.go:168 +0x1f0 Previous write at 0x00c000a36060 by goroutine 132: github.com/tendermint/tendermint/rpc/client.(*Local).Subscribe() /go/src/github.com/tendermint/tendermint/rpc/client/localclient.go:191 +0x4e0 github.com/tendermint/tendermint/rpc/client.WaitForOneEvent() /go/src/github.com/tendermint/tendermint/rpc/client/helpers.go:64 +0x178 github.com/tendermint/tendermint/rpc/client_test.TestTxEventsSentWithBroadcastTxSync.func1() /go/src/github.com/tendermint/tendermint/rpc/client/event_test.go:139 +0x298 testing.tRunner() /usr/local/go/src/testing/testing.go:827 +0x162 Goroutine 129 (running) created at: github.com/tendermint/tendermint/rpc/client.(*Local).Subscribe() /go/src/github.com/tendermint/tendermint/rpc/client/localclient.go:164 +0x4b7 github.com/tendermint/tendermint/rpc/client.WaitForOneEvent() /go/src/github.com/tendermint/tendermint/rpc/client/helpers.go:64 +0x178 github.com/tendermint/tendermint/rpc/client_test.TestTxEventsSentWithBroadcastTxSync.func1() /go/src/github.com/tendermint/tendermint/rpc/client/event_test.go:139 +0x298 testing.tRunner() /usr/local/go/src/testing/testing.go:827 +0x162 Goroutine 132 (running) created at: testing.(*T).Run() /usr/local/go/src/testing/testing.go:878 +0x659 github.com/tendermint/tendermint/rpc/client_test.TestTxEventsSentWithBroadcastTxSync() /go/src/github.com/tendermint/tendermint/rpc/client/event_test.go:119 +0x186 testing.tRunner() /usr/local/go/src/testing/testing.go:827 +0x162 ================== ``` lite client works (tested manually) godoc comments httpclient: do not close the out channel use TimeoutBroadcastTxCommit no timeout for unsubscribe but 1s Local (5s HTTP) timeout for resubscribe format code change Subscribe#out cap to 1 and replace config vars with RPCConfig TimeoutBroadcastTxCommit can't be greater than rpcserver.WriteTimeout rpc: Context as first parameter to all functions reformat code fixes after my own review fixes after Ethan's review add test stubs fix config.toml * fixes after manual testing - rpc: do not recommend to use BroadcastTxCommit because it's slow and wastes Tendermint resources (pubsub) - rpc: better error in Subscribe and BroadcastTxCommit - HTTPClient: do not resubscribe if err = ErrAlreadySubscribed * fixes after Ismail's review * Update rpc/grpc/grpc_test.go Co-Authored-By: melekes <anton.kalyaev@gmail.com>
6 years ago
8 years ago
8 years ago
8 years ago
8 years ago
8 years ago
8 years ago
8 years ago
7 years ago
7 years ago
7 years ago
7 years ago
  1. package jsonrpc
  2. import (
  3. "bytes"
  4. "context"
  5. crand "crypto/rand"
  6. "encoding/json"
  7. "fmt"
  8. "net/http"
  9. "os"
  10. "os/exec"
  11. "testing"
  12. "time"
  13. "github.com/go-kit/kit/log/term"
  14. "github.com/stretchr/testify/assert"
  15. "github.com/stretchr/testify/require"
  16. tmbytes "github.com/tendermint/tendermint/libs/bytes"
  17. "github.com/tendermint/tendermint/libs/log"
  18. tmrand "github.com/tendermint/tendermint/libs/rand"
  19. client "github.com/tendermint/tendermint/rpc/jsonrpc/client"
  20. server "github.com/tendermint/tendermint/rpc/jsonrpc/server"
  21. types "github.com/tendermint/tendermint/rpc/jsonrpc/types"
  22. )
  23. // Client and Server should work over tcp or unix sockets
  24. const (
  25. tcpAddr = "tcp://127.0.0.1:47768"
  26. unixSocket = "/tmp/rpc_test.sock"
  27. unixAddr = "unix://" + unixSocket
  28. websocketEndpoint = "/websocket/endpoint"
  29. testVal = "acbd"
  30. )
  31. type ResultEcho struct {
  32. Value string `json:"value"`
  33. }
  34. type ResultEchoInt struct {
  35. Value int `json:"value"`
  36. }
  37. type ResultEchoBytes struct {
  38. Value []byte `json:"value"`
  39. }
  40. type ResultEchoDataBytes struct {
  41. Value tmbytes.HexBytes `json:"value"`
  42. }
  43. // Define some routes
  44. var Routes = map[string]*server.RPCFunc{
  45. "echo": server.NewRPCFunc(EchoResult, "arg"),
  46. "echo_ws": server.NewWSRPCFunc(EchoWSResult, "arg"),
  47. "echo_bytes": server.NewRPCFunc(EchoBytesResult, "arg"),
  48. "echo_data_bytes": server.NewRPCFunc(EchoDataBytesResult, "arg"),
  49. "echo_int": server.NewRPCFunc(EchoIntResult, "arg"),
  50. }
  51. func EchoResult(ctx *types.Context, v string) (*ResultEcho, error) {
  52. return &ResultEcho{v}, nil
  53. }
  54. func EchoWSResult(ctx *types.Context, v string) (*ResultEcho, error) {
  55. return &ResultEcho{v}, nil
  56. }
  57. func EchoIntResult(ctx *types.Context, v int) (*ResultEchoInt, error) {
  58. return &ResultEchoInt{v}, nil
  59. }
  60. func EchoBytesResult(ctx *types.Context, v []byte) (*ResultEchoBytes, error) {
  61. return &ResultEchoBytes{v}, nil
  62. }
  63. func EchoDataBytesResult(ctx *types.Context, v tmbytes.HexBytes) (*ResultEchoDataBytes, error) {
  64. return &ResultEchoDataBytes{v}, nil
  65. }
  66. func TestMain(m *testing.M) {
  67. setup()
  68. code := m.Run()
  69. os.Exit(code)
  70. }
  71. var colorFn = func(keyvals ...interface{}) term.FgBgColor {
  72. for i := 0; i < len(keyvals)-1; i += 2 {
  73. if keyvals[i] == "socket" {
  74. if keyvals[i+1] == "tcp" {
  75. return term.FgBgColor{Fg: term.DarkBlue}
  76. } else if keyvals[i+1] == "unix" {
  77. return term.FgBgColor{Fg: term.DarkCyan}
  78. }
  79. }
  80. }
  81. return term.FgBgColor{}
  82. }
  83. // launch unix and tcp servers
  84. func setup() {
  85. logger := log.NewTMLoggerWithColorFn(log.NewSyncWriter(os.Stdout), colorFn)
  86. cmd := exec.Command("rm", "-f", unixSocket)
  87. err := cmd.Start()
  88. if err != nil {
  89. panic(err)
  90. }
  91. if err = cmd.Wait(); err != nil {
  92. panic(err)
  93. }
  94. tcpLogger := logger.With("socket", "tcp")
  95. mux := http.NewServeMux()
  96. server.RegisterRPCFuncs(mux, Routes, tcpLogger)
  97. wm := server.NewWebsocketManager(Routes, server.ReadWait(5*time.Second), server.PingPeriod(1*time.Second))
  98. wm.SetLogger(tcpLogger)
  99. mux.HandleFunc(websocketEndpoint, wm.WebsocketHandler)
  100. config := server.DefaultConfig()
  101. listener1, err := server.Listen(tcpAddr, config)
  102. if err != nil {
  103. panic(err)
  104. }
  105. go server.Serve(listener1, mux, tcpLogger, config)
  106. unixLogger := logger.With("socket", "unix")
  107. mux2 := http.NewServeMux()
  108. server.RegisterRPCFuncs(mux2, Routes, unixLogger)
  109. wm = server.NewWebsocketManager(Routes)
  110. wm.SetLogger(unixLogger)
  111. mux2.HandleFunc(websocketEndpoint, wm.WebsocketHandler)
  112. listener2, err := server.Listen(unixAddr, config)
  113. if err != nil {
  114. panic(err)
  115. }
  116. go server.Serve(listener2, mux2, unixLogger, config)
  117. // wait for servers to start
  118. time.Sleep(time.Second * 2)
  119. }
  120. func echoViaHTTP(cl client.Caller, val string) (string, error) {
  121. params := map[string]interface{}{
  122. "arg": val,
  123. }
  124. result := new(ResultEcho)
  125. if _, err := cl.Call("echo", params, result); err != nil {
  126. return "", err
  127. }
  128. return result.Value, nil
  129. }
  130. func echoIntViaHTTP(cl client.Caller, val int) (int, error) {
  131. params := map[string]interface{}{
  132. "arg": val,
  133. }
  134. result := new(ResultEchoInt)
  135. if _, err := cl.Call("echo_int", params, result); err != nil {
  136. return 0, err
  137. }
  138. return result.Value, nil
  139. }
  140. func echoBytesViaHTTP(cl client.Caller, bytes []byte) ([]byte, error) {
  141. params := map[string]interface{}{
  142. "arg": bytes,
  143. }
  144. result := new(ResultEchoBytes)
  145. if _, err := cl.Call("echo_bytes", params, result); err != nil {
  146. return []byte{}, err
  147. }
  148. return result.Value, nil
  149. }
  150. func echoDataBytesViaHTTP(cl client.Caller, bytes tmbytes.HexBytes) (tmbytes.HexBytes, error) {
  151. params := map[string]interface{}{
  152. "arg": bytes,
  153. }
  154. result := new(ResultEchoDataBytes)
  155. if _, err := cl.Call("echo_data_bytes", params, result); err != nil {
  156. return []byte{}, err
  157. }
  158. return result.Value, nil
  159. }
  160. func testWithHTTPClient(t *testing.T, cl client.HTTPClient) {
  161. val := testVal
  162. got, err := echoViaHTTP(cl, val)
  163. require.Nil(t, err)
  164. assert.Equal(t, got, val)
  165. val2 := randBytes(t)
  166. got2, err := echoBytesViaHTTP(cl, val2)
  167. require.Nil(t, err)
  168. assert.Equal(t, got2, val2)
  169. val3 := tmbytes.HexBytes(randBytes(t))
  170. got3, err := echoDataBytesViaHTTP(cl, val3)
  171. require.Nil(t, err)
  172. assert.Equal(t, got3, val3)
  173. val4 := tmrand.Intn(10000)
  174. got4, err := echoIntViaHTTP(cl, val4)
  175. require.Nil(t, err)
  176. assert.Equal(t, got4, val4)
  177. }
  178. func echoViaWS(cl *client.WSClient, val string) (string, error) {
  179. params := map[string]interface{}{
  180. "arg": val,
  181. }
  182. err := cl.Call(context.Background(), "echo", params)
  183. if err != nil {
  184. return "", err
  185. }
  186. msg := <-cl.ResponsesCh
  187. if msg.Error != nil {
  188. return "", err
  189. }
  190. result := new(ResultEcho)
  191. err = json.Unmarshal(msg.Result, result)
  192. if err != nil {
  193. return "", nil
  194. }
  195. return result.Value, nil
  196. }
  197. func echoBytesViaWS(cl *client.WSClient, bytes []byte) ([]byte, error) {
  198. params := map[string]interface{}{
  199. "arg": bytes,
  200. }
  201. err := cl.Call(context.Background(), "echo_bytes", params)
  202. if err != nil {
  203. return []byte{}, err
  204. }
  205. msg := <-cl.ResponsesCh
  206. if msg.Error != nil {
  207. return []byte{}, msg.Error
  208. }
  209. result := new(ResultEchoBytes)
  210. err = json.Unmarshal(msg.Result, result)
  211. if err != nil {
  212. return []byte{}, nil
  213. }
  214. return result.Value, nil
  215. }
  216. func testWithWSClient(t *testing.T, cl *client.WSClient) {
  217. val := testVal
  218. got, err := echoViaWS(cl, val)
  219. require.Nil(t, err)
  220. assert.Equal(t, got, val)
  221. val2 := randBytes(t)
  222. got2, err := echoBytesViaWS(cl, val2)
  223. require.Nil(t, err)
  224. assert.Equal(t, got2, val2)
  225. }
  226. //-------------
  227. func TestServersAndClientsBasic(t *testing.T) {
  228. serverAddrs := [...]string{tcpAddr, unixAddr}
  229. for _, addr := range serverAddrs {
  230. cl1, err := client.NewURI(addr)
  231. require.Nil(t, err)
  232. fmt.Printf("=== testing server on %s using URI client", addr)
  233. testWithHTTPClient(t, cl1)
  234. cl2, err := client.New(addr)
  235. require.Nil(t, err)
  236. fmt.Printf("=== testing server on %s using JSONRPC client", addr)
  237. testWithHTTPClient(t, cl2)
  238. cl3, err := client.NewWS(addr, websocketEndpoint)
  239. require.Nil(t, err)
  240. cl3.SetLogger(log.TestingLogger())
  241. err = cl3.Start()
  242. require.Nil(t, err)
  243. fmt.Printf("=== testing server on %s using WS client", addr)
  244. testWithWSClient(t, cl3)
  245. cl3.Stop()
  246. }
  247. }
  248. func TestHexStringArg(t *testing.T) {
  249. cl, err := client.NewURI(tcpAddr)
  250. require.Nil(t, err)
  251. // should NOT be handled as hex
  252. val := "0xabc"
  253. got, err := echoViaHTTP(cl, val)
  254. require.Nil(t, err)
  255. assert.Equal(t, got, val)
  256. }
  257. func TestQuotedStringArg(t *testing.T) {
  258. cl, err := client.NewURI(tcpAddr)
  259. require.Nil(t, err)
  260. // should NOT be unquoted
  261. val := "\"abc\""
  262. got, err := echoViaHTTP(cl, val)
  263. require.Nil(t, err)
  264. assert.Equal(t, got, val)
  265. }
  266. func TestWSNewWSRPCFunc(t *testing.T) {
  267. cl, err := client.NewWS(tcpAddr, websocketEndpoint)
  268. require.Nil(t, err)
  269. cl.SetLogger(log.TestingLogger())
  270. err = cl.Start()
  271. require.Nil(t, err)
  272. defer cl.Stop()
  273. val := testVal
  274. params := map[string]interface{}{
  275. "arg": val,
  276. }
  277. err = cl.Call(context.Background(), "echo_ws", params)
  278. require.Nil(t, err)
  279. msg := <-cl.ResponsesCh
  280. if msg.Error != nil {
  281. t.Fatal(err)
  282. }
  283. result := new(ResultEcho)
  284. err = json.Unmarshal(msg.Result, result)
  285. require.Nil(t, err)
  286. got := result.Value
  287. assert.Equal(t, got, val)
  288. }
  289. func TestWSHandlesArrayParams(t *testing.T) {
  290. cl, err := client.NewWS(tcpAddr, websocketEndpoint)
  291. require.Nil(t, err)
  292. cl.SetLogger(log.TestingLogger())
  293. err = cl.Start()
  294. require.Nil(t, err)
  295. defer cl.Stop()
  296. val := testVal
  297. params := []interface{}{val}
  298. err = cl.CallWithArrayParams(context.Background(), "echo_ws", params)
  299. require.Nil(t, err)
  300. msg := <-cl.ResponsesCh
  301. if msg.Error != nil {
  302. t.Fatalf("%+v", err)
  303. }
  304. result := new(ResultEcho)
  305. err = json.Unmarshal(msg.Result, result)
  306. require.Nil(t, err)
  307. got := result.Value
  308. assert.Equal(t, got, val)
  309. }
  310. // TestWSClientPingPong checks that a client & server exchange pings
  311. // & pongs so connection stays alive.
  312. func TestWSClientPingPong(t *testing.T) {
  313. cl, err := client.NewWS(tcpAddr, websocketEndpoint)
  314. require.Nil(t, err)
  315. cl.SetLogger(log.TestingLogger())
  316. err = cl.Start()
  317. require.Nil(t, err)
  318. defer cl.Stop()
  319. time.Sleep(6 * time.Second)
  320. }
  321. func randBytes(t *testing.T) []byte {
  322. n := tmrand.Intn(10) + 2
  323. buf := make([]byte, n)
  324. _, err := crand.Read(buf)
  325. require.Nil(t, err)
  326. return bytes.Replace(buf, []byte("="), []byte{100}, -1)
  327. }