[tests] remove direct testing on JSONRPCException from individual test cases

test/functional/import-rescan.py

@@ -19,9 +19,8 @@ importing nodes pick up the new transactions regardless of whether rescans
 happened previously.
 """
 
-from test_framework.authproxy import JSONRPCException
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import (connect_nodes, sync_blocks, assert_equal, set_node_times)
+from test_framework.util import (assert_raises_jsonrpc, connect_nodes, sync_blocks, assert_equal, set_node_times)
 
 import collections
 import enum
@@ -35,21 +34,26 @@ Rescan = enum.Enum("Rescan", "no yes late_timestamp")
 class Variant(collections.namedtuple("Variant", "call data rescan prune")):
     """Helper for importing one key and verifying scanned transactions."""
 
+    def try_rpc(self, func, *args, **kwargs):
+        if self.expect_disabled:
+            assert_raises_jsonrpc(-4, "Rescan is disabled in pruned mode", func, *args, **kwargs)
+        else:
+            return func(*args, **kwargs)
+
     def do_import(self, timestamp):
         """Call one key import RPC."""
 
         if self.call == Call.single:
             if self.data == Data.address:
-                response, error = try_rpc(self.node.importaddress, self.address["address"], self.label,
+                response = self.try_rpc(self.node.importaddress, self.address["address"], self.label,
-                                          self.rescan == Rescan.yes)
+                                               self.rescan == Rescan.yes)
             elif self.data == Data.pub:
-                response, error = try_rpc(self.node.importpubkey, self.address["pubkey"], self.label,
+                response = self.try_rpc(self.node.importpubkey, self.address["pubkey"], self.label,
-                                          self.rescan == Rescan.yes)
+                                               self.rescan == Rescan.yes)
             elif self.data == Data.priv:
-                response, error = try_rpc(self.node.importprivkey, self.key, self.label, self.rescan == Rescan.yes)
+                response = self.try_rpc(self.node.importprivkey, self.key, self.label, self.rescan == Rescan.yes)
             assert_equal(response, None)
-            assert_equal(error, {'message': 'Rescan is disabled in pruned mode',
+
-                                 'code': -4} if self.expect_disabled else None)
         elif self.call == Call.multi:
             response = self.node.importmulti([{
                 "scriptPubKey": {
@@ -179,13 +183,5 @@ class ImportRescanTest(BitcoinTestFramework):
             else:
                 variant.check()
 
-
-def try_rpc(func, *args, **kwargs):
-    try:
-        return func(*args, **kwargs), None
-    except JSONRPCException as e:
-        return None, e.error
-
-
 if __name__ == "__main__":
     ImportRescanTest().main()

test/functional/importmulti.py

@@ -423,11 +423,11 @@ class ImportMultiTest (BitcoinTestFramework):
 
         # Bad or missing timestamps
         self.log.info("Should throw on invalid or missing timestamp values")
-        assert_raises_message(JSONRPCException, 'Missing required timestamp field for key',
+        assert_raises_jsonrpc(-3, 'Missing required timestamp field for key',
             self.nodes[1].importmulti, [{
                 "scriptPubKey": address['scriptPubKey'],
             }])
-        assert_raises_message(JSONRPCException, 'Expected number or "now" timestamp value for key. got type string',
+        assert_raises_jsonrpc(-3, 'Expected number or "now" timestamp value for key. got type string',
             self.nodes[1].importmulti, [{
                 "scriptPubKey": address['scriptPubKey'],
                 "timestamp": "",

test/functional/segwit.py

@@ -452,11 +452,7 @@ class SegWitTest(BitcoinTestFramework):
         for i in importlist:
             # import all generated addresses. The wallet already has the private keys for some of these, so catch JSON RPC
             # exceptions and continue.
-            try:
+            try_rpc(-4, "The wallet already contains the private key for this address or script", self.nodes[0].importaddress, i, "", False, True)
-                self.nodes[0].importaddress(i,"",False,True)
-            except JSONRPCException as exp:
-                assert_equal(exp.error["message"], "The wallet already contains the private key for this address or script")
-                assert_equal(exp.error["code"], -4)
 
         self.nodes[0].importaddress(script_to_p2sh(op0)) # import OP_0 as address only
         self.nodes[0].importaddress(multisig_without_privkey_address) # Test multisig_without_privkey

test/functional/signrawtransactions.py

@@ -82,7 +82,7 @@ class SignRawTransactionsTest(BitcoinTestFramework):
             assert_equal(decodedRawTx["vin"][i]["vout"], inp["vout"])
 
         # Make sure decoderawtransaction throws if there is extra data
-        assert_raises(JSONRPCException, self.nodes[0].decoderawtransaction, rawTx + "00")
+        assert_raises_jsonrpc(-22, "TX decode failed", self.nodes[0].decoderawtransaction, rawTx + "00")
 
         rawTxSigned = self.nodes[0].signrawtransaction(rawTx, scripts, privKeys)
 

test/functional/test_framework/util.py

@@ -99,6 +99,13 @@ def assert_raises_jsonrpc(code, message, fun, *args, **kwds):
         args*: positional arguments for the function.
         kwds**: named arguments for the function.
     """
+    assert try_rpc(code, message, fun, *args, **kwds), "No exception raised"
+
+def try_rpc(code, message, fun, *args, **kwds):
+    """Tries to run an rpc command.
+
+    Test against error code and message if the rpc fails.
+    Returns whether a JSONRPCException was raised."""
     try:
         fun(*args, **kwds)
     except JSONRPCException as e:
@@ -107,10 +114,11 @@ def assert_raises_jsonrpc(code, message, fun, *args, **kwds):
             raise AssertionError("Unexpected JSONRPC error code %i" % e.error["code"])
         if (message is not None) and (message not in e.error['message']):
             raise AssertionError("Expected substring not found:" + e.error['message'])
+        return True
     except Exception as e:
         raise AssertionError("Unexpected exception raised: " + type(e).__name__)
     else:
-        raise AssertionError("No exception raised")
+        return False
 
 def assert_is_hex_string(string):
     try: