refactor: [#1235] remove pun method only used for testing

Now that we inject dependencies we can write assert using the dependencies instead of exposing public methods.

Author: josecelano

packages/tracker-core/src/core_tests.rs

@@ -5,8 +5,12 @@ use std::sync::Arc;
 use aquatic_udp_protocol::{AnnounceEvent, NumberOfBytes, PeerId};
 use bittorrent_primitives::info_hash::InfoHash;
 use torrust_tracker_configuration::Configuration;
+#[cfg(test)]
+use torrust_tracker_configuration::Core;
 use torrust_tracker_primitives::peer::Peer;
 use torrust_tracker_primitives::DurationSinceUnixEpoch;
+#[cfg(test)]
+use torrust_tracker_test_helpers::configuration::ephemeral_sqlite_database;
 
 use super::announce_handler::AnnounceHandler;
 use super::databases::setup::initialize_database;
@@ -103,3 +107,20 @@ pub fn initialize_handlers(config: &Configuration) -> (Arc<AnnounceHandler>, Arc
 
     (announce_handler, scrape_handler)
 }
+
+/// # Panics
+///
+/// Will panic if the temporary file path is not a valid UFT string.
+#[cfg(test)]
+#[must_use]
+pub fn ephemeral_configuration_for_listed_tracker() -> Core {
+    let mut config = Core {
+        listed: true,
+        ..Default::default()
+    };
+
+    let temp_file = ephemeral_sqlite_database();
+    temp_file.to_str().unwrap().clone_into(&mut config.database.path);
+
+    config
+}

packages/tracker-core/src/whitelist/manager.rs

@@ -53,11 +53,6 @@ impl WhitelistManager {
         self.in_memory_whitelist.remove(info_hash).await
     }
 
-    /// It checks if a torrent is whitelisted.
-    pub async fn is_info_hash_whitelisted(&self, info_hash: &InfoHash) -> bool {
-        self.in_memory_whitelist.contains(info_hash).await
-    }
-
     /// It loads the whitelist from the database.
     ///
     /// # Errors
@@ -81,17 +76,41 @@ mod tests {
 
     use std::sync::Arc;
 
-    use torrust_tracker_test_helpers::configuration;
+    use torrust_tracker_configuration::Core;
 
+    use crate::core_tests::ephemeral_configuration_for_listed_tracker;
+    use crate::databases::setup::initialize_database;
+    use crate::databases::Database;
     use crate::whitelist::manager::WhitelistManager;
-    use crate::whitelist::whitelist_tests::initialize_whitelist_services;
+    use crate::whitelist::repository::in_memory::InMemoryWhitelist;
+    use crate::whitelist::repository::persisted::DatabaseWhitelist;
 
-    fn initialize_whitelist_manager_for_whitelisted_tracker() -> Arc<WhitelistManager> {
-        let config = configuration::ephemeral_listed();
+    struct WhitelistManagerDeps {
+        pub _database: Arc<Box<dyn Database>>,
+        pub _database_whitelist: Arc<DatabaseWhitelist>,
+        pub in_memory_whitelist: Arc<InMemoryWhitelist>,
+    }
 
-        let (_whitelist_authorization, whitelist_manager) = initialize_whitelist_services(&config);
+    fn initialize_whitelist_manager_for_whitelisted_tracker() -> (Arc<WhitelistManager>, Arc<WhitelistManagerDeps>) {
+        let config = ephemeral_configuration_for_listed_tracker();
+        initialize_whitelist_manager_and_deps(&config)
+    }
 
-        whitelist_manager
+    fn initialize_whitelist_manager_and_deps(config: &Core) -> (Arc<WhitelistManager>, Arc<WhitelistManagerDeps>) {
+        let database = initialize_database(config);
+        let database_whitelist = Arc::new(DatabaseWhitelist::new(database.clone()));
+        let in_memory_whitelist = Arc::new(InMemoryWhitelist::default());
+
+        let whitelist_manager = Arc::new(WhitelistManager::new(database_whitelist.clone(), in_memory_whitelist.clone()));
+
+        (
+            whitelist_manager,
+            Arc::new(WhitelistManagerDeps {
+                _database: database,
+                _database_whitelist: database_whitelist,
+                in_memory_whitelist,
+            }),
+        )
     }
 
     mod configured_as_whitelisted {
@@ -102,26 +121,26 @@ mod tests {
 
             #[tokio::test]
             async fn it_should_add_a_torrent_to_the_whitelist() {
-                let whitelist_manager = initialize_whitelist_manager_for_whitelisted_tracker();
+                let (whitelist_manager, services) = initialize_whitelist_manager_for_whitelisted_tracker();
 
                 let info_hash = sample_info_hash();
 
                 whitelist_manager.add_torrent_to_whitelist(&info_hash).await.unwrap();
 
-                assert!(whitelist_manager.is_info_hash_whitelisted(&info_hash).await);
+                assert!(services.in_memory_whitelist.contains(&info_hash).await);
             }
 
             #[tokio::test]
             async fn it_should_remove_a_torrent_from_the_whitelist() {
-                let whitelist_manager = initialize_whitelist_manager_for_whitelisted_tracker();
+                let (whitelist_manager, services) = initialize_whitelist_manager_for_whitelisted_tracker();
 
                 let info_hash = sample_info_hash();
 
                 whitelist_manager.add_torrent_to_whitelist(&info_hash).await.unwrap();
 
                 whitelist_manager.remove_torrent_from_whitelist(&info_hash).await.unwrap();
 
-                assert!(!whitelist_manager.is_info_hash_whitelisted(&info_hash).await);
+                assert!(!services.in_memory_whitelist.contains(&info_hash).await);
             }
 
             mod persistence {
@@ -130,19 +149,19 @@ mod tests {
 
                 #[tokio::test]
                 async fn it_should_load_the_whitelist_from_the_database() {
-                    let whitelist_manager = initialize_whitelist_manager_for_whitelisted_tracker();
+                    let (whitelist_manager, services) = initialize_whitelist_manager_for_whitelisted_tracker();
 
                     let info_hash = sample_info_hash();
 
                     whitelist_manager.add_torrent_to_whitelist(&info_hash).await.unwrap();
 
                     whitelist_manager.remove_torrent_from_memory_whitelist(&info_hash).await;
 
-                    assert!(!whitelist_manager.is_info_hash_whitelisted(&info_hash).await);
+                    assert!(!services.in_memory_whitelist.contains(&info_hash).await);
 
                     whitelist_manager.load_whitelist_from_database().await.unwrap();
 
-                    assert!(whitelist_manager.is_info_hash_whitelisted(&info_hash).await);
+                    assert!(services.in_memory_whitelist.contains(&info_hash).await);
                 }
             }
         }

packages/tracker-core/src/whitelist/repository/persisted.rs

@@ -65,10 +65,7 @@ impl DatabaseWhitelist {
 mod tests {
     mod the_persisted_whitelist_repository {
 
-        use torrust_tracker_configuration::Core;
-        use torrust_tracker_test_helpers::configuration::ephemeral_sqlite_database;
-
-        use crate::core_tests::sample_info_hash;
+        use crate::core_tests::{ephemeral_configuration_for_listed_tracker, sample_info_hash};
         use crate::databases::setup::initialize_database;
         use crate::whitelist::repository::persisted::DatabaseWhitelist;
 
@@ -78,18 +75,6 @@ mod tests {
             DatabaseWhitelist::new(database)
         }
 
-        fn ephemeral_configuration_for_listed_tracker() -> Core {
-            let mut config = Core {
-                listed: true,
-                ..Default::default()
-            };
-
-            let temp_file = ephemeral_sqlite_database();
-            temp_file.to_str().unwrap().clone_into(&mut config.database.path);
-
-            config
-        }
-
         #[test]
         fn should_add_a_new_infohash_to_the_list() {
             let whitelist = initialize_database_whitelist();

src/bootstrap/app.rs

@@ -141,6 +141,7 @@ pub fn initialize_app_container(configuration: &Configuration) -> AppContainer {
         scrape_handler,
         keys_handler,
         authentication_service,
+        in_memory_whitelist,
         whitelist_authorization,
         ban_service,
         http_stats_event_sender,

src/container.rs

@@ -10,6 +10,7 @@ use bittorrent_tracker_core::torrent::repository::in_memory::InMemoryTorrentRepo
 use bittorrent_tracker_core::torrent::repository::persisted::DatabasePersistentTorrentRepository;
 use bittorrent_tracker_core::whitelist;
 use bittorrent_tracker_core::whitelist::manager::WhitelistManager;
+use bittorrent_tracker_core::whitelist::repository::in_memory::InMemoryWhitelist;
 use tokio::sync::RwLock;
 use torrust_tracker_configuration::{Core, HttpApi, HttpTracker, UdpTracker};
 
@@ -23,6 +24,7 @@ pub struct AppContainer {
     pub scrape_handler: Arc<ScrapeHandler>,
     pub keys_handler: Arc<KeysHandler>,
     pub authentication_service: Arc<AuthenticationService>,
+    pub in_memory_whitelist: Arc<InMemoryWhitelist>,
     pub whitelist_authorization: Arc<whitelist::authorization::WhitelistAuthorization>,
     pub ban_service: Arc<RwLock<BanService>>,
     pub http_stats_event_sender: Arc<Option<Box<dyn http_tracker_core::statistics::event::sender::Sender>>>,

tests/servers/api/environment.rs

@@ -4,6 +4,7 @@ use std::sync::Arc;
 use bittorrent_primitives::info_hash::InfoHash;
 use bittorrent_tracker_core::authentication::service::AuthenticationService;
 use bittorrent_tracker_core::databases::Database;
+use bittorrent_tracker_core::whitelist::repository::in_memory::InMemoryWhitelist;
 use futures::executor::block_on;
 use torrust_tracker_api_client::connection_info::{ConnectionInfo, Origin};
 use torrust_tracker_configuration::Configuration;
@@ -22,6 +23,7 @@ where
 
     pub database: Arc<Box<dyn Database>>,
     pub authentication_service: Arc<AuthenticationService>,
+    pub in_memory_whitelist: Arc<InMemoryWhitelist>,
 
     pub registar: Registar,
     pub server: ApiServer<S>,
@@ -70,6 +72,7 @@ impl Environment<Stopped> {
 
             database: app_container.database.clone(),
             authentication_service: app_container.authentication_service.clone(),
+            in_memory_whitelist: app_container.in_memory_whitelist.clone(),
 
             registar: Registar::default(),
             server,
@@ -84,6 +87,7 @@ impl Environment<Stopped> {
 
             database: self.database.clone(),
             authentication_service: self.authentication_service.clone(),
+            in_memory_whitelist: self.in_memory_whitelist.clone(),
 
             registar: self.registar.clone(),
             server: self
@@ -106,6 +110,7 @@ impl Environment<Running> {
 
             database: self.database,
             authentication_service: self.authentication_service,
+            in_memory_whitelist: self.in_memory_whitelist,
 
             registar: Registar::default(),
             server: self.server.stop().await.unwrap(),

tests/servers/api/v1/contract/context/whitelist.rs

@@ -31,9 +31,8 @@ async fn should_allow_whitelisting_a_torrent() {
 
     assert_ok(response).await;
     assert!(
-        env.http_api_container
-            .whitelist_manager
-            .is_info_hash_whitelisted(&InfoHash::from_str(&info_hash).unwrap())
+        env.in_memory_whitelist
+            .contains(&InfoHash::from_str(&info_hash).unwrap())
             .await
     );
 
@@ -181,12 +180,7 @@ async fn should_allow_removing_a_torrent_from_the_whitelist() {
         .await;
 
     assert_ok(response).await;
-    assert!(
-        !env.http_api_container
-            .whitelist_manager
-            .is_info_hash_whitelisted(&info_hash)
-            .await
-    );
+    assert!(!env.in_memory_whitelist.contains(&info_hash).await);
 
     env.stop().await;
 }