Fix tests

Cargo.lock

@@ -2872,6 +2872,7 @@ dependencies = [
  "error-chain",
  "eth2-libp2p",
  "eth2_ssz",
+ "exit-future",
  "fnv",
  "futures 0.3.5",
  "genesis",

beacon_node/eth2-libp2p/tests/common/mod.rs

@@ -86,9 +86,14 @@ pub fn build_libp2p_instance(
     let port = unused_port("tcp").unwrap();
     let config = build_config(port, boot_nodes, secret_key);
     // launch libp2p service
-    LibP2PService::new(&config, EnrForkId::default(), &log)
+    LibP2PService::new(
-        .expect("should build libp2p instance")
+        tokio::runtime::Handle::current(),
-        .1
+        &config,
+        EnrForkId::default(),
+        &log,
+    )
+    .expect("should build libp2p instance")
+    .1
 }
 
 #[allow(dead_code)]

beacon_node/eth2-libp2p/tests/noise.rs

@@ -136,9 +136,14 @@ async fn test_secio_noise_fallback() {
 
     let port = common::unused_port("tcp").unwrap();
     let noisy_config = common::build_config(port, vec![], None);
-    let mut noisy_node = Service::new(&noisy_config, EnrForkId::default(), &log)
+    let mut noisy_node = Service::new(
-        .expect("should build a libp2p instance")
+        tokio::runtime::Handle::current(),
-        .1;
+        &noisy_config,
+        EnrForkId::default(),
+        &log,
+    )
+    .expect("should build a libp2p instance")
+    .1;
 
     let port = common::unused_port("tcp").unwrap();
     let secio_config = common::build_config(port, vec![common::get_enr(&noisy_node)], None);

beacon_node/network/Cargo.toml

@@ -10,6 +10,7 @@ genesis = { path = "../genesis" }
 lazy_static = "1.4.0"
 matches = "0.1.8"
 tempfile = "3.1.0"
+exit-future = "0.2.0"
 
 [dependencies]
 beacon_chain =  { path = "../beacon_chain" }

beacon_node/network/src/service/tests.rs

@@ -32,7 +32,9 @@ mod tests {
         let enrs = vec![enr1, enr2];
 
         let runtime = Runtime::new().unwrap();
-        let handle = runtime.handle().clone();
+
+        let (signal, exit) = exit_future::signal();
+        let executor = environment::TaskExecutor::new(runtime.handle().clone(), exit, log.clone());
 
         let mut config = NetworkConfig::default();
         config.libp2p_port = 21212;
@@ -42,8 +44,9 @@ mod tests {
             // Create a new network service which implicitly gets dropped at the
             // end of the block.
 
-            let _ =
+            let _ = NetworkService::start(beacon_chain.clone(), &config, executor, log.clone())
-                NetworkService::start(beacon_chain.clone(), &config, &handle, log.clone()).unwrap();
+                .unwrap();
+            drop(signal);
         });
         runtime.shutdown_timeout(tokio::time::Duration::from_millis(300));
 

lighthouse/environment/src/lib.rs

@@ -237,6 +237,12 @@ pub struct TaskExecutor {
 }
 
 impl TaskExecutor {
+    /// Create a new task executor.
+    ///
+    /// Note: this is mainly useful in testing.
+    pub fn new(handle: Handle, exit: exit_future::Exit, log: slog::Logger) -> Self {
+        Self { handle, exit, log }
+    }
     /// Spawn a future on the tokio runtime wrapped in an exit_future `Exit`. The task is canceled
     /// when the corresponding exit_future `Signal` is fired/dropped.
     ///

validator_client/src/attestation_service.rs

@@ -540,6 +540,7 @@ impl<T: SlotClock + 'static, E: EthSpec> AttestationService<T, E> {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use futures::future::FutureExt;
     use parking_lot::RwLock;
 
     /// This test is to ensure that a `tokio_timer::Delay` with an instant in the past will still