fix tests

lbry/testcase.py

@@ -340,6 +340,7 @@ class CommandTestCase(IntegrationTestCase):
         server_tmp_dir = tempfile.mkdtemp()
         self.addCleanup(shutil.rmtree, server_tmp_dir)
         self.server_config = Config()
+        self.server_config.transaction_cache_size = 10000
         self.server_storage = SQLiteStorage(self.server_config, ':memory:')
         await self.server_storage.open()
 
@@ -389,6 +390,7 @@ class CommandTestCase(IntegrationTestCase):
         conf.fixed_peers = [('127.0.0.1', 5567)]
         conf.known_dht_nodes = []
         conf.blob_lru_cache_size = self.blob_lru_cache_size
+        conf.transaction_cache_size = 10000
         conf.components_to_skip = [
             DHT_COMPONENT, UPNP_COMPONENT, HASH_ANNOUNCER_COMPONENT,
             PEER_PROTOCOL_SERVER_COMPONENT

lbry/wallet/ledger.py

@@ -156,7 +156,7 @@ class Ledger(metaclass=LedgerRegistry):
         self._on_ready_controller = StreamController()
         self.on_ready = self._on_ready_controller.stream
 
-        self._tx_cache = pylru.lrucache(self.config.get("tx_cache_size", 10_000_000))
+        self._tx_cache = pylru.lrucache(self.config.get("tx_cache_size", 10_000))
         self._update_tasks = TaskGroup()
         self._other_tasks = TaskGroup()  # that we dont need to start
         self._utxo_reservation_lock = asyncio.Lock()
@@ -578,7 +578,7 @@ class Ledger(metaclass=LedgerRegistry):
                     log.warning("history mismatch: %s vs %s", remote_history[remote_i], pending_synced_history[i])
                 synced_history += pending_synced_history[i]
 
-            cache_size = self.config.get("tx_cache_size", 10_000_000)
+            cache_size = self.config.get("tx_cache_size", 10_000)
             for txid, cache_item in updated_cached_items.items():
                 cache_item.pending_verifications -= 1
                 if cache_item.pending_verifications < 0:
@@ -665,7 +665,8 @@ class Ledger(metaclass=LedgerRegistry):
             if cache_item is None:
                 cache_item = TransactionCacheItem()
                 self._tx_cache[txid] = cache_item
-            tx = cache_item.tx or Transaction(bytes.fromhex(raw.decode()), height=remote_height)
+            tx = cache_item.tx or Transaction(bytes.fromhex(raw.decode() if isinstance(raw, bytes) else raw),
+                                              height=remote_height)
             tx.height = remote_height
             cache_item.tx = tx
             if 'merkle' in merkle and remote_heights[txid] > 0:

tests/integration/blockchain/test_network.py

@@ -71,7 +71,7 @@ class ReconnectTests(IntegrationTestCase):
         self.ledger.network.session_pool.new_connection_event.clear()
         await node2.start(self.blockchain)
         # this is only to speed up the test as retrying would take 4+ seconds
-        for session in self.ledger.network.session_pool.sessions.values():
+        for session in self.ledger.network.session_pool.sessions:
             session.trigger_urgent_reconnect.set()
         await asyncio.wait_for(self.ledger.network.session_pool.new_connection_event.wait(), timeout=1)
         self.assertEqual(2, len(list(self.ledger.network.session_pool.available_sessions)))
@@ -139,7 +139,7 @@ class ReconnectTests(IntegrationTestCase):
     async def test_online_but_still_unavailable(self):
         # Edge case. See issue #2445 for context
         self.assertIsNotNone(self.ledger.network.session_pool.fastest_session)
-        for session in self.ledger.network.session_pool.sessions.values():
+        for session in self.ledger.network.session_pool.sessions:
             session.response_time = None
         self.assertIsNone(self.ledger.network.session_pool.fastest_session)
 

tests/unit/blob_exchange/test_transfer_blob.py

@@ -36,12 +36,14 @@ class BlobExchangeTestBase(AsyncioTestCase):
         self.addCleanup(shutil.rmtree, self.server_dir)
         self.server_config = Config(data_dir=self.server_dir, download_dir=self.server_dir, wallet=self.server_dir,
                                     fixed_peers=[])
+        self.server_config.transaction_cache_size = 10000
         self.server_storage = SQLiteStorage(self.server_config, os.path.join(self.server_dir, "lbrynet.sqlite"))
         self.server_blob_manager = BlobManager(self.loop, self.server_dir, self.server_storage, self.server_config)
         self.server = BlobServer(self.loop, self.server_blob_manager, 'bQEaw42GXsgCAGio1nxFncJSyRmnztSCjP')
 
         self.client_config = Config(data_dir=self.client_dir, download_dir=self.client_dir,
                                     wallet=self.client_wallet_dir, fixed_peers=[])
+        self.client_config.transaction_cache_size = 10000
         self.client_storage = SQLiteStorage(self.client_config, os.path.join(self.client_dir, "lbrynet.sqlite"))
         self.client_blob_manager = BlobManager(self.loop, self.client_dir, self.client_storage, self.client_config)
         self.client_peer_manager = PeerManager(self.loop)

tests/unit/stream/test_stream_manager.py

@@ -98,12 +98,14 @@ async def get_mock_wallet(sd_hash, storage, wallet_dir, balance=10.0, fee=None):
     wallet = Wallet()
     ledger = Ledger({
         'db': Database(os.path.join(wallet_dir, 'blockchain.db')),
-        'headers': FakeHeaders(514082)
+        'headers': FakeHeaders(514082),
+        'tx_cache_size': 10000
     })
     await ledger.db.open()
     wallet.generate_account(ledger)
     manager = WalletManager()
     manager.config = Config()
+    manager.config.transaction_cache_size = 10000
     manager.wallets.append(wallet)
     manager.ledgers[Ledger] = ledger
     manager.ledger.network.client = ClientSession(