test: v2 services helpers and demo using x/bank

core/testing/context.go

@@ -4,21 +4,65 @@ import (
 	"context"
 
 	"cosmossdk.io/core/event"
+	"cosmossdk.io/core/gas"
+	"cosmossdk.io/core/header"
 	"cosmossdk.io/core/store"
 	"cosmossdk.io/core/transaction"
 )
 
 type dummyKey struct{}
 
-func Context() context.Context {
+var _ context.Context = &TestContext{}
+
+type TestContext struct {
+	context.Context
+}
+
+func Context() TestContext {
 	dummy := &dummyCtx{
 		stores:      map[string]store.KVStore{},
 		events:      map[string][]event.Event{},
 		protoEvents: map[string][]transaction.Msg{},
+		header:      header.Info{},
+		execMode:    transaction.ExecModeFinalize,
+		gasConfig:   gas.GasConfig{},
+		gasMeter:    nil,
+	}
+
+	return TestContext{
+		Context: context.WithValue(context.Background(), dummyKey{}, dummy),
+	}
+}
+
+// WithHeaderInfo sets the header on a testing ctx and returns the updated ctx.
+func (t TestContext) WithHeaderInfo(info header.Info) TestContext {
+	dummy := unwrap(t.Context)
+	dummy.header = info
+
+	return TestContext{
+		Context: context.WithValue(t.Context, dummyKey{}, dummy),
 	}
+}
+
+// WithExecMode sets the exec mode on a testing ctx and returns the updated ctx.
+func (t TestContext) WithExecMode(mode transaction.ExecMode) TestContext {
+	dummy := unwrap(t.Context)
+	dummy.execMode = mode
 
-	ctx := context.WithValue(context.Background(), dummyKey{}, dummy)
-	return ctx
+	return TestContext{
+		Context: context.WithValue(t.Context, dummyKey{}, dummy),
+	}
+}
+
+// WithGas sets the gas config and meter on a testing ctx and returns the updated ctx.
+func (t TestContext) WithGas(gasConfig gas.GasConfig, gasMeter gas.Meter) TestContext {
+	dummy := unwrap(t.Context)
+	dummy.gasConfig = gasConfig
+	dummy.gasMeter = gasMeter
+
+	return TestContext{
+		Context: context.WithValue(t.Context, dummyKey{}, dummy),
+	}
 }
 
 type dummyCtx struct {
@@ -28,6 +72,12 @@ type dummyCtx struct {
 	events map[string][]event.Event
 	// maps proto events emitted by the actor.
 	protoEvents map[string][]transaction.Msg
+
+	header   header.Info
+	execMode transaction.ExecMode
+
+	gasMeter  gas.Meter
+	gasConfig gas.GasConfig
 }
 
 func unwrap(ctx context.Context) *dummyCtx {

core/testing/environment.go

@@ -0,0 +1,65 @@
+package coretesting
+
+import (
+	"context"
+
+	appmodulev2 "cosmossdk.io/core/appmodule/v2"
+	corecontext "cosmossdk.io/core/context"
+	corelog "cosmossdk.io/core/log"
+	"cosmossdk.io/core/router"
+	"cosmossdk.io/core/store"
+)
+
+type TestEnvironmentConfig struct {
+	ModuleName  string
+	Logger      corelog.Logger
+	MsgRouter   router.Service
+	QueryRouter router.Service
+}
+
+type TestEnvironment struct {
+	appmodulev2.Environment
+
+	memEventsService MemEventsService
+	memHeaderService MemHeaderService
+}
+
+func NewTestEnvironment(cfg TestEnvironmentConfig) (TestContext, TestEnvironment) {
+	ctx := Context()
+
+	memEventService := EventsService(ctx, cfg.ModuleName)
+	memHeaderService := MemHeaderService{}
+
+	env := TestEnvironment{
+		Environment: appmodulev2.Environment{
+			Logger:             cfg.Logger,
+			BranchService:      nil,
+			EventService:       memEventService,
+			GasService:         MemGasService{},
+			HeaderService:      memHeaderService,
+			QueryRouterService: cfg.QueryRouter,
+			MsgRouterService:   cfg.MsgRouter,
+			TransactionService: MemTransactionService{},
+			KVStoreService:     KVStoreService(ctx, cfg.ModuleName),
+			MemStoreService:    nil,
+		},
+		memEventsService: memEventService,
+		memHeaderService: memHeaderService,
+	}
+
+	// set internal context to point to environment
+	ctx.Context = context.WithValue(ctx.Context, corecontext.EnvironmentContextKey, env.Environment)
+	return ctx, env
+}
+
+func (env TestEnvironment) MemEventsService() MemEventsService {
+	return env.memEventsService
+}
+
+func (env TestEnvironment) KVStoreService() store.KVStoreService {
+	return env.Environment.KVStoreService
+}
+
+func (env TestEnvironment) HeaderService() MemHeaderService {
+	return env.memHeaderService
+}

core/testing/gas.go

@@ -0,0 +1,23 @@
+package coretesting
+
+import (
+	"context"
+
+	"cosmossdk.io/core/gas"
+)
+
+var _ gas.Service = &MemGasService{}
+
+type MemGasService struct{}
+
+func (m MemGasService) GasMeter(ctx context.Context) gas.Meter {
+	dummy := unwrap(ctx)
+
+	return dummy.gasMeter
+}
+
+func (m MemGasService) GasConfig(ctx context.Context) gas.GasConfig {
+	dummy := unwrap(ctx)
+
+	return dummy.gasConfig
+}

core/testing/header.go

@@ -0,0 +1,15 @@
+package coretesting
+
+import (
+	"context"
+
+	"cosmossdk.io/core/header"
+)
+
+var _ header.Service = &MemHeaderService{}
+
+type MemHeaderService struct{}
+
+func (e MemHeaderService) HeaderInfo(ctx context.Context) header.Info {
+	return unwrap(ctx).header
+}

core/testing/router.go

@@ -0,0 +1,159 @@
+package coretesting
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"reflect"
+
+	appmodulev2 "cosmossdk.io/core/appmodule/v2"
+	"cosmossdk.io/core/router"
+	"cosmossdk.io/core/transaction"
+)
+
+var ErrNoHandler = errors.New("no handler")
+
+// NewMsgRouterBuilder is a router that routes messages to their respective handlers.
+func NewMsgRouterBuilder() *ReflectionRouterBuilder {
+	return &ReflectionRouterBuilder{
+		handlers:     make(map[string]appmodulev2.HandlerFunc),
+		preHandlers:  make(map[string][]appmodulev2.PreMsgHandler),
+		postHandlers: make(map[string][]appmodulev2.PostMsgHandler),
+	}
+}
+
+type ReflectionRouterBuilder struct {
+	handlers           map[string]appmodulev2.HandlerFunc
+	globalPreHandlers  []appmodulev2.PreMsgHandler
+	preHandlers        map[string][]appmodulev2.PreMsgHandler
+	postHandlers       map[string][]appmodulev2.PostMsgHandler
+	globalPostHandlers []appmodulev2.PostMsgHandler
+}
+
+func (b *ReflectionRouterBuilder) RegisterHandler(msgType string, handler appmodulev2.HandlerFunc) error {
+	// panic on override
+	if _, ok := b.handlers[msgType]; ok {
+		return fmt.Errorf("handler already registered: %s", msgType)
+	}
+	b.handlers[msgType] = handler
+	return nil
+}
+
+func (b *ReflectionRouterBuilder) RegisterGlobalPreMsgHandler(handler appmodulev2.PreMsgHandler) {
+	b.globalPreHandlers = append(b.globalPreHandlers, handler)
+}
+
+func (b *ReflectionRouterBuilder) RegisterPreMsgHandler(msgType string, handler appmodulev2.PreMsgHandler) {
+	b.preHandlers[msgType] = append(b.preHandlers[msgType], handler)
+}
+
+func (b *ReflectionRouterBuilder) RegisterPostMsgHandler(msgType string, handler appmodulev2.PostMsgHandler) {
+	b.postHandlers[msgType] = append(b.postHandlers[msgType], handler)
+}
+
+func (b *ReflectionRouterBuilder) RegisterGlobalPostMsgHandler(handler appmodulev2.PostMsgHandler) {
+	b.globalPostHandlers = append(b.globalPostHandlers, handler)
+}
+
+func (b *ReflectionRouterBuilder) HandlerExists(msgType string) bool {
+	_, ok := b.handlers[msgType]
+	return ok
+}
+
+func (b *ReflectionRouterBuilder) Build() (ReflectionRouter, error) {
+	handlers := make(map[string]appmodulev2.HandlerFunc)
+
+	globalPreHandler := func(ctx context.Context, msg transaction.Msg) error {
+		for _, h := range b.globalPreHandlers {
+			err := h(ctx, msg)
+			if err != nil {
+				return err
+			}
+		}
+		return nil
+	}
+
+	globalPostHandler := func(ctx context.Context, msg, msgResp transaction.Msg) error {
+		for _, h := range b.globalPostHandlers {
+			err := h(ctx, msg, msgResp)
+			if err != nil {
+				return err
+			}
+		}
+		return nil
+	}
+
+	for msgType, handler := range b.handlers {
+		// find pre handler
+		preHandlers := b.preHandlers[msgType]
+		// find post handler
+		postHandlers := b.postHandlers[msgType]
+		// build the handler
+		handlers[msgType] = buildHandler(handler, preHandlers, globalPreHandler, postHandlers, globalPostHandler)
+	}
+
+	return ReflectionRouter{
+		handlers: handlers,
+	}, nil
+}
+
+func buildHandler(
+	handler appmodulev2.HandlerFunc,
+	preHandlers []appmodulev2.PreMsgHandler,
+	globalPreHandler appmodulev2.PreMsgHandler,
+	postHandlers []appmodulev2.PostMsgHandler,
+	globalPostHandler appmodulev2.PostMsgHandler,
+) appmodulev2.HandlerFunc {
+	return func(ctx context.Context, msg transaction.Msg) (msgResp transaction.Msg, err error) {
+		if len(preHandlers) != 0 {
+			for _, preHandler := range preHandlers {
+				if err := preHandler(ctx, msg); err != nil {
+					return nil, err
+				}
+			}
+		}
+		err = globalPreHandler(ctx, msg)
+		if err != nil {
+			return nil, err
+		}
+		msgResp, err = handler(ctx, msg)
+		if err != nil {
+			return nil, err
+		}
+
+		if len(postHandlers) != 0 {
+			for _, postHandler := range postHandlers {
+				if err := postHandler(ctx, msg, msgResp); err != nil {
+					return nil, err
+				}
+			}
+		}
+		err = globalPostHandler(ctx, msg, msgResp)
+		return msgResp, err
+	}
+}
+
+var _ router.Service = (*ReflectionRouter)(nil)
+
+// ReflectionRouter implements the STF router for msg and query handlers.
+type ReflectionRouter struct {
+	handlers map[string]appmodulev2.HandlerFunc
+}
+
+func (r ReflectionRouter) CanInvoke(_ context.Context, typeURL string) error {
+	_, exists := r.handlers[typeURL]
+	if !exists {
+		return fmt.Errorf("%w: %s", ErrNoHandler, typeURL)
+	}
+	return nil
+}
+
+func (r ReflectionRouter) Invoke(ctx context.Context, req transaction.Msg) (res transaction.Msg, err error) {
+	typeName := reflect.TypeOf(req).String()
+	handler, exists := r.handlers[typeName]
+	if !exists {
+		return nil, fmt.Errorf("%w: %s", ErrNoHandler, typeName)
+	}
+
+	return handler(ctx, req)
+}

core/testing/services_test.go

@@ -6,8 +6,14 @@ import (
 )
 
 func TestKVStoreService(t *testing.T) {
-	ctx := Context()
-	svc1 := KVStoreService(ctx, "bank")
+	cfg := TestEnvironmentConfig{
+		ModuleName:  "bank",
+		Logger:      nil,
+		MsgRouter:   nil,
+		QueryRouter: nil,
+	}
+	ctx, env := NewTestEnvironment(cfg)
+	svc1 := env.KVStoreService()
 
 	// must panic
 	t.Run("must panic on invalid ctx", func(t *testing.T) {

core/testing/transaction.go

@@ -0,0 +1,17 @@
+package coretesting
+
+import (
+	"context"
+
+	"cosmossdk.io/core/transaction"
+)
+
+var _ transaction.Service = &MemTransactionService{}
+
+type MemTransactionService struct{}
+
+func (m MemTransactionService) ExecMode(ctx context.Context) transaction.ExecMode {
+	dummy := unwrap(ctx)
+
+	return dummy.execMode
+}

schema/appdata/mux.go

@@ -139,7 +139,7 @@ func ListenerMux(listeners ...Listener) Listener {
 
 	mux.onBatch = func(batch PacketBatch) error {
 		for _, listener := range listeners {
-			err := batch.apply(&listener) //nolint:gosec // aliasing is safe here
+			err := batch.apply(&listener) 
 			if err != nil {
 				return err
 			}