Fix unittests for pygraphene@develop

Author: xeroc

bitshares/storage.py

@@ -8,9 +8,9 @@
     SQLiteFile
 )
 
-
-InRamConfigurationStore.setdefault("node", "wss://node.bitshares.eu")
-SqliteConfigurationStore.setdefault("node", "wss://node.bitshares.eu")
+url = "wss://node.bitshares.eu"
+InRamConfigurationStore.setdefault("node", url)
+SqliteConfigurationStore.setdefault("node", url)
 
 
 def get_default_config_store(*args, **kwargs):
@@ -19,7 +19,7 @@ def get_default_config_store(*args, **kwargs):
     return SqliteConfigurationStore(*args, **kwargs)
 
 
-def get_default_key_store(*args, config, **kwargs):
+def get_default_key_store(config, *args, **kwargs):
     if "appname" not in kwargs:
         kwargs["appname"] = "bitshares"
     return SqliteEncryptedKeyStore(

bitshares/wallet.py

@@ -92,25 +92,38 @@ def setKeys(self, loadkeys):
             pub = format(PrivateKey(str(wif)).pubkey, self.prefix)
             self.store.add(str(wif), pub)
 
+    def is_encrypted(self):
+        """ Is the key store encrypted?
+        """
+        return self.store.is_encrypted()
+
     def unlock(self, pwd):
         """ Unlock the wallet database
         """
-        return self.store.unlock(pwd)
+        if self.store.is_encrypted():
+            return self.store.unlock(pwd)
 
     def lock(self):
         """ Lock the wallet database
         """
-        return self.store.lock()
+        if self.store.is_encrypted():
+            return self.store.lock()
+        else:
+            return False
 
     def unlocked(self):
         """ Is the wallet database unlocked?
         """
-        return not self.store.locked()
+        if self.store.is_encrypted():
+            return not self.store.locked()
+        else:
+            return True
 
     def locked(self):
         """ Is the wallet database locked?
         """
-        return self.store.locked()
+        if self.store.is_encrypted():
+            return self.store.locked()
 
     def changePassphrase(self, new_pwd):
         """ Change the passphrase for the wallet database
@@ -143,18 +156,18 @@ def addPrivateKey(self, wif):
             pub = format(PrivateKey(str(wif)).pubkey, self.prefix)
         except:
             raise InvalidWifError("Invalid Key format!")
-        if pub in self.store:
+        if str(pub) in self.store:
             raise KeyAlreadyInStoreException("Key already in the store")
-        self.store.add(str(wif), pub)
+        self.store.add(str(wif), str(pub))
 
     def getPrivateKeyForPublicKey(self, pub):
         """ Obtain the private key for a given public key
 
             :param str pub: Public Key
         """
-        if pub not in self.store:
+        if str(pub) not in self.store:
             raise KeyNotFound
-        return self.store.getPrivateKeyForPublicKey(pub)
+        return self.store.getPrivateKeyForPublicKey(str(pub))
 
     def removePrivateKeyFromPublicKey(self, pub):
         """ Remove a key from the wallet database
@@ -208,7 +221,7 @@ def getAccountFromPrivateKey(self, wif):
     def getAccountsFromPublicKey(self, pub):
         """ Obtain all accounts associated with a public key
         """
-        names = self.rpc.get_key_references([pub])
+        names = self.rpc.get_key_references([str(pub)])
         for name in names:
             for i in name:
                 yield i
@@ -219,7 +232,7 @@ def getAccountFromPublicKey(self, pub):
         # FIXME, this only returns the first associated key.
         # If the key is used by multiple accounts, this
         # will surely lead to undesired behavior
-        names = self.rpc.get_key_references([pub])[0]
+        names = self.rpc.get_key_references([str(pub)])[0]
         if not names:
             return None
         else:
@@ -229,24 +242,24 @@ def getAllAccounts(self, pub):
         """ Get the account data for a public key (all accounts found for this
             public key)
         """
-        for id in self.getAccountsFromPublicKey(pub):
+        for id in self.getAccountsFromPublicKey(str(pub)):
             try:
                 account = Account(id, blockchain_instance=self.blockchain)
             except:
                 continue
             yield {"name": account["name"],
                    "account": account,
-                   "type": self.getKeyType(account, pub),
-                   "pubkey": pub}
+                   "type": self.getKeyType(account, str(pub)),
+                   "pubkey": str(pub)}
 
     def getKeyType(self, account, pub):
         """ Get key type
         """
         for authority in ["owner", "active"]:
             for key in account[authority]["key_auths"]:
-                if pub == key[0]:
+                if str(pub) == key[0]:
                     return authority
-        if pub == account["options"]["memo_key"]:
+        if str(pub) == account["options"]["memo_key"]:
             return "memo"
         return None
 

tests/fixtures.py

@@ -9,17 +9,27 @@
 
 from bitsharesbase.operationids import operations
 
+# Configuration for unit tests
+config = storage.InRamConfigurationStore()
+config["node"] = "wss://node.bitshares.eu"
 
+# default wif key for testing
 wif = "5KQwrPbwdL6PhXujxW37FSSQZ1JiwsST4cqQzDeyXtP79zkvFD3"
+
+# bitshares instance
 bitshares = BitShares(
     keys=[wif],
     nobroadcast=True,
     num_retries=1,
-    config_store=storage.InRamConfigurationStore(),
+    config_store=config,
     key_store=storage.InRamPlainKeyStore()
 )
+
+# Set defaults
 bitshares.set_default_account("init0")
 set_shared_blockchain_instance(bitshares)
+
+# Ensure we are not going to transaction anythin on chain!
 assert bitshares.nobroadcast
 
 # Setup custom Cache
@@ -37,7 +47,8 @@ def add_to_object_cache(objects, key="id"):
 
 
 def fixture_data():
-    # Accounts.cache = dict()
+    # Clear tx buffer
+    bitshares.clear()
 
     with open(os.path.join(
         os.path.dirname(__file__),

tests/test_amount.py

@@ -13,7 +13,6 @@ def __init__(self, *args, **kwargs):
         self.asset = Asset("BTS")
         self.symbol = Asset("BTS")["symbol"]
         self.precision = Asset("BTS")["precision"]
-
         self.asset2 = Asset("EUR")
 
     def setUp(self):

tests/test_asset.py

@@ -3,17 +3,13 @@
 from bitshares.asset import Asset
 from bitshares.instance import set_shared_bitshares_instance
 from bitshares.exceptions import AssetDoesNotExistsException
+from .fixtures import fixture_data
 
 
 class Testcases(unittest.TestCase):
 
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-
-        self.bts = BitShares(
-            nobroadcast=True,
-        )
-        set_shared_bitshares_instance(self.bts)
+    def setUp(self):
+        fixture_data()
 
     def test_assert(self):
         with self.assertRaises(AssetDoesNotExistsException):
@@ -37,13 +33,3 @@ def test_properties(self):
         self.assertEqual(asset.permissions, asset["permissions"])
         self.assertIsInstance(asset.flags, dict)
         self.assertEqual(asset.flags, asset["flags"])
-
-    """
-    # Mocker comes from pytest-mock, providing an easy way to have patched objects
-    # for the life of the test.
-    def test_calls(mocker):
-        asset = Asset("USD", lazy=True, bitshares_instance=BitShares(offline=True))
-        method = mocker.patch.object(Asset, 'get_call_orders')
-        asset.calls
-        method.assert_called_with(10)
-    """

tests/test_base_objects.py

@@ -3,26 +3,22 @@
 from bitshares.instance import set_shared_bitshares_instance
 from bitshares.account import Account
 from bitshares.committee import Committee
+from .fixtures import fixture_data
 
 
 class Testcases(unittest.TestCase):
 
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-
-        self.bts = BitShares(
-            nobroadcast=True,
-        )
-        set_shared_bitshares_instance(self.bts)
+    def setUp(self):
+        fixture_data()
 
     def test_Committee(self):
         with self.assertRaises(
             exceptions.AccountDoesNotExistsException
         ):
             Committee("FOObarNonExisting")
 
-        c = Committee("init0")
-        self.assertEqual(c["id"], "1.5.0")
+        c = Committee("xeroc")
+        self.assertEqual(c["id"], "1.5.27")
         self.assertIsInstance(c.account, Account)
 
         with self.assertRaises(

tests/test_block.py

@@ -4,26 +4,20 @@
 from bitshares.block import Block, BlockHeader
 from bitshares.instance import set_shared_bitshares_instance
 from bitshares.utils import parse_time
+from .fixtures import fixture_data
 
 
 class Testcases(unittest.TestCase):
 
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-
-        self.bts = BitShares(
-            "wss://node.testnet.bitshares.eu",
-            nobroadcast=True,
-        )
-        self.bts.set_default_account("init0")
-        set_shared_bitshares_instance(self.bts)
+    def setUp(self):
+        fixture_data()
 
     def test_block(self):
         block = Block(1)
         self.assertEqual(block["previous"], "0000000000000000000000000000000000000000")
-        self.assertEqual(block.time(), parse_time('2016-01-18T10:59:20'))
+        self.assertEqual(block.time(), parse_time('2015-10-13T14:12:24'))
 
     def test_blockheader(self):
         header = BlockHeader(1)
         self.assertEqual(header["previous"], "0000000000000000000000000000000000000000")
-        self.assertEqual(header.time(), parse_time('2016-01-18T10:59:20'))
+        self.assertEqual(header.time(), parse_time('2015-10-13T14:12:24'))

tests/test_blockchain.py

@@ -5,19 +5,13 @@
 from bitshares.block import Block
 from bitshares.instance import set_shared_bitshares_instance
 from bitshares.utils import parse_time
+from .fixtures import fixture_data
 
 
 class Testcases(unittest.TestCase):
 
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-
-        self.bts = BitShares(
-            "wss://node.testnet.bitshares.eu",
-            nobroadcast=True,
-        )
-        self.bts.set_default_account("init0")
-        set_shared_bitshares_instance(self.bts)
+    def setUp(self):
+        fixture_data()
         self.chain = Blockchain(mode="head")
 
     def test_is_irv(self):