diff --git a/justfile b/justfile
index 4a9e198004..4a0b379d15 100644
--- a/justfile
+++ b/justfile
@@ -20,7 +20,7 @@ test_tokio:
 
 test_async_std_all:
   echo Testing with async std executor
-  RUST_LOG="error" cargo test  --features=full-ci --lib --bins --tests --benches --workspace --no-fail-fast test_basic -- --test-threads=1 --nocapture
+  cargo test  --features=full-ci --lib --bins --tests --benches --workspace --no-fail-fast -- --test-threads=1
 
 _test_basic:
   echo Testing with async std executor
diff --git a/src/traits.rs b/src/traits.rs
index 3838e16c5b..6d5551956f 100644
--- a/src/traits.rs
+++ b/src/traits.rs
@@ -16,7 +16,7 @@ pub mod implementations {
             libp2p_network::{Libp2pCommChannel, Libp2pNetwork, PeerInfoVec},
             memory_network::{DummyReliability, MasterMap, MemoryCommChannel, MemoryNetwork},
             web_server_network::{WebCommChannel, WebServerNetwork},
-            web_sever_libp2p_fallback::WebServerWithFallbackCommChannel,
+            web_sever_libp2p_fallback::{CombinedNetworks, WebServerWithFallbackCommChannel},
         },
         storage::memory_storage::MemoryStorage, // atomic_storage::AtomicStorage,
     };
diff --git a/src/traits/networking/web_sever_libp2p_fallback.rs b/src/traits/networking/web_sever_libp2p_fallback.rs
index 304dc2619f..d6a88b99ff 100644
--- a/src/traits/networking/web_sever_libp2p_fallback.rs
+++ b/src/traits/networking/web_sever_libp2p_fallback.rs
@@ -67,15 +67,15 @@ impl<TYPES: NodeType, I: NodeImplementation<TYPES>, MEMBERSHIP: Membership<TYPES
 /// Wrapper for the tuple of `WebServerNetwork` and `Libp2pNetwork`
 /// We need this so we can impl `TestableNetworkingImplementation`
 /// on the tuple
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct CombinedNetworks<
     TYPES: NodeType,
     I: NodeImplementation<TYPES>,
     MEMBERSHIP: Membership<TYPES>,
 >(
-    WebServerNetwork<Message<TYPES, I>, TYPES::SignatureKey, TYPES::ElectionConfigType, TYPES>,
-    Libp2pNetwork<Message<TYPES, I>, TYPES::SignatureKey>,
-    PhantomData<MEMBERSHIP>,
+    pub WebServerNetwork<Message<TYPES, I>, TYPES::SignatureKey, TYPES::ElectionConfigType, TYPES>,
+    pub Libp2pNetwork<Message<TYPES, I>, TYPES::SignatureKey>,
+    pub PhantomData<MEMBERSHIP>,
 );
 
 impl<TYPES: NodeType, I: NodeImplementation<TYPES>, MEMBERSHIP: Membership<TYPES>>
diff --git a/testing/src/node_types.rs b/testing/src/node_types.rs
index 8a79812f1e..4c88dc58d6 100644
--- a/testing/src/node_types.rs
+++ b/testing/src/node_types.rs
@@ -1,3 +1,5 @@
+use hotshot::traits::implementations::CombinedNetworks;
+use std::marker::PhantomData;
 use std::sync::Arc;
 
 use hotshot::{
@@ -8,8 +10,8 @@ use hotshot::{
             vrf::JfPubKey,
         },
         implementations::{
-            Libp2pCommChannel, MemoryCommChannel, MemoryNetwork, MemoryStorage, WebCommChannel,
-            WebServerWithFallbackCommChannel,
+            Libp2pCommChannel, Libp2pNetwork, MemoryCommChannel, MemoryNetwork, MemoryStorage,
+            WebCommChannel, WebServerNetwork, WebServerWithFallbackCommChannel,
         },
         NodeImplementation,
     },
@@ -149,34 +151,36 @@ type StaticWebViewSyncComm = WebCommChannel<
     StaticMembership,
 >;
 
+pub type SequencingLibp2pExchange = SequencingExchanges<
+    SequencingTestTypes,
+    Message<SequencingTestTypes, SequencingLibp2pImpl>,
+    QuorumExchange<
+        SequencingTestTypes,
+        <SequencingLibp2pImpl as NodeImplementation<SequencingTestTypes>>::Leaf,
+        QuorumProposal<SequencingTestTypes, SequencingLeaf<SequencingTestTypes>>,
+        StaticMembership,
+        StaticLibp2pQuorumComm,
+        Message<SequencingTestTypes, SequencingLibp2pImpl>,
+    >,
+    CommitteeExchange<
+        SequencingTestTypes,
+        StaticMembership,
+        StaticLibp2pDAComm,
+        Message<SequencingTestTypes, SequencingLibp2pImpl>,
+    >,
+    ViewSyncExchange<
+        SequencingTestTypes,
+        ViewSyncCertificate<SequencingTestTypes>,
+        StaticMembership,
+        StaticLibp2pViewSyncComm,
+        Message<SequencingTestTypes, SequencingLibp2pImpl>,
+    >,
+>;
+
 impl NodeImplementation<SequencingTestTypes> for SequencingLibp2pImpl {
     type Storage = MemoryStorage<SequencingTestTypes, SequencingLeaf<SequencingTestTypes>>;
     type Leaf = SequencingLeaf<SequencingTestTypes>;
-    type Exchanges = SequencingExchanges<
-        SequencingTestTypes,
-        Message<SequencingTestTypes, Self>,
-        QuorumExchange<
-            SequencingTestTypes,
-            Self::Leaf,
-            QuorumProposal<SequencingTestTypes, SequencingLeaf<SequencingTestTypes>>,
-            StaticMembership,
-            StaticLibp2pQuorumComm,
-            Message<SequencingTestTypes, Self>,
-        >,
-        CommitteeExchange<
-            SequencingTestTypes,
-            StaticMembership,
-            StaticLibp2pDAComm,
-            Message<SequencingTestTypes, Self>,
-        >,
-        ViewSyncExchange<
-            SequencingTestTypes,
-            ViewSyncCertificate<SequencingTestTypes>,
-            StaticMembership,
-            StaticLibp2pViewSyncComm,
-            Message<SequencingTestTypes, Self>,
-        >,
-    >;
+    type Exchanges = SequencingLibp2pExchange;
     type ConsensusMessage = SequencingMessage<SequencingTestTypes, Self>;
 
     fn new_channel_maps(
@@ -192,6 +196,60 @@ impl NodeImplementation<SequencingTestTypes> for SequencingLibp2pImpl {
     }
 }
 
+impl
+    TestableExchange<
+        SequencingTestTypes,
+        <SequencingLibp2pImpl as NodeImplementation<SequencingTestTypes>>::Leaf,
+        Message<SequencingTestTypes, SequencingLibp2pImpl>,
+    > for SequencingLibp2pExchange
+{
+    fn gen_comm_channels(
+        expected_node_count: usize,
+        num_bootstrap: usize,
+        da_committee_size: usize,
+    ) -> Box<
+        dyn Fn(
+                u64,
+            ) -> (
+                <Self::QuorumExchange as hotshot_types::traits::election::ConsensusExchange<
+                    SequencingTestTypes,
+                    Message<SequencingTestTypes, SequencingLibp2pImpl>,
+                >>::Networking,
+                <Self::CommitteeExchange as hotshot_types::traits::election::ConsensusExchange<
+                    SequencingTestTypes,
+                    Message<SequencingTestTypes, SequencingLibp2pImpl>,
+                >>::Networking,
+                <Self::ViewSyncExchange as hotshot_types::traits::election::ConsensusExchange<
+                    SequencingTestTypes,
+                    Message<SequencingTestTypes, SequencingLibp2pImpl>,
+                >>::Networking,
+            ) + 'static,
+    > {
+        let network_generator = Arc::new(<Libp2pNetwork<
+            Message<SequencingTestTypes, SequencingLibp2pImpl>,
+            <SequencingTestTypes as NodeType>::SignatureKey,
+        > as TestableNetworkingImplementation<
+            SequencingTestTypes,
+            Message<SequencingTestTypes, SequencingLibp2pImpl>,
+        >>::generator(
+            expected_node_count,
+            num_bootstrap,
+            0,
+            da_committee_size,
+            false,
+        ));
+
+        Box::new(move |id| {
+            let network = Arc::new(network_generator(id));
+            let quorum_chan = <<Self::QuorumExchange as hotshot_types::traits::election::ConsensusExchange<SequencingTestTypes, Message<SequencingTestTypes, SequencingLibp2pImpl>>>::Networking as TestableChannelImplementation<_, _, _, _, _, _>>::generate_network()(network.clone());
+            let committee_chan = <<Self::CommitteeExchange as hotshot_types::traits::election::ConsensusExchange<SequencingTestTypes, Message<SequencingTestTypes, SequencingLibp2pImpl>>>::Networking as TestableChannelImplementation<_, _, _, _, _, _>>::generate_network()(network.clone());
+            let view_sync_chan = <<Self::ViewSyncExchange as hotshot_types::traits::election::ConsensusExchange<SequencingTestTypes, Message<SequencingTestTypes, SequencingLibp2pImpl>>>::Networking as TestableChannelImplementation<_, _, _, _, _, _>>::generate_network()(network);
+
+            (quorum_chan, committee_chan, view_sync_chan)
+        })
+    }
+}
+
 pub type SequencingMemoryExchange = SequencingExchanges<
     SequencingTestTypes,
     Message<SequencingTestTypes, SequencingMemoryImpl>,
@@ -309,34 +367,107 @@ impl NodeImplementation<SequencingTestTypes> for SequencingMemoryImpl {
 // when are we getting HKT for rust
 // smh my head
 
-impl NodeImplementation<SequencingTestTypes> for SequencingWebImpl {
-    type Storage = MemoryStorage<SequencingTestTypes, SequencingLeaf<SequencingTestTypes>>;
-    type Leaf = SequencingLeaf<SequencingTestTypes>;
-    type Exchanges = SequencingExchanges<
+pub type SequencingWebExchanges = SequencingExchanges<
+    SequencingTestTypes,
+    Message<SequencingTestTypes, SequencingWebImpl>,
+    QuorumExchange<
+        SequencingTestTypes,
+        <SequencingWebImpl as NodeImplementation<SequencingTestTypes>>::Leaf,
+        QuorumProposal<SequencingTestTypes, SequencingLeaf<SequencingTestTypes>>,
+        StaticMembership,
+        StaticWebQuorumComm,
+        Message<SequencingTestTypes, SequencingWebImpl>,
+    >,
+    CommitteeExchange<
+        SequencingTestTypes,
+        StaticMembership,
+        StaticWebDAComm,
+        Message<SequencingTestTypes, SequencingWebImpl>,
+    >,
+    ViewSyncExchange<
         SequencingTestTypes,
-        Message<SequencingTestTypes, Self>,
-        QuorumExchange<
+        ViewSyncCertificate<SequencingTestTypes>,
+        StaticMembership,
+        StaticWebViewSyncComm,
+        Message<SequencingTestTypes, SequencingWebImpl>,
+    >,
+>;
+
+impl
+    TestableExchange<
+        SequencingTestTypes,
+        <SequencingWebImpl as NodeImplementation<SequencingTestTypes>>::Leaf,
+        Message<SequencingTestTypes, SequencingWebImpl>,
+    > for SequencingWebExchanges
+{
+    fn gen_comm_channels(
+        expected_node_count: usize,
+        num_bootstrap: usize,
+        da_committee_size: usize,
+    ) -> Box<
+        dyn Fn(
+                u64,
+            ) -> (
+                <Self::QuorumExchange as hotshot_types::traits::election::ConsensusExchange<
+                    SequencingTestTypes,
+                    Message<SequencingTestTypes, SequencingWebImpl>,
+                >>::Networking,
+                <Self::CommitteeExchange as hotshot_types::traits::election::ConsensusExchange<
+                    SequencingTestTypes,
+                    Message<SequencingTestTypes, SequencingWebImpl>,
+                >>::Networking,
+                <Self::ViewSyncExchange as hotshot_types::traits::election::ConsensusExchange<
+                    SequencingTestTypes,
+                    Message<SequencingTestTypes, SequencingWebImpl>,
+                >>::Networking,
+            ) + 'static,
+    > {
+        let network_generator = Arc::new(<WebServerNetwork<
+            Message<SequencingTestTypes, SequencingWebImpl>,
+            <SequencingTestTypes as NodeType>::SignatureKey,
+            _,
+            _,
+        > as TestableNetworkingImplementation<
             SequencingTestTypes,
-            Self::Leaf,
-            QuorumProposal<SequencingTestTypes, SequencingLeaf<SequencingTestTypes>>,
-            StaticMembership,
-            StaticWebQuorumComm,
-            Message<SequencingTestTypes, Self>,
-        >,
-        CommitteeExchange<
+            Message<SequencingTestTypes, SequencingWebImpl>,
+        >>::generator(
+            expected_node_count,
+            num_bootstrap,
+            0,
+            da_committee_size,
+            false,
+        ));
+        let network_da_generator = Arc::new(<WebServerNetwork<
+            Message<SequencingTestTypes, SequencingWebImpl>,
+            <SequencingTestTypes as NodeType>::SignatureKey,
+            <SequencingTestTypes as NodeType>::ElectionConfigType,
             SequencingTestTypes,
-            StaticMembership,
-            StaticWebDAComm,
-            Message<SequencingTestTypes, Self>,
-        >,
-        ViewSyncExchange<
+        > as TestableNetworkingImplementation<
             SequencingTestTypes,
-            ViewSyncCertificate<SequencingTestTypes>,
-            StaticMembership,
-            StaticWebViewSyncComm,
-            Message<SequencingTestTypes, Self>,
-        >,
-    >;
+            Message<SequencingTestTypes, SequencingWebImpl>,
+        >>::generator(
+            expected_node_count,
+            num_bootstrap,
+            1,
+            da_committee_size,
+            true,
+        ));
+        Box::new(move |id| {
+            let network = Arc::new(network_generator(id));
+            let network_da = Arc::new(network_da_generator(id));
+            let quorum_chan = <<Self::QuorumExchange as hotshot_types::traits::election::ConsensusExchange<SequencingTestTypes, Message<SequencingTestTypes, SequencingWebImpl>>>::Networking as TestableChannelImplementation<_, _, _, _, _, _>>::generate_network()(network.clone());
+            let committee_chan = <<Self::CommitteeExchange as hotshot_types::traits::election::ConsensusExchange<SequencingTestTypes, Message<SequencingTestTypes, SequencingWebImpl>>>::Networking as TestableChannelImplementation<_, _, _, _, _, _>>::generate_network()(network_da);
+            let view_sync_chan = <<Self::ViewSyncExchange as hotshot_types::traits::election::ConsensusExchange<SequencingTestTypes, Message<SequencingTestTypes, SequencingWebImpl>>>::Networking as TestableChannelImplementation<_, _, _, _, _, _>>::generate_network()(network);
+
+            (quorum_chan, committee_chan, view_sync_chan)
+        })
+    }
+}
+
+impl NodeImplementation<SequencingTestTypes> for SequencingWebImpl {
+    type Storage = MemoryStorage<SequencingTestTypes, SequencingLeaf<SequencingTestTypes>>;
+    type Leaf = SequencingLeaf<SequencingTestTypes>;
+    type Exchanges = SequencingWebExchanges;
     type ConsensusMessage = SequencingMessage<SequencingTestTypes, Self>;
 
     fn new_channel_maps(
@@ -352,34 +483,165 @@ impl NodeImplementation<SequencingTestTypes> for SequencingWebImpl {
     }
 }
 
-impl NodeImplementation<SequencingTestTypes> for StaticFallbackImpl {
-    type Storage = MemoryStorage<SequencingTestTypes, SequencingLeaf<SequencingTestTypes>>;
-    type Leaf = SequencingLeaf<SequencingTestTypes>;
-    type Exchanges = SequencingExchanges<
+pub type SequencingFallbackExchange = SequencingExchanges<
+    SequencingTestTypes,
+    Message<SequencingTestTypes, StaticFallbackImpl>,
+    QuorumExchange<
+        SequencingTestTypes,
+        <StaticFallbackImpl as NodeImplementation<SequencingTestTypes>>::Leaf,
+        QuorumProposal<SequencingTestTypes, SequencingLeaf<SequencingTestTypes>>,
+        StaticMembership,
+        StaticFallbackComm,
+        Message<SequencingTestTypes, StaticFallbackImpl>,
+    >,
+    CommitteeExchange<
         SequencingTestTypes,
-        Message<SequencingTestTypes, Self>,
-        QuorumExchange<
+        StaticMembership,
+        StaticFallbackComm,
+        Message<SequencingTestTypes, StaticFallbackImpl>,
+    >,
+    ViewSyncExchange<
+        SequencingTestTypes,
+        ViewSyncCertificate<SequencingTestTypes>,
+        StaticMembership,
+        StaticFallbackComm,
+        Message<SequencingTestTypes, StaticFallbackImpl>,
+    >,
+>;
+
+impl
+    TestableExchange<
+        SequencingTestTypes,
+        <StaticFallbackImpl as NodeImplementation<SequencingTestTypes>>::Leaf,
+        Message<SequencingTestTypes, StaticFallbackImpl>,
+    > for SequencingFallbackExchange
+{
+    fn gen_comm_channels(
+        expected_node_count: usize,
+        num_bootstrap: usize,
+        da_committee_size: usize,
+    ) -> Box<
+        dyn Fn(
+                u64,
+            ) -> (
+                <Self::QuorumExchange as hotshot_types::traits::election::ConsensusExchange<
+                    SequencingTestTypes,
+                    Message<SequencingTestTypes, StaticFallbackImpl>,
+                >>::Networking,
+                <Self::CommitteeExchange as hotshot_types::traits::election::ConsensusExchange<
+                    SequencingTestTypes,
+                    Message<SequencingTestTypes, StaticFallbackImpl>,
+                >>::Networking,
+                <Self::ViewSyncExchange as hotshot_types::traits::election::ConsensusExchange<
+                    SequencingTestTypes,
+                    Message<SequencingTestTypes, StaticFallbackImpl>,
+                >>::Networking,
+            ) + 'static,
+    > {
+        let libp2p_generator = Arc::new(<Libp2pNetwork<
+            Message<SequencingTestTypes, StaticFallbackImpl>,
+            <SequencingTestTypes as NodeType>::SignatureKey,
+        > as TestableNetworkingImplementation<
             SequencingTestTypes,
-            Self::Leaf,
-            QuorumProposal<SequencingTestTypes, SequencingLeaf<SequencingTestTypes>>,
-            StaticMembership,
-            StaticFallbackComm,
-            Message<SequencingTestTypes, Self>,
-        >,
-        CommitteeExchange<
+            Message<SequencingTestTypes, StaticFallbackImpl>,
+        >>::generator(
+            expected_node_count,
+            num_bootstrap,
+            0,
+            da_committee_size,
+            true,
+        ));
+        let ws_generator = Arc::new(<WebServerNetwork<
+            Message<SequencingTestTypes, StaticFallbackImpl>,
+            <SequencingTestTypes as NodeType>::SignatureKey,
+            _,
+            _,
+        > as TestableNetworkingImplementation<
+            SequencingTestTypes,
+            Message<SequencingTestTypes, StaticFallbackImpl>,
+        >>::generator(
+            expected_node_count,
+            num_bootstrap,
+            1,
+            da_committee_size,
+            false,
+        ));
+        let ws_da_generator = Arc::new(<WebServerNetwork<
+            Message<SequencingTestTypes, StaticFallbackImpl>,
+            <SequencingTestTypes as NodeType>::SignatureKey,
+            <SequencingTestTypes as NodeType>::ElectionConfigType,
             SequencingTestTypes,
-            StaticMembership,
-            StaticFallbackComm,
-            Message<SequencingTestTypes, Self>,
-        >,
-        ViewSyncExchange<
+        > as TestableNetworkingImplementation<
             SequencingTestTypes,
-            ViewSyncCertificate<SequencingTestTypes>,
-            StaticMembership,
-            StaticFallbackComm,
-            Message<SequencingTestTypes, Self>,
-        >,
-    >;
+            Message<SequencingTestTypes, StaticFallbackImpl>,
+        >>::generator(
+            expected_node_count,
+            num_bootstrap,
+            2,
+            da_committee_size,
+            true,
+        ));
+
+        Box::new(move |id| {
+            let libp2p_network = libp2p_generator(id);
+            let ws = ws_generator(id);
+            let ws_da = ws_da_generator(id);
+
+            // TODO make a proper constructor
+            let network = Arc::new(CombinedNetworks(ws, libp2p_network.clone(), PhantomData));
+            let network_da = Arc::new(CombinedNetworks(ws_da, libp2p_network, PhantomData));
+
+            let quorum_chan =
+                <<Self::QuorumExchange as hotshot_types::traits::election::ConsensusExchange<
+                    SequencingTestTypes,
+                    Message<SequencingTestTypes, StaticFallbackImpl>,
+                >>::Networking as TestableChannelImplementation<
+                    _,
+                    _,
+                    QuorumProposal<
+                        SequencingTestTypes,
+                        <StaticFallbackImpl as NodeImplementation<SequencingTestTypes>>::Leaf,
+                    >,
+                    QuorumVote<
+                        SequencingTestTypes,
+                        <StaticFallbackImpl as NodeImplementation<SequencingTestTypes>>::Leaf,
+                    >,
+                    _,
+                    _,
+                >>::generate_network()(network.clone());
+            let committee_chan =
+                <<Self::CommitteeExchange as hotshot_types::traits::election::ConsensusExchange<
+                    SequencingTestTypes,
+                    Message<SequencingTestTypes, StaticFallbackImpl>,
+                >>::Networking as TestableChannelImplementation<
+                    _,
+                    _,
+                    DAProposal<SequencingTestTypes>,
+                    DAVote<SequencingTestTypes>,
+                    _,
+                    _,
+                >>::generate_network()(network_da);
+            let view_sync_chan =
+                <<Self::ViewSyncExchange as hotshot_types::traits::election::ConsensusExchange<
+                    SequencingTestTypes,
+                    Message<SequencingTestTypes, StaticFallbackImpl>,
+                >>::Networking as TestableChannelImplementation<
+                    _,
+                    _,
+                    ViewSyncCertificate<SequencingTestTypes>,
+                    ViewSyncVote<SequencingTestTypes>,
+                    _,
+                    _,
+                >>::generate_network()(network);
+            (quorum_chan, committee_chan, view_sync_chan)
+        })
+    }
+}
+
+impl NodeImplementation<SequencingTestTypes> for StaticFallbackImpl {
+    type Storage = MemoryStorage<SequencingTestTypes, SequencingLeaf<SequencingTestTypes>>;
+    type Leaf = SequencingLeaf<SequencingTestTypes>;
+    type Exchanges = SequencingFallbackExchange;
     type ConsensusMessage = SequencingMessage<SequencingTestTypes, Self>;
 
     fn new_channel_maps(
diff --git a/testing/tests/fallback_network.rs b/testing/tests/fallback_network.rs
index 81404bfd60..105f71cf9b 100644
--- a/testing/tests/fallback_network.rs
+++ b/testing/tests/fallback_network.rs
@@ -1,42 +1,42 @@
-// use hotshot_testing::{
-//     node_types::{SequencingLibp2pImpl, SequencingTestTypes},
-//     test_builder::TestMetadata,
-// };
-// use tracing::instrument;
-//
-// /// web server with libp2p network test
-// #[cfg_attr(
-//     feature = "tokio-executor",
-//     tokio::test(flavor = "multi_thread", worker_threads = 2)
-// )]
-// #[cfg_attr(feature = "async-std-executor", async_std::test)]
-// #[instrument]
-// async fn webserver_libp2p_network() {
-//     async_compatibility_layer::logging::setup_logging();
-//     async_compatibility_layer::logging::setup_backtrace();
-//     let metadata = TestMetadata::default_multiple_rounds();
-//     metadata
-//         .gen_launcher::<SequencingTestTypes, SequencingLibp2pImpl>()
-//         .launch()
-//         .run_test()
-//         .await
-// }
-//
-// // stress test for web server with libp2p
-// #[cfg_attr(
-//     feature = "tokio-executor",
-//     tokio::test(flavor = "multi_thread", worker_threads = 2)
-// )]
-// #[cfg_attr(feature = "async-std-executor", async_std::test)]
-// #[instrument]
-// #[ignore]
-// async fn test_stress_webserver_libp2p_network() {
-//     async_compatibility_layer::logging::setup_logging();
-//     async_compatibility_layer::logging::setup_backtrace();
-//     let metadata = TestMetadata::default_stress();
-//     metadata
-//         .gen_launcher::<SequencingTestTypes, SequencingLibp2pImpl>()
-//         .launch()
-//         .run_test()
-//         .await
-// }
+use hotshot_testing::{
+    node_types::{SequencingLibp2pImpl, SequencingTestTypes},
+    test_builder::TestMetadata,
+};
+use tracing::instrument;
+
+/// web server with libp2p network test
+#[cfg_attr(
+    feature = "tokio-executor",
+    tokio::test(flavor = "multi_thread", worker_threads = 2)
+)]
+#[cfg_attr(feature = "async-std-executor", async_std::test)]
+#[instrument]
+async fn webserver_libp2p_network() {
+    async_compatibility_layer::logging::setup_logging();
+    async_compatibility_layer::logging::setup_backtrace();
+    let metadata = TestMetadata::default_multiple_rounds();
+    metadata
+        .gen_launcher::<SequencingTestTypes, SequencingLibp2pImpl>()
+        .launch()
+        .run_test()
+        .await
+}
+
+// stress test for web server with libp2p
+#[cfg_attr(
+    feature = "tokio-executor",
+    tokio::test(flavor = "multi_thread", worker_threads = 2)
+)]
+#[cfg_attr(feature = "async-std-executor", async_std::test)]
+#[instrument]
+#[ignore]
+async fn test_stress_webserver_libp2p_network() {
+    async_compatibility_layer::logging::setup_logging();
+    async_compatibility_layer::logging::setup_backtrace();
+    let metadata = TestMetadata::default_stress();
+    metadata
+        .gen_launcher::<SequencingTestTypes, SequencingLibp2pImpl>()
+        .launch()
+        .run_test()
+        .await
+}
diff --git a/testing/tests/libp2p.rs b/testing/tests/libp2p.rs
index cb392f5307..e3afe4b8e4 100644
--- a/testing/tests/libp2p.rs
+++ b/testing/tests/libp2p.rs
@@ -1,43 +1,43 @@
-// use hotshot_testing::{
-//     node_types::{SequencingLibp2pImpl, SequencingTestTypes},
-//     test_builder::TestMetadata,
-// };
-// use tracing::instrument;
-//
-// /// libp2p network test
-// #[cfg_attr(
-//     feature = "tokio-executor",
-//     tokio::test(flavor = "multi_thread", worker_threads = 2)
-// )]
-// #[cfg_attr(feature = "async-std-executor", async_std::test)]
-// #[instrument]
-// async fn libp2p_network() {
-//     async_compatibility_layer::logging::setup_logging();
-//     async_compatibility_layer::logging::setup_backtrace();
-//     let metadata = TestMetadata::default_multiple_rounds();
-//
-//     metadata
-//         .gen_launcher::<SequencingTestTypes, SequencingLibp2pImpl>()
-//         .launch()
-//         .run_test()
-//         .await
-// }
-//
-// /// stress test for libp2p
-// #[cfg_attr(
-//     feature = "tokio-executor",
-//     tokio::test(flavor = "multi_thread", worker_threads = 2)
-// )]
-// #[cfg_attr(feature = "async-std-executor", async_std::test)]
-// #[instrument]
-// #[ignore]
-// async fn test_stress_libp2p_network() {
-//     async_compatibility_layer::logging::setup_logging();
-//     async_compatibility_layer::logging::setup_backtrace();
-//     let metadata = TestMetadata::default_stress();
-//     metadata
-//         .gen_launcher::<SequencingTestTypes, SequencingLibp2pImpl>()
-//         .launch()
-//         .run_test()
-//         .await
-// }
+use hotshot_testing::{
+    node_types::{SequencingLibp2pImpl, SequencingTestTypes},
+    test_builder::TestMetadata,
+};
+use tracing::instrument;
+
+/// libp2p network test
+#[cfg_attr(
+    feature = "tokio-executor",
+    tokio::test(flavor = "multi_thread", worker_threads = 2)
+)]
+#[cfg_attr(feature = "async-std-executor", async_std::test)]
+#[instrument]
+async fn libp2p_network() {
+    async_compatibility_layer::logging::setup_logging();
+    async_compatibility_layer::logging::setup_backtrace();
+    let metadata = TestMetadata::default_multiple_rounds();
+
+    metadata
+        .gen_launcher::<SequencingTestTypes, SequencingLibp2pImpl>()
+        .launch()
+        .run_test()
+        .await
+}
+
+/// stress test for libp2p
+#[cfg_attr(
+    feature = "tokio-executor",
+    tokio::test(flavor = "multi_thread", worker_threads = 2)
+)]
+#[cfg_attr(feature = "async-std-executor", async_std::test)]
+#[instrument]
+#[ignore]
+async fn test_stress_libp2p_network() {
+    async_compatibility_layer::logging::setup_logging();
+    async_compatibility_layer::logging::setup_backtrace();
+    let metadata = TestMetadata::default_stress();
+    metadata
+        .gen_launcher::<SequencingTestTypes, SequencingLibp2pImpl>()
+        .launch()
+        .run_test()
+        .await
+}
diff --git a/testing/tests/web_server.rs b/testing/tests/web_server.rs
index c87c2134ab..e5205baad1 100644
--- a/testing/tests/web_server.rs
+++ b/testing/tests/web_server.rs
@@ -1,40 +1,39 @@
-// use async_compatibility_layer::logging::shutdown_logging;
-// use hotshot_testing::{
-//     node_types::{SequencingTestTypes, SequencingWebImpl},
-//     overall_safety_task::OverallSafetyPropertiesDescription,
-//     test_builder::{TestMetadata, TimingData},
-// };
-// use tracing::instrument;
-//
-// /// Web server network test
-// #[cfg_attr(
-//     feature = "tokio-executor",
-//     tokio::test(flavor = "multi_thread", worker_threads = 2)
-// )]
-// #[cfg_attr(feature = "async-std-executor", async_std::test)]
-// #[instrument]
-// async fn web_server_network() {
-//     async_compatibility_layer::logging::setup_logging();
-//     async_compatibility_layer::logging::setup_backtrace();
-//     let metadata = TestMetadata {
-//         timing_data: TimingData {
-//             round_start_delay: 25,
-//             next_view_timeout: 3000,
-//             start_delay: 120000,
-//
-//             ..Default::default()
-//         },
-//         overall_safety_properties: OverallSafetyPropertiesDescription {
-//             num_successful_views: 35,
-//             ..Default::default()
-//         },
-//         ..TestMetadata::default()
-//     };
-//     // TODO web server network doesn't implement TestableNetworkingImplementation
-//     metadata
-//         .gen_launcher::<SequencingTestTypes, SequencingWebImpl>()
-//         .launch()
-//         .run_test()
-//         .await;
-//     shutdown_logging();
-// }
+use async_compatibility_layer::logging::shutdown_logging;
+use hotshot_testing::{
+    node_types::{SequencingTestTypes, SequencingWebImpl},
+    overall_safety_task::OverallSafetyPropertiesDescription,
+    test_builder::{TestMetadata, TimingData},
+};
+use tracing::instrument;
+
+/// Web server network test
+#[cfg_attr(
+    feature = "tokio-executor",
+    tokio::test(flavor = "multi_thread", worker_threads = 2)
+)]
+#[cfg_attr(feature = "async-std-executor", async_std::test)]
+#[instrument]
+async fn web_server_network() {
+    async_compatibility_layer::logging::setup_logging();
+    async_compatibility_layer::logging::setup_backtrace();
+    let metadata = TestMetadata {
+        timing_data: TimingData {
+            round_start_delay: 25,
+            next_view_timeout: 3000,
+            start_delay: 120000,
+
+            ..Default::default()
+        },
+        overall_safety_properties: OverallSafetyPropertiesDescription {
+            num_successful_views: 35,
+            ..Default::default()
+        },
+        ..TestMetadata::default()
+    };
+    metadata
+        .gen_launcher::<SequencingTestTypes, SequencingWebImpl>()
+        .launch()
+        .run_test()
+        .await;
+    shutdown_logging();
+}