Integration tests infrastructure refactoring. Separation of creation …

itests/alias_tx_api_internal_test.go

@@ -8,6 +8,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/suite"
+
 	f "github.com/wavesplatform/gowaves/itests/fixtures"
 	"github.com/wavesplatform/gowaves/itests/testdata"
 	utl "github.com/wavesplatform/gowaves/itests/utilities"

itests/clients/grpc_client.go

@@ -0,0 +1,142 @@
+package clients
+
+import (
+	"context"
+	"math"
+	"testing"
+	"time"
+
+	"github.com/pkg/errors"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials/insecure"
+	"google.golang.org/protobuf/types/known/emptypb"
+	"google.golang.org/protobuf/types/known/wrapperspb"
+
+	"github.com/wavesplatform/gowaves/itests/config"
+	"github.com/wavesplatform/gowaves/pkg/client"
+	"github.com/wavesplatform/gowaves/pkg/grpc/generated/waves"
+	g "github.com/wavesplatform/gowaves/pkg/grpc/generated/waves/node/grpc"
+	"github.com/wavesplatform/gowaves/pkg/proto"
+)
+
+const defaultTimeout = 30 * time.Second
+
+type balanceAtHeight struct {
+	impl    Implementation
+	balance int64
+	height  uint64
+}
+
+type GRPCClient struct {
+	impl    Implementation
+	conn    *grpc.ClientConn
+	timeout time.Duration
+}
+
+func NewGRPCClient(t *testing.T, impl Implementation, port string) *GRPCClient {
+	conn, err := grpc.NewClient(config.DefaultIP+":"+port, grpc.WithTransportCredentials(insecure.NewCredentials()))
+	assert.NoError(t, err, "failed to dial GRPC to %s", impl.String())
+	return &GRPCClient{impl: impl, conn: conn, timeout: defaultTimeout}
+}
+
+func (c *GRPCClient) GetFeatureActivationStatusInfo(t *testing.T, h int32) *g.ActivationStatusResponse {
+	ctx, cancel := context.WithTimeout(context.Background(), c.timeout)
+	defer cancel()
+	response, err := g.NewBlockchainApiClient(c.conn).GetActivationStatus(ctx, &g.ActivationStatusRequest{Height: h})
+	require.NoError(t, err, "[GRPC] failed to get feature activation status from %s node", c.impl.String())
+	return response
+}
+
+func (c *GRPCClient) GetHeight(t *testing.T) *client.BlocksHeight {
+	ctx, cancel := context.WithTimeout(context.Background(), c.timeout)
+	defer cancel()
+	h, err := g.NewBlocksApiClient(c.conn).GetCurrentHeight(ctx, &emptypb.Empty{}, grpc.EmptyCallOption{})
+	assert.NoError(t, err, "[GRPC] failed to get height from %s node", c.impl.String())
+	return &client.BlocksHeight{Height: uint64(h.Value)}
+}
+
+func (c *GRPCClient) GetBlock(t *testing.T, height uint64) *g.BlockWithHeight {
+	if height > math.MaxInt32 {
+		require.FailNow(t, "height is too large to be casted to int32")
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), c.timeout)
+	defer cancel()
+	block, err := g.NewBlocksApiClient(c.conn).GetBlock(ctx,
+		&g.BlockRequest{Request: &g.BlockRequest_Height{Height: int32(height)}, IncludeTransactions: true})
+	assert.NoError(t, err, "[GRPC] failed to get block from %s node", c.impl.String())
+	return block
+}
+
+func (c *GRPCClient) GetWavesBalance(t *testing.T, address proto.WavesAddress) *g.BalanceResponse_WavesBalances {
+	return c.getBalance(t, &g.BalancesRequest{Address: address.Bytes(), Assets: [][]byte{nil}}).GetWaves()
+}
+
+func (c *GRPCClient) GetAssetBalance(t *testing.T, address proto.WavesAddress, id []byte) *waves.Amount {
+	require.NotEmpty(t, id, "asset bytes must not be empty than calling %s node", c.impl.String())
+	return c.getBalance(t, &g.BalancesRequest{Address: address.Bytes(), Assets: [][]byte{id}}).GetAsset()
+}
+
+func (c *GRPCClient) GetAddressByAlias(t *testing.T, alias string) []byte {
+	ctx, cancel := context.WithTimeout(context.Background(), c.timeout)
+	defer cancel()
+	addr, err := g.NewAccountsApiClient(c.conn).ResolveAlias(ctx, &wrapperspb.StringValue{Value: alias})
+	assert.NoError(t, err, "failed to get address by alias from %s node", c.impl.String())
+	return addr.GetValue()
+}
+
+func (c *GRPCClient) GetAssetsInfo(t *testing.T, id []byte) *g.AssetInfoResponse {
+	ctx, cancel := context.WithTimeout(context.Background(), c.timeout)
+	defer cancel()
+	assetInfo, err := g.NewAssetsApiClient(c.conn).GetInfo(ctx, &g.AssetRequest{AssetId: id})
+	assert.NoError(t, err, "failed to get asset info from %s node", c.impl.String())
+	return assetInfo
+}
+
+func (c *GRPCClient) getBalance(t *testing.T, req *g.BalancesRequest) *g.BalanceResponse {
+	ctx, cancel := context.WithTimeout(context.Background(), c.timeout)
+	defer cancel()
+	stream, err := g.NewAccountsApiClient(c.conn).GetBalances(ctx, req, grpc.EmptyCallOption{})
+	assert.NoError(t, err, "[GRPC] failed to get stream from %s node", c.impl.String())
+	b, err := stream.Recv()
+	assert.NoError(t, err, "[GRPC] failed to get balance from %s node", c.impl.String())
+	return b
+}
+
+func (c *GRPCClient) syncedWavesAvailableBalance(
+	ctx context.Context, address proto.WavesAddress,
+) (balanceAtHeight, error) {
+	beforeRsp, err := g.NewBlocksApiClient(c.conn).GetCurrentHeight(ctx, &emptypb.Empty{}, grpc.EmptyCallOption{})
+	if err != nil {
+		return balanceAtHeight{}, errors.Wrapf(err,
+			"syncedWavesAvailableBalance: failed to get initial height from %s node", c.impl.String())
+	}
+	before := uint64(beforeRsp.Value)
+
+	req := &g.BalancesRequest{Address: address.Bytes(), Assets: [][]byte{nil}}
+	stream, err := g.NewAccountsApiClient(c.conn).GetBalances(ctx, req, grpc.EmptyCallOption{})
+	if err != nil {
+		return balanceAtHeight{}, errors.Wrapf(err,
+			"syncedWavesAvailableBalance: failed to get balance stream from %s node", c.impl.String())
+	}
+	balanceRsp, err := stream.Recv()
+	if err != nil {
+		return balanceAtHeight{}, errors.Wrapf(err,
+			"syncedWavesAvailableBalance: failed to get balance from %s node", c.impl.String())
+	}
+	available := balanceRsp.GetWaves().Available
+
+	afterRsp, err := g.NewBlocksApiClient(c.conn).GetCurrentHeight(ctx, &emptypb.Empty{}, grpc.EmptyCallOption{})
+	if err != nil {
+		return balanceAtHeight{}, errors.Wrapf(err,
+			"syncedWavesAvailableBalance: failed to get height from %s node", c.impl.String())
+	}
+	after := uint64(afterRsp.Value)
+
+	if before != after {
+		return balanceAtHeight{}, errors.Errorf(
+			"syncedWavesAvailableBalance: height changed during balance check on %s node", c.impl.String())
+	}
+	return balanceAtHeight{impl: c.impl, balance: available, height: after}, nil
+}

itests/node_client/http_client.go → itests/clients/http_client.go

@@ -1,4 +1,4 @@
-package node_client
+package clients
 
 import (
 	"context"
@@ -8,137 +8,142 @@ import (
 
 	"github.com/stretchr/testify/require"
 
+	"github.com/wavesplatform/gowaves/itests/config"
 	d "github.com/wavesplatform/gowaves/itests/docker"
 	"github.com/wavesplatform/gowaves/pkg/client"
 	"github.com/wavesplatform/gowaves/pkg/crypto"
 	"github.com/wavesplatform/gowaves/pkg/proto"
 )
 
-type HttpClient struct {
+type HTTPClient struct {
+	impl    Implementation
 	cli     *client.Client
 	timeout time.Duration
 }
 
-func NewHttpClient(t *testing.T, port string) *HttpClient {
+func NewHTTPClient(t *testing.T, impl Implementation, port string) *HTTPClient {
 	c, err := client.NewClient(client.Options{
-		BaseUrl: "http://" + d.Localhost + ":" + port + "/",
+		BaseUrl: "http://" + config.DefaultIP + ":" + port + "/",
 		Client:  &http.Client{Timeout: d.DefaultTimeout},
-		ApiKey:  "itest-api-key",
+		ApiKey:  d.DefaultAPIKey,
 		ChainID: 'L', // I tried to use constant `utilities.TestChainID`, but after all decided that a little duplication is better in this case.
 	})
-	require.NoError(t, err, "couldn't create go node api client")
-	return &HttpClient{
-		cli: c,
+	require.NoError(t, err, "couldn't create %s node HTTP API client", impl.String())
+	return &HTTPClient{
+		impl: impl,
+		cli:  c,
 		// actually, there's no need to use such timeout because above we've already set default context for http client
 		timeout: 15 * time.Second,
 	}
 }
 
-func (c *HttpClient) GetHeight(t *testing.T) *client.BlocksHeight {
+func (c *HTTPClient) GetHeight(t *testing.T) *client.BlocksHeight {
 	ctx, cancel := context.WithTimeout(context.Background(), c.timeout)
 	defer cancel()
 	h, _, err := c.cli.Blocks.Height(ctx)
-	require.NoError(t, err, "failed to get height from node")
+	require.NoError(t, err, "failed to get height from %s node", c.impl.String())
 	return h
 }
 
-func (c *HttpClient) StateHash(t *testing.T, height uint64) *proto.StateHash {
+func (c *HTTPClient) StateHash(t *testing.T, height uint64) *proto.StateHash {
 	ctx, cancel := context.WithTimeout(context.Background(), c.timeout)
 	defer cancel()
 	stateHash, _, err := c.cli.Debug.StateHash(ctx, height)
-	require.NoError(t, err, "failed to get stateHash from node")
+	require.NoError(t, err, "failed to get stateHash from %s node", c.impl.String())
 	return stateHash
 }
 
-func (c *HttpClient) PrintMsg(t *testing.T, msg string) {
+func (c *HTTPClient) PrintMsg(t *testing.T, msg string) {
 	ctx, cancel := context.WithTimeout(context.Background(), c.timeout)
 	defer cancel()
 	_, err := c.cli.Debug.PrintMsg(ctx, msg)
-	require.NoError(t, err, "failed to send Msg to node")
+	require.NoError(t, err, "failed to send Msg to %s node", c.impl.String())
 }
 
-func (c *HttpClient) GetAssetDetails(assetID crypto.Digest) (*client.AssetsDetail, error) {
+func (c *HTTPClient) GetAssetDetails(assetID crypto.Digest) (*client.AssetsDetail, error) {
 	ctx, cancel := context.WithTimeout(context.Background(), c.timeout)
 	defer cancel()
 	details, _, err := c.cli.Assets.Details(ctx, assetID)
 	return details, err
 }
 
-func (c *HttpClient) TransactionInfo(t *testing.T, ID crypto.Digest) proto.Transaction {
+func (c *HTTPClient) TransactionInfo(t *testing.T, id crypto.Digest) proto.Transaction {
 	ctx, cancel := context.WithTimeout(context.Background(), c.timeout)
 	defer cancel()
-	info, _, err := c.cli.Transactions.Info(ctx, ID)
-	require.NoError(t, err, "failed to get TransactionInfo from node")
+	info, _, err := c.cli.Transactions.Info(ctx, id)
+	require.NoError(t, err, "failed to get TransactionInfo from %s node", c.impl.String())
 	return info
 }
 
-func (c *HttpClient) TransactionInfoRaw(id crypto.Digest) (proto.Transaction, *client.Response, error) {
+func (c *HTTPClient) TransactionInfoRaw(id crypto.Digest) (proto.Transaction, *client.Response, error) {
 	ctx, cancel := context.WithTimeout(context.Background(), c.timeout)
 	defer cancel()
 	return c.cli.Transactions.Info(ctx, id)
 }
 
-func (c *HttpClient) TransactionBroadcast(transaction proto.Transaction) (*client.Response, error) {
+func (c *HTTPClient) TransactionBroadcast(transaction proto.Transaction) (*client.Response, error) {
 	ctx, cancel := context.WithTimeout(context.Background(), c.timeout)
 	defer cancel()
 	return c.cli.Transactions.Broadcast(ctx, transaction)
 }
 
-func (c *HttpClient) WavesBalance(t *testing.T, address proto.WavesAddress) *client.AddressesBalance {
+func (c *HTTPClient) WavesBalance(t *testing.T, address proto.WavesAddress) *client.AddressesBalance {
 	ctx, cancel := context.WithTimeout(context.Background(), c.timeout)
 	defer cancel()
 	balance, _, err := c.cli.Addresses.Balance(ctx, address)
-	require.NoError(t, err)
+	require.NoError(t, err, "failed to get waves balance from %s node", c.impl.String())
 	return balance
 }
 
-func (c *HttpClient) AssetBalance(t *testing.T, address proto.WavesAddress, assetId crypto.Digest) *client.AssetsBalanceAndAsset {
+func (c *HTTPClient) AssetBalance(
+	t *testing.T, address proto.WavesAddress, assetID crypto.Digest,
+) *client.AssetsBalanceAndAsset {
 	ctx, cancel := context.WithTimeout(context.Background(), c.timeout)
 	defer cancel()
-	balance, _, err := c.cli.Assets.BalanceByAddressAndAsset(ctx, address, assetId)
-	require.NoError(t, err)
+	balance, _, err := c.cli.Assets.BalanceByAddressAndAsset(ctx, address, assetID)
+	require.NoError(t, err, "failed to get asset balance from %s node", c.impl.String())
 	return balance
 }
 
-func (c *HttpClient) ConnectedPeers() ([]*client.PeersConnectedRow, *client.Response, error) {
+func (c *HTTPClient) ConnectedPeers() ([]*client.PeersConnectedRow, *client.Response, error) {
 	ctx, cancel := context.WithTimeout(context.Background(), c.timeout)
 	defer cancel()
 	connectedPeers, resp, err := c.cli.Peers.Connected(ctx)
 	return connectedPeers, resp, err
 }
 
-func (c *HttpClient) BlockHeader(t *testing.T, height proto.Height) *client.Headers {
+func (c *HTTPClient) BlockHeader(t *testing.T, height proto.Height) *client.Headers {
 	ctx, cancel := context.WithTimeout(context.Background(), c.timeout)
 	defer cancel()
 
 	header, _, err := c.cli.Blocks.HeadersAt(ctx, height)
-	require.NoError(t, err)
+	require.NoError(t, err, "failed to get block header from %s node", c.impl.String())
 	return header
 }
 
-func (c *HttpClient) Rewards(t *testing.T) *client.RewardInfo {
+func (c *HTTPClient) Rewards(t *testing.T) *client.RewardInfo {
 	ctx, cancel := context.WithTimeout(context.Background(), c.timeout)
 	defer cancel()
 
 	rewardInfo, _, err := c.cli.Blockchain.Rewards(ctx)
-	require.NoError(t, err)
+	require.NoError(t, err, "failed to get rewards from %s node", c.impl.String())
 	return rewardInfo
 }
 
-func (c *HttpClient) RewardsAtHeight(t *testing.T, height proto.Height) *client.RewardInfo {
+func (c *HTTPClient) RewardsAtHeight(t *testing.T, height proto.Height) *client.RewardInfo {
 	ctx, cancel := context.WithTimeout(context.Background(), c.timeout)
 	defer cancel()
 
 	rewardInfo, _, err := c.cli.Blockchain.RewardsAtHeight(ctx, height)
-	require.NoError(t, err)
+	require.NoError(t, err, "failed to get rewards from %s node", c.impl.String())
 	return rewardInfo
 }
 
-func (c *HttpClient) RollbackToHeight(t *testing.T, height uint64, returnTxToUtx bool) *proto.BlockID {
+func (c *HTTPClient) RollbackToHeight(t *testing.T, height uint64, returnTxToUtx bool) *proto.BlockID {
 	ctx, cancel := context.WithTimeout(context.Background(), c.timeout)
 	defer cancel()
 
 	blockID, _, err := c.cli.Debug.RollbackToHeight(ctx, height, returnTxToUtx)
-	require.NoError(t, err)
+	require.NoError(t, err, "failed to rollback to height on %s node", c.impl.String())
 	return blockID
 }

itests/clients/implementation.go

@@ -0,0 +1,9 @@
+package clients
+
+//go:generate stringer -type Implementation -trimprefix Node
+type Implementation byte
+
+const (
+	NodeGo Implementation = iota
+	NodeScala
+)