Unlock 30% off on Manual Testing Annual Plans this Holiday Season.

Copied to Clipboard!

How to use require_that method in Lemoncheesecake

Best Python code snippet using lemoncheesecake

TestRPC.py

Source:TestRPC.py

...35        return payload36    def get_response(self, payload):37        response = requests.post(TESTRPC_URL, json=payload).json()38        lcc.log_debug(str(response))39        if require_that("json-rpc response", response, has_length(3)):40            require_that_in(response, "id", is_integer(), "jsonrpc", equal_to("2.0"))41            return response42    def transfer(self):43        payload = self.rpc_call(44            "personal_sendTransaction", [{45                "from": self.account_address,46                "to": self.new_account_address,47                "value": self.value48            }, ""]49        )50        trx_hash = self.get_response(payload)["result"]51        return trx_hash52    def create_contract(self):53        payload = self.rpc_call(54            "personal_sendTransaction", [{55                "from": self.account_address,56                "data": self.contract,57            }, ""]58        )59        trx_hash = self.get_response(payload)["result"]60        return trx_hash61    def validate_transaction(self, transaction):62        if require_that("transactions", transaction, has_length(14)):63            if not self.type_validator.is_SHA3_256(transaction["blockHash"]):64                lcc.log_error("Wrong format of 'blockHash', got: '{}'".format(transaction["blockHash"]))65            else:66                lcc.log_info("'blockHash' has correct format: eth_hash")67            if not self.type_validator.is_eth_hash(transaction["blockNumber"]):68                lcc.log_error("Wrong format of 'blockNumber', got: '{}'".format(transaction["blockNumber"]))69            else:70                lcc.log_info("'blockNumber' has correct format: eth_hash")71            if not self.type_validator.is_eth_hash(transaction["gas"]):72                lcc.log_error("Wrong format of 'gas', got: '{}'".format(transaction["gas"]))73            else:74                lcc.log_info("'gas' has correct format: eth_hash")75            if not self.type_validator.is_eth_hash(transaction["gasPrice"]):76                lcc.log_error("Wrong format of 'gasPrice', got: '{}'".format(transaction["gasPrice"]))77            else:78                lcc.log_info("'gasPrice' has correct format: eth_hash")79            if not self.type_validator.is_SHA3_256(transaction["hash"]):80                lcc.log_error("Wrong format of 'hash', got: '{}'".format(transaction["hash"]))81            else:82                lcc.log_info("'hash' has correct format: eth_hash")83            if not self.type_validator.is_eth_hash(transaction["nonce"]):84                lcc.log_error("Wrong format of 'nonce', got: '{}'".format(transaction["nonce"]))85            else:86                lcc.log_info("'nonce' has correct format: eth_hash")87            if not self.type_validator.is_eth_hash(transaction["to"]):88                lcc.log_error("Wrong format of 'to', got: '{}'".format(transaction["to"]))89            else:90                lcc.log_info("'to' has correct format: eth_hash")91            if not self.type_validator.is_eth_hash(transaction["transactionIndex"]):92                lcc.log_error("Wrong format of 'transactionIndex', got: '{}'".format(transaction["transactionIndex"]))93            else:94                lcc.log_info("'transactionIndex' has correct format: eth_hash")95            check_that("value", transaction["value"], equal_to(self.value))96            if not self.type_validator.is_eth_hash(transaction["v"]):97                lcc.log_error("Wrong format of 'v', got: '{}'".format(transaction["v"]))98            else:99                lcc.log_info("'v' has correct format: eth_hash")100            if not self.type_validator.is_eth_hash(transaction["r"]):101                lcc.log_error("Wrong format of 'r', got: '{}'".format(transaction["r"]))102            else:103                lcc.log_info("'r' has correct format: eth_hash")104            if not self.type_validator.is_eth_hash(transaction["s"]):105                lcc.log_error("Wrong format of 's', got: '{}'".format(transaction["s"]))106            else:107                lcc.log_info("'s' has correct format: eth_hash")108    def validate_block(self, result):109        if require_that("'result'", result, has_length(19)):110            if not self.type_validator.is_eth_hash(result["number"]):111                lcc.log_error("Wrong format of 'number', got: '{}'".format(result["number"]))112            else:113                lcc.log_info("'number' has correct format: hash")114            if not self.type_validator.is_eth_hash(result["hash"]):115                lcc.log_error("Wrong format of 'hash', got: '{}'".format(result["hash"]))116            else:117                lcc.log_info("'hash' has correct format: hash")118            if not self.type_validator.is_eth_hash(result["parentHash"]):119                lcc.log_error("Wrong format of 'parentHash', got: '{}'".format(result["parentHash"]))120            else:121                lcc.log_info("'parentHash' has correct format: hash")122            if not self.type_validator.is_eth_hash(result["nonce"]):123                lcc.log_error("Wrong format of 'nonce', got: '{}'".format(result["nonce"]))124            else:125                lcc.log_info("'nonce' has correct format: hash")126            if not self.type_validator.is_eth_hash(result["sha3Uncles"]):127                lcc.log_error("Wrong format of 'sha3Uncles', got: '{}'".format(result["sha3Uncles"]))128            else:129                lcc.log_info("'result' has correct format: hash")130            if not self.type_validator.is_eth_hash(result["logsBloom"]):131                lcc.log_error("Wrong format of 'logsBloom', got: '{}'".format(result["logsBloom"]))132            else:133                lcc.log_info("'result' has correct format: hash")134            if not self.type_validator.is_eth_hash(result["transactionsRoot"]):135                lcc.log_error("Wrong format of 'transactionsRoot', got: '{}'".format(result["transactionsRoot"]))136            else:137                lcc.log_info("'transactionsRoot' has correct format: hash")138            if not self.type_validator.is_eth_hash(result["stateRoot"]):139                lcc.log_error("Wrong format of 'stateRoot', got: '{}'".format(result["stateRoot"]))140            else:141                lcc.log_info("'stateRoot' has correct format: hash")142            if not self.type_validator.is_eth_hash(result["receiptsRoot"]):143                lcc.log_error("Wrong format of 'receiptsRoot', got: '{}'".format(result["receiptsRoot"]))144            else:145                lcc.log_info("'receiptsRoot' has correct format: hash")146            if not self.type_validator.is_eth_hash(result["miner"]):147                lcc.log_error("Wrong format of 'miner', got: '{}'".format(result["miner"]))148            else:149                lcc.log_info("'miner' has correct format: hash")150            if not self.type_validator.is_eth_hash(result["difficulty"]):151                lcc.log_error("Wrong format of 'difficulty', got: '{}'".format(result["difficulty"]))152            else:153                lcc.log_info("'difficulty' has correct format: hash")154            if not self.type_validator.is_eth_hash(result["totalDifficulty"]):155                lcc.log_error("Wrong format of 'totalDifficulty', got: '{}'".format(result["totalDifficulty"]))156            else:157                lcc.log_info("'totalDifficulty' has correct format: hash")158            if not self.type_validator.is_eth_hash(result["extraData"]):159                lcc.log_error("Wrong format of 'extraData', got: '{}'".format(result["extraData"]))160            else:161                lcc.log_info("'extraData' has correct format: hash")162            if not self.type_validator.is_eth_hash(result["size"]):163                lcc.log_error("Wrong format of 'size', got: '{}'".format(result["size"]))164            else:165                lcc.log_info("'size' has correct format: hash")166            if not self.type_validator.is_eth_hash(result["gasLimit"]):167                lcc.log_error("Wrong format of 'gasLimit', got: '{}'".format(result["gasLimit"]))168            else:169                lcc.log_info("'gasLimit' has correct format: hash")170            if not self.type_validator.is_eth_hash(result["gasUsed"]):171                lcc.log_error("Wrong format of 'gasUsed', got: '{}'".format(result["gasUsed"]))172            else:173                lcc.log_info("'gasUsed' has correct format: hash")174            if not self.type_validator.is_eth_hash(result["timestamp"]):175                lcc.log_error("Wrong format of 'timestamp', got: '{}'".format(result["timestamp"]))176            else:177                lcc.log_info("'timestamp' has correct format: hash")178            if check_that("uncles", result["uncles"], is_list()):179                if len(result["transactions"]) > 0:180                    for transaction in result["transactions"]:181                        self.validate_transaction(transaction)182    def setup_suite(self):183        self.passphrase = "Account"184        self.null_trx_hash = "0x0000000000000000000000000000000000000000000000000000000000000000"185        self.account_address = "0x000000000000000000000000000000000000000a"186        self.contract_address = "0x0100000000000000000000000000000000000001"187        self.time = "0xffff"188        self.SHA3_trx_hash = "0x68656c6c6f20776f726c64"189        self.value = "0xffff"190        self.contract = self.get_byte_code("code_contract_Callee", "code")191        self.initial_account = "0x000000000000000000000000000000000000000b"192        self.invalid_hex_encoded_signature = \193            "0x0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"194    def teardown_suite(self):195        pass196    @lcc.test("Check connection to ECHO test node")197    def main_check(self):198        message = {199            'code': -32600,200            'message': 'Missing or invalid method'201        }202        payload = self.rpc_call("", "")203        response = requests.post(TESTRPC_URL, json=payload).json()204        if require_that("json-rpc response", response, has_length(3)):205            require_that_in(response, "id", is_none(), "jsonrpc", equal_to("2.0"), "error", equal_to(message))206    @lcc.test("Check method 'miner_stop'")207    @lcc.depends_on("TestRPC.TestRPC.TestRPC.main_check")208    def miner_stop(self):209        payload = self.rpc_call("miner_stop", ["0x0"])210        response = self.get_response(payload)211        require_that("'result'", response["result"], is_none())212    @lcc.test("Check method 'miner_start'")213    @lcc.depends_on("TestRPC.TestRPC.TestRPC.miner_stop")214    def miner_start(self):215        payload = self.rpc_call("miner_start", ["0x0"])216        response = self.get_response(payload)217        require_that("'result'", response["result"], is_none())218    @lcc.test("Check method 'eth_mining'")219    @lcc.depends_on("TestRPC.TestRPC.TestRPC.miner_start")220    def eth_mining(self):221        payload = self.rpc_call("eth_mining", [])222        response = self.get_response(payload)223        require_that("'result'", response["result"], is_true())224    @lcc.test("Check method 'personal_newAccount'")225    @lcc.depends_on("TestRPC.TestRPC.TestRPC.main_check")226    def personal_new_account(self):227        payload = self.rpc_call("personal_newAccount", [self.passphrase])228        response = self.get_response(payload)229        if not self.type_validator.is_eth_address(response["result"]):230            lcc.log_error("Wrong format of 'result', got: {}".format(response["result"]))231        else:232            lcc.log_info("'result' has correct format: address")233            self.new_account_address = response["result"]234            return self.new_account_address235    @lcc.test("Check method 'personal_listAccounts'")236    @lcc.depends_on("TestRPC.TestRPC.TestRPC.main_check")237    def personal_list_accounts(self):238        payload = self.rpc_call("personal_listAccounts", [])239        results = self.get_response(payload)["result"]240        for result in results:241            if not self.type_validator.is_eth_address(result):242                lcc.log_error("Wrong format of 'result', got: {}".format(result))243            else:244                lcc.log_info("'result' has correct format: address")245    @lcc.test("Check method 'personal_listRawAccounts'")246    @lcc.depends_on("TestRPC.TestRPC.TestRPC.main_check")247    def personal_list_raw_accounts(self):248        payload = self.rpc_call("personal_listRawAccounts", [])249        results = self.get_response(payload)["result"]250        lcc.set_step("Check initialized accounts")251        for result in results[:2]:252            if not self.type_validator.is_eth_address(result["address"]):253                lcc.log_error("Wrong format of 'address', got: {}".format(result["address"]))254            else:255                lcc.log_info("'result' has correct format: address")256            if not self.type_validator.is_privkey(result["privkey"]):257                lcc.log_error("Wrong format of 'privkey', got: {}".format(result["privkey"]))258            else:259                lcc.log_info("'result' has correct format: privkey")260            check_that("passphrase", result["passphrase"], equal_to(""))261        lcc.set_step("Check created accounts")262        for result in results[2:]:263            if not self.type_validator.is_eth_address(result["address"]):264                lcc.log_error("Wrong format of 'address', got: {}".format(result["address"]))265            else:266                lcc.log_info("'result' has correct format: address")267            if not self.type_validator.is_privkey(result["privkey"]):268                lcc.log_error("Wrong format of 'privkey', got: {}".format(result["privkey"]))269            else:270                lcc.log_info("'result' has correct format: privkey")271            check_that("passphrase", result["passphrase"], equal_to(self.passphrase))272    @lcc.test("Check method 'eth_accounts'")273    @lcc.depends_on("TestRPC.TestRPC.TestRPC.main_check")274    def eth_accounts(self):275        payload = self.rpc_call("eth_accounts", [])276        results = self.get_response(payload)["result"]277        for account_address in results:278            if not self.type_validator.is_eth_address(account_address):279                lcc.log_error("Wrong format of 'address', got: {}".format(account_address))280            else:281                lcc.log_info("'result' has correct format: address")282    @lcc.test("Check method 'personal_lockAccount'")283    @lcc.depends_on("TestRPC.TestRPC.TestRPC.main_check")284    def personal_lock_account(self):285        payload = self.rpc_call("personal_lockAccount", [self.account_address])286        response = self.get_response(payload)287        require_that("'result'", response["result"], is_true())288    @lcc.test("Check method 'personal_unlockAccount'")289    @lcc.depends_on("TestRPC.TestRPC.TestRPC.personal_lock_account")290    def personal_unlock_account(self):291        payload = self.rpc_call("personal_unlockAccount", [self.account_address, self.passphrase, self.time])292        response = self.get_response(payload)293        require_that("'result'", response["result"], is_false())294    @lcc.test("Check method 'personal_sendTransaction'")295    @lcc.depends_on("TestRPC.TestRPC.TestRPC.personal_new_account")296    def personal_send_transaction(self):297        payload = self.rpc_call(298            "personal_sendTransaction", [{299                "from": self.account_address,300                "to": self.new_account_address,301                "value": self.value302            }, ""]303        )304        response = self.get_response(payload)305        if not self.type_validator.is_hex(response["result"]):306            lcc.log_error("Wrong format of 'result', got: '{}'".format(response["result"]))307        else:308            lcc.log_info("'result' has correct format: hex")309    @lcc.test("Check method 'eth_sign'")310    @lcc.depends_on("TestRPC.TestRPC.TestRPC.main_check")311    def eth_sign(self):312        payload = self.rpc_call("eth_sign", [self.initial_account, "0xdeadbaaf"])313        response = self.get_response(payload)314        require_that("'result'", response["result"], not_equal_to(self.invalid_hex_encoded_signature))315        if not self.type_validator.is_hex(response["result"]):316            lcc.log_error("Wrong format of 'result', got: '{}'".format(response["result"]))317        else:318            lcc.log_info("'result' has correct format: hex")319    @lcc.disabled()320    @lcc.test("Check method 'eth_sendTransaction'")321    @lcc.depends_on("TestRPC.TestRPC.TestRPC.main_check")322    def eth_send_transaction(self):323        payload = self.rpc_call(324            "eth_sendTransaction", [{325                "from": "0x0000000000000000000000000000000000000006",326                "to": "0x0000000000000000000000000000000000000007",327                "value": "0xfff"328            }]329        )330        response = self.get_response(payload)331        require_that("'result'", response["result"], not_equal_to(self.null_trx_hash))332        if not self.type_validator.is_hex(response["result"]):333            lcc.log_error("Wrong format of 'result', got: '{}'".format(response["result"]))334        else:335            lcc.log_info("'result' has correct format: hex")336    @lcc.test("Check method 'web3_clientVersion'")337    @lcc.depends_on("TestRPC.TestRPC.TestRPC.main_check")338    def web3_client_version(self):339        payload = self.rpc_call("web3_clientVersion", [])340        response = self.get_response(payload)341        client_version_parts = response["result"].split("/")342        require_that("'first part of web3 client version", client_version_parts[0], equal_to("ECHO"))343        echo_version_parts = client_version_parts[1].split(".")344        require_that("'version of echo splitted by dot have length", len(echo_version_parts), greater_than(2))345        require_that("'third part of web3 client version", client_version_parts[2], equal_to("Linux.64-bit"))346    @lcc.test("Check method 'web3_sha3'")347    @lcc.depends_on("TestRPC.TestRPC.TestRPC.main_check")348    def web3_sha3(self):349        payload = self.rpc_call("web3_sha3", [self.SHA3_trx_hash])350        response = self.get_response(payload)351        if not self.type_validator.is_SHA3_256(response["result"]):352            lcc.log_error("Wrong format of 'result', got: '{}'".format(response["result"]))353        else:354            lcc.log_info("'result' has correct format: hex")355    @lcc.test("Check method 'net_version'")356    @lcc.depends_on("TestRPC.TestRPC.TestRPC.main_check")357    def net_version(self):358        payload = self.rpc_call("net_version", [])359        response = self.get_response(payload)360        require_that("'result'", response["result"], equal_to("255"))361    @lcc.test("Check method 'net_listening'")362    @lcc.depends_on("TestRPC.TestRPC.TestRPC.main_check")363    def net_listening(self):364        payload = self.rpc_call("net_listening", [])365        response = self.get_response(payload)366        require_that("'result'", response["result"], is_true())367    @lcc.test("Check method 'net_peerCount'")368    @lcc.depends_on("TestRPC.TestRPC.TestRPC.main_check")369    def net_peer_count(self):370        payload = self.rpc_call("net_peerCount", [])371        response = self.get_response(payload)372        require_that("'result'", response["result"], equal_to("0x00"))373    @lcc.test("Check method 'eth_protocolVersion'")374    @lcc.depends_on("TestRPC.TestRPC.TestRPC.main_check")375    def eth_protocol_version(self):376        payload = self.rpc_call("eth_protocolVersion", [])377        response = self.get_response(payload)378        require_that("'result'", response["result"], equal_to("0x3f"))379    @lcc.test("Check method 'eth_syncing'")380    @lcc.depends_on("TestRPC.TestRPC.TestRPC.main_check")381    def eth_syncing(self):382        payload = self.rpc_call("eth_syncing", [])383        response = self.get_response(payload)384        require_that("'result'", response["result"], is_false())385    @lcc.test("Check method 'eth_coinbase'")386    @lcc.depends_on("TestRPC.TestRPC.TestRPC.main_check")387    def eth_coinbase(self):388        payload = self.rpc_call("eth_coinbase", [])389        response = self.get_response(payload)390        require_that("'result'", response["result"], equal_to(self.account_address))391    @lcc.test("Check method 'eth_gasPrice'")392    @lcc.depends_on("TestRPC.TestRPC.TestRPC.main_check")393    def eth_gas_price(self):394        payload = self.rpc_call("eth_gasPrice", [])395        response = self.get_response(payload)396        require_that("'result'", response["result"], equal_to("0x01"))397    @lcc.test("Check method 'eth_block_number'")398    @lcc.depends_on("TestRPC.TestRPC.TestRPC.main_check")399    def eth_block_number(self):400        payload = self.rpc_call("eth_blockNumber", [])401        response = self.get_response(payload)402        if not self.type_validator.is_eth_block_number(response["result"]):403            lcc.log_error("Wrong format of 'eth_blockNumber', got: '{}'".format(response["result"]))404        else:405            lcc.log_info("'result' has correct format: eth_blockNumber")406    @lcc.test("Check method 'eth_getBalance'")407    @lcc.depends_on("TestRPC.TestRPC.TestRPC.main_check")408    def eth_get_balance(self):409        payload = self.rpc_call("eth_getBalance", [self.account_address, "latest"])410        response = self.get_response(payload)411        if not self.type_validator.is_eth_balance(response["result"]):412            lcc.log_error("Wrong format of 'eth_balance', got: '{}'".format(response["result"]))413        else:414            lcc.log_info("'result' has correct format: eth_balance")415    @lcc.disabled()416    @lcc.test("Check method 'eth_getStorageAt'")417    @lcc.depends_on("TestRPC.TestRPC.TestRPC.personal_send_transaction")418    def eth_get_storage_at(self):419        self.create_contract()420        payload = self.rpc_call(421            "eth_getStorageAt",422            [self.contract_address, "0x6661e9d6d8b923d5bbaab1b96e1dd51ff6ea2a93520fdc9eb75d059238b8c5e9", "latest"]423        )424        response = self.get_response(payload)425        require_that("'result'", response["result"], not_equal_to(self.null_trx_hash))426    @lcc.test("Check method 'eth_getTransactionCount'")427    @lcc.depends_on("TestRPC.TestRPC.TestRPC.main_check")428    def eth_get_transaction_count(self):429        payload = self.rpc_call("eth_getTransactionCount", [self.account_address, "latest"])430        response = self.get_response(payload)431        if not self.type_validator.is_eth_hash(response["result"]):432            lcc.log_error("Wrong format of 'count', got: '{}'".format(response["result"]))433        else:434            lcc.log_info("'count' has correct format: eth_hash")435    @lcc.test("Check method 'eth_getBlockTransactionCountByHash'")436    @lcc.depends_on("TestRPC.TestRPC.TestRPC.main_check")437    def eth_get_block_transaction_count_by_trx_hash(self):438        self.transfer()439        block_id = self.get_response(self.rpc_call("eth_blockNumber", []))440        block_hash = self.get_response(self.rpc_call("eth_getBlockByNumber",441                                                     [block_id["result"], True]))["result"]["hash"]442        payload = self.rpc_call("eth_getBlockTransactionCountByHash", [block_hash])443        response = self.get_response(payload)444        require_that("'result'", response["result"], equal_to("0x01"))445    @lcc.test("Check method 'eth_getCode'")446    @lcc.depends_on("TestRPC.TestRPC.TestRPC.main_check")447    def eth_get_code(self):448        self.create_contract()449        self.create_contract()450        payload = self.rpc_call("eth_getCode", [self.contract_address, "0x02"])451        response = self.get_response(payload)452        require_that("'result'", response["result"][2:], equal_to(self.contract[58:]))453    @lcc.disabled()454    @lcc.test("Check method 'eth_sendRawTransaction'")455    @lcc.depends_on("TestRPC.TestRPC.TestRPC.main_check")456    def eth_send_raw_transaction(self):457        trx_hash = self.create_contract()458        payload = self.rpc_call("eth_sendRawTransaction", [trx_hash])459        response = self.get_response(payload)460        require_that("'result'", response["result"], equal_to("0x01"))461    @lcc.test("Check method 'eth_call'")462    @lcc.depends_on("TestRPC.TestRPC.TestRPC.personal_new_account")463    def eth_call(self):464        self.create_contract()465        payload = self.rpc_call(466            "eth_call", [{467                "from": self.new_account_address,468                "to": "0x0100000000000000000000000000000000000000"469            }, "latest"]470        )471        response = self.get_response(payload)472        require_that("'result'", response["result"], equal_to("0x"))473    @lcc.test("Check method 'eth_estimateGas'")474    @lcc.depends_on("TestRPC.TestRPC.TestRPC.main_check")475    def eth_estimate_gas(self):476        payload = self.rpc_call("eth_estimateGas", [{477            "from": self.account_address,478            "data": self.contract,479        }])480        response = self.get_response(payload)481        if not self.type_validator.is_eth_balance(response["result"]):482            lcc.log_error("Wrong format of 'gas', got: '{}'".format(response["result"]))483        else:484            lcc.log_info("'result' has correct format: gas")485    @lcc.test("Check method 'eth_getBlockByHash'")486    @lcc.depends_on("TestRPC.TestRPC.TestRPC.eth_block_number")487    def eth_get_block_by_trx_hash(self):488        self.transfer()489        block_id = self.get_response(self.rpc_call("eth_blockNumber", []))490        block_hash = self.get_response(self.rpc_call("eth_getBlockByNumber",491                                                     [block_id["result"], True]))["result"]["hash"]492        payload = self.rpc_call("eth_getBlockByHash", [block_hash, True])493        result = self.get_response(payload)["result"]494        self.validate_block(result)495    @lcc.test("Check method 'eth_getBlockByNumber'")496    @lcc.depends_on("TestRPC.TestRPC.TestRPC.eth_block_number")497    def eth_get_block_by_number(self):498        self.transfer()499        block_id = self.get_response(self.rpc_call("eth_blockNumber", []))500        payload = self.rpc_call("eth_getBlockByNumber", [block_id["result"], True])501        result = self.get_response(payload)["result"]502        self.validate_block(result)503    @lcc.test("Check method 'eth_getTransactionByHash'")504    @lcc.depends_on("TestRPC.TestRPC.TestRPC.main_check")505    def eth_get_transaction_by_hash(self):506        trx_hash = self.transfer()507        payload = self.rpc_call("eth_getTransactionByHash", [trx_hash])508        result = self.get_response(payload)["result"]509        self.validate_transaction(result)510    @lcc.test("Check method 'eth_getTransactionByBlockHashAndIndex'")511    @lcc.depends_on("TestRPC.TestRPC.TestRPC.main_check")512    def eth_get_transaction_by_hash_and_index(self):513        self.transfer()514        block_id = self.get_response(self.rpc_call("eth_blockNumber", []))515        block_hash = self.get_response(self.rpc_call("eth_getBlockByNumber",516                                                     [block_id["result"], True]))["result"]["hash"]517        payload = self.rpc_call("eth_getTransactionByBlockHashAndIndex", [block_hash, "0x00"])518        result = self.get_response(payload)["result"]519        self.validate_transaction(result)520    @lcc.test("Check method 'eth_getTransactionReceipt'")521    @lcc.depends_on("TestRPC.TestRPC.TestRPC.main_check")522    def eth_get_transaction_receipt(self):523        self.create_contract()524        block_id = self.get_response(self.rpc_call("eth_blockNumber", []))525        trx_hash = self.get_response(self.rpc_call("eth_getBlockByNumber",526                                                   [block_id["result"], True]))["result"]["transactions"][0]["hash"]527        payload = self.rpc_call("eth_getTransactionReceipt", [trx_hash])528        result = self.get_response(payload)["result"]529        if require_that("'result'", result, has_length(12)):530            if not self.type_validator.check_hash_by_bytes(result["transactionHash"], 32):531                lcc.log_error("Wrong format of 'transactionHash', got: '{}'".format(result["transactionHash"]))532            else:533                lcc.log_info("'transactionHash' has correct format: trx_hash")534            if not self.type_validator.is_eth_hash(result["transactionIndex"]):535                lcc.log_error("Wrong format of 'transactionIndex', got: '{}'".format(result["transactionIndex"]))536            else:537                lcc.log_info("'transactionIndex' has correct format: trx_hash")538            if not self.type_validator.is_eth_hash(result["transactionIndex"]):539                lcc.log_error("Wrong format of 'transactionIndex', got: '{}'".format(result["transactionIndex"]))540            else:541                lcc.log_info("'transactionIndex' has correct format: trx_hash")542            check_that('from', result["from"], equal_to(self.account_address))543            check_that('to', result["to"], is_none())544            if not self.type_validator.is_eth_hash(result["cumulativeGasUsed"]):545                lcc.log_error("Wrong format of 'cumulativeGasUsed', got: '{}'".format(result["cumulativeGasUsed"]))546            else:547                lcc.log_info("'cumulativeGasUsed' has correct format: trx_hash")548            if not self.type_validator.is_eth_hash(result["gasUsed"]):549                lcc.log_error("Wrong format of 'gasUsed', got: '{}'".format(result["gasUsed"]))550            else:551                lcc.log_info("'gasUsed' has correct format: trx_hash")552            check_that('logs', result["logs"], is_list())553            if not self.type_validator.is_digit(result["logsBloom"]):554                lcc.log_error("Wrong format of 'logsBloom', got: '{}'".format(result["logsBloom"]))555            else:556                lcc.log_info("'logsBloom' has correct format: trx_hash")557            check_that('status', result["status"], equal_to("0x01"))558    @lcc.test("Check method 'eth_pendingTransactions'")559    @lcc.depends_on("TestRPC.TestRPC.TestRPC.main_check")560    def eth_pending_transactions(self):561        self.create_contract()562        payload = self.rpc_call("eth_pendingTransactions", [])563        response = self.get_response(payload)564        require_that("'result'", response["result"], is_list())565    @lcc.test("Check method 'echo_requestRegistrationTask'")566    @lcc.depends_on("TestRPC.TestRPC.TestRPC.main_check")567    def echo_request_registration_task(self):568        payload = self.rpc_call("echo_requestRegistrationTask", [])569        response = self.get_response(payload)["result"]570        if not self.type_validator.is_eth_hash(response["blockId"]):571            lcc.log_error("Wrong format of 'blockId', got: '{}'".format(response["blockId"]))572        else:573            lcc.log_info("'blockId' has correct format: eth_hash")574        if not self.type_validator.is_eth_hash(response["randNum"]):575            lcc.log_error("Wrong format of 'randNum', got: '{}'".format(response["randNum"]))576        else:577            lcc.log_info("'randNum' has correct format: eth_hash")578        if not self.type_validator.is_eth_hash(response["difficulty"]):579            lcc.log_error("Wrong format of 'difficulty', got: '{}'".format(response["difficulty"]))580        else:581            lcc.log_info("'difficulty' has correct format: eth_hash")582    @lcc.test("Check method 'echo_submitRegistrationSolution'")583    @lcc.depends_on("TestRPC.TestRPC.TestRPC.echo_request_registration_task")584    def echo_submit_registration_solution(self, get_random_valid_account_name):585        payload = self.rpc_call("echo_requestRegistrationTask", [])586        response = self.get_response(payload)["result"]587        block_id_right160 = response["blockId"][26:]588        rand_num_decimal = int(response["randNum"].lstrip("0x"), 16)589        difficulty = int(response["difficulty"].lstrip("0x"), 16)590        nonce = self.echo.solve_registration_task(block_id_right160, rand_num_decimal, difficulty)591        nonce_hex = hex(nonce)592        account_name = get_random_valid_account_name593        evm_address = None594        active_key = echorand_key = "ECHOHCcqrvESxeg4Kmmpr73FdQSQR6TbusCMsHeuXvx2rM1G"595        rand_num = response["randNum"]596        payload = self.rpc_call(597            "echo_submitRegistrationSolution",598            [account_name, active_key, echorand_key, evm_address, nonce_hex, rand_num]599        )600        response = self.get_response(payload)601        if not self.type_validator.is_eth_hash(response["result"]):602            lcc.log_error("Wrong format of 'difficulty', got: '{}'".format(response["difficulty"]))603        else:604            lcc.log_info("'difficulty' has correct format: eth_hash")605    @lcc.test("Check method 'evm_increaseTime'")606    @lcc.depends_on("TestRPC.TestRPC.TestRPC.main_check")607    def evm_increase_time(self):608        payload = self.rpc_call("evm_increaseTime", [60])609        response = self.get_response(payload)["result"]610        if not self.type_validator.is_eth_hash(response):611            lcc.log_error("Wrong format of 'increaseTime', got: '{}'".format(response))612        else:613            lcc.log_info("'increaseTime' has correct format: eth_hash")614    @lcc.test("Check method 'evm_mine'")615    @lcc.depends_on("TestRPC.TestRPC.TestRPC.main_check")616    def evm_mine(self):617        lcc.log_info("Get block number before method ''evm_mine")618        block_id = self.get_response(self.rpc_call("eth_blockNumber", []))619        block_number_before = self.get_response(self.rpc_call("eth_getBlockByNumber",620                                                              [block_id["result"], True]))["result"]["number"]621        lcc.log_info("Call method 'evm_mine'")622        payload = self.rpc_call("evm_mine", [])623        result = self.get_response(payload)["result"]624        require_that('result', result, is_none())625        lcc.log_info("Get block number after method ''evm_mine")626        block_id = self.get_response(self.rpc_call("eth_blockNumber", []))627        block_number_after = self.get_response(self.rpc_call("eth_getBlockByNumber",628                                                             [block_id["result"], True]))["result"]["number"]629        lcc.log_info("Block number {}".format(block_number_after))...

ERC20.py

Source:ERC20.py

...84        lcc.log_info("ERC20 contract created in Ethereum network, address: '{}'".format(self.erc20_contract.address))85        lcc.set_step("Get ethereum account ERC20 tokens balance in the Ethereum network")86        self.in_ethereum_erc20_balance = self.eth_trx.get_balance_of(self.erc20_contract, self.eth_account.address)87        self.in_ethereum_start_erc20_balance = self.in_ethereum_erc20_balance88        require_that("'in ethereum owner's erc20 balance'", self.in_ethereum_erc20_balance, greater_than(0))89        lcc.set_step("Perform register erc20 token operation")90        bd_result = \91            self.utils.perform_sidechain_erc20_register_token_operation(self, account=self.new_account,92                                                                        eth_addr=self.erc20_contract.address,93                                                                        name=name, symbol=symbol,94                                                                        database_api_id=self.__database_api_identifier)95        self.erc20_token_id = self.get_contract_result(bd_result, self.__database_api_identifier)96        lcc.log_info(97            "Registration of ERC20 token completed successfully, ERC20 token object is '{}'".format(98                self.erc20_token_id99            )100        )101        lcc.set_step("Get created ERC20 token and store contract id in the ECHO network")102        response_id = self.send_request(103            self.get_request("get_erc20_token", [self.erc20_contract.address[2:]]), self.__database_api_identifier104        )105        self.erc20_contract_id = self.get_response(response_id)["result"]["contract"]106        lcc.log_info("ERC20 token has id '{}' and contract_id '{}'".format(self.erc20_token_id, self.erc20_contract_id))107    @lcc.test("The scenario entering erc20 tokens to the echo account")108    @lcc.depends_on("API.SideChain.ERC20.ERC20.erc20_sidechain_pre_run_scenario")109    def erc20_in_scenario(self):110        erc20_deposit_amounts = []111        lcc.set_step("First transfer erc20 to ethereum address of created account")112        erc20_deposit_amounts.append(self.get_random_amount(_to=self.in_ethereum_erc20_balance))113        self.eth_trx.transfer(self.web3, self.erc20_contract, self.eth_account_address, erc20_deposit_amounts[0])114        lcc.log_info(115            "Transfer '{}' erc20 tokens to '{}' account completed successfully".format(116                erc20_deposit_amounts[0], self.eth_account_address117            )118        )119        lcc.set_step("First: Get ERC20 account deposits")120        deposits = \121            self.utils.get_erc20_account_deposits(self, self.new_account, self.__database_api_identifier)["result"]122        require_that("'account deposits'", deposits, has_length(len(erc20_deposit_amounts)))123        for i, deposit in enumerate(deposits):124            deposit_value = deposit["value"]125            require_that(126                "'account deposit value #'{}''".format(i), deposit_value, equal_to(str(erc20_deposit_amounts[i]))127            )128        lcc.set_step("Get ERC20 token balance of account in the ECHO network and check result")129        in_echo_erc20_balance = \130            self.utils.get_erc20_token_balance_in_echo(self, account_id=self.new_account,131                                                       balance_of_method=self.erc20_balanceOf,132                                                       contract_id=self.erc20_contract_id,133                                                       database_api_id=self.__database_api_identifier)134        require_that("'in echo account's erc20 balance'", in_echo_erc20_balance, equal_to(erc20_deposit_amounts[0]))135        lcc.set_step("Get updated ethereum account ERC20 tokens balance in the Ethereum network")136        updated_in_ethereum_erc20_balance = self.eth_trx.get_balance_of(self.erc20_contract, self.eth_account.address)137        require_that(138            "'in ethereum owner's erc20 balance'", updated_in_ethereum_erc20_balance,139            equal_to(self.in_ethereum_erc20_balance - erc20_deposit_amounts[0])140        )141        lcc.set_step("Second transfer erc20 to ethereum address of created account")142        erc20_deposit_amounts.append(self.get_random_amount(_to=updated_in_ethereum_erc20_balance))143        self.eth_trx.transfer(self.web3, self.erc20_contract, self.eth_account_address, erc20_deposit_amounts[1])144        lcc.log_info(145            "Transfer '{}' erc20 tokens to '{}' account completed successfully".format(146                erc20_deposit_amounts[1], self.eth_account_address147            )148        )149        lcc.set_step("Second: Get ERC20 account deposits")150        import time151        time.sleep(3)152        deposits = self.utils.get_erc20_account_deposits(153            self, self.new_account, self.__database_api_identifier, previous_account_deposits=deposits154        )["result"]155        require_that("'account deposits'", deposits, has_length(len(erc20_deposit_amounts)))156        for i, deposit in enumerate(deposits):157            deposit_value = deposit["value"]158            require_that(159                "'account deposit value #'{}''".format(i), deposit_value, equal_to(str(erc20_deposit_amounts[i]))160            )161        lcc.set_step("Get ERC20 token balance of account in the ECHO network and check result")162        in_echo_erc20_balance = \163            self.utils.get_erc20_token_balance_in_echo(self, account_id=self.new_account,164                                                       balance_of_method=self.erc20_balanceOf,165                                                       contract_id=self.erc20_contract_id,166                                                       database_api_id=self.__database_api_identifier)167        require_that(168            "'in echo account's erc20 balance'", in_echo_erc20_balance,169            equal_to(erc20_deposit_amounts[0] + erc20_deposit_amounts[1])170        )171        lcc.set_step("Get final ethereum account ERC20 tokens balance in the Ethereum network")172        final_in_ethereum_erc20_balance = self.eth_trx.get_balance_of(self.erc20_contract, self.eth_account.address)173        require_that(174            "'in ethereum owner'serc20 balance'", final_in_ethereum_erc20_balance,175            equal_to(updated_in_ethereum_erc20_balance - erc20_deposit_amounts[1])176        )177        self.in_echo_erc20_balance = in_echo_erc20_balance178        self.in_ethereum_erc20_balance = final_in_ethereum_erc20_balance179        lcc.set_step("Get ERC20 tokens of 'sidechain_erc20_issue_operation'")180        operation_id = self.echo.config.operation_ids.SIDECHAIN_ERC20_ISSUE181        operation_history_obj = "{}0".format(self.get_object_type(self.echo.config.object_types.OPERATION_HISTORY))182        stop, start = operation_history_obj, operation_history_obj183        limit = 100184        params = [self.new_account, operation_id, start, stop, limit]185        response_id = self.send_request(186            self.get_request("get_account_history_operations", params), self.__history_api_identifier187        )188        history_operations = self.get_response(response_id)["result"]189        lcc.log_info(190            "Call method 'get_account_history' with: account='{}', operation_id='{}', stop='{}', limit='{}', "191            "start='{}' parameters".format(self.new_account, operation_id, stop, limit, start)192        )193        lcc.set_step("Check ERC20 tokens of 'sidechain_erc20_issue_operation'")194        deposits.reverse()195        for i, history_operation in enumerate(history_operations):196            sidechain_erc20_issue_operation = history_operation["op"]197            if check_that("'sidechain_erc20_issue_operation'", sidechain_erc20_issue_operation[1], has_length(5)):198                check_that_in(199                    sidechain_erc20_issue_operation[1],200                    "deposit",201                    is_(deposits[i]["id"]),202                    "account",203                    is_(deposits[i]["account"]),204                    "amount",205                    is_(deposits[i]["value"]),206                    "extensions",207                    is_list(),208                    quite=True209                )210                if not self.type_validator.is_erc20_object_id(sidechain_erc20_issue_operation[1]["token"]):211                    lcc.log_error(212                        "Wrong format of 'token', got: {}".format(sidechain_erc20_issue_operation[1]["token"])213                    )214                else:215                    lcc.log_info("'operation_id' has correct format: erc20_token_object_type")216    @lcc.test("The scenario withdrawing erc20 tokens from the echo account")217    @lcc.depends_on("API.SideChain.ERC20.ERC20.erc20_in_scenario")218    def erc20_out_scenario(self):219        erc20_withdraw_amounts = []220        withdraw_erc20_token_ids = []221        lcc.set_step("Get ERC20 balance in the ECHO network")222        if self.in_echo_erc20_balance <= 0:223            raise Exception("No ERC20 balance to withdraw")224        lcc.log_info("ERC20 balance in ECHO network: '{}'".format(self.in_echo_erc20_balance))225        lcc.log_info("ERC20 balance in Ethereum network: '{}'".format(self.in_ethereum_erc20_balance))226        lcc.set_step("Perform first withdraw ERC20 token operation")227        erc20_withdraw_amounts.append(str(self.get_random_amount(_to=self.in_echo_erc20_balance)))228        bd_result = \229            self.utils.perform_sidechain_erc20_withdraw_token_operation(self, account=self.new_account,230                                                                        to=self.eth_account.address,231                                                                        erc20_token=self.erc20_token_id,232                                                                        value=erc20_withdraw_amounts[0],233                                                                        database_api_id=self.__database_api_identifier)234        withdraw_erc20_token_ids.append(self.get_operation_results_ids(bd_result))235        lcc.log_info(236            "Withdraw ERC20 token completed successfully, Withdraw ERC20 token object is '{}'".format(237                withdraw_erc20_token_ids[0]238            )239        )240        lcc.set_step("Get ERC20 account withdrawals")241        withdrawals = \242            self.utils.get_erc20_account_withdrawals(self, self.new_account, self.__database_api_identifier)["result"]243        require_that("'account withdrawals'", withdrawals, has_length(len(erc20_withdraw_amounts)))244        for i, withdraw in enumerate(withdrawals):245            lcc.log_info("Check account withdraw #'{}'".format(i))246            check_that_in(247                withdraw, "id", equal_to(withdraw_erc20_token_ids[i]), "value",248                equal_to(str(erc20_withdraw_amounts[i]))249            )250        lcc.set_step("Get ERC20 token balance of account in the ECHO network and check result")251        in_echo_erc20_balance = \252            self.utils.get_erc20_token_balance_in_echo(self, account_id=self.new_account,253                                                       balance_of_method=self.erc20_balanceOf,254                                                       contract_id=self.erc20_contract_id,255                                                       database_api_id=self.__database_api_identifier)256        require_that(257            "'in echo account's erc20 balance'", in_echo_erc20_balance,258            equal_to(self.in_echo_erc20_balance - int(erc20_withdraw_amounts[0]))259        )260        lcc.set_step("Get updated ethereum account ERC20 tokens balance in the Ethereum network")261        updated_in_ethereum_erc20_balance = \262            self.utils.get_updated_account_erc20_balance_in_eth_network(self, self.erc20_contract,263                                                                        self.eth_account.address,264                                                                        self.in_ethereum_erc20_balance,265                                                                        self.__database_api_identifier)266        require_that(267            "'in ethereum owner'serc20 balance'", updated_in_ethereum_erc20_balance,268            equal_to(self.in_ethereum_erc20_balance + int(erc20_withdraw_amounts[0]))269        )270        lcc.set_step("Perform second withdraw ERC20 token operation to withdraw all ERC20 balance")271        erc20_withdraw_amounts.append(str(in_echo_erc20_balance))272        bd_result = \273            self.utils.perform_sidechain_erc20_withdraw_token_operation(self, account=self.new_account,274                                                                        to=self.eth_account.address,275                                                                        erc20_token=self.erc20_token_id,276                                                                        value=erc20_withdraw_amounts[1],277                                                                        database_api_id=self.__database_api_identifier)278        withdraw_erc20_token_ids.append(self.get_operation_results_ids(bd_result))279        lcc.log_info(280            "Withdraw ERC20 token completed successfully, Withdraw ERC20 token object is '{}'".format(281                withdraw_erc20_token_ids[1]282            )283        )284        lcc.set_step("Get ERC20 account withdrawals")285        withdrawals = \286            self.utils.get_erc20_account_withdrawals(self, self.new_account, self.__database_api_identifier)["result"]287        require_that("'account withdrawals'", withdrawals, has_length(len(erc20_withdraw_amounts)))288        for i, withdraw in enumerate(withdrawals):289            lcc.log_info("Check account withdraw #'{}'".format(i))290            check_that_in(291                withdraw, "id", equal_to(withdraw_erc20_token_ids[i]), "value",292                equal_to(str(erc20_withdraw_amounts[i]))293            )294        lcc.set_step("Get ERC20 token balance of account in the ECHO network and check result")295        updated_in_echo_erc20_balance = \296            self.utils.get_erc20_token_balance_in_echo(self, account_id=self.new_account,297                                                       balance_of_method=self.erc20_balanceOf,298                                                       contract_id=self.erc20_contract_id,299                                                       database_api_id=self.__database_api_identifier)300        require_that(301            "'in echo account's erc20 balance'", updated_in_echo_erc20_balance,302            equal_to(in_echo_erc20_balance - int(erc20_withdraw_amounts[1]))303        )304        lcc.set_step("Get final ethereum account ERC20 tokens balance in the Ethereum network")305        final_in_ethereum_erc20_balance = \306            self.utils.get_updated_account_erc20_balance_in_eth_network(self, self.erc20_contract,307                                                                        self.eth_account.address,308                                                                        self.in_ethereum_erc20_balance,309                                                                        self.__database_api_identifier)310        require_that(311            "'in ethereum owner'serc20 balance'", final_in_ethereum_erc20_balance,312            equal_to(updated_in_ethereum_erc20_balance + int(erc20_withdraw_amounts[1]))313        )314        require_that(315            "'final balance equal to start balance'",316            final_in_ethereum_erc20_balance == self.in_ethereum_start_erc20_balance, is_true()317        )318        lcc.set_step("Get ERC20 burn token")319        operation_id = self.echo.config.operation_ids.SIDECHAIN_ERC20_BURN320        operation_history_obj = "{}0".format(self.get_object_type(self.echo.config.object_types.OPERATION_HISTORY))321        stop, start = operation_history_obj, operation_history_obj322        limit = 100323        params = [self.new_account, operation_id, start, stop, limit]324        response_id = self.send_request(325            self.get_request("get_account_history_operations", params), self.__history_api_identifier326        )327        history_operations = self.get_response(response_id)["result"]328        lcc.log_info(...

selection.py

Source:selection.py

...161        the :py:func:`lemoncheesecake.matching.require_that` function.162        :param expected: a ``Matcher`` instance whose ``matches`` method will be called with163            the ``WebElement`` that has been found164        """165        require_that(str(self), self, HasElement(expected))166    def require_no_element(self):167        """168        Check that the element is not present using169        the :py:func:`lemoncheesecake.matching.require_that` function.170        """171        require_that(str(self), self, not_(HasElement(is_in_page())))172    def assert_element(self, expected: Matcher):173        """174        Check that the element matches ``expected`` using175        the :py:func:`lemoncheesecake.matching.assert_that` function.176        :param expected: a ``Matcher`` instance whose ``matches`` method will be called with177            the ``WebElement`` that has been found178        """179        assert_that(str(self), self, HasElement(expected))180    def assert_no_element(self):181        """182        Check that the element is not present using183        the :py:func:`lemoncheesecake.matching.assert_that` function.184        """185        assert_that(str(self), self, not_(HasElement(is_in_page())))...

Config.py

Source:Config.py

...35        }36        return payload37    def get_response(self, payload):38        response = requests.post(ETHRPC_URL, json=payload).json()39        if require_that("eth-rpc response", response, has_length(3)):40            require_that_in(response, "id", is_integer(), "jsonrpc", equal_to("2.0"))41            return response42    def create_contract(self):43        payload = self.rpc_call(44            "personal_sendTransaction", [{45                "from": self.account_address,46                "data": self.contract,47            }, ""]48        )49        trx_hash = self.get_response(payload)["result"]50        return trx_hash51    def setup_suite(self):52        self.passphrase = "Account"53        self.null_trx_hash = "0x0000000000000000000000000000000000000000000000000000000000000000"54        self.account_address = "0x0000000000000000000000000000000000000006"55        self.new_account_address = "0x0000000000000000000000000000000000000007"56        self.contract_address = "0x0100000000000000000000000000000000000001"57        self.time = "0xffff"58        self.SHA3_trx_hash = "0x68656c6c6f20776f726c64"59        self.value = "0xffff"60        self.contract = self.get_byte_code("piggy", "code")61    def teardown_suite(self):62        pass63    @lcc.test("Check connection to EthPRC interface")64    def main_check(self):65        message = {66            'code': -32600,67            'message': 'Missing or invalid method'68        }69        payload = self.rpc_call("", "")70        response = requests.post(ETHRPC_URL, json=payload).json()71        if require_that("json-rpc response", response, has_length(3)):72            require_that_in(response, "id", is_none(), "jsonrpc", equal_to("2.0"), "error", equal_to(message))73    @lcc.test("Check method 'web3_clientVersion'")74    @lcc.depends_on("EthRPC.Config.Config.main_check")75    def web3_client_version(self):76        payload = self.rpc_call("web3_clientVersion", [])77        response = self.get_response(payload)78        client_version_parts = response["result"].split("/")79        require_that("'first part of web3 client version", client_version_parts[0], equal_to("ECHO"))80        echo_version_parts = client_version_parts[1].split(".")81        require_that("'version of echo splitted by dot have length", len(echo_version_parts), greater_than(2))82        require_that("'third part of web3 client version", client_version_parts[2], equal_to("Linux.64-bit"))83    @lcc.test("Check method 'eth_chain_id'")84    @lcc.depends_on("EthRPC.Config.Config.main_check")85    def eth_chain_id(self):86        chain_id = "0xff"87        payload = self.rpc_call("eth_chainId", [])88        response = self.get_response(payload)89        require_that("'result'", response["result"], equal_to(chain_id))90    @lcc.test("Check method 'web3_sha3'")91    @lcc.depends_on("EthRPC.Config.Config.main_check")92    def web3_sha3(self):93        payload = self.rpc_call("web3_sha3", [self.SHA3_trx_hash])94        response = self.get_response(payload)95        if not self.type_validator.is_SHA3_256(response["result"]):96            lcc.log_error("Wrong format of 'result', got: '{}'".format(response["result"]))97        else:98            lcc.log_info("'result' has correct format: hex")99    @lcc.test("Check method 'net_version'")100    @lcc.depends_on("EthRPC.Config.Config.main_check")101    def net_version(self):102        payload = self.rpc_call("net_version", [])103        response = self.get_response(payload)104        require_that("'result'", response["result"], equal_to("255"))105    @lcc.test("Check method 'net_listening'")106    @lcc.depends_on("EthRPC.Config.Config.main_check")107    def net_listening(self):108        payload = self.rpc_call("net_listening", [])109        response = self.get_response(payload)110        require_that("'result'", response["result"], is_true())111    @lcc.test("Check method 'net_peerCount'")112    @lcc.depends_on("EthRPC.Config.Config.main_check")113    def net_peer_count(self):114        payload = self.rpc_call("net_peerCount", [])115        response = self.get_response(payload)116        require_that("'result'", response["result"], equal_to("0x00"))117    @lcc.test("Check method 'eth_protocolVersion'")118    @lcc.depends_on("EthRPC.Config.Config.main_check")119    def eth_protocol_version(self):120        payload = self.rpc_call("eth_protocolVersion", [])121        response = self.get_response(payload)122        require_that("'result'", response["result"], equal_to("0x3f"))123    @lcc.test("Check method 'eth_syncing'")124    @lcc.depends_on("EthRPC.Config.Config.main_check")125    def eth_syncing(self):126        payload = self.rpc_call("eth_syncing", [])127        response = self.get_response(payload)128        require_that("'result'", response["result"], is_false())129    @lcc.test("Check method 'eth_coinbase'")130    @lcc.depends_on("EthRPC.Config.Config.main_check")131    def eth_coinbase(self):132        payload = self.rpc_call("eth_coinbase", [])133        response = self.get_response(payload)134        require_that("'result'", response["result"], equal_to(self.account_address))135    @lcc.test("Check method 'eth_gasPrice'")136    @lcc.depends_on("EthRPC.Config.Config.main_check")137    def eth_gas_price(self):138        payload = self.rpc_call("eth_gasPrice", [])139        response = self.get_response(payload)140        require_that("'result'", response["result"], equal_to("0x01"))141    @lcc.test("Check method 'eth_block_number'")142    @lcc.depends_on("EthRPC.Config.Config.main_check")143    def eth_block_number(self):144        payload = self.rpc_call("eth_blockNumber", [])145        response = self.get_response(payload)146        echo = Echo()147        echo.connect(BASE_URL)148        head_block_number = echo.api.database.get_dynamic_global_properties()["head_block_number"]149        check_that('block_number', int(response["result"], 16), equal_to(head_block_number))150    @lcc.disabled()151    @lcc.test("Check method 'eth_getStorageAt'")152    @lcc.depends_on("EthRPC.Config.Config.main_check")153    def eth_get_storage_at(self):154        self.create_contract()155        payload = self.rpc_call(156            "eth_getStorageAt",157            [self.contract_address, "0x6661e9d6d8b923d5bbaab1b96e1dd51ff6ea2a93520fdc9eb75d059238b8c5e9", "latest"]158        )159        response = self.get_response(payload)160        require_that("'result'", response["result"], not_equal_to(self.null_trx_hash))161    @lcc.test("Check method 'eth_estimateGas'")162    @lcc.depends_on("EthRPC.Config.Config.main_check")163    def eth_estimate_gas(self):164        payload = self.rpc_call("eth_estimateGas", [{165            "from": self.account_address,166            "data": self.contract,167        }])168        response = self.get_response(payload)169        if not self.type_validator.is_eth_balance(response["result"]):170            lcc.log_error("Wrong format of 'gas', got: '{}'".format(response["result"]))171        else:172            lcc.log_info("'result' has correct format: gas")173    @lcc.test("Check method 'eth_pendingTransactions'")174    @lcc.depends_on("EthRPC.Config.Config.main_check")175    def eth_pending_transactions(self):176        payload = self.rpc_call("eth_pendingTransactions", [])177        response = self.get_response(payload)178        require_that("'result'", response["result"], is_list())179    @lcc.test("Check method 'echo_requestRegistrationTask'")180    @lcc.depends_on("EthRPC.Config.Config.main_check")181    def echo_request_registration_task(self):182        payload = self.rpc_call("echo_requestRegistrationTask", [])183        response = self.get_response(payload)["result"]184        if not self.type_validator.is_eth_hash(response["blockId"]):185            lcc.log_error("Wrong format of 'blockId', got: '{}'".format(response["blockId"]))186        else:187            lcc.log_info("'blockId' has correct format: eth_hash")188        if not self.type_validator.is_eth_hash(response["randNum"]):189            lcc.log_error("Wrong format of 'randNum', got: '{}'".format(response["randNum"]))190        else:191            lcc.log_info("'randNum' has correct format: eth_hash")192        if not self.type_validator.is_eth_hash(response["difficulty"]):...

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.