feat: fixed comments

Author: gsoares85

.mockery.yaml

@@ -35,6 +35,9 @@ packages:
   github.com/rsksmart/liquidity-provider-server/internal/usecases/liquidity_provider:
     interfaces:
       DefaultCredentialsProvider:
+  github.com/rsksmart/liquidity-provider-server/internal/usecases/reports:
+    interfaces:
+      AssetsReportUseCase:
   github.com/rsksmart/liquidity-provider-server/internal/entities/liquidity_provider:
     interfaces:
       LiquidityProviderRepository:

OpenApi.yml

@@ -521,6 +521,7 @@ components:
       properties:
         fee:
           type: integer
+          deprecated: true
         feePercentage:
           type: number
         fixedFee:

internal/adapters/entrypoints/rest/handlers/get_reports_assets.go

@@ -3,23 +3,32 @@ package handlers
 import (
 	"github.com/rsksmart/liquidity-provider-server/internal/adapters/entrypoints/rest"
 	"github.com/rsksmart/liquidity-provider-server/internal/usecases/reports"
+	"github.com/rsksmart/liquidity-provider-server/pkg"
 	"net/http"
 )
 
 // NewGetReportsAssetsHandler
 // @Title Get asset Reports
 // @Description Get the asset information for the LPS.
-// @Success 200 pkg.GetAssetsReportResponse
+// @Success 200 pkg.GetAssetsReportDTO
 // @Route /reports/assets [get]
-func NewGetReportsAssetsHandler(useCase *reports.GetAssetsReportUseCase) http.HandlerFunc {
+func NewGetReportsAssetsHandler(useCase reports.AssetsReportUseCase) http.HandlerFunc {
 	return func(w http.ResponseWriter, req *http.Request) {
 		response, err := useCase.Run(req.Context())
 		if err != nil {
 			jsonErr := rest.NewErrorResponseWithDetails("Request error", rest.DetailsFromError(err), false)
 			rest.JsonErrorResponse(w, http.StatusBadRequest, jsonErr)
 			return
 		}
+		responseDto := pkg.GetAssetsReportDTO{
+			RbtcLocked:    response.RbtcLocked,
+			RbtcBalance:   response.RbtcBalance,
+			RbtcLiquidity: response.RbtcLiquidity,
+			BtcLocked:     response.BtcLocked,
+			BtcBalance:    response.BtcBalance,
+			BtcLiquidity:  response.BtcLiquidity,
+		}
 
-		rest.JsonResponseWithBody(w, http.StatusOK, &response)
+		rest.JsonResponseWithBody(w, http.StatusOK, &responseDto)
 	}
 }

internal/adapters/entrypoints/rest/handlers/get_reports_assets_test.go

@@ -0,0 +1,61 @@
+package handlers
+
+import (
+	"context"
+	"fmt"
+	"github.com/rsksmart/liquidity-provider-server/internal/usecases/reports"
+	"github.com/rsksmart/liquidity-provider-server/test/mocks"
+	"github.com/stretchr/testify/assert"
+	"math/big"
+	"testing"
+)
+
+func TestNewGetReportsAssetsHandler(t *testing.T) {
+	const (
+		path = "/reports/assets"
+		verb = "GET"
+	)
+
+	successReturn := reports.GetAssetsReportResponse{
+		BtcBalance:    big.NewInt(100000),
+		RbtcBalance:   big.NewInt(100000),
+		BtcLocked:     big.NewInt(15000),
+		RbtcLocked:    big.NewInt(17500),
+		BtcLiquidity:  big.NewInt(85000),
+		RbtcLiquidity: big.NewInt(67500),
+	}
+
+	failReturn := reports.GetAssetsReportResponse{
+		BtcBalance:    big.NewInt(0),
+		RbtcBalance:   big.NewInt(0),
+		BtcLocked:     big.NewInt(0),
+		RbtcLocked:    big.NewInt(0),
+		BtcLiquidity:  big.NewInt(0),
+		RbtcLiquidity: big.NewInt(0),
+	}
+
+	t.Run("should return 200 on success", func(t *testing.T) {
+		ctx := context.Background()
+		useCase := mocks.NewAssetsReportUseCaseMock(t)
+
+		useCase.On("Run", ctx).Return(successReturn, nil)
+
+		handler := NewGetReportsAssetsHandler(useCase)
+		assert.HTTPSuccess(t, handler, verb, path, nil)
+		assert.HTTPBodyContains(t, handler, verb, path, nil, fmt.Sprintf(`"btcBalance":%d`, successReturn.BtcBalance))
+		assert.HTTPBodyContains(t, handler, verb, path, nil, fmt.Sprintf(`"rbtcBalance":%d`, successReturn.RbtcBalance))
+		assert.HTTPBodyContains(t, handler, verb, path, nil, fmt.Sprintf(`"btcLocked":%d`, successReturn.BtcLocked))
+		assert.HTTPBodyContains(t, handler, verb, path, nil, fmt.Sprintf(`"rbtcLocked":%d`, successReturn.RbtcLocked))
+		assert.HTTPBodyContains(t, handler, verb, path, nil, fmt.Sprintf(`"btcLiquidity":%d`, successReturn.BtcLiquidity))
+		assert.HTTPBodyContains(t, handler, verb, path, nil, fmt.Sprintf(`"rbtcLiquidity":%d`, successReturn.RbtcLiquidity))
+	})
+	t.Run("Should return an error when use case fail", func(t *testing.T) {
+		ctx := context.Background()
+		useCase := mocks.NewAssetsReportUseCaseMock(t)
+
+		useCase.On("Run", ctx).Return(failReturn, assert.AnError)
+		handler := NewGetReportsAssetsHandler(useCase)
+		assert.HTTPError(t, handler, verb, path, nil)
+		assert.HTTPBodyContains(t, handler, verb, path, nil, `{"error":"assert.AnError general error for testing"}`)
+	})
+}

internal/adapters/entrypoints/rest/registry/registry.go

@@ -39,5 +39,5 @@ type UseCaseRegistry interface {
 	GetPeginReportUseCase() *reports.GetPeginReportUseCase
 	GetPegoutReportUseCase() *reports.GetPegoutReportUseCase
 	GetRevenueReportUseCase() *reports.GetRevenueReportUseCase
-	GetAssetsReportUseCase() *reports.GetAssetsReportUseCase
+	GetAssetsReportUseCase() reports.AssetsReportUseCase
 }

internal/configuration/registry/usecase.go

@@ -62,7 +62,7 @@ type UseCaseRegistry struct {
 	getPeginReportUseCase         *reports.GetPeginReportUseCase
 	getPegoutReportUseCase        *reports.GetPegoutReportUseCase
 	getRevenueReportUseCase       *reports.GetRevenueReportUseCase
-	getAssetsReportUseCase        *reports.GetAssetsReportUseCase
+	getAssetsReportUseCase        reports.AssetsReportUseCase
 }
 
 // NewUseCaseRegistry
@@ -382,6 +382,6 @@ func (registry *UseCaseRegistry) GetRevenueReportUseCase() *reports.GetRevenueRe
 	return registry.getRevenueReportUseCase
 }
 
-func (registry *UseCaseRegistry) GetAssetsReportUseCase() *reports.GetAssetsReportUseCase {
+func (registry *UseCaseRegistry) GetAssetsReportUseCase() reports.AssetsReportUseCase {
 	return registry.getAssetsReportUseCase
 }

internal/usecases/reports/get_assets_report.go

@@ -6,9 +6,28 @@ import (
 	"github.com/rsksmart/liquidity-provider-server/internal/entities/blockchain"
 	"github.com/rsksmart/liquidity-provider-server/internal/entities/liquidity_provider"
 	"github.com/rsksmart/liquidity-provider-server/internal/entities/quote"
-	"github.com/rsksmart/liquidity-provider-server/pkg"
+	"math/big"
 )
 
+type AssetsReportUseCase interface {
+	Run(ctx context.Context) (GetAssetsReportResponse, error)
+	GetRBTCLiquidity(ctx context.Context) (*entities.Wei, error)
+	GetBTCLiquidity(ctx context.Context) (*entities.Wei, error)
+	GetBTCLocked(ctx context.Context) (*entities.Wei, error)
+	GetRBTCLocked(ctx context.Context) (*entities.Wei, error)
+	GetRBTCBalance(ctx context.Context) (*entities.Wei, error)
+	GetBtcBalance() (*entities.Wei, error)
+}
+
+type GetAssetsReportResponse struct {
+	BtcBalance    *big.Int `json:"btcBalance" validate:"required"`
+	RbtcBalance   *big.Int `json:"rbtcBalance" validate:"required"`
+	BtcLocked     *big.Int `json:"btcLocked" validate:"required"`
+	RbtcLocked    *big.Int `json:"rbtcLocked" validate:"required"`
+	BtcLiquidity  *big.Int `json:"btcLiquidity" validate:"required"`
+	RbtcLiquidity *big.Int `json:"rbtcLiquidity" validate:"required"`
+}
+
 type GetAssetsReportUseCase struct {
 	btcWallet        blockchain.BitcoinWallet
 	rsk              blockchain.Rpc
@@ -27,7 +46,7 @@ func NewGetAssetsReportUseCase(
 	pegoutProvider liquidity_provider.PegoutLiquidityProvider,
 	peginRepository quote.PeginQuoteRepository,
 	pegoutRepository quote.PegoutQuoteRepository,
-) *GetAssetsReportUseCase {
+) AssetsReportUseCase {
 	return &GetAssetsReportUseCase{
 		btcWallet:        wallet,
 		rsk:              rsk,
@@ -39,8 +58,8 @@ func NewGetAssetsReportUseCase(
 	}
 }
 
-func (useCase *GetAssetsReportUseCase) Run(ctx context.Context) (pkg.GetAssetsReportResponse, error) {
-	response := pkg.GetAssetsReportResponse{
+func (useCase *GetAssetsReportUseCase) Run(ctx context.Context) (GetAssetsReportResponse, error) {
+	response := GetAssetsReportResponse{
 		BtcBalance:    entities.NewWei(0).AsBigInt(),
 		RbtcBalance:   entities.NewWei(0).AsBigInt(),
 		BtcLocked:     entities.NewWei(0).AsBigInt(),
@@ -52,36 +71,39 @@ func (useCase *GetAssetsReportUseCase) Run(ctx context.Context) (pkg.GetAssetsRe
 	if err != nil {
 		return response, err
 	}
-	response.BtcBalance = btcBalance.AsBigInt()
+
 	rbtcBalance, err := useCase.GetRBTCBalance(ctx)
 	if err != nil {
 		return response, err
 	}
-	response.RbtcBalance = rbtcBalance.AsBigInt()
 
 	rbtcLocked, err := useCase.GetRBTCLocked(ctx)
 	if err != nil {
 		return response, err
 	}
-	response.RbtcLocked = rbtcLocked.AsBigInt()
 
 	lockedBtc, err := useCase.GetBTCLocked(ctx)
 	if err != nil {
 		return response, err
 	}
-	response.BtcLocked = lockedBtc.AsBigInt()
 
 	btcLiquidity, err := useCase.GetBTCLiquidity(ctx)
 	if err != nil {
 		return response, err
 	}
-	response.BtcLiquidity = btcLiquidity.AsBigInt()
 
 	rbtcLiquidity, err := useCase.GetRBTCLiquidity(ctx)
 	if err != nil {
 		return response, err
 	}
+
+	response.BtcBalance = btcBalance.AsBigInt()
 	response.RbtcLiquidity = rbtcLiquidity.AsBigInt()
+	response.BtcLiquidity = btcLiquidity.AsBigInt()
+	response.BtcLocked = lockedBtc.AsBigInt()
+	response.RbtcLocked = rbtcLocked.AsBigInt()
+	response.RbtcBalance = rbtcBalance.AsBigInt()
+
 	return response, nil
 }
 
@@ -118,20 +140,13 @@ func (useCase *GetAssetsReportUseCase) GetBTCLocked(ctx context.Context) (*entit
 
 func (useCase *GetAssetsReportUseCase) GetRBTCLocked(ctx context.Context) (*entities.Wei, error) {
 	lockedPegin := entities.NewWei(0)
-	peginQuotes, err := useCase.peginRepository.GetRetainedQuoteByState(ctx, quote.PeginStateWaitingForDeposit)
+	peginQuotes, err := useCase.peginRepository.GetRetainedQuoteByState(ctx, quote.PeginStateWaitingForDeposit, quote.PeginStateWaitingForDepositConfirmations)
 	if err != nil {
 		return nil, err
 	}
 	for _, retainedQuote := range peginQuotes {
 		lockedPegin.Add(lockedPegin, retainedQuote.RequiredLiquidity)
 	}
-	pegoutQuotes, err := useCase.pegoutRepository.GetRetainedQuoteByState(ctx, quote.PegoutStateRefundPegOutSucceeded)
-	if err != nil {
-		return nil, err
-	}
-	for _, retainedQuote := range pegoutQuotes {
-		lockedPegin.Add(lockedPegin, retainedQuote.RequiredLiquidity)
-	}
 
 	return lockedPegin, nil
 }