Add isolated test for list_sellers function

swap/src/cli.rs

@@ -12,3 +12,168 @@ pub use cancel::cancel;
 pub use event_loop::{EventLoop, EventLoopHandle};
 pub use list_sellers::list_sellers;
 pub use refund::refund;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::asb;
+    use crate::cli::list_sellers::Seller;
+    use crate::network::quote;
+    use crate::network::quote::BidQuote;
+    use crate::network::rendezvous::XmrBtcNamespace;
+    use crate::network::test::{new_swarm, SwarmExt};
+    use futures::StreamExt;
+    use libp2p::multiaddr::Protocol;
+    use libp2p::request_response::RequestResponseEvent;
+    use libp2p::swarm::{AddressScore, NetworkBehaviourEventProcess};
+    use libp2p::{identity, Multiaddr, PeerId};
+    use std::collections::HashSet;
+    use std::iter::FromIterator;
+    use std::time::Duration;
+
+    #[tokio::test]
+    async fn list_sellers_should_report_all_registered_asbs_with_a_quote() {
+        let namespace = XmrBtcNamespace::Mainnet;
+        let (rendezvous_address, rendezvous_peer_id) = setup_rendezvous_point().await;
+        let expected_seller_1 =
+            setup_asb(rendezvous_peer_id, rendezvous_address.clone(), namespace).await;
+        let expected_seller_2 =
+            setup_asb(rendezvous_peer_id, rendezvous_address.clone(), namespace).await;
+
+        let list_sellers = list_sellers(
+            rendezvous_peer_id,
+            rendezvous_address,
+            namespace,
+            0,
+            identity::Keypair::generate_ed25519(),
+        );
+        let sellers = tokio::time::timeout(Duration::from_secs(15), list_sellers)
+            .await
+            .unwrap()
+            .unwrap();
+
+        assert_eq!(
+            HashSet::<Seller>::from_iter(sellers),
+            HashSet::<Seller>::from_iter([expected_seller_1, expected_seller_2])
+        )
+    }
+
+    async fn setup_rendezvous_point() -> (Multiaddr, PeerId) {
+        let mut rendezvous_node = new_swarm(|_, identity| RendezvousPointBehaviour {
+            rendezvous: libp2p::rendezvous::Rendezvous::new(
+                identity,
+                libp2p::rendezvous::Config::default(),
+            ),
+            ping: Default::default(),
+        });
+        let rendezvous_address = rendezvous_node.listen_on_tcp_localhost().await;
+        let rendezvous_peer_id = *rendezvous_node.local_peer_id();
+
+        tokio::spawn(async move {
+            loop {
+                rendezvous_node.next().await;
+            }
+        });
+
+        (rendezvous_address, rendezvous_peer_id)
+    }
+
+    async fn setup_asb(
+        rendezvous_peer_id: PeerId,
+        rendezvous_address: Multiaddr,
+        namespace: XmrBtcNamespace,
+    ) -> Seller {
+        let static_quote = BidQuote {
+            price: bitcoin::Amount::from_sat(1337),
+            min_quantity: bitcoin::Amount::from_sat(42),
+            max_quantity: bitcoin::Amount::from_sat(9001),
+        };
+
+        let mut asb = new_swarm(|_, identity| StaticQuoteAsbBehaviour {
+            rendezvous: asb::rendezous::Behaviour::new(
+                identity,
+                rendezvous_peer_id,
+                rendezvous_address,
+                namespace,
+                None,
+            ),
+            ping: Default::default(),
+            quote: quote::asb(),
+            static_quote,
+            registered: false,
+        });
+
+        let asb_address = asb.listen_on_tcp_localhost().await;
+        asb.add_external_address(asb_address.clone(), AddressScore::Infinite);
+
+        let asb_peer_id = *asb.local_peer_id();
+
+        // avoid race condition where `list_sellers` tries to discover before we are
+        // registered block this function until we are registered
+        while !asb.behaviour().registered {
+            asb.next().await;
+        }
+
+        tokio::spawn(async move {
+            loop {
+                asb.next().await;
+            }
+        });
+
+        Seller {
+            multiaddr: asb_address.with(Protocol::P2p(asb_peer_id.into())),
+            quote: static_quote,
+        }
+    }
+
+    #[derive(libp2p::NetworkBehaviour)]
+    struct StaticQuoteAsbBehaviour {
+        rendezvous: asb::rendezous::Behaviour,
+        // Support `Ping` as a workaround until https://github.com/libp2p/rust-libp2p/issues/2109 is fixed.
+        ping: libp2p::ping::Ping,
+        quote: quote::Behaviour,
+
+        #[behaviour(ignore)]
+        static_quote: BidQuote,
+        #[behaviour(ignore)]
+        registered: bool,
+    }
+
+    impl NetworkBehaviourEventProcess<libp2p::rendezvous::Event> for StaticQuoteAsbBehaviour {
+        fn inject_event(&mut self, event: libp2p::rendezvous::Event) {
+            if let libp2p::rendezvous::Event::Registered { .. } = event {
+                self.registered = true;
+            }
+        }
+    }
+    impl NetworkBehaviourEventProcess<libp2p::ping::PingEvent> for StaticQuoteAsbBehaviour {
+        fn inject_event(&mut self, _: libp2p::ping::PingEvent) {}
+    }
+    impl NetworkBehaviourEventProcess<quote::OutEvent> for StaticQuoteAsbBehaviour {
+        fn inject_event(&mut self, event: quote::OutEvent) {
+            if let RequestResponseEvent::Message {
+                message: quote::Message::Request { channel, .. },
+                ..
+            } = event
+            {
+                self.quote
+                    .send_response(channel, self.static_quote)
+                    .unwrap();
+            }
+        }
+    }
+
+    #[derive(libp2p::NetworkBehaviour)]
+    struct RendezvousPointBehaviour {
+        rendezvous: libp2p::rendezvous::Rendezvous,
+        // Support `Ping` as a workaround until https://github.com/libp2p/rust-libp2p/issues/2109 is fixed.
+        ping: libp2p::ping::Ping,
+    }
+
+    impl NetworkBehaviourEventProcess<libp2p::rendezvous::Event> for RendezvousPointBehaviour {
+        fn inject_event(&mut self, _: libp2p::rendezvous::Event) {}
+    }
+    impl NetworkBehaviourEventProcess<libp2p::ping::PingEvent> for RendezvousPointBehaviour {
+        fn inject_event(&mut self, _: libp2p::ping::PingEvent) {}
+    }
+}