Merge dev into liquid staking 19 04 22

.github/workflows/golangci-lint.yml

@@ -15,7 +15,7 @@ jobs:
         uses: golangci/golangci-lint-action@v2
         with:
           # Required: the version of golangci-lint is required and must be specified without patch version: we always use the latest patch version.
-          version: v1.29
+          version: v1.45.2
 
           # Optional: working directory, useful for monorepos
           # working-directory: somedir

api/gin/webServer.go

@@ -74,7 +74,7 @@ func (ws *webServer) UpdateFacade(facade shared.FacadeHandler) error {
 	return nil
 }
 
-// CreateHttpServer will create a new instance of http.Server and populate it with all the routes
+// StartHttpServer will create a new instance of http.Server and populate it with all the routes
 func (ws *webServer) StartHttpServer() error {
 	ws.Lock()
 	defer ws.Unlock()
@@ -98,8 +98,9 @@ func (ws *webServer) StartHttpServer() error {
 		return err
 	}
 
-	for _, proc := range processors {
+	for idx, proc := range processors {
 		if check.IfNil(proc) {
+			log.Error("got nil middleware processor, skipping it...", "index", idx)
 			continue
 		}
 

api/groups/networkGroup.go

@@ -141,7 +141,19 @@ func NewNetworkGroup(facade networkFacadeHandler) (*networkGroup, error) {
 
 // getNetworkConfig returns metrics related to the network configuration (shard independent)
 func (ng *networkGroup) getNetworkConfig(c *gin.Context) {
-	configMetrics := ng.getFacade().StatusMetrics().ConfigMetrics()
+	configMetrics, err := ng.getFacade().StatusMetrics().ConfigMetrics()
+	if err != nil {
+		c.JSON(
+			http.StatusInternalServerError,
+			shared.GenericAPIResponse{
+				Data:  nil,
+				Error: err.Error(),
+				Code:  shared.ReturnCodeInternalError,
+			},
+		)
+		return
+	}
+
 	c.JSON(
 		http.StatusOK,
 		shared.GenericAPIResponse{
@@ -154,7 +166,19 @@ func (ng *networkGroup) getNetworkConfig(c *gin.Context) {
 
 // getEnableEpochs returns metrics related to the activation epochs of the network
 func (ng *networkGroup) getEnableEpochs(c *gin.Context) {
-	enableEpochsMetrics := ng.getFacade().StatusMetrics().EnableEpochsMetrics()
+	enableEpochsMetrics, err := ng.getFacade().StatusMetrics().EnableEpochsMetrics()
+	if err != nil {
+		c.JSON(
+			http.StatusInternalServerError,
+			shared.GenericAPIResponse{
+				Data:  nil,
+				Error: err.Error(),
+				Code:  shared.ReturnCodeInternalError,
+			},
+		)
+		return
+	}
+
 	c.JSON(
 		http.StatusOK,
 		shared.GenericAPIResponse{
@@ -167,7 +191,19 @@ func (ng *networkGroup) getEnableEpochs(c *gin.Context) {
 
 // getNetworkStatus returns metrics related to the network status (shard specific)
 func (ng *networkGroup) getNetworkStatus(c *gin.Context) {
-	networkMetrics := ng.getFacade().StatusMetrics().NetworkMetrics()
+	networkMetrics, err := ng.getFacade().StatusMetrics().NetworkMetrics()
+	if err != nil {
+		c.JSON(
+			http.StatusInternalServerError,
+			shared.GenericAPIResponse{
+				Data:  nil,
+				Error: err.Error(),
+				Code:  shared.ReturnCodeInternalError,
+			},
+		)
+		return
+	}
+
 	c.JSON(
 		http.StatusOK,
 		shared.GenericAPIResponse{
@@ -193,7 +229,19 @@ func (ng *networkGroup) economicsMetrics(c *gin.Context) {
 		return
 	}
 
-	metrics := ng.getFacade().StatusMetrics().EconomicsMetrics()
+	metrics, err := ng.getFacade().StatusMetrics().EconomicsMetrics()
+	if err != nil {
+		c.JSON(
+			http.StatusInternalServerError,
+			shared.GenericAPIResponse{
+				Data:  nil,
+				Error: err.Error(),
+				Code:  shared.ReturnCodeInternalError,
+			},
+		)
+		return
+	}
+
 	metrics[common.MetricTotalBaseStakedValue] = stakeValues.BaseStaked.String()
 	metrics[common.MetricTopUpValue] = stakeValues.TopUp.String()
 
@@ -317,7 +365,19 @@ func (ng *networkGroup) getESDTTokenSupply(c *gin.Context) {
 
 // getRatingsConfig returns metrics related to ratings configuration
 func (ng *networkGroup) getRatingsConfig(c *gin.Context) {
-	ratingsConfig := ng.getFacade().StatusMetrics().RatingsMetrics()
+	ratingsConfig, err := ng.getFacade().StatusMetrics().RatingsMetrics()
+	if err != nil {
+		c.JSON(
+			http.StatusInternalServerError,
+			shared.GenericAPIResponse{
+				Data:  nil,
+				Error: err.Error(),
+				Code:  shared.ReturnCodeInternalError,
+			},
+		)
+		return
+	}
+
 	c.JSON(
 		http.StatusOK,
 		shared.GenericAPIResponse{

api/groups/networkGroup_test.go

@@ -16,10 +16,12 @@ import (
 	apiErrors "github.com/ElrondNetwork/elrond-go/api/errors"
 	"github.com/ElrondNetwork/elrond-go/api/groups"
 	"github.com/ElrondNetwork/elrond-go/api/mock"
+	"github.com/ElrondNetwork/elrond-go/api/shared"
 	"github.com/ElrondNetwork/elrond-go/common"
 	"github.com/ElrondNetwork/elrond-go/config"
 	"github.com/ElrondNetwork/elrond-go/node/external"
 	"github.com/ElrondNetwork/elrond-go/statusHandler"
+	"github.com/ElrondNetwork/elrond-go/testscommon"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
@@ -60,6 +62,14 @@ type genesisNodesConfigData struct {
 	Nodes groups.GenesisNodesConfig `json:"nodes"`
 }
 
+type ratingsConfigResponse struct {
+	Data struct {
+		Config map[string]interface{} `json:"config"`
+	} `json:"data"`
+	Error string `json:"error"`
+	Code  string `json:"code"`
+}
+
 func TestNetworkConfigMetrics_ShouldWork(t *testing.T) {
 	t.Parallel()
 
@@ -90,6 +100,66 @@ func TestNetworkConfigMetrics_ShouldWork(t *testing.T) {
 	assert.True(t, keyAndValueFoundInResponse)
 }
 
+func TestGetNetworkConfig_ShouldReturnErrorIfFacadeReturnsError(t *testing.T) {
+	expectedErr := errors.New("i am an error")
+
+	facade := mock.FacadeStub{
+		StatusMetricsHandler: func() external.StatusMetricsHandler {
+			return &testscommon.StatusMetricsStub{
+				ConfigMetricsCalled: func() (map[string]interface{}, error) {
+					return nil, expectedErr
+				},
+			}
+		},
+	}
+
+	networkGroup, err := groups.NewNetworkGroup(&facade)
+	require.NoError(t, err)
+
+	ws := startWebServer(networkGroup, "network", getNetworkRoutesConfig())
+
+	req, _ := http.NewRequest("GET", "/network/config", nil)
+	resp := httptest.NewRecorder()
+	ws.ServeHTTP(resp, req)
+
+	assert.Equal(t, http.StatusInternalServerError, resp.Code)
+
+	response := &shared.GenericAPIResponse{}
+	loadResponse(resp.Body, response)
+
+	assert.Equal(t, expectedErr.Error(), response.Error)
+}
+
+func TestGetNetworkStatus_ShouldReturnErrorIfFacadeReturnsError(t *testing.T) {
+	expectedErr := errors.New("i am an error")
+
+	facade := mock.FacadeStub{
+		StatusMetricsHandler: func() external.StatusMetricsHandler {
+			return &testscommon.StatusMetricsStub{
+				NetworkMetricsCalled: func() (map[string]interface{}, error) {
+					return nil, expectedErr
+				},
+			}
+		},
+	}
+
+	networkGroup, err := groups.NewNetworkGroup(&facade)
+	require.NoError(t, err)
+
+	ws := startWebServer(networkGroup, "network", getNetworkRoutesConfig())
+
+	req, _ := http.NewRequest("GET", "/network/status", nil)
+	resp := httptest.NewRecorder()
+	ws.ServeHTTP(resp, req)
+
+	assert.Equal(t, http.StatusInternalServerError, resp.Code)
+
+	response := &shared.GenericAPIResponse{}
+	loadResponse(resp.Body, response)
+
+	assert.Equal(t, expectedErr.Error(), response.Error)
+}
+
 func TestNetworkStatusMetrics_ShouldWork(t *testing.T) {
 	t.Parallel()
 
@@ -155,6 +225,39 @@ func TestEconomicsMetrics_ShouldWork(t *testing.T) {
 	assert.True(t, keyAndValueFoundInResponse)
 }
 
+func TestGetEconomicValues_ShouldReturnErrorIfFacadeReturnsError(t *testing.T) {
+	expectedErr := errors.New("i am an error")
+
+	facade := mock.FacadeStub{
+		StatusMetricsHandler: func() external.StatusMetricsHandler {
+			return &testscommon.StatusMetricsStub{
+				EconomicsMetricsCalled: func() (map[string]interface{}, error) {
+					return nil, expectedErr
+				},
+			}
+		},
+		GetTotalStakedValueHandler: func() (*api.StakeValues, error) {
+			return nil, nil
+		},
+	}
+
+	networkGroup, err := groups.NewNetworkGroup(&facade)
+	require.NoError(t, err)
+
+	ws := startWebServer(networkGroup, "network", getNetworkRoutesConfig())
+
+	req, _ := http.NewRequest("GET", "/network/economics", nil)
+	resp := httptest.NewRecorder()
+	ws.ServeHTTP(resp, req)
+
+	assert.Equal(t, http.StatusInternalServerError, resp.Code)
+
+	response := &shared.GenericAPIResponse{}
+	loadResponse(resp.Body, response)
+
+	assert.Equal(t, expectedErr.Error(), response.Error)
+}
+
 func TestEconomicsMetrics_CannotGetStakeValues(t *testing.T) {
 	statusMetricsProvider := statusHandler.NewStatusMetrics()
 	key := common.MetricTotalSupply
@@ -387,6 +490,36 @@ func TestDelegatedInfo_CannotGetDelegatedList(t *testing.T) {
 	assert.True(t, strings.Contains(respStr, expectedError.Error()))
 }
 
+func TestGetEnableEpochs_ShouldReturnErrorIfFacadeReturnsError(t *testing.T) {
+	expectedErr := errors.New("i am an error")
+
+	facade := mock.FacadeStub{
+		StatusMetricsHandler: func() external.StatusMetricsHandler {
+			return &testscommon.StatusMetricsStub{
+				EnableEpochsMetricsCalled: func() (map[string]interface{}, error) {
+					return nil, expectedErr
+				},
+			}
+		},
+	}
+
+	networkGroup, err := groups.NewNetworkGroup(&facade)
+	require.NoError(t, err)
+
+	ws := startWebServer(networkGroup, "network", getNetworkRoutesConfig())
+
+	req, _ := http.NewRequest("GET", "/network/enable-epochs", nil)
+	resp := httptest.NewRecorder()
+	ws.ServeHTTP(resp, req)
+
+	assert.Equal(t, http.StatusInternalServerError, resp.Code)
+
+	response := &shared.GenericAPIResponse{}
+	loadResponse(resp.Body, response)
+
+	assert.Equal(t, expectedErr.Error(), response.Error)
+}
+
 func TestGetEnableEpochs_ShouldWork(t *testing.T) {
 	t.Parallel()
 
@@ -444,6 +577,68 @@ func TestGetESDTTotalSupply_InternalError(t *testing.T) {
 	require.True(t, keyAndValueInResponse)
 }
 
+func TestGetNetworkRatings_ShouldReturnErrorIfFacadeReturnsError(t *testing.T) {
+	expectedErr := errors.New("i am an error")
+
+	facade := mock.FacadeStub{
+		StatusMetricsHandler: func() external.StatusMetricsHandler {
+			return &testscommon.StatusMetricsStub{
+				RatingsMetricsCalled: func() (map[string]interface{}, error) {
+					return nil, expectedErr
+				},
+			}
+		},
+	}
+
+	networkGroup, err := groups.NewNetworkGroup(&facade)
+	require.NoError(t, err)
+
+	ws := startWebServer(networkGroup, "network", getNetworkRoutesConfig())
+
+	req, _ := http.NewRequest("GET", "/network/ratings", nil)
+	resp := httptest.NewRecorder()
+	ws.ServeHTTP(resp, req)
+
+	assert.Equal(t, http.StatusInternalServerError, resp.Code)
+
+	response := &shared.GenericAPIResponse{}
+	loadResponse(resp.Body, response)
+
+	assert.Equal(t, expectedErr.Error(), response.Error)
+}
+
+func TestGetNetworkRatings_ShouldWork(t *testing.T) {
+	expectedMap := map[string]interface{}{
+		"key0": "val0",
+	}
+
+	facade := mock.FacadeStub{
+		StatusMetricsHandler: func() external.StatusMetricsHandler {
+			return &testscommon.StatusMetricsStub{
+				RatingsMetricsCalled: func() (map[string]interface{}, error) {
+					return expectedMap, nil
+				},
+			}
+		},
+	}
+
+	networkGroup, err := groups.NewNetworkGroup(&facade)
+	require.NoError(t, err)
+
+	ws := startWebServer(networkGroup, "network", getNetworkRoutesConfig())
+
+	req, _ := http.NewRequest("GET", "/network/ratings", nil)
+	resp := httptest.NewRecorder()
+	ws.ServeHTTP(resp, req)
+
+	assert.Equal(t, http.StatusOK, resp.Code)
+
+	response := &ratingsConfigResponse{}
+	loadResponse(resp.Body, response)
+
+	assert.Equal(t, expectedMap, response.Data.Config)
+}
+
 func TestGetESDTTotalSupply(t *testing.T) {
 	t.Parallel()
 
@@ -567,6 +762,7 @@ func getNetworkRoutesConfig() config.ApiRoutesConfig {
 					{Name: "/delegated-info", Open: true},
 					{Name: "/esdt/supply/:token", Open: true},
 					{Name: "/genesis-nodes", Open: true},
+					{Name: "/ratings", Open: true},
 				},
 			},
 		},