Update tests for higher coverage

Author: MoonBoi9001

tests/test_blockchain_client.py

@@ -377,7 +377,61 @@ def test_send_signed_transaction_reverted(blockchain_client: BlockchainClient):
         blockchain_client._send_signed_transaction(mock_signed_tx)
 
 
-# 3. Orchestration Tests
+# 3. Orchestration and Edge Case Tests
+
+
+def test_execute_rpc_call_with_failover(blockchain_client: BlockchainClient):
+    """
+    Tests that _execute_rpc_call fails over to the next provider if the first one
+    is unreachable, and sends a Slack notification.
+    """
+    # 1. Setup
+    # Simulate the first provider failing, then the second succeeding.
+    # The inner retry will try 3 times, then the outer failover logic will switch provider.
+    mock_func = MagicMock()
+    mock_func.side_effect = [
+        requests.exceptions.ConnectionError("RPC down 1"),
+        requests.exceptions.ConnectionError("RPC down 2"),
+        requests.exceptions.ConnectionError("RPC down 3"),
+        "Success",
+    ]
+    blockchain_client.slack_notifier.reset_mock()  # Clear prior calls
+
+    # 2. Action
+    # The _execute_rpc_call decorator will handle the retry/failover
+    result = blockchain_client._execute_rpc_call(mock_func)
+
+    # 3. Assertions
+    assert result == "Success"
+    assert mock_func.call_count == 4
+    assert blockchain_client.current_rpc_index == 1  # Should have failed over to the 2nd provider
+
+    # Verify a slack message was sent about the failover
+    blockchain_client.slack_notifier.send_info_notification.assert_called_once()
+    call_kwargs = blockchain_client.slack_notifier.send_info_notification.call_args.kwargs
+    assert "Switching from previous RPC" in call_kwargs["message"]
+
+
+def test_determine_transaction_nonce_replace_handles_errors(blockchain_client: BlockchainClient):
+    """
+    Tests that nonce determination falls back gracefully if checking for pending
+    transactions or nonce gaps fails.
+    """
+    # 1. Setup
+    # Simulate errors when trying to get pending blocks and checking for gaps
+    w3_instance = blockchain_client.mock_w3_instance
+    w3_instance.eth.get_block.side_effect = ValueError("Cannot get pending block")
+    # After all errors, the final fallback is to get the latest transaction count.
+    w3_instance.eth.get_transaction_count.side_effect = [
+        ValueError("Cannot get pending nonce"),
+        ValueError("Cannot get latest nonce"),
+        9,  # This will be the final fallback value
+    ]
+
+    # 2. Action & Assertions
+    # The function should swallow the errors and then raise the final one
+    with pytest.raises(ValueError, match="Cannot get latest nonce"):
+        blockchain_client._determine_transaction_nonce(MOCK_SENDER_ADDRESS, replace=True)
 
 
 def test_send_transaction_to_allow_indexers_orchestration(blockchain_client: BlockchainClient):
@@ -428,6 +482,7 @@ def test_batch_processing_splits_correctly(blockchain_client: BlockchainClient):
     # Assertions
     assert len(tx_hashes) == 3
     assert blockchain_client.send_transaction_to_allow_indexers.call_count == 3
+
     # Check the contents of each call
     assert blockchain_client.send_transaction_to_allow_indexers.call_args_list[0][0][0] == addresses[0:2]
     assert blockchain_client.send_transaction_to_allow_indexers.call_args_list[1][0][0] == addresses[2:4]
@@ -440,6 +495,7 @@ def test_batch_processing_halts_on_failure(blockchain_client: BlockchainClient):
     """
     # Setup
     addresses = [f"0x{i}" * 40 for i in range(5)]
+
     # Simulate failure on the second call
     blockchain_client.send_transaction_to_allow_indexers = MagicMock(
         side_effect=["tx_hash_1", Exception("RPC Error"), "tx_hash_3"]

tests/test_configuration.py

@@ -215,6 +215,50 @@ def test_credential_manager_invalid_json(mock_env):
         CredentialManager().setup_google_credentials()
 
 
+def test_credential_manager_incomplete_service_account(mock_env):
+    """Tests that a ValueError is raised for incomplete service account JSON."""
+    # 1. Setup - Missing 'private_key'
+    creds_json = '{"type": "service_account", "client_email": "ce", "project_id": "pi"}'
+    mock_env.setenv("GOOGLE_APPLICATION_CREDENTIALS", creds_json)
+
+    # 2. Action & Assertion
+    with pytest.raises(ValueError, match="Incomplete service_account credentials"):
+        CredentialManager().setup_google_credentials()
+
+
+def test_credential_manager_unsupported_type(mock_env):
+    """Tests that a ValueError is raised for an unsupported credential type."""
+    # 1. Setup
+    creds_json = '{"type": "unsupported"}'
+    mock_env.setenv("GOOGLE_APPLICATION_CREDENTIALS", creds_json)
+
+    # 2. Action & Assertion
+    with pytest.raises(ValueError, match="Unsupported credential type"):
+        CredentialManager().setup_google_credentials()
+
+
+def test_get_default_config_path_docker(tmp_path: Path):
+    """Tests that the loader finds the config in the default /app path for Docker."""
+    # 1. Setup
+    # Simulate being in a Docker container where the /app/config.toml exists
+    docker_config_path = tmp_path / "app" / "config.toml"
+    docker_config_path.parent.mkdir()
+    docker_config_path.write_text(MOCK_TOML_CONFIG)
+
+    with patch("pathlib.Path.exists") as mock_exists:
+        # The first check is for the Docker path, so we make it return True
+        mock_exists.return_value = True
+        loader = ConfigLoader()
+        # Overwrite the loader's default path for this test
+        loader.config_path = str(docker_config_path)
+
+        # 2. Action
+        found_path = loader._get_default_config_path()
+
+        # 3. Assertions
+        assert found_path == "/app/config.toml"
+
+
 # 4. Standalone Validator Tests
 
 

tests/test_scheduler.py

@@ -244,6 +244,43 @@ def test_check_missed_runs_does_nothing_if_recent(scheduler_no_init: "Scheduler"
         scheduler.run_oracle.assert_not_called()
 
 
+def test_check_missed_runs_sends_slack_notification(scheduler_no_init: "Scheduler"):
+    """
+    Tests that a Slack notification is sent when missed runs are detected.
+    """
+    # 1. Setup
+    scheduler = scheduler_no_init
+    two_days_ago = datetime.now().date() - timedelta(days=2)
+    scheduler.get_last_run_date = MagicMock(return_value=two_days_ago)
+    scheduler.run_oracle = MagicMock()  # Mock the main run function
+    scheduler.slack_notifier.send_info_notification.reset_mock()
+
+    # 2. Action
+    scheduler.check_missed_runs()
+
+    # 3. Assertions
+    scheduler.slack_notifier.send_info_notification.assert_called_once()
+    call_kwargs = scheduler.slack_notifier.send_info_notification.call_args.kwargs
+    assert "Missed Runs Detected" in call_kwargs["title"]
+    assert "Detected 1 missed oracle runs" in call_kwargs["message"]
+
+
+def test_get_last_run_date_handles_corrupted_file(scheduler: "Scheduler", mock_dependencies: dict):
+    """
+    Tests that get_last_run_date returns None if the file contains an invalid date string.
+    """
+    # 1. Setup
+    mock_dependencies["os"].path.exists.return_value = True
+    # Simulate a file with corrupted content
+    mock_dependencies["open"].return_value.read.return_value = "not-a-date"
+
+    # 2. Action
+    last_run = scheduler.get_last_run_date()
+
+    # 3. Assertions
+    assert last_run is None
+
+
 def test_run_oracle_success(scheduler: "Scheduler", mock_dependencies: dict):
     """
     Tests that `run_oracle` calls the main oracle function and saves state upon success.