Apply changes proposed by Moises

safe_transaction_service/history/services/index_service.py

@@ -399,7 +399,7 @@ def fix_out_of_order(
         SafeLastStatus.objects.filter(address=address).delete()
         logger.info("[%s] Ended fixing out of order", address)
 
-    def process_address(self, safe_address: ChecksumAddress) -> int:
+    def process_decoded_txs(self, safe_address: ChecksumAddress) -> int:
         """
         Process all the pending `InternalTxDecoded` for a Safe
 
@@ -417,19 +417,19 @@ def process_address(self, safe_address: ChecksumAddress) -> int:
             self.tx_processor.clear_cache(safe_address)
 
         # Use chunks for memory issues
-        number_processed = 0
+        total_processed_txs = 0
         while True:
             internal_txs_decoded_queryset = InternalTxDecoded.objects.pending_for_safe(
                 safe_address
             )[: self.eth_internal_tx_decoded_process_batch]
             if not internal_txs_decoded_queryset:
                 break
-            number_processed += len(
+            total_processed_txs += len(
                 self.tx_processor.process_decoded_transactions(
                     internal_txs_decoded_queryset
                 )
             )
-        return number_processed
+        return total_processed_txs
 
     def reprocess_addresses(self, addresses: List[ChecksumAddress]):
         """

safe_transaction_service/history/tasks.py

@@ -285,7 +285,7 @@ def process_decoded_internal_txs_for_safe_task(
         with only_one_running_task(self, lock_name_suffix=safe_address):
             logger.info("[%s] Start processing decoded internal txs", safe_address)
             index_service: IndexService = IndexServiceProvider()
-            number_processed = index_service.process_address(safe_address)
+            number_processed = index_service.process_decoded_txs(safe_address)
             logger.info(
                 "[%s] Processed %d decoded transactions", safe_address, number_processed
             )

safe_transaction_service/history/tests/test_index_service.py

@@ -126,28 +126,28 @@ def test_is_service_synced(self, current_block_number_mock: PropertyMock):
         current_block_number_mock.side_effect = RequestsConnectionError
         self.assertFalse(self.index_service.is_service_synced())
 
-    def test_process_address(self):
+    def test_process_decoded_txs(self):
         safe_address = Account.create().address
         with mock.patch.object(
             IndexService, "fix_out_of_order"
         ) as fix_out_of_order_mock:
-            self.assertEqual(self.index_service.process_address(safe_address), 0)
+            self.assertEqual(self.index_service.process_decoded_txs(safe_address), 0)
             fix_out_of_order_mock.assert_not_called()
 
             # Setup for a random Safe should not be processed
             InternalTxDecodedFactory(
                 function_name="setup",
             )
-            self.assertEqual(self.index_service.process_address(safe_address), 0)
+            self.assertEqual(self.index_service.process_decoded_txs(safe_address), 0)
 
             setup_internal_tx = InternalTxDecodedFactory(
                 function_name="setup",
                 internal_tx___from=safe_address,
             )
-            self.assertEqual(self.index_service.process_address(safe_address), 1)
+            self.assertEqual(self.index_service.process_decoded_txs(safe_address), 1)
             fix_out_of_order_mock.assert_not_called()
             # After processed, it should not be processed again
-            self.assertEqual(self.index_service.process_address(safe_address), 0)
+            self.assertEqual(self.index_service.process_decoded_txs(safe_address), 0)
 
             exec_transactions = [
                 InternalTxDecodedFactory(
@@ -157,15 +157,15 @@ def test_process_address(self):
                 for _ in range(3)
             ]
 
-            self.assertEqual(self.index_service.process_address(safe_address), 3)
+            self.assertEqual(self.index_service.process_decoded_txs(safe_address), 3)
             fix_out_of_order_mock.assert_not_called()
             # After processed, they should not be processed again
-            self.assertEqual(self.index_service.process_address(safe_address), 0)
+            self.assertEqual(self.index_service.process_decoded_txs(safe_address), 0)
 
             # Add a transaction out of order
             exec_transactions[1].processed = False
             exec_transactions[1].save(update_fields=["processed"])
-            self.assertEqual(self.index_service.process_address(safe_address), 1)
+            self.assertEqual(self.index_service.process_decoded_txs(safe_address), 1)
             # Out of order transaction was detected
             fix_out_of_order_mock.assert_called_with(
                 safe_address, exec_transactions[1].internal_tx

safe_transaction_service/history/tests/test_tasks.py

@@ -194,10 +194,10 @@ def test_process_decoded_internal_txs_for_safe_task(self):
         SafeLastStatus.objects.update_or_create_from_safe_status(safe_status_0)
         with self.assertLogs(logger=task_logger) as cm:
             with patch.object(
-                IndexService, "process_address", return_value=5
-            ) as process_address_mock:
+                IndexService, "process_decoded_txs", return_value=5
+            ) as process_decoded_txs_mock:
                 process_decoded_internal_txs_for_safe_task.delay(safe_address)
-                process_address_mock.assert_called_with(safe_address)
+                process_decoded_txs_mock.assert_called_with(safe_address)
                 self.assertIn(
                     f"[{safe_address}] Start processing decoded internal txs",
                     cm.output[0],