fix(dot/sync, dot/rpc): implement HighestBlock

dot/node.go

@@ -317,16 +317,16 @@ func NewNode(cfg *Config, ks *keystore.GlobalKeystore) (*Node, error) {
 	// check if rpc service is enabled
 	if enabled := cfg.RPC.isRPCEnabled() || cfg.RPC.isWSEnabled(); enabled {
 		var rpcSrvc *rpc.HTTPServer
-		cRPCParams := createRPCServiceParams{
-			cfg,
-			ns,
-			stateSrvc,
-			coreSrvc,
-			networkSrvc,
-			bp,
-			sysSrvc,
-			fg,
-			syncer,
+		cRPCParams := rpcServiceSettings{
+			config:        cfg,
+			nodeStorage:   ns,
+			state:         stateSrvc,
+			core:          coreSrvc,
+			network:       networkSrvc,
+			blockProducer: bp,
+			system:        sysSrvc,
+			blockFinality: fg,
+			syncer:        syncer,
 		}
 		rpcSrvc, err = createRPCService(cRPCParams)
 		if err != nil {

dot/rpc/modules/api.go

@@ -153,7 +153,8 @@ type SyncStateAPI interface {
 	GenSyncSpec(raw bool) (*genesis.Genesis, error)
 }
 
-//go:generate mockery --name SyncAPI --structname SyncAPI --case underscore --keeptree
+//go:generate mockgen -destination=mock_sync_api_test.go -package $GOPACKAGE . SyncAPI
+// SyncAPI is the interface to interact with sync service
 type SyncAPI interface {
 	HighestBlock() int64
 }

dot/rpc/modules/system_integration_test.go

@@ -92,7 +92,7 @@ func TestSystemModule_Health(t *testing.T) {
 	networkMock := new(mocks.NetworkAPI)
 	networkMock.On("Health").Return(testHealth)
 
-	sys := NewSystemModule(networkMock, nil, nil, nil, nil, nil)
+	sys := NewSystemModule(networkMock, nil, nil, nil, nil, nil, nil)
 
 	res := &SystemHealthResponse{}
 	err := sys.Health(nil, nil, res)
@@ -103,7 +103,7 @@ func TestSystemModule_Health(t *testing.T) {
 // Test RPC's System.NetworkState() response
 func TestSystemModule_NetworkState(t *testing.T) {
 	net := newNetworkService(t)
-	sys := NewSystemModule(net, nil, nil, nil, nil, nil)
+	sys := NewSystemModule(net, nil, nil, nil, nil, nil, nil)
 
 	res := &SystemNetworkStateResponse{}
 	err := sys.NetworkState(nil, nil, res)
@@ -120,7 +120,7 @@ func TestSystemModule_NetworkState(t *testing.T) {
 func TestSystemModule_Peers(t *testing.T) {
 	net := newNetworkService(t)
 	net.Stop()
-	sys := NewSystemModule(net, nil, nil, nil, nil, nil)
+	sys := NewSystemModule(net, nil, nil, nil, nil, nil, nil)
 
 	res := &SystemPeersResponse{}
 	err := sys.Peers(nil, nil, res)
@@ -133,7 +133,7 @@ func TestSystemModule_Peers(t *testing.T) {
 
 func TestSystemModule_NodeRoles(t *testing.T) {
 	net := newNetworkService(t)
-	sys := NewSystemModule(net, nil, nil, nil, nil, nil)
+	sys := NewSystemModule(net, nil, nil, nil, nil, nil, nil)
 	expected := []interface{}{"Full"}
 
 	var res []interface{}
@@ -165,7 +165,7 @@ func newMockSystemAPI() *mocks.SystemAPI {
 }
 
 func TestSystemModule_Chain(t *testing.T) {
-	sys := NewSystemModule(nil, newMockSystemAPI(), nil, nil, nil, nil)
+	sys := NewSystemModule(nil, newMockSystemAPI(), nil, nil, nil, nil, nil)
 
 	res := new(string)
 	err := sys.Chain(nil, nil, res)
@@ -176,14 +176,14 @@ func TestSystemModule_Chain(t *testing.T) {
 func TestSystemModule_ChainType(t *testing.T) {
 	api := newMockSystemAPI()
 
-	sys := NewSystemModule(nil, api, nil, nil, nil, nil)
+	sys := NewSystemModule(nil, api, nil, nil, nil, nil, nil)
 
 	res := new(string)
 	sys.ChainType(nil, nil, res)
 	require.Equal(t, testGenesisData.ChainType, *res)
 }
 func TestSystemModule_Name(t *testing.T) {
-	sys := NewSystemModule(nil, newMockSystemAPI(), nil, nil, nil, nil)
+	sys := NewSystemModule(nil, newMockSystemAPI(), nil, nil, nil, nil, nil)
 
 	res := new(string)
 	err := sys.Name(nil, nil, res)
@@ -192,7 +192,7 @@ func TestSystemModule_Name(t *testing.T) {
 }
 
 func TestSystemModule_Version(t *testing.T) {
-	sys := NewSystemModule(nil, newMockSystemAPI(), nil, nil, nil, nil)
+	sys := NewSystemModule(nil, newMockSystemAPI(), nil, nil, nil, nil, nil)
 
 	res := new(string)
 	err := sys.Version(nil, nil, res)
@@ -201,7 +201,7 @@ func TestSystemModule_Version(t *testing.T) {
 }
 
 func TestSystemModule_Properties(t *testing.T) {
-	sys := NewSystemModule(nil, newMockSystemAPI(), nil, nil, nil, nil)
+	sys := NewSystemModule(nil, newMockSystemAPI(), nil, nil, nil, nil, nil)
 
 	expected := map[string]interface{}(nil)
 
@@ -331,7 +331,7 @@ func setupSystemModule(t *testing.T) *SystemModule {
 		AnyTimes()
 
 	txQueue := state.NewTransactionState(telemetryMock)
-	return NewSystemModule(net, nil, core, chain.Storage, txQueue, nil)
+	return NewSystemModule(net, nil, core, chain.Storage, txQueue, nil, nil)
 }
 
 func newCoreService(t *testing.T, srvc *state.Service) *core.Service {
@@ -383,12 +383,16 @@ func TestSyncState(t *testing.T) {
 	blockapiMock.On("GetHeader", fakeCommonHash).Return(fakeHeader, nil).Once()
 
 	netapiMock := new(mocks.NetworkAPI)
-	netapiMock.On("HighestBlock").Return(int64(90))
 	netapiMock.On("StartingBlock").Return(int64(10))
 
+	syncapiCtrl := gomock.NewController(t)
+	syncapiMock := NewMockSyncAPI(syncapiCtrl)
+	syncapiMock.EXPECT().HighestBlock().Return(int64(90))
+
 	sysmodule := new(SystemModule)
 	sysmodule.blockAPI = blockapiMock
 	sysmodule.networkAPI = netapiMock
+	sysmodule.syncAPI = syncapiMock
 
 	var res SyncStateResponse
 	err := sysmodule.SyncState(nil, nil, &res)

dot/rpc/modules/system_test.go

@@ -13,6 +13,7 @@ import (
 	"github.com/ChainSafe/gossamer/dot/types"
 	"github.com/ChainSafe/gossamer/lib/common"
 	"github.com/ChainSafe/gossamer/lib/transaction"
+	"github.com/golang/mock/gomock"
 	"github.com/multiformats/go-multiaddr"
 
 	"github.com/stretchr/testify/assert"
@@ -319,8 +320,9 @@ func TestSystemModule_SyncState(t *testing.T) {
 	mockNetworkAPI := new(mocks.NetworkAPI)
 	mockNetworkAPI.On("StartingBlock").Return(int64(23))
 
-	mockSyncAPI := new(mocks.SyncAPI)
-	mockSyncAPI.On("HighestBlock").Return(int64(21))
+	ctrlSyncAPI := gomock.NewController(t)
+	mockSyncAPI := NewMockSyncAPI(ctrlSyncAPI)
+	mockSyncAPI.EXPECT().HighestBlock().Return(int64(21))
 
 	type args struct {
 		r   *http.Request

dot/services.go

@@ -36,17 +36,18 @@ import (
 	"github.com/ChainSafe/gossamer/lib/utils"
 )
 
-// createRPCServiceParams struct to implements the Parameter Object Pattern: https://refactoring.guru/introduce-parameter-object
-type createRPCServiceParams struct {
-	cfg         *Config
-	ns          *runtime.NodeStorage
-	stateSrvc   *state.Service
-	coreSrvc    *core.Service
-	networkSrvc *network.Service
-	bp          modules.BlockProducerAPI
-	sysSrvc     *system.Service
-	finSrvc     *grandpa.Service
-	syncer      *sync.Service
+// rpcServiceSettings struct to implements the Parameter Object Pattern:
+// https://refactoring.guru/introduce-parameter-object
+type rpcServiceSettings struct {
+	config        *Config
+	nodeStorage   *runtime.NodeStorage
+	state         *state.Service
+	core          *core.Service
+	network       *network.Service
+	blockProducer modules.BlockProducerAPI
+	system        *system.Service
+	blockFinality *grandpa.Service
+	syncer        *sync.Service
 }
 
 func newInMemoryDB(path string) (chaindb.Database, error) {
@@ -317,50 +318,55 @@ func createNetworkService(cfg *Config, stateSrvc *state.Service,
 // RPC Service
 
 // createRPCService creates the RPC service from the provided core configuration
-func createRPCService(params createRPCServiceParams) (*rpc.HTTPServer, error) {
+func createRPCService(params rpcServiceSettings) (*rpc.HTTPServer, error) {
 	logger.Infof(
 		"creating rpc service with host %s, external=%t, port %d, modules %s, ws=%t, ws port %d and ws external=%t",
-		params.cfg.RPC.Host, params.cfg.RPC.External, params.cfg.RPC.Port, strings.Join(params.cfg.RPC.Modules, ","), params.cfg.RPC.WS,
-		params.cfg.RPC.WSPort, params.cfg.RPC.WSExternal,
+		params.config.RPC.Host,
+		params.config.RPC.External,
+		params.config.RPC.Port,
+		strings.Join(params.config.RPC.Modules, ","),
+		params.config.RPC.WS,
+		params.config.RPC.WSPort,
+		params.config.RPC.WSExternal,
 	)
 	rpcService := rpc.NewService()
 
-	genesisData, err := params.stateSrvc.Base.LoadGenesisData()
+	genesisData, err := params.state.Base.LoadGenesisData()
 	if err != nil {
 		return nil, fmt.Errorf("failed to load genesis data: %s", err)
 	}
 
-	syncStateSrvc, err := modules.NewStateSync(genesisData, params.stateSrvc.Storage)
+	syncStateSrvc, err := modules.NewStateSync(genesisData, params.state.Storage)
 	if err != nil {
 		return nil, fmt.Errorf("failed to create sync state service: %s", err)
 	}
 
 	rpcConfig := &rpc.HTTPServerConfig{
-		LogLvl:              params.cfg.Log.RPCLvl,
-		BlockAPI:            params.stateSrvc.Block,
-		StorageAPI:          params.stateSrvc.Storage,
-		NetworkAPI:          params.networkSrvc,
-		CoreAPI:             params.coreSrvc,
-		NodeStorage:         params.ns,
-		BlockProducerAPI:    params.bp,
-		BlockFinalityAPI:    params.finSrvc,
-		TransactionQueueAPI: params.stateSrvc.Transaction,
+		LogLvl:              params.config.Log.RPCLvl,
+		BlockAPI:            params.state.Block,
+		StorageAPI:          params.state.Storage,
+		NetworkAPI:          params.network,
+		CoreAPI:             params.core,
+		NodeStorage:         params.nodeStorage,
+		BlockProducerAPI:    params.blockProducer,
+		BlockFinalityAPI:    params.blockFinality,
+		TransactionQueueAPI: params.state.Transaction,
 		RPCAPI:              rpcService,
 		SyncStateAPI:        syncStateSrvc,
 		SyncAPI:             params.syncer,
-		SystemAPI:           params.sysSrvc,
-		RPC:                 params.cfg.RPC.Enabled,
-		RPCExternal:         params.cfg.RPC.External,
-		RPCUnsafe:           params.cfg.RPC.Unsafe,
-		RPCUnsafeExternal:   params.cfg.RPC.UnsafeExternal,
-		Host:                params.cfg.RPC.Host,
-		RPCPort:             params.cfg.RPC.Port,
-		WS:                  params.cfg.RPC.WS,
-		WSExternal:          params.cfg.RPC.WSExternal,
-		WSUnsafe:            params.cfg.RPC.WSUnsafe,
-		WSUnsafeExternal:    params.cfg.RPC.WSUnsafeExternal,
-		WSPort:              params.cfg.RPC.WSPort,
-		Modules:             params.cfg.RPC.Modules,
+		SystemAPI:           params.system,
+		RPC:                 params.config.RPC.Enabled,
+		RPCExternal:         params.config.RPC.External,
+		RPCUnsafe:           params.config.RPC.Unsafe,
+		RPCUnsafeExternal:   params.config.RPC.UnsafeExternal,
+		Host:                params.config.RPC.Host,
+		RPCPort:             params.config.RPC.Port,
+		WS:                  params.config.RPC.WS,
+		WSExternal:          params.config.RPC.WSExternal,
+		WSUnsafe:            params.config.RPC.WSUnsafe,
+		WSUnsafeExternal:    params.config.RPC.WSUnsafeExternal,
+		WSPort:              params.config.RPC.WSPort,
+		Modules:             params.config.RPC.Modules,
 	}
 
 	return rpc.NewHTTPServer(rpcConfig), nil

dot/services_test.go

@@ -221,16 +221,13 @@ func TestCreateRPCService(t *testing.T) {
 	sysSrvc, err := createSystemService(&cfg.System, stateSrvc)
 	require.NoError(t, err)
 
-	paramsRPC := createRPCServiceParams{
-		cfg,
-		ns,
-		stateSrvc,
-		coreSrvc,
-		networkSrvc,
-		nil,
-		sysSrvc,
-		nil,
-		nil,
+	paramsRPC := rpcServiceSettings{
+		config:      cfg,
+		nodeStorage: ns,
+		state:       stateSrvc,
+		core:        coreSrvc,
+		network:     networkSrvc,
+		system:      sysSrvc,
 	}
 	rpcSrvc, err := createRPCService(paramsRPC)
 	require.NoError(t, err)
@@ -396,16 +393,13 @@ func TestNewWebSocketServer(t *testing.T) {
 	sysSrvc, err := createSystemService(&cfg.System, stateSrvc)
 	require.NoError(t, err)
 
-	paramsRPC := createRPCServiceParams{
-		cfg,
-		ns,
-		stateSrvc,
-		coreSrvc,
-		networkSrvc,
-		nil,
-		sysSrvc,
-		nil,
-		nil,
+	paramsRPC := rpcServiceSettings{
+		config:      cfg,
+		nodeStorage: ns,
+		state:       stateSrvc,
+		core:        coreSrvc,
+		network:     networkSrvc,
+		system:      sysSrvc,
 	}
 	rpcSrvc, err := createRPCService(paramsRPC)
 	require.NoError(t, err)