2015-07-06 17:54:22 -07:00
// Copyright 2015 The go-ethereum Authors
// This file is part of go-ethereum.
//
// go-ethereum is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// go-ethereum is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
2015-04-03 08:37:59 -07:00
package natspec
import (
2015-04-22 15:11:11 -07:00
"fmt"
2015-04-03 08:37:59 -07:00
"io/ioutil"
2015-07-05 11:19:42 -07:00
"math/big"
2015-04-03 08:37:59 -07:00
"os"
2015-07-05 11:19:42 -07:00
"runtime"
2015-05-12 08:04:35 -07:00
"strings"
2015-04-03 08:37:59 -07:00
"testing"
2015-07-05 11:19:42 -07:00
"time"
2015-04-03 08:37:59 -07:00
"github.com/ethereum/go-ethereum/accounts"
"github.com/ethereum/go-ethereum/common"
2015-04-05 23:01:36 -07:00
"github.com/ethereum/go-ethereum/common/docserver"
2015-06-23 07:48:33 -07:00
"github.com/ethereum/go-ethereum/common/registrar"
2015-04-03 08:37:59 -07:00
"github.com/ethereum/go-ethereum/core"
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/eth"
xe "github.com/ethereum/go-ethereum/xeth"
)
2015-04-14 07:01:25 -07:00
const (
2015-04-22 15:11:11 -07:00
testBalance = "10000000000000000000"
2015-04-14 07:01:25 -07:00
2015-04-22 15:11:11 -07:00
testFileName = "long_file_name_for_testing_registration_of_URLs_longer_than_32_bytes.content"
2015-04-17 04:46:38 -07:00
2015-04-22 15:11:11 -07:00
testNotice = "Register key `utils.toHex(_key)` <- content `utils.toHex(_content)`"
2015-04-07 02:50:17 -07:00
2015-04-22 15:11:11 -07:00
testExpNotice = "Register key 0xadd1a7d961cff0242089674ec2ef6fca671ab15e1fe80e38859fc815b98d88ab <- content 0xb3a2dea218de5d8bbe6c4645aadbf67b5ab00ecb1a9ec95dbdad6a0eed3e41a7"
testExpNotice2 = ` About to submit transaction (NatSpec notice error: abi key does not match any method): { "params":[ { "to":"%s","data": "0x31e12c20"}]} `
testExpNotice3 = ` About to submit transaction (no NatSpec info found for contract: content hash not found for '0x1392c62d05b2d149e22a339c531157ae06b44d39a674cce500064b12b9aeb019'): { "params":[ { "to":"%s","data": "0x300a3bbfb3a2dea218de5d8bbe6c4645aadbf67b5ab00ecb1a9ec95dbdad6a0eed3e41a7000000000000000000000000000000000000000000000000000000000000000000000000000000000000000066696c653a2f2f2f746573742e636f6e74656e74"}]} `
)
const (
testUserDoc = `
2015-04-07 02:50:17 -07:00
{
"methods" : {
"register(uint256,uint256)" : {
"notice" : "` + testNotice + `"
}
} ,
"invariants" : [
{ "notice" : "" }
] ,
"construction" : [
{ "notice" : "" }
]
}
`
2015-04-22 15:11:11 -07:00
testAbiDefinition = `
2015-04-07 02:50:17 -07:00
[ {
"name" : "register" ,
"constant" : false ,
"type" : "function" ,
"inputs" : [ {
"name" : "_key" ,
"type" : "uint256"
} , {
"name" : "_content" ,
"type" : "uint256"
} ] ,
"outputs" : [ ]
} ]
`
2015-04-22 15:11:11 -07:00
testContractInfo = `
2015-04-07 02:50:17 -07:00
{
2015-04-22 15:11:11 -07:00
"userDoc" : ` + testUserDoc + ` ,
"abiDefinition" : ` + testAbiDefinition + `
2015-04-07 02:50:17 -07:00
}
`
2015-04-22 15:11:11 -07:00
)
type testFrontend struct {
2015-06-23 07:48:33 -07:00
t * testing . T
2015-04-22 15:11:11 -07:00
ethereum * eth . Ethereum
xeth * xe . XEth
2015-07-05 11:19:42 -07:00
wait chan * big . Int
2015-04-22 15:11:11 -07:00
lastConfirm string
wantNatSpec bool
}
2015-04-07 02:50:17 -07:00
2015-04-22 15:11:11 -07:00
func ( self * testFrontend ) UnlockAccount ( acc [ ] byte ) bool {
2015-04-26 08:18:06 -07:00
self . ethereum . AccountManager ( ) . Unlock ( common . BytesToAddress ( acc ) , "password" )
2015-04-03 08:37:59 -07:00
return true
}
2015-04-22 15:11:11 -07:00
func ( self * testFrontend ) ConfirmTransaction ( tx string ) bool {
if self . wantNatSpec {
2015-06-23 07:48:33 -07:00
ds := docserver . New ( "/tmp/" )
2015-04-22 15:11:11 -07:00
self . lastConfirm = GetNotice ( self . xeth , tx , ds )
2015-04-07 02:50:17 -07:00
}
2015-04-05 23:01:36 -07:00
return true
}
2015-04-03 08:37:59 -07:00
2015-04-05 23:01:36 -07:00
func testEth ( t * testing . T ) ( ethereum * eth . Ethereum , err error ) {
2015-04-22 15:11:11 -07:00
2015-04-19 11:24:46 -07:00
os . RemoveAll ( "/tmp/eth-natspec/" )
2015-04-22 15:11:11 -07:00
2015-05-12 09:33:04 -07:00
err = os . MkdirAll ( "/tmp/eth-natspec/keystore" , os . ModePerm )
2015-04-03 08:37:59 -07:00
if err != nil {
2015-04-22 15:11:11 -07:00
panic ( err )
2015-04-03 08:37:59 -07:00
}
2015-04-22 15:11:11 -07:00
// create a testAddress
2015-05-12 09:33:04 -07:00
ks := crypto . NewKeyStorePassphrase ( "/tmp/eth-natspec/keystore" )
2015-04-22 15:11:11 -07:00
am := accounts . NewManager ( ks )
testAccount , err := am . NewAccount ( "password" )
2015-04-03 08:37:59 -07:00
if err != nil {
2015-04-22 15:11:11 -07:00
panic ( err )
2015-04-03 08:37:59 -07:00
}
2015-05-12 08:04:35 -07:00
testAddress := strings . TrimPrefix ( testAccount . Address . Hex ( ) , "0x" )
2015-04-22 15:11:11 -07:00
// set up mock genesis with balance on the testAddress
2015-06-04 02:41:20 -07:00
core . GenesisAccounts = [ ] byte ( ` {
2015-04-22 15:11:11 -07:00
"` + testAddress + `" : { "balance" : "` + testBalance + `" }
} ` )
2015-04-03 08:37:59 -07:00
2015-04-22 15:11:11 -07:00
// only use minimalistic stack with no networking
2015-04-03 08:37:59 -07:00
ethereum , err = eth . New ( & eth . Config {
2015-04-19 11:24:46 -07:00
DataDir : "/tmp/eth-natspec" ,
2015-04-22 15:11:11 -07:00
AccountManager : am ,
MaxPeers : 0 ,
2015-07-05 11:19:42 -07:00
PowTest : true ,
2015-07-07 04:01:39 -07:00
Etherbase : common . HexToAddress ( testAddress ) ,
2015-04-03 08:37:59 -07:00
} )
if err != nil {
2015-04-22 15:11:11 -07:00
panic ( err )
2015-04-03 08:37:59 -07:00
}
return
}
2015-04-05 23:01:36 -07:00
func testInit ( t * testing . T ) ( self * testFrontend ) {
2015-04-22 15:11:11 -07:00
// initialise and start minimal ethereum stack
2015-04-05 23:01:36 -07:00
ethereum , err := testEth ( t )
if err != nil {
2015-04-19 11:24:46 -07:00
t . Errorf ( "error creating ethereum: %v" , err )
2015-04-05 23:01:36 -07:00
return
}
err = ethereum . Start ( )
if err != nil {
t . Errorf ( "error starting ethereum: %v" , err )
return
}
2015-04-22 15:11:11 -07:00
// mock frontend
2015-04-05 23:01:36 -07:00
self = & testFrontend { t : t , ethereum : ethereum }
self . xeth = xe . New ( ethereum , self )
2015-07-05 11:19:42 -07:00
self . wait = self . xeth . UpdateState ( )
addr , _ := self . ethereum . Etherbase ( )
2015-04-14 06:20:52 -07:00
2015-04-22 15:11:11 -07:00
// initialise the registry contracts
2015-06-23 07:48:33 -07:00
reg := registrar . New ( self . xeth )
2015-07-06 22:00:58 -07:00
var registrarTxhash , hashRegTxhash , urlHintTxhash string
registrarTxhash , err = reg . SetGlobalRegistrar ( "" , addr )
2015-07-05 11:19:42 -07:00
if err != nil {
t . Errorf ( "error creating GlobalRegistrar: %v" , err )
}
2015-07-06 22:00:58 -07:00
hashRegTxhash , err = reg . SetHashReg ( "" , addr )
2015-06-23 07:48:33 -07:00
if err != nil {
t . Errorf ( "error creating HashReg: %v" , err )
}
2015-07-06 22:00:58 -07:00
urlHintTxhash , err = reg . SetUrlHint ( "" , addr )
2015-06-23 07:48:33 -07:00
if err != nil {
t . Errorf ( "error creating UrlHint: %v" , err )
}
2015-07-06 22:00:58 -07:00
if ! processTxs ( self , t , 3 ) {
2015-07-05 11:19:42 -07:00
t . Errorf ( "error mining txs" )
}
2015-07-06 22:00:58 -07:00
_ = registrarTxhash
_ = hashRegTxhash
_ = urlHintTxhash
/ * TODO :
* lookup receipt and contract addresses by tx hash
* name registration for HashReg and UrlHint addresses
* mine those transactions
* then set once more SetHashReg SetUrlHint
* /
2015-04-07 05:46:14 -07:00
2015-04-22 15:11:11 -07:00
return
2015-04-14 06:20:52 -07:00
2015-04-07 02:50:17 -07:00
}
2015-04-22 15:11:11 -07:00
// end to end test
2015-04-05 23:01:36 -07:00
func TestNatspecE2E ( t * testing . T ) {
2015-07-06 22:00:58 -07:00
t . Skip ( )
2015-04-05 23:01:36 -07:00
tf := testInit ( t )
defer tf . ethereum . Stop ( )
2015-07-05 11:19:42 -07:00
addr , _ := tf . ethereum . Etherbase ( )
2015-04-03 08:37:59 -07:00
2015-04-22 15:11:11 -07:00
// create a contractInfo file (mock cloud-deployed contract metadocs)
// incidentally this is the info for the registry contract itself
ioutil . WriteFile ( "/tmp/" + testFileName , [ ] byte ( testContractInfo ) , os . ModePerm )
2015-07-05 11:19:42 -07:00
dochash := crypto . Sha3Hash ( [ ] byte ( testContractInfo ) )
2015-04-03 08:37:59 -07:00
2015-04-22 15:11:11 -07:00
// take the codehash for the contract we wanna test
2015-06-23 07:48:33 -07:00
codeb := tf . xeth . CodeAtBytes ( registrar . HashRegAddr )
2015-07-05 11:19:42 -07:00
codehash := crypto . Sha3Hash ( codeb )
2015-04-03 08:37:59 -07:00
2015-04-22 15:11:11 -07:00
// use resolver to register codehash->dochash->url
2015-06-23 07:48:33 -07:00
// test if globalregistry works
// registrar.HashRefAddr = "0x0"
// registrar.UrlHintAddr = "0x0"
reg := registrar . New ( tf . xeth )
2015-07-05 11:19:42 -07:00
_ , err := reg . SetHashToHash ( addr , codehash , dochash )
2015-06-23 07:48:33 -07:00
if err != nil {
t . Errorf ( "error registering: %v" , err )
}
2015-07-05 11:19:42 -07:00
_ , err = reg . SetUrlToHash ( addr , dochash , "file:///" + testFileName )
2015-04-07 02:50:17 -07:00
if err != nil {
2015-04-22 15:11:11 -07:00
t . Errorf ( "error registering: %v" , err )
2015-04-07 02:50:17 -07:00
}
2015-07-05 11:19:42 -07:00
if ! processTxs ( tf , t , 5 ) {
return
}
2015-04-07 02:50:17 -07:00
2015-04-08 03:35:02 -07:00
// NatSpec info for register method of HashReg contract installed
// now using the same transactions to check confirm messages
2015-04-22 15:11:11 -07:00
tf . wantNatSpec = true // this is set so now the backend uses natspec confirmation
2015-07-05 11:19:42 -07:00
_ , err = reg . SetHashToHash ( addr , codehash , dochash )
2015-04-22 15:11:11 -07:00
if err != nil {
t . Errorf ( "error calling contract registry: %v" , err )
}
2015-06-23 07:48:33 -07:00
fmt . Printf ( "GlobalRegistrar: %v, HashReg: %v, UrlHint: %v\n" , registrar . GlobalRegistrarAddr , registrar . HashRegAddr , registrar . UrlHintAddr )
2015-04-07 02:50:17 -07:00
if tf . lastConfirm != testExpNotice {
2015-07-05 11:19:42 -07:00
t . Errorf ( "Wrong confirm message. expected\n'%v', got\n'%v'" , testExpNotice , tf . lastConfirm )
2015-04-07 02:50:17 -07:00
}
2015-04-03 08:37:59 -07:00
2015-04-22 15:11:11 -07:00
// test unknown method
2015-06-23 07:48:33 -07:00
exp := fmt . Sprintf ( testExpNotice2 , registrar . HashRegAddr )
2015-07-05 11:19:42 -07:00
_ , err = reg . SetOwner ( addr )
2015-04-22 15:11:11 -07:00
if err != nil {
t . Errorf ( "error setting owner: %v" , err )
}
if tf . lastConfirm != exp {
2015-07-05 11:19:42 -07:00
t . Errorf ( "Wrong confirm message, expected\n'%v', got\n'%v'" , exp , tf . lastConfirm )
2015-04-22 15:11:11 -07:00
}
// test unknown contract
2015-06-23 07:48:33 -07:00
exp = fmt . Sprintf ( testExpNotice3 , registrar . UrlHintAddr )
2015-04-22 15:11:11 -07:00
2015-07-05 11:19:42 -07:00
_ , err = reg . SetUrlToHash ( addr , dochash , "file:///test.content" )
2015-04-22 15:11:11 -07:00
if err != nil {
t . Errorf ( "error registering: %v" , err )
2015-04-08 03:35:02 -07:00
}
2015-04-22 15:11:11 -07:00
if tf . lastConfirm != exp {
t . Errorf ( "Wrong confirm message, expected '%v', got '%v'" , exp , tf . lastConfirm )
2015-04-08 03:35:02 -07:00
}
2015-04-03 08:37:59 -07:00
}
2015-07-05 11:19:42 -07:00
func pendingTransactions ( repl * testFrontend , t * testing . T ) ( txc int64 , err error ) {
txs := repl . ethereum . TxPool ( ) . GetTransactions ( )
return int64 ( len ( txs ) ) , nil
}
func processTxs ( repl * testFrontend , t * testing . T , expTxc int ) bool {
var txc int64
var err error
for i := 0 ; i < 50 ; i ++ {
txc , err = pendingTransactions ( repl , t )
if err != nil {
t . Errorf ( "unexpected error checking pending transactions: %v" , err )
return false
}
if expTxc < int ( txc ) {
t . Errorf ( "too many pending transactions: expected %v, got %v" , expTxc , txc )
return false
} else if expTxc == int ( txc ) {
break
}
time . Sleep ( 100 * time . Millisecond )
}
if int ( txc ) != expTxc {
t . Errorf ( "incorrect number of pending transactions, expected %v, got %v" , expTxc , txc )
return false
}
err = repl . ethereum . StartMining ( runtime . NumCPU ( ) )
if err != nil {
t . Errorf ( "unexpected error mining: %v" , err )
return false
}
defer repl . ethereum . StopMining ( )
timer := time . NewTimer ( 100 * time . Second )
height := new ( big . Int ) . Add ( repl . xeth . CurrentBlock ( ) . Number ( ) , big . NewInt ( 1 ) )
repl . wait <- height
select {
case <- timer . C :
// if times out make sure the xeth loop does not block
go func ( ) {
select {
case repl . wait <- nil :
case <- repl . wait :
}
} ( )
case <- repl . wait :
}
txc , err = pendingTransactions ( repl , t )
if err != nil {
t . Errorf ( "unexpected error checking pending transactions: %v" , err )
return false
}
if txc != 0 {
t . Errorf ( "%d trasactions were not mined" , txc )
return false
}
return true
}