plugeth/rpc/responses_test.go

package rpc

import (
	"encoding/json"
	"fmt"
	"math/big"
	"regexp"
	"testing"

	"github.com/ethereum/go-ethereum/common"
	"github.com/ethereum/go-ethereum/core/state"
	"github.com/ethereum/go-ethereum/core/types"
)

const (
	reHash       = `"0x[0-9a-f]{64}"`                    // 32 bytes
	reHashOpt    = `"(0x[0-9a-f]{64})"|null`             // 32 bytes or null
	reAddress    = `"0x[0-9a-f]{40}"`                    // 20 bytes
	reAddressOpt = `"0x[0-9a-f]{40}"|null`               // 20 bytes or null
	reNum        = `"0x([1-9a-f][0-9a-f]{0,15})|0"`      // must not have left-padded zeros
	reNumNonZero = `"0x([1-9a-f][0-9a-f]{0,15})"`        // non-zero required must not have left-padded zeros
	reNumOpt     = `"0x([1-9a-f][0-9a-f]{0,15})|0"|null` // must not have left-padded zeros or null
	reData       = `"0x[0-9a-f]*"`                       // can be "empty"
	// reListHash   = `[("\w":"0x[0-9a-f]{64}",?)*]`
	// reListObj    = `[("\w":(".+"|null),?)*]`
)

func TestNewBlockRes(t *testing.T) {
	tests := map[string]string{
		"number":           reNum,
		"hash":             reHash,
		"parentHash":       reHash,
		"nonce":            reData,
		"sha3Uncles":       reHash,
		"logsBloom":        reData,
		"transactionsRoot": reHash,
		"stateRoot":        reHash,
		"miner":            reAddress,
		"difficulty":       `"0x1"`,
		"totalDifficulty":  reNum,
		"size":             reNumNonZero,
		"extraData":        reData,
		"gasLimit":         reNum,
		// "minGasPrice":  "0x",
		"gasUsed":   reNum,
		"timestamp": reNum,
		// "transactions": reListHash,
		// "uncles":       reListHash,
	}

	block := makeBlock()
	v := NewBlockRes(block, false)
	j, _ := json.Marshal(v)

	for k, re := range tests {
		match, _ := regexp.MatchString(fmt.Sprintf(`{.*"%s":%s.*}`, k, re), string(j))
		if !match {
			t.Error(fmt.Sprintf("%s output json does not match format %s. Got %s", k, re, j))
		}
	}
}

func TestNewBlockResTxFull(t *testing.T) {
	tests := map[string]string{
		"number":           reNum,
		"hash":             reHash,
		"parentHash":       reHash,
		"nonce":            reData,
		"sha3Uncles":       reHash,
		"logsBloom":        reData,
		"transactionsRoot": reHash,
		"stateRoot":        reHash,
		"miner":            reAddress,
		"difficulty":       `"0x1"`,
		"totalDifficulty":  reNum,
		"size":             reNumNonZero,
		"extraData":        reData,
		"gasLimit":         reNum,
		// "minGasPrice":  "0x",
		"gasUsed":   reNum,
		"timestamp": reNum,
		// "transactions": reListHash,
		// "uncles":       reListHash,
	}

	block := makeBlock()
	v := NewBlockRes(block, true)
	j, _ := json.Marshal(v)

	for k, re := range tests {
		match, _ := regexp.MatchString(fmt.Sprintf(`{.*"%s":%s.*}`, k, re), string(j))
		if !match {
			t.Error(fmt.Sprintf("%s output json does not match format %s. Got %s", k, re, j))
		}
	}
}

func TestBlockNil(t *testing.T) {
	var block *types.Block
	block = nil
	u := NewBlockRes(block, false)
	j, _ := json.Marshal(u)
	if string(j) != "null" {
		t.Errorf("Expected null but got %v", string(j))
	}
}

func TestNewTransactionRes(t *testing.T) {
	to := common.HexToAddress("0x02")
	amount := big.NewInt(1)
	gasAmount := big.NewInt(1)
	gasPrice := big.NewInt(1)
	data := []byte{1, 2, 3}
	tx := types.NewTransactionMessage(to, amount, gasAmount, gasPrice, data)

	tests := map[string]string{
		"hash":             reHash,
		"nonce":            reNum,
		"blockHash":        reHashOpt,
		"blockNum":         reNumOpt,
		"transactionIndex": reNumOpt,
		"from":             reAddress,
		"to":               reAddressOpt,
		"value":            reNum,
		"gas":              reNum,
		"gasPrice":         reNum,
		"input":            reData,
	}

	v := NewTransactionRes(tx)
	v.BlockHash = newHexData(common.HexToHash("0x030201"))
	v.BlockNumber = newHexNum(5)
	v.TxIndex = newHexNum(0)
	j, _ := json.Marshal(v)
	for k, re := range tests {
		match, _ := regexp.MatchString(fmt.Sprintf(`{.*"%s":%s.*}`, k, re), string(j))
		if !match {
			t.Error(fmt.Sprintf("`%s` output json does not match format %s. Source %s", k, re, j))
		}
	}

}

func TestTransactionNil(t *testing.T) {
	var tx *types.Transaction
	tx = nil
	u := NewTransactionRes(tx)
	j, _ := json.Marshal(u)
	if string(j) != "null" {
		t.Errorf("Expected null but got %v", string(j))
	}
}

func TestNewUncleRes(t *testing.T) {
	header := makeHeader()
	u := NewUncleRes(header)
	tests := map[string]string{
		"number":           reNum,
		"hash":             reHash,
		"parentHash":       reHash,
		"nonce":            reData,
		"sha3Uncles":       reHash,
		"receiptHash":      reHash,
		"transactionsRoot": reHash,
		"stateRoot":        reHash,
		"miner":            reAddress,
		"difficulty":       reNum,
		"extraData":        reData,
		"gasLimit":         reNum,
		"gasUsed":          reNum,
		"timestamp":        reNum,
	}

	j, _ := json.Marshal(u)
	for k, re := range tests {
		match, _ := regexp.MatchString(fmt.Sprintf(`{.*"%s":%s.*}`, k, re), string(j))
		if !match {
			t.Error(fmt.Sprintf("`%s` output json does not match format %s. Source %s", k, re, j))
		}
	}
}

func TestUncleNil(t *testing.T) {
	var header *types.Header
	header = nil
	u := NewUncleRes(header)
	j, _ := json.Marshal(u)
	if string(j) != "null" {
		t.Errorf("Expected null but got %v", string(j))
	}
}

func TestNewLogRes(t *testing.T) {
	log := makeStateLog(0)
	tests := map[string]string{
		"address": reAddress,
		// "topics": "[.*]"
		"data":        reData,
		"blockNumber": reNum,
		// "hash":             reHash,
		// "logIndex":         reNum,
		// "blockHash":        reHash,
		// "transactionHash":  reHash,
		"transactionIndex": reNum,
	}

	v := NewLogRes(log)
	j, _ := json.Marshal(v)

	for k, re := range tests {
		match, _ := regexp.MatchString(fmt.Sprintf(`{.*"%s":%s.*}`, k, re), string(j))
		if !match {
			t.Error(fmt.Sprintf("`%s` output json does not match format %s. Got %s", k, re, j))
		}
	}

}

func TestNewLogsRes(t *testing.T) {
	logs := make([]state.Log, 3)
	logs[0] = makeStateLog(1)
	logs[1] = makeStateLog(2)
	logs[2] = makeStateLog(3)
	tests := map[string]string{}

	v := NewLogsRes(logs)
	j, _ := json.Marshal(v)

	for k, re := range tests {
		match, _ := regexp.MatchString(fmt.Sprintf(`[{.*"%s":%s.*}]`, k, re), string(j))
		if !match {
			t.Error(fmt.Sprintf("%s output json does not match format %s. Got %s", k, re, j))
		}
	}

}

func makeStateLog(num int) state.Log {
	address := common.HexToAddress("0x0")
	data := []byte{1, 2, 3}
	number := uint64(num)
	topics := make([]common.Hash, 3)
	topics = append(topics, common.HexToHash("0x00"))
	topics = append(topics, common.HexToHash("0x10"))
	topics = append(topics, common.HexToHash("0x20"))
	log := state.NewLog(address, topics, data, number)
	return log
}

func makeHeader() *types.Header {
	header := &types.Header{
		ParentHash:  common.StringToHash("0x00"),
		UncleHash:   common.StringToHash("0x00"),
		Coinbase:    common.StringToAddress("0x00"),
		Root:        common.StringToHash("0x00"),
		TxHash:      common.StringToHash("0x00"),
		ReceiptHash: common.StringToHash("0x00"),
		// Bloom:
		Difficulty: big.NewInt(88888888),
		Number:     big.NewInt(16),
		GasLimit:   big.NewInt(70000),
		GasUsed:    big.NewInt(25000),
		Time:       124356789,
		Extra:      nil,
		MixDigest:  common.StringToHash("0x00"),
		Nonce:      [8]byte{0, 1, 2, 3, 4, 5, 6, 7},
	}
	return header
}

func makeBlock() *types.Block {
	parentHash := common.HexToHash("0x01")
	coinbase := common.HexToAddress("0x01")
	root := common.HexToHash("0x01")
	difficulty := common.Big1
	nonce := uint64(1)
	block := types.NewBlock(parentHash, coinbase, root, difficulty, nonce, nil)

	txto := common.HexToAddress("0x02")
	txamount := big.NewInt(1)
	txgasAmount := big.NewInt(1)
	txgasPrice := big.NewInt(1)
	txdata := []byte{1, 2, 3}

	tx := types.NewTransactionMessage(txto, txamount, txgasAmount, txgasPrice, txdata)
	txs := make([]*types.Transaction, 1)
	txs[0] = tx
	block.SetTransactions(txs)

	uncles := make([]*types.Header, 1)
	uncles[0] = makeHeader()
	block.SetUncles(uncles)

	return block
}