diff --git a/api/mocks/api.go b/api/mocks/api.go new file mode 100644 index 0000000000..55e3163c0b --- /dev/null +++ b/api/mocks/api.go @@ -0,0 +1,415 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: github.com/celestiaorg/celestia-node/api/rpc/client (interfaces: API) + +// Package mocks is a generated GoMock package. +package mocks + +import ( + context "context" + reflect "reflect" + + math "cosmossdk.io/math" + types "github.com/cosmos/cosmos-sdk/types" + types0 "github.com/cosmos/cosmos-sdk/x/staking/types" + gomock "github.com/golang/mock/gomock" + da "github.com/tendermint/tendermint/pkg/da" + types1 "github.com/tendermint/tendermint/types" + + das "github.com/celestiaorg/celestia-node/das" + fraud "github.com/celestiaorg/celestia-node/fraud" + header "github.com/celestiaorg/celestia-node/header" + namespace "github.com/celestiaorg/nmt/namespace" +) + +// MockAPI is a mock of API interface. +type MockAPI struct { + ctrl *gomock.Controller + recorder *MockAPIMockRecorder +} + +// MockAPIMockRecorder is the mock recorder for MockAPI. +type MockAPIMockRecorder struct { + mock *MockAPI +} + +// NewMockAPI creates a new mock instance. +func NewMockAPI(ctrl *gomock.Controller) *MockAPI { + mock := &MockAPI{ctrl: ctrl} + mock.recorder = &MockAPIMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockAPI) EXPECT() *MockAPIMockRecorder { + return m.recorder +} + +// Balance mocks base method. +func (m *MockAPI) Balance(arg0 context.Context) (*types.Coin, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Balance", arg0) + ret0, _ := ret[0].(*types.Coin) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Balance indicates an expected call of Balance. +func (mr *MockAPIMockRecorder) Balance(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Balance", reflect.TypeOf((*MockAPI)(nil).Balance), arg0) +} + +// BalanceForAddress mocks base method. +func (m *MockAPI) BalanceForAddress(arg0 context.Context, arg1 types.Address) (*types.Coin, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BalanceForAddress", arg0, arg1) + ret0, _ := ret[0].(*types.Coin) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BalanceForAddress indicates an expected call of BalanceForAddress. +func (mr *MockAPIMockRecorder) BalanceForAddress(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BalanceForAddress", reflect.TypeOf((*MockAPI)(nil).BalanceForAddress), arg0, arg1) +} + +// BeginRedelegate mocks base method. +func (m *MockAPI) BeginRedelegate(arg0 context.Context, arg1, arg2 types.ValAddress, arg3 math.Int, arg4 uint64) (*types.TxResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BeginRedelegate", arg0, arg1, arg2, arg3, arg4) + ret0, _ := ret[0].(*types.TxResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BeginRedelegate indicates an expected call of BeginRedelegate. +func (mr *MockAPIMockRecorder) BeginRedelegate(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BeginRedelegate", reflect.TypeOf((*MockAPI)(nil).BeginRedelegate), arg0, arg1, arg2, arg3, arg4) +} + +// Broadcast mocks base method. +func (m *MockAPI) Broadcast(arg0 context.Context, arg1 fraud.Proof) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Broadcast", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// Broadcast indicates an expected call of Broadcast. +func (mr *MockAPIMockRecorder) Broadcast(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Broadcast", reflect.TypeOf((*MockAPI)(nil).Broadcast), arg0, arg1) +} + +// CancelUnbondingDelegation mocks base method. +func (m *MockAPI) CancelUnbondingDelegation(arg0 context.Context, arg1 types.ValAddress, arg2, arg3 math.Int, arg4 uint64) (*types.TxResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CancelUnbondingDelegation", arg0, arg1, arg2, arg3, arg4) + ret0, _ := ret[0].(*types.TxResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CancelUnbondingDelegation indicates an expected call of CancelUnbondingDelegation. +func (mr *MockAPIMockRecorder) CancelUnbondingDelegation(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelUnbondingDelegation", reflect.TypeOf((*MockAPI)(nil).CancelUnbondingDelegation), arg0, arg1, arg2, arg3, arg4) +} + +// Delegate mocks base method. +func (m *MockAPI) Delegate(arg0 context.Context, arg1 types.ValAddress, arg2 math.Int, arg3 uint64) (*types.TxResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Delegate", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*types.TxResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Delegate indicates an expected call of Delegate. +func (mr *MockAPIMockRecorder) Delegate(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delegate", reflect.TypeOf((*MockAPI)(nil).Delegate), arg0, arg1, arg2, arg3) +} + +// Get mocks base method. +func (m *MockAPI) Get(arg0 context.Context, arg1 fraud.ProofType) ([]fraud.Proof, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Get", arg0, arg1) + ret0, _ := ret[0].([]fraud.Proof) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Get indicates an expected call of Get. +func (mr *MockAPIMockRecorder) Get(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockAPI)(nil).Get), arg0, arg1) +} + +// GetByHeight mocks base method. +func (m *MockAPI) GetByHeight(arg0 context.Context, arg1 uint64) (*header.ExtendedHeader, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetByHeight", arg0, arg1) + ret0, _ := ret[0].(*header.ExtendedHeader) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetByHeight indicates an expected call of GetByHeight. +func (mr *MockAPIMockRecorder) GetByHeight(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByHeight", reflect.TypeOf((*MockAPI)(nil).GetByHeight), arg0, arg1) +} + +// GetShare mocks base method. +func (m *MockAPI) GetShare(arg0 context.Context, arg1 *da.DataAvailabilityHeader, arg2, arg3 int) ([]byte, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetShare", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].([]byte) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetShare indicates an expected call of GetShare. +func (mr *MockAPIMockRecorder) GetShare(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetShare", reflect.TypeOf((*MockAPI)(nil).GetShare), arg0, arg1, arg2, arg3) +} + +// GetShares mocks base method. +func (m *MockAPI) GetShares(arg0 context.Context, arg1 *da.DataAvailabilityHeader) ([][][]byte, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetShares", arg0, arg1) + ret0, _ := ret[0].([][][]byte) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetShares indicates an expected call of GetShares. +func (mr *MockAPIMockRecorder) GetShares(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetShares", reflect.TypeOf((*MockAPI)(nil).GetShares), arg0, arg1) +} + +// GetSharesByNamespace mocks base method. +func (m *MockAPI) GetSharesByNamespace(arg0 context.Context, arg1 *da.DataAvailabilityHeader, arg2 namespace.ID) ([][]byte, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetSharesByNamespace", arg0, arg1, arg2) + ret0, _ := ret[0].([][]byte) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetSharesByNamespace indicates an expected call of GetSharesByNamespace. +func (mr *MockAPIMockRecorder) GetSharesByNamespace(arg0, arg1, arg2 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSharesByNamespace", reflect.TypeOf((*MockAPI)(nil).GetSharesByNamespace), arg0, arg1, arg2) +} + +// Head mocks base method. +func (m *MockAPI) Head(arg0 context.Context) (*header.ExtendedHeader, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Head", arg0) + ret0, _ := ret[0].(*header.ExtendedHeader) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Head indicates an expected call of Head. +func (mr *MockAPIMockRecorder) Head(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Head", reflect.TypeOf((*MockAPI)(nil).Head), arg0) +} + +// IsStopped mocks base method. +func (m *MockAPI) IsStopped() bool { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "IsStopped") + ret0, _ := ret[0].(bool) + return ret0 +} + +// IsStopped indicates an expected call of IsStopped. +func (mr *MockAPIMockRecorder) IsStopped() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsStopped", reflect.TypeOf((*MockAPI)(nil).IsStopped)) +} + +// IsSyncing mocks base method. +func (m *MockAPI) IsSyncing() bool { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "IsSyncing") + ret0, _ := ret[0].(bool) + return ret0 +} + +// IsSyncing indicates an expected call of IsSyncing. +func (mr *MockAPIMockRecorder) IsSyncing() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsSyncing", reflect.TypeOf((*MockAPI)(nil).IsSyncing)) +} + +// ProbabilityOfAvailability mocks base method. +func (m *MockAPI) ProbabilityOfAvailability() float64 { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ProbabilityOfAvailability") + ret0, _ := ret[0].(float64) + return ret0 +} + +// ProbabilityOfAvailability indicates an expected call of ProbabilityOfAvailability. +func (mr *MockAPIMockRecorder) ProbabilityOfAvailability() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProbabilityOfAvailability", reflect.TypeOf((*MockAPI)(nil).ProbabilityOfAvailability)) +} + +// QueryDelegation mocks base method. +func (m *MockAPI) QueryDelegation(arg0 context.Context, arg1 types.ValAddress) (*types0.QueryDelegationResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryDelegation", arg0, arg1) + ret0, _ := ret[0].(*types0.QueryDelegationResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryDelegation indicates an expected call of QueryDelegation. +func (mr *MockAPIMockRecorder) QueryDelegation(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryDelegation", reflect.TypeOf((*MockAPI)(nil).QueryDelegation), arg0, arg1) +} + +// QueryRedelegations mocks base method. +func (m *MockAPI) QueryRedelegations(arg0 context.Context, arg1, arg2 types.ValAddress) (*types0.QueryRedelegationsResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryRedelegations", arg0, arg1, arg2) + ret0, _ := ret[0].(*types0.QueryRedelegationsResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryRedelegations indicates an expected call of QueryRedelegations. +func (mr *MockAPIMockRecorder) QueryRedelegations(arg0, arg1, arg2 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryRedelegations", reflect.TypeOf((*MockAPI)(nil).QueryRedelegations), arg0, arg1, arg2) +} + +// QueryUnbonding mocks base method. +func (m *MockAPI) QueryUnbonding(arg0 context.Context, arg1 types.ValAddress) (*types0.QueryUnbondingDelegationResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryUnbonding", arg0, arg1) + ret0, _ := ret[0].(*types0.QueryUnbondingDelegationResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryUnbonding indicates an expected call of QueryUnbonding. +func (mr *MockAPIMockRecorder) QueryUnbonding(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryUnbonding", reflect.TypeOf((*MockAPI)(nil).QueryUnbonding), arg0, arg1) +} + +// SamplingStats mocks base method. +func (m *MockAPI) SamplingStats(arg0 context.Context) (das.SamplingStats, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SamplingStats", arg0) + ret0, _ := ret[0].(das.SamplingStats) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SamplingStats indicates an expected call of SamplingStats. +func (mr *MockAPIMockRecorder) SamplingStats(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SamplingStats", reflect.TypeOf((*MockAPI)(nil).SamplingStats), arg0) +} + +// SharesAvailable mocks base method. +func (m *MockAPI) SharesAvailable(arg0 context.Context, arg1 *da.DataAvailabilityHeader) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SharesAvailable", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// SharesAvailable indicates an expected call of SharesAvailable. +func (mr *MockAPIMockRecorder) SharesAvailable(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SharesAvailable", reflect.TypeOf((*MockAPI)(nil).SharesAvailable), arg0, arg1) +} + +// SubmitPayForData mocks base method. +func (m *MockAPI) SubmitPayForData(arg0 context.Context, arg1 namespace.ID, arg2 []byte, arg3 uint64) (*types.TxResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SubmitPayForData", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*types.TxResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SubmitPayForData indicates an expected call of SubmitPayForData. +func (mr *MockAPIMockRecorder) SubmitPayForData(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitPayForData", reflect.TypeOf((*MockAPI)(nil).SubmitPayForData), arg0, arg1, arg2, arg3) +} + +// SubmitTx mocks base method. +func (m *MockAPI) SubmitTx(arg0 context.Context, arg1 types1.Tx) (*types.TxResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SubmitTx", arg0, arg1) + ret0, _ := ret[0].(*types.TxResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SubmitTx indicates an expected call of SubmitTx. +func (mr *MockAPIMockRecorder) SubmitTx(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitTx", reflect.TypeOf((*MockAPI)(nil).SubmitTx), arg0, arg1) +} + +// Subscribe mocks base method. +func (m *MockAPI) Subscribe(arg0 fraud.ProofType) (fraud.Subscription, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Subscribe", arg0) + ret0, _ := ret[0].(fraud.Subscription) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Subscribe indicates an expected call of Subscribe. +func (mr *MockAPIMockRecorder) Subscribe(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Subscribe", reflect.TypeOf((*MockAPI)(nil).Subscribe), arg0) +} + +// Transfer mocks base method. +func (m *MockAPI) Transfer(arg0 context.Context, arg1 types.AccAddress, arg2 math.Int, arg3 uint64) (*types.TxResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Transfer", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*types.TxResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Transfer indicates an expected call of Transfer. +func (mr *MockAPIMockRecorder) Transfer(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Transfer", reflect.TypeOf((*MockAPI)(nil).Transfer), arg0, arg1, arg2, arg3) +} + +// Undelegate mocks base method. +func (m *MockAPI) Undelegate(arg0 context.Context, arg1 types.ValAddress, arg2 math.Int, arg3 uint64) (*types.TxResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Undelegate", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*types.TxResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Undelegate indicates an expected call of Undelegate. +func (mr *MockAPIMockRecorder) Undelegate(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Undelegate", reflect.TypeOf((*MockAPI)(nil).Undelegate), arg0, arg1, arg2, arg3) +} diff --git a/api/rpc/client/client.go b/api/rpc/client/client.go index 9a980ab53a..8ced5f9745 100644 --- a/api/rpc/client/client.go +++ b/api/rpc/client/client.go @@ -12,6 +12,15 @@ import ( "github.com/celestiaorg/celestia-node/nodebuilder/state" ) +//go:generate go run github.com/golang/mock/mockgen -destination=../../mocks/api.go -package=mocks . API +type API interface { + fraud.Module + header.Module + state.Module + share.Module + daser.Module +} + type Client struct { Fraud fraud.API Header header.API diff --git a/api/rpc/client/client_test.go b/api/rpc/client/client_test.go deleted file mode 100644 index b50b720add..0000000000 --- a/api/rpc/client/client_test.go +++ /dev/null @@ -1,19 +0,0 @@ -package client - -import ( - "context" - "fmt" - "testing" - - "github.com/stretchr/testify/require" -) - -func TestBalance(t *testing.T) { - t.Skip() - client, closer, err := NewClient(context.Background(), "http://localhost:26658") - defer closer() - require.NoError(t, err) - balance, err := client.State.Balance(context.Background()) - require.NoError(t, err) - fmt.Println(balance) -} diff --git a/api/rpc/handler.go b/api/rpc/handler.go index b4da3429c2..68e423178b 100644 --- a/api/rpc/handler.go +++ b/api/rpc/handler.go @@ -3,7 +3,6 @@ package rpc import ( logging "github.com/ipfs/go-log/v2" - "github.com/celestiaorg/celestia-node/das" "github.com/celestiaorg/celestia-node/nodebuilder/daser" "github.com/celestiaorg/celestia-node/nodebuilder/fraud" "github.com/celestiaorg/celestia-node/nodebuilder/header" @@ -26,7 +25,7 @@ func NewHandler( share share.Module, header header.Module, fraud fraud.Module, - das *das.DASer, + das daser.Module, ) *Handler { return &Handler{ state: state, diff --git a/go.mod b/go.mod index e55196c813..b5f49e619e 100644 --- a/go.mod +++ b/go.mod @@ -17,6 +17,7 @@ require ( github.com/filecoin-project/go-jsonrpc v0.1.8 github.com/gammazero/workerpool v1.1.3 github.com/gogo/protobuf v1.3.3 + github.com/golang/mock v1.6.0 github.com/gorilla/mux v1.8.0 github.com/hashicorp/go-retryablehttp v0.7.1-0.20211018174820-ff6d014e72d9 github.com/hashicorp/golang-lru v0.5.5-0.20210104140557-80c98217689d diff --git a/nodebuilder/daser/module.go b/nodebuilder/daser/module.go index 15f37cee4f..9f045774a1 100644 --- a/nodebuilder/daser/module.go +++ b/nodebuilder/daser/module.go @@ -28,6 +28,10 @@ func ConstructModule(tp node.Type) fx.Option { return das.Stop(ctx) }), )), + // Module is needed for the RPC handler + fx.Provide(func(das *das.DASer) Module { + return das + }), ) case node.Bridge: return fx.Options() diff --git a/nodebuilder/rpc_test.go b/nodebuilder/rpc_test.go new file mode 100644 index 0000000000..e589e8dbd8 --- /dev/null +++ b/nodebuilder/rpc_test.go @@ -0,0 +1,119 @@ +package nodebuilder + +import ( + "context" + "encoding/json" + "reflect" + "testing" + + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/golang/mock/gomock" + "github.com/stretchr/testify/require" + "go.uber.org/fx" + + "github.com/celestiaorg/celestia-node/api/mocks" + "github.com/celestiaorg/celestia-node/api/rpc" + "github.com/celestiaorg/celestia-node/api/rpc/client" + "github.com/celestiaorg/celestia-node/nodebuilder/node" + "github.com/celestiaorg/celestia-node/state" +) + +func TestRPCCallsUnderlyingNode(t *testing.T) { + nd, server := setupNodeWithModifiedRPC(t) + url := nd.RPCServer.ListenAddr() + port := url[len(url)-6:] + client, closer, err := client.NewClient(context.Background(), "http://0.0.0.0"+port) + require.NoError(t, err) + defer closer() + ctx := context.Background() + + expectedBalance := &state.Balance{ + Amount: sdk.NewInt(100), + Denom: "utia", + } + + server.EXPECT().Balance(gomock.Any()).Return(expectedBalance, nil).Times(1) + + balance, err := client.State.Balance(ctx) + require.NoError(t, err) + require.Equal(t, expectedBalance, balance) +} + +func TestModulesImplementFullAPI(t *testing.T) { + api := reflect.TypeOf(new(client.API)).Elem() + client := reflect.TypeOf(new(client.Client)).Elem() + for i := 0; i < client.NumField(); i++ { + module := client.Field(i) + for j := 0; j < module.Type.NumField(); j++ { + impl := module.Type.Field(j) + method, _ := api.MethodByName(impl.Name) + require.Equal(t, method.Type, impl.Type) + } + } +} + +// TODO(@distractedm1nd): Blocked by issues #1208 and #1207 +func TestAllReturnValuesAreMarshalable(t *testing.T) { + t.Skip() + ra := reflect.TypeOf(new(client.API)).Elem() + for i := 0; i < ra.NumMethod(); i++ { + m := ra.Method(i) + for j := 0; j < m.Type.NumOut(); j++ { + implementsMarshaler(t, m.Type.Out(j)) + } + } +} + +func implementsMarshaler(t *testing.T, typ reflect.Type) { //nolint:unused + switch typ.Kind() { + case reflect.Struct: + for i := 0; i < typ.NumField(); i++ { + implementsMarshaler(t, typ.Field(i).Type) + } + return + case reflect.Map: + implementsMarshaler(t, typ.Elem()) + implementsMarshaler(t, typ.Key()) + case reflect.Ptr: + fallthrough + case reflect.Array: + fallthrough + case reflect.Slice: + fallthrough + case reflect.Chan: + implementsMarshaler(t, typ.Elem()) + case reflect.Interface: + if typ != reflect.TypeOf(new(interface{})).Elem() && typ != reflect.TypeOf(new(error)).Elem() { + require.True( + t, + typ.Implements(reflect.TypeOf(new(json.Marshaler)).Elem()), + "type %s does not implement json.Marshaler", typ.String(), + ) + } + default: + return + } + +} + +func setupNodeWithModifiedRPC(t *testing.T) (*Node, *mocks.MockAPI) { + ctx, cancel := context.WithCancel(context.Background()) + t.Cleanup(cancel) + + ctrl := gomock.NewController(t) + server := mocks.NewMockAPI(ctrl) + + overrideRPCHandler := fx.Invoke(func(srv *rpc.Server) { + handler := rpc.NewHandler(server, server, server, server, server) + handler.RegisterEndpoints(srv) + }) + nd := TestNode(t, node.Full, overrideRPCHandler) + // start node + err := nd.Start(ctx) + require.NoError(t, err) + t.Cleanup(func() { + err = nd.Stop(ctx) + require.NoError(t, err) + }) + return nd, server +}