From 67437e4f0acc0acc0e27c0369ee739fc200e2461 Mon Sep 17 00:00:00 2001
From: Cryp Toon <info@1200wd.com>
Date: Sat, 3 Feb 2024 23:04:51 +0100
Subject: [PATCH] Fix mysql issues and database unittesting

---
 bitcoinlib/db.py      |  10 +-
 tests/test_tools.py   | 161 ++++++------
 tests/test_wallets.py | 592 ++++++++++++++++++++++--------------------
 3 files changed, 394 insertions(+), 369 deletions(-)

diff --git a/bitcoinlib/db.py b/bitcoinlib/db.py
index b3ebadac..f5d966d7 100644
--- a/bitcoinlib/db.py
+++ b/bitcoinlib/db.py
@@ -286,7 +286,7 @@ class DbKey(Base):
                        "depth=1 are the masterkeys children.")
     change = Column(Integer, doc="Change or normal address: Normal=0, Change=1")
     address_index = Column(BigInteger, doc="Index of address in HD key structure address level")
-    public = Column(LargeBinary(32), index=True, doc="Bytes representation of public key")
+    public = Column(LargeBinary(33), index=True, doc="Bytes representation of public key")
     private = Column(EncryptedBinary(48), doc="Bytes representation of private key")
     wif = Column(EncryptedString(128), index=True, doc="Public or private WIF (Wallet Import Format) representation")
     compressed = Column(Boolean, default=True, doc="Is key compressed or not. Default is True")
@@ -309,7 +309,7 @@ class DbKey(Base):
                                               "Default is False")
     network_name = Column(String(20), ForeignKey('networks.name'),
                           doc="Name of key network, i.e. bitcoin, litecoin, dash")
-    latest_txid = Column(LargeBinary(32), doc="TxId of latest transaction downloaded from the blockchain")
+    latest_txid = Column(LargeBinary(33), doc="TxId of latest transaction downloaded from the blockchain")
     witness_type = Column(String(20), default='segwit',
                           doc="Key witness type, only specify when using mixed wallets. Can be 'legacy', 'segwit' or "
                               "'p2sh-segwit'. Default is segwit.")
@@ -369,7 +369,7 @@ class DbTransaction(Base):
     __tablename__ = 'transactions'
     id = Column(Integer, Sequence('transaction_id_seq'), primary_key=True,
                 doc="Unique transaction index for internal usage")
-    txid = Column(LargeBinary(32), index=True, doc="Bytes representation of transaction ID")
+    txid = Column(LargeBinary(33), index=True, doc="Bytes representation of transaction ID")
     wallet_id = Column(Integer, ForeignKey('wallets.id'), index=True,
                        doc="ID of wallet which contains this transaction")
     account_id = Column(Integer, index=True, doc="ID of account")
@@ -443,7 +443,7 @@ class DbTransactionInput(Base):
     witnesses = Column(LargeBinary, doc="Witnesses (signatures) used in Segwit transaction inputs")
     witness_type = Column(String(20), default='segwit',
                           doc="Type of transaction, can be legacy, segwit or p2sh-segwit. Default is segwit")
-    prev_txid = Column(LargeBinary(32),
+    prev_txid = Column(LargeBinary(33),
                        doc="Transaction hash of previous transaction. Previous unspent outputs (UTXO) is spent "
                            "in this input")
     output_n = Column(BigInteger, doc="Output_n of previous transaction output that is spent in this input")
@@ -487,7 +487,7 @@ class DbTransactionOutput(Base):
                              "'nulldata', 'unknown', 'p2wpkh', 'p2wsh', 'p2tr'. Default is p2pkh")
     value = Column(BigInteger, default=0, doc="Total transaction output value")
     spent = Column(Boolean, default=False, doc="Indicated if output is already spent in another transaction")
-    spending_txid = Column(LargeBinary(32), doc="Transaction hash of input which spends this output")
+    spending_txid = Column(LargeBinary(33), doc="Transaction hash of input which spends this output")
     spending_index_n = Column(Integer, doc="Index number of transaction input which spends this output")
 
     __table_args__ = (UniqueConstraint('transaction_id', 'output_n', name='constraint_transaction_output_unique'),)
diff --git a/tests/test_tools.py b/tests/test_tools.py
index 6eb62a22..91855a4b 100644
--- a/tests/test_tools.py
+++ b/tests/test_tools.py
@@ -4,6 +4,7 @@
 #    Unit Tests for Bitcoinlib Tools
 #    © 2018 - 2024 January - 1200 Web Development <http://1200wd.com/>
 #
+
 import ast
 import os
 import sys
@@ -13,7 +14,6 @@
 try:
     import mysql.connector
     import psycopg2
-    from parameterized import parameterized_class
     from psycopg2 import sql
     from psycopg2.extensions import ISOLATION_LEVEL_AUTOCOMMIT
 except ImportError:
@@ -27,60 +27,61 @@
 DATABASE_NAME = 'bitcoinlib_unittest'
 
 
-def init_sqlite(_):
-    if os.path.isfile(SQLITE_DATABASE_FILE):
-        os.remove(SQLITE_DATABASE_FILE)
-
-
-def init_postgresql(_):
-    con = psycopg2.connect(user='postgres', host='localhost', password='postgres')
-    con.set_isolation_level(ISOLATION_LEVEL_AUTOCOMMIT)
-    cur = con.cursor()
-    cur.execute(sql.SQL("DROP DATABASE IF EXISTS {}").format(
-        sql.Identifier(DATABASE_NAME))
-    )
-    cur.execute(sql.SQL("CREATE DATABASE {}").format(
-        sql.Identifier(DATABASE_NAME))
-    )
-    cur.close()
-    con.close()
-
-
-def init_mysql(_):
-    con = mysql.connector.connect(user='root', host='localhost')
-    cur = con.cursor()
-    cur.execute("DROP DATABASE IF EXISTS {}".format(DATABASE_NAME))
-    cur.execute("CREATE DATABASE {}".format(DATABASE_NAME))
-    con.commit()
-    cur.close()
-    con.close()
-
-
-# db_uris = (('sqlite:///' + SQLITE_DATABASE_FILE, init_sqlite),)
-# if UNITTESTS_FULL_DATABASE_TEST:
-#     db_uris += (
-#         ('mysql://root@localhost:3306/' + DATABASE_NAME, init_mysql),
-#         ('postgresql://postgres:postgres@localhost:5432/' + DATABASE_NAME, init_postgresql),
-#     )
+def database_init():
+    
+    def init_sqlite():
+        if os.path.isfile(SQLITE_DATABASE_FILE):
+            os.remove(SQLITE_DATABASE_FILE)
+    
+    
+    def init_postgresql():
+        con = psycopg2.connect(user='postgres', host='localhost', password='postgres')
+        con.set_isolation_level(ISOLATION_LEVEL_AUTOCOMMIT)
+        cur = con.cursor()
+        cur.execute(sql.SQL("DROP DATABASE IF EXISTS {}").format(
+            sql.Identifier(DATABASE_NAME))
+        )
+        cur.execute(sql.SQL("CREATE DATABASE {}").format(
+            sql.Identifier(DATABASE_NAME))
+        )
+        cur.close()
+        con.close()
+    
+    
+    def init_mysql():
+        con = mysql.connector.connect(user='user', host='localhost', password='password')
+        cur = con.cursor()
+        cur.execute("DROP DATABASE IF EXISTS {}".format(DATABASE_NAME))
+        cur.execute("CREATE DATABASE {}".format(DATABASE_NAME))
+        con.commit()
+        cur.close()
+        con.close()
+
+    if os.getenv('UNITTEST_DATABASE') == 'mysql':
+        init_mysql()
+        return 'mysql://user:password@localhost:3306/' + DATABASE_NAME
+    elif os.getenv('UNITTEST_DATABASE') == 'postgresql':
+        init_postgresql()
+        return 'postgresql://postgres:postgres@localhost:5432/' + DATABASE_NAME
+    else:
+        init_sqlite()
+        return SQLITE_DATABASE_FILE
 
 
-# @parameterized_class(('DATABASE_URI', 'init_fn'), db_uris)
 class TestToolsCommandLineWallet(unittest.TestCase):
 
     def setUp(self):
-        # self.init_fn()
-        init_sqlite(self)
         self.python_executable = sys.executable
         self.clw_executable = os.path.normpath(os.path.join(os.path.dirname(os.path.abspath(__file__)),
                                                             '../bitcoinlib/tools/clw.py'))
-        self.DATABASE_URI = SQLITE_DATABASE_FILE
+        self.database_uri = database_init()
 
     def test_tools_clw_create_wallet(self):
         cmd_wlt_create = '%s %s new -w test --passphrase "emotion camp sponsor curious bacon squeeze bean world ' \
                          'actual chicken obscure spray" -r -d %s' % \
-                         (self.python_executable, self.clw_executable, self.DATABASE_URI)
+                         (self.python_executable, self.clw_executable, self.database_uri)
         cmd_wlt_delete = "%s %s -w test --wallet-remove -d %s" % \
-                         (self.python_executable, self.clw_executable, self.DATABASE_URI)
+                         (self.python_executable, self.clw_executable, self.database_uri)
         output_wlt_create = "bc1qdv5tuzrluh4lzhnu59je9n83w4hkqjhgg44d5g"
         output_wlt_delete = "Wallet test has been removed"
 
@@ -99,9 +100,9 @@ def test_tools_clw_create_multisig_wallet(self):
             'MeQHdWDp'
         ]
         cmd_wlt_create = "%s %s new -w testms -m 2 2 %s -r -n testnet -d %s -o 0" % \
-                         (self.python_executable, self.clw_executable, ' '.join(key_list), self.DATABASE_URI)
+                         (self.python_executable, self.clw_executable, ' '.join(key_list), self.database_uri)
         cmd_wlt_delete = "%s %s -w testms --wallet-remove -d %s" % \
-                         (self.python_executable, self.clw_executable, self.DATABASE_URI)
+                         (self.python_executable, self.clw_executable, self.database_uri)
         output_wlt_create = "2NBrLTapyFqU4Wo29xG4QeEt8kn38KVWRR"
         output_wlt_delete = "Wallet testms has been removed"
 
@@ -118,9 +119,9 @@ def test_tools_clw_create_multisig_wallet_one_key(self):
             '5zNYeiX8'
         ]
         cmd_wlt_create = "%s %s new -w testms1 -m 2 2 %s -r -n testnet -d %s -o 0" % \
-                         (self.python_executable, self.clw_executable, ' '.join(key_list), self.DATABASE_URI)
+                         (self.python_executable, self.clw_executable, ' '.join(key_list), self.database_uri)
         cmd_wlt_delete = "%s %s -w testms1 --wallet-remove -d %s" % \
-                         (self.python_executable, self.clw_executable, self.DATABASE_URI)
+                         (self.python_executable, self.clw_executable, self.database_uri)
         output_wlt_create = "if you understood and wrote down your key: Receive address:"
         output_wlt_delete = "Wallet testms1 has been removed"
 
@@ -133,7 +134,7 @@ def test_tools_clw_create_multisig_wallet_one_key(self):
 
     def test_tools_clw_create_multisig_wallet_error(self):
         cmd_wlt_create = "%s %s new -w testms2 -m 2 a -d %s" % \
-                         (self.python_executable, self.clw_executable, self.DATABASE_URI)
+                         (self.python_executable, self.clw_executable, self.database_uri)
         output_wlt_create = "Number of total signatures (second argument) must be a numeric value"
         process = Popen(cmd_wlt_create, stdin=PIPE, stdout=PIPE, shell=True)
         poutput = process.communicate(input=b'y')
@@ -142,13 +143,13 @@ def test_tools_clw_create_multisig_wallet_error(self):
     def test_tools_clw_transaction_with_script(self):
         cmd_wlt_create = '%s %s new -w test2 --passphrase "emotion camp sponsor curious bacon squeeze bean world ' \
                          'actual chicken obscure spray" -r -n bitcoinlib_test -d %s' % \
-                         (self.python_executable, self.clw_executable, self.DATABASE_URI)
+                         (self.python_executable, self.clw_executable, self.database_uri)
         cmd_wlt_update = "%s %s -w test2 -x -d %s" % \
-                         (self.python_executable, self.clw_executable, self.DATABASE_URI)
+                         (self.python_executable, self.clw_executable, self.database_uri)
         cmd_wlt_transaction = "%s %s -w test2 -d %s -s 21HVXMEdxdgjNzgfERhPwX4okXZ8WijHkvu 0.5 -f 100000 -p" % \
-                              (self.python_executable, self.clw_executable, self.DATABASE_URI)
+                              (self.python_executable, self.clw_executable, self.database_uri)
         cmd_wlt_delete = "%s %s -w test2 --wallet-remove -d %s" % \
-                         (self.python_executable, self.clw_executable, self.DATABASE_URI)
+                         (self.python_executable, self.clw_executable, self.database_uri)
         output_wlt_create = "blt1qj0mgwyhxuw9p0ngj5kqnxhlrx8ypecqekm2gr7"
         output_wlt_transaction = 'Transaction pushed to network'
         output_wlt_delete = "Wallet test2 has been removed"
@@ -171,9 +172,9 @@ def test_tools_clw_transaction_with_script(self):
     def test_tools_clw_create_litecoin_segwit_wallet(self):
         cmd_wlt_create = '%s %s new -w ltcsw --passphrase "lounge chief tip frog camera build trouble write end ' \
                          'sword order share" -d %s -j segwit -n litecoin -r' % \
-                         (self.python_executable, self.clw_executable, self.DATABASE_URI)
+                         (self.python_executable, self.clw_executable, self.database_uri)
         cmd_wlt_delete = "%s %s -w ltcsw --wallet-remove -d %s" % \
-                         (self.python_executable, self.clw_executable, self.DATABASE_URI)
+                         (self.python_executable, self.clw_executable, self.database_uri)
         output_wlt_create = "ltc1qgc7c2z56rr4lftg0fr8tgh2vknqc3yuydedu6m"
         output_wlt_delete = "Wallet ltcsw has been removed"
 
@@ -194,9 +195,9 @@ def test_tools_clw_create_multisig_wallet_p2sh_segwit(self):
             '7FW6wpKW'
         ]
         cmd_wlt_create = "%s %s new -w testms-p2sh-segwit -m 2 3 %s -r -j p2sh-segwit -d %s -o 0" % \
-                         (self.python_executable, self.clw_executable, ' '.join(key_list), self.DATABASE_URI)
+                         (self.python_executable, self.clw_executable, ' '.join(key_list), self.database_uri)
         cmd_wlt_delete = "%s %s -w testms-p2sh-segwit --wallet-remove -d %s" % \
-                         (self.python_executable, self.clw_executable, self.DATABASE_URI)
+                         (self.python_executable, self.clw_executable, self.database_uri)
         output_wlt_create = "3MtNi5U2cjs3EcPizzjarSz87pU9DTANge"
         output_wlt_delete = "Wallet testms-p2sh-segwit has been removed"
 
@@ -218,7 +219,7 @@ def test_tools_wallet_create_from_key(self):
         phrase = ("hover rescue clock ocean strategy post melt banner anxiety phone pink paper enhance more "
                   "copy gate bag brass raise logic stone duck muffin conduct")
         cmd_wlt_create = "%s %s new -w wlt_from_key -c \"%s\" -d %s -y" % \
-                         (self.python_executable, self.clw_executable, phrase, self.DATABASE_URI)
+                         (self.python_executable, self.clw_executable, phrase, self.database_uri)
         output_wlt_create = "bc1qpylcrcyqa5wkwe2stzc6h7q0mhs5skxuas44w2"
 
         poutput = Popen(cmd_wlt_create, stdin=PIPE, stdout=PIPE, shell=True).communicate()
@@ -228,11 +229,11 @@ def test_tools_wallet_send_to_multi(self):
         send_str = ("-s blt1qzt90vqqjsqspuaegu9fh4e2htaxrgt0l76d9gz 0.1 "
                     "-s blt1qu825hm0a6ajg66j79x4tzkn56qmljjms97c5tp 1")
         cmd_wlt_create = "%s %s new -w wallet_send_to_multi -d %s -n bitcoinlib_test -yq" % \
-                         (self.python_executable, self.clw_executable, self.DATABASE_URI)
+                         (self.python_executable, self.clw_executable, self.database_uri)
         cmd_wlt_update = "%s %s -w wallet_send_to_multi -d %s -x" % \
-                         (self.python_executable, self.clw_executable, self.DATABASE_URI)
+                         (self.python_executable, self.clw_executable, self.database_uri)
         cmd_wlt_send = "%s %s -w wallet_send_to_multi -d %s %s" % \
-                        (self.python_executable, self.clw_executable, self.DATABASE_URI, send_str)
+                        (self.python_executable, self.clw_executable, self.database_uri, send_str)
 
         Popen(cmd_wlt_create, stdin=PIPE, stdout=PIPE, shell=True).communicate()
         Popen(cmd_wlt_update, stdin=PIPE, stdout=PIPE, shell=True).communicate()
@@ -243,31 +244,31 @@ def test_tools_wallet_empty(self):
         pk = ("zprvAWgYBBk7JR8GiejuVoZaVXtWf5zNawFbTH88uKao9qnZxBypJQNvh1tGHZghpfjUfSUiS7G7MmNw3cyakkNcNis3MjD4ic54n"
               "FY5LQxMszQ")
         cmd_wlt_create = "%s %s new -w wlt_create_and_empty -c %s -d %s -y" % \
-                         (self.python_executable, self.clw_executable, pk, self.DATABASE_URI)
+                         (self.python_executable, self.clw_executable, pk, self.database_uri)
         output_wlt_create = "bc1qqnqkjpnmr5zsxar76wxqcntp28ltly0fz6crdg"
         poutput = Popen(cmd_wlt_create, stdin=PIPE, stdout=PIPE, shell=True).communicate()
         self.assertIn(output_wlt_create, normalize_string(poutput[0]))
 
         cmd_wlt_empty = "%s %s -w wlt_create_and_empty -d %s --wallet-empty" % \
-                        (self.python_executable, self.clw_executable, self.DATABASE_URI)
+                        (self.python_executable, self.clw_executable, self.database_uri)
         poutput = Popen(cmd_wlt_empty, stdin=PIPE, stdout=PIPE, shell=True).communicate()
         self.assertIn("Removed transactions and emptied wallet", normalize_string(poutput[0]))
 
         cmd_wlt_info = "%s %s -w wlt_create_and_empty -d %s -i" % \
-                       (self.python_executable, self.clw_executable, self.DATABASE_URI)
+                       (self.python_executable, self.clw_executable, self.database_uri)
         poutput = Popen(cmd_wlt_info, stdin=PIPE, stdout=PIPE, shell=True).communicate()
         self.assertIn("- - Transactions Account 0 (0)", normalize_string(poutput[0]))
         self.assertNotIn(output_wlt_create, normalize_string(poutput[0]))
 
     def test_tools_wallet_sweep(self):
         cmd_wlt_create = "%s %s new -w wlt_sweep -d %s -n bitcoinlib_test -yq" % \
-                         (self.python_executable, self.clw_executable, self.DATABASE_URI)
+                         (self.python_executable, self.clw_executable, self.database_uri)
         cmd_wlt_update = "%s %s -w wlt_sweep -d %s -x" % \
-                         (self.python_executable, self.clw_executable, self.DATABASE_URI)
+                         (self.python_executable, self.clw_executable, self.database_uri)
         cmd_wlt_send = "%s %s -w wlt_sweep -d %s --sweep blt1qzt90vqqjsqspuaegu9fh4e2htaxrgt0l76d9gz -p" % \
-                        (self.python_executable, self.clw_executable, self.DATABASE_URI)
+                        (self.python_executable, self.clw_executable, self.database_uri)
         cmd_wlt_info = "%s %s -w wlt_sweep -d %s -i" % \
-                        (self.python_executable, self.clw_executable, self.DATABASE_URI)
+                        (self.python_executable, self.clw_executable, self.database_uri)
         Popen(cmd_wlt_create, stdin=PIPE, stdout=PIPE, shell=True).communicate()
         Popen(cmd_wlt_update, stdin=PIPE, stdout=PIPE, shell=True).communicate()
         process = Popen(cmd_wlt_send, stdin=PIPE, stdout=PIPE, shell=True)
@@ -290,34 +291,34 @@ def test_tools_wallet_multisig_cosigners(self):
         pub_key3 = ('BC11mYrL5yBtMgaYxHEUg3anvLX3gcLi8hbtwbjymReCgGiP6hYifVMi96M3ejtvZpZbDvetBfbzgRxmu22ZkqP2i7yhFge'
                     'mSkHp7BRhoDubrQvs')
         cmd_wlt_create1 = "%s %s new -w wlt_multisig_2_3_A -m 2 3 %s %s %s -d %s -n bitcoinlib_test -q" % \
-                         (self.python_executable, self.clw_executable, pk1, pub_key2, pub_key3, self.DATABASE_URI)
+                         (self.python_executable, self.clw_executable, pk1, pub_key2, pub_key3, self.database_uri)
         Popen(cmd_wlt_create1, stdin=PIPE, stdout=PIPE, shell=True).communicate()
         cmd_wlt_create2 = "%s %s new -w wlt_multisig_2_3_B -m 2 3 %s %s %s -d %s -n bitcoinlib_test -q" % \
-                         (self.python_executable, self.clw_executable, pub_key1, pub_key2, pk3, self.DATABASE_URI)
+                         (self.python_executable, self.clw_executable, pub_key1, pub_key2, pk3, self.database_uri)
         Popen(cmd_wlt_create2, stdin=PIPE, stdout=PIPE, shell=True).communicate()
 
         cmd_wlt_receive1 = "%s %s -w wlt_multisig_2_3_A -d %s -r -o 1 -q" % \
-                         (self.python_executable, self.clw_executable, self.DATABASE_URI)
+                         (self.python_executable, self.clw_executable, self.database_uri)
         output1 = Popen(cmd_wlt_receive1, stdin=PIPE, stdout=PIPE, shell=True).communicate()
         cmd_wlt_receive2 = "%s %s -w wlt_multisig_2_3_B -d %s -r -o 1 -q" % \
-                         (self.python_executable, self.clw_executable, self.DATABASE_URI)
+                         (self.python_executable, self.clw_executable, self.database_uri)
         output2 = Popen(cmd_wlt_receive2, stdin=PIPE, stdout=PIPE, shell=True).communicate()
         self.assertEqual(output1[0], output2[0])
         address = normalize_string(output1[0].strip(b'\n'))
 
         cmd_wlt_update1 = "%s %s -w wlt_multisig_2_3_A -d %s -x -o 1" % \
-                         (self.python_executable, self.clw_executable, self.DATABASE_URI)
+                         (self.python_executable, self.clw_executable, self.database_uri)
         Popen(cmd_wlt_update1, stdin=PIPE, stdout=PIPE, shell=True).communicate()
         cmd_wlt_update2 = "%s %s -w wlt_multisig_2_3_B -d %s -x -o 1" % \
-                         (self.python_executable, self.clw_executable, self.DATABASE_URI)
+                         (self.python_executable, self.clw_executable, self.database_uri)
         Popen(cmd_wlt_update2, stdin=PIPE, stdout=PIPE, shell=True).communicate()
 
         create_tx = "%s %s -w wlt_multisig_2_3_A -d %s -s %s 0.5 -o 1" % \
-                         (self.python_executable, self.clw_executable, self.DATABASE_URI, address)
+                         (self.python_executable, self.clw_executable, self.database_uri, address)
         output = Popen(create_tx, stdin=PIPE, stdout=PIPE, shell=True).communicate()
         tx_dict_str = '{' + normalize_string(output[0]).split('{', 1)[1]
         sign_tx =  "%s %s -w wlt_multisig_2_3_B -d %s -o 1 --import-tx \"%s\"" % \
-                   (self.python_executable, self.clw_executable, self.DATABASE_URI,
+                   (self.python_executable, self.clw_executable, self.database_uri,
                     tx_dict_str.replace('\r', '').replace('\n', ''))
         output = Popen(sign_tx, stdin=PIPE, stdout=PIPE, shell=True).communicate()
         response = normalize_string(output[0])
@@ -327,7 +328,7 @@ def test_tools_wallet_multisig_cosigners(self):
 
         filename = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'import_test.tx')
         sign_import_tx_file =  "%s %s -w wlt_multisig_2_3_B -d %s -o 1 --import-tx-file %s" % \
-            (self.python_executable, self.clw_executable, self.DATABASE_URI, filename)
+            (self.python_executable, self.clw_executable, self.database_uri, filename)
         output = Popen(sign_import_tx_file, stdin=PIPE, stdout=PIPE, shell=True).communicate()
         response2 = normalize_string(output[0])
         self.assertIn('2e07be62d933f5b257ac066b874df651cd6e6763795c24036904024a2b44180b', response2)
@@ -337,12 +338,12 @@ def test_tools_wallet_multisig_cosigners(self):
 
     def test_tools_transaction_options(self):
         cmd_wlt_create = "%s %s new -w test_tools_transaction_options -d %s -n bitcoinlib_test -yq" % \
-                         (self.python_executable, self.clw_executable, self.DATABASE_URI)
+                         (self.python_executable, self.clw_executable, self.database_uri)
         cmd_wlt_update = "%s %s -w test_tools_transaction_options -d %s -x" % \
-                         (self.python_executable, self.clw_executable, self.DATABASE_URI)
+                         (self.python_executable, self.clw_executable, self.database_uri)
         cmd_wlt_send = ("%s %s -w test_tools_transaction_options -d %s -s blt1qg7du8cs0scxccmfly7x252qurv7kwsy6rm4xr7 0.001 "
                         "--number-of-change-outputs 5") % \
-                       (self.python_executable, self.clw_executable, self.DATABASE_URI)
+                       (self.python_executable, self.clw_executable, self.database_uri)
         Popen(cmd_wlt_create, stdin=PIPE, stdout=PIPE, shell=True).communicate()
         Popen(cmd_wlt_update, stdin=PIPE, stdout=PIPE, shell=True).communicate()
         output = normalize_string(Popen(cmd_wlt_send, stdin=PIPE, stdout=PIPE, shell=True).communicate()[0])
@@ -352,14 +353,14 @@ def test_tools_transaction_options(self):
         self.assertTrue(tx_dict['verified'])
 
         cmd_wlt_update2 = "%s %s -w test_tools_transaction_options -d %s -ix" % \
-                         (self.python_executable, self.clw_executable, self.DATABASE_URI)
+                         (self.python_executable, self.clw_executable, self.database_uri)
         output = normalize_string(Popen(cmd_wlt_update2, stdin=PIPE, stdout=PIPE, shell=True).communicate()[0])
         output_list = [i for i in output.split('Keys')[1].split(' ') if i != '']
         first_key_id = int(output_list[1])
         address = output_list[3]
         cmd_wlt_send2 = ("%s %s -w test_tools_transaction_options -d %s "
                         "-s blt1qdjre3yw9hnt53entkp6tflhg34y4sp999emjnk 0.5 -k %d") % \
-                       (self.python_executable, self.clw_executable, self.DATABASE_URI, first_key_id)
+                       (self.python_executable, self.clw_executable, self.database_uri, first_key_id)
         output = normalize_string(Popen(cmd_wlt_send2, stdin=PIPE, stdout=PIPE, shell=True).communicate()[0])
         self.assertIn(address, output)
         self.assertIn("Transaction created", output)
diff --git a/tests/test_wallets.py b/tests/test_wallets.py
index 41898565..23b447bb 100644
--- a/tests/test_wallets.py
+++ b/tests/test_wallets.py
@@ -43,6 +43,8 @@
 DATABASEFILE_UNITTESTS_2 = os.path.join(str(BCL_DATABASE_DIR), 'bitcoinlib.unittest2.sqlite')
 DATABASE_NAME = 'bitcoinlib_test'
 DATABASE_NAME_2 = 'bitcoinlib2_test'
+# SQLITE_DATABASE_FILE = os.path.join(str(BCL_DATABASE_DIR), '%s.sqlite' % DATABASE_NAME)
+# SQLITE_DATABASE_FILE2 = os.path.join(str(BCL_DATABASE_DIR), '%s.sqlite' % DATABASE_NAME_2)
 
 db_uris = (
     ('sqlite', 'sqlite:///' + DATABASEFILE_UNITTESTS, 'sqlite:///' + DATABASEFILE_UNITTESTS_2),)
@@ -134,16 +136,45 @@ def db_remove(cls):
                     con.close()
 
 
-@parameterized_class(*params)
-class TestWalletCreate(TestWalletMixin, unittest.TestCase):
+def database_init(dbname=DATABASE_NAME):
+
+    print(os.getenv('UNITTEST_DATABASE'))
+    if os.getenv('UNITTEST_DATABASE') == 'postgresql':
+        con = psycopg2.connect(user='postgres', host='localhost', password='postgres')
+        con.set_isolation_level(ISOLATION_LEVEL_AUTOCOMMIT)
+        cur = con.cursor()
+        cur.execute(sql.SQL("DROP DATABASE IF EXISTS {}").format(
+            sql.Identifier(dbname))
+        )
+        cur.close()
+        con.close()
+        return 'postgresql://postgres:postgres@localhost:5432/' + dbname
+    elif os.getenv('UNITTEST_DATABASE') == 'mysql':
+        con = mysql.connector.connect(user='user', host='localhost', password='password')
+        cur = con.cursor()
+        cur.execute("DROP DATABASE IF EXISTS {}".format(dbname))
+        cur.execute("CREATE DATABASE {}".format(dbname))
+        con.commit()
+        cur.close()
+        con.close()
+        return 'mysql://user:password@localhost:3306/' + dbname
+    else:
+        dburi = os.path.join(str(BCL_DATABASE_DIR), '%s.sqlite' % dbname)
+        if os.path.isfile(dburi):
+            os.remove(dburi)
+        return dburi
+
+
+class TestWalletCreate(unittest.TestCase):
     wallet = None
 
     @classmethod
     def setUpClass(cls):
-        cls.db_remove()
+        # cls.database_uri = database_init()
+        cls.database_uri = database_init()
         cls.wallet = Wallet.create(
             name='test_wallet_create', witness_type='legacy',
-            db_uri=cls.DATABASE_URI)
+            db_uri=cls.database_uri)
 
     def test_wallet_create(self):
         self.assertTrue(isinstance(self.wallet, Wallet))
@@ -155,8 +186,8 @@ def test_wallet_info(self):
         self.assertIn("<Wallet(name=\"test_wallet_create\", db_uri=", repr(self.wallet))
 
     def test_wallet_exists(self):
-        self.assertTrue(wallet_exists(self.wallet.wallet_id, db_uri=self.DATABASE_URI))
-        self.assertTrue(wallet_exists('test_wallet_create', db_uri=self.DATABASE_URI))
+        self.assertTrue(wallet_exists(self.wallet.wallet_id, db_uri=self.database_uri))
+        self.assertTrue(wallet_exists('test_wallet_create', db_uri=self.database_uri))
 
     def test_wallet_key_info(self):
         self.assertIsNone(self.wallet.main_key.key().info())
@@ -175,50 +206,50 @@ def test_wallet_create_key(self):
         self.assertEqual(new_key.path, "m/44'/0'/200'/0/0")
 
     def test_wallets_list(self):
-        wallets = wallets_list(db_uri=self.DATABASE_URI)
+        wallets = wallets_list(db_uri=self.database_uri)
         self.assertEqual(wallets[0]['name'], 'test_wallet_create')
 
     def test_delete_wallet(self):
         Wallet.create(
             name='wallet_to_remove',
-            db_uri=self.DATABASE_URI)
-        self.assertEqual(wallet_delete('wallet_to_remove', db_uri=self.DATABASE_URI), 1)
+            db_uri=self.database_uri)
+        self.assertEqual(wallet_delete('wallet_to_remove', db_uri=self.database_uri), 1)
 
     def test_delete_wallet_no_private(self):
         key = ("BC19UtECk2r9PVQYhZo2RsN5SJVTmTt6NjCqGh6KH7FoVGhV9oV3f6UdyMtSzWPUBPw2S313ZJqCCNd6kTV9xbNQWzPBUVufnp"
                "sNKhh3vb3ut5bY")
-        Wallet.create('delete_watch_only_wallet', keys=key, network='bitcoinlib_test', db_uri=self.DATABASE_URI)
-        self.assertEqual(wallet_delete('delete_watch_only_wallet', db_uri=self.DATABASE_URI), 1)
+        Wallet.create('delete_watch_only_wallet', keys=key, network='bitcoinlib_test', db_uri=self.database_uri)
+        self.assertEqual(wallet_delete('delete_watch_only_wallet', db_uri=self.database_uri), 1)
 
     def test_wallet_empty(self):
-        w = Wallet.create('empty_wallet_test', db_uri=self.DATABASE_URI)
+        w = Wallet.create('empty_wallet_test', db_uri=self.database_uri)
         self.assertNotEqual(len(w.keys()), 1)
         master_key = w.public_master().key()
-        w2 = Wallet.create('empty_wallet_test2', keys=master_key, db_uri=self.DATABASE_URI)
-        w3 = Wallet.create('empty_wallet_test3', keys=master_key, db_uri=self.DATABASE_URI)
-        wallet_empty('empty_wallet_test', db_uri=self.DATABASE_URI)
-        wallet_empty('empty_wallet_test2', db_uri=self.DATABASE_URI)
-        wallet_empty(w3.wallet_id, db_uri=self.DATABASE_URI)
+        w2 = Wallet.create('empty_wallet_test2', keys=master_key, db_uri=self.database_uri)
+        w3 = Wallet.create('empty_wallet_test3', keys=master_key, db_uri=self.database_uri)
+        wallet_empty('empty_wallet_test', db_uri=self.database_uri)
+        wallet_empty('empty_wallet_test2', db_uri=self.database_uri)
+        wallet_empty(w3.wallet_id, db_uri=self.database_uri)
         self.assertEqual(len(w.keys()), 1)
         self.assertEqual(len(w2.keys()), 1)
         self.assertEqual(len(w3.keys()), 1)
         # Test exceptions
         self.assertRaisesRegex(WalletError, "Wallet 'unknown_wallet_2' not found", wallet_empty, 'unknown_wallet_2',
-                                db_uri=self.DATABASE_URI)
+                                db_uri=self.database_uri)
 
     def test_wallet_delete_not_empty(self):
-        w = Wallet.create('unempty_wallet_test', network='bitcoinlib_test', db_uri=self.DATABASE_URI)
+        w = Wallet.create('unempty_wallet_test', network='bitcoinlib_test', db_uri=self.database_uri)
         w.utxos_update()
         self.assertRaisesRegex(WalletError, "still has unspent outputs. Use 'force=True' to delete this wallet",
-                                wallet_delete, 'unempty_wallet_test', db_uri=self.DATABASE_URI)
-        self.assertTrue(wallet_delete('unempty_wallet_test', db_uri=self.DATABASE_URI, force=True))
+                                wallet_delete, 'unempty_wallet_test', db_uri=self.database_uri)
+        self.assertTrue(wallet_delete('unempty_wallet_test', db_uri=self.database_uri, force=True))
 
     def test_delete_wallet_exception(self):
-        self.assertRaisesRegex(WalletError, '', wallet_delete, 'unknown_wallet', db_uri=self.DATABASE_URI)
+        self.assertRaisesRegex(WalletError, '', wallet_delete, 'unknown_wallet', db_uri=self.database_uri)
 
     def test_wallet_unknown_error(self):
         self.assertRaisesRegex(WalletError, "Wallet 'test_wallet_create_errors10' not found",
-                                Wallet, 'test_wallet_create_errors10', db_uri=self.DATABASE_URI)
+                                Wallet, 'test_wallet_create_errors10', db_uri=self.database_uri)
 
     def test_wallet_duplicate_key_for_path(self):
         nkfp = self.wallet.key_for_path("m/44'/0'/100'/1200/1200")
@@ -233,67 +264,67 @@ def test_wallet_key_for_path_normalized(self):
     def test_wallet_create_with_passphrase(self):
         passphrase = "always reward element perfect chunk father margin slab pond suffer episode deposit"
         wlt = Wallet.create("wallet-passphrase", keys=passphrase, network='testnet', witness_type='legacy',
-                            db_uri=self.DATABASE_URI)
+                            db_uri=self.database_uri)
         key0 = wlt.get_key()
         self.assertEqual(key0.address, "mqDeXXaFnWKNWhLmAae7zHhZDW4PMsLHPp")
 
     def test_wallet_create_with_passphrase_litecoin(self):
         passphrase = "always reward element perfect chunk father margin slab pond suffer episode deposit"
         wlt = Wallet.create("wallet-passphrase-litecoin", keys=passphrase, network='litecoin',
-                            witness_type='legacy', db_uri=self.DATABASE_URI)
+                            witness_type='legacy', db_uri=self.database_uri)
         keys = wlt.get_keys(number_of_keys=5)
         self.assertEqual(keys[4].address, "Li5nEi62nAKWjv6fpixEpoLzN1pYFK621g")
 
     def test_wallet_create_change_name(self):
-        wlt = Wallet.create('test_wallet_create_change_name', db_uri=self.DATABASE_URI)
+        wlt = Wallet.create('test_wallet_create_change_name', db_uri=self.database_uri)
         wlt.name = 'wallet_renamed'
-        wlt2 = Wallet('wallet_renamed', db_uri=self.DATABASE_URI)
+        wlt2 = Wallet('wallet_renamed', db_uri=self.database_uri)
         self.assertEqual(wlt2.name, 'wallet_renamed')
 
     def test_wallet_create_errors(self):
-        Wallet.create('test_wallet_create_errors', db_uri=self.DATABASE_URI)
+        Wallet.create('test_wallet_create_errors', db_uri=self.database_uri)
         self.assertRaisesRegex(WalletError, "Wallet with name 'test_wallet_create_errors' already exists",
-                                Wallet.create, 'test_wallet_create_errors', db_uri=self.DATABASE_URI)
+                                Wallet.create, 'test_wallet_create_errors', db_uri=self.database_uri)
         self.assertRaisesRegex(WalletError, "Only bip32 or single key scheme's are supported at the moment",
                                 Wallet.create, 'test_wallet_create_errors2', scheme='raar',
-                                db_uri=self.DATABASE_URI)
+                                db_uri=self.database_uri)
         self.assertRaisesRegex(WalletError, "Wallet name '123' invalid, please include letter characters",
-                                Wallet.create, '123', db_uri=self.DATABASE_URI)
+                                Wallet.create, '123', db_uri=self.database_uri)
         self.assertRaisesRegex(WalletError, "Please enter wallet name",
-                                Wallet.create, '', db_uri=self.DATABASE_URI)
+                                Wallet.create, '', db_uri=self.database_uri)
         self.assertRaisesRegex(WalletError, "Witness type unknown not supported at the moment",
-                                Wallet.create, '', witness_type='unknown', db_uri=self.DATABASE_URI)
+                                Wallet.create, '', witness_type='unknown', db_uri=self.database_uri)
         self.assertRaisesRegex(WalletError, "Multisig wallets should use bip32 scheme not single",
                                 Wallet.create, 'test_wallet_create_errors_multisig', keys=[HDKey(), HDKey()],
-                                scheme='single', db_uri=self.DATABASE_URI)
+                                scheme='single', db_uri=self.database_uri)
         self.assertRaisesRegex(WalletError, "Password protected multisig wallets not supported",
                                 Wallet.create, 'test_wallet_create_errors_multisig2', keys=[HDKey(), HDKey()],
-                                password='geheim', db_uri=self.DATABASE_URI)
+                                password='geheim', db_uri=self.database_uri)
         self.assertRaisesRegex(WalletError, "Number of keys required to sign is greater then number of keys provided",
                                 Wallet.create, 'test_wallet_create_errors_multisig3', keys=[HDKey(), HDKey()],
-                                sigs_required=3, db_uri=self.DATABASE_URI)
+                                sigs_required=3, db_uri=self.database_uri)
         self.assertRaisesRegex(WalletError,
                                 "Network from key \(litecoin\) is different then specified network \(bitcoin\)",
                                 Wallet.create, 'test_wallet_create_errors_multisig4',
-                                keys=[HDKey(), HDKey(network='litecoin')], db_uri=self.DATABASE_URI)
+                                keys=[HDKey(), HDKey(network='litecoin')], db_uri=self.database_uri)
         self.assertRaisesRegex(WalletError, "Invalid key or address: zwqrC7h9pRj7SBhLRDG4FnkNBRQgene3y3",
                                 Wallet.create, 'test_wallet_create_errors4', keys='zwqrC7h9pRj7SBhLRDG4FnkNBRQgene3y3',
-                                db_uri=self.DATABASE_URI)
+                                db_uri=self.database_uri)
         self.assertRaisesRegex(WalletError, "Invalid key or address: zwqrC7h9pRj7SBhLRDG4FnkNBRQgene3y3",
                                 Wallet.create, 'test_wallet_create_errors4', keys='zwqrC7h9pRj7SBhLRDG4FnkNBRQgene3y3',
-                                db_uri=self.DATABASE_URI)
+                                db_uri=self.database_uri)
         k = HDKey(network='litecoin').wif_private()
         self.assertRaisesRegex(WalletError, "Invalid key or address",
                                 Wallet.create, 'test_wallet_create_errors5', keys=k, network='bitcoin',
-                                db_uri=self.DATABASE_URI)
+                                db_uri=self.database_uri)
         k = HDKey().subkey_for_path('m/1/2/3/4/5/6/7')
         self.assertRaisesRegex(WalletError, "Depth of provided public master key 7 does not correspond with key path",
                                 Wallet.create, 'test_wallet_create_errors7', keys=k,
-                                db_uri=self.DATABASE_URI)
+                                db_uri=self.database_uri)
 
     def test_wallet_rename_duplicate(self):
-        Wallet.create('test_wallet_rename_duplicate1', db_uri=self.DATABASE_URI)
-        w2 = Wallet.create('test_wallet_rename_duplicate2', db_uri=self.DATABASE_URI)
+        Wallet.create('test_wallet_rename_duplicate1', db_uri=self.database_uri)
+        w2 = Wallet.create('test_wallet_rename_duplicate2', db_uri=self.database_uri)
 
         def test_func():
             w2.name = 'test_wallet_rename_duplicate1'
@@ -302,7 +333,7 @@ def test_func():
                                 test_func)
 
     def test_wallet_as_dict_json(self):
-        wallet = Wallet.create("test_wallet_as_dict_json", db_uri=self.DATABASE_URI, network='bitcoinlib_test')
+        wallet = Wallet.create("test_wallet_as_dict_json", db_uri=self.database_uri, network='bitcoinlib_test')
         self.assertTrue(wallet.as_dict())
         self.assertTrue(wallet.as_json())
 
@@ -313,7 +344,7 @@ def test_wallet_create_bip38(self):
         k = HDKey().from_passphrase(passphrase, witness_type='legacy')
         ke = k.encrypt('hoihoi')
         w = wallet_create_or_open('kewallet', ke, password='hoihoi', network='bitcoin', witness_type='legacy',
-                                  db_uri=self.DATABASE_URI)
+                                  db_uri=self.database_uri)
         self.assertEqual(k.private_hex, w.main_key.key_private.hex())
 
     def test_wallet_create_bip38_segwit(self):
@@ -322,22 +353,21 @@ def test_wallet_create_bip38_segwit(self):
         passphrase = "region kite swamp float card flag chalk click gadget share wage clever"
         k = HDKey().from_passphrase(passphrase)
         ke = k.encrypt('hoihoi')
-        w = wallet_create_or_open('kewallet', ke, password='hoihoi', network='bitcoin', db_uri=self.DATABASE_URI)
+        w = wallet_create_or_open('kewallet', ke, password='hoihoi', network='bitcoin', db_uri=self.database_uri)
         self.assertEqual(k.private_hex, w.main_key.key_private.hex())
 
 
-@parameterized_class(*params)
-class TestWalletImport(TestWalletMixin, unittest.TestCase):
+class TestWalletImport(unittest.TestCase):
 
     @classmethod
     def setUpClass(cls):
-        cls.db_remove()
+        cls.database_uri = database_init()
 
     def test_wallet_import(self):
         keystr = 'tprv8ZgxMBicQKsPeWn8NtYVK5Hagad84UEPEs85EciCzf8xYWocuJovxsoNoxZAgfSrCp2xa6DdhDrzYVE8UXF75r2dKePy' \
                  'A7irEvBoe4aAn52'
         wallet_import = Wallet.create(
-            db_uri=self.DATABASE_URI,
+            db_uri=self.database_uri,
             name='test_wallet_import',
             network='testnet',
             keys=keystr)
@@ -350,7 +380,7 @@ def test_wallet_import_account(self):
         accountkey = 'tprv8h4wEmfC2aSckSCYa68t8MhL7F8p9xAy322B5d6ipzY5ZWGGwksJMoajMCqd73cP4EVRygPQubgJPu9duBzPn3QV' \
                      '8Y7KbKUnaMzx9nnsSvh'
         wallet_import = Wallet.create(
-            db_uri=self.DATABASE_URI,
+            db_uri=self.database_uri,
             name='test_wallet_import_account',
             keys=accountkey,
             network='testnet',
@@ -365,7 +395,7 @@ def test_wallet_import_account_new_keys(self):
         accountkey = 'tprv8h4wEmfC2aSckSCYa68t8MhL7F8p9xAy322B5d6ipzY5ZWGGwksJMoajMCqd73cP4EVRygPQubgJPu9duBzPn3QV' \
                      '8Y7KbKUnaMzx9nnsSvh'
         wallet_import = Wallet.create(
-            db_uri=self.DATABASE_URI,
+            db_uri=self.database_uri,
             name='test_wallet_import_account_new_key',
             keys=accountkey,
             network='testnet',
@@ -384,7 +414,7 @@ def test_wallet_import_public_wallet(self):
         pubkey = 'tpubDDkyPBhSAx8DFYxx5aLjvKH6B6Eq2eDK1YN76x1WeijE8eVUswpibGbv8zJjD6yLDHzVcqWzSp2fWVFhEW9XnBssFqMwt' \
                  '9SrsVeBeqfBbR3'
         pubwal = Wallet.create(
-            db_uri=self.DATABASE_URI,
+            db_uri=self.database_uri,
             name='test_wallet_import_public_wallet',
             keys=pubkey,
             network='testnet',
@@ -396,7 +426,7 @@ def test_wallet_import_litecoin(self):
         accountkey = 'Ltpv71G8qDifUiNet6mn25D7GPAVLZeaFRWzDABxx5xNeigVpFEviHK1ZggPS1kbtegB3U2i8w6ToNfM5sdvEQPW' \
                      'tov4KWyQ5NxWUd3oDWXQb4C'
         wallet_import = Wallet.create(
-            db_uri=self.DATABASE_URI,
+            db_uri=self.database_uri,
             name='test_wallet_litecoin',
             keys=accountkey,
             network='litecoin')
@@ -408,7 +438,7 @@ def test_wallet_import_litecoin(self):
     def test_wallet_import_key_network_error(self):
         w = Wallet.create(
             name='Wallet Error',
-            db_uri=self.DATABASE_URI)
+            db_uri=self.database_uri)
         self.assertRaisesRegex(WalletError,
                                 "Network litecoin not available in this wallet, please create an account "
                                 "for this network first.",
@@ -420,7 +450,7 @@ def test_wallet_import_hdwif(self):
         wif = \
             'zpub6s7HTSrGmNUWSgfbDMhYbXVuxA14yNnycS25v6ogicEauzUrRUkuCLQUWbJXP1NyXNqGmwpU6hZw7vr22a4yspwH8XQFjjwRmxC' \
             'KkXdDAXN'
-        w = Wallet.create("wif_import_p2wpkh", wif, db_uri=self.DATABASE_URI)
+        w = Wallet.create("wif_import_p2wpkh", wif, db_uri=self.database_uri)
         self.assertEqual(w.get_key().address, "bc1qruvyu8f2tg06zhysytdsc3qlngnpfzn0juwssx")
         self.assertEqual(w.get_key_change().address, "bc1qg6h45txt82x87uvv3ndm82xsf3wjknq8j7sufh")
 
@@ -428,7 +458,7 @@ def test_wallet_import_hdwif(self):
         wif = \
             'ypub6YMgBd4GfQjtxUf8ExorFUQEpBfUYTDz7E1tvfNgDqZeDEUuNNVXSNfsebis2cyeqWYXx6yaBBEQV7sJW3NGoXw5wsp9kkEsB2D' \
             'qiVquYLE'
-        w = Wallet.create("wif_import_p2sh_p2wpkh", wif, db_uri=self.DATABASE_URI)
+        w = Wallet.create("wif_import_p2sh_p2wpkh", wif, db_uri=self.database_uri)
         self.assertEqual(w.get_key().address, "3EFDqEWcrzyidoCXhxaUDB28pVtgX3YuiR")
         self.assertEqual(w.get_key_change().address, "33Un3fDSdT2hsuqyuHiCci1GyUbiyZEWHW")
 
@@ -439,7 +469,7 @@ def test_wallet_import_hdwif(self):
         wif2 = \
             'Zpub74JTMKMB9cTWwE9Hs4UVaHvddqPtR51D99x2B5EGyXyxEg3PW77vfmD15RZ86TVdwwwuUaCueBtvaL921mgyKe9Ya6LHCaMXnEp' \
             '1PMw4vDy'
-        w = Wallet.create("wif_import_p2wsh", [wif1, wif2], cosigner_id=0, db_uri=self.DATABASE_URI)
+        w = Wallet.create("wif_import_p2wsh", [wif1, wif2], cosigner_id=0, db_uri=self.database_uri)
         self.assertEqual(w.get_key().address, "bc1qhk5pd2fh0uea8z2wkceuf8eqlxsnkxm0hlt6qvfv346evqnfyumqucpqew")
         self.assertEqual(w.get_key_change().address, "bc1qyn73qh408ry38twxnj4aqzuyv7j6euwhwt2qtzayg673vtw2a4rsn7jlek")
 
@@ -454,14 +484,14 @@ def test_wallet_import_hdwif(self):
             'Ypub6jVwyh6yYiRoA5zAnGY1g88G5LdaxkHX65d2kSW97yTBAF1RQwAs3UGPz8bX7LvQfg8tc9MQz7eZ79qVigELqSJzfFbGmPak4PZ' \
             'rvW8fZXy'
         w = Wallet.create("wif_import_p2sh_p2wsh", [wif1, wif2, wif3], sigs_required=2, cosigner_id=0,
-                          db_uri=self.DATABASE_URI)
+                          db_uri=self.database_uri)
         self.assertEqual(w.get_key().address, "3BeYQTUgrGPQMHDJcch6mF7G7sRrNYkRhP")
         self.assertEqual(w.get_key_change().address, "3PFD1qkgbaeeDnX38Smerb5vAPBkDVkhcm")
 
     def test_wallet_import_master_key(self):
         k = HDKey()
         w = Wallet.create('test_wallet_import_master_key', keys=k.public_master(),
-                          db_uri=self.DATABASE_URI)
+                          db_uri=self.database_uri)
         self.assertFalse(w.main_key.is_private)
         self.assertRaisesRegex(WalletError, "Please supply a valid private BIP32 master key with key depth 0",
                                 w.import_master_key, k.public())
@@ -475,7 +505,7 @@ def test_wallet_import_master_key(self):
 
         k2 = HDKey()
         w2 = Wallet.create('test_wallet_import_master_key2', keys=k2.subkey_for_path("m/32'"), scheme='single',
-                           db_uri=self.DATABASE_URI)
+                           db_uri=self.database_uri)
         self.assertRaisesRegex(WalletError, "Main key is already a private key, cannot import key",
                                 w2.import_master_key, k2)
         w2.main_key = None
@@ -484,23 +514,22 @@ def test_wallet_import_master_key(self):
 
         k3 = HDKey()
         w3 = Wallet.create('test_wallet_import_master_key3', keys=k3.subkey_for_path("m/32'").public(),
-                           scheme='single', db_uri=self.DATABASE_URI)
+                           scheme='single', db_uri=self.database_uri)
         self.assertRaisesRegex(WalletError, "Current main key is not a valid BIP32 public master key",
                                 w3.import_master_key, k3)
 
 
-@parameterized_class(*params)
-class TestWalletExport(TestWalletMixin, unittest.TestCase):
+class TestWalletExport(unittest.TestCase):
 
     @classmethod
     def setUpClass(cls):
-        cls.db_remove()
+        cls.database_uri = database_init()
 
     def test_wallet_export_hdwifs(self):
         # p2wpkh
         p = 'garage million cheese nephew original subject pass reward month practice advance decide'
         w = Wallet.create("wif_import_p2wpkh", p, network='bitcoin', witness_type='segwit',
-                          db_uri=self.DATABASE_URI)
+                          db_uri=self.database_uri)
         wif = 'zpub6s7HTSrGmNUWSgfbDMhYbXVuxA14yNnycS25v6ogicEauzUrRUkuCLQUWbJXP1NyXNqGmwpU6hZw7vr22a4yspwH8XQFjjwRmx' \
               'CKkXdDAXN'
         self.assertEqual(w.account(0).key().wif_public(witness_type=w.witness_type), wif)
@@ -509,7 +538,7 @@ def test_wallet_export_hdwifs(self):
         # # p2sh_p2wpkh
         p = 'cluster census trash van rack skill feed inflict mixture vocal crew sea'
         w = Wallet.create("wif_import_p2sh_p2wpkh", p, network='bitcoin', witness_type='p2sh-segwit',
-                          db_uri=self.DATABASE_URI)
+                          db_uri=self.database_uri)
         wif = 'ypub6YMgBd4GfQjtxUf8ExorFUQEpBfUYTDz7E1tvfNgDqZeDEUuNNVXSNfsebis2cyeqWYXx6yaBBEQV7sJW3NGoXw5wsp9kkEsB2' \
               'DqiVquYLE'
         self.assertEqual(w.wif(is_private=False), wif)
@@ -523,7 +552,7 @@ def test_wallet_export_hdwifs(self):
             'Zpub74JTMKMB9cTWwE9Hs4UVaHvddqPtR51D99x2B5EGyXyxEg3PW77vfmD15RZ86TVdwwwuUaCueBtvaL921mgyKe9Ya6LHCaMXnEp1'
             'PMw4vDy']
         w = Wallet.create("wif_import_p2wsh", [p1, p2], witness_type='segwit', network='bitcoin', cosigner_id=0,
-                          db_uri=self.DATABASE_URI)
+                          db_uri=self.database_uri)
         for wif in w.wif(is_private=False):
             self.assertIn(wif, wifs)
 
@@ -539,24 +568,25 @@ def test_wallet_export_hdwifs(self):
             'Ypub6jVwyh6yYiRoA5zAnGY1g88G5LdaxkHX65d2kSW97yTBAF1RQwAs3UGPz8bX7LvQfg8tc9MQz7eZ79qVigELqSJzfFbGmPak4PZr'
             'vW8fZXy']
         w = Wallet.create("wif_import_p2sh_p2wsh", [p1, p2, p3], sigs_required=2, witness_type='p2sh-segwit',
-                          network='bitcoin', cosigner_id=0, db_uri=self.DATABASE_URI)
+                          network='bitcoin', cosigner_id=0, db_uri=self.database_uri)
         for wif in w.wif(is_private=False):
             self.assertIn(wif, wifs)
 
 
-@parameterized_class(*params)
-class TestWalletKeys(TestWalletMixin, unittest.TestCase):
+class TestWalletKeys(unittest.TestCase):
+    private_wif = None
+    database_uri = None
     wallet = None
 
     @classmethod
     def setUpClass(cls):
-        cls.db_remove()
+        cls.database_uri = database_init()
         cls.private_wif = 'xprv9s21ZrQH143K24Mfq5zL5MhWK9hUhhGbd45hLXo2Pq2oqzMMo63oStZzF9ySUHZw5qJkk5LCALAhXS' \
                           'XoCmCSnStRvgwLBtcbGsg1PeKT2en'
         cls.wallet = Wallet.create(
             keys=cls.private_wif,
             name='test_wallet_keys',
-            db_uri=cls.DATABASE_URI)
+            db_uri=cls.database_uri)
         cls.wallet.new_key()
         cls.wallet.new_key_change()
 
@@ -594,10 +624,10 @@ def test_wallet_keys_method_keys_change(self):
         self.assertEqual(self.wallet.keys_address_change()[0].address, '13uQKuiWwWp15BsEijnpKZSuTuHVTpZMvP')
 
     def test_wallet_keys_single_key(self):
-        self.db_remove()
+        # self.db_remove()
         wk = 'xprv9s21ZrQH143K3tCgu8uhkA2fw9F9opbvoNNzh5wcuEvNHbCU6Kg3c6dam2a6cw4UYeDxAsgBorAqXp2nsoYS84DqYMwkzxZ15' \
              'ujRHzmBMxE'
-        w = Wallet.create('test_wallet_keys_single_key', wk, scheme='single', db_uri=self.DATABASE_URI)
+        w = Wallet.create('test_wallet_keys_single_key', wk, scheme='single', db_uri=self.database_uri)
         self.assertEqual(w.new_key(), w.new_key())
         self.assertRaisesRegex(WalletError,
                                 "Single wallet has only one \(master\)key. Use get_key\(\) or main_key\(\) method",
@@ -605,7 +635,7 @@ def test_wallet_keys_single_key(self):
 
     def test_wallet_create_uncompressed_masterkey(self):
         wlt = wallet_create_or_open('uncompressed_test', keys='68vBWcBndYGLpd4KmeNTk1gS1A71zyDX6uVQKCxq6umYKyYUav5',
-                                    network='bitcoinlib_test', witness_type='legacy', db_uri=self.DATABASE_URI)
+                                    network='bitcoinlib_test', witness_type='legacy', db_uri=self.database_uri)
         wlt.get_key()
         wlt.utxos_update()
         self.assertIsNone(wlt.sweep('216xtQvbcG4o7Yz33n7VCGyaQhiytuvoqJY', offline=False).error)
@@ -615,13 +645,13 @@ def test_wallet_create_invalid_key(self):
         key_correct = HDKey(witness_type='segwit', network='testnet')
         key_invalid = HDKey(witness_type='segwit', network='testnet')
         wallet_create_or_open('my-awesome-wallet55', keys=key_correct, witness_type='segwit', network='testnet',
-                                  db_uri=self.DATABASE_URI)
+                                  db_uri=self.database_uri)
         self.assertRaisesRegex(AssertionError, '', Wallet, 'my-awesome-wallet55', main_key_object=key_invalid,
-                                db_uri=self.DATABASE_URI)
+                                db_uri=self.database_uri)
 
     def test_wallet_single_key(self):
         wlt = wallet_create_or_open('single_key', scheme='single', network='bitcoinlib_test',
-                                    db_uri=self.DATABASE_URI)
+                                    db_uri=self.database_uri)
         wlt.utxos_update()
         transaction = wlt.transaction_create([('21DQCyZTNRoAccG1TWz9YaffDUKzZf6JWii', 90000000)])
         transaction.sign()
@@ -629,12 +659,12 @@ def test_wallet_single_key(self):
 
     def test_wallet_single_key_segwit(self):
         wlt = wallet_create_or_open('single_key_segwit', scheme='single', network='litecoin_testnet',
-                                    witness_type='segwit', db_uri=self.DATABASE_URI)
+                                    witness_type='segwit', db_uri=self.database_uri)
         self.assertEqual(wlt.addresslist()[0][:5], 'tltc1')
 
     def test_wallet_single_key_main_key(self):
         w = Wallet.create('multisig_with_single_key', [HDKey().public_master_multisig(), HDKey(key_type='single')],
-                          sigs_required=2, db_uri=self.DATABASE_URI)
+                          sigs_required=2, db_uri=self.database_uri)
         w.new_key()
         self.assertEqual(len(w.keys_addresses()), 1)
 
@@ -644,7 +674,7 @@ def test_wallet_private_parts(self):
         private_hex = 'ffbf97886300c36e747a71d227a3132b209109a9e5296659f5aa03356ca27e1f'
         secret = 115678290018782943471210007860528561263328164009987126706295777426273334361631
         k = HDKey(wif)
-        w = wallet_create_or_open('wlttest', k, db_uri=self.DATABASE_URI)
+        w = wallet_create_or_open('wlttest', k, db_uri=self.database_uri)
         w_json = w.as_json()
         self.assertFalse(wif in w_json)
         self.assertFalse(private_hex in w_json)
@@ -672,7 +702,7 @@ def test_wallet_private_parts(self):
         secret2 = 104285397059777051994770481926675935425657204513917549168323819901909731871228
         k2 = HDKey(wif2)
 
-        wms = wallet_create_or_open('wlttest_ms', [k, k2], cosigner_id=0, db_uri=self.DATABASE_URI)
+        wms = wallet_create_or_open('wlttest_ms', [k, k2], cosigner_id=0, db_uri=self.database_uri)
         w_json = wms.as_json()
         self.assertFalse('"xprv' in w_json)
         self.assertFalse(wif in w_json)
@@ -685,13 +715,13 @@ def test_wallet_private_parts(self):
     def test_wallet_key_create_from_key(self):
         k1 = HDKey(network='testnet')
         k2 = HDKey(network='testnet')
-        w1 = Wallet.create('network_mixup_test_wallet', network='litecoin', db_uri=self.DATABASE_URI)
+        w1 = Wallet.create('network_mixup_test_wallet', network='litecoin', db_uri=self.database_uri)
         wk1 = WalletKey.from_key('key1', w1.wallet_id, w1._session, key=k1.address_obj)
         self.assertEqual(wk1.network.name, 'testnet')
         self.assertRaisesRegex(WalletError, "Specified network and key network should be the same",
                                 WalletKey.from_key, 'key2', w1.wallet_id, w1._session, key=k2.address_obj,
                                 network='bitcoin')
-        w2 = Wallet.create('network_mixup_test_wallet2', network='litecoin', db_uri=self.DATABASE_URI)
+        w2 = Wallet.create('network_mixup_test_wallet2', network='litecoin', db_uri=self.database_uri)
         wk2 = WalletKey.from_key('key1', w2.wallet_id, w2._session, key=k1)
         self.assertEqual(wk2.network.name, 'testnet')
         self.assertRaisesRegex(WalletError, "Specified network and key network should be the same",
@@ -702,7 +732,7 @@ def test_wallet_key_create_from_key(self):
         wk4 = WalletKey.from_key('key4', w2.wallet_id, w2._session, key=k1.address_obj)
         self.assertEqual(wk4.name, 'key1')
         k = HDKey().public_master()
-        w = Wallet.create('pmtest', network='litecoin', db_uri=self.DATABASE_URI)
+        w = Wallet.create('pmtest', network='litecoin', db_uri=self.database_uri)
         wk1 = WalletKey.from_key('key', w.wallet_id, w._session, key=k)
         self.assertEqual(wk1.path, 'M')
         # Test __repr__ method
@@ -712,7 +742,7 @@ def test_wallet_key_create_from_key(self):
         self.assertEqual(wk1.name, 'new_name')
 
     def test_wallet_key_exceptions(self):
-        w = Wallet.create('test_wallet_key_not_found', db_uri=self.DATABASE_URI)
+        w = Wallet.create('test_wallet_key_not_found', db_uri=self.database_uri)
         self.assertRaisesRegex(WalletError, 'Key with id 1000000 not found', WalletKey, 1000000, w._session)
         self.assertRaisesRegex(BKeyError, "Specified key \['litecoin', 'litecoin_legacy'\] is from different "
                                            "network then specified: bitcoin",
@@ -721,29 +751,28 @@ def test_wallet_key_exceptions(self):
         self.assertRaisesRegex(WalletError, "", w.get_key, cosigner_id=10)
 
     def test_wallet_key_public_leaks(self):
-        w = wallet_create_or_open("wallet_private", network='testnet', db_uri=self.DATABASE_URI)
+        w = wallet_create_or_open("wallet_private", network='testnet', db_uri=self.database_uri)
         wk = w.public_master()
         self.assertIsNone(wk._hdkey_object.private_hex)
         self.assertIsNone(wk._dbkey)
 
-        w2 = wallet_create_or_open('wallet_public', network='testnet', keys=wk, db_uri=self.DATABASE_URI)
+        w2 = wallet_create_or_open('wallet_public', network='testnet', keys=wk, db_uri=self.database_uri)
         self.assertFalse(w2.main_key.is_private)
         self.assertIsNone(w2.main_key.key_private)
 
 
-@parameterized_class(*params)
-class TestWalletElectrum(TestWalletMixin, unittest.TestCase):
+class TestWalletElectrum(unittest.TestCase):
     wallet = None
 
     @classmethod
     def setUpClass(cls):
-        cls.db_remove()
+        cls.database_uri = database_init()
         cls.pk = 'xprv9s21ZrQH143K2fuscnMTwUadsPqEbYdFQVJ1uWPawUYi7C485NHhCiotGy6Kz3Cz7ReVr65oXNwhREZ8ePrz8p7zy' \
                  'Hra82D1EGS7cQQmreK'
         cls.wallet = Wallet.create(
             keys=cls.pk,
             name='test_wallet_electrum',
-            db_uri=cls.DATABASE_URI)
+            db_uri=cls.database_uri)
         cls.wallet.key_path = ["m", "change", "address_index"]
         workdir = os.path.dirname(__file__)
         with open('%s/%s' % (workdir, 'electrum_keys.json')) as f:
@@ -763,7 +792,7 @@ def test_electrum_keys(self):
     def test_wallet_electrum_p2pkh(self):
         phrase = 'smart donor clever resource stool denial wink under oak sand limb wagon'
         wlt = Wallet.create('wallet_electrum_p2pkh', phrase, network='bitcoin', witness_type='segwit',
-                            db_uri=self.DATABASE_URI)
+                            db_uri=self.database_uri)
         self.assertEqual(wlt.get_key().address, 'bc1qjz5l6mej6ptqlggfvdlys8pfukwqp8xnu0mn5u')
         self.assertEqual(wlt.get_key_change().address, 'bc1qz4tr569wfs2fuekgcjtdlz0eufk7rfs8gnu5j9')
 
@@ -771,24 +800,23 @@ def test_wallet_electrum_p2sh_p2wsh(self):
         phrase1 = 'magnet voice math okay castle recall arrange music high sustain require crowd'
         phrase2 = 'wink tornado honey delay nest sing series timber album region suit spawn'
         wlt = Wallet.create('wallet_electrum_p2sh_p2wsh', [phrase1, phrase2], network='bitcoin', cosigner_id=0,
-                            witness_type='p2sh-segwit', db_uri=self.DATABASE_URI)
+                            witness_type='p2sh-segwit', db_uri=self.database_uri)
         self.assertEqual(wlt.get_key().address, '3ArRVGXfqcjw68XzUZr4iCCemrPoFZxm7s')
         self.assertEqual(wlt.get_key_change().address, '3FZEUFf59C3psUUiKB8TFbjsFUGWD73QPY')
 
 
-@parameterized_class(*params)
-class TestWalletMultiCurrency(TestWalletMixin, unittest.TestCase):
+class TestWalletMultiCurrency(unittest.TestCase):
     wallet = None
 
     @classmethod
     def setUpClass(cls):
-        cls.db_remove()
+        cls.database_uri = database_init()
         cls.pk = 'xprv9s21ZrQH143K4478MENLXpSXSvJSRYsjD2G3sY7s5sxAGubyujDmt9Qzfd1me5s1HokWGGKW9Uft8eB9dqryybAcFZ5JAs' \
                  'rg84jAVYwKJ8c'
         cls.wallet = Wallet.create(
             keys=cls.pk, network='dogecoin', witness_type='legacy',
             name='test_wallet_multicurrency',
-            db_uri=cls.DATABASE_URI)
+            db_uri=cls.database_uri)
 
         cls.wallet.new_account(network='litecoin')
         cls.wallet.new_account(network='bitcoin')
@@ -835,8 +863,8 @@ def test_wallet_multiple_networks_import_error(self):
     def test_wallet_multiple_networks_value(self):
         pk = 'vprv9DMUxX4ShgxMM1FFB24BgXE3fMYXKicceSdMUtfhyyUzKNkCvPeYrcoZpPezahBEzFc23yHTPj46eqx3jKuQpQFq5kbd2oxDysd' \
              'teSN16sH'
-        wallet_delete_if_exists('test_wallet_multiple_networks_value', force=True, db_uri=self.DATABASE_URI)
-        w = wallet_create_or_open('test_wallet_multiple_networks_value', keys=pk, db_uri=self.DATABASE_URI)
+        wallet_delete_if_exists('test_wallet_multiple_networks_value', force=True, db_uri=self.database_uri)
+        w = wallet_create_or_open('test_wallet_multiple_networks_value', keys=pk, db_uri=self.database_uri)
         w.new_account(network='bitcoin')
         w.new_account(network='bitcoinlib_test')
         w.utxos_update(networks='testnet')
@@ -850,19 +878,18 @@ def test_wallet_multiple_networks_value(self):
         self.assertTrue(t.verified)
 
 
-@parameterized_class(*params)
-class TestWalletMultiNetworksMultiAccount(TestWalletMixin, unittest.TestCase):
+class TestWalletMultiNetworksMultiAccount(unittest.TestCase):
 
     @classmethod
     def setUpClass(cls):
-        cls.db_remove()
+        cls.database_uri = database_init()
 
     def test_wallet_multi_networks_send_transaction(self):
         pk = 'tobacco defy swarm leaf flat pyramid velvet pen minor twist maximum extend'
         wallet = Wallet.create(
             keys=pk, network='bitcoin',
             name='test_wallet_multi_network_multi_account', witness_type='legacy',
-            db_uri=self.DATABASE_URI)
+            db_uri=self.database_uri)
 
         wallet.new_key()
         acc = wallet.new_account('BCL test home', network='bitcoinlib_test')
@@ -891,13 +918,13 @@ def test_wallet_multi_networks_send_transaction(self):
         del wallet
 
     def test_wallet_multi_networks_account_bip44_code_error(self):
-        wlt = Wallet.create("wallet-bip44-code-error", network='testnet', db_uri=self.DATABASE_URI)
+        wlt = Wallet.create("wallet-bip44-code-error", network='testnet', db_uri=self.database_uri)
         error_str = "Can not create new account for network litecoin_testnet with same BIP44 cointype"
         self.assertRaisesRegex(WalletError, error_str, wlt.new_account, network='litecoin_testnet')
 
     def test_wallet_get_account_defaults(self):
         w = wallet_create_or_open("test_wallet_get_account_defaults", witness_type='segwit',
-                                  db_uri=self.DATABASE_URI)
+                                  db_uri=self.database_uri)
         w.get_key(network='litecoin', account_id=100)
         network, account_id, account_key = w._get_account_defaults(network='litecoin')
         self.assertEqual(network, 'litecoin')
@@ -905,7 +932,7 @@ def test_wallet_get_account_defaults(self):
         self.assertIn('account', account_key.name)
 
     def test_wallet_update_attributes(self):
-        w = Wallet.create('test_wallet_set_attributes', witness_type='legacy', db_uri=self.DATABASE_URI)
+        w = Wallet.create('test_wallet_set_attributes', witness_type='legacy', db_uri=self.database_uri)
         w.new_account(network='litecoin', account_id=1200)
         owner = 'Satoshi'
         w.owner = owner
@@ -913,25 +940,24 @@ def test_wallet_update_attributes(self):
         w.default_account_id = 1200
         del w
 
-        w2 = Wallet('test_wallet_set_attributes', db_uri=self.DATABASE_URI)
+        w2 = Wallet('test_wallet_set_attributes', db_uri=self.database_uri)
         self.assertEqual(w2.owner, owner)
         self.assertEqual(w2.network.name, 'litecoin')
         nk = w2.new_key()
         self.assertEqual(nk.path, "m/44'/2'/1200'/0/1")
 
 
-@parameterized_class(*params)
-class TestWalletBitcoinlibTestnet(TestWalletMixin, unittest.TestCase):
+class TestWalletBitcoinlibTestnet(unittest.TestCase):
 
     @classmethod
     def setUpClass(cls):
-        cls.db_remove()
+        cls.database_uri = database_init()
 
     def test_wallet_bitcoinlib_testnet_sendto(self):
         w = Wallet.create(
             network='bitcoinlib_test',
             name='test_wallet_bitcoinlib_testnet_sendto',
-            db_uri=self.DATABASE_URI)
+            db_uri=self.database_uri)
 
         w.new_key()
         w.utxos_update()
@@ -943,7 +969,7 @@ def test_wallet_bitcoinlib_testnet_send_utxos_updated(self):
         w = Wallet.create(
             network='bitcoinlib_test',
             name='test_wallet_bitcoinlib_testnet_send_utxos_updated',
-            db_uri=self.DATABASE_URI)
+            db_uri=self.database_uri)
 
         w.utxos_update()
         self.assertEqual(len(w.utxos()), 2)
@@ -954,7 +980,7 @@ def test_wallet_bitcoinlib_testnet_sendto_no_funds_txfee(self):
         w = Wallet.create(
             network='bitcoinlib_test',
             name='test_wallet_bitcoinlib_testnet_sendto_no_funds_txfee',
-            db_uri=self.DATABASE_URI)
+            db_uri=self.database_uri)
         w.new_key()
         w.utxos_update()
         balance = w.balance()
@@ -965,7 +991,7 @@ def test_wallet_bitcoinlib_testnet_sweep(self):
         w = Wallet.create(
             network='bitcoinlib_test',
             name='test_wallet_bitcoinlib_testnet_sweep',
-            db_uri=self.DATABASE_URI)
+            db_uri=self.database_uri)
         w.new_key()
         w.new_key()
         w.new_key()
@@ -976,21 +1002,23 @@ def test_wallet_bitcoinlib_testnet_sweep(self):
                                 w.sweep, '21DBmFUMQMP7A6KeENXgZQ4wJdSCeGc2zFo', offline=False)
 
 
-@parameterized_class(*params)
-class TestWalletMultisig(TestWalletMixin, unittest.TestCase):
+class TestWalletMultisig(unittest.TestCase):
+    database_uri = None
+    database_uri_2 = None
 
     @classmethod
     def setUpClass(cls):
-        cls.db_remove()
+        cls.database_uri = database_init()
+        cls.database_uri_2 = database_init(DATABASE_NAME_2)
 
     def test_wallet_multisig_2_wallets_private_master_plus_account_public(self):
-        self.db_remove()
+        # self.db_remove()
         pk1 = 'tprv8ZgxMBicQKsPdPVdNSEeAhagkU6tUDhUQi8DcCTmJyNLUyU7svTFzXQdkYqNJDEtQ3S2wAspz3K56CMcmMsZ9eXZ2nkNq' \
               'gVxJhMHq3bGJ1X'
         pk1_acc_pub = 'tpubDCZUk9HLxh5gdB9eC8FUxPB1AbZtsSnbvyrAAzsC8x3tiYDgbzyxcngU99rG333jegHG5vJhs11AHcSVkbwrU' \
                       'bYEsPK8vA7E6yFB9qbsTYi'
-        w1 = Wallet.create(name='test_wallet_create_1', keys=pk1, db_uri=self.DATABASE_URI)
-        w2 = Wallet.create(name='test_wallet_create_2', keys=pk1_acc_pub, db_uri=self.DATABASE_URI)
+        w1 = Wallet.create(name='test_wallet_create_1', keys=pk1, db_uri=self.database_uri)
+        w2 = Wallet.create(name='test_wallet_create_2', keys=pk1_acc_pub, db_uri=self.database_uri)
         wk1 = w1.new_key()
         wk2 = w2.new_key()
         self.assertTrue(wk1.is_private)
@@ -998,7 +1026,7 @@ def test_wallet_multisig_2_wallets_private_master_plus_account_public(self):
         self.assertEqual(wk1.address, wk2.address)
 
     def test_wallet_multisig_create_2_cosigner_wallets(self):
-        self.db_remove()
+        # self.db_remove()
         pk_wif1 = 'tprv8ZgxMBicQKsPdvHCP6VxtFgowj2k7nBJnuRiVWE4DReDFojkLjyqdT8mtR6XJK9dRBcaa3RwvqiKFjsEQVhKfQmHZCCY' \
                   'f4jRTWvJuVuK67n'
         pk_wif2 = 'tprv8ZgxMBicQKsPdkJVWDkqQQAMVYB2usfVs3VS2tBEsFAzjC84M3TaLMkHyJWjydnJH835KHvksS92ecuwwWFEdLAAccwZ' \
@@ -1007,17 +1035,17 @@ def test_wallet_multisig_create_2_cosigner_wallets(self):
         pk2 = HDKey(pk_wif2, network='testnet')
         wl1 = Wallet.create('multisig_test_wallet1',
                             [pk_wif1, pk2.subkey_for_path("m/45'").wif_public()],
-                            sigs_required=2, network='testnet', db_uri=self.DATABASE_URI)
+                            sigs_required=2, network='testnet', db_uri=self.database_uri)
         wl2 = Wallet.create('multisig_test_wallet2',
                             [pk1.subkey_for_path("m/45'").wif_public(), pk_wif2],
-                            sigs_required=2, network='testnet', db_uri=self.DATABASE_URI)
+                            sigs_required=2, network='testnet', db_uri=self.database_uri)
         wl1_key = wl1.new_key()
         wl2_key = wl2.new_key(cosigner_id=wl1.cosigner_id)
         self.assertEqual(wl1_key.address, wl2_key.address)
         self.assertRaisesRegex(WalletError, "Accounts are not supported for this wallet", wl1.account, 10)
 
     def test_wallet_multisig_bitcoinlib_testnet_transaction_send(self):
-        self.db_remove()
+        # self.db_remove()
 
         key_list = [
             'Pdke4WfXvALPdbrKEfBU9z9BNuRNbv1gRr66BEiZHKcRXDSZQ3gV',
@@ -1027,7 +1055,7 @@ def test_wallet_multisig_bitcoinlib_testnet_transaction_send(self):
 
         # Create wallet and generate key
         wl = Wallet.create('multisig_test_simple', key_list, sigs_required=2, network='bitcoinlib_test',
-                           cosigner_id=0, db_uri=self.DATABASE_URI)
+                           cosigner_id=0, db_uri=self.database_uri)
         wl.new_key()
 
         # Sign, verify and send transaction
@@ -1039,7 +1067,7 @@ def test_wallet_multisig_bitcoinlib_testnet_transaction_send(self):
         self.assertIsNone(t.error)
 
     def test_wallet_multisig_bitcoin_transaction_send_offline(self):
-        self.db_remove()
+        # self.db_remove()
         pk2 = HDKey('e2cbed99ad03c500f2110f1a3c90e0562a3da4ba0cff0e74028b532c3d69d29d', witness_type='legacy')
         key_list = [
             HDKey('e9e5095d3e26643cc4d996efc6cb9a8d8eb55119fdec9fa28a684ba297528067', witness_type='legacy'),
@@ -1048,7 +1076,7 @@ def test_wallet_multisig_bitcoin_transaction_send_offline(self):
                 multisig=True, witness_type='legacy').public(),
         ]
         wl = Wallet.create('multisig_test_bitcoin_send', key_list, sigs_required=2, witness_type='legacy',
-                           db_uri=self.DATABASE_URI)
+                           db_uri=self.database_uri)
         wl.utxo_add(wl.get_key().address, 200000, '46fcfdbdc3573756916a0ced8bbc5418063abccd2c272f17bf266f77549b62d5',
                     0, 1)
         t = wl.transaction_create([('3CuJb6XrBNddS79vr27SwqgR4oephY6xiJ', 100000)], fee=10000)
@@ -1059,7 +1087,7 @@ def test_wallet_multisig_bitcoin_transaction_send_offline(self):
         self.assertEqual(t.export()[0][2], 'out')
 
     def test_wallet_multisig_bitcoin_transaction_send_no_subkey_for_path(self):
-        self.db_remove()
+        # self.db_remove()
         pk2 = HDKey('e2cbed99ad03c500f2110f1a3c90e0562a3da4ba0cff0e74028b532c3d69d29d')
         key_list = [
             HDKey('e9e5095d3e26643cc4d996efc6cb9a8d8eb55119fdec9fa28a684ba297528067'),
@@ -1067,7 +1095,7 @@ def test_wallet_multisig_bitcoin_transaction_send_no_subkey_for_path(self):
             HDKey('86b77aee5cfc3a55eb0b1099752479d82cb6ebaa8f1c4e9ef46ca0d1dc3847e6').public_master(multisig=True),
         ]
         wl = Wallet.create('multisig_test_bitcoin_send2', key_list, sigs_required=2,
-                           db_uri=self.DATABASE_URI)
+                           db_uri=self.database_uri)
         wl.utxo_add(wl.get_key().address, 200000, '46fcfdbdc3573756916a0ced8bbc5418063abccd2c272f17bf266f77549b62d5',
                     0, 1)
         t = wl.transaction_create([('3CuJb6XrBNddS79vr27SwqgR4oephY6xiJ', 100000)], fee=10000)
@@ -1077,14 +1105,14 @@ def test_wallet_multisig_bitcoin_transaction_send_no_subkey_for_path(self):
         self.assertIsNone(t.error)
 
     def test_wallet_multisig_bitcoin_transaction_send_fee_priority(self):
-        self.db_remove()
+        # self.db_remove()
         pk2 = HDKey('e2cbed99ad03c500f2110f1a3c90e0562a3da4ba0cff0e74028b532c3d69d29d')
         key_list = [
             HDKey('e9e5095d3e26643cc4d996efc6cb9a8d8eb55119fdec9fa28a684ba297528067'),
             pk2.public_master(multisig=True),
             HDKey('86b77aee5cfc3a55eb0b1099752479d82cb6ebaa8f1c4e9ef46ca0d1dc3847e6').public_master(multisig=True),
         ]
-        wl = Wallet.create('multisig_test_bitcoin_send3', key_list, sigs_required=2, db_uri=self.DATABASE_URI)
+        wl = Wallet.create('multisig_test_bitcoin_send3', key_list, sigs_required=2, db_uri=self.database_uri)
         wl.utxo_add(wl.get_key().address, 20000000, '46fcfdbdc3573756916a0ced8bbc5418063abccd2c272f17bf266f77549b62d5',
                     0, 1)
         t = wl.sweep('3CuJb6XrBNddS79vr27SwqgR4oephY6xiJ', fee='low')
@@ -1098,7 +1126,7 @@ def test_wallet_multisig_bitcoin_transaction_send_fee_priority(self):
         self.assertIsNone(t2.error)
 
     def test_wallet_multisig_litecoin_transaction_send_offline(self):
-        self.db_remove()
+        # self.db_remove()
         network = 'litecoin_legacy'
         pk2 = HDKey('e2cbed99ad03c500f2110f1a3c90e0562a3da4ba0cff0e74028b532c3d69d29d', witness_type='legacy',
                     network=network)
@@ -1110,7 +1138,7 @@ def test_wallet_multisig_litecoin_transaction_send_offline(self):
                   witness_type='legacy', network=network).public_master(multisig=True),
         ]
         wl = Wallet.create('multisig_test_litecoin_send', key_list, sigs_required=2, network=network,
-                           witness_type='legacy', db_uri=self.DATABASE_URI)
+                           witness_type='legacy', db_uri=self.database_uri)
         wl.get_keys(number_of_keys=2)
         wl.utxo_add(wl.get_key().address, 200000, '46fcfdbdc3573756916a0ced8bbc5418063abccd2c272f17bf266f77549b62d5',
                     0, 1)
@@ -1127,7 +1155,7 @@ def test_wallet_multisig_2of2(self):
         and verify created transaction.
 
         """
-        self.db_remove()
+        # self.db_remove()
 
         keys = [
             HDKey('BC12Se7KL1uS2bA6QQaWWrcA5kApD8UAM78dx91LrFvsvdvua3irnpQNjHUTCPJR7tZ72eGhMsy3mLPp5C'
@@ -1137,10 +1165,10 @@ def test_wallet_multisig_2of2(self):
 
         msw1 = Wallet.create('msw1', [keys[0], keys[1].subkey_for_path("m/45'").wif_public()],
                              network='bitcoinlib_test', sort_keys=False, sigs_required=2,
-                             db_uri=self.DATABASE_URI)
+                             db_uri=self.database_uri)
         msw2 = Wallet.create('msw2', [keys[0].subkey_for_path("m/45'").wif_public(), keys[1]],
                              network='bitcoinlib_test', sort_keys=False, sigs_required=2,
-                             db_uri=self.DATABASE_URI)
+                             db_uri=self.database_uri)
         msw1.new_key()
         self.assertEqual(len(msw1.get_key().key()), 2)
         msw2.new_key(cosigner_id=0)
@@ -1161,7 +1189,7 @@ def test_wallet_multisig_2of2_different_database(self):
         separate databases to check for database interference.
 
         """
-        self.db_remove()
+        # self.db_remove()
 
         keys = [
             HDKey('BC12Se7KL1uS2bA6QQaWWrcA5kApD8UAM78dx91LrFvsvdvua3irnpQNjHUTCPJR7tZ72eGhMsy3mLPp5C'
@@ -1169,10 +1197,10 @@ def test_wallet_multisig_2of2_different_database(self):
             HDKey('BC12Se7KL1uS2bA6QPiq4cdXWKfmQwuPPTXkRUJNBSLFZt9tPgLfgrRSfkVLRLYCYpgzsTmKybPHSX165w'
                   '42VBjw4Neub1KyPBfNpjFfgx9SyynF', network='bitcoinlib_test', witness_type='legacy')]
 
-        msw1 = Wallet.create('msw1', [keys[0], keys[1].public_master(multisig=True)], network='bitcoinlib_test',
-                             sort_keys=False, sigs_required=2, db_uri=self.DATABASE_URI)
-        msw2 = Wallet.create('msw2', [keys[0].public_master(multisig=True), keys[1]], network='bitcoinlib_test',
-                             sort_keys=False, sigs_required=2, db_uri=self.DATABASE_URI_2)
+        msw1 = Wallet.create('msw-2-2-1', [keys[0], keys[1].public_master(multisig=True)], network='bitcoinlib_test',
+                             sort_keys=False, sigs_required=2, db_uri=self.database_uri)
+        msw2 = Wallet.create('msw-2-2-2', [keys[0].public_master(multisig=True), keys[1]], network='bitcoinlib_test',
+                             sort_keys=False, sigs_required=2, db_uri=self.database_uri_2)
         msw1.new_key()
         msw2.new_key(cosigner_id=msw1.cosigner_id)
         msw1.utxos_update()
@@ -1199,7 +1227,8 @@ def _multisig_test(cls, sigs_required, number_of_sigs, sort_keys, network, witne
         wallet_dict = {}
         wallet_keys = {}
         for wallet_id in range(number_of_sigs):
-            wallet_name = 'multisig-%d' % wallet_id
+            wallet_name = 'multisig-%d-%d-%d-%s-%s-%s' % (wallet_id, sigs_required, number_of_sigs, witness_type,
+                                                         network, int(sort_keys))
             key_list = []
             for key_id in key_dict:
                 if key_id == wallet_id:
@@ -1208,7 +1237,7 @@ def _multisig_test(cls, sigs_required, number_of_sigs, sort_keys, network, witne
                     key_list.append(key_dict[key_id].public_master(multisig=True, as_private=True))
             wallet_dict[wallet_id] = Wallet.create(
                 wallet_name, key_list, sigs_required=sigs_required, network=network, sort_keys=sort_keys, cosigner_id=0,
-                witness_type=witness_type, db_uri=cls.DATABASE_URI)
+                witness_type=witness_type, db_uri=cls.database_uri)
             wallet_keys[wallet_id] = wallet_dict[wallet_id].new_key()
             wallet_dict[wallet_id].utxos_update()
 
@@ -1235,37 +1264,37 @@ def _multisig_test(cls, sigs_required, number_of_sigs, sort_keys, network, witne
         return t
 
     def test_wallet_multisig_2of3(self):
-        self.db_remove()
+        # self.db_remove()
         t = self._multisig_test(2, 3, False, 'bitcoinlib_test')
         self.assertTrue(t.verify())
 
     def test_wallet_multisig_2of3_segwit(self):
-        self.db_remove()
+        # self.db_remove()
         t = self._multisig_test(2, 3, False, 'bitcoinlib_test', 'segwit')
         self.assertTrue(t.verify())
 
     def test_wallet_multisig_2of3_sorted(self):
-        self.db_remove()
+        # self.db_remove()
         t = self._multisig_test(2, 3, True, 'bitcoinlib_test')
         self.assertTrue(t.verify())
 
     def test_wallet_multisig_3of5(self):
-        self.db_remove()
+        # self.db_remove()
         t = self._multisig_test(3, 5, False, 'bitcoinlib_test')
         self.assertTrue(t.verify())
 
     def test_wallet_multisig_3of5_segwit(self):
-        self.db_remove()
+        # self.db_remove()
         t = self._multisig_test(3, 5, False, 'bitcoinlib_test', 'segwit')
         self.assertTrue(t.verify())
 
     def test_wallet_multisig_2of2_with_single_key(self):
-        self.db_remove()
+        # self.db_remove()
         keys = [HDKey(network='bitcoinlib_test'), HDKey(network='bitcoinlib_test', key_type='single')]
         key_list = [keys[0], keys[1].public()]
 
         wl = Wallet.create('multisig_expk2', key_list, sigs_required=2, network='bitcoinlib_test',
-                           db_uri=self.DATABASE_URI, sort_keys=False)
+                           db_uri=self.database_uri, sort_keys=False)
         k1 = wl.new_key()
         k2 = wl.new_key()
         k3 = wl.new_key_change()
@@ -1280,16 +1309,16 @@ def test_wallet_multisig_2of2_with_single_key(self):
         self.assertIsNone(t.error)
 
     def test_wallet_multisig_sorted_keys(self):
-        self.db_remove()
+        # self.db_remove()
         key1 = HDKey()
         key2 = HDKey()
         key3 = HDKey()
         w1 = Wallet.create('w1', [key1, key2.public_master(multisig=True), key3.public_master(multisig=True)],
-                           sigs_required=2, db_uri=self.DATABASE_URI)
+                           sigs_required=2, db_uri=self.database_uri)
         w2 = Wallet.create('w2', [key1.public_master(multisig=True), key2, key3.public_master(multisig=True)],
-                           sigs_required=2, db_uri=self.DATABASE_URI)
+                           sigs_required=2, db_uri=self.database_uri)
         w3 = Wallet.create('w3', [key1.public_master(multisig=True), key2.public_master(multisig=True), key3],
-                           sigs_required=2, db_uri=self.DATABASE_URI)
+                           sigs_required=2, db_uri=self.database_uri)
         for _ in range(5):
             cosigner_id = random.randint(0, 2)
             address1 = w1.new_key(cosigner_id=cosigner_id).address
@@ -1299,7 +1328,7 @@ def test_wallet_multisig_sorted_keys(self):
                             'Different addressed generated: %s %s %s' % (address1, address2, address3))
 
     def test_wallet_multisig_sign_with_external_single_key(self):
-        self.db_remove()
+        # self.db_remove()
         network = 'bitcoinlib_test'
         words = 'square innocent drama'
         seed = Mnemonic().to_seed(words, 'password')
@@ -1312,7 +1341,7 @@ def test_wallet_multisig_sign_with_external_single_key(self):
             hdkey.public()
         ]
         wallet = Wallet.create('Multisig-2-of-3-example', key_list, sigs_required=2, network=network,
-                               db_uri=self.DATABASE_URI)
+                               db_uri=self.database_uri)
         wallet.new_key()
         wallet.utxos_update()
         wt = wallet.send_to('21A6yyUPRL9hZZo1Rw4qP5G6h9idVVLUncE', 10000000, offline=False)
@@ -1325,19 +1354,19 @@ def test_wallet_multisig_reopen_wallet(self):
         def _open_all_wallets():
             wl1 = wallet_create_or_open(
                 'multisigmulticur1_tst', sigs_required=2, network=network,
-                db_uri=self.DATABASE_URI, sort_keys=False, witness_type='segwit',
+                db_uri=self.database_uri, sort_keys=False, witness_type='segwit',
                 keys=[pk1, pk2.public_master(), pk3.public_master()])
             wl2 = wallet_create_or_open(
                 'multisigmulticur2_tst', sigs_required=2, network=network,
-                db_uri=self.DATABASE_URI, sort_keys=False, witness_type='segwit',
+                db_uri=self.database_uri, sort_keys=False, witness_type='segwit',
                 keys=[pk1.public_master(), pk2, pk3.public_master()])
             wl3 = wallet_create_or_open(
                 'multisigmulticur3_tst', sigs_required=2, network=network,
-                db_uri=self.DATABASE_URI, sort_keys=False, witness_type='segwit',
+                db_uri=self.database_uri, sort_keys=False, witness_type='segwit',
                 keys=[pk1.public_master(), pk2.public_master(), pk3])
             return wl1, wl2, wl3
 
-        self.db_remove()
+        # self.db_remove()
         network = 'litecoin'
         phrase1 = 'shop cloth bench traffic vintage security hour engage omit almost episode fragile'
         phrase2 = 'exclude twice mention orchard grit ignore display shine cheap exercise same apart'
@@ -1356,7 +1385,7 @@ def _open_all_wallets():
                              'ltc1qmw3e97pgrwypr0378wjje984guu0jy3ye4n523lcymk3rctuef6q7t3sek')
 
     def test_wallet_multisig_network_mixups(self):
-        self.db_remove()
+        # self.db_remove()
         network = 'litecoin_testnet'
         phrase1 = 'shop cloth bench traffic vintage security hour engage omit almost episode fragile'
         phrase2 = 'exclude twice mention orchard grit ignore display shine cheap exercise same apart'
@@ -1364,7 +1393,7 @@ def test_wallet_multisig_network_mixups(self):
         pk2 = HDKey.from_passphrase(phrase2, multisig=True, network=network, witness_type='legacy')
         pk3 = HDKey.from_passphrase(phrase3, multisig=True, network=network, witness_type='legacy')
         wlt = wallet_create_or_open(
-            'multisig_network_mixups', sigs_required=2, network=network, db_uri=self.DATABASE_URI,
+            'multisig_network_mixups', sigs_required=2, network=network, db_uri=self.database_uri,
             keys=[phrase1, pk2.public_master(), pk3.public_master()], witness_type='legacy',
             sort_keys=False)
         self.assertEqual(wlt.get_key().address, 'QjecchURWzhzUzLkhJ8Xijnm29Z9PscSqD')
@@ -1373,7 +1402,7 @@ def test_wallet_multisig_network_mixups(self):
     def test_wallet_multisig_info(self):
         w = Wallet.create('test_wallet_multisig_info', keys=[HDKey(network='bitcoinlib_test'),
                                                              HDKey(network='bitcoinlib_test')],
-                          network='bitcoinlib_test', cosigner_id=0, db_uri=self.DATABASE_URI)
+                          network='bitcoinlib_test', cosigner_id=0, db_uri=self.database_uri)
         w.utxos_update()
         w.info(detail=6)
 
@@ -1391,7 +1420,7 @@ def test_wallets_multisig_missing_private_and_cosigner(self):
                                 "This wallet does not contain any private keys, please specify cosigner_id for "
                                 "this wallet", wallet_create_or_open,
                                 'test_wallets_multisig_missing_private_and_cosigner',
-                                keys=[hdkey0, hdkey1, hdkey2], db_uri=self.DATABASE_URI)
+                                keys=[hdkey0, hdkey1, hdkey2], db_uri=self.database_uri)
 
     def test_wallets_multisig_with_single_key_cosigner(self):
         k0 = 'xprv9s21ZrQH143K459uwGGCU3Wj3v1LFFJ42tgyTsNnr6p2BS6FZ9jQ7fmZMMnqsWSi2BBgpX3hFbR4ode8Jx58ibSNeaBLFQ68Xs3' \
@@ -1405,7 +1434,7 @@ def test_wallets_multisig_with_single_key_cosigner(self):
         hdkey2 = HDKey(k2, key_type='single')
 
         w = wallet_create_or_open('test_wallets_multisig_with_single_key_cosigner0', keys=[hdkey0, hdkey1, hdkey2],
-                                  cosigner_id=0, db_uri=self.DATABASE_URI)
+                                  cosigner_id=0, db_uri=self.database_uri)
         w.new_key(cosigner_id=2)
         w.new_key(cosigner_id=2)
         # Cosigner 0 use a single key wallet, so calling new_key() repeatedly has no effect
@@ -1416,7 +1445,7 @@ def test_wallets_multisig_with_single_key_cosigner(self):
         self.assertEqual(w.keys()[1].address, '3K2eBv2hm3SjhVRaJJK8Dt7wMb8mRTWcMH')
 
         w2 = wallet_create_or_open('test_wallets_multisig_with_single_key_cosigner2', keys=[hdkey0, hdkey1, hdkey2],
-                                   cosigner_id=2, db_uri=self.DATABASE_URI)
+                                   cosigner_id=2, db_uri=self.database_uri)
         w2.new_key()
         w2.new_key()
         self.assertEqual(w2.keys()[0].address, '39b2tosg9To6cQTrqnZLhuhW5auqCqXKsH')
@@ -1427,7 +1456,7 @@ def test_wallets_multisig_with_single_key_cosigner(self):
         # Close wallet and reopen to test for database issues for example
         del w
         w = wallet_create_or_open('test_wallets_multisig_with_single_key_cosigner0',
-                                  db_uri=self.DATABASE_URI)
+                                  db_uri=self.database_uri)
         w.new_key(cosigner_id=2)
         self.assertEqual(w.keys()[3].address, '3Q9rnDniMa55jZFyzBDKihtXwZSM34zfEj')
 
@@ -1443,7 +1472,7 @@ def test_wallets_multisig_huge(self):
             key_list_wallet = [key_list[pk_n]] + key_list_cosigners
 
             w = Wallet.create(wallet_name, keys=key_list_wallet, sigs_required=sigs_req,
-                              witness_type=witness_type, network=network, db_uri=self.DATABASE_URI)
+                              witness_type=witness_type, network=network, db_uri=self.database_uri)
             w.get_keys(number_of_keys=2)
             w.utxos_update()
             to_address = HDKey(network=network, witness_type=witness_type).address()
@@ -1468,7 +1497,7 @@ def test_wallets_multisig_huge_error(self):
         self.assertRaisesRegex(WalletError, 'Redeemscripts with more then 15 keys are non-standard and could '
                                              'result in locked up funds',
                                 Wallet.create, wallet_name, keys=key_list_wallet, sigs_required=sigs_req,
-                                network=network, db_uri=self.DATABASE_URI)
+                                network=network, db_uri=self.database_uri)
 
     def test_wallet_multisig_replace_sig_bug(self):
         network = 'bitcoinlib_test'
@@ -1487,7 +1516,7 @@ def test_wallet_multisig_replace_sig_bug(self):
         key_list_cosigners = [k.public_master(multisig=True) for k in key_list if k is not key_list[0]]
         key_list_wallet = [key_list[0]] + key_list_cosigners
         w = wallet_create_or_open(wallet_name, keys=key_list_wallet, sigs_required=sigs_req, witness_type=witness_type,
-                                  network=network, db_uri=self.DATABASE_URI)
+                                  network=network, db_uri=self.database_uri)
         w.get_keys()
         w.utxos_update()
         to_address = HDKey(network=network, witness_type=witness_type).address()
@@ -1507,7 +1536,7 @@ def test_wallet_multisig_multinetwork(self):
         p2 = 'oyster pelican debate mass scene title pipe lock recipe flavor razor accident'
         k2 = HDKey.from_passphrase(p2, network=network1, multisig=True).public_master()
         w = wallet_create_or_open('ltcswms', [p1, k2], network=network1, witness_type='segwit',
-                                  cosigner_id=0, db_uri=self.DATABASE_URI)
+                                  cosigner_id=0, db_uri=self.database_uri)
         self.assertEqual(len(w.get_keys(number_of_keys=2)), 2)
         w.utxo_add('ltc1qkewaz7lxn75y6wppvqlsfhrnq5p5mksmlp26n8xsef0556cdfzqq2uhdrt', 2100000000000001,
                    '21da13be453624cf46b3d883f39602ce74d04efa7a186037898b6d7bcfd405ee', 0, 15)
@@ -1518,12 +1547,12 @@ def test_wallet_multisig_multinetwork(self):
         self.assertRaisesRegex(WalletError, "Cannot create new keys for network bitcoinlib_test, "
                                             "no private masterkey found", w.new_key, network=network2)
 
-@parameterized_class(*params)
-class TestWalletKeyImport(TestWalletMixin, unittest.TestCase):
+
+class TestWalletKeyImport(unittest.TestCase):
 
     @classmethod
     def setUpClass(cls):
-        cls.db_remove()
+        cls.database_uri = database_init()
 
     def test_wallet_key_import_and_sign_multisig(self):
         network = 'bitcoinlib_test'
@@ -1538,7 +1567,7 @@ def test_wallet_key_import_and_sign_multisig(self):
             hdkey.public()
         ]
         with Wallet.create('Multisig-2-of-3-example', key_list, sigs_required=2,
-                           db_uri=self.DATABASE_URI) as wlt:
+                           db_uri=self.database_uri) as wlt:
             wlt.new_key()
             wlt.utxos_update()
             wt = wlt.send_to('21A6yyUPRL9hZZo1Rw4qP5G6h9idVVLUncE', 10000000, offline=False)
@@ -1550,7 +1579,7 @@ def test_wallet_import_private_for_known_public(self):
         hdkey = HDKey(
             'xprv9s21ZrQH143K2noEZoqGHnaDDLjrnFpis8jm7NWDhkWuNNCqMupGSy7PMYtGL9jvdTY7Nx3GZ6UZ9C52nebwbYXK73imaPUK24'
             'dZJtGZhGd')
-        with Wallet.create('public-private', hdkey.public_master().public(), db_uri=self.DATABASE_URI) \
+        with Wallet.create('public-private', hdkey.public_master().public(), db_uri=self.database_uri) \
                 as wlt:
             self.assertFalse(wlt.main_key.is_private)
             wlt.import_key(hdkey)
@@ -1571,7 +1600,7 @@ def test_wallet_import_private_for_known_public_multisig(self):
                "iFEwaUv85GA"
 
         with wallet_create_or_open("mstest", [puk1, puk2, puk3], 2, network='litecoin', sort_keys=False,
-                                   cosigner_id=0, db_uri=self.DATABASE_URI) as wlt:
+                                   cosigner_id=0, db_uri=self.database_uri) as wlt:
             self.assertFalse(wlt.cosigner[2].main_key.is_private)
             wlt.import_key(prk3)
             self.assertTrue(wlt.cosigner[2].main_key.is_private)
@@ -1583,7 +1612,7 @@ def test_wallet_import_private_for_known_public_p2sh_segwit(self):
                     'VKQy7FMLXzMq7N2nQq')
         w = Wallet.create('segwit-p2sh-p2wsh-import',
                           [pk1, pk2.public_master(witness_type='p2sh-segwit', multisig=True)],
-                          witness_type='p2sh-segwit', network='bitcoinlib_test', db_uri=self.DATABASE_URI)
+                          witness_type='p2sh-segwit', network='bitcoinlib_test', db_uri=self.database_uri)
         w.get_key()
         w.utxos_update()
         t = w.sweep('23CvEnQKsTVGgqCZzW6ewXPSJH9msFPsBt3', offline=False)
@@ -1615,7 +1644,7 @@ def test_wallet_import_private_for_known_public_segwit_passphrases(self):
         pubk2 = k2.public_master_multisig(witness_type=witness_type)
         self.assertEqual(pubk1.wif(), wif1)
         self.assertEqual(pubk2.wif(), wif2)
-        w = Wallet.create('mswlt', [p1, pubk2], db_uri=self.DATABASE_URI, witness_type=witness_type)
+        w = Wallet.create('mswlt', [p1, pubk2], db_uri=self.database_uri, witness_type=witness_type)
         wk = w.new_key()
         self.assertEqual(wk.address, 'bc1qr7r7zpr5gqnz0zs39ve7c0g54gwe7h7322lt3kae6gh8tzc5epts0j9rhm')
         self.assertFalse(w.public_master(as_private=True)[1].is_private)
@@ -1632,17 +1661,16 @@ def test_wallet_import_private_for_known_public_segwit_passphrases(self):
         self.assertListEqual(txids, txids_expected)
 
 
-@parameterized_class(*params)
-class TestWalletTransactions(TestWalletMixin, unittest.TestCase, CustomAssertions):
+class TestWalletTransactions(unittest.TestCase, CustomAssertions):
     wallet = None
 
     @classmethod
     def setUpClass(cls):
-        cls.db_remove()
+        cls.database_uri = database_init()
         account_key = 'tpubDCmJWqxWch7LYDhSuE1jEJMbAkbkDm3DotWKZ69oZfNMzuw7U5DwEaTVZHGPzt5j9BJDoxqVkPHt2EpUF66FrZhpfq' \
                       'ZY6DFj6x61Wwbrg8Q'
         cls.wallet = wallet_create_or_open('utxo-test', keys=account_key, network='testnet',
-                                           db_uri=cls.DATABASE_URI)
+                                           db_uri=cls.database_uri)
         cls.wallet.new_key()
         cls.wallet.utxos_update()
 
@@ -1679,7 +1707,7 @@ def test_wallet_offline_create_transaction(self):
                     'qjcDhTcyVLhrXXZ'
         hdkey = HDKey(hdkey_wif)
         wlt = wallet_create_or_open('offline-create-transaction', keys=hdkey, network='testnet',
-                                    db_uri=self.DATABASE_URI)
+                                    db_uri=self.database_uri)
         self.assertEqual(wlt.wif(is_private=True), hdkey_wif)
         wlt.get_key()
         utxos = [{
@@ -1699,7 +1727,7 @@ def test_wallet_offline_create_transaction(self):
     def test_wallet_scan(self):
         account_key = 'tpubDCmJWqxWch7LYDhSuE1jEJMbAkbkDm3DotWKZ69oZfNMzuw7U5DwEaTVZHGPzt5j9BJDoxqVkPHt2EpUF66FrZhpfq' \
                       'ZY6DFj6x61Wwbrg8Q'
-        wallet = wallet_create_or_open('scan-test', keys=account_key, network='testnet', db_uri=self.DATABASE_URI)
+        wallet = wallet_create_or_open('scan-test', keys=account_key, network='testnet', db_uri=self.database_uri)
         wallet.scan(scan_gap_limit=8)
         self.assertEqual(len(wallet.keys()), 27)
         self.assertEqual(wallet.balance(), 60500000)
@@ -1708,13 +1736,13 @@ def test_wallet_scan(self):
 
         # Check tx order in same block
         address = 'tb1qlh9x3jwhfqspp7u9w6l7zqxpmuvplzaczaele3'
-        w = wallet_create_or_open('fix-multiple-tx-1-block', keys=address, db_uri=self.DATABASE_URI)
+        w = wallet_create_or_open('fix-multiple-tx-1-block', keys=address, db_uri=self.database_uri)
         w.scan()
         self.assertEqual(w.transactions()[0].txid, 'bae05e65c13a1b1635abf581a6250a458cbd672c914e2563b5bb175274f9c5a7')
 
     def test_wallet_scan_utxos(self):
         pk = 'tpubDDi7dF92m7UrWNuAmzR9mzETcCjFT9v6XZq2oXjvhH4Bzr4L13np7d6bBB5tZk1Kg3y2vB79ohpgsLiubcRA8RfA6L69nmZvSG26XfmC5Ao'
-        w = wallet_create_or_open('kladkladklieder3', keys=pk, db_uri=self.DATABASE_URI)
+        w = wallet_create_or_open('kladkladklieder3', keys=pk, db_uri=self.database_uri)
         w.scan(scan_gap_limit=1)
         self.assertEqual(len(w.utxos()), 2)
         self.assertEqual(w.balance(), 2000)
@@ -1727,7 +1755,7 @@ def test_wallet_scan_utxos(self):
         self.assertListEqual(tx_list, exp_tx_list)
 
     def test_wallet_two_utxos_one_key(self):
-        wlt = Wallet.create('double-utxo-test', network='bitcoinlib_test', db_uri=self.DATABASE_URI)
+        wlt = Wallet.create('double-utxo-test', network='bitcoinlib_test', db_uri=self.database_uri)
         key = wlt.new_key()
         wlt.utxos_update()
         utxos = wlt.utxos()
@@ -1744,7 +1772,7 @@ def test_wallet_two_utxos_one_key(self):
         del wlt
 
     def test_wallet_balance_update(self):
-        wlt = Wallet.create('test-balance-update', network='bitcoinlib_test', db_uri=self.DATABASE_URI)
+        wlt = Wallet.create('test-balance-update', network='bitcoinlib_test', db_uri=self.database_uri)
         to_key = wlt.get_key()
         wlt.utxos_update()
         self.assertEqual(wlt.balance(), 200000000)
@@ -1759,7 +1787,7 @@ def test_wallet_balance_update_multi_network(self):
         k = "tpubDCutwJADa3iSbFtB2LgnaaqJgZ8FPXRRzcrMq7Tms41QNnTV291rpkps9vRwyss9zgDc7hS5V1aM1by8nFip5VjpGpz1oP54peKt" \
             "hJzfabX"
         wlt = Wallet.create("test_wallet_balance_update_multi_network", network='bitcoinlib_test',
-                            witness_type='legacy', db_uri=self.DATABASE_URI)
+                            witness_type='legacy', db_uri=self.database_uri)
         wlt.new_key()
         wlt.new_account(network='testnet')
         wlt.import_key(k)
@@ -1773,14 +1801,14 @@ def test_wallet_balance_update_total(self):
         k = "tpubDCutwJADa3iSbFtB2LgnaaqJgZ8FPXRRzcrMq7Tms41QNnTV291rpkps9vRwyss9zgDc7hS5V1aM1by8nFip5VjpGpz1oP54peKt" \
             "hJzfabX"
         wlt = Wallet.create("test_wallet_balance_update_total", keys=k, network='testnet',
-                            db_uri=self.DATABASE_URI)
+                            db_uri=self.database_uri)
         wlt.get_key()
         self.assertEqual(wlt.balance_update_from_serviceprovider(), 900)
 
     def test_wallet_add_dust_to_fee(self):
         # Send bitcoinlib test transaction and check if dust resume amount is added to fee
         wlt = Wallet.create('bcltestwlt', network='bitcoinlib_test', witness_type='legacy',
-                            db_uri=self.DATABASE_URI)
+                            db_uri=self.database_uri)
         to_key = wlt.get_key()
         wlt.utxos_update()
         t = wlt.send_to(to_key.address, 99992000, offline=False)
@@ -1789,7 +1817,7 @@ def test_wallet_add_dust_to_fee(self):
 
     def test_wallet_transactions_send_update_utxos(self):
         # Send bitcoinlib test transaction and check if all utxo's are updated after send
-        wlt = Wallet.create('bcltestwlt2', network='bitcoinlib_test', db_uri=self.DATABASE_URI)
+        wlt = Wallet.create('bcltestwlt2', network='bitcoinlib_test', db_uri=self.database_uri)
         to_keys = wlt.get_keys(number_of_keys=5)
         wlt.utxos_update()
         self.assertEqual(wlt.balance(), 1000000000)
@@ -1800,7 +1828,7 @@ def test_wallet_transactions_send_update_utxos(self):
         del wlt
 
     def test_wallet_transaction_import(self):
-        wlt = Wallet.create('bcltestwlt3', network='bitcoinlib_test', db_uri=self.DATABASE_URI)
+        wlt = Wallet.create('bcltestwlt3', network='bitcoinlib_test', db_uri=self.database_uri)
         to_key = wlt.get_key()
         wlt.utxos_update()
         t = wlt.send_to(to_key.address, 40000000)
@@ -1809,7 +1837,7 @@ def test_wallet_transaction_import(self):
         del wlt
 
     def test_wallet_transaction_import_raw(self):
-        wlt = Wallet.create('bcltestwlt4', network='bitcoinlib_test', db_uri=self.DATABASE_URI)
+        wlt = Wallet.create('bcltestwlt4', network='bitcoinlib_test', db_uri=self.database_uri)
         to_key = wlt.get_key()
         wlt.utxos_update()
         t = wlt.send_to(to_key.address, 50000000)
@@ -1818,7 +1846,7 @@ def test_wallet_transaction_import_raw(self):
         del wlt
 
     def test_wallet_transaction_import_raw_locktime(self):
-        wlt = Wallet.create('bcltestwlt4b', network='bitcoinlib_test', db_uri=self.DATABASE_URI)
+        wlt = Wallet.create('bcltestwlt4b', network='bitcoinlib_test', db_uri=self.database_uri)
         to_key = wlt.get_key()
         wlt.utxos_update()
         t = wlt.send_to(to_key.address, 12312837)
@@ -1828,11 +1856,11 @@ def test_wallet_transaction_import_raw_locktime(self):
         del wlt
 
     def test_wallet_transaction_import_raw_segwit_fee(self):
-        wallet_delete_if_exists('bcltestwlt-size', force=True, db_uri=self.DATABASE_URI)
+        wallet_delete_if_exists('bcltestwlt-size', force=True, db_uri=self.database_uri)
         pk = ('BC19UtECk2r9PVQYhZT9iJZvzK7jDgQXFQxRiguB28ESn53b8BjZjT4ZyQEStPD9yKAXBhTq6Wtb9zyPQiRU4chaTjEwvtpKW'
               'EdrMscH3ZqPTtdV')
         wlt = Wallet.create('bcltestwlt-size', keys=pk, network='bitcoinlib_test', witness_type='segwit',
-                            db_uri=self.DATABASE_URI)
+                            db_uri=self.database_uri)
         wlt.utxos_update()
         t = wlt.send_to(wlt.get_key().address, 8237234)
         t2 = wlt.transaction_import_raw(t.raw())
@@ -1847,7 +1875,7 @@ def test_wallet_transaction_load_segwit_size(self):
         pk = ('BC19UtECk2r9PVQYhZT9iJZvzK7jDgQXFQxRiguB28ESn53b8BjZjT4ZyQEStPD9yKAXBhTq6Wtb9zyPQiRU4chaTjEwvtpKW'
               'EdrMscH3ZqPTtdV')
         wlt = Wallet.create('bcltestwlt2-size', keys=pk, network='bitcoinlib_test', witness_type='segwit',
-                            db_uri=self.DATABASE_URI)
+                            db_uri=self.database_uri)
         wlt.utxos_update()
         t = wlt.send_to(wlt.get_key().address, 50000000, offline=False)
         t.verify()
@@ -1860,7 +1888,7 @@ def test_wallet_transaction_load_segwit_size(self):
         self.assertEqual(t.witness_data(), t2.witness_data())
 
     def test_wallet_transaction_import_dict(self):
-        wlt = Wallet.create('bcltestwlt5', network='bitcoinlib_test', db_uri=self.DATABASE_URI)
+        wlt = Wallet.create('bcltestwlt5', network='bitcoinlib_test', db_uri=self.database_uri)
         to_key = wlt.get_key()
         wlt.utxos_update()
         t = wlt.send_to(to_key.address, 60000000)
@@ -1870,7 +1898,7 @@ def test_wallet_transaction_import_dict(self):
 
     def test_wallet_transaction_fee_limits(self):
         wlt = Wallet.create('bcltestwlt6', network='bitcoinlib_test', witness_type='legacy',
-                            db_uri=self.DATABASE_URI)
+                            db_uri=self.database_uri)
         to_key = wlt.get_key()
         wlt.utxos_update()
         self.assertRaisesRegex(WalletError, 'Fee per kB of 660 is lower then minimal network fee of 1000',
@@ -1879,7 +1907,7 @@ def test_wallet_transaction_fee_limits(self):
                                 wlt.send_to, to_key.address, 50000000, fee=300000)
 
     def test_wallet_transaction_fee_zero_problem(self):
-        wlt = Wallet.create(name='bcltestwlt7', network='bitcoinlib_test', db_uri=self.DATABASE_URI)
+        wlt = Wallet.create(name='bcltestwlt7', network='bitcoinlib_test', db_uri=self.database_uri)
         nk = wlt.get_key()
         wlt.utxos_update()
         t = wlt.send_to(nk.address, 100000000, offline=False)
@@ -1890,9 +1918,9 @@ def test_wallet_transactions_estimate_size(self):
         prev_txid = '46fcfdbdc3573756916a0ced8bbc5418063abccd2c272f17bf266f77549b62d5'
 
         for witness_type in ['legacy', 'p2sh-segwit', 'segwit']:
-            wallet_delete_if_exists('wallet_estimate_size', force=True, db_uri=self.DATABASE_URI)
+            wallet_delete_if_exists('wallet_estimate_size', force=True, db_uri=self.database_uri)
             wl3 = Wallet.create('wallet_estimate_size', witness_type=witness_type,
-                                db_uri=self.DATABASE_URI)
+                                db_uri=self.database_uri)
             wl3.utxo_add(wl3.get_key().address, 110000, prev_txid, 0, 1)
             to_address = wl3.get_key_change().address
             t = wl3.transaction_create([(to_address, 90000)], fee=10000, random_output_order=False)
@@ -1909,9 +1937,9 @@ def test_wallet_transactions_estimate_size(self):
             p2 = HDKey(witness_type=witness_type, multisig=True)
             p3 = HDKey(witness_type=witness_type, multisig=True)
 
-            wallet_delete_if_exists('wallet_estimate_size_multisig', force=True, db_uri=self.DATABASE_URI)
+            wallet_delete_if_exists('wallet_estimate_size_multisig', force=True, db_uri=self.database_uri)
             wl3 = Wallet.create('wallet_estimate_size_multisig', [p1, p2.public_master(), p3.public_master()],
-                                sigs_required=2, db_uri=self.DATABASE_URI)
+                                sigs_required=2, db_uri=self.database_uri)
             wl3.utxo_add(wl3.get_key().address, 110000, prev_txid, 0, 1)
             to_address = wl3.get_key_change().address
             t = wl3.transaction_create([(to_address, 90000)], fee=10000, random_output_order=False)
@@ -1927,7 +1955,7 @@ def test_wallet_transaction_method(self):
         pk1 = HDKey(network='bitcoinlib_test')
         pk2 = HDKey(network='bitcoinlib_test')
         w = Wallet.create('wallet_transaction_tests', keys=[pk1, pk2], cosigner_id=0,
-                          db_uri=self.DATABASE_URI)
+                          db_uri=self.database_uri)
         w.get_key()
         w.utxos_update()
         self.assertEqual(len(w.transactions()), 2)
@@ -1936,7 +1964,7 @@ def test_wallet_transaction_method(self):
 
     def test_wallet_transaction_from_txid(self):
         w = Wallet.create('testwltbcl', keys='dda84e87df25f32d73a7f7d008ed2b89fc00d9d07fde588d1b8af0af297023de',
-                          witness_type='legacy', network='bitcoinlib_test', db_uri=self.DATABASE_URI)
+                          witness_type='legacy', network='bitcoinlib_test', db_uri=self.database_uri)
         w.utxos_update()
         wts = w.transactions()
         txid = wts[0].txid
@@ -1954,7 +1982,7 @@ def test_wallet_transaction_from_txid(self):
     def test_wallet_transaction_sign_with_hex(self):
         k = HDKey(network='bitcoinlib_test', witness_type='legacy')
         pmk = k.public_master()
-        w = Wallet.create('wallet_tx_tests', keys=pmk, network='bitcoinlib_test', db_uri=self.DATABASE_URI)
+        w = Wallet.create('wallet_tx_tests', keys=pmk, network='bitcoinlib_test', db_uri=self.database_uri)
         w.utxos_update()
         wt = w.transaction_create([(w.get_key(), 190000000)])
         sk = k.subkey_for_path("m/44'/9999999'/0'/0/0")
@@ -1969,7 +1997,7 @@ def test_wallet_transaction_sign_with_wif(self):
         w = wallet_create_or_open('test_wallet_transaction_sign_with_wif',
                                   keys=[wif, HDKey(wif2).public_master_multisig(witness_type='segwit')],
                                   witness_type='segwit', network='bitcoinlib_test',
-                                  db_uri=self.DATABASE_URI)
+                                  db_uri=self.database_uri)
         w.get_key()
         w.utxos_update()
         t = w.send_to('blt1q285vnphcs4r0t5dw06tmxl7aryj3jnx88duehv4p7eldsshrmygsmlq84z', 2000, fee=1000, offline=False)
@@ -1979,7 +2007,7 @@ def test_wallet_transaction_sign_with_wif(self):
 
     def test_wallet_transaction_restore_saved_tx(self):
         w = wallet_create_or_open('test_wallet_transaction_restore', network='bitcoinlib_test',
-                                  db_uri=self.DATABASE_URI)
+                                  db_uri=self.database_uri)
         wk = w.get_key()
         if not USE_FASTECDSA:
             self.skipTest("Need fastecdsa module with deterministic txid's to run this test")
@@ -1995,9 +2023,9 @@ def test_wallet_transaction_restore_saved_tx(self):
         to = w.get_key_change()
         t = w.sweep(to.address)
         tx_id = t.store()
-        wallet_empty('test_wallet_transaction_restore', db_uri=self.DATABASE_URI)
+        wallet_empty('test_wallet_transaction_restore', db_uri=self.database_uri)
         w = wallet_create_or_open('test_wallet_transaction_restore', network='bitcoinlib_test',
-                                  db_uri=self.DATABASE_URI)
+                                  db_uri=self.database_uri)
         w.get_key()
         w.utxos_update(utxos=utxos)
         to = w.get_key_change()
@@ -2006,7 +2034,7 @@ def test_wallet_transaction_restore_saved_tx(self):
 
     def test_wallet_transaction_send_keyid(self):
         w = Wallet.create('wallet_send_key_id', witness_type='segwit', network='bitcoinlib_test',
-                          db_uri=self.DATABASE_URI)
+                          db_uri=self.database_uri)
         keys = w.get_keys(number_of_keys=2)
         w.utxos_update()
         t = w.send_to('blt1qtk5swtntg8gvtsyr3kkx3mjcs5ncav84exjvde', 150000000, input_key_id=keys[1].key_id,
@@ -2019,7 +2047,7 @@ def test_wallet_transaction_send_keyid(self):
 
     def test_wallet_transactions_limit(self):
         address = '15yN7NPEpu82sHhB6TzCW5z5aXoamiKeGy'
-        w = wallet_create_or_open('ftrtxtstwlt', address, db_uri=self.DATABASE_URI)
+        w = wallet_create_or_open('ftrtxtstwlt', address, db_uri=self.database_uri)
         w.transactions_update(limit=2)
         self.assertGreaterEqual(w.balance(), 1000)
         self.assertGreaterEqual(len(w.transactions()), 2)
@@ -2028,7 +2056,7 @@ def test_wallet_transactions_limit(self):
 
     def test_wallet_transactions_update_by_txids(self):
         address = '15yN7NPEpu82sHhB6TzCW5z5aXoamiKeGy'
-        w = wallet_create_or_open('ftrtxtstwlt2', address, db_uri=self.DATABASE_URI)
+        w = wallet_create_or_open('ftrtxtstwlt2', address, db_uri=self.database_uri)
         w.transactions_update_by_txids(['b246dad8980093fa55814b4739396fd6a7f5f28994f721f55d1a862d6c98e7ab'])
         txs = w.transactions()
         self.assertEqual(len(txs), 1)
@@ -2038,7 +2066,7 @@ def test_wallet_transactions_sign_with_mnenomic(self):
         phr = 'battle alter frequent adult tuna follow always jar obtain until ice arrange'
         prv_key = HDKey.from_passphrase(phr, network='bitcoinlib_test')
         w = wallet_create_or_open('wlt-sign-with-mnemonic', keys=prv_key.public(), network='bitcoinlib_test',
-                                  scheme='single', db_uri=self.DATABASE_URI)
+                                  scheme='single', db_uri=self.database_uri)
         w.new_key()
         w.utxos_update()
         t = w.send_to('214bP4ZpdejMppADEnxSkzziPgEG6XGcxiJ', 100000)
@@ -2048,7 +2076,7 @@ def test_wallet_transactions_sign_with_mnenomic(self):
         self.assertTrue(t.verified)
 
     def test_wallet_select_inputs(self):
-        wlt = Wallet.create('bclwltsltinputs', network='bitcoinlib_test', db_uri=self.DATABASE_URI)
+        wlt = Wallet.create('bclwltsltinputs', network='bitcoinlib_test', db_uri=self.database_uri)
         wlt.get_key()
         wlt.utxos_update()
         self.assertEqual(wlt.select_inputs(150000000, max_utxos=1), [])
@@ -2057,7 +2085,7 @@ def test_wallet_select_inputs(self):
     def test_wallet_transaction_create_exceptions(self):
         wif = ('BC17qWy2RMw8AmwsqwTjmX2SwwSHBNA2c6KyGHs5Kghg3q6dPa4ajP1jwFBPCkoSeXWsPAiVD2iAcroVc6cJQmHrYatvi'
                'NCk5jDM83DkbPGFxbCK')
-        wlt = Wallet.create('test_wallet_transaction_create_exceptions', keys=wif, db_uri=self.DATABASE_URI)
+        wlt = Wallet.create('test_wallet_transaction_create_exceptions', keys=wif, db_uri=self.database_uri)
         wlt.utxos_update()
         self.assertRaisesRegex(WalletError, "Output array must be a list of tuples with address and amount. "
                                              "Use 'send_to' method to send to one address",
@@ -2066,13 +2094,13 @@ def test_wallet_transaction_create_exceptions(self):
         self.assertRaisesRegex(WalletError, "Input array contains 2 UTXO's but max_utxos=1 parameter specified",
                                 wlt.transaction_create, [('217rBycQpv9rjhiLcg94vdZ7muMVLJ9yysJ', 150000000)],
                                 inps, max_utxos=1)
-        wallet_empty('test_wallet_transaction_create_exceptions', db_uri=self.DATABASE_URI)
+        wallet_empty('test_wallet_transaction_create_exceptions', db_uri=self.database_uri)
         self.assertRaisesRegex(WalletError, "UTXO",
                                 wlt.transaction_create, [('217rBycQpv9rjhiLcg94vdZ7muMVLJ9yysJ', 150000000)],
                                 inps)
 
     def test_wallet_transactions_sweep(self):
-        w = wallet_create_or_open('test_wallet_sweep_check_fee', db_uri=self.DATABASE_URI)
+        w = wallet_create_or_open('test_wallet_sweep_check_fee', db_uri=self.database_uri)
         w.utxo_add(w.new_key().address, 5000,
                    'f31446151f06522eb321d5992f4f1c95123c8b9d082b92c391df83c6d0a35516', 0, 1)
         t = w.sweep('14pThTJoEnQxbJJVYLhzSKcs6EmZgShscX', fee=2000)
@@ -2083,7 +2111,7 @@ def test_wallet_transactions_sweep(self):
                                w.sweep, to_address='14pThTJoEnQxbJJVYLhzSKcs6EmZgShscX', fee=6000)
 
     def test_wallet_sweep_multiple_inputs_or_outputs(self):
-        w = wallet_create_or_open('test_wallet_sweep_multiple_outputs', db_uri=self.DATABASE_URI)
+        w = wallet_create_or_open('test_wallet_sweep_multiple_outputs', db_uri=self.database_uri)
 
         utxos = [
             {
@@ -2134,7 +2162,7 @@ def test_wallet_sweep_multiple_inputs_or_outputs(self):
         self.assertTrue(t.verified)
 
     def test_wallet_send_multiple_change_outputs(self):
-        w = wallet_create_or_open('test_wallet_send_multiple_change_outputs', db_uri=self.DATABASE_URI)
+        w = wallet_create_or_open('test_wallet_send_multiple_change_outputs', db_uri=self.database_uri)
 
         utxos = [
             {
@@ -2181,7 +2209,7 @@ def test_wallet_send_multiple_change_outputs(self):
 
     def test_wallet_transaction_save_and_load(self):
         w = wallet_create_or_open('wallet_transaction_save_and_load', network='bitcoinlib_test',
-                                  db_uri=self.DATABASE_URI)
+                                  db_uri=self.database_uri)
         w.utxos_update()
         t = w.send_to(w.get_key(), 50000001)
         self.assertTrue(t.verify())
@@ -2193,7 +2221,7 @@ def test_wallet_transaction_save_and_load(self):
 
     def test_wallet_transaction_save_and_load_filename(self):
         w = wallet_create_or_open('wallet_transaction_save_and_load_filename', network='bitcoinlib_test',
-                                  db_uri=self.DATABASE_URI)
+                                  db_uri=self.database_uri)
         w.utxos_update()
         t = w.send_to(w.get_key(), 44000001)
         self.assertTrue(t.verify())
@@ -2205,7 +2233,7 @@ def test_wallet_transaction_save_and_load_filename(self):
 
     def test_wallet_avoid_forced_address_reuse(self):
         w = wallet_create_or_open('wallet_avoid_forced_address_reuse_test', network='bitcoinlib_test',
-                                  db_uri=self.DATABASE_URI)
+                                  db_uri=self.database_uri)
         k1 = w.get_key()
         w.utxos_update()
         k2 = w.new_key()
@@ -2219,7 +2247,7 @@ def test_wallet_avoid_forced_address_reuse(self):
         self.assertEqual(len(t.inputs), 1)
 
     def test_wallet_avoid_forced_address_reuse2(self):
-        w = wallet_create_or_open('wallet_avoid_forced_address_reuse_test2', db_uri=self.DATABASE_URI)
+        w = wallet_create_or_open('wallet_avoid_forced_address_reuse_test2', db_uri=self.database_uri)
         utxos = [
             {
                 'address': w.new_key().address,
@@ -2243,19 +2271,19 @@ def test_wallet_avoid_forced_address_reuse2(self):
                                 fee=150)
 
     def test_wallet_transactions_delete(self):
-        w = wallet_create_or_open('wallet_transactions_delete', network='bitcoinlib_test', db_uri=self.DATABASE_URI)
+        w = wallet_create_or_open('wallet_transactions_delete', network='bitcoinlib_test', db_uri=self.database_uri)
         w.utxos_update()
         w.transactions()[0].delete()
         self.assertEqual(len(w.transactions()), 1)
 
     def test_wallet_create_import_key(self):
         w = wallet_create_or_open("test_wallet_create_import_key_private", network='bitcoinlib_test',
-                                  db_uri=self.DATABASE_URI)
+                                  db_uri=self.database_uri)
 
         w.utxos_update()
         wk = w.public_master()
         w2 = wallet_create_or_open('test_wallet_create_import_key_public', network='bitcoinlib_test', keys=wk,
-                                   db_uri=self.DATABASE_URI)
+                                   db_uri=self.database_uri)
         w2.utxos_update()
 
         wt = w2.send_to('21HKMUVtSUETuWyDESrmCj6Vwvtuns8XG5k', 1000, fee=1000)
@@ -2265,7 +2293,7 @@ def test_wallet_create_import_key(self):
         self.assertEqual(wt, wt2)
 
     def test_wallet_transactions_pagination(self):
-        w = wallet_create_or_open("bclt_wallet_pagination_test", network='bitcoinlib_test', db_uri=self.DATABASE_URI)
+        w = wallet_create_or_open("bclt_wallet_pagination_test", network='bitcoinlib_test', db_uri=self.database_uri)
         w.get_keys(number_of_keys=10)
         w.utxos_update()
         txs_all = w.transactions_full()
@@ -2277,7 +2305,7 @@ def test_wallet_transactions_pagination(self):
 
     def test_wallet_merge_transactions(self):
         w = wallet_create_or_open('wallet_merge_transactions_tests', network='bitcoinlib_test',
-                                  db_uri=self.DATABASE_URI)
+                                  db_uri=self.database_uri)
         w.utxos_update()
         u = w.utxos()
 
@@ -2291,7 +2319,7 @@ def test_wallet_merge_transactions(self):
 
     def test_wallet_transaction_replace_by_fee(self):
         w = wallet_create_or_open('wallet_transaction_rbf', network='bitcoinlib_test',
-                                  db_uri=self.DATABASE_URI)
+                                  db_uri=self.database_uri)
         w.utxos_update()
         address = w.get_key()
         t = w.send_to(address, 10000, fee=500, replace_by_fee=True)
@@ -2302,17 +2330,16 @@ def test_wallet_transaction_replace_by_fee(self):
         self.assertEqual(t2.inputs[0].sequence, SEQUENCE_REPLACE_BY_FEE)
 
 
-@parameterized_class(*params)
-class TestWalletSegwit(TestWalletMixin, unittest.TestCase):
+class TestWalletSegwit(unittest.TestCase):
 
     @classmethod
     def setUpClass(cls):
-        cls.db_remove()
+        cls.database_uri = database_init()
 
     def test_wallet_segwit_create_p2pkh(self):
         phrase = "review arch uniform illness hello animal device reform bicycle obscure cruise boat"
         wlt = wallet_create_or_open('thetestwallet-bech32', keys=phrase, network='bitcoin', witness_type='segwit',
-                                    db_uri=self.DATABASE_URI)
+                                    db_uri=self.database_uri)
         self.assertEqual(wlt.get_key().address, 'bc1ql22f3gqqphsejtqkqjqg9an03sjz4l6gztcm34')
 
     def test_wallet_segwit_create_pswsh(self):
@@ -2321,7 +2348,7 @@ def test_wallet_segwit_create_pswsh(self):
         pk1 = HDKey.from_passphrase(phrase1, witness_type='segwit', multisig=True)
         pk2 = HDKey.from_passphrase(phrase2, witness_type='segwit', multisig=True)
         w = Wallet.create('multisig-segwit', [pk1, pk2.public_master()], sigs_required=1, witness_type='segwit',
-                          db_uri=self.DATABASE_URI)
+                          db_uri=self.database_uri)
         self.assertEqual(w.get_key().address, 'bc1qfjhmzzt9l6dmm0xx3tc6qrtff8dve7j7qrcyp88tllszm97r84aqxel5jk')
 
     def test_wallet_segwit_create_p2sh_p2wsh(self):
@@ -2330,7 +2357,7 @@ def test_wallet_segwit_create_p2sh_p2wsh(self):
         pk1 = HDKey.from_passphrase(phrase1)
         pk2 = HDKey.from_passphrase(phrase2)
         w = Wallet.create('segwit-p2sh-p2wsh', [pk1, pk2.public_master(witness_type='p2sh-segwit', multisig=True)],
-                          sigs_required=2, witness_type='p2sh-segwit', db_uri=self.DATABASE_URI)
+                          sigs_required=2, witness_type='p2sh-segwit', db_uri=self.database_uri)
         nk = w.get_key()
         self.assertEqual(nk.address, '3JFyRjKWYFz5BMFHLZvT7EZQJ85gLFvtkT')
         self.assertEqual(nk.key_type, 'multisig')
@@ -2339,7 +2366,7 @@ def test_wallet_segwit_create_p2sh_p2wsh(self):
     def test_wallet_segwit_create_p2sh_p2wpkh(self):
         phrase = 'fun brick apology sport museum vague once gospel walnut jump spawn hedgehog'
         w = wallet_create_or_open('segwit-p2sh-p2wpkh', phrase, purpose=49, witness_type='p2sh-segwit',
-                                  network='bitcoin', db_uri=self.DATABASE_URI)
+                                  network='bitcoin', db_uri=self.database_uri)
 
         k1 = w.get_key()
         address = '3Disr2CmERuYuuMkkfGrjRUHqDENQvtNep'
@@ -2349,7 +2376,7 @@ def test_wallet_segwit_create_p2sh_p2wpkh(self):
 
     def test_wallet_segwit_p2wpkh_send(self):
         w = Wallet.create('segwit_p2wpkh_send', witness_type='segwit', network='bitcoinlib_test',
-                          db_uri=self.DATABASE_URI)
+                          db_uri=self.database_uri)
         w.get_key()
         w.utxos_update()
         t = w.send_to('blt1q7ywlg3lsyntsmp74jh65pnkntk3csagdwpz78k', 10000, offline=False)
@@ -2362,7 +2389,7 @@ def test_wallet_segwit_p2wpkh_send(self):
     def test_wallet_segwit_p2wsh_send(self):
         w = Wallet.create('segwit_p2wsh_send', witness_type='segwit', network='bitcoinlib_test',
                           keys=[HDKey(network='bitcoinlib_test'), HDKey(network='bitcoinlib_test')], sigs_required=2,
-                          cosigner_id=0, db_uri=self.DATABASE_URI)
+                          cosigner_id=0, db_uri=self.database_uri)
         k = w.get_key()
         w.utxos_update()
         w.utxos_update(key_id=k.key_id)   # Test db updates after second request and only update single key
@@ -2375,7 +2402,7 @@ def test_wallet_segwit_p2wsh_send(self):
 
     def test_wallet_segwit_p2sh_p2wpkh_send(self):
         w = Wallet.create('segwit_p2sh_p2wpkh_send', witness_type='p2sh-segwit', network='bitcoinlib_test',
-                          db_uri=self.DATABASE_URI)
+                          db_uri=self.database_uri)
         w.get_key()
         w.utxos_update()
         t = w.send_to('blt1q7ywlg3lsyntsmp74jh65pnkntk3csagdwpz78k', 10000, offline=False)
@@ -2389,7 +2416,7 @@ def test_wallet_segwit_p2sh_p2wsh_send(self):
         w = Wallet.create('segwit_p2sh_p2wsh_send', witness_type='p2sh-segwit', network='bitcoinlib_test',
                           keys=[HDKey(network='bitcoinlib_test'), HDKey(network='bitcoinlib_test'),
                                 HDKey(network='bitcoinlib_test')], sigs_required=2, cosigner_id=0,
-                          db_uri=self.DATABASE_URI)
+                          db_uri=self.database_uri)
         w.get_key()
         w.utxos_update()
         t = w.send_to('blt1q7ywlg3lsyntsmp74jh65pnkntk3csagdwpz78k', 10000, offline=False)
@@ -2403,7 +2430,7 @@ def test_wallet_segwit_uncompressed_error(self):
         k = HDKey(compressed=False, network='bitcoinlib_test')
         self.assertRaisesRegex(BKeyError, 'Uncompressed keys are non-standard', wallet_create_or_open,
                                 'segwit_uncompressed_error', k, witness_type='segwit', network='bitcoinlib_test',
-                                db_uri=self.DATABASE_URI)
+                                db_uri=self.database_uri)
 
     def test_wallet_segwit_bitcoin_send(self):
         # Create several SegWit wallet and create transaction to send to each other. Uses utxo_add() method to create
@@ -2420,7 +2447,7 @@ def test_wallet_segwit_bitcoin_send(self):
         ]
 
         wl1 = Wallet.create('segwit_bitcoin_p2wsh_send', key_list, sigs_required=2, witness_type='segwit',
-                            db_uri=self.DATABASE_URI)
+                            db_uri=self.database_uri)
         wl1.utxo_add(wl1.get_key().address, 10000000, prev_txid, 0, 1)
         to_address = wl1.get_key_change().address
         t = wl1.transaction_create([(to_address, 100000)], fee=10000, random_output_order=False)
@@ -2431,7 +2458,7 @@ def test_wallet_segwit_bitcoin_send(self):
         self.assertFalse(t.error)
 
         # === Segwit P2WPKH to P2WSH ===
-        wl2 = Wallet.create('segwit_bitcoin_p2wpkh_send', witness_type='segwit', db_uri=self.DATABASE_URI)
+        wl2 = Wallet.create('segwit_bitcoin_p2wpkh_send', witness_type='segwit', db_uri=self.database_uri)
         wl2.utxo_add(wl2.get_key().address, 200000, prev_txid, 0, 1)
         to_address = wl1.get_key_change().address
         t = wl2.transaction_create([(to_address, 100000)], fee=10000, random_output_order=False)
@@ -2442,7 +2469,7 @@ def test_wallet_segwit_bitcoin_send(self):
 
         # === Segwit P2SH-P2WPKH to P2WPK ===
         wl3 = Wallet.create('segwit_bitcoin_p2sh_p2wpkh_send', witness_type='p2sh-segwit',
-                            db_uri=self.DATABASE_URI)
+                            db_uri=self.database_uri)
         wl3.utxo_add(wl3.get_key().address, 110000, prev_txid, 0, 1)
         t = wl3.transaction_create([(to_address, 100000)], fee=10000, random_output_order=False)
         t.sign()
@@ -2453,7 +2480,7 @@ def test_wallet_segwit_bitcoin_send(self):
     def test_wallet_segwit_litecoin_multi_accounts(self):
         phrase = 'rug rebuild group coin artwork degree basic humor flight away praise able'
         w = Wallet.create('segwit_wallet_litecoin_p2wpkh', keys=phrase, network='litecoin',
-                          db_uri=self.DATABASE_URI, witness_type='segwit')
+                          db_uri=self.database_uri, witness_type='segwit')
         self.assertEqual(w.get_key().address, "ltc1qsrzxzg39jyt8knsw5hlqmpwmuc8ejxvp9hfch8")
         self.assertEqual(w.get_key_change().address, "ltc1q9n6zknsw2hhq7dkyvczars8vl8zta5yusjjem5")
         acc2 = w.new_account()
@@ -2465,14 +2492,14 @@ def test_wallet_segwit_litecoin_multi_accounts(self):
         phrase = 'rug rebuild group coin artwork degree basic humor flight away praise able'
 
         w = Wallet.create('segwit_wallet_litecoin_p2sh_p2wpkh', keys=phrase, network='litecoin',
-                          db_uri=self.DATABASE_URI, witness_type='p2sh-segwit')
+                          db_uri=self.database_uri, witness_type='p2sh-segwit')
         self.assertEqual(w.get_key().address, "MW1V5XPPW1YYQ5BGL5mSWEZNZSyD4XQPgh")
         self.assertEqual(w.get_key_change().address, "MWQoYMDTNvwZPNNypLMzkQ7JNSCtvS554j")
 
     def test_wallet_segwit_litecoin_sweep(self):
         phrase = 'wagon tunnel garage blast eager jaguar shop bring lake dumb chalk emerge'
         w = wallet_create_or_open('ltcsw', phrase, network='litecoin', witness_type='segwit',
-                                  db_uri=self.DATABASE_URI)
+                                  db_uri=self.database_uri)
         w.utxo_add('ltc1qu8dum66gd6dfr2cchgenf87qqxgenyme2kyhn8', 28471723,
                    '21da13be453624cf46b3d883f39602ce74d04efa7a186037898b6d7bcfd405ee', 10, 99)
         t = w.sweep('MLqham8sXULvktmNMuDQdrBbHRdytVZ1QK')
@@ -2482,7 +2509,7 @@ def test_wallet_segwit_litecoin_multisig(self):
         p1 = 'only sing document speed outer gauge stand govern way column material odor'
         p2 = 'oyster pelican debate mass scene title pipe lock recipe flavor razor accident'
         w = wallet_create_or_open('ltcswms', [p1, p2], network='litecoin', witness_type='segwit',
-                                  cosigner_id=0, db_uri=self.DATABASE_URI)
+                                  cosigner_id=0, db_uri=self.database_uri)
         w.get_keys(number_of_keys=2)
         w.utxo_add('ltc1qkewaz7lxn75y6wppvqlsfhrnq5p5mksmlp26n8xsef0556cdfzqq2uhdrt', 2100000000000001,
                    '21da13be453624cf46b3d883f39602ce74d04efa7a186037898b6d7bcfd405ee', 0, 15)
@@ -2495,7 +2522,7 @@ def test_wallet_segwit_multisig_multiple_inputs(self):
         cosigner = HDKey(network='bitcoinlib_test')
         w = wallet_create_or_open('test_wallet_segwit_multisig_multiple_inputs',
                                   [main_key, cosigner.public_master(witness_type='segwit', multisig=True)],
-                                  witness_type='segwit', network='bitcoinlib_test', db_uri=self.DATABASE_URI)
+                                  witness_type='segwit', network='bitcoinlib_test', db_uri=self.database_uri)
 
         w.get_keys(number_of_keys=2)
         w.utxos_update()
@@ -2512,7 +2539,7 @@ def test_wallet_segwit_multiple_account_paths(self):
             "ZprvAhadJRUYsNgeBbjftwKvAhDEV1hrYBGY19wATHqnEt5jfWXxXChYP8Qfnw3w2zJZskNercma5S1fWYH7e7XwbTVPgbabvs1CfU"
             "zY2KQD2cB")
         w = Wallet.create("account-test", keys=[pk1, pk2.public_master(multisig=True)], witness_type='segwit',
-                          db_uri=self.DATABASE_URI)
+                          db_uri=self.database_uri)
         w.new_account()
         w.new_account()
         w.new_account(account_id=100)
@@ -2531,7 +2558,7 @@ def test_wallet_segwit_multiple_networks_accounts(self):
         pk2 = 'defy push try brush ceiling sugar film present goat settle praise toilet'
         wallet = Wallet.create(keys=[pk1, pk2], network='bitcoin', name='test_wallet_multicurrency',
                                witness_type='segwit', cosigner_id=0, encoding='base58',
-                               db_uri=self.DATABASE_URI)
+                               db_uri=self.database_uri)
         wallet.new_account(network='litecoin')
         wallet.new_account(network='litecoin')
         wallet.new_account(network='bitcoin')
@@ -2551,16 +2578,15 @@ def test_wallet_segwit_multiple_networks_accounts(self):
                          "bc1qd0f952amxkmqc9e60u4g8w4r5a3cx22lt5vqeeyljllacxq8ezusclkwa0")
 
 
-@parameterized_class(*params)
-class TestWalletKeyStructures(TestWalletMixin, unittest.TestCase):
+class TestWalletKeyStructures(unittest.TestCase):
 
     @classmethod
     def setUpClass(cls):
-        cls.db_remove()
+        cls.database_uri = database_init()
 
     def test_wallet_path_expand(self):
         wlt = wallet_create_or_open('wallet_path_expand', network='bitcoin', witness_type='legacy',
-                                    db_uri=self.DATABASE_URI)
+                                    db_uri=self.database_uri)
         self.assertListEqual(wlt.path_expand([8]), ['m', "44'", "0'", "0'", '0', '8'])
         self.assertListEqual(wlt.path_expand(['8']), ['m', "44'", "0'", "0'", '0', '8'])
         self.assertListEqual(wlt.path_expand(["99'", 1, 2]), ['m', "44'", "0'", "99'", '1', '2'])
@@ -2578,7 +2604,7 @@ def test_wallet_path_expand(self):
 
     def test_wallet_exotic_key_paths(self):
         w = Wallet.create("simple_custom_keypath", key_path="m/change/address_index", witness_type='legacy',
-                          db_uri=self.DATABASE_URI)
+                          db_uri=self.database_uri)
         self.assertEqual(w.new_key().path, "m/0/1")
         self.assertEqual(w.new_key_change().path, "m/1/0")
         self.assertEqual(w.wif()[:4], 'xpub')
@@ -2586,7 +2612,7 @@ def test_wallet_exotic_key_paths(self):
         w = Wallet.create(
             "strange_key_path", keys=[HDKey(), HDKey()], purpose=100, cosigner_id=0,
             key_path="m/purpose'/cosigner_index/change/address_index", witness_type='legacy',
-            db_uri=self.DATABASE_URI)
+            db_uri=self.database_uri)
         self.assertEqual(w.new_key().path, "m/100'/0/0/0")
         self.assertEqual(w.new_key_change().path, "m/100'/0/1/0")
 
@@ -2597,7 +2623,7 @@ def test_wallet_exotic_key_paths(self):
         w = Wallet.create(
             "long_key_path", keys=[wif1, wif2], witness_type='segwit', cosigner_id=1,
             key_path="m/purpose'/coin_type'/account'/script_type'/cosigner_index/change/address_index",
-            db_uri=self.DATABASE_URI)
+            db_uri=self.database_uri)
         self.assertEqual(w.new_key().path, "M/1/0/0")
         self.assertEqual(w.new_key_change().path, "M/1/1/0")
         self.assertEqual(w.public_master()[0].wif, wif1)
@@ -2609,23 +2635,22 @@ def test_wallet_normalize_path(self):
                                 "m/44h/0p/100H//1201")
 
     def test_wallet_accounts(self):
-        w = Wallet.create('test_litecoin_accounts', network='litecoin', account_id=1111, db_uri=self.DATABASE_URI)
+        w = Wallet.create('test_litecoin_accounts', network='litecoin', account_id=1111, db_uri=self.database_uri)
         w.new_account(account_id=2222)
         w.new_account(account_id=5555, network='testnet')
         self.assertListEqual(w.accounts(), [1111, 2222])
         self.assertListEqual(w.accounts(network='testnet'), [5555])
 
 
-@parameterized_class(*params)
-class TestWalletReadonlyAddress(TestWalletMixin, unittest.TestCase):
+class TestWalletReadonlyAddress(unittest.TestCase):
 
     @classmethod
     def setUpClass(cls):
-        cls.db_remove()
+        cls.database_uri = database_init()
 
     def test_wallet_readonly_create_and_import(self):
         k = '13A1W4jLPP75pzvn2qJ5KyyqG3qPSpb9jM'
-        w = wallet_create_or_open('addrwlt', k, db_uri=self.DATABASE_URI)
+        w = wallet_create_or_open('addrwlt', k, db_uri=self.database_uri)
         addr = Address.parse('12yuSkjKmHzXCFn39PK1XP3XyeoVw9LJdN')
         w.import_key(addr)
         self.assertEqual(len(w.accounts()), 1)
@@ -2641,7 +2666,7 @@ def test_wallet_address_import_public_key(self):
         wif = 'xpub661MyMwAqRbcFCwFkcko75u2VEinbG1u5U4nq8AFJq4AbLPEvwcmhZGgGcnDcEBpcfAFEP8vVhbJJvX1ieGWdoaa5AnHfyB' \
               'DAY95TfYH6H6'
         address = '1EJiPa66sT4PCDCFnc7oRnpWebAogPqppr'
-        w = Wallet.create('test_wallet_address_import_public_key', address, db_uri=self.DATABASE_URI)
+        w = Wallet.create('test_wallet_address_import_public_key', address, db_uri=self.database_uri)
         self.assertEqual(w.addresslist(), [address])
         self.assertIsNone(w.main_key.key_public)
         w.import_key(wif)
@@ -2652,7 +2677,7 @@ def test_wallet_address_import_public_key_segwit(self):
         address = 'bc1q84xq6lrzr09t3h2pw5ys5zee7rn3mxh5v65732'
         wif = 'zprvAWgYBBk7JR8Gj9CNFRBUq3DvNHDbZhH4L6AybFSTCH7DDW6boPyiQfTigAPhJma5wC4TP1o53Gz1XLh94xD3dVQUpsFDaCb2' \
               '9XmDQKBwKhz'
-        w = Wallet.create('test_wallet_address_import_public_key_segwit', address, db_uri=self.DATABASE_URI)
+        w = Wallet.create('test_wallet_address_import_public_key_segwit', address, db_uri=self.database_uri)
         self.assertEqual(w.addresslist(), [address])
         self.assertIsNone(w.main_key.wif)
         w.import_key(wif)
@@ -2662,27 +2687,26 @@ def test_wallet_address_import_private_key(self):
         wif = 'xprv9s21ZrQH143K2irnebDnjwxHwCtJBoJ3iF9C2jkdkVXBiY46PQJX9kxCRMVcM1YXLERWUiUBoxQEUDqFAKbrTaL9FB4HfRY' \
               'jsGgCGpRPWTy'
         address = '1EJiPa66sT4PCDCFnc7oRnpWebAogPqppr'
-        w = Wallet.create('test_wallet_address_import_private_key', address, db_uri=self.DATABASE_URI)
+        w = Wallet.create('test_wallet_address_import_private_key', address, db_uri=self.database_uri)
         self.assertListEqual(w.addresslist(), [address])
         self.assertFalse(w.main_key.is_private)
         w.import_key(wif)
         self.assertTrue(w.main_key.is_private)
 
 
-@parameterized_class(*params)
-class TestWalletMixedWitnessTypes(TestWalletMixin, unittest.TestCase):
+class TestWalletMixedWitnessTypes(unittest.TestCase):
 
     @classmethod
     def setUpClass(cls):
-        cls.db_remove()
+        cls.database_uri = database_init()
 
     def test_wallet_mixed_witness_types_address(self):
         pk = 'a9b723d90282710036e06ec5b3d0c303817e486fa3e8bc117aec839deaedb961'
-        wseg = Wallet.create(name='wallet_witness_type_segwit', keys=pk, db_uri=self.DATABASE_URI)
+        wseg = Wallet.create(name='wallet_witness_type_segwit', keys=pk, db_uri=self.database_uri)
         wleg = Wallet.create(name='wallet_witness_type_legacy', keys=pk, witness_type='legacy',
-                             db_uri=self.DATABASE_URI)
+                             db_uri=self.database_uri)
         wp2sh = Wallet.create(name='wallet_witness_type_p2sh', keys=pk, witness_type='p2sh-segwit',
-                              db_uri=self.DATABASE_URI)
+                              db_uri=self.database_uri)
         self.assertEqual(wseg.get_key(witness_type='legacy').address, wleg.get_key().address)
         self.assertEqual(wseg.get_key(witness_type='p2sh-segwit').address, wp2sh.get_key().address)
         self.assertEqual(wleg.get_key(witness_type='segwit').address, wseg.get_key().address)
@@ -2698,11 +2722,11 @@ def test_wallet_mixed_witness_types_address(self):
 
     def test_wallet_mixed_witness_types_masterkeys(self):
         pk = '5f5b1f7d8c023c4bf5deff1eefe7ee27c126879da7e65487cf9ff64bdc3a1518'
-        wseg = Wallet.create(name='wallet_witness_types_masterkey_segwit', keys=pk, db_uri=self.DATABASE_URI)
+        wseg = Wallet.create(name='wallet_witness_types_masterkey_segwit', keys=pk, db_uri=self.database_uri)
         wleg = Wallet.create(name='wallet_witness_types_masterkey_legacy', keys=pk, witness_type='legacy',
-                             db_uri=self.DATABASE_URI)
+                             db_uri=self.database_uri)
         wp2sh = Wallet.create(name='wallet_witness_types_masterkey_p2sh', keys=pk, witness_type='p2sh-segwit',
-                              db_uri=self.DATABASE_URI)
+                              db_uri=self.database_uri)
         self.assertEqual(wseg.public_master().wif, wleg.public_master(witness_type='segwit').wif)
         self.assertEqual(wseg.public_master(witness_type='p2sh-segwit').wif,
                          wleg.public_master(witness_type='p2sh-segwit').wif)
@@ -2710,7 +2734,7 @@ def test_wallet_mixed_witness_types_masterkeys(self):
         self.assertEqual(wleg.public_master().wif, wp2sh.public_master(witness_type='legacy').wif)
 
     def test_wallet_mixed_witness_types_send(self):
-        w = Wallet.create(name='wallet_mixed_bcltest', network='bitcoinlib_test', db_uri=self.DATABASE_URI)
+        w = Wallet.create(name='wallet_mixed_bcltest', network='bitcoinlib_test', db_uri=self.database_uri)
         seg_key = w.get_key()
         leg_key = w.new_key(witness_type='legacy')
         p2sh_key = w.new_key(witness_type='p2sh-segwit')
@@ -2729,13 +2753,13 @@ def test_wallet_mixed_witness_no_private_key(self):
         pub_master = ('zpub6qwhKTArtsgtCpVweSyJdVqmXTkmH3HXE2sc7RdhF5drnmcW2HXuFBqRPzVxhQkdaER3bSZeJbAbYxNGeShwUu'
                       'T49JfJqZLHNAsEUHD76AR')
         address = 'bc1qgf8fzfj65lcr5vae0sh77akurh4zc9s9m4uspm'
-        w = Wallet.create('wallet_mix_no_private', keys=pub_master, db_uri=self.DATABASE_URI)
+        w = Wallet.create('wallet_mix_no_private', keys=pub_master, db_uri=self.database_uri)
         self.assertEqual(address, w.get_key().address)
         self.assertRaisesRegexp(WalletError, "This wallet has no private key, cannot use multiple witness types",
                                 w.get_key, witness_type='legacy')
 
     def test_wallet_mixed_witness_type_create(self):
-        w = Wallet.create('test_wallet_mixed_witness_type_create', network='testnet', db_uri=self.DATABASE_URI)
+        w = Wallet.create('test_wallet_mixed_witness_type_create', network='testnet', db_uri=self.database_uri)
         w.get_key(witness_type='legacy')
         w.new_account('test-account', 101, witness_type='p2sh-segwit')
         w.get_key(account_id=101)