Test coverage api package [accounts, blocks, events, node, transactions, transfers]

api/accounts/accounts.go

@@ -349,10 +349,10 @@ func (a *Accounts) handleRevision(revision string) (*chain.BlockSummary, error)
 func (a *Accounts) Mount(root *mux.Router, pathPrefix string) {
 	sub := root.PathPrefix(pathPrefix).Subrouter()
 
-	sub.Path("/*").Methods("POST").HandlerFunc(utils.WrapHandlerFunc(a.handleCallBatchCode))
+	sub.Path("/*").Methods(http.MethodPost).HandlerFunc(utils.WrapHandlerFunc(a.handleCallBatchCode))
 	sub.Path("/{address}").Methods(http.MethodGet).HandlerFunc(utils.WrapHandlerFunc(a.handleGetAccount))
 	sub.Path("/{address}/code").Methods(http.MethodGet).HandlerFunc(utils.WrapHandlerFunc(a.handleGetCode))
-	sub.Path("/{address}/storage/{key}").Methods("GET").HandlerFunc(utils.WrapHandlerFunc(a.handleGetStorage))
-	sub.Path("").Methods("POST").HandlerFunc(utils.WrapHandlerFunc(a.handleCallContract))
-	sub.Path("/{address}").Methods("POST").HandlerFunc(utils.WrapHandlerFunc(a.handleCallContract))
+	sub.Path("/{address}/storage/{key}").Methods(http.MethodGet).HandlerFunc(utils.WrapHandlerFunc(a.handleGetStorage))
+	sub.Path("").Methods(http.MethodPost).HandlerFunc(utils.WrapHandlerFunc(a.handleCallContract))
+	sub.Path("/{address}").Methods(http.MethodPost).HandlerFunc(utils.WrapHandlerFunc(a.handleCallContract))
 }

api/accounts/accounts_test.go

@@ -3,11 +3,12 @@
 // Distributed under the GNU Lesser General Public License v3.0 software license, see the accompanying
 // file LICENSE or <https://www.gnu.org/licenses/lgpl-3.0.html>
 
-package accounts_test
+package accounts
 
 import (
 	"bytes"
 	"encoding/json"
+	"fmt"
 	"io"
 	"math/big"
 	"net/http"
@@ -22,7 +23,7 @@ import (
 	"github.com/gorilla/mux"
 	"github.com/stretchr/testify/assert"
 	ABI "github.com/vechain/thor/v2/abi"
-	"github.com/vechain/thor/v2/api/accounts"
+	"github.com/vechain/thor/v2/block"
 	"github.com/vechain/thor/v2/chain"
 	"github.com/vechain/thor/v2/genesis"
 	"github.com/vechain/thor/v2/muxdb"
@@ -86,6 +87,8 @@ var addr = thor.BytesToAddress([]byte("to"))
 var value = big.NewInt(10000)
 var storageKey = thor.Bytes32{}
 var storageValue = byte(1)
+var gasLimit uint64
+var genesisBlock *block.Block
 
 var contractAddr thor.Address
 
@@ -97,13 +100,18 @@ var invalidAddr = "abc"
 var invalidBytes32 = "0x000000000000000000000000000000000000000000000000000000000000000g" //invlaid bytes32
 var invalidNumberRevision = "4294967296"                                                  //invalid block number
 
+var accounts *Accounts
 var ts *httptest.Server
 
 func TestAccount(t *testing.T) {
 	initAccountServer(t)
 	defer ts.Close()
 	getAccount(t)
+	getAccountWithNonExisitingRevision(t)
+	getAccountWithGenesisRevision(t)
+	getInvalidCode(t)
 	getCode(t)
+	getStorageWhenError(t)
 	getStorage(t)
 	deployContractWithCall(t)
 	callContract(t)
@@ -119,14 +127,42 @@ func getAccount(t *testing.T) {
 
 	//revision is optional defaut `best`
 	res, statusCode := httpGet(t, ts.URL+"/accounts/"+addr.String())
-	var acc accounts.Account
+	var acc Account
 	if err := json.Unmarshal(res, &acc); err != nil {
 		t.Fatal(err)
 	}
 	assert.Equal(t, math.HexOrDecimal256(*value), acc.Balance, "balance should be equal")
 	assert.Equal(t, http.StatusOK, statusCode, "OK")
 }
 
+func getAccountWithNonExisitingRevision(t *testing.T) {
+	revision64Len := "0123456789012345678901234567890123456789012345678901234567890123"
+
+	_, statusCode := httpGet(t, ts.URL+"/accounts/"+addr.String()+"?revision="+revision64Len)
+
+	assert.Equal(t, http.StatusBadRequest, statusCode, "bad revision")
+}
+
+func getAccountWithGenesisRevision(t *testing.T) {
+	res, statusCode := httpGet(t, ts.URL+"/accounts/"+addr.String()+"?revision="+genesisBlock.Header().ID().String())
+	assert.Equal(t, http.StatusOK, statusCode, "bad revision")
+
+	var acc Account
+	if err := json.Unmarshal(res, &acc); err != nil {
+		t.Fatal(err)
+	}
+
+	balance, err := acc.Balance.MarshalText()
+	assert.NoError(t, err)
+	assert.Equal(t, "0x0", string(balance), "balance should be 0")
+
+	energy, err := acc.Energy.MarshalText()
+	assert.NoError(t, err)
+	assert.Equal(t, "0x0", string(energy), "energy should be 0")
+
+	assert.Equal(t, false, acc.HasCode, "hasCode should be false")
+}
+
 func getCode(t *testing.T) {
 	_, statusCode := httpGet(t, ts.URL+"/accounts/"+invalidAddr+"/code")
 	assert.Equal(t, http.StatusBadRequest, statusCode, "bad address")
@@ -148,6 +184,36 @@ func getCode(t *testing.T) {
 	assert.Equal(t, http.StatusOK, statusCode, "OK")
 }
 
+func getInvalidCode(t *testing.T) {
+	blockSummary := &chain.BlockSummary{
+		Header:    genesisBlock.Header(),
+		Txs:       []thor.Bytes32{thor.BytesToBytes32([]byte("123"))},
+		Size:      1,
+		Conflicts: 1,
+		SteadyNum: 1,
+	}
+
+	code, err := accounts.getCode(addr, blockSummary)
+
+	assert.Error(t, err)
+	assert.Empty(t, code)
+}
+
+func getStorageWhenError(t *testing.T) {
+	blockSummary := &chain.BlockSummary{
+		Header:    genesisBlock.Header(),
+		Txs:       []thor.Bytes32{thor.BytesToBytes32([]byte("123"))},
+		Size:      1,
+		Conflicts: 1,
+		SteadyNum: 1,
+	}
+
+	storage, err := accounts.getStorage(addr, storageKey, blockSummary)
+
+	assert.Error(t, err)
+	assert.Equal(t, thor.Bytes32{}, storage)
+}
+
 func getStorage(t *testing.T) {
 	_, statusCode := httpGet(t, ts.URL+"/accounts/"+invalidAddr+"/storage/"+storageKey.String())
 	assert.Equal(t, http.StatusBadRequest, statusCode, "bad address")
@@ -181,6 +247,7 @@ func initAccountServer(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
+	genesisBlock = b
 	repo, _ := chain.NewRepository(db, b)
 	claTransfer := tx.NewClause(&addr).WithValue(value)
 	claDeploy := tx.NewClause(nil).WithData(bytecode)
@@ -200,7 +267,9 @@ func initAccountServer(t *testing.T) {
 	packTx(repo, stater, transactionCall, t)
 
 	router := mux.NewRouter()
-	accounts.New(repo, stater, math.MaxUint64, thor.NoFork).Mount(router, "/accounts")
+	gasLimit = math.MaxUint32
+	accounts = New(repo, stater, gasLimit, thor.NoFork)
+	accounts.Mount(router, "/accounts")
 	ts = httptest.NewServer(router)
 }
 
@@ -247,14 +316,14 @@ func packTx(repo *chain.Repository, stater *state.Stater, transaction *tx.Transa
 }
 
 func deployContractWithCall(t *testing.T) {
-	badBody := &accounts.CallData{
+	badBody := &CallData{
 		Gas:  10000000,
 		Data: "abc",
 	}
 	_, statusCode := httpPost(t, ts.URL+"/accounts", badBody)
 	assert.Equal(t, http.StatusBadRequest, statusCode, "bad data")
 
-	reqBody := &accounts.CallData{
+	reqBody := &CallData{
 		Gas:  10000000,
 		Data: hexutil.Encode(bytecode),
 	}
@@ -264,7 +333,7 @@ func deployContractWithCall(t *testing.T) {
 
 	//revision is optional defaut `best`
 	res, _ := httpPost(t, ts.URL+"/accounts", reqBody)
-	var output *accounts.CallResult
+	var output *CallResult
 	if err := json.Unmarshal(res, &output); err != nil {
 		t.Fatal(err)
 	}
@@ -275,7 +344,14 @@ func callContract(t *testing.T) {
 	_, statusCode := httpPost(t, ts.URL+"/accounts/"+invalidAddr, nil)
 	assert.Equal(t, http.StatusBadRequest, statusCode, "invalid address")
 
-	badBody := &accounts.CallData{
+	malFormedBody := 123
+	_, statusCode = httpPost(t, ts.URL+"/accounts", malFormedBody)
+	assert.Equal(t, http.StatusBadRequest, statusCode, "invalid address")
+
+	_, statusCode = httpPost(t, ts.URL+"/accounts/"+contractAddr.String(), malFormedBody)
+	assert.Equal(t, http.StatusBadRequest, statusCode, "invalid address")
+
+	badBody := &CallData{
 		Data: "input",
 	}
 	_, statusCode = httpPost(t, ts.URL+"/accounts/"+contractAddr.String(), badBody)
@@ -290,11 +366,11 @@ func callContract(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	reqBody := &accounts.CallData{
+	reqBody := &CallData{
 		Data: hexutil.Encode(input),
 	}
 	res, statusCode := httpPost(t, ts.URL+"/accounts/"+contractAddr.String(), reqBody)
-	var output *accounts.CallResult
+	var output *CallResult
 	if err = json.Unmarshal(res, &output); err != nil {
 		t.Fatal(err)
 	}
@@ -312,22 +388,44 @@ func callContract(t *testing.T) {
 }
 
 func batchCall(t *testing.T) {
-	badBody := &accounts.BatchCallData{
-		Clauses: accounts.Clauses{
-			accounts.Clause{
+	// Request body is not a valid JSON
+	malformedBody := 123
+	_, statusCode := httpPost(t, ts.URL+"/accounts/*", malformedBody)
+	assert.Equal(t, http.StatusBadRequest, statusCode, "malformed data")
+
+	// Request body is not a valid BatchCallData
+	badBody := &BatchCallData{
+		Clauses: Clauses{
+			Clause{
 				To:    &contractAddr,
 				Data:  "data1",
 				Value: nil,
 			},
-			accounts.Clause{
+			Clause{
 				To:    &contractAddr,
 				Data:  "data2",
 				Value: nil,
 			}},
 	}
-	_, statusCode := httpPost(t, ts.URL+"/accounts/*", badBody)
+	_, statusCode = httpPost(t, ts.URL+"/accounts/*", badBody)
 	assert.Equal(t, http.StatusBadRequest, statusCode, "invalid data")
 
+	// Request body has an invalid blockRef
+	badBlockRef := &BatchCallData{
+		BlockRef: "0x00",
+	}
+	_, statusCode = httpPost(t, ts.URL+"/accounts/*", badBlockRef)
+	assert.Equal(t, http.StatusInternalServerError, statusCode, "invalid blockRef")
+
+	// Request body has an invalid malformed revision
+	_, statusCode = httpPost(t, fmt.Sprintf("%s/accounts/*?revision=%d", ts.URL, malformedBody), badBody)
+	assert.Equal(t, http.StatusBadRequest, statusCode, "invalid revision")
+
+	// Request body has an invalid revision number
+	_, statusCode = httpPost(t, ts.URL+"/accounts/*?revision="+invalidNumberRevision, badBody)
+	assert.Equal(t, http.StatusBadRequest, statusCode, "invalid revision")
+
+	// Valid request
 	a := uint8(1)
 	b := uint8(2)
 	method := "add"
@@ -337,25 +435,22 @@ func batchCall(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	reqBody := &accounts.BatchCallData{
-		Clauses: accounts.Clauses{
-			accounts.Clause{
+	reqBody := &BatchCallData{
+		Clauses: Clauses{
+			Clause{
 				To:    &contractAddr,
 				Data:  hexutil.Encode(input),
 				Value: nil,
 			},
-			accounts.Clause{
+			Clause{
 				To:    &contractAddr,
 				Data:  hexutil.Encode(input),
 				Value: nil,
 			}},
 	}
 
-	_, statusCode = httpPost(t, ts.URL+"/accounts/*?revision="+invalidNumberRevision, badBody)
-	assert.Equal(t, http.StatusBadRequest, statusCode, "invalid revision")
-
 	res, statusCode := httpPost(t, ts.URL+"/accounts/*", reqBody)
-	var results accounts.BatchCallResults
+	var results BatchCallResults
 	if err = json.Unmarshal(res, &results); err != nil {
 		t.Fatal(err)
 	}
@@ -373,9 +468,10 @@ func batchCall(t *testing.T) {
 	}
 	assert.Equal(t, http.StatusOK, statusCode)
 
+	// Valid request
 	big := math.HexOrDecimal256(*big.NewInt(1000))
-	fullBody := &accounts.BatchCallData{
-		Clauses:    accounts.Clauses{},
+	fullBody := &BatchCallData{
+		Clauses:    Clauses{},
 		Gas:        21000,
 		GasPrice:   &big,
 		ProvedWork: &big,
@@ -386,6 +482,20 @@ func batchCall(t *testing.T) {
 	}
 	_, statusCode = httpPost(t, ts.URL+"/accounts/*", fullBody)
 	assert.Equal(t, http.StatusOK, statusCode)
+
+	// Request with not enough gas
+	tooMuchGasBody := &BatchCallData{
+		Clauses:    Clauses{},
+		Gas:        math.MaxUint64,
+		GasPrice:   &big,
+		ProvedWork: &big,
+		Caller:     &contractAddr,
+		GasPayer:   &contractAddr,
+		Expiration: 100,
+		BlockRef:   "0x00000000aabbccdd",
+	}
+	_, statusCode = httpPost(t, ts.URL+"/accounts/*", tooMuchGasBody)
+	assert.Equal(t, http.StatusForbidden, statusCode)
 }
 
 func httpPost(t *testing.T, url string, body interface{}) ([]byte, int) {