tests: reorganize packages (#7)

* tests: reorganize testing packages

* gitignore and minor changes

tests/solidity/suites/basic/contracts/Counter.sol

@@ -0,0 +1,24 @@
+pragma solidity ^0.5.11;
+
+contract Counter {
+  uint256 counter = 0;
+  string internal constant ERROR_TOO_LOW = "COUNTER_TOO_LOW";
+  event Changed(uint256 counter);
+  event Added(uint256 counter);
+
+  function add() public {
+    counter++;
+    emit Added(counter);
+    emit Changed(counter);
+  }
+
+  function subtract() public {
+    require(counter > 0, ERROR_TOO_LOW);
+    counter--;
+    emit Changed(counter);
+  }
+
+  function getCounter() public view returns (uint256) {
+    return counter;
+  }
+}

tests/solidity/suites/basic/contracts/test/Migrations.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.4.22 <0.8.0;
+
+contract Migrations {
+  address public owner = msg.sender;
+  uint public last_completed_migration;
+
+  modifier restricted() {
+    require(
+      msg.sender == owner,
+      "This function is restricted to the contract's owner"
+    );
+    _;
+  }
+
+  function setCompleted(uint completed) public restricted {
+    last_completed_migration = completed;
+  }
+}

tests/solidity/suites/basic/main.go

@@ -0,0 +1,158 @@
+package main
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io/ioutil"
+	"log"
+	"net/http"
+	"os"
+	"time"
+
+	"github.com/ethereum/go-ethereum/common/hexutil"
+)
+
+var (
+	HOST = os.Getenv("HOST")
+	HOME = os.Getenv("PWD")
+)
+
+type Request struct {
+	Version string      `json:"jsonrpc"`
+	Method  string      `json:"method"`
+	Params  interface{} `json:"params"`
+	ID      int         `json:"id"`
+}
+
+type RPCError struct {
+	Code    int         `json:"code"`
+	Message string      `json:"message"`
+	Data    interface{} `json:"data,omitempty"`
+}
+
+type Response struct {
+	Error  *RPCError       `json:"error"`
+	ID     int             `json:"id"`
+	Result json.RawMessage `json:"result,omitempty"`
+}
+
+func createRequest(method string, params interface{}) Request {
+	return Request{
+		Version: "2.0",
+		Method:  method,
+		Params:  params,
+		ID:      1,
+	}
+}
+
+func getTransactionReceipt(hash hexutil.Bytes) (map[string]interface{}, error) {
+	param := []string{hash.String()}
+
+	rpcRes, err := call("eth_getTransactionReceipt", param)
+	if err != nil {
+		return nil, err
+	}
+
+	receipt := make(map[string]interface{})
+
+	err = json.Unmarshal(rpcRes.Result, &receipt)
+	if err != nil {
+		return nil, err
+	}
+
+	return receipt, nil
+}
+
+func waitForReceipt(hash hexutil.Bytes) (map[string]interface{}, error) {
+	for i := 0; i < 10; i++ {
+		receipt, err := getTransactionReceipt(hash)
+		if receipt != nil {
+			return receipt, err
+		} else if err != nil {
+			return nil, err
+		}
+
+		time.Sleep(time.Second)
+	}
+
+	return nil, errors.New("cound not find transaction on chain")
+}
+
+func call(method string, params interface{}) (*Response, error) {
+	var rpcRes *Response
+
+	if HOST == "" {
+		HOST = "http://localhost:8545"
+	}
+
+	req, err := json.Marshal(createRequest(method, params))
+	if err != nil {
+		return nil, err
+	}
+
+	time.Sleep(1000000 * time.Nanosecond)
+	/* #nosec */
+	res, err := http.Post(HOST, "application/json", bytes.NewBuffer(req))
+	if err != nil {
+		return nil, err
+	}
+
+	decoder := json.NewDecoder(res.Body)
+	rpcRes = new(Response)
+
+	if err := decoder.Decode(&rpcRes); err != nil {
+		return nil, err
+	}
+
+	if err := res.Body.Close(); err != nil {
+		return nil, err
+	}
+
+	return rpcRes, nil
+}
+
+func main() {
+	var hash hexutil.Bytes
+
+	dat, err := ioutil.ReadFile(HOME + "/counter/counter_sol.bin")
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	param := make([]map[string]string, 1)
+	param[0] = make(map[string]string)
+	param[0]["from"] = os.Args[1]
+	param[0]["data"] = "0x" + string(dat)
+
+	txRPCRes, err := call("eth_sendTransaction", param)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	if err := json.Unmarshal(txRPCRes.Result, &hash); err != nil {
+		log.Fatal(err)
+	}
+
+	fmt.Println("Contract TX hash: ", hash)
+
+	receipt, err := waitForReceipt(hash)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	/*
+		//test for bad hash
+		testhash, err := hexutil.Decode("0xe146d95c74a48e730bf825c2a3dcbce8122b8a463bc15bcbb38b9c195402f0a5")
+		if err != nil {
+			log.Fatal(err)
+		}
+		receipt, err := waitForReceipt(testhash)
+		if err != nil {
+			log.Fatal(err)
+		}
+	*/
+
+	fmt.Println("receipt: ", receipt)
+}

tests/solidity/suites/basic/migrations/1_initial_migration.js

@@ -0,0 +1,5 @@
+const Migrations = artifacts.require("Migrations");
+
+module.exports = function (deployer) {
+  deployer.deploy(Migrations);
+};

tests/solidity/suites/basic/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "basic",
+  "version": "1.0.0",
+  "author": "Aragon Association <contact@aragon.org>",
+  "license": "GPL-3.0-or-later",
+  "scripts": {
+    "test-ganache": "yarn truffle test",
+    "test-ethermint": "yarn truffle test --network ethermint"
+  },
+  "devDependencies": {
+    "truffle": "^5.1.42",
+    "web3": "^1.2.11"
+  },
+  "dependencies": {
+    "truffle": "^5.1.43"
+  }
+}

tests/solidity/suites/basic/test/counter.js

@@ -0,0 +1,80 @@
+const Counter = artifacts.require("Counter")
+
+contract('Counter', ([one, two, three]) => {
+  console.log(one, two, three)
+  let counter
+
+  beforeEach(async() => {
+    counter = await Counter.new()
+    console.log('Counter:', counter.address)
+
+    console.log('Current eth:')
+    console.log('  - ', await web3.eth.getBalance(one))
+    console.log('  - ', await web3.eth.getBalance(two))
+    console.log('  - ', await web3.eth.getBalance(three))
+    console.log('')
+  })
+
+  it('should add', async() => {
+    const balanceOne = await web3.eth.getBalance(one)
+    const balanceTwo = await web3.eth.getBalance(two)
+    const balanceThree = await web3.eth.getBalance(three)
+
+    let count
+
+    await counter.add({ from: one })
+    count = await counter.getCounter()
+    console.log(count.toString())
+    assert.equal(count, '1', 'Counter should be 1')
+    assert.notEqual(balanceOne, await web3.eth.getBalance(one), `${one}'s balance should be different`)
+
+    await counter.add({ from: two })
+    count = await counter.getCounter()
+    console.log(count.toString())
+    assert.equal(count, '2', 'Counter should be 2')
+    assert.notEqual(balanceTwo, await web3.eth.getBalance(two), `${two}'s balance should be different`)
+
+    await counter.add({ from: three })
+    count = await counter.getCounter()
+    console.log(count.toString())
+    assert.equal(count, '3', 'Counter should be 3')
+    assert.notEqual(balanceThree, await web3.eth.getBalance(three), `${three}'s balance should be different`)
+  })
+
+  it('should subtract', async() => {
+    let count
+
+    await counter.add()
+    count = await counter.getCounter()
+    console.log(count.toString())
+    assert.equal(count, '1', 'Counter should be 1')
+
+    // Use receipt to ensure logs are emitted
+    const receipt = await counter.subtract()
+    count = await counter.getCounter()
+    console.log(count.toString())
+    console.log()
+    console.log('Subtract tx receipt:', receipt)
+    assert.equal(count, '0', 'Counter should be 0')
+    assert.equal(receipt.logs[0].event, 'Changed', "Should have emitted 'Changed' event")
+    assert.equal(receipt.logs[0].args.counter, '0', "Should have emitted 'Changed' event with counter being 0")
+
+    // Check lifecycle of events
+    const contract = new web3.eth.Contract(counter.abi, counter.address)
+    const allEvents = await contract.getPastEvents("allEvents", { fromBlock: 0, toBlock: 'latest' })
+    const changedEvents = await contract.getPastEvents("Changed", { fromBlock: 0, toBlock: 'latest' })
+    console.log('allEvents', allEvents)
+    console.log('changedEvents', changedEvents)
+    assert.equal(allEvents.length, 3)
+    assert.equal(changedEvents.length, 2)
+
+    try {
+      await counter.subtract()
+      assert.fail('Subtracting past 0 should have reverted')
+    } catch (err) {
+      console.log()
+      console.log('Passed -- was expecting error')
+      console.log('Error:', err)
+    }
+  })
+})

tests/solidity/suites/basic/truffle-config.js

@@ -0,0 +1,17 @@
+module.exports = {
+  networks: {
+    // Development network is just left as truffle's default settings
+    ethermint: {
+      host: "127.0.0.1",     // Localhost (default: none)
+      port: 8545,            // Standard Ethereum port (default: none)
+      network_id: "*",       // Any network (default: none)
+      gas: 5000000,          // Gas sent with each transaction
+      gasPrice: 1000000000,  // 1 gwei (in wei)
+    },
+  },
+  compilers: {
+    solc: {
+      version: "0.5.17",
+    },
+  },
+}