udp: move PeerStatus from common.rs to swarm worker

crates/udp/src/common.rs

@@ -153,29 +153,6 @@ impl ConnectedResponseSender {
 
 pub type ConnectedResponseReceiver = Receiver<(CanonicalSocketAddr, ConnectedResponse)>;
 
-#[derive(PartialEq, Eq, Hash, Clone, Copy, Debug)]
-pub enum PeerStatus {
-    Seeding,
-    Leeching,
-    Stopped,
-}
-
-impl PeerStatus {
-    /// Determine peer status from announce event and number of bytes left.
-    ///
-    /// Likely, the last branch will be taken most of the time.
-    #[inline]
-    pub fn from_event_and_bytes_left(event: AnnounceEvent, bytes_left: NumberOfBytes) -> Self {
-        if event == AnnounceEvent::Stopped {
-            Self::Stopped
-        } else if bytes_left.0.get() == 0 {
-            Self::Seeding
-        } else {
-            Self::Leeching
-        }
-    }
-}
-
 pub enum StatisticsMessage {
     Ipv4PeerHistogram(Histogram<u64>),
     Ipv6PeerHistogram(Histogram<u64>),
@@ -242,27 +219,6 @@ mod tests {
 
     use super::*;
 
-    #[test]
-    fn test_peer_status_from_event_and_bytes_left() {
-        use crate::common::*;
-
-        use PeerStatus::*;
-
-        let f = PeerStatus::from_event_and_bytes_left;
-
-        assert_eq!(Stopped, f(AnnounceEvent::Stopped, NumberOfBytes::new(0)));
-        assert_eq!(Stopped, f(AnnounceEvent::Stopped, NumberOfBytes::new(1)));
-
-        assert_eq!(Seeding, f(AnnounceEvent::Started, NumberOfBytes::new(0)));
-        assert_eq!(Leeching, f(AnnounceEvent::Started, NumberOfBytes::new(1)));
-
-        assert_eq!(Seeding, f(AnnounceEvent::Completed, NumberOfBytes::new(0)));
-        assert_eq!(Leeching, f(AnnounceEvent::Completed, NumberOfBytes::new(1)));
-
-        assert_eq!(Seeding, f(AnnounceEvent::None, NumberOfBytes::new(0)));
-        assert_eq!(Leeching, f(AnnounceEvent::None, NumberOfBytes::new(1)));
-    }
-
     // Assumes that announce response with maximum amount of ipv6 peers will
     // be the longest
     #[test]

crates/udp/src/workers/swarm/storage.rs

@@ -516,3 +516,50 @@ struct Peer {
     is_seeder: bool,
     valid_until: ValidUntil,
 }
+
+#[derive(PartialEq, Eq, Hash, Clone, Copy, Debug)]
+pub enum PeerStatus {
+    Seeding,
+    Leeching,
+    Stopped,
+}
+
+impl PeerStatus {
+    /// Determine peer status from announce event and number of bytes left.
+    ///
+    /// Likely, the last branch will be taken most of the time.
+    #[inline]
+    pub fn from_event_and_bytes_left(event: AnnounceEvent, bytes_left: NumberOfBytes) -> Self {
+        if event == AnnounceEvent::Stopped {
+            Self::Stopped
+        } else if bytes_left.0.get() == 0 {
+            Self::Seeding
+        } else {
+            Self::Leeching
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_peer_status_from_event_and_bytes_left() {
+        use PeerStatus::*;
+
+        let f = PeerStatus::from_event_and_bytes_left;
+
+        assert_eq!(Stopped, f(AnnounceEvent::Stopped, NumberOfBytes::new(0)));
+        assert_eq!(Stopped, f(AnnounceEvent::Stopped, NumberOfBytes::new(1)));
+
+        assert_eq!(Seeding, f(AnnounceEvent::Started, NumberOfBytes::new(0)));
+        assert_eq!(Leeching, f(AnnounceEvent::Started, NumberOfBytes::new(1)));
+
+        assert_eq!(Seeding, f(AnnounceEvent::Completed, NumberOfBytes::new(0)));
+        assert_eq!(Leeching, f(AnnounceEvent::Completed, NumberOfBytes::new(1)));
+
+        assert_eq!(Seeding, f(AnnounceEvent::None, NumberOfBytes::new(0)));
+        assert_eq!(Leeching, f(AnnounceEvent::None, NumberOfBytes::new(1)));
+    }
+}