pool: add more tests

Closes #898

Pull-Request: #898
Signed-off-by: Yuki Kishimoto <yukikishimoto@protonmail.com>

Author: YichiZhang0613

crates/nostr-relay-pool/src/monitor.rs

@@ -55,3 +55,20 @@ impl Monitor {
         self.notify(MonitorNotification::StatusChanged { relay_url, status });
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    #[should_panic]
+    fn test_monitor_capacity_is_zero() {
+        Monitor::new(0);
+    }
+
+    #[test]
+    #[should_panic]
+    fn test_monitor_capacity_overflows() {
+        let _ = Monitor::new(usize::MAX / 2);
+    }
+}

crates/nostr-relay-pool/src/policy.rs

@@ -96,3 +96,25 @@ pub trait AdmitPolicy: fmt::Debug + Send + Sync {
         Box::pin(async move { Ok(AdmitStatus::Success) })
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_admit_status_success() {
+        let status = AdmitStatus::success();
+        assert_eq!(status, AdmitStatus::Success);
+    }
+
+    #[test]
+    fn test_admit_status_rejcted() {
+        let status = AdmitStatus::rejected("not admitted");
+        assert_eq!(
+            status,
+            AdmitStatus::Rejected {
+                reason: Some(String::from("not admitted"))
+            }
+        );
+    }
+}

crates/nostr-relay-pool/src/relay/flags.rs

@@ -315,4 +315,58 @@ mod tests {
         let f = AtomicRelayServiceFlags::new(RelayServiceFlags::DISCOVERY);
         assert!(!f.can_write());
     }
+
+    #[test]
+    fn test_has_any_service_flags() {
+        let f = AtomicRelayServiceFlags::new(RelayServiceFlags::DISCOVERY);
+        assert!(f.has_any(RelayServiceFlags::READ | RelayServiceFlags::DISCOVERY));
+        assert!(!f.has_any(RelayServiceFlags::READ | RelayServiceFlags::WRITE));
+    }
+
+    #[test]
+    fn test_has_all_service_flags() {
+        let f = AtomicRelayServiceFlags::new(RelayServiceFlags::READ | RelayServiceFlags::GOSSIP);
+        assert!(f.has_all(RelayServiceFlags::READ | RelayServiceFlags::GOSSIP));
+        assert!(!f.has_all(RelayServiceFlags::READ | RelayServiceFlags::WRITE));
+    }
+
+    #[test]
+    fn test_has_read_service_flags() {
+        let f1 = AtomicRelayServiceFlags::new(RelayServiceFlags::READ);
+        assert!(f1.has_read());
+        let f2 = AtomicRelayServiceFlags::new(RelayServiceFlags::WRITE);
+        assert!(!f2.has_read());
+    }
+
+    #[test]
+    fn test_has_write_service_flags() {
+        let f1 = AtomicRelayServiceFlags::new(RelayServiceFlags::WRITE);
+        assert!(f1.has_write());
+        let f2 = AtomicRelayServiceFlags::new(RelayServiceFlags::READ);
+        assert!(!f2.has_write());
+    }
+
+    #[test]
+    fn test_has_ping_service_flags() {
+        let f1 = AtomicRelayServiceFlags::new(RelayServiceFlags::PING);
+        assert!(f1.has_ping());
+        let f2 = AtomicRelayServiceFlags::new(RelayServiceFlags::default());
+        assert!(f2.has_ping());
+    }
+
+    #[test]
+    fn test_has_gossip_flags() {
+        let f1 = AtomicRelayServiceFlags::new(RelayServiceFlags::GOSSIP);
+        assert!(f1.has_gossip());
+        let f2 = AtomicRelayServiceFlags::new(RelayServiceFlags::default());
+        assert!(!f2.has_gossip());
+    }
+
+    #[test]
+    fn test_has_discovery_flags() {
+        let f1 = AtomicRelayServiceFlags::new(RelayServiceFlags::DISCOVERY);
+        assert!(f1.has_discovery());
+        let f2 = AtomicRelayServiceFlags::new(RelayServiceFlags::default());
+        assert!(!f2.has_discovery());
+    }
 }

crates/nostr-relay-pool/src/relay/options.rs

@@ -303,3 +303,70 @@ impl SyncOptions {
         !self.dry_run && matches!(self.direction, SyncDirection::Down | SyncDirection::Both)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_exit_policy() {
+        let policy = ReqExitPolicy::default();
+        let opts = SubscribeAutoCloseOptions::default().exit_policy(policy);
+        assert_eq!(
+            std::mem::discriminant(&opts.exit_policy),
+            std::mem::discriminant(&policy)
+        );
+    }
+
+    #[test]
+    fn test_timeout() {
+        let duration = Some(Duration::from_secs(10));
+        let opts = SubscribeAutoCloseOptions::default().timeout(duration);
+        assert_eq!(opts.timeout, duration);
+        let duration = Some(Duration::from_millis(500));
+        let opts = SubscribeAutoCloseOptions::default().idle_timeout(duration);
+        assert_eq!(opts.idle_timeout, duration);
+        let opt = SyncOptions::default().initial_timeout(Duration::from_secs(5));
+        assert_eq!(opt.initial_timeout, Duration::from_secs(5));
+    }
+
+    #[test]
+    fn test_close() {
+        let opts = SubscribeOptions::default();
+        assert_eq!(opts.is_auto_closing(), false);
+        let opts = SubscribeOptions::default().close_on(Some(SubscribeAutoCloseOptions::default()));
+        assert_eq!(opts.is_auto_closing(), true);
+    }
+
+    #[test]
+    fn test_sync_progress_percentage() {
+        let mut sp = SyncProgress::default();
+        sp.total = 5;
+        sp.current = 2;
+        assert_eq!(sp.percentage(), 2f64 / 5f64);
+        let sp_zero = SyncProgress::default();
+        assert_eq!(sp_zero.percentage(), 0.0);
+    }
+
+    #[test]
+    fn test_do_up() {
+        let opt = SyncOptions::default();
+        assert!(!opt.do_up());
+        let opt2 = SyncOptions::default().dry_run();
+        assert!(!opt2.do_up());
+        let opt3 = SyncOptions::default().direction(SyncDirection::Up);
+        assert!(opt3.do_up());
+    }
+
+    #[test]
+    fn test_do_down() {
+        let opt = SyncOptions::default();
+        assert!(opt.do_down());
+        let opt2 = SyncOptions::default().direction(SyncDirection::Down);
+        assert!(opt2.do_down());
+        let opt3 = SyncOptions::default()
+            .dry_run()
+            .direction(SyncDirection::Down);
+        assert!(!opt3.do_down());
+    }
+}

crates/nostr-relay-pool/src/relay/ping.rs

@@ -68,3 +68,31 @@ impl PingTracker {
         self.replied.store(replied, Ordering::SeqCst);
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn test_ping_tracker_sent() {
+        let tracker = PingTracker::default();
+        let before = tracker.sent_at().await;
+        tracker.just_sent().await;
+        let after = tracker.sent_at().await;
+        assert!(after >= before);
+    }
+
+    #[test]
+    fn test_ping_tracker_last_nonce() {
+        let tracker = PingTracker::default();
+        tracker.set_last_nonce(42);
+        assert_eq!(tracker.last_nonce(), 42);
+    }
+
+    #[test]
+    fn test_ping_tracker_replied() {
+        let tracker = PingTracker::default();
+        tracker.set_replied(true);
+        assert!(tracker.replied());
+    }
+}

crates/nostr-relay-pool/src/relay/stats.rs

@@ -147,3 +147,33 @@ impl RelayConnectionStats {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_attempt_success() {
+        let stats = RelayConnectionStats::default();
+        stats.new_attempt();
+        stats.new_success();
+        assert_eq!(stats.attempts(), 1);
+        assert_eq!(stats.success(), 1);
+        assert_eq!(stats.success_rate(), 1.0);
+        assert!(stats.connected_at().as_u64() > 0);
+        assert!(stats.first_connection_timestamp().as_u64() > 0);
+    }
+
+    #[test]
+    fn test_add_bytes() {
+        let stats = RelayConnectionStats::default();
+        stats.add_bytes_sent(0);
+        assert_eq!(stats.bytes_sent(), 0);
+        stats.add_bytes_sent(50);
+        assert_eq!(stats.bytes_sent(), 50);
+        stats.add_bytes_received(0);
+        assert_eq!(stats.bytes_received(), 0);
+        stats.add_bytes_received(30);
+        assert_eq!(stats.bytes_received(), 30);
+    }
+}

crates/nostr-relay-pool/src/relay/status.rs

@@ -112,3 +112,106 @@ impl RelayStatus {
         matches!(self, Self::Initialized | Self::Terminated)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_status_set() {
+        let relay = AtomicRelayStatus::default();
+        relay.set(RelayStatus::Connected);
+        assert_eq!(relay.load(), RelayStatus::Connected);
+    }
+
+    #[test]
+    fn test_status_initialized() {
+        let status = RelayStatus::Initialized;
+        assert!(status.is_initialized());
+        assert!(!status.is_connected());
+        assert!(!status.is_disconnected());
+        assert!(!status.is_terminated());
+        assert!(!status.is_banned());
+        assert!(status.can_connect());
+        let relay = AtomicRelayStatus::new(status);
+        assert_eq!(relay.load(), RelayStatus::Initialized);
+    }
+
+    #[test]
+    fn test_status_pending() {
+        let status = RelayStatus::Pending;
+        assert!(!status.is_initialized());
+        assert!(!status.is_connected());
+        assert!(!status.is_disconnected());
+        assert!(!status.is_terminated());
+        assert!(!status.is_banned());
+        assert!(!status.can_connect());
+        let relay = AtomicRelayStatus::new(status);
+        assert_eq!(relay.load(), RelayStatus::Pending);
+    }
+
+    #[test]
+    fn test_status_connecting() {
+        let status = RelayStatus::Connecting;
+        assert!(!status.is_initialized());
+        assert!(!status.is_connected());
+        assert!(!status.is_disconnected());
+        assert!(!status.is_terminated());
+        assert!(!status.is_banned());
+        assert!(!status.can_connect());
+        let relay = AtomicRelayStatus::new(status);
+        assert_eq!(relay.load(), RelayStatus::Connecting);
+    }
+
+    #[test]
+    fn test_status_connected() {
+        let status = RelayStatus::Connected;
+        assert!(!status.is_initialized());
+        assert!(status.is_connected());
+        assert!(!status.is_disconnected());
+        assert!(!status.is_terminated());
+        assert!(!status.is_banned());
+        assert!(!status.can_connect());
+        let relay = AtomicRelayStatus::new(status);
+        assert_eq!(relay.load(), RelayStatus::Connected);
+    }
+
+    #[test]
+    fn test_status_disconnected() {
+        let status = RelayStatus::Disconnected;
+        assert!(!status.is_initialized());
+        assert!(!status.is_connected());
+        assert!(status.is_disconnected());
+        assert!(!status.is_terminated());
+        assert!(!status.is_banned());
+        assert!(!status.can_connect());
+        let relay = AtomicRelayStatus::new(status);
+        assert_eq!(relay.load(), RelayStatus::Disconnected);
+    }
+
+    #[test]
+    fn test_status_terminated() {
+        let status = RelayStatus::Terminated;
+        assert!(!status.is_initialized());
+        assert!(!status.is_connected());
+        assert!(status.is_disconnected());
+        assert!(status.is_terminated());
+        assert!(!status.is_banned());
+        assert!(status.can_connect());
+        let relay = AtomicRelayStatus::new(status);
+        assert_eq!(relay.load(), RelayStatus::Terminated);
+    }
+
+    #[test]
+    fn test_status_banned() {
+        let status = RelayStatus::Banned;
+        assert!(!status.is_initialized());
+        assert!(!status.is_connected());
+        assert!(status.is_disconnected());
+        assert!(!status.is_terminated());
+        assert!(status.is_banned());
+        assert!(!status.can_connect());
+        let relay = AtomicRelayStatus::new(status);
+        assert_eq!(relay.load(), RelayStatus::Banned);
+    }
+}