[tests] Remove 'account' API from wallet functional tests

jnewbery · jnewbery · commit 5d536619abda · 2018-05-02T17:53:23.000-04:00
Removes usage of account API from the following functional tests:

- wallet_listreceivedby.py
- wallet_basic.py
- wallet_keypool_topup.py
- wallet_txn_clone.py
- wallet_listsinceblock.py
- wallet_import_rescan.py
- wallet_listtransactions.py
- wallet_txn_doublespend.py
diff --git a/test/functional/wallet_basic.py b/test/functional/wallet_basic.py
@@ -22,10 +22,9 @@ class WalletTest(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 4
         self.setup_clean_chain = True
-        self.extra_args = [['-deprecatedrpc=accounts']] * 4
 
     def setup_network(self):
-        self.add_nodes(4, self.extra_args)
+        self.add_nodes(4)
         self.start_node(0)
         self.start_node(1)
         self.start_node(2)
@@ -151,7 +150,7 @@ def run_test(self):
             inputs = []
             outputs = {}
             inputs.append({"txid": utxo["txid"], "vout": utxo["vout"]})
-            outputs[self.nodes[2].getnewaddress("from1")] = utxo["amount"] - 3
+            outputs[self.nodes[2].getnewaddress()] = utxo["amount"] - 3
             raw_tx = self.nodes[0].createrawtransaction(inputs, outputs)
             txns_to_send.append(self.nodes[0].signrawtransactionwithwallet(raw_tx))
 
@@ -165,7 +164,6 @@ def run_test(self):
 
         assert_equal(self.nodes[0].getbalance(), 0)
         assert_equal(self.nodes[2].getbalance(), 94)
-        assert_equal(self.nodes[2].getbalance("from1"), 94 - 21)
 
         # Verify that a spent output cannot be locked anymore
         spent_0 = {"txid": node0utxos[0]["txid"], "vout": node0utxos[0]["vout"]}
@@ -190,15 +188,15 @@ def run_test(self):
         node_0_bal = self.check_fee_amount(self.nodes[0].getbalance(), Decimal('20'), fee_per_byte, self.get_vsize(self.nodes[2].getrawtransaction(txid)))
 
         # Sendmany 10 BTC
-        txid = self.nodes[2].sendmany('from1', {address: 10}, 0, "", [])
+        txid = self.nodes[2].sendmany('', {address: 10}, 0, "", [])
         self.nodes[2].generate(1)
         self.sync_all([self.nodes[0:3]])
         node_0_bal += Decimal('10')
         node_2_bal = self.check_fee_amount(self.nodes[2].getbalance(), node_2_bal - Decimal('10'), fee_per_byte, self.get_vsize(self.nodes[2].getrawtransaction(txid)))
         assert_equal(self.nodes[0].getbalance(), node_0_bal)
 
         # Sendmany 10 BTC with subtract fee from amount
-        txid = self.nodes[2].sendmany('from1', {address: 10}, 0, "", [address])
+        txid = self.nodes[2].sendmany('', {address: 10}, 0, "", [address])
         self.nodes[2].generate(1)
         self.sync_all([self.nodes[0:3]])
         node_2_bal -= Decimal('10')
@@ -365,14 +363,14 @@ def run_test(self):
         #   - True: unicode escaped as \u....
         #   - False: unicode directly as UTF-8
         for mode in [True, False]:
-            self.nodes[0].ensure_ascii = mode
+            self.nodes[0].rpc.ensure_ascii = mode
             # unicode check: Basic Multilingual Plane, Supplementary Plane respectively
-            for s in [u'рыба', u'𝅘𝅥𝅯']:
-                addr = self.nodes[0].getaccountaddress(s)
-                label = self.nodes[0].getaccount(addr)
-                assert_equal(label, s)
-                assert(s in self.nodes[0].listaccounts().keys())
-        self.nodes[0].ensure_ascii = True  # restore to default
+            for label in [u'рыба', u'𝅘𝅥𝅯']:
+                addr = self.nodes[0].getnewaddress()
+                self.nodes[0].setlabel(addr, label)
+                assert_equal(self.nodes[0].getaddressinfo(addr)['label'], label)
+                assert(label in self.nodes[0].listlabels())
+        self.nodes[0].rpc.ensure_ascii = True  # restore to default
 
         # maintenance tests
         maintenance = [
@@ -388,9 +386,9 @@ def run_test(self):
             self.log.info("check " + m)
             self.stop_nodes()
             # set lower ancestor limit for later
-            self.start_node(0, [m, "-deprecatedrpc=accounts", "-limitancestorcount=" + str(chainlimit)])
-            self.start_node(1, [m, "-deprecatedrpc=accounts", "-limitancestorcount=" + str(chainlimit)])
-            self.start_node(2, [m, "-deprecatedrpc=accounts", "-limitancestorcount=" + str(chainlimit)])
+            self.start_node(0, [m, "-limitancestorcount=" + str(chainlimit)])
+            self.start_node(1, [m, "-limitancestorcount=" + str(chainlimit)])
+            self.start_node(2, [m, "-limitancestorcount=" + str(chainlimit)])
             if m == '-reindex':
                 # reindex will leave rpc warm up "early"; Wait for it to finish
                 wait_until(lambda: [block_count] * 3 == [self.nodes[i].getblockcount() for i in range(3)])
@@ -438,7 +436,7 @@ def run_test(self):
         # Try with walletrejectlongchains
         # Double chain limit but require combining inputs, so we pass SelectCoinsMinConf
         self.stop_node(0)
-        self.start_node(0, extra_args=["-deprecatedrpc=accounts", "-walletrejectlongchains", "-limitancestorcount=" + str(2 * chainlimit)])
+        self.start_node(0, extra_args=["-walletrejectlongchains", "-limitancestorcount=" + str(2 * chainlimit)])
 
         # wait for loadmempool
         timeout = 10
diff --git a/test/functional/wallet_import_rescan.py b/test/functional/wallet_import_rescan.py
@@ -42,16 +42,15 @@ def try_rpc(self, func, *args, **kwargs):
 
     def do_import(self, timestamp):
         """Call one key import RPC."""
+        rescan = self.rescan == Rescan.yes
 
         if self.call == Call.single:
             if self.data == Data.address:
-                response = self.try_rpc(self.node.importaddress, self.address["address"], self.label,
-                                        self.rescan == Rescan.yes)
+                response = self.try_rpc(self.node.importaddress, address=self.address["address"], rescan=rescan)
             elif self.data == Data.pub:
-                response = self.try_rpc(self.node.importpubkey, self.address["pubkey"], self.label,
-                                        self.rescan == Rescan.yes)
+                response = self.try_rpc(self.node.importpubkey, pubkey=self.address["pubkey"], rescan=rescan)
             elif self.data == Data.priv:
-                response = self.try_rpc(self.node.importprivkey, self.key, self.label, self.rescan == Rescan.yes)
+                response = self.try_rpc(self.node.importprivkey, privkey=self.key, rescan=rescan)
             assert_equal(response, None)
 
         elif self.call == Call.multi:
@@ -62,40 +61,32 @@ def do_import(self, timestamp):
                 "timestamp": timestamp + TIMESTAMP_WINDOW + (1 if self.rescan == Rescan.late_timestamp else 0),
                 "pubkeys": [self.address["pubkey"]] if self.data == Data.pub else [],
                 "keys": [self.key] if self.data == Data.priv else [],
-                "label": self.label,
                 "watchonly": self.data != Data.priv
             }], {"rescan": self.rescan in (Rescan.yes, Rescan.late_timestamp)})
             assert_equal(response, [{"success": True}])
 
     def check(self, txid=None, amount=None, confirmations=None):
-        """Verify that getbalance/listtransactions return expected values."""
+        """Verify that listreceivedbyaddress returns expected values."""
 
-        balance = self.node.getbalance(self.label, 0, True)
-        assert_equal(balance, self.expected_balance)
-
-        txs = self.node.listtransactions(self.label, 10000, 0, True)
-        assert_equal(len(txs), self.expected_txs)
+        addresses = self.node.listreceivedbyaddress(minconf=0, include_watchonly=True, address_filter=self.address['address'])
+        if self.expected_txs:
+            assert_equal(len(addresses[0]["txids"]), self.expected_txs)
 
         if txid is not None:
-            tx, = [tx for tx in txs if tx["txid"] == txid]
-            assert_equal(tx["label"], self.label)
-            assert_equal(tx["address"], self.address["address"])
-            assert_equal(tx["amount"], amount)
-            assert_equal(tx["category"], "receive")
-            assert_equal(tx["label"], self.label)
-            assert_equal(tx["txid"], txid)
-            assert_equal(tx["confirmations"], confirmations)
-            assert_equal("trusted" not in tx, True)
+            address, = [ad for ad in addresses if txid in ad["txids"]]
+            assert_equal(address["address"], self.address["address"])
+            assert_equal(address["amount"], self.expected_balance)
+            assert_equal(address["confirmations"], confirmations)
             # Verify the transaction is correctly marked watchonly depending on
             # whether the transaction pays to an imported public key or
             # imported private key. The test setup ensures that transaction
             # inputs will not be from watchonly keys (important because
             # involvesWatchonly will be true if either the transaction output
             # or inputs are watchonly).
             if self.data != Data.priv:
-                assert_equal(tx["involvesWatchonly"], True)
+                assert_equal(address["involvesWatchonly"], True)
             else:
-                assert_equal("involvesWatchonly" not in tx, True)
+                assert_equal("involvesWatchonly" not in address, True)
 
 
 # List of Variants for each way a key or address could be imported.
@@ -119,7 +110,7 @@ def set_test_params(self):
         self.num_nodes = 2 + len(IMPORT_NODES)
 
     def setup_network(self):
-        extra_args = [["-addresstype=legacy", '-deprecatedrpc=accounts'] for _ in range(self.num_nodes)]
+        extra_args = [["-addresstype=legacy"] for _ in range(self.num_nodes)]
         for i, import_node in enumerate(IMPORT_NODES, 2):
             if import_node.prune:
                 extra_args[i] += ["-prune=1"]
@@ -130,11 +121,10 @@ def setup_network(self):
             connect_nodes(self.nodes[i], 0)
 
     def run_test(self):
-        # Create one transaction on node 0 with a unique amount and label for
+        # Create one transaction on node 0 with a unique amount for
         # each possible type of wallet import RPC.
         for i, variant in enumerate(IMPORT_VARIANTS):
-            variant.label = "label {} {}".format(i, variant)
-            variant.address = self.nodes[1].getaddressinfo(self.nodes[1].getnewaddress(variant.label))
+            variant.address = self.nodes[1].getaddressinfo(self.nodes[1].getnewaddress())
             variant.key = self.nodes[1].dumpprivkey(variant.address["address"])
             variant.initial_amount = 10 - (i + 1) / 4.0
             variant.initial_txid = self.nodes[0].sendtoaddress(variant.address["address"], variant.initial_amount)
diff --git a/test/functional/wallet_keypool_topup.py b/test/functional/wallet_keypool_topup.py
@@ -25,7 +25,7 @@ class KeypoolRestoreTest(BitcoinTestFramework):
     def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 2
-        self.extra_args = [['-deprecatedrpc=accounts'], ['-deprecatedrpc=accounts', '-keypool=100', '-keypoolmin=20']]
+        self.extra_args = [[], ['-keypool=100']]
 
     def run_test(self):
         wallet_path = os.path.join(self.nodes[1].datadir, "regtest", "wallets", "wallet.dat")
diff --git a/test/functional/wallet_listreceivedby.py b/test/functional/wallet_listreceivedby.py
@@ -14,7 +14,6 @@
 class ReceivedByTest(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 2
-        self.extra_args = [['-deprecatedrpc=accounts']] * 2
 
     def run_test(self):
         # Generate block to get out of IBD
@@ -112,8 +111,9 @@ def run_test(self):
         self.log.info("listreceivedbylabel + getreceivedbylabel Test")
 
         # set pre-state
+        label = ''
         address = self.nodes[1].getnewaddress()
-        label = self.nodes[1].getaccount(address)
+        assert_equal(self.nodes[1].getaddressinfo(address)['label'], label)
         received_by_label_json = [r for r in self.nodes[1].listreceivedbylabel() if r["label"] == label][0]
         balance_by_label = self.nodes[1].getreceivedbylabel(label)
 
@@ -141,7 +141,8 @@ def run_test(self):
         assert_equal(balance, balance_by_label + Decimal("0.1"))
 
         # Create a new label named "mynewlabel" that has a 0 balance
-        self.nodes[1].getlabeladdress(label="mynewlabel", force=True)
+        address = self.nodes[1].getnewaddress()
+        self.nodes[1].setlabel(address, "mynewlabel")
         received_by_label_json = [r for r in self.nodes[1].listreceivedbylabel(0, True) if r["label"] == "mynewlabel"][0]
 
         # Test includeempty of listreceivedbylabel
diff --git a/test/functional/wallet_listsinceblock.py b/test/functional/wallet_listsinceblock.py
@@ -11,7 +11,6 @@ class ListSinceBlockTest (BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 4
         self.setup_clean_chain = True
-        self.extra_args = [['-deprecatedrpc=accounts']] * 4
 
     def run_test(self):
         self.nodes[2].generate(101)
diff --git a/test/functional/wallet_listtransactions.py b/test/functional/wallet_listtransactions.py
@@ -25,7 +25,6 @@ def tx_from_hex(hexstring):
 class ListTransactionsTest(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 2
-        self.extra_args = [['-deprecatedrpc=accounts']] * 2
         self.enable_mocktime()
 
     def run_test(self):
@@ -34,19 +33,19 @@ def run_test(self):
         self.sync_all()
         assert_array_result(self.nodes[0].listtransactions(),
                             {"txid": txid},
-                            {"category": "send", "account": "", "amount": Decimal("-0.1"), "confirmations": 0})
+                            {"category": "send", "amount": Decimal("-0.1"), "confirmations": 0})
         assert_array_result(self.nodes[1].listtransactions(),
                             {"txid": txid},
-                            {"category": "receive", "account": "", "amount": Decimal("0.1"), "confirmations": 0})
+                            {"category": "receive", "amount": Decimal("0.1"), "confirmations": 0})
         # mine a block, confirmations should change:
         self.nodes[0].generate(1)
         self.sync_all()
         assert_array_result(self.nodes[0].listtransactions(),
                             {"txid": txid},
-                            {"category": "send", "account": "", "amount": Decimal("-0.1"), "confirmations": 1})
+                            {"category": "send", "amount": Decimal("-0.1"), "confirmations": 1})
         assert_array_result(self.nodes[1].listtransactions(),
                             {"txid": txid},
-                            {"category": "receive", "account": "", "amount": Decimal("0.1"), "confirmations": 1})
+                            {"category": "receive", "amount": Decimal("0.1"), "confirmations": 1})
 
         # send-to-self:
         txid = self.nodes[0].sendtoaddress(self.nodes[0].getnewaddress(), 0.2)
@@ -60,8 +59,8 @@ def run_test(self):
         # sendmany from node1: twice to self, twice to node2:
         send_to = {self.nodes[0].getnewaddress(): 0.11,
                    self.nodes[1].getnewaddress(): 0.22,
-                   self.nodes[0].getaccountaddress("from1"): 0.33,
-                   self.nodes[1].getaccountaddress("toself"): 0.44}
+                   self.nodes[0].getnewaddress(): 0.33,
+                   self.nodes[1].getnewaddress(): 0.44}
         txid = self.nodes[1].sendmany("", send_to)
         self.sync_all()
         assert_array_result(self.nodes[1].listtransactions(),
@@ -81,24 +80,23 @@ def run_test(self):
                             {"txid": txid})
         assert_array_result(self.nodes[0].listtransactions(),
                             {"category": "receive", "amount": Decimal("0.33")},
-                            {"txid": txid, "account": "from1"})
+                            {"txid": txid})
         assert_array_result(self.nodes[1].listtransactions(),
                             {"category": "send", "amount": Decimal("-0.44")},
-                            {"txid": txid, "account": ""})
+                            {"txid": txid})
         assert_array_result(self.nodes[1].listtransactions(),
                             {"category": "receive", "amount": Decimal("0.44")},
-                            {"txid": txid, "account": "toself"})
+                            {"txid": txid})
 
         pubkey = self.nodes[1].getaddressinfo(self.nodes[1].getnewaddress())['pubkey']
         multisig = self.nodes[1].createmultisig(1, [pubkey])
         self.nodes[0].importaddress(multisig["redeemScript"], "watchonly", False, True)
         txid = self.nodes[1].sendtoaddress(multisig["address"], 0.1)
         self.nodes[1].generate(1)
         self.sync_all()
-        assert(len(self.nodes[0].listtransactions("watchonly", 100, 0, False)) == 0)
-        assert_array_result(self.nodes[0].listtransactions("watchonly", 100, 0, True),
-                            {"category": "receive", "amount": Decimal("0.1")},
-                            {"txid": txid, "account": "watchonly"})
+        assert not [tx for tx in self.nodes[0].listtransactions(dummy="*", count=100, skip=0, include_watchonly=False) if "label" in tx and tx["label"] == "watchonly"]
+        txs = [tx for tx in self.nodes[0].listtransactions(dummy="*", count=100, skip=0, include_watchonly=True) if "label" in tx and tx['label'] == 'watchonly']
+        assert_array_result(txs, {"category": "receive", "amount": Decimal("0.1")}, {"txid": txid})
 
         self.run_rbf_opt_in_test()
 
diff --git a/test/functional/wallet_txn_clone.py b/test/functional/wallet_txn_clone.py
diff --git a/test/functional/wallet_txn_doublespend.py b/test/functional/wallet_txn_doublespend.py
