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.
175 lines
4.5 KiB
175 lines
4.5 KiB
package mocks
|
|
|
|
import (
|
|
types "github.com/tendermint/tendermint/abci/types"
|
|
)
|
|
|
|
// BaseMock provides a wrapper around the generated Application mock and a BaseApplication.
|
|
// BaseMock first tries to use the mock's implementation of the method.
|
|
// If no functionality was provided for the mock by the user, BaseMock dispatches
|
|
// to the BaseApplication and uses its functionality.
|
|
// BaseMock allows users to provide mocked functionality for only the methods that matter
|
|
// for their test while avoiding a panic if the code calls Application methods that are
|
|
// not relevant to the test.
|
|
type BaseMock struct {
|
|
base *types.BaseApplication
|
|
*Application
|
|
}
|
|
|
|
func NewBaseMock() BaseMock {
|
|
return BaseMock{
|
|
base: types.NewBaseApplication(),
|
|
Application: new(Application),
|
|
}
|
|
}
|
|
|
|
// Info/Query Connection
|
|
// Return application info
|
|
func (m BaseMock) Info(input types.RequestInfo) (ret types.ResponseInfo) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ret = m.base.Info(input)
|
|
}
|
|
}()
|
|
ret = m.Application.Info(input)
|
|
return ret
|
|
}
|
|
|
|
func (m BaseMock) Query(input types.RequestQuery) (ret types.ResponseQuery) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ret = m.base.Query(input)
|
|
}
|
|
}()
|
|
ret = m.Application.Query(input)
|
|
return ret
|
|
}
|
|
|
|
// Mempool Connection
|
|
// Validate a tx for the mempool
|
|
func (m BaseMock) CheckTx(input types.RequestCheckTx) (ret types.ResponseCheckTx) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ret = m.base.CheckTx(input)
|
|
}
|
|
}()
|
|
ret = m.Application.CheckTx(input)
|
|
return ret
|
|
}
|
|
|
|
// Consensus Connection
|
|
// Initialize blockchain w validators/other info from TendermintCore
|
|
func (m BaseMock) InitChain(input types.RequestInitChain) (ret types.ResponseInitChain) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ret = m.base.InitChain(input)
|
|
}
|
|
}()
|
|
ret = m.Application.InitChain(input)
|
|
return ret
|
|
}
|
|
|
|
func (m BaseMock) PrepareProposal(input types.RequestPrepareProposal) (ret types.ResponsePrepareProposal) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ret = m.base.PrepareProposal(input)
|
|
}
|
|
}()
|
|
ret = m.Application.PrepareProposal(input)
|
|
return ret
|
|
}
|
|
|
|
func (m BaseMock) ProcessProposal(input types.RequestProcessProposal) (ret types.ResponseProcessProposal) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ret = m.base.ProcessProposal(input)
|
|
}
|
|
}()
|
|
ret = m.Application.ProcessProposal(input)
|
|
return ret
|
|
}
|
|
|
|
// Commit the state and return the application Merkle root hash
|
|
func (m BaseMock) Commit() (ret types.ResponseCommit) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ret = m.base.Commit()
|
|
}
|
|
}()
|
|
ret = m.Application.Commit()
|
|
return ret
|
|
}
|
|
|
|
// Create application specific vote extension
|
|
func (m BaseMock) ExtendVote(input types.RequestExtendVote) (ret types.ResponseExtendVote) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ret = m.base.ExtendVote(input)
|
|
}
|
|
}()
|
|
ret = m.Application.ExtendVote(input)
|
|
return ret
|
|
}
|
|
|
|
// Verify application's vote extension data
|
|
func (m BaseMock) VerifyVoteExtension(input types.RequestVerifyVoteExtension) (ret types.ResponseVerifyVoteExtension) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ret = m.base.VerifyVoteExtension(input)
|
|
}
|
|
}()
|
|
ret = m.Application.VerifyVoteExtension(input)
|
|
return ret
|
|
}
|
|
|
|
// State Sync Connection
|
|
// List available snapshots
|
|
func (m BaseMock) ListSnapshots(input types.RequestListSnapshots) (ret types.ResponseListSnapshots) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ret = m.base.ListSnapshots(input)
|
|
}
|
|
}()
|
|
ret = m.Application.ListSnapshots(input)
|
|
return ret
|
|
}
|
|
|
|
func (m BaseMock) OfferSnapshot(input types.RequestOfferSnapshot) (ret types.ResponseOfferSnapshot) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ret = m.base.OfferSnapshot(input)
|
|
}
|
|
}()
|
|
ret = m.Application.OfferSnapshot(input)
|
|
return ret
|
|
}
|
|
|
|
func (m BaseMock) LoadSnapshotChunk(input types.RequestLoadSnapshotChunk) (ret types.ResponseLoadSnapshotChunk) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ret = m.base.LoadSnapshotChunk(input)
|
|
}
|
|
}()
|
|
ret = m.Application.LoadSnapshotChunk(input)
|
|
return ret
|
|
}
|
|
|
|
func (m BaseMock) ApplySnapshotChunk(input types.RequestApplySnapshotChunk) (ret types.ResponseApplySnapshotChunk) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ret = m.base.ApplySnapshotChunk(input)
|
|
}
|
|
}()
|
|
ret = m.Application.ApplySnapshotChunk(input)
|
|
return ret
|
|
}
|
|
|
|
func (m BaseMock) FinalizeBlock(input types.RequestFinalizeBlock) (ret types.ResponseFinalizeBlock) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ret = m.base.FinalizeBlock(input)
|
|
}
|
|
}()
|
|
ret = m.Application.FinalizeBlock(input)
|
|
return ret
|
|
}
|