path: root/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]{1,15})|0"` // must not have left-padded zeros
    reData       = `"0x[0-9a-f]*"`                  // can be "empty"
)

func TestNewBlockRes(t *testing.T) {
    parentHash := common.HexToHash("0x01")
    coinbase := common.HexToAddress("0x01")
    root := common.HexToHash("0x01")
    difficulty := common.Big1
    nonce := uint64(1)
    extra := ""
    block := types.NewBlock(parentHash, coinbase, root, difficulty, nonce, extra)
    tests := map[string]string{
        "number":          reNum,
        "hash":            reHash,
        "parentHash":      reHash,
        "nonce":           reNum,
        "sha3Uncles":      reHash,
        "logsBloom":       reData,
        "transactionRoot": reHash,
        "stateRoot":       reHash,
        "miner":           reAddress,
        "difficulty":      `"0x1"`,
        "totalDifficulty": reNum,
        "size":            reNum,
        "extraData":       reData,
        "gasLimit":        reNum,
        // "minGasPrice":  "0x",
        "gasUsed":   reNum,
        "timestamp": reNum,
    }

    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 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":        reHash,
        "blockNum":         reNum,
        "transactionIndex": reNum,
        "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 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
}