package rpctest import ( "bytes" "crypto/rand" "fmt" "testing" . "github.com/tendermint/go-common" ctypes "github.com/tendermint/tendermint/rpc/core/types" "github.com/tendermint/tendermint/types" tmsp "github.com/tendermint/tmsp/types" ) //-------------------------------------------------------------------------------- // Test the HTTP client //-------------------------------------------------------------------------------- //-------------------------------------------------------------------------------- // status func TestURIStatus(t *testing.T) { tmResult := new(ctypes.TMResult) _, err := clientURI.Call("status", map[string]interface{}{}, tmResult) if err != nil { panic(err) } testStatus(t, tmResult) } func TestJSONStatus(t *testing.T) { tmResult := new(ctypes.TMResult) _, err := clientJSON.Call("status", []interface{}{}, tmResult) if err != nil { panic(err) } testStatus(t, tmResult) } func testStatus(t *testing.T, statusI interface{}) { tmRes := statusI.(*ctypes.TMResult) status := (*tmRes).(*ctypes.ResultStatus) if status.NodeInfo.Network != chainID { panic(Fmt("ChainID mismatch: got %s expected %s", status.NodeInfo.Network, chainID)) } } //-------------------------------------------------------------------------------- // broadcast tx sync func testTx() []byte { buf := make([]byte, 16) _, err := rand.Read(buf) if err != nil { panic(err) } return buf } func TestURIBroadcastTxSync(t *testing.T) { config.Set("block_size", 0) defer config.Set("block_size", -1) tmResult := new(ctypes.TMResult) tx := testTx() _, err := clientURI.Call("broadcast_tx_sync", map[string]interface{}{"tx": tx}, tmResult) if err != nil { panic(err) } testBroadcastTxSync(t, tmResult, tx) } func TestJSONBroadcastTxSync(t *testing.T) { config.Set("block_size", 0) defer config.Set("block_size", -1) tmResult := new(ctypes.TMResult) tx := testTx() _, err := clientJSON.Call("broadcast_tx_sync", []interface{}{tx}, tmResult) if err != nil { panic(err) } testBroadcastTxSync(t, tmResult, tx) } func testBroadcastTxSync(t *testing.T, resI interface{}, tx []byte) { tmRes := resI.(*ctypes.TMResult) res := (*tmRes).(*ctypes.ResultBroadcastTx) if res.Code != tmsp.CodeType_OK { panic(Fmt("BroadcastTxSync got non-zero exit code: %v. %X; %s", res.Code, res.Data, res.Log)) } mem := node.MempoolReactor().Mempool if mem.Size() != 1 { panic(Fmt("Mempool size should have been 1. Got %d", mem.Size())) } txs := mem.Reap(1) if !bytes.Equal(txs[0], tx) { panic(Fmt("Tx in mempool does not match test tx. Got %X, expected %X", txs[0], testTx)) } mem.Flush() } //-------------------------------------------------------------------------------- // broadcast tx commit func TestURIBroadcastTxCommit(t *testing.T) { tmResult := new(ctypes.TMResult) tx := testTx() _, err := clientURI.Call("broadcast_tx_commit", map[string]interface{}{"tx": tx}, tmResult) if err != nil { panic(err) } testBroadcastTxCommit(t, tmResult, tx) } func TestJSONBroadcastTxCommit(t *testing.T) { tmResult := new(ctypes.TMResult) tx := testTx() _, err := clientJSON.Call("broadcast_tx_commit", []interface{}{tx}, tmResult) if err != nil { panic(err) } testBroadcastTxCommit(t, tmResult, tx) } func testBroadcastTxCommit(t *testing.T, resI interface{}, tx []byte) { tmRes := resI.(*ctypes.TMResult) res := (*tmRes).(*ctypes.ResultBroadcastTx) if res.Code != tmsp.CodeType_OK { panic(Fmt("BroadcastTxCommit got non-zero exit code: %v. %X; %s", res.Code, res.Data, res.Log)) } mem := node.MempoolReactor().Mempool if mem.Size() != 0 { panic(Fmt("Mempool size should have been 0. Got %d", mem.Size())) } // TODO: find tx in block } //-------------------------------------------------------------------------------- // Test the websocket service var wsTyp = "JSONRPC" // make a simple connection to the server func TestWSConnect(t *testing.T) { wsc := newWSClient(t) wsc.Stop() } // receive a new block message func TestWSNewBlock(t *testing.T) { wsc := newWSClient(t) eid := types.EventStringNewBlock() subscribe(t, wsc, eid) defer func() { unsubscribe(t, wsc, eid) wsc.Stop() }() waitForEvent(t, wsc, eid, true, func() {}, func(eid string, b interface{}) error { fmt.Println("Check:", b) return nil }) } // receive a few new block messages in a row, with increasing height func TestWSBlockchainGrowth(t *testing.T) { if testing.Short() { t.Skip("skipping test in short mode.") } wsc := newWSClient(t) eid := types.EventStringNewBlock() subscribe(t, wsc, eid) defer func() { unsubscribe(t, wsc, eid) wsc.Stop() }() // listen for NewBlock, ensure height increases by 1 var initBlockN int for i := 0; i < 3; i++ { waitForEvent(t, wsc, eid, true, func() {}, func(eid string, eventData interface{}) error { block := eventData.(types.EventDataNewBlock).Block if i == 0 { initBlockN = block.Header.Height } else { if block.Header.Height != initBlockN+i { return fmt.Errorf("Expected block %d, got block %d", initBlockN+i, block.Header.Height) } } return nil }) } } /* TODO: this with dummy app.. func TestWSDoubleFire(t *testing.T) { if testing.Short() { t.Skip("skipping test in short mode.") } con := newWSCon(t) eid := types.EventStringAccInput(user[0].Address) subscribe(t, con, eid) defer func() { unsubscribe(t, con, eid) con.Close() }() amt := int64(100) toAddr := user[1].Address // broadcast the transaction, wait to hear about it waitForEvent(t, con, eid, true, func() { tx := makeDefaultSendTxSigned(t, wsTyp, toAddr, amt) broadcastTx(t, wsTyp, tx) }, func(eid string, b []byte) error { return nil }) // but make sure we don't hear about it twice waitForEvent(t, con, eid, false, func() { }, func(eid string, b []byte) error { return nil }) }*/ //-------------------------------------------------------------------------------- // unsafe_set_config var stringVal = "my string" var intVal = 987654321 var boolVal = true // don't change these var testCasesUnsafeSetConfig = [][]string{ []string{"string", "key1", stringVal}, []string{"int", "key2", fmt.Sprintf("%v", intVal)}, []string{"bool", "key3", fmt.Sprintf("%v", boolVal)}, } func TestURIUnsafeSetConfig(t *testing.T) { for _, testCase := range testCasesUnsafeSetConfig { tmResult := new(ctypes.TMResult) _, err := clientURI.Call("unsafe_set_config", map[string]interface{}{ "type": testCase[0], "key": testCase[1], "value": testCase[2], }, tmResult) if err != nil { panic(err) } } testUnsafeSetConfig(t) } func TestJSONUnsafeSetConfig(t *testing.T) { for _, testCase := range testCasesUnsafeSetConfig { tmResult := new(ctypes.TMResult) _, err := clientJSON.Call("unsafe_set_config", []interface{}{testCase[0], testCase[1], testCase[2]}, tmResult) if err != nil { panic(err) } } testUnsafeSetConfig(t) } func testUnsafeSetConfig(t *testing.T) { s := config.GetString("key1") if s != stringVal { panic(Fmt("got %v, expected %v", s, stringVal)) } i := config.GetInt("key2") if i != intVal { panic(Fmt("got %v, expected %v", i, intVal)) } b := config.GetBool("key3") if b != boolVal { panic(Fmt("got %v, expected %v", b, boolVal)) } }