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.

387 lines
10 KiB

blockchain: Reorg reactor (#3561) * go routines in blockchain reactor * Added reference to the go routine diagram * Initial commit * cleanup * Undo testing_logger change, committed by mistake * Fix the test loggers * pulled some fsm code into pool.go * added pool tests * changes to the design added block requests under peer moved the request trigger in the reactor poolRoutine, triggered now by a ticker in general moved everything required for making block requests smarter in the poolRoutine added a simple map of heights to keep track of what will need to be requested next added a few more tests * send errors to FSM in a different channel than blocks send errors (RemovePeer) from switch on a different channel than the one receiving blocks renamed channels added more pool tests * more pool tests * lint errors * more tests * more tests * switch fast sync to new implementation * fixed data race in tests * cleanup * finished fsm tests * address golangci comments :) * address golangci comments :) * Added timeout on next block needed to advance * updating docs and cleanup * fix issue in test from previous cleanup * cleanup * Added termination scenarios, tests and more cleanup * small fixes to adr, comments and cleanup * Fix bug in sendRequest() If we tried to send a request to a peer not present in the switch, a missing continue statement caused the request to be blackholed in a peer that was removed and never retried. While this bug was manifesting, the reactor kept asking for other blocks that would be stored and never consumed. Added the number of unconsumed blocks in the math for requesting blocks ahead of current processing height so eventually there will be no more blocks requested until the already received ones are consumed. * remove bpPeer's didTimeout field * Use distinct err codes for peer timeout and FSM timeouts * Don't allow peers to update with lower height * review comments from Ethan and Zarko * some cleanup, renaming, comments * Move block execution in separate goroutine * Remove pool's numPending * review comments * fix lint, remove old blockchain reactor and duplicates in fsm tests * small reorg around peer after review comments * add the reactor spec * verify block only once * review comments * change to int for max number of pending requests * cleanup and godoc * Add configuration flag fast sync version * golangci fixes * fix config template * move both reactor versions under blockchain * cleanup, golint, renaming stuff * updated documentation, fixed more golint warnings * integrate with behavior package * sync with master * gofmt * add changelog_pending entry * move to improvments * suggestion to changelog entry
5 years ago
mempool: move interface into mempool package (#3524) ## Description Refs #2659 Breaking changes in the mempool package: [mempool] #2659 Mempool now an interface old Mempool renamed to CListMempool NewMempool renamed to NewCListMempool Option renamed to CListOption MempoolReactor renamed to Reactor NewMempoolReactor renamed to NewReactor unexpose TxID method TxInfo.PeerID renamed to SenderID unexpose MempoolReactor.Mempool Breaking changes in the state package: [state] #2659 Mempool interface moved to mempool package MockMempool moved to top-level mock package and renamed to Mempool Non Breaking changes in the node package: [node] #2659 Add Mempool method, which allows you to access mempool ## Commits * move Mempool interface into mempool package Refs #2659 Breaking changes in the mempool package: - Mempool now an interface - old Mempool renamed to CListMempool Breaking changes to state package: - MockMempool moved to mempool/mock package and renamed to Mempool - Mempool interface moved to mempool package * assert CListMempool impl Mempool * gofmt code * rename MempoolReactor to Reactor - combine everything into one interface - rename TxInfo.PeerID to TxInfo.SenderID - unexpose MempoolReactor.Mempool * move mempool mock into top-level mock package * add a fixme TxsFront should not be a part of the Mempool interface because it leaks implementation details. Instead, we need to come up with general interface for querying the mempool so the MempoolReactor can fetch and broadcast txs to peers. * change node#Mempool to return interface * save commit = new reactor arch * Revert "save commit = new reactor arch" This reverts commit 1bfceacd9d65a720574683a7f22771e69af9af4d. * require CListMempool in mempool.Reactor * add two changelog entries * fixes after my own review * quote interfaces, structs and functions * fixes after Ismail's review * make node's mempool an interface * make InitWAL/CloseWAL methods a part of Mempool interface * fix merge conflicts * make node's mempool an interface
6 years ago
blockchain: Reorg reactor (#3561) * go routines in blockchain reactor * Added reference to the go routine diagram * Initial commit * cleanup * Undo testing_logger change, committed by mistake * Fix the test loggers * pulled some fsm code into pool.go * added pool tests * changes to the design added block requests under peer moved the request trigger in the reactor poolRoutine, triggered now by a ticker in general moved everything required for making block requests smarter in the poolRoutine added a simple map of heights to keep track of what will need to be requested next added a few more tests * send errors to FSM in a different channel than blocks send errors (RemovePeer) from switch on a different channel than the one receiving blocks renamed channels added more pool tests * more pool tests * lint errors * more tests * more tests * switch fast sync to new implementation * fixed data race in tests * cleanup * finished fsm tests * address golangci comments :) * address golangci comments :) * Added timeout on next block needed to advance * updating docs and cleanup * fix issue in test from previous cleanup * cleanup * Added termination scenarios, tests and more cleanup * small fixes to adr, comments and cleanup * Fix bug in sendRequest() If we tried to send a request to a peer not present in the switch, a missing continue statement caused the request to be blackholed in a peer that was removed and never retried. While this bug was manifesting, the reactor kept asking for other blocks that would be stored and never consumed. Added the number of unconsumed blocks in the math for requesting blocks ahead of current processing height so eventually there will be no more blocks requested until the already received ones are consumed. * remove bpPeer's didTimeout field * Use distinct err codes for peer timeout and FSM timeouts * Don't allow peers to update with lower height * review comments from Ethan and Zarko * some cleanup, renaming, comments * Move block execution in separate goroutine * Remove pool's numPending * review comments * fix lint, remove old blockchain reactor and duplicates in fsm tests * small reorg around peer after review comments * add the reactor spec * verify block only once * review comments * change to int for max number of pending requests * cleanup and godoc * Add configuration flag fast sync version * golangci fixes * fix config template * move both reactor versions under blockchain * cleanup, golint, renaming stuff * updated documentation, fixed more golint warnings * integrate with behavior package * sync with master * gofmt * add changelog_pending entry * move to improvments * suggestion to changelog entry
5 years ago
cs/replay: execCommitBlock should not read from state.lastValidators (#3067) * execCommitBlock should not read from state.lastValidators * fix height 1 * fix blockchain/reactor_test * fix consensus/mempool_test * fix consensus/reactor_test * fix consensus/replay_test * add CHANGELOG * fix consensus/reactor_test * fix consensus/replay_test * add a test for replay validators change * fix mem_pool test * fix byzantine test * remove a redundant code * reduce validator change blocks to 6 * fix * return peer0 config * seperate testName * seperate testName 1 * seperate testName 2 * seperate app db path * seperate app db path 1 * add a lock before startNet * move the lock to reactor_test * simulate just once * try to find problem * handshake only saveState when app version changed * update gometalinter to 3.0.0 (#3233) in the attempt to fix https://circleci.com/gh/tendermint/tendermint/43165 also code is simplified by running gofmt -s . remove unused vars enable linters we're currently passing remove deprecated linters (cherry picked from commit d47094550315c094512a242445e0dde24b5a03f5) * gofmt code * goimport code * change the bool name to testValidatorsChange * adjust receive kvstore.ProtocolVersion * adjust receive kvstore.ProtocolVersion 1 * adjust receive kvstore.ProtocolVersion 3 * fix merge execution.go * fix merge develop * fix merge develop 1 * fix run cleanupFunc * adjust code according to reviewers' opinion * modify the func name match the convention * simplify simulate a chain containing some validator change txs 1 * test CI error * Merge remote-tracking branch 'upstream/develop' into fixReplay 1 * fix pubsub_test * subscribeUnbuffered vote channel
6 years ago
mempool: move interface into mempool package (#3524) ## Description Refs #2659 Breaking changes in the mempool package: [mempool] #2659 Mempool now an interface old Mempool renamed to CListMempool NewMempool renamed to NewCListMempool Option renamed to CListOption MempoolReactor renamed to Reactor NewMempoolReactor renamed to NewReactor unexpose TxID method TxInfo.PeerID renamed to SenderID unexpose MempoolReactor.Mempool Breaking changes in the state package: [state] #2659 Mempool interface moved to mempool package MockMempool moved to top-level mock package and renamed to Mempool Non Breaking changes in the node package: [node] #2659 Add Mempool method, which allows you to access mempool ## Commits * move Mempool interface into mempool package Refs #2659 Breaking changes in the mempool package: - Mempool now an interface - old Mempool renamed to CListMempool Breaking changes to state package: - MockMempool moved to mempool/mock package and renamed to Mempool - Mempool interface moved to mempool package * assert CListMempool impl Mempool * gofmt code * rename MempoolReactor to Reactor - combine everything into one interface - rename TxInfo.PeerID to TxInfo.SenderID - unexpose MempoolReactor.Mempool * move mempool mock into top-level mock package * add a fixme TxsFront should not be a part of the Mempool interface because it leaks implementation details. Instead, we need to come up with general interface for querying the mempool so the MempoolReactor can fetch and broadcast txs to peers. * change node#Mempool to return interface * save commit = new reactor arch * Revert "save commit = new reactor arch" This reverts commit 1bfceacd9d65a720574683a7f22771e69af9af4d. * require CListMempool in mempool.Reactor * add two changelog entries * fixes after my own review * quote interfaces, structs and functions * fixes after Ismail's review * make node's mempool an interface * make InitWAL/CloseWAL methods a part of Mempool interface * fix merge conflicts * make node's mempool an interface
6 years ago
cs/replay: execCommitBlock should not read from state.lastValidators (#3067) * execCommitBlock should not read from state.lastValidators * fix height 1 * fix blockchain/reactor_test * fix consensus/mempool_test * fix consensus/reactor_test * fix consensus/replay_test * add CHANGELOG * fix consensus/reactor_test * fix consensus/replay_test * add a test for replay validators change * fix mem_pool test * fix byzantine test * remove a redundant code * reduce validator change blocks to 6 * fix * return peer0 config * seperate testName * seperate testName 1 * seperate testName 2 * seperate app db path * seperate app db path 1 * add a lock before startNet * move the lock to reactor_test * simulate just once * try to find problem * handshake only saveState when app version changed * update gometalinter to 3.0.0 (#3233) in the attempt to fix https://circleci.com/gh/tendermint/tendermint/43165 also code is simplified by running gofmt -s . remove unused vars enable linters we're currently passing remove deprecated linters (cherry picked from commit d47094550315c094512a242445e0dde24b5a03f5) * gofmt code * goimport code * change the bool name to testValidatorsChange * adjust receive kvstore.ProtocolVersion * adjust receive kvstore.ProtocolVersion 1 * adjust receive kvstore.ProtocolVersion 3 * fix merge execution.go * fix merge develop * fix merge develop 1 * fix run cleanupFunc * adjust code according to reviewers' opinion * modify the func name match the convention * simplify simulate a chain containing some validator change txs 1 * test CI error * Merge remote-tracking branch 'upstream/develop' into fixReplay 1 * fix pubsub_test * subscribeUnbuffered vote channel
6 years ago
abci: Refactor tagging events using list of lists (#3643) ## PR This PR introduces a fundamental breaking change to the structure of ABCI response and tx tags and the way they're processed. Namely, the SDK can support more complex and aggregated events for distribution and slashing. In addition, block responses can include duplicate keys in events. Implement new Event type. An event has a type and a list of KV pairs (ie. list-of-lists). Typical events may look like: "rewards": [{"amount": "5000uatom", "validator": "...", "recipient": "..."}] "sender": [{"address": "...", "balance": "100uatom"}] The events are indexed by {even.type}.{even.attribute[i].key}/.... In this case a client would subscribe or query for rewards.recipient='...' ABCI response types and related types now include Events []Event instead of Tags []cmn.KVPair. PubSub logic now publishes/matches against map[string][]string instead of map[string]string to support duplicate keys in response events (from #1385). A match is successful if the value is found in the slice of strings. closes: #1859 closes: #2905 ## Commits: * Implement Event ABCI type and updates responses to use events * Update messages_test.go * Update kvstore.go * Update event_bus.go * Update subscription.go * Update pubsub.go * Update kvstore.go * Update query logic to handle slice of strings in events * Update Empty#Matches and unit tests * Update pubsub logic * Update EventBus#Publish * Update kv tx indexer * Update godocs * Update ResultEvent to use slice of strings; update RPC * Update more tests * Update abci.md * Check for key in validateAndStringifyEvents * Fix KV indexer to skip empty keys * Fix linting errors * Update CHANGELOG_PENDING.md * Update docs/spec/abci/abci.md Co-Authored-By: Federico Kunze <31522760+fedekunze@users.noreply.github.com> * Update abci/types/types.proto Co-Authored-By: Ethan Buchman <ethan@coinculture.info> * Update docs/spec/abci/abci.md Co-Authored-By: Ethan Buchman <ethan@coinculture.info> * Update libs/pubsub/query/query.go Co-Authored-By: Ethan Buchman <ethan@coinculture.info> * Update match function to match if ANY value matches * Implement TestSubscribeDuplicateKeys * Update TestMatches to include multi-key test cases * Update events.go * Update Query interface godoc * Update match godoc * Add godoc for matchValue * DRY-up tx indexing * Return error from PublishWithEvents in EventBus#Publish * Update PublishEventNewBlockHeader to return an error * Fix build * Update events doc in ABCI * Update ABCI events godoc * Implement TestEventBusPublishEventTxDuplicateKeys * Update TestSubscribeDuplicateKeys to be table-driven * Remove mod file * Remove markdown from events godoc * Implement TestTxSearchDeprecatedIndexing test
6 years ago
  1. package v0
  2. import (
  3. "os"
  4. "sort"
  5. "testing"
  6. "time"
  7. "github.com/pkg/errors"
  8. "github.com/stretchr/testify/assert"
  9. dbm "github.com/tendermint/tm-db"
  10. abci "github.com/tendermint/tendermint/abci/types"
  11. cfg "github.com/tendermint/tendermint/config"
  12. "github.com/tendermint/tendermint/libs/log"
  13. "github.com/tendermint/tendermint/mock"
  14. "github.com/tendermint/tendermint/p2p"
  15. "github.com/tendermint/tendermint/proxy"
  16. sm "github.com/tendermint/tendermint/state"
  17. "github.com/tendermint/tendermint/store"
  18. "github.com/tendermint/tendermint/types"
  19. tmtime "github.com/tendermint/tendermint/types/time"
  20. )
  21. var config *cfg.Config
  22. func randGenesisDoc(numValidators int, randPower bool, minPower int64) (*types.GenesisDoc, []types.PrivValidator) {
  23. validators := make([]types.GenesisValidator, numValidators)
  24. privValidators := make([]types.PrivValidator, numValidators)
  25. for i := 0; i < numValidators; i++ {
  26. val, privVal := types.RandValidator(randPower, minPower)
  27. validators[i] = types.GenesisValidator{
  28. PubKey: val.PubKey,
  29. Power: val.VotingPower,
  30. }
  31. privValidators[i] = privVal
  32. }
  33. sort.Sort(types.PrivValidatorsByAddress(privValidators))
  34. return &types.GenesisDoc{
  35. GenesisTime: tmtime.Now(),
  36. ChainID: config.ChainID(),
  37. Validators: validators,
  38. }, privValidators
  39. }
  40. type BlockchainReactorPair struct {
  41. reactor *BlockchainReactor
  42. app proxy.AppConns
  43. }
  44. func newBlockchainReactor(
  45. logger log.Logger,
  46. genDoc *types.GenesisDoc,
  47. privVals []types.PrivValidator,
  48. maxBlockHeight int64) BlockchainReactorPair {
  49. if len(privVals) != 1 {
  50. panic("only support one validator")
  51. }
  52. app := &testApp{}
  53. cc := proxy.NewLocalClientCreator(app)
  54. proxyApp := proxy.NewAppConns(cc)
  55. err := proxyApp.Start()
  56. if err != nil {
  57. panic(errors.Wrap(err, "error start app"))
  58. }
  59. blockDB := dbm.NewMemDB()
  60. stateDB := dbm.NewMemDB()
  61. blockStore := store.NewBlockStore(blockDB)
  62. state, err := sm.LoadStateFromDBOrGenesisDoc(stateDB, genDoc)
  63. if err != nil {
  64. panic(errors.Wrap(err, "error constructing state from genesis file"))
  65. }
  66. // Make the BlockchainReactor itself.
  67. // NOTE we have to create and commit the blocks first because
  68. // pool.height is determined from the store.
  69. fastSync := true
  70. db := dbm.NewMemDB()
  71. blockExec := sm.NewBlockExecutor(db, log.TestingLogger(), proxyApp.Consensus(),
  72. mock.Mempool{}, sm.MockEvidencePool{})
  73. sm.SaveState(db, state)
  74. // let's add some blocks in
  75. for blockHeight := int64(1); blockHeight <= maxBlockHeight; blockHeight++ {
  76. lastCommit := types.NewCommit(blockHeight-1, 0, types.BlockID{}, nil)
  77. if blockHeight > 1 {
  78. lastBlockMeta := blockStore.LoadBlockMeta(blockHeight - 1)
  79. lastBlock := blockStore.LoadBlock(blockHeight - 1)
  80. vote, err := types.MakeVote(
  81. lastBlock.Header.Height,
  82. lastBlockMeta.BlockID,
  83. state.Validators,
  84. privVals[0],
  85. lastBlock.Header.ChainID,
  86. time.Now(),
  87. )
  88. if err != nil {
  89. panic(err)
  90. }
  91. lastCommit = types.NewCommit(vote.Height, vote.Round,
  92. lastBlockMeta.BlockID, []types.CommitSig{vote.CommitSig()})
  93. }
  94. thisBlock := makeBlock(blockHeight, state, lastCommit)
  95. thisParts := thisBlock.MakePartSet(types.BlockPartSizeBytes)
  96. blockID := types.BlockID{Hash: thisBlock.Hash(), PartsHeader: thisParts.Header()}
  97. state, err = blockExec.ApplyBlock(state, blockID, thisBlock)
  98. if err != nil {
  99. panic(errors.Wrap(err, "error apply block"))
  100. }
  101. blockStore.SaveBlock(thisBlock, thisParts, lastCommit)
  102. }
  103. bcReactor := NewBlockchainReactor(state.Copy(), blockExec, blockStore, fastSync)
  104. bcReactor.SetLogger(logger.With("module", "blockchain"))
  105. return BlockchainReactorPair{bcReactor, proxyApp}
  106. }
  107. func TestNoBlockResponse(t *testing.T) {
  108. config = cfg.ResetTestRoot("blockchain_reactor_test")
  109. defer os.RemoveAll(config.RootDir)
  110. genDoc, privVals := randGenesisDoc(1, false, 30)
  111. maxBlockHeight := int64(65)
  112. reactorPairs := make([]BlockchainReactorPair, 2)
  113. reactorPairs[0] = newBlockchainReactor(log.TestingLogger(), genDoc, privVals, maxBlockHeight)
  114. reactorPairs[1] = newBlockchainReactor(log.TestingLogger(), genDoc, privVals, 0)
  115. p2p.MakeConnectedSwitches(config.P2P, 2, func(i int, s *p2p.Switch) *p2p.Switch {
  116. s.AddReactor("BLOCKCHAIN", reactorPairs[i].reactor)
  117. return s
  118. }, p2p.Connect2Switches)
  119. defer func() {
  120. for _, r := range reactorPairs {
  121. r.reactor.Stop()
  122. r.app.Stop()
  123. }
  124. }()
  125. tests := []struct {
  126. height int64
  127. existent bool
  128. }{
  129. {maxBlockHeight + 2, false},
  130. {10, true},
  131. {1, true},
  132. {100, false},
  133. }
  134. for {
  135. if reactorPairs[1].reactor.pool.IsCaughtUp() {
  136. break
  137. }
  138. time.Sleep(10 * time.Millisecond)
  139. }
  140. assert.Equal(t, maxBlockHeight, reactorPairs[0].reactor.store.Height())
  141. for _, tt := range tests {
  142. block := reactorPairs[1].reactor.store.LoadBlock(tt.height)
  143. if tt.existent {
  144. assert.True(t, block != nil)
  145. } else {
  146. assert.True(t, block == nil)
  147. }
  148. }
  149. }
  150. // NOTE: This is too hard to test without
  151. // an easy way to add test peer to switch
  152. // or without significant refactoring of the module.
  153. // Alternatively we could actually dial a TCP conn but
  154. // that seems extreme.
  155. func TestBadBlockStopsPeer(t *testing.T) {
  156. config = cfg.ResetTestRoot("blockchain_reactor_test")
  157. defer os.RemoveAll(config.RootDir)
  158. genDoc, privVals := randGenesisDoc(1, false, 30)
  159. maxBlockHeight := int64(148)
  160. otherChain := newBlockchainReactor(log.TestingLogger(), genDoc, privVals, maxBlockHeight)
  161. defer func() {
  162. otherChain.reactor.Stop()
  163. otherChain.app.Stop()
  164. }()
  165. reactorPairs := make([]BlockchainReactorPair, 4)
  166. reactorPairs[0] = newBlockchainReactor(log.TestingLogger(), genDoc, privVals, maxBlockHeight)
  167. reactorPairs[1] = newBlockchainReactor(log.TestingLogger(), genDoc, privVals, 0)
  168. reactorPairs[2] = newBlockchainReactor(log.TestingLogger(), genDoc, privVals, 0)
  169. reactorPairs[3] = newBlockchainReactor(log.TestingLogger(), genDoc, privVals, 0)
  170. switches := p2p.MakeConnectedSwitches(config.P2P, 4, func(i int, s *p2p.Switch) *p2p.Switch {
  171. s.AddReactor("BLOCKCHAIN", reactorPairs[i].reactor)
  172. return s
  173. }, p2p.Connect2Switches)
  174. defer func() {
  175. for _, r := range reactorPairs {
  176. r.reactor.Stop()
  177. r.app.Stop()
  178. }
  179. }()
  180. for {
  181. if reactorPairs[3].reactor.pool.IsCaughtUp() {
  182. break
  183. }
  184. time.Sleep(1 * time.Second)
  185. }
  186. //at this time, reactors[0-3] is the newest
  187. assert.Equal(t, 3, reactorPairs[1].reactor.Switch.Peers().Size())
  188. //mark reactorPairs[3] is an invalid peer
  189. reactorPairs[3].reactor.store = otherChain.reactor.store
  190. lastReactorPair := newBlockchainReactor(log.TestingLogger(), genDoc, privVals, 0)
  191. reactorPairs = append(reactorPairs, lastReactorPair)
  192. switches = append(switches, p2p.MakeConnectedSwitches(config.P2P, 1, func(i int, s *p2p.Switch) *p2p.Switch {
  193. s.AddReactor("BLOCKCHAIN", reactorPairs[len(reactorPairs)-1].reactor)
  194. return s
  195. }, p2p.Connect2Switches)...)
  196. for i := 0; i < len(reactorPairs)-1; i++ {
  197. p2p.Connect2Switches(switches, i, len(reactorPairs)-1)
  198. }
  199. for {
  200. if lastReactorPair.reactor.pool.IsCaughtUp() || lastReactorPair.reactor.Switch.Peers().Size() == 0 {
  201. break
  202. }
  203. time.Sleep(1 * time.Second)
  204. }
  205. assert.True(t, lastReactorPair.reactor.Switch.Peers().Size() < len(reactorPairs)-1)
  206. }
  207. func TestBcBlockRequestMessageValidateBasic(t *testing.T) {
  208. testCases := []struct {
  209. testName string
  210. requestHeight int64
  211. expectErr bool
  212. }{
  213. {"Valid Request Message", 0, false},
  214. {"Valid Request Message", 1, false},
  215. {"Invalid Request Message", -1, true},
  216. }
  217. for _, tc := range testCases {
  218. tc := tc
  219. t.Run(tc.testName, func(t *testing.T) {
  220. request := bcBlockRequestMessage{Height: tc.requestHeight}
  221. assert.Equal(t, tc.expectErr, request.ValidateBasic() != nil, "Validate Basic had an unexpected result")
  222. })
  223. }
  224. }
  225. func TestBcNoBlockResponseMessageValidateBasic(t *testing.T) {
  226. testCases := []struct {
  227. testName string
  228. nonResponseHeight int64
  229. expectErr bool
  230. }{
  231. {"Valid Non-Response Message", 0, false},
  232. {"Valid Non-Response Message", 1, false},
  233. {"Invalid Non-Response Message", -1, true},
  234. }
  235. for _, tc := range testCases {
  236. tc := tc
  237. t.Run(tc.testName, func(t *testing.T) {
  238. nonResponse := bcNoBlockResponseMessage{Height: tc.nonResponseHeight}
  239. assert.Equal(t, tc.expectErr, nonResponse.ValidateBasic() != nil, "Validate Basic had an unexpected result")
  240. })
  241. }
  242. }
  243. func TestBcStatusRequestMessageValidateBasic(t *testing.T) {
  244. testCases := []struct {
  245. testName string
  246. requestHeight int64
  247. expectErr bool
  248. }{
  249. {"Valid Request Message", 0, false},
  250. {"Valid Request Message", 1, false},
  251. {"Invalid Request Message", -1, true},
  252. }
  253. for _, tc := range testCases {
  254. tc := tc
  255. t.Run(tc.testName, func(t *testing.T) {
  256. request := bcStatusRequestMessage{Height: tc.requestHeight}
  257. assert.Equal(t, tc.expectErr, request.ValidateBasic() != nil, "Validate Basic had an unexpected result")
  258. })
  259. }
  260. }
  261. func TestBcStatusResponseMessageValidateBasic(t *testing.T) {
  262. testCases := []struct {
  263. testName string
  264. responseHeight int64
  265. expectErr bool
  266. }{
  267. {"Valid Response Message", 0, false},
  268. {"Valid Response Message", 1, false},
  269. {"Invalid Response Message", -1, true},
  270. }
  271. for _, tc := range testCases {
  272. tc := tc
  273. t.Run(tc.testName, func(t *testing.T) {
  274. response := bcStatusResponseMessage{Height: tc.responseHeight}
  275. assert.Equal(t, tc.expectErr, response.ValidateBasic() != nil, "Validate Basic had an unexpected result")
  276. })
  277. }
  278. }
  279. //----------------------------------------------
  280. // utility funcs
  281. func makeTxs(height int64) (txs []types.Tx) {
  282. for i := 0; i < 10; i++ {
  283. txs = append(txs, types.Tx([]byte{byte(height), byte(i)}))
  284. }
  285. return txs
  286. }
  287. func makeBlock(height int64, state sm.State, lastCommit *types.Commit) *types.Block {
  288. block, _ := state.MakeBlock(height, makeTxs(height), lastCommit, nil, state.Validators.GetProposer().Address)
  289. return block
  290. }
  291. type testApp struct {
  292. abci.BaseApplication
  293. }
  294. var _ abci.Application = (*testApp)(nil)
  295. func (app *testApp) Info(req abci.RequestInfo) (resInfo abci.ResponseInfo) {
  296. return abci.ResponseInfo{}
  297. }
  298. func (app *testApp) BeginBlock(req abci.RequestBeginBlock) abci.ResponseBeginBlock {
  299. return abci.ResponseBeginBlock{}
  300. }
  301. func (app *testApp) EndBlock(req abci.RequestEndBlock) abci.ResponseEndBlock {
  302. return abci.ResponseEndBlock{}
  303. }
  304. func (app *testApp) DeliverTx(req abci.RequestDeliverTx) abci.ResponseDeliverTx {
  305. return abci.ResponseDeliverTx{Events: []abci.Event{}}
  306. }
  307. func (app *testApp) CheckTx(req abci.RequestCheckTx) abci.ResponseCheckTx {
  308. return abci.ResponseCheckTx{}
  309. }
  310. func (app *testApp) Commit() abci.ResponseCommit {
  311. return abci.ResponseCommit{}
  312. }
  313. func (app *testApp) Query(reqQuery abci.RequestQuery) (resQuery abci.ResponseQuery) {
  314. return
  315. }