github.com/0xPolygon/supernets2-node@v0.0.0-20230711153321-2fe574524eaa/jsonrpc/server_test.go (about)

     1  package jsonrpc
     2  
     3  import (
     4  	"fmt"
     5  	"net/http"
     6  	"testing"
     7  	"time"
     8  
     9  	"github.com/0xPolygon/supernets2-node/jsonrpc/client"
    10  	"github.com/0xPolygon/supernets2-node/jsonrpc/mocks"
    11  	"github.com/0xPolygon/supernets2-node/jsonrpc/types"
    12  	"github.com/0xPolygon/supernets2-node/state"
    13  	"github.com/ethereum/go-ethereum/ethclient"
    14  	"github.com/stretchr/testify/mock"
    15  	"github.com/stretchr/testify/require"
    16  )
    17  
    18  const (
    19  	maxRequestsPerIPAndSecond        = 1000
    20  	chainID                   uint64 = 1000
    21  )
    22  
    23  type mockedServer struct {
    24  	Config    Config
    25  	Server    *Server
    26  	ServerURL string
    27  }
    28  
    29  type mocksWrapper struct {
    30  	Pool    *mocks.PoolMock
    31  	State   *mocks.StateMock
    32  	Storage *storageMock
    33  	DbTx    *mocks.DBTxMock
    34  }
    35  
    36  func newMockedServer(t *testing.T, cfg Config) (*mockedServer, *mocksWrapper, *ethclient.Client) {
    37  	pool := mocks.NewPoolMock(t)
    38  	st := mocks.NewStateMock(t)
    39  	storage := newStorageMock(t)
    40  	dbTx := mocks.NewDBTxMock(t)
    41  	apis := map[string]bool{
    42  		APIEth:    true,
    43  		APINet:    true,
    44  		APIDebug:  true,
    45  		APIZKEVM:  true,
    46  		APITxPool: true,
    47  		APIWeb3:   true,
    48  	}
    49  
    50  	var newL2BlockEventHandler state.NewL2BlockEventHandler = func(e state.NewL2BlockEvent) {}
    51  	st.On("RegisterNewL2BlockEventHandler", mock.IsType(newL2BlockEventHandler)).Once()
    52  	st.On("PrepareWebSocket").Once()
    53  
    54  	services := []Service{}
    55  	if _, ok := apis[APIEth]; ok {
    56  		services = append(services, Service{
    57  			Name:    APIEth,
    58  			Service: NewEthEndpoints(cfg, chainID, pool, st, storage),
    59  		})
    60  	}
    61  
    62  	if _, ok := apis[APINet]; ok {
    63  		services = append(services, Service{
    64  			Name:    APINet,
    65  			Service: NewNetEndpoints(chainID),
    66  		})
    67  	}
    68  
    69  	if _, ok := apis[APIZKEVM]; ok {
    70  		services = append(services, Service{
    71  			Name:    APIZKEVM,
    72  			Service: NewZKEVMEndpoints(st),
    73  		})
    74  	}
    75  
    76  	if _, ok := apis[APITxPool]; ok {
    77  		services = append(services, Service{
    78  			Name:    APITxPool,
    79  			Service: &TxPoolEndpoints{},
    80  		})
    81  	}
    82  
    83  	if _, ok := apis[APIDebug]; ok {
    84  		services = append(services, Service{
    85  			Name:    APIDebug,
    86  			Service: NewDebugEndpoints(st),
    87  		})
    88  	}
    89  
    90  	if _, ok := apis[APIWeb3]; ok {
    91  		services = append(services, Service{
    92  			Name:    APIWeb3,
    93  			Service: &Web3Endpoints{},
    94  		})
    95  	}
    96  	server := NewServer(cfg, chainID, pool, st, storage, services)
    97  
    98  	go func() {
    99  		err := server.Start()
   100  		if err != nil {
   101  			panic(err)
   102  		}
   103  	}()
   104  
   105  	serverURL := fmt.Sprintf("http://%s:%d", cfg.Host, cfg.Port)
   106  	for {
   107  		fmt.Println("waiting server to get ready...") // fmt is used here to avoid race condition with logs
   108  		res, err := http.Get(serverURL)               //nolint:gosec
   109  		if err == nil && res.StatusCode == http.StatusOK {
   110  			fmt.Println("server ready!") // fmt is used here to avoid race condition with logs
   111  			break
   112  		}
   113  		time.Sleep(10 * time.Millisecond)
   114  	}
   115  
   116  	ethClient, err := ethclient.Dial(serverURL)
   117  	require.NoError(t, err)
   118  
   119  	msv := &mockedServer{
   120  		Config:    cfg,
   121  		Server:    server,
   122  		ServerURL: serverURL,
   123  	}
   124  
   125  	mks := &mocksWrapper{
   126  		Pool:    pool,
   127  		State:   st,
   128  		Storage: storage,
   129  		DbTx:    dbTx,
   130  	}
   131  
   132  	return msv, mks, ethClient
   133  }
   134  
   135  func getDefaultConfig() Config {
   136  	cfg := Config{
   137  		Host:                      "0.0.0.0",
   138  		Port:                      9123,
   139  		MaxRequestsPerIPAndSecond: maxRequestsPerIPAndSecond,
   140  		MaxCumulativeGasUsed:      300000,
   141  	}
   142  	return cfg
   143  }
   144  
   145  func newSequencerMockedServer(t *testing.T) (*mockedServer, *mocksWrapper, *ethclient.Client) {
   146  	cfg := getDefaultConfig()
   147  	return newMockedServer(t, cfg)
   148  }
   149  
   150  func newNonSequencerMockedServer(t *testing.T, sequencerNodeURI string) (*mockedServer, *mocksWrapper, *ethclient.Client) {
   151  	cfg := getDefaultConfig()
   152  	cfg.Port = 9124
   153  	cfg.SequencerNodeURI = sequencerNodeURI
   154  	return newMockedServer(t, cfg)
   155  }
   156  
   157  func (s *mockedServer) Stop() {
   158  	err := s.Server.Stop()
   159  	if err != nil {
   160  		panic(err)
   161  	}
   162  }
   163  
   164  func (s *mockedServer) JSONRPCCall(method string, parameters ...interface{}) (types.Response, error) {
   165  	return client.JSONRPCCall(s.ServerURL, method, parameters...)
   166  }
   167  
   168  func (s *mockedServer) ChainID() uint64 {
   169  	return chainID
   170  }