test fixes

Author: jstuczyn

Cargo.lock

@@ -2,16 +2,16 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::traits::Timeboxed;
-use rand_chacha::ChaCha20Rng;
+use nym_bin_common::logging::tracing_subscriber::EnvFilter;
+use nym_bin_common::logging::tracing_subscriber::layer::SubscriberExt;
+use nym_bin_common::logging::tracing_subscriber::util::SubscriberInitExt;
+use nym_bin_common::logging::{default_tracing_fmt_layer, tracing_subscriber};
 use rand_chacha::rand_core::SeedableRng;
 use std::future::Future;
 use tokio::task::JoinHandle;
 use tokio::time::error::Elapsed;
 
-use nym_bin_common::logging::tracing_subscriber::EnvFilter;
-use nym_bin_common::logging::tracing_subscriber::layer::SubscriberExt;
-use nym_bin_common::logging::tracing_subscriber::util::SubscriberInitExt;
-use nym_bin_common::logging::{default_tracing_fmt_layer, tracing_subscriber};
+pub use rand_chacha::ChaCha20Rng as DeterministicRng;
 pub use rand_chacha::rand_core::{CryptoRng, RngCore};
 
 pub fn leak<T>(val: T) -> &'static mut T {
@@ -26,16 +26,16 @@ where
     tokio::spawn(async move { fut.timeboxed().await })
 }
 
-pub fn deterministic_rng() -> ChaCha20Rng {
+pub fn deterministic_rng() -> DeterministicRng {
     seeded_rng([42u8; 32])
 }
 
-pub fn seeded_rng(seed: [u8; 32]) -> ChaCha20Rng {
-    ChaCha20Rng::from_seed(seed)
+pub fn seeded_rng(seed: [u8; 32]) -> DeterministicRng {
+    DeterministicRng::from_seed(seed)
 }
 
-pub fn u64_seeded_rng(seed: u64) -> ChaCha20Rng {
-    ChaCha20Rng::seed_from_u64(seed)
+pub fn u64_seeded_rng(seed: u64) -> DeterministicRng {
+    DeterministicRng::seed_from_u64(seed)
 }
 
 // test logger to use during debugging

common/test-utils/src/helpers.rs

@@ -240,6 +240,14 @@ impl IpPool {
             .count()
     }
 
+    /// Get the number of allocated IPs in the pool
+    pub fn pre_allocated_count(&self) -> usize {
+        self.allocations
+            .iter()
+            .filter(|(_, state)| matches!(state, AllocationState::PreAllocated { .. }))
+            .count()
+    }
+
     /// Get the number of allocated IPs in the pool
     pub fn allocated_count(&self) -> usize {
         self.allocations
@@ -261,7 +269,6 @@ impl IpPool {
         let mut freed = 0;
 
         for state in self.allocations.values_mut() {
-            println!("entry: {state:?}");
             if let AllocationState::PreAllocated { allocated_at, .. } = state {
                 let age = now.duration_since(*allocated_at);
                 if age > max_age {
@@ -373,19 +380,25 @@ mod tests {
         };
 
         assert_eq!(pool.free_count(), 3);
-        assert_eq!(pool.allocated_count(), 0);
+        assert_eq!(pool.pre_allocated_count(), 0);
 
         let allocation1 = pool.pre_allocate()?;
         assert_eq!(pool.free_count(), 2);
-        assert_eq!(pool.allocated_count(), 1);
+        assert_eq!(pool.pre_allocated_count(), 1);
 
         let allocation2 = pool.pre_allocate()?;
         assert_eq!(pool.free_count(), 1);
-        assert_eq!(pool.allocated_count(), 2);
+        assert_eq!(pool.pre_allocated_count(), 2);
+
+        pool.confirm_allocation(allocation1)?;
+        assert_eq!(pool.free_count(), 1);
+        assert_eq!(pool.pre_allocated_count(), 1);
+        assert_eq!(pool.allocated_count(), 1);
 
         let allocation3 = pool.pre_allocate()?;
         assert_eq!(pool.free_count(), 0);
-        assert_eq!(pool.allocated_count(), 3);
+        assert_eq!(pool.pre_allocated_count(), 2);
+        assert_eq!(pool.allocated_count(), 1);
 
         // make sure each was unique and different from the gateway
         ensure_different_allocation(allocation1, allocation2)?;
@@ -402,13 +415,15 @@ mod tests {
         // if pair gets released, it's eligible for allocation again
         pool.release(allocation2);
         assert_eq!(pool.free_count(), 1);
-        assert_eq!(pool.allocated_count(), 2);
+        assert_eq!(pool.pre_allocated_count(), 1);
+        assert_eq!(pool.allocated_count(), 1);
 
         let reallocation = pool.pre_allocate()?;
         assert_eq!(reallocation, allocation2);
 
         assert_eq!(pool.free_count(), 0);
-        assert_eq!(pool.allocated_count(), 3);
+        assert_eq!(pool.pre_allocated_count(), 2);
+        assert_eq!(pool.allocated_count(), 1);
 
         Ok(())
     }

common/wireguard/src/ip_pool/mod.rs

@@ -269,7 +269,6 @@ impl PeerController {
                 "could not determine ip pair allocated to the peer".to_string(),
             ));
         };
-        self.ip_pool.confirm_allocation(ip_pair)?;
 
         // Try to configure WireGuard peer
         if let Err(e) = self.wg_api.configure_peer(peer) {
@@ -302,6 +301,9 @@ impl PeerController {
             *self.host_information.write().await = host_information;
         }
         let public_key = peer.public_key.clone();
+
+        self.ip_pool.confirm_allocation(ip_pair)?;
+
         tokio::spawn(async move {
             handle.run().await;
             debug!("Peer handle shut down for {public_key}");

common/wireguard/src/peer_controller/mod.rs

@@ -89,9 +89,11 @@ bytes = { workspace = true }
 defguard_wireguard_rs = { workspace = true }
 
 [dev-dependencies]
+anyhow = { workspace = true }
+nym-test-utils = { workspace = true }
 nym-gateway-storage = { workspace = true, features = ["mock"] }
 nym-wireguard = { workspace = true, features = ["mock"] }
-mock_instant = "0.6.0"
+mock_instant = { workspace = true }
 time = { workspace = true }
 
 [lints]

gateway/Cargo.toml

@@ -156,30 +156,9 @@ mod test {
         cache.remove_stale();
         assert!(cache.get_peer_pub_key(&credential).is_some());
 
-        MockClock::advance_system_time(SEEN_CREDENTIAL_CACHE_TIME * 2);
+        MockClock::advance(SEEN_CREDENTIAL_CACHE_TIME * 2);
 
         cache.remove_stale();
         assert!(cache.get_peer_pub_key(&credential).is_none());
     }
-
-    #[test]
-    fn invalid_time() {
-        assert!(MockClock::is_thread_local());
-        assert!(Instant::now().is_thread_local());
-
-        let mut cache = SeenCredentialCache::new();
-        let credential = CredentialSpendingData::try_from_bytes(&CREDENTIAL_BYTES).unwrap();
-        let peer_pub_key = PeerPublicKey::from_str(PUB_KEY).unwrap();
-
-        // set some value for time
-        MockClock::set_system_time(Duration::from_secs(10));
-        cache.insert_credential(credential.clone(), peer_pub_key);
-
-        // then set the time in the past
-        MockClock::set_system_time(Duration::ZERO);
-        cache.remove_stale();
-
-        // invalid time should remove the credential, just in case
-        assert!(cache.get_peer_pub_key(&credential).is_none());
-    }
 }