github.com/Finschia/finschia-sdk@v0.48.1/types/module/module_test.go (about)

     1  package module_test
     2  
     3  import (
     4  	"encoding/json"
     5  	"errors"
     6  	"testing"
     7  
     8  	"github.com/Finschia/finschia-sdk/codec/types"
     9  
    10  	ocabci "github.com/Finschia/ostracon/abci/types"
    11  	"github.com/golang/mock/gomock"
    12  	"github.com/spf13/cobra"
    13  	"github.com/stretchr/testify/require"
    14  	abci "github.com/tendermint/tendermint/abci/types"
    15  
    16  	"github.com/Finschia/finschia-sdk/client"
    17  	"github.com/Finschia/finschia-sdk/codec"
    18  	"github.com/Finschia/finschia-sdk/tests/mocks"
    19  	sdk "github.com/Finschia/finschia-sdk/types"
    20  	"github.com/Finschia/finschia-sdk/types/module"
    21  )
    22  
    23  var errFoo = errors.New("dummy")
    24  
    25  func TestBasicManager(t *testing.T) {
    26  	mockCtrl := gomock.NewController(t)
    27  	t.Cleanup(mockCtrl.Finish)
    28  	legacyAmino := codec.NewLegacyAmino()
    29  	interfaceRegistry := types.NewInterfaceRegistry()
    30  	cdc := codec.NewProtoCodec(interfaceRegistry)
    31  
    32  	clientCtx := client.Context{}
    33  	clientCtx = clientCtx.WithLegacyAmino(legacyAmino)
    34  	wantDefaultGenesis := map[string]json.RawMessage{"mockAppModuleBasic1": json.RawMessage(``)}
    35  
    36  	mockAppModuleBasic1 := mocks.NewMockAppModuleBasic(mockCtrl)
    37  
    38  	mockAppModuleBasic1.EXPECT().Name().AnyTimes().Return("mockAppModuleBasic1")
    39  	mockAppModuleBasic1.EXPECT().DefaultGenesis(gomock.Eq(cdc)).Times(1).Return(json.RawMessage(``))
    40  	mockAppModuleBasic1.EXPECT().ValidateGenesis(gomock.Eq(cdc), gomock.Eq(nil), gomock.Eq(wantDefaultGenesis["mockAppModuleBasic1"])).Times(1).Return(errFoo)
    41  	mockAppModuleBasic1.EXPECT().RegisterLegacyAminoCodec(gomock.Eq(legacyAmino)).Times(1)
    42  	mockAppModuleBasic1.EXPECT().RegisterInterfaces(gomock.Eq(interfaceRegistry)).Times(1)
    43  	mockAppModuleBasic1.EXPECT().GetTxCmd().Times(1).Return(nil)
    44  	mockAppModuleBasic1.EXPECT().GetQueryCmd().Times(1).Return(nil)
    45  
    46  	mm := module.NewBasicManager(mockAppModuleBasic1)
    47  	require.Equal(t, mm["mockAppModuleBasic1"], mockAppModuleBasic1)
    48  
    49  	mm.RegisterLegacyAminoCodec(legacyAmino)
    50  	mm.RegisterInterfaces(interfaceRegistry)
    51  
    52  	require.Equal(t, wantDefaultGenesis, mm.DefaultGenesis(cdc))
    53  
    54  	var data map[string]string
    55  	require.Equal(t, map[string]string(nil), data)
    56  
    57  	require.True(t, errors.Is(errFoo, mm.ValidateGenesis(cdc, nil, wantDefaultGenesis)))
    58  
    59  	mockCmd := &cobra.Command{Use: "root"}
    60  	mm.AddTxCommands(mockCmd)
    61  
    62  	mm.AddQueryCommands(mockCmd)
    63  
    64  	// validate genesis returns nil
    65  	require.Nil(t, module.NewBasicManager().ValidateGenesis(cdc, nil, wantDefaultGenesis))
    66  }
    67  
    68  func TestGenesisOnlyAppModule(t *testing.T) {
    69  	mockCtrl := gomock.NewController(t)
    70  	t.Cleanup(mockCtrl.Finish)
    71  
    72  	mockModule := mocks.NewMockAppModuleGenesis(mockCtrl)
    73  	mockInvariantRegistry := mocks.NewMockInvariantRegistry(mockCtrl)
    74  	goam := module.NewGenesisOnlyAppModule(mockModule)
    75  
    76  	require.True(t, goam.Route().Empty())
    77  	require.Empty(t, goam.QuerierRoute())
    78  	require.Nil(t, goam.LegacyQuerierHandler(nil))
    79  
    80  	// no-op
    81  	goam.RegisterInvariants(mockInvariantRegistry)
    82  }
    83  
    84  func TestManagerOrderSetters(t *testing.T) {
    85  	mockCtrl := gomock.NewController(t)
    86  	t.Cleanup(mockCtrl.Finish)
    87  	mockAppModule1 := mocks.NewMockAppModule(mockCtrl)
    88  	mockAppModule2 := mocks.NewMockAppModule(mockCtrl)
    89  
    90  	mockAppModule1.EXPECT().Name().Times(2).Return("module1")
    91  	mockAppModule2.EXPECT().Name().Times(2).Return("module2")
    92  	mm := module.NewManager(mockAppModule1, mockAppModule2)
    93  	require.NotNil(t, mm)
    94  	require.Equal(t, 2, len(mm.Modules))
    95  
    96  	require.Equal(t, []string{"module1", "module2"}, mm.OrderInitGenesis)
    97  	mm.SetOrderInitGenesis("module2", "module1")
    98  	require.Equal(t, []string{"module2", "module1"}, mm.OrderInitGenesis)
    99  
   100  	require.Equal(t, []string{"module1", "module2"}, mm.OrderExportGenesis)
   101  	mm.SetOrderExportGenesis("module2", "module1")
   102  	require.Equal(t, []string{"module2", "module1"}, mm.OrderExportGenesis)
   103  
   104  	require.Equal(t, []string{"module1", "module2"}, mm.OrderBeginBlockers)
   105  	mm.SetOrderBeginBlockers("module2", "module1")
   106  	require.Equal(t, []string{"module2", "module1"}, mm.OrderBeginBlockers)
   107  
   108  	require.Equal(t, []string{"module1", "module2"}, mm.OrderEndBlockers)
   109  	mm.SetOrderEndBlockers("module2", "module1")
   110  	require.Equal(t, []string{"module2", "module1"}, mm.OrderEndBlockers)
   111  }
   112  
   113  func TestManager_RegisterInvariants(t *testing.T) {
   114  	mockCtrl := gomock.NewController(t)
   115  	t.Cleanup(mockCtrl.Finish)
   116  
   117  	mockAppModule1 := mocks.NewMockAppModule(mockCtrl)
   118  	mockAppModule2 := mocks.NewMockAppModule(mockCtrl)
   119  	mockAppModule1.EXPECT().Name().Times(2).Return("module1")
   120  	mockAppModule2.EXPECT().Name().Times(2).Return("module2")
   121  	mm := module.NewManager(mockAppModule1, mockAppModule2)
   122  	require.NotNil(t, mm)
   123  	require.Equal(t, 2, len(mm.Modules))
   124  
   125  	// test RegisterInvariants
   126  	mockInvariantRegistry := mocks.NewMockInvariantRegistry(mockCtrl)
   127  	mockAppModule1.EXPECT().RegisterInvariants(gomock.Eq(mockInvariantRegistry)).Times(1)
   128  	mockAppModule2.EXPECT().RegisterInvariants(gomock.Eq(mockInvariantRegistry)).Times(1)
   129  	mm.RegisterInvariants(mockInvariantRegistry)
   130  }
   131  
   132  func TestManager_RegisterRoutes(t *testing.T) {
   133  	mockCtrl := gomock.NewController(t)
   134  	t.Cleanup(mockCtrl.Finish)
   135  
   136  	mockAppModule1 := mocks.NewMockAppModule(mockCtrl)
   137  	mockAppModule2 := mocks.NewMockAppModule(mockCtrl)
   138  	mockAppModule1.EXPECT().Name().Times(2).Return("module1")
   139  	mockAppModule2.EXPECT().Name().Times(2).Return("module2")
   140  	mm := module.NewManager(mockAppModule1, mockAppModule2)
   141  	require.NotNil(t, mm)
   142  	require.Equal(t, 2, len(mm.Modules))
   143  
   144  	router := mocks.NewMockRouter(mockCtrl)
   145  	noopHandler := sdk.Handler(func(ctx sdk.Context, msg sdk.Msg) (*sdk.Result, error) { return nil, nil })
   146  	route1 := sdk.NewRoute("route1", noopHandler)
   147  	route2 := sdk.NewRoute("", noopHandler)
   148  	mockAppModule1.EXPECT().Route().Times(1).Return(route1)
   149  	mockAppModule2.EXPECT().Route().Times(1).Return(route2)
   150  	router.EXPECT().AddRoute(gomock.Any()).Times(1) // Use of Any due to limitations to compare Functions as the sdk.Handler
   151  
   152  	queryRouter := mocks.NewMockQueryRouter(mockCtrl)
   153  	mockAppModule1.EXPECT().QuerierRoute().Times(1).Return("querierRoute1")
   154  	mockAppModule2.EXPECT().QuerierRoute().Times(1).Return("")
   155  	handler3 := sdk.Querier(nil)
   156  	amino := codec.NewLegacyAmino()
   157  	mockAppModule1.EXPECT().LegacyQuerierHandler(amino).Times(1).Return(handler3)
   158  	queryRouter.EXPECT().AddRoute(gomock.Eq("querierRoute1"), gomock.Eq(handler3)).Times(1)
   159  
   160  	mm.RegisterRoutes(router, queryRouter, amino)
   161  }
   162  
   163  func TestManager_RegisterQueryServices(t *testing.T) {
   164  	mockCtrl := gomock.NewController(t)
   165  	t.Cleanup(mockCtrl.Finish)
   166  
   167  	mockAppModule1 := mocks.NewMockAppModule(mockCtrl)
   168  	mockAppModule2 := mocks.NewMockAppModule(mockCtrl)
   169  	mockAppModule1.EXPECT().Name().Times(2).Return("module1")
   170  	mockAppModule2.EXPECT().Name().Times(2).Return("module2")
   171  	mm := module.NewManager(mockAppModule1, mockAppModule2)
   172  	require.NotNil(t, mm)
   173  	require.Equal(t, 2, len(mm.Modules))
   174  
   175  	msgRouter := mocks.NewMockServer(mockCtrl)
   176  	queryRouter := mocks.NewMockServer(mockCtrl)
   177  	interfaceRegistry := types.NewInterfaceRegistry()
   178  	cdc := codec.NewProtoCodec(interfaceRegistry)
   179  	cfg := module.NewConfigurator(cdc, msgRouter, queryRouter)
   180  	mockAppModule1.EXPECT().RegisterServices(cfg).Times(1)
   181  	mockAppModule2.EXPECT().RegisterServices(cfg).Times(1)
   182  
   183  	mm.RegisterServices(cfg)
   184  }
   185  
   186  func TestManager_InitGenesis(t *testing.T) {
   187  	mockCtrl := gomock.NewController(t)
   188  	t.Cleanup(mockCtrl.Finish)
   189  
   190  	mockAppModule1 := mocks.NewMockAppModule(mockCtrl)
   191  	mockAppModule2 := mocks.NewMockAppModule(mockCtrl)
   192  	mockAppModule1.EXPECT().Name().Times(2).Return("module1")
   193  	mockAppModule2.EXPECT().Name().Times(2).Return("module2")
   194  	mm := module.NewManager(mockAppModule1, mockAppModule2)
   195  	require.NotNil(t, mm)
   196  	require.Equal(t, 2, len(mm.Modules))
   197  
   198  	ctx := sdk.Context{}
   199  	interfaceRegistry := types.NewInterfaceRegistry()
   200  	cdc := codec.NewProtoCodec(interfaceRegistry)
   201  	genesisData := map[string]json.RawMessage{"module1": json.RawMessage(`{"key": "value"}`)}
   202  
   203  	mockAppModule1.EXPECT().InitGenesis(gomock.Eq(ctx), gomock.Eq(cdc), gomock.Eq(genesisData["module1"])).Times(1).Return(nil)
   204  	require.Equal(t, abci.ResponseInitChain{Validators: []abci.ValidatorUpdate(nil)}, mm.InitGenesis(ctx, cdc, genesisData))
   205  
   206  	// test panic
   207  	genesisData = map[string]json.RawMessage{
   208  		"module1": json.RawMessage(`{"key": "value"}`),
   209  		"module2": json.RawMessage(`{"key": "value"}`),
   210  	}
   211  	mockAppModule1.EXPECT().InitGenesis(gomock.Eq(ctx), gomock.Eq(cdc), gomock.Eq(genesisData["module1"])).Times(1).Return([]abci.ValidatorUpdate{{}})
   212  	mockAppModule2.EXPECT().InitGenesis(gomock.Eq(ctx), gomock.Eq(cdc), gomock.Eq(genesisData["module2"])).Times(1).Return([]abci.ValidatorUpdate{{}})
   213  	require.Panics(t, func() { mm.InitGenesis(ctx, cdc, genesisData) })
   214  }
   215  
   216  func TestManager_ExportGenesis(t *testing.T) {
   217  	mockCtrl := gomock.NewController(t)
   218  	t.Cleanup(mockCtrl.Finish)
   219  
   220  	mockAppModule1 := mocks.NewMockAppModule(mockCtrl)
   221  	mockAppModule2 := mocks.NewMockAppModule(mockCtrl)
   222  	mockAppModule1.EXPECT().Name().Times(2).Return("module1")
   223  	mockAppModule2.EXPECT().Name().Times(2).Return("module2")
   224  	mm := module.NewManager(mockAppModule1, mockAppModule2)
   225  	require.NotNil(t, mm)
   226  	require.Equal(t, 2, len(mm.Modules))
   227  
   228  	ctx := sdk.Context{}
   229  	interfaceRegistry := types.NewInterfaceRegistry()
   230  	cdc := codec.NewProtoCodec(interfaceRegistry)
   231  	mockAppModule1.EXPECT().ExportGenesis(gomock.Eq(ctx), gomock.Eq(cdc)).Times(1).Return(json.RawMessage(`{"key1": "value1"}`))
   232  	mockAppModule2.EXPECT().ExportGenesis(gomock.Eq(ctx), gomock.Eq(cdc)).Times(1).Return(json.RawMessage(`{"key2": "value2"}`))
   233  
   234  	want := map[string]json.RawMessage{
   235  		"module1": json.RawMessage(`{"key1": "value1"}`),
   236  		"module2": json.RawMessage(`{"key2": "value2"}`),
   237  	}
   238  	require.Equal(t, want, mm.ExportGenesis(ctx, cdc))
   239  }
   240  
   241  func TestManager_BeginBlock(t *testing.T) {
   242  	mockCtrl := gomock.NewController(t)
   243  	t.Cleanup(mockCtrl.Finish)
   244  
   245  	mockAppModule1 := mocks.NewMockAppModule(mockCtrl)
   246  	mockAppModule2 := mocks.NewMockAppModule(mockCtrl)
   247  	mockAppModule1.EXPECT().Name().Times(2).Return("module1")
   248  	mockAppModule2.EXPECT().Name().Times(2).Return("module2")
   249  	mm := module.NewManager(mockAppModule1, mockAppModule2)
   250  	require.NotNil(t, mm)
   251  	require.Equal(t, 2, len(mm.Modules))
   252  
   253  	req := ocabci.RequestBeginBlock{Hash: []byte("test")}
   254  
   255  	mockAppModule1.EXPECT().BeginBlock(gomock.Any(), gomock.Eq(req)).Times(1)
   256  	mockAppModule2.EXPECT().BeginBlock(gomock.Any(), gomock.Eq(req)).Times(1)
   257  	mm.BeginBlock(sdk.Context{}, req)
   258  }
   259  
   260  func TestManager_EndBlock(t *testing.T) {
   261  	mockCtrl := gomock.NewController(t)
   262  	t.Cleanup(mockCtrl.Finish)
   263  
   264  	mockAppModule1 := mocks.NewMockAppModule(mockCtrl)
   265  	mockAppModule2 := mocks.NewMockAppModule(mockCtrl)
   266  	mockAppModule1.EXPECT().Name().Times(2).Return("module1")
   267  	mockAppModule2.EXPECT().Name().Times(2).Return("module2")
   268  	mm := module.NewManager(mockAppModule1, mockAppModule2)
   269  	require.NotNil(t, mm)
   270  	require.Equal(t, 2, len(mm.Modules))
   271  
   272  	req := abci.RequestEndBlock{Height: 10}
   273  
   274  	mockAppModule1.EXPECT().EndBlock(gomock.Any(), gomock.Eq(req)).Times(1).Return([]abci.ValidatorUpdate{{}})
   275  	mockAppModule2.EXPECT().EndBlock(gomock.Any(), gomock.Eq(req)).Times(1)
   276  	ret := mm.EndBlock(sdk.Context{}, req)
   277  	require.Equal(t, []abci.ValidatorUpdate{{}}, ret.ValidatorUpdates)
   278  
   279  	// test panic
   280  	mockAppModule1.EXPECT().EndBlock(gomock.Any(), gomock.Eq(req)).Times(1).Return([]abci.ValidatorUpdate{{}})
   281  	mockAppModule2.EXPECT().EndBlock(gomock.Any(), gomock.Eq(req)).Times(1).Return([]abci.ValidatorUpdate{{}})
   282  	require.Panics(t, func() { mm.EndBlock(sdk.Context{}, req) })
   283  }