From 045eeb887092a631d49194e743859b1da84c1d5d Mon Sep 17 00:00:00 2001
From: Russell Yanofsky <russ@yanofsky.org>
Date: Fri, 20 Oct 2017 13:27:55 -0400
Subject: Rename account to label where appropriate

This change only updates strings and adds RPC aliases, but should simplify the
implementation of address labels in
https://github.com/bitcoin/bitcoin/pull/7729, by getting renaming out of the
way and letting it focus on semantics.

The difference between accounts and labels is that labels apply only to
addresses, while accounts apply to both addresses and transactions
(transactions have "from" and "to" accounts). The code associating accounts
with transactions is clumsy and unreliable so we would like get rid of it.
---
 test/functional/wallet_accounts.py       | 164 +++++++++++++++----------------
 test/functional/wallet_import_rescan.py  |   2 +-
 test/functional/wallet_listreceivedby.py |  60 +++++------
 3 files changed, 113 insertions(+), 113 deletions(-)

(limited to 'test')

diff --git a/test/functional/wallet_accounts.py b/test/functional/wallet_accounts.py
index ecd1cfc82b..b2695e681f 100755
--- a/test/functional/wallet_accounts.py
+++ b/test/functional/wallet_accounts.py
@@ -2,13 +2,13 @@
 # Copyright (c) 2016-2017 The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
-"""Test account RPCs.
+"""Test label RPCs.
 
 RPCs tested are:
-    - getaccountaddress
+    - getlabeladdress
     - getaddressesbyaccount
     - listaddressgroupings
-    - setaccount
+    - setlabel
     - sendfrom (with account arguments)
     - move (with account arguments)
 """
@@ -16,7 +16,7 @@ RPCs tested are:
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import assert_equal
 
-class WalletAccountsTest(BitcoinTestFramework):
+class WalletLabelsTest(BitcoinTestFramework):
     def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 1
@@ -68,97 +68,97 @@ class WalletAccountsTest(BitcoinTestFramework):
 
         node.generate(1)
 
-        # we want to reset so that the "" account has what's expected.
+        # we want to reset so that the "" label has what's expected.
         # otherwise we're off by exactly the fee amount as that's mined
         # and matures in the next 100 blocks
         node.sendfrom("", common_address, fee)
         amount_to_send = 1.0
 
-        # Create accounts and make sure subsequent account API calls
-        # recognize the account/address associations.
-        accounts = [Account(name) for name in ("a", "b", "c", "d", "e")]
-        for account in accounts:
-            account.add_receive_address(node.getaccountaddress(account.name))
-            account.verify(node)
+        # Create labels and make sure subsequent label API calls
+        # recognize the label/address associations.
+        labels = [Label(name) for name in ("a", "b", "c", "d", "e")]
+        for label in labels:
+            label.add_receive_address(node.getlabeladdress(label.name))
+            label.verify(node)
 
-        # Send a transaction to each account, and make sure this forces
-        # getaccountaddress to generate a new receiving address.
-        for account in accounts:
-            node.sendtoaddress(account.receive_address, amount_to_send)
-            account.add_receive_address(node.getaccountaddress(account.name))
-            account.verify(node)
+        # Send a transaction to each label, and make sure this forces
+        # getlabeladdress to generate a new receiving address.
+        for label in labels:
+            node.sendtoaddress(label.receive_address, amount_to_send)
+            label.add_receive_address(node.getlabeladdress(label.name))
+            label.verify(node)
 
         # Check the amounts received.
         node.generate(1)
-        for account in accounts:
+        for label in labels:
             assert_equal(
-                node.getreceivedbyaddress(account.addresses[0]), amount_to_send)
-            assert_equal(node.getreceivedbyaccount(account.name), amount_to_send)
-        
-        # Check that sendfrom account reduces listaccounts balances.
-        for i, account in enumerate(accounts):
-            to_account = accounts[(i+1) % len(accounts)]
-            node.sendfrom(account.name, to_account.receive_address, amount_to_send)
+                node.getreceivedbyaddress(label.addresses[0]), amount_to_send)
+            assert_equal(node.getreceivedbylabel(label.name), amount_to_send)
+
+        # Check that sendfrom label reduces listaccounts balances.
+        for i, label in enumerate(labels):
+            to_label = labels[(i+1) % len(labels)]
+            node.sendfrom(label.name, to_label.receive_address, amount_to_send)
         node.generate(1)
-        for account in accounts:
-            account.add_receive_address(node.getaccountaddress(account.name))
-            account.verify(node)
-            assert_equal(node.getreceivedbyaccount(account.name), 2)
-            node.move(account.name, "", node.getbalance(account.name))
-            account.verify(node)
+        for label in labels:
+            label.add_receive_address(node.getlabeladdress(label.name))
+            label.verify(node)
+            assert_equal(node.getreceivedbylabel(label.name), 2)
+            node.move(label.name, "", node.getbalance(label.name))
+            label.verify(node)
         node.generate(101)
         expected_account_balances = {"": 5200}
-        for account in accounts:
-            expected_account_balances[account.name] = 0
+        for label in labels:
+            expected_account_balances[label.name] = 0
         assert_equal(node.listaccounts(), expected_account_balances)
         assert_equal(node.getbalance(""), 5200)
-        
-        # Check that setaccount can assign an account to a new unused address.
-        for account in accounts:
-            address = node.getaccountaddress("")
-            node.setaccount(address, account.name)
-            account.add_address(address)
-            account.verify(node)
+
+        # Check that setlabel can assign a label to a new unused address.
+        for label in labels:
+            address = node.getlabeladdress("")
+            node.setlabel(address, label.name)
+            label.add_address(address)
+            label.verify(node)
             assert(address not in node.getaddressesbyaccount(""))
-        
-        # Check that addmultisigaddress can assign accounts.
-        for account in accounts:
+
+        # Check that addmultisigaddress can assign labels.
+        for label in labels:
             addresses = []
             for x in range(10):
                 addresses.append(node.getnewaddress())
-            multisig_address = node.addmultisigaddress(5, addresses, account.name)['address']
-            account.add_address(multisig_address)
-            account.verify(node)
+            multisig_address = node.addmultisigaddress(5, addresses, label.name)['address']
+            label.add_address(multisig_address)
+            label.verify(node)
             node.sendfrom("", multisig_address, 50)
         node.generate(101)
-        for account in accounts:
-            assert_equal(node.getbalance(account.name), 50)
+        for label in labels:
+            assert_equal(node.getbalance(label.name), 50)
 
-        # Check that setaccount can change the account of an address from a
-        # different account.
-        change_account(node, accounts[0].addresses[0], accounts[0], accounts[1])
+        # Check that setlabel can change the label of an address from a
+        # different label.
+        change_label(node, labels[0].addresses[0], labels[0], labels[1])
 
-        # Check that setaccount can change the account of an address which
-        # is the receiving address of a different account.
-        change_account(node, accounts[0].receive_address, accounts[0], accounts[1])
+        # Check that setlabel can change the label of an address which
+        # is the receiving address of a different label.
+        change_label(node, labels[0].receive_address, labels[0], labels[1])
 
-        # Check that setaccount can set the account of an address already
-        # in the account. This is a no-op.
-        change_account(node, accounts[2].addresses[0], accounts[2], accounts[2])
+        # Check that setlabel can set the label of an address already
+        # in the label. This is a no-op.
+        change_label(node, labels[2].addresses[0], labels[2], labels[2])
 
-        # Check that setaccount can set the account of an address which is
-        # already the receiving address of the account. It would probably make
+        # Check that setlabel can set the label of an address which is
+        # already the receiving address of the label. It would probably make
         # sense for this to be a no-op, but right now it resets the receiving
-        # address, causing getaccountaddress to return a brand new address.
-        change_account(node, accounts[2].receive_address, accounts[2], accounts[2])
+        # address, causing getlabeladdress to return a brand new address.
+        change_label(node, labels[2].receive_address, labels[2], labels[2])
 
-class Account:
+class Label:
     def __init__(self, name):
-        # Account name
+        # Label name
         self.name = name
-        # Current receiving address associated with this account.
+        # Current receiving address associated with this label.
         self.receive_address = None
-        # List of all addresses assigned with this account
+        # List of all addresses assigned with this label
         self.addresses = []
 
     def add_address(self, address):
@@ -172,7 +172,7 @@ class Account:
     def verify(self, node):
         if self.receive_address is not None:
             assert self.receive_address in self.addresses
-            assert_equal(node.getaccountaddress(self.name), self.receive_address)
+            assert_equal(node.getlabeladdress(self.name), self.receive_address)
 
         for address in self.addresses:
             assert_equal(node.getaccount(address), self.name)
@@ -181,26 +181,26 @@ class Account:
             set(node.getaddressesbyaccount(self.name)), set(self.addresses))
 
 
-def change_account(node, address, old_account, new_account):
-    assert_equal(address in old_account.addresses, True)
-    node.setaccount(address, new_account.name)
+def change_label(node, address, old_label, new_label):
+    assert_equal(address in old_label.addresses, True)
+    node.setlabel(address, new_label.name)
 
-    old_account.addresses.remove(address)
-    new_account.add_address(address)
+    old_label.addresses.remove(address)
+    new_label.add_address(address)
 
-    # Calling setaccount on an address which was previously the receiving
-    # address of a different account should reset the receiving address of
-    # the old account, causing getaccountaddress to return a brand new
+    # Calling setlabel on an address which was previously the receiving
+    # address of a different label should reset the receiving address of
+    # the old label, causing getlabeladdress to return a brand new
     # address.
-    if address == old_account.receive_address:
-        new_address = node.getaccountaddress(old_account.name)
-        assert_equal(new_address not in old_account.addresses, True)
-        assert_equal(new_address not in new_account.addresses, True)
-        old_account.add_receive_address(new_address)
+    if address == old_label.receive_address:
+        new_address = node.getlabeladdress(old_label.name)
+        assert_equal(new_address not in old_label.addresses, True)
+        assert_equal(new_address not in new_label.addresses, True)
+        old_label.add_receive_address(new_address)
 
-    old_account.verify(node)
-    new_account.verify(node)
+    old_label.verify(node)
+    new_label.verify(node)
 
 
 if __name__ == '__main__':
-    WalletAccountsTest().main()
+    WalletLabelsTest().main()
diff --git a/test/functional/wallet_import_rescan.py b/test/functional/wallet_import_rescan.py
index bfd4638481..b66e9b5d91 100755
--- a/test/functional/wallet_import_rescan.py
+++ b/test/functional/wallet_import_rescan.py
@@ -78,7 +78,7 @@ class Variant(collections.namedtuple("Variant", "call data rescan prune")):
 
         if txid is not None:
             tx, = [tx for tx in txs if tx["txid"] == txid]
-            assert_equal(tx["account"], self.label)
+            assert_equal(tx["label"], self.label)
             assert_equal(tx["address"], self.address["address"])
             assert_equal(tx["amount"], amount)
             assert_equal(tx["category"], "receive")
diff --git a/test/functional/wallet_listreceivedby.py b/test/functional/wallet_listreceivedby.py
index 01c9899c71..a4754852ed 100755
--- a/test/functional/wallet_listreceivedby.py
+++ b/test/functional/wallet_listreceivedby.py
@@ -36,11 +36,11 @@ class ReceivedByTest(BitcoinTestFramework):
         self.sync_all()
         assert_array_result(self.nodes[1].listreceivedbyaddress(),
                             {"address": addr},
-                            {"address": addr, "account": "", "amount": Decimal("0.1"), "confirmations": 10, "txids": [txid, ]})
+                            {"address": addr, "label": "", "amount": Decimal("0.1"), "confirmations": 10, "txids": [txid, ]})
         # With min confidence < 10
         assert_array_result(self.nodes[1].listreceivedbyaddress(5),
                             {"address": addr},
-                            {"address": addr, "account": "", "amount": Decimal("0.1"), "confirmations": 10, "txids": [txid, ]})
+                            {"address": addr, "label": "", "amount": Decimal("0.1"), "confirmations": 10, "txids": [txid, ]})
         # With min confidence > 10, should not find Tx
         assert_array_result(self.nodes[1].listreceivedbyaddress(11), {"address": addr}, {}, True)
 
@@ -48,11 +48,11 @@ class ReceivedByTest(BitcoinTestFramework):
         empty_addr = self.nodes[1].getnewaddress()
         assert_array_result(self.nodes[1].listreceivedbyaddress(0, True),
                             {"address": empty_addr},
-                            {"address": empty_addr, "account": "", "amount": 0, "confirmations": 0, "txids": []})
+                            {"address": empty_addr, "label": "", "amount": 0, "confirmations": 0, "txids": []})
 
         #Test Address filtering
         #Only on addr
-        expected = {"address":addr, "account":"", "amount":Decimal("0.1"), "confirmations":10, "txids":[txid,]}
+        expected = {"address":addr, "label":"", "amount":Decimal("0.1"), "confirmations":10, "txids":[txid,]}
         res = self.nodes[1].listreceivedbyaddress(minconf=0, include_empty=True, include_watchonly=True, address_filter=addr)
         assert_array_result(res, {"address":addr}, expected)
         assert_equal(len(res), 1)
@@ -66,12 +66,12 @@ class ReceivedByTest(BitcoinTestFramework):
         self.nodes[0].generate(1)
         self.sync_all()
         #Same test as above should still pass
-        expected = {"address":addr, "account":"", "amount":Decimal("0.1"), "confirmations":11, "txids":[txid,]}
+        expected = {"address":addr, "label":"", "amount":Decimal("0.1"), "confirmations":11, "txids":[txid,]}
         res = self.nodes[1].listreceivedbyaddress(0, True, True, addr)
         assert_array_result(res, {"address":addr}, expected)
         assert_equal(len(res), 1)
         #Same test as above but with other_addr should still pass
-        expected = {"address":other_addr, "account":"", "amount":Decimal("0.1"), "confirmations":1, "txids":[txid2,]}
+        expected = {"address":other_addr, "label":"", "amount":Decimal("0.1"), "confirmations":1, "txids":[txid2,]}
         res = self.nodes[1].listreceivedbyaddress(0, True, True, other_addr)
         assert_array_result(res, {"address":other_addr}, expected)
         assert_equal(len(res), 1)
@@ -108,46 +108,46 @@ class ReceivedByTest(BitcoinTestFramework):
         # Trying to getreceivedby for an address the wallet doesn't own should return an error
         assert_raises_rpc_error(-4, "Address not found in wallet", self.nodes[0].getreceivedbyaddress, addr)
 
-        self.log.info("listreceivedbyaccount + getreceivedbyaccount Test")
+        self.log.info("listreceivedbylabel + getreceivedbylabel Test")
 
         # set pre-state
         addrArr = self.nodes[1].getnewaddress()
-        account = self.nodes[1].getaccount(addrArr)
-        received_by_account_json = [r for r in self.nodes[1].listreceivedbyaccount() if r["account"] == account][0]
-        balance_by_account = self.nodes[1].getreceivedbyaccount(account)
+        label = self.nodes[1].getaccount(addrArr)
+        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)
 
         txid = self.nodes[0].sendtoaddress(addr, 0.1)
         self.sync_all()
 
-        # listreceivedbyaccount should return received_by_account_json because of 0 confirmations
-        assert_array_result(self.nodes[1].listreceivedbyaccount(),
-                            {"account": account},
-                            received_by_account_json)
+        # listreceivedbylabel should return received_by_label_json because of 0 confirmations
+        assert_array_result(self.nodes[1].listreceivedbylabel(),
+                            {"label": label},
+                            received_by_label_json)
 
         # getreceivedbyaddress should return same balance because of 0 confirmations
-        balance = self.nodes[1].getreceivedbyaccount(account)
-        assert_equal(balance, balance_by_account)
+        balance = self.nodes[1].getreceivedbylabel(label)
+        assert_equal(balance, balance_by_label)
 
         self.nodes[1].generate(10)
         self.sync_all()
-        # listreceivedbyaccount should return updated account balance
-        assert_array_result(self.nodes[1].listreceivedbyaccount(),
-                            {"account": account},
-                            {"account": received_by_account_json["account"], "amount": (received_by_account_json["amount"] + Decimal("0.1"))})
+        # listreceivedbylabel should return updated received list
+        assert_array_result(self.nodes[1].listreceivedbylabel(),
+                            {"label": label},
+                            {"label": received_by_label_json["label"], "amount": (received_by_label_json["amount"] + Decimal("0.1"))})
 
-        # getreceivedbyaddress should return updates balance
-        balance = self.nodes[1].getreceivedbyaccount(account)
-        assert_equal(balance, balance_by_account + Decimal("0.1"))
+        # getreceivedbylabel should return updated receive total
+        balance = self.nodes[1].getreceivedbylabel(label)
+        assert_equal(balance, balance_by_label + Decimal("0.1"))
 
-        # Create a new account named "mynewaccount" that has a 0 balance
-        self.nodes[1].getaccountaddress("mynewaccount")
-        received_by_account_json = [r for r in self.nodes[1].listreceivedbyaccount(0, True) if r["account"] == "mynewaccount"][0]
+        # Create a new label named "mynewlabel" that has a 0 balance
+        self.nodes[1].getlabeladdress("mynewlabel")
+        received_by_label_json = [r for r in self.nodes[1].listreceivedbylabel(0, True) if r["label"] == "mynewlabel"][0]
 
-        # Test includeempty of listreceivedbyaccount
-        assert_equal(received_by_account_json["amount"], Decimal("0.0"))
+        # Test includeempty of listreceivedbylabel
+        assert_equal(received_by_label_json["amount"], Decimal("0.0"))
 
-        # Test getreceivedbyaccount for 0 amount accounts
-        balance = self.nodes[1].getreceivedbyaccount("mynewaccount")
+        # Test getreceivedbylabel for 0 amount labels
+        balance = self.nodes[1].getreceivedbylabel("mynewlabel")
         assert_equal(balance, Decimal("0.0"))
 
 if __name__ == '__main__':
-- 
cgit v1.2.3


From d2527bd54e994747d9e24043c91d46c7219d46ac Mon Sep 17 00:00:00 2001
From: Russell Yanofsky <russ@yanofsky.org>
Date: Fri, 20 Oct 2017 13:27:55 -0400
Subject: Rename wallet_accounts.py test

This is a separate commit because changing the test at the same time as
renaming it breaks git (and github) rename detection.
---
 test/functional/test_runner.py     |   2 +-
 test/functional/wallet_accounts.py | 206 -------------------------------------
 test/functional/wallet_labels.py   | 206 +++++++++++++++++++++++++++++++++++++
 3 files changed, 207 insertions(+), 207 deletions(-)
 delete mode 100755 test/functional/wallet_accounts.py
 create mode 100755 test/functional/wallet_labels.py

(limited to 'test')

diff --git a/test/functional/test_runner.py b/test/functional/test_runner.py
index 09f7f50de0..a2eaf99146 100755
--- a/test/functional/test_runner.py
+++ b/test/functional/test_runner.py
@@ -67,7 +67,7 @@ BASE_SCRIPTS= [
     'feature_segwit.py',
     # vv Tests less than 2m vv
     'wallet_basic.py',
-    'wallet_accounts.py',
+    'wallet_labels.py',
     'p2p_segwit.py',
     'wallet_dump.py',
     'rpc_listtransactions.py',
diff --git a/test/functional/wallet_accounts.py b/test/functional/wallet_accounts.py
deleted file mode 100755
index b2695e681f..0000000000
--- a/test/functional/wallet_accounts.py
+++ /dev/null
@@ -1,206 +0,0 @@
-#!/usr/bin/env python3
-# Copyright (c) 2016-2017 The Bitcoin Core developers
-# Distributed under the MIT software license, see the accompanying
-# file COPYING or http://www.opensource.org/licenses/mit-license.php.
-"""Test label RPCs.
-
-RPCs tested are:
-    - getlabeladdress
-    - getaddressesbyaccount
-    - listaddressgroupings
-    - setlabel
-    - sendfrom (with account arguments)
-    - move (with account arguments)
-"""
-
-from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import assert_equal
-
-class WalletLabelsTest(BitcoinTestFramework):
-    def set_test_params(self):
-        self.setup_clean_chain = True
-        self.num_nodes = 1
-        self.extra_args = [[]]
-
-    def run_test(self):
-        node = self.nodes[0]
-        # Check that there's no UTXO on any of the nodes
-        assert_equal(len(node.listunspent()), 0)
-
-        # Note each time we call generate, all generated coins go into
-        # the same address, so we call twice to get two addresses w/50 each
-        node.generate(1)
-        node.generate(101)
-        assert_equal(node.getbalance(), 100)
-
-        # there should be 2 address groups
-        # each with 1 address with a balance of 50 Bitcoins
-        address_groups = node.listaddressgroupings()
-        assert_equal(len(address_groups), 2)
-        # the addresses aren't linked now, but will be after we send to the
-        # common address
-        linked_addresses = set()
-        for address_group in address_groups:
-            assert_equal(len(address_group), 1)
-            assert_equal(len(address_group[0]), 2)
-            assert_equal(address_group[0][1], 50)
-            linked_addresses.add(address_group[0][0])
-
-        # send 50 from each address to a third address not in this wallet
-        # There's some fee that will come back to us when the miner reward
-        # matures.
-        common_address = "msf4WtN1YQKXvNtvdFYt9JBnUD2FB41kjr"
-        txid = node.sendmany(
-            fromaccount="",
-            amounts={common_address: 100},
-            subtractfeefrom=[common_address],
-            minconf=1,
-        )
-        tx_details = node.gettransaction(txid)
-        fee = -tx_details['details'][0]['fee']
-        # there should be 1 address group, with the previously
-        # unlinked addresses now linked (they both have 0 balance)
-        address_groups = node.listaddressgroupings()
-        assert_equal(len(address_groups), 1)
-        assert_equal(len(address_groups[0]), 2)
-        assert_equal(set([a[0] for a in address_groups[0]]), linked_addresses)
-        assert_equal([a[1] for a in address_groups[0]], [0, 0])
-
-        node.generate(1)
-
-        # we want to reset so that the "" label has what's expected.
-        # otherwise we're off by exactly the fee amount as that's mined
-        # and matures in the next 100 blocks
-        node.sendfrom("", common_address, fee)
-        amount_to_send = 1.0
-
-        # Create labels and make sure subsequent label API calls
-        # recognize the label/address associations.
-        labels = [Label(name) for name in ("a", "b", "c", "d", "e")]
-        for label in labels:
-            label.add_receive_address(node.getlabeladdress(label.name))
-            label.verify(node)
-
-        # Send a transaction to each label, and make sure this forces
-        # getlabeladdress to generate a new receiving address.
-        for label in labels:
-            node.sendtoaddress(label.receive_address, amount_to_send)
-            label.add_receive_address(node.getlabeladdress(label.name))
-            label.verify(node)
-
-        # Check the amounts received.
-        node.generate(1)
-        for label in labels:
-            assert_equal(
-                node.getreceivedbyaddress(label.addresses[0]), amount_to_send)
-            assert_equal(node.getreceivedbylabel(label.name), amount_to_send)
-
-        # Check that sendfrom label reduces listaccounts balances.
-        for i, label in enumerate(labels):
-            to_label = labels[(i+1) % len(labels)]
-            node.sendfrom(label.name, to_label.receive_address, amount_to_send)
-        node.generate(1)
-        for label in labels:
-            label.add_receive_address(node.getlabeladdress(label.name))
-            label.verify(node)
-            assert_equal(node.getreceivedbylabel(label.name), 2)
-            node.move(label.name, "", node.getbalance(label.name))
-            label.verify(node)
-        node.generate(101)
-        expected_account_balances = {"": 5200}
-        for label in labels:
-            expected_account_balances[label.name] = 0
-        assert_equal(node.listaccounts(), expected_account_balances)
-        assert_equal(node.getbalance(""), 5200)
-
-        # Check that setlabel can assign a label to a new unused address.
-        for label in labels:
-            address = node.getlabeladdress("")
-            node.setlabel(address, label.name)
-            label.add_address(address)
-            label.verify(node)
-            assert(address not in node.getaddressesbyaccount(""))
-
-        # Check that addmultisigaddress can assign labels.
-        for label in labels:
-            addresses = []
-            for x in range(10):
-                addresses.append(node.getnewaddress())
-            multisig_address = node.addmultisigaddress(5, addresses, label.name)['address']
-            label.add_address(multisig_address)
-            label.verify(node)
-            node.sendfrom("", multisig_address, 50)
-        node.generate(101)
-        for label in labels:
-            assert_equal(node.getbalance(label.name), 50)
-
-        # Check that setlabel can change the label of an address from a
-        # different label.
-        change_label(node, labels[0].addresses[0], labels[0], labels[1])
-
-        # Check that setlabel can change the label of an address which
-        # is the receiving address of a different label.
-        change_label(node, labels[0].receive_address, labels[0], labels[1])
-
-        # Check that setlabel can set the label of an address already
-        # in the label. This is a no-op.
-        change_label(node, labels[2].addresses[0], labels[2], labels[2])
-
-        # Check that setlabel can set the label of an address which is
-        # already the receiving address of the label. It would probably make
-        # sense for this to be a no-op, but right now it resets the receiving
-        # address, causing getlabeladdress to return a brand new address.
-        change_label(node, labels[2].receive_address, labels[2], labels[2])
-
-class Label:
-    def __init__(self, name):
-        # Label name
-        self.name = name
-        # Current receiving address associated with this label.
-        self.receive_address = None
-        # List of all addresses assigned with this label
-        self.addresses = []
-
-    def add_address(self, address):
-        assert_equal(address not in self.addresses, True)
-        self.addresses.append(address)
-
-    def add_receive_address(self, address):
-        self.add_address(address)
-        self.receive_address = address
-
-    def verify(self, node):
-        if self.receive_address is not None:
-            assert self.receive_address in self.addresses
-            assert_equal(node.getlabeladdress(self.name), self.receive_address)
-
-        for address in self.addresses:
-            assert_equal(node.getaccount(address), self.name)
-
-        assert_equal(
-            set(node.getaddressesbyaccount(self.name)), set(self.addresses))
-
-
-def change_label(node, address, old_label, new_label):
-    assert_equal(address in old_label.addresses, True)
-    node.setlabel(address, new_label.name)
-
-    old_label.addresses.remove(address)
-    new_label.add_address(address)
-
-    # Calling setlabel on an address which was previously the receiving
-    # address of a different label should reset the receiving address of
-    # the old label, causing getlabeladdress to return a brand new
-    # address.
-    if address == old_label.receive_address:
-        new_address = node.getlabeladdress(old_label.name)
-        assert_equal(new_address not in old_label.addresses, True)
-        assert_equal(new_address not in new_label.addresses, True)
-        old_label.add_receive_address(new_address)
-
-    old_label.verify(node)
-    new_label.verify(node)
-
-
-if __name__ == '__main__':
-    WalletLabelsTest().main()
diff --git a/test/functional/wallet_labels.py b/test/functional/wallet_labels.py
new file mode 100755
index 0000000000..b2695e681f
--- /dev/null
+++ b/test/functional/wallet_labels.py
@@ -0,0 +1,206 @@
+#!/usr/bin/env python3
+# Copyright (c) 2016-2017 The Bitcoin Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+"""Test label RPCs.
+
+RPCs tested are:
+    - getlabeladdress
+    - getaddressesbyaccount
+    - listaddressgroupings
+    - setlabel
+    - sendfrom (with account arguments)
+    - move (with account arguments)
+"""
+
+from test_framework.test_framework import BitcoinTestFramework
+from test_framework.util import assert_equal
+
+class WalletLabelsTest(BitcoinTestFramework):
+    def set_test_params(self):
+        self.setup_clean_chain = True
+        self.num_nodes = 1
+        self.extra_args = [[]]
+
+    def run_test(self):
+        node = self.nodes[0]
+        # Check that there's no UTXO on any of the nodes
+        assert_equal(len(node.listunspent()), 0)
+
+        # Note each time we call generate, all generated coins go into
+        # the same address, so we call twice to get two addresses w/50 each
+        node.generate(1)
+        node.generate(101)
+        assert_equal(node.getbalance(), 100)
+
+        # there should be 2 address groups
+        # each with 1 address with a balance of 50 Bitcoins
+        address_groups = node.listaddressgroupings()
+        assert_equal(len(address_groups), 2)
+        # the addresses aren't linked now, but will be after we send to the
+        # common address
+        linked_addresses = set()
+        for address_group in address_groups:
+            assert_equal(len(address_group), 1)
+            assert_equal(len(address_group[0]), 2)
+            assert_equal(address_group[0][1], 50)
+            linked_addresses.add(address_group[0][0])
+
+        # send 50 from each address to a third address not in this wallet
+        # There's some fee that will come back to us when the miner reward
+        # matures.
+        common_address = "msf4WtN1YQKXvNtvdFYt9JBnUD2FB41kjr"
+        txid = node.sendmany(
+            fromaccount="",
+            amounts={common_address: 100},
+            subtractfeefrom=[common_address],
+            minconf=1,
+        )
+        tx_details = node.gettransaction(txid)
+        fee = -tx_details['details'][0]['fee']
+        # there should be 1 address group, with the previously
+        # unlinked addresses now linked (they both have 0 balance)
+        address_groups = node.listaddressgroupings()
+        assert_equal(len(address_groups), 1)
+        assert_equal(len(address_groups[0]), 2)
+        assert_equal(set([a[0] for a in address_groups[0]]), linked_addresses)
+        assert_equal([a[1] for a in address_groups[0]], [0, 0])
+
+        node.generate(1)
+
+        # we want to reset so that the "" label has what's expected.
+        # otherwise we're off by exactly the fee amount as that's mined
+        # and matures in the next 100 blocks
+        node.sendfrom("", common_address, fee)
+        amount_to_send = 1.0
+
+        # Create labels and make sure subsequent label API calls
+        # recognize the label/address associations.
+        labels = [Label(name) for name in ("a", "b", "c", "d", "e")]
+        for label in labels:
+            label.add_receive_address(node.getlabeladdress(label.name))
+            label.verify(node)
+
+        # Send a transaction to each label, and make sure this forces
+        # getlabeladdress to generate a new receiving address.
+        for label in labels:
+            node.sendtoaddress(label.receive_address, amount_to_send)
+            label.add_receive_address(node.getlabeladdress(label.name))
+            label.verify(node)
+
+        # Check the amounts received.
+        node.generate(1)
+        for label in labels:
+            assert_equal(
+                node.getreceivedbyaddress(label.addresses[0]), amount_to_send)
+            assert_equal(node.getreceivedbylabel(label.name), amount_to_send)
+
+        # Check that sendfrom label reduces listaccounts balances.
+        for i, label in enumerate(labels):
+            to_label = labels[(i+1) % len(labels)]
+            node.sendfrom(label.name, to_label.receive_address, amount_to_send)
+        node.generate(1)
+        for label in labels:
+            label.add_receive_address(node.getlabeladdress(label.name))
+            label.verify(node)
+            assert_equal(node.getreceivedbylabel(label.name), 2)
+            node.move(label.name, "", node.getbalance(label.name))
+            label.verify(node)
+        node.generate(101)
+        expected_account_balances = {"": 5200}
+        for label in labels:
+            expected_account_balances[label.name] = 0
+        assert_equal(node.listaccounts(), expected_account_balances)
+        assert_equal(node.getbalance(""), 5200)
+
+        # Check that setlabel can assign a label to a new unused address.
+        for label in labels:
+            address = node.getlabeladdress("")
+            node.setlabel(address, label.name)
+            label.add_address(address)
+            label.verify(node)
+            assert(address not in node.getaddressesbyaccount(""))
+
+        # Check that addmultisigaddress can assign labels.
+        for label in labels:
+            addresses = []
+            for x in range(10):
+                addresses.append(node.getnewaddress())
+            multisig_address = node.addmultisigaddress(5, addresses, label.name)['address']
+            label.add_address(multisig_address)
+            label.verify(node)
+            node.sendfrom("", multisig_address, 50)
+        node.generate(101)
+        for label in labels:
+            assert_equal(node.getbalance(label.name), 50)
+
+        # Check that setlabel can change the label of an address from a
+        # different label.
+        change_label(node, labels[0].addresses[0], labels[0], labels[1])
+
+        # Check that setlabel can change the label of an address which
+        # is the receiving address of a different label.
+        change_label(node, labels[0].receive_address, labels[0], labels[1])
+
+        # Check that setlabel can set the label of an address already
+        # in the label. This is a no-op.
+        change_label(node, labels[2].addresses[0], labels[2], labels[2])
+
+        # Check that setlabel can set the label of an address which is
+        # already the receiving address of the label. It would probably make
+        # sense for this to be a no-op, but right now it resets the receiving
+        # address, causing getlabeladdress to return a brand new address.
+        change_label(node, labels[2].receive_address, labels[2], labels[2])
+
+class Label:
+    def __init__(self, name):
+        # Label name
+        self.name = name
+        # Current receiving address associated with this label.
+        self.receive_address = None
+        # List of all addresses assigned with this label
+        self.addresses = []
+
+    def add_address(self, address):
+        assert_equal(address not in self.addresses, True)
+        self.addresses.append(address)
+
+    def add_receive_address(self, address):
+        self.add_address(address)
+        self.receive_address = address
+
+    def verify(self, node):
+        if self.receive_address is not None:
+            assert self.receive_address in self.addresses
+            assert_equal(node.getlabeladdress(self.name), self.receive_address)
+
+        for address in self.addresses:
+            assert_equal(node.getaccount(address), self.name)
+
+        assert_equal(
+            set(node.getaddressesbyaccount(self.name)), set(self.addresses))
+
+
+def change_label(node, address, old_label, new_label):
+    assert_equal(address in old_label.addresses, True)
+    node.setlabel(address, new_label.name)
+
+    old_label.addresses.remove(address)
+    new_label.add_address(address)
+
+    # Calling setlabel on an address which was previously the receiving
+    # address of a different label should reset the receiving address of
+    # the old label, causing getlabeladdress to return a brand new
+    # address.
+    if address == old_label.receive_address:
+        new_address = node.getlabeladdress(old_label.name)
+        assert_equal(new_address not in old_label.addresses, True)
+        assert_equal(new_address not in new_label.addresses, True)
+        old_label.add_receive_address(new_address)
+
+    old_label.verify(node)
+    new_label.verify(node)
+
+
+if __name__ == '__main__':
+    WalletLabelsTest().main()
-- 
cgit v1.2.3