go-ethereum/cmd/geth/js_test.go

package main

import (
	"fmt"
	"io/ioutil"
	"path/filepath"
	"os"
	"path"
	"testing"

	"github.com/ethereum/go-ethereum/accounts"
	"github.com/ethereum/go-ethereum/crypto"
	"github.com/ethereum/go-ethereum/eth"
	"runtime"
	"regexp"
	"strconv"
)

var port = 30300

func testJEthRE(t *testing.T) (*jsre, *eth.Ethereum) {
	tmp, err := ioutil.TempDir("", "geth-test")
	if err != nil {
		t.Fatal(err)
	}
	defer os.RemoveAll(tmp)

	ks := crypto.NewKeyStorePlain(filepath.Join(tmp, "keys"))
	ethereum, err := eth.New(&eth.Config{
		DataDir:        tmp,
		AccountManager: accounts.NewManager(ks),
		MaxPeers:       0,
		Name:           "test",
	})
	if err != nil {
		t.Fatal("%v", err)
	}
	assetPath := path.Join(os.Getenv("GOPATH"), "src", "github.com", "ethereum", "go-ethereum", "cmd", "mist", "assets", "ext")
	repl := newJSRE(ethereum, assetPath, false)
	return repl, ethereum
}

func TestNodeInfo(t *testing.T) {
	repl, ethereum := testJEthRE(t)
	if err := ethereum.Start(); err != nil {
		t.Fatalf("error starting ethereum: %v", err)
	}
	defer ethereum.Stop()

	want := `{"DiscPort":0,"IP":"0.0.0.0","ListenAddr":"","Name":"test","NodeID":"00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000","NodeUrl":"enode://00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000@0.0.0.0:0","TCPPort":0,"Td":"0"}`
	checkEvalJSON(t, repl, `admin.nodeInfo()`, want)
}

func TestAccounts(t *testing.T) {
	repl, ethereum := testJEthRE(t)
	if err := ethereum.Start(); err != nil {
		t.Fatalf("error starting ethereum: %v", err)
	}
	defer ethereum.Stop()

	checkEvalJSON(t, repl, `eth.accounts`, `[]`)
	checkEvalJSON(t, repl, `eth.coinbase`, `"0x"`)

	val, err := repl.re.Run(`admin.newAccount("password")`)
	if err != nil {
		t.Errorf("expected no error, got %v", err)
	}
	addr := val.String()
	if !regexp.MustCompile(`0x[0-9a-f]{40}`).MatchString(addr) {
		t.Errorf("address not hex: %q", addr)
	}

	checkEvalJSON(t, repl, `eth.accounts`, `["` + addr + `"]`)
	checkEvalJSON(t, repl, `eth.coinbase`, `"` + addr + `"`)
}

func TestBlockChain(t *testing.T) {
	repl, ethereum := testJEthRE(t)
	if err := ethereum.Start(); err != nil {
		t.Fatalf("error starting ethereum: %v", err)
	}
	defer ethereum.Stop()

	// get current block dump before export/import.
	val, err := repl.re.Run("JSON.stringify(admin.debug.dumpBlock())")
	if err != nil {
		t.Errorf("expected no error, got %v", err)
	}
	beforeExport := val.String()

	// do the export
	tmp, err := ioutil.TempDir("", "geth-test-export")
	if err != nil {
		t.Fatal(err)
	}
	defer os.RemoveAll(tmp)
	tmpfile := filepath.Join(tmp, "export.chain")
	tmpfileq := strconv.Quote(tmpfile)

	checkEvalJSON(t, repl, `admin.export(` + tmpfileq + `)`, `true`)
	if _, err := os.Stat(tmpfile); err != nil {
		t.Fatal(err)
	}

	// check import, verify that dumpBlock gives the same result.
	checkEvalJSON(t, repl, `admin.import(` + tmpfileq + `)`, `true`)
	checkEvalJSON(t, repl, `admin.debug.dumpBlock()`, beforeExport)
}

func TestMining(t *testing.T) {
	repl, ethereum := testJEthRE(t)
	if err := ethereum.Start(); err != nil {
		t.Fatalf("error starting ethereum: %v", err)
	}
	defer ethereum.Stop()

	checkEvalJSON(t, repl, `eth.mining`, `false`)
}

func TestRPC(t *testing.T) {
	repl, ethereum := testJEthRE(t)
	if err := ethereum.Start(); err != nil {
		t.Errorf("error starting ethereum: %v", err)
		return
	}
	defer ethereum.Stop()

	checkEvalJSON(t, repl, `admin.startRPC("127.0.0.1", 5004)`, `true`)
}

func checkEvalJSON(t *testing.T, re *jsre, expr, want string) error {
	val, err := re.re.Run("JSON.stringify("+ expr + ")")
	if err == nil && val.String() != want {
		err = fmt.Errorf("Output mismatch for `%s`:\ngot:  %s\nwant: %s", expr, val.String(), want)
	}
	if err != nil {
		_, file, line, _ := runtime.Caller(1)
		file = path.Base(file)
		fmt.Printf("\t%s:%d: %v\n", file, line, err)
		t.Fail()
	}
	return err
}