graph: prepare graphman cli integration & clean-up tests

Author: isum

chain/ethereum/src/network.rs

@@ -2,7 +2,6 @@ use anyhow::{anyhow, bail};
 use graph::blockchain::ChainIdentifier;
 use graph::components::network_provider::ChainName;
 use graph::components::network_provider::NetworkDetails;
-use graph::components::network_provider::ProviderCheckStrategy;
 use graph::components::network_provider::ProviderManager;
 use graph::components::network_provider::ProviderName;
 use graph::endpoint::EndpointMetrics;
@@ -106,6 +105,7 @@ impl EthereumNetworkAdapters {
     ) -> Self {
         use std::cmp::Ordering;
 
+        use graph::components::network_provider::ProviderCheckStrategy;
         use graph::slog::{o, Discard, Logger};
 
         let chain_id: ChainName = "testing".into();

graph/src/components/network_provider/extended_blocks_check.rs

@@ -52,26 +52,26 @@ impl ProviderCheck for ExtendedBlocksCheck {
         match adapter.provides_extended_blocks().await {
             Ok(true) => ProviderCheckStatus::Valid,
             Ok(false) => {
-                error!(
-                    logger,
+                let message = format!(
                     "Provider '{}' does not support extended blocks on chain '{}'",
-                    provider_name,
-                    chain_name,
+                    provider_name, chain_name,
                 );
 
-                ProviderCheckStatus::Failed
+                error!(logger, "{}", message);
+
+                ProviderCheckStatus::Failed { message }
             }
             Err(err) => {
-                error!(
-                    logger,
+                let message = format!(
                     "Failed to check if provider '{}' supports extended blocks on chain '{}': {:#}",
-                    provider_name,
-                    chain_name,
-                    err,
+                    provider_name, chain_name, err,
                 );
 
+                error!(logger, "{}", message);
+
                 ProviderCheckStatus::TemporaryFailure {
                     checked_at: Instant::now(),
+                    message,
                 }
             }
         }
@@ -89,17 +89,27 @@ mod tests {
     use crate::blockchain::ChainIdentifier;
     use crate::log::discard;
 
-    macro_rules! lock {
-        ($obj:ident.$field:ident. $( $call:tt )+) => {{
-            $obj.$field.lock().unwrap(). $( $call )+
-        }};
-    }
-
     #[derive(Default)]
     struct TestAdapter {
         provides_extended_blocks_calls: Mutex<Vec<Result<bool>>>,
     }
 
+    impl TestAdapter {
+        fn provides_extended_blocks_call(&self, x: Result<bool>) {
+            self.provides_extended_blocks_calls.lock().unwrap().push(x)
+        }
+    }
+
+    impl Drop for TestAdapter {
+        fn drop(&mut self) {
+            assert!(self
+                .provides_extended_blocks_calls
+                .lock()
+                .unwrap()
+                .is_empty());
+        }
+    }
+
     #[async_trait]
     impl NetworkDetails for TestAdapter {
         fn provider_name(&self) -> ProviderName {
@@ -111,13 +121,10 @@ mod tests {
         }
 
         async fn provides_extended_blocks(&self) -> Result<bool> {
-            lock!(self.provides_extended_blocks_calls.remove(0))
-        }
-    }
-
-    impl Drop for TestAdapter {
-        fn drop(&mut self) {
-            assert!(lock!(self.provides_extended_blocks_calls.is_empty()));
+            self.provides_extended_blocks_calls
+                .lock()
+                .unwrap()
+                .remove(0)
         }
     }
 
@@ -171,7 +178,7 @@ mod tests {
         let check = ExtendedBlocksCheck::new([]);
 
         let adapter = TestAdapter::default();
-        lock! { adapter.provides_extended_blocks_calls.push(Ok(true)) };
+        adapter.provides_extended_blocks_call(Ok(true));
 
         let status = check
             .check(
@@ -190,7 +197,7 @@ mod tests {
         let check = ExtendedBlocksCheck::new([]);
 
         let adapter = TestAdapter::default();
-        lock! { adapter.provides_extended_blocks_calls.push(Ok(false)) };
+        adapter.provides_extended_blocks_call(Ok(false));
 
         let status = check
             .check(
@@ -201,15 +208,15 @@ mod tests {
             )
             .await;
 
-        assert_eq!(status, ProviderCheckStatus::Failed);
+        assert!(matches!(status, ProviderCheckStatus::Failed { .. }));
     }
 
     #[tokio::test]
     async fn check_temporary_failure_when_provider_request_fails() {
         let check = ExtendedBlocksCheck::new([]);
 
         let adapter = TestAdapter::default();
-        lock! { adapter.provides_extended_blocks_calls.push(Err(anyhow!("error"))) };
+        adapter.provides_extended_blocks_call(Err(anyhow!("error")));
 
         let status = check
             .check(