test: adding test for claim logic

Author: kehiy

README.md

@@ -4,7 +4,7 @@
 
 # Pactus Bot Engine (RoboPac)
 
-Pactus Bor Engine is a Robot that provides support and information about the Pactus Blockchain.
+The Pactus Bot Engine is a Robot that provides support and information about the Pactus Blockchain.
 
 
 ## Contributing

client/client.go

@@ -149,6 +149,13 @@ func (c *Client) GetNodeInfo() (*pactus.GetNodeInfoResponse, error) {
 	return info, err
 }
 
+func (c *Client) GetTransactionData(txID string) (*pactus.GetTransactionResponse, error) {
+	return c.transactionClient.GetTransaction(context.Background(), &pactus.GetTransactionRequest{
+		Id:        []byte(txID),
+		Verbosity: pactus.TransactionVerbosity_TRANSACTION_DATA,
+	})
+}
+
 func (c *Client) Close() error {
 	return c.conn.Close()
 }

client/client_mgr.go

@@ -179,6 +179,18 @@ func (cm *Mgr) GetValidatorInfoByNumber(num int32) (*pactus.GetValidatorResponse
 	return nil, errors.New("unable to get validator info")
 }
 
+func (cm *Mgr) GetTransactionData(txID string) (*pactus.GetTransactionResponse, error) {
+	for _, c := range cm.clients {
+		txData, err := c.GetTransactionData(txID)
+		if err != nil {
+			continue
+		}
+		return txData, nil
+	}
+
+	return nil, errors.New("unable to get transaction data")
+}
+
 func (cm *Mgr) Close() {
 	for addr, c := range cm.clients {
 		if err := c.Close(); err != nil {

client/interface.go

@@ -12,5 +12,6 @@ type IClient interface {
 	IsValidator(string) (bool, error)
 	GetValidatorInfo(string) (*pactus.GetValidatorResponse, error)
 	GetValidatorInfoByNumber(int32) (*pactus.GetValidatorResponse, error)
+	GetTransactionData(string) (*pactus.GetTransactionResponse, error)
 	Close() error
 }

client/mock.go

@@ -12,6 +12,7 @@ import (
 	"github.com/kehiy/RoboPac/utils"
 	"github.com/kehiy/RoboPac/wallet"
 	"github.com/libp2p/go-libp2p/core/peer"
+	"github.com/pactus-project/pactus/util"
 )
 
 type BotEngine struct {
@@ -179,7 +180,12 @@ func (be *BotEngine) Claim(tokens []string) (*store.ClaimTransaction, error) {
 		return nil, errors.New("can't send bond transaction")
 	}
 
-	err = be.Store.AddClaimTransaction(txID, claimer.TotalReward, time.Now(), "", discordID)
+	txData, err := be.Cm.GetTransactionData(txID)
+	if err != nil {
+		return nil, err
+	}
+
+	err = be.Store.AddClaimTransaction(txID, util.ChangeToCoin(txData.Transaction.Value), int64(txData.BlockTime), discordID)
 	if err != nil {
 		return nil, err
 	}

engine/engine.go

@@ -1,21 +1,23 @@
 package engine_test
 
 import (
+	"fmt"
 	"testing"
 	"time"
 
 	"github.com/kehiy/RoboPac/client"
 	"github.com/kehiy/RoboPac/engine"
 	"github.com/kehiy/RoboPac/log"
-	"github.com/kehiy/RoboPac/store"
+	rpstore "github.com/kehiy/RoboPac/store"
 	"github.com/kehiy/RoboPac/wallet"
 	"github.com/libp2p/go-libp2p/core/peer"
+	"github.com/pactus-project/pactus/util"
 	pactus "github.com/pactus-project/pactus/www/grpc/gen/go"
 	"github.com/stretchr/testify/assert"
 	"go.uber.org/mock/gomock"
 )
 
-func setup(t *testing.T) (engine.Engine, client.MockIClient, error) {
+func setup(t *testing.T) (engine.Engine, client.MockIClient, rpstore.MockIStore, wallet.MockIWallet, error) {
 	t.Helper()
 	ctrl := gomock.NewController(t)
 
@@ -30,14 +32,14 @@ func setup(t *testing.T) (engine.Engine, client.MockIClient, error) {
 	wallet := wallet.NewMockIWallet(ctrl)
 
 	// mocking store.
-	store := store.NewMockIStore(ctrl)
+	store := rpstore.NewMockIStore(ctrl)
 
 	eng, err := engine.NewBotEngine(sl, cm, wallet, store)
-	return eng, *mockClient, err
+	return eng, *mockClient, *store, *wallet, err
 }
 
 func TestNetworkStatus(t *testing.T) {
-	eng, client, err := setup(t)
+	eng, client, _, _, err := setup(t)
 	assert.NoError(t, err)
 
 	client.EXPECT().GetNetworkInfo().Return(
@@ -62,7 +64,7 @@ func TestNetworkStatus(t *testing.T) {
 }
 
 func TestNetworkHealth(t *testing.T) {
-	eng, client, err := setup(t)
+	eng, client, _, _, err := setup(t)
 	assert.NoError(t, err)
 
 	t.Run("should be healthy", func(t *testing.T) {
@@ -93,7 +95,7 @@ func TestNetworkHealth(t *testing.T) {
 }
 
 func TestNodeInfo(t *testing.T) {
-	eng, client, err := setup(t)
+	eng, client, _, _, err := setup(t)
 	assert.NoError(t, err)
 
 	t.Run("should return error, invalid input", func(t *testing.T) {
@@ -146,3 +148,64 @@ func TestNodeInfo(t *testing.T) {
 		assert.Equal(t, float64(0.9), info.AvailabilityScore)
 	})
 }
+
+func TestClaim(t *testing.T) {
+	eng, client, store, wallet, err := setup(t)
+	assert.NoError(t, err)
+
+	t.Run("everything normal and good", func(t *testing.T) {
+		valAddress := "pc1p74scge5dyzjktv9q70xtr0pjmyqcqk7nuh8nzp"
+		discordID := "123456789"
+		txID := "0x123456789"
+		amount := 74.68
+		time := time.Now().Unix()
+
+		client.EXPECT().IsValidator(valAddress).Return(
+			true, nil,
+		)
+
+		store.EXPECT().ClaimerInfo(discordID).Return(
+			&rpstore.Claimer{
+				DiscordID:        discordID,
+				TotalReward:      amount,
+				ClaimTransaction: nil,
+			},
+		)
+
+		memo := fmt.Sprintf("RP to: %v", discordID)
+		wallet.EXPECT().BondTransaction("", valAddress, memo, amount).Return(
+			txID, nil,
+		)
+
+		client.EXPECT().GetTransactionData(txID).Return(
+			&pactus.GetTransactionResponse{
+				BlockTime: uint32(time),
+				Transaction: &pactus.TransactionInfo{
+					Id:    []byte(txID),
+					Value: util.CoinToChange(amount),
+					Memo:  memo,
+				},
+			}, nil,
+		)
+
+		store.EXPECT().AddClaimTransaction(txID, amount, time, discordID).Return(
+			nil,
+		)
+
+		store.EXPECT().ClaimerInfo(discordID).Return(
+			&rpstore.Claimer{
+				DiscordID:   discordID,
+				TotalReward: amount,
+				ClaimTransaction: &rpstore.ClaimTransaction{
+					TxID:   txID,
+					Amount: amount,
+					Time:   time,
+				},
+			},
+		).AnyTimes()
+
+		claimTx, err := eng.Claim([]string{valAddress, discordID})
+		assert.NoError(t, err)
+		assert.NotNil(t, claimTx)
+	})
+}

engine/engine_test.go

@@ -1,10 +1,7 @@
 package store
 
-import "time"
-
 type ClaimTransaction struct {
 	TxID   string  `json:"transaction_id"`
-	Data   string  `json:"data"`
 	Amount float64 `json:"amount"`
 	Time   int64   `json:"time"`
 }
@@ -21,5 +18,5 @@ func (c *Claimer) IsClaimed() bool {
 
 type IStore interface {
 	ClaimerInfo(discordID string) *Claimer
-	AddClaimTransaction(TxID string, Amount float64, Time time.Time, Data string, discordID string) error
+	AddClaimTransaction(TxID string, Amount float64, Time int64, discordID string) error
 }

store/interface.go

@@ -5,7 +5,6 @@ import (
 	"fmt"
 	"os"
 	"sync"
-	"time"
 
 	"github.com/kehiy/RoboPac/config"
 	"github.com/kehiy/RoboPac/log"
@@ -54,32 +53,31 @@ func (s *Store) ClaimerInfo(discordID string) *Claimer {
 	return claimerInfo
 }
 
-func (s *Store) AddClaimTransaction(txID string, amount float64, time time.Time, txData string, discordID string) error {
+func (s *Store) AddClaimTransaction(txID string, amount float64, time int64, discordID string) error {
 	s.syncMap.Store(discordID, &Claimer{
 		DiscordID: discordID,
 		ClaimTransaction: &ClaimTransaction{
 			TxID:   txID,
 			Amount: amount,
-			Time:   time.Unix(),
-			Data:   txData,
+			Time:   time,
 		},
 	})
 
 	s.logger.Info("new claim transaction added", "discordID", discordID, "amount",
-		amount, "data", txData, "time", time.Unix(), "txID", txID)
+		amount, "time", time, "txID", txID)
 
 	// save record.
 	data, err := marshalJSON(s.syncMap)
 	if err != nil {
 		s.logger.Panic("can't marshal json new claim transaction", "discordID", discordID, "amount",
-			amount, "data", txData, "time", time.Unix(), "txID", txID, "err", err)
+			amount, "time", time, "txID", txID, "err", err)
 
 		return fmt.Errorf("error marshalling validator data file: %w", err)
 	}
 
 	if err := os.WriteFile(s.cfg.StorePath, data, 0o600); err != nil {
 		s.logger.Panic("can't write new claim transaction", "discordID", discordID, "amount",
-			amount, "data", txData, "time", time.Unix(), "txID", txID, "err", err)
+			amount, "time", time, "txID", txID, "err", err)
 
 		return fmt.Errorf("failed to write to %s: %w", s.cfg.StorePath, err)
 	}

store/mock.go

@@ -43,19 +43,17 @@ func TestStore(t *testing.T) {
 	t.Run("test add claim transaction", func(t *testing.T) {
 		txID := "0x123456789"
 		time := time.Now()
-		data := "data"
 		discordID := "123456789"
 
 		claimer := store.ClaimerInfo(discordID)
 
 		isClaimed := claimer.IsClaimed()
 		assert.False(t, isClaimed)
 
-		err := store.AddClaimTransaction(txID, claimer.TotalReward, time, data, discordID)
+		err := store.AddClaimTransaction(txID, claimer.TotalReward, time.Unix(), discordID)
 		assert.NoError(t, err)
 
 		claimedInfo := store.ClaimerInfo(discordID)
-		assert.Equal(t, data, claimedInfo.ClaimTransaction.Data)
 		assert.Equal(t, discordID, claimedInfo.DiscordID)
 		assert.Equal(t, float64(100), claimedInfo.ClaimTransaction.Amount)
 		assert.Equal(t, txID, claimedInfo.ClaimTransaction.TxID)