149 lines
3.5 KiB
Go
149 lines
3.5 KiB
Go
package streaming
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
"runtime"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
"github.com/stretchr/testify/suite"
|
|
|
|
"cosmossdk.io/core/log"
|
|
coretesting "cosmossdk.io/core/testing"
|
|
)
|
|
|
|
type PluginTestSuite struct {
|
|
suite.Suite
|
|
|
|
loggerCtx MockContext
|
|
|
|
workDir string
|
|
|
|
deliverBlockrequest ListenDeliverBlockRequest
|
|
stateChangeRequest ListenStateChangesRequest
|
|
|
|
changeSet []*StoreKVPair
|
|
}
|
|
|
|
func (s *PluginTestSuite) SetupTest() {
|
|
if runtime.GOOS != "linux" {
|
|
s.T().Skip("only run on linux")
|
|
}
|
|
|
|
path, err := os.Getwd()
|
|
if err != nil {
|
|
s.T().Fail()
|
|
}
|
|
s.workDir = path
|
|
|
|
pluginVersion := defaultPlugin
|
|
// to write data to files, replace stdout/stdout => file/file
|
|
pluginPath := fmt.Sprintf("%s/abci/examples/stdout/stdout", s.workDir)
|
|
if err := os.Setenv(GetPluginEnvKey(pluginVersion), pluginPath); err != nil {
|
|
s.T().Fail()
|
|
}
|
|
|
|
raw, err := NewStreamingPlugin(pluginVersion, "trace")
|
|
require.NoError(s.T(), err, "load", "streaming", "unexpected error")
|
|
|
|
abciListener, ok := raw.(Listener)
|
|
require.True(s.T(), ok, "should pass type check")
|
|
|
|
logger := coretesting.NewNopLogger()
|
|
streamingService := Manager{
|
|
Listeners: []Listener{abciListener},
|
|
StopNodeOnErr: true,
|
|
}
|
|
s.loggerCtx = NewMockContext(1, logger, streamingService)
|
|
|
|
// test abci message types
|
|
|
|
s.deliverBlockrequest = ListenDeliverBlockRequest{
|
|
BlockHeight: s.loggerCtx.BlockHeight(),
|
|
Txs: [][]byte{{1, 2, 3, 4, 5, 6, 7, 8, 9}},
|
|
Events: []*Event{},
|
|
}
|
|
s.stateChangeRequest = ListenStateChangesRequest{}
|
|
|
|
key := []byte("mockStore")
|
|
key = append(key, 1, 2, 3)
|
|
// test store kv pair types
|
|
for range [2000]int{} {
|
|
s.changeSet = append(s.changeSet, &StoreKVPair{
|
|
Key: key,
|
|
Value: []byte{3, 2, 1},
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestPluginTestSuite(t *testing.T) {
|
|
suite.Run(t, new(PluginTestSuite))
|
|
}
|
|
|
|
func (s *PluginTestSuite) TestABCIGRPCPlugin() {
|
|
s.T().Run("Should successfully load streaming", func(t *testing.T) {
|
|
abciListeners := s.loggerCtx.StreamingManager().Listeners
|
|
for _, abciListener := range abciListeners {
|
|
for i := range [50]int{} {
|
|
|
|
err := abciListener.ListenDeliverBlock(s.loggerCtx, s.deliverBlockrequest)
|
|
assert.NoError(t, err, "ListenEndBlock")
|
|
|
|
err = abciListener.ListenStateChanges(s.loggerCtx, s.changeSet)
|
|
assert.NoError(t, err, "ListenCommit")
|
|
|
|
s.updateHeight(int64(i + 1))
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
func (s *PluginTestSuite) updateHeight(n int64) {
|
|
s.loggerCtx = NewMockContext(n, s.loggerCtx.Logger(), s.loggerCtx.StreamingManager())
|
|
}
|
|
|
|
var (
|
|
_ context.Context = MockContext{}
|
|
_ Context = MockContext{}
|
|
)
|
|
|
|
type MockContext struct {
|
|
baseCtx context.Context
|
|
height int64
|
|
logger log.Logger
|
|
streamingManager Manager
|
|
}
|
|
|
|
func (m MockContext) BlockHeight() int64 { return m.height }
|
|
func (m MockContext) Logger() log.Logger { return m.logger }
|
|
func (m MockContext) StreamingManager() Manager { return m.streamingManager }
|
|
|
|
func NewMockContext(height int64, logger log.Logger, sm Manager) MockContext {
|
|
return MockContext{
|
|
baseCtx: context.Background(),
|
|
height: height,
|
|
logger: logger,
|
|
streamingManager: sm,
|
|
}
|
|
}
|
|
|
|
func (m MockContext) Deadline() (deadline time.Time, ok bool) {
|
|
return m.baseCtx.Deadline()
|
|
}
|
|
|
|
func (m MockContext) Done() <-chan struct{} {
|
|
return m.baseCtx.Done()
|
|
}
|
|
|
|
func (m MockContext) Err() error {
|
|
return m.baseCtx.Err()
|
|
}
|
|
|
|
func (m MockContext) Value(key any) any {
|
|
return m.baseCtx.Value(key)
|
|
}
|