Problem:(CRO-587) no integration test for new validator join tx

enable drone


Update integration-tests/bot/chainrpc.py

thanks

Co-Authored-By: yihuang <[email protected]>
Update integration-tests/bot/chainrpc.py

Co-Authored-By: yihuang <[email protected]>
turn off join, jail integration test


fix enckey


fix for enckey


tidy up

remove SPID, IAS_API_KEY


remove spid print

remove un-necessary print


remove jail.nix in join

setup spid, ias_api_key in docker-compose

move setting to docker-compose

support azure sgx

integration-tests/all/run.sh

@@ -0,0 +1,14 @@
+#!/bin/bash
+./run_jail.sh
+ret=$?
+if [ $ret -ne 0 ]; then
+    echo "jail test fail"
+    exit -1
+fi
+
+./run_join.sh
+ret=$?
+if [ $ret -ne 0 ]; then
+    echo "join test fail"
+    exit -1
+fi

integration-tests/all/run_jail.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+cd ../jail
+./run.sh

integration-tests/all/run_join.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+cd ../join
+./run.sh

integration-tests/bot/chainbot.py

@@ -15,6 +15,7 @@
 import fire
 import toml
 import nacl.signing
+import copy
 from nacl.encoding import HexEncoder
 
 PASSPHRASE = '123456'
@@ -340,7 +341,16 @@ async def gen_wallet_addr(mnemonic, type='Staking', count=1):
         return addrs
 
 
-async def gen_genesis(cfg):
+async def gen_genesis(cfg_orig):
+    cfg = copy.deepcopy(cfg_orig)
+    newnodes= []
+    for n in cfg["nodes"]:
+        print(n)
+        if n["bonded_coin"]> 0:
+            newnodes.append(n)
+    cfg["nodes"]= newnodes
+
+
     genesis = {
         "genesis_time": cfg['genesis_time'],
         "chain_id": cfg['chain_id'],

integration-tests/bot/chainrpc.py

@@ -183,6 +183,9 @@ def withdraw_all_unbonded(self, from_address, to_address, view_keys=None, name=D
     def unjail(self, address, name=DEFAULT_WALLET, enckey=None):
         return call('staking_unjail', [name, enckey or get_enckey()], fix_address(address))
 
+    def join(self, node_name, node_pubkey, node_staking_address, name=DEFAULT_WALLET, enckey=None):
+        return call('staking_validatorNodeJoin', [name, enckey or get_enckey()], node_name, node_pubkey,  fix_address(node_staking_address))
+
 
 class MultiSig:
     def create_address(self, public_keys, self_public_key, required_signatures, name=DEFAULT_WALLET, enckey=None):

integration-tests/bot/jail_test.py

@@ -19,6 +19,16 @@ def __init__(self) :
         # wallet b
         self.node1_address = ""
         self.node1_mnemonics=""
+
+        # wallet b
+        self.node2_address = ""
+        self.node2_mnemonics=""
+
+        self.keya=""
+        self.keyb=""
+        self.keyc=""
+
+
         self.headers = {
             'Content-Type': 'application/json',
         }
@@ -39,29 +49,32 @@ def get_containers(self) :
 
 
 
-    def get_staking_state(self,name, passphrase, addr):
-        return self.rpc.staking.state(addr, name)
+    def get_staking_state(self,name, enckey, addr):
+        return self.rpc.staking.state(addr, name, enckey)
 
 
-    def create_staking_address(self,name, passphrase):
-        return self.rpc.address.create(name,'staking')
+    def create_staking_address(self,name, enckey):
+        return self.rpc.address.create(name,'staking', enckey)
 
     def restore_wallets(self):
         print("restore wallets")
         self.rpc.wallet.restore(self.node0_mnemonics, "a")
         self.rpc.wallet.restore(self.node1_mnemonics, "b")
+        self.rpc.wallet.restore(self.node2_mnemonics, "c")
 
 
     def create_addresses(self):
-        self.create_staking_address("a", "1")
-        self.create_staking_address("a", "1")
-        self.create_staking_address("b", "1")
-        self.create_staking_address("b", "1")
+        self.create_staking_address("a", self.keya)
+        self.create_staking_address("a", self.keya)
+        self.create_staking_address("b", self.keyb)
+        self.create_staking_address("b", self.keyb)
+        self.create_staking_address("c", self.keyc)
+        self.create_staking_address("c", self.keyc)
 
 
-    def unjail(self,name, passphrase, address):
+    def unjail(self,name, enckey, address):
         try:
-            return self.rpc.staking.unjail(address, name)
+            return self.rpc.staking.unjail(address, name, enckey)
         except jsonrpcclient.exceptions.JsonRpcClientError as ex:
             print("unjail fail={}".format(ex))
 
@@ -131,8 +144,8 @@ def test_unjailing(self) :
             self.check_validators()
             if remain_time< 0 :
                 assert False
-            self.unjail("b","1", self.node1_address)
-            state= self.get_staking_state("b","1", self.node1_address)
+            self.unjail("b",self.keyb, self.node1_address)
+            state= self.get_staking_state("b",self.keyb, self.node1_address)
             print("state {}".format(state))
             punishment=state["punishment"] 
             print("{0}  remain time={1:.2f}  punishment {2}".format(datetime.datetime.now(), remain_time, punishment))
@@ -151,9 +164,18 @@ def main (self) :
             self.restore_wallets()
         except jsonrpcclient.exceptions.JsonRpcClientError as ex:
             print("wallet already exists={}".format(ex))
+        self.keya=self.rpc.wallet.enckey("a")
+        self.keyb=self.rpc.wallet.enckey("b") 
+        self.keyc=self.rpc.wallet.enckey("c") 
         self.create_addresses()
         self.test_unjailing()
 
+    def main2 (self) :
+        try :
+            self.restore_wallets()
+        except jsonrpcclient.exceptions.JsonRpcClientError as ex:
+            print("wallet already exists={}".format(ex))
+        self.create_addresses()
 
     def read_info(self):
         print("read data")
@@ -162,16 +184,20 @@ def read_info(self):
         print(json.dumps(data,indent=4))
         self.node0_address= data["nodes"][0]["staking"][0]
         self.node1_address= data["nodes"][1]["staking"][0]
+        self.node2_address= data["nodes"][2]["staking"][0]
 
         self.node0_mnemonics=data["nodes"][0]["mnemonic"]
         self.node1_mnemonics=data["nodes"][1]["mnemonic"]
+        self.node2_mnemonics=data["nodes"][2]["mnemonic"]
 
     def display_info(self):
         print("jail test current hash={}".format(CURRENT_HASH))
         print("node0 staking= {}".format(self.node0_address))
         print("node1 staking= {}".format(self.node1_address))
+        print("node2 staking= {}".format(self.node2_address))
         print("node0 mnemonics= {}".format(self.node0_mnemonics))
         print("node1 mnemonics= {}".format(self.node1_mnemonics))
+        print("node2 mnemonics= {}".format(self.node2_mnemonics))
 
 
 p = Program()