test(tracker): [#207] add tests for whitelist in Tracker

Author: josecelano

src/apis/handlers.rs

@@ -86,7 +86,7 @@ pub async fn remove_torrent_from_whitelist_handler(
 }
 
 pub async fn reload_whitelist_handler(State(tracker): State<Arc<Tracker>>) -> Response {
-    match tracker.load_whitelist().await {
+    match tracker.load_whitelist_from_database().await {
         Ok(_) => ok_response(),
         Err(e) => failed_to_reload_whitelist_response(e),
     }
@@ -117,7 +117,7 @@ pub async fn delete_auth_key_handler(
 }
 
 pub async fn reload_keys_handler(State(tracker): State<Arc<Tracker>>) -> Response {
-    match tracker.load_keys().await {
+    match tracker.load_keys_from_database().await {
         Ok(_) => ok_response(),
         Err(e) => failed_to_reload_keys_response(e),
     }

src/setup.rs

@@ -16,13 +16,16 @@ pub async fn setup(config: &Configuration, tracker: Arc<tracker::Tracker>) -> Ve
 
     // Load peer keys
     if tracker.is_private() {
-        tracker.load_keys().await.expect("Could not retrieve keys from database.");
+        tracker
+            .load_keys_from_database()
+            .await
+            .expect("Could not retrieve keys from database.");
     }
 
     // Load whitelisted torrents
     if tracker.is_whitelisted() {
         tracker
-            .load_whitelist()
+            .load_whitelist_from_database()
             .await
             .expect("Could not load whitelist from database.");
     }

src/tracker/mod.rs

@@ -38,6 +38,9 @@ pub struct Tracker {
 
 #[derive(Debug, PartialEq, Default)]
 pub struct TorrentsMetrics {
+    // code-review: consider using `SwamStats` for
+    // `seeders`, `completed`, and `leechers` attributes.
+    // pub swam_stats: SwamStats;
     pub seeders: u64,
     pub completed: u64,
     pub leechers: u64,
@@ -223,7 +226,7 @@ impl Tracker {
     /// # Errors
     ///
     /// Will return a `database::Error` if unable to `load_keys` from the database.
-    pub async fn load_keys(&self) -> Result<(), databases::error::Error> {
+    pub async fn load_keys_from_database(&self) -> Result<(), databases::error::Error> {
         let keys_from_database = self.database.load_keys().await?;
         let mut keys = self.keys.write().await;
 
@@ -301,7 +304,7 @@ impl Tracker {
     /// # Errors
     ///
     /// Will return a `database::Error` if unable to load the list whitelisted `info_hash`s from the database.
-    pub async fn load_whitelist(&self) -> Result<(), databases::error::Error> {
+    pub async fn load_whitelist_from_database(&self) -> Result<(), databases::error::Error> {
         let whitelisted_torrents_from_database = self.database.load_whitelist().await?;
         let mut whitelist = self.whitelist.write().await;
 
@@ -402,7 +405,7 @@ impl Tracker {
     /// # Errors
     ///
     /// Will return a `database::Error` if unable to load the list of `persistent_torrents` from the database.
-    pub async fn load_persistent_torrents(&self) -> Result<(), databases::error::Error> {
+    pub async fn load_torrents_from_database(&self) -> Result<(), databases::error::Error> {
         let persistent_torrents = self.database.load_persistent_torrents().await?;
 
         let mut torrents = self.torrents.write().await;
@@ -700,6 +703,55 @@ mod tests {
             );
         }
 
+        #[tokio::test]
+        async fn it_should_return_all_the_peers_for_a_given_torrent() {
+            let tracker = public_tracker();
+
+            let info_hash = sample_info_hash();
+            let peer = sample_peer();
+
+            tracker.update_torrent_with_peer_and_get_stats(&info_hash, &peer).await;
+
+            let peers = tracker.get_all_torrent_peers(&info_hash).await;
+
+            assert_eq!(peers, vec![peer]);
+        }
+
+        #[tokio::test]
+        async fn it_should_return_all_the_peers_for_a_given_torrent_excluding_a_given_peer() {
+            let tracker = public_tracker();
+
+            let info_hash = sample_info_hash();
+            let peer = sample_peer();
+
+            tracker.update_torrent_with_peer_and_get_stats(&info_hash, &peer).await;
+
+            let peers = tracker.get_peers_for_peer(&info_hash, &peer).await;
+
+            assert_eq!(peers, vec![]);
+        }
+
+        #[tokio::test]
+        async fn it_should_return_the_torrent_metrics() {
+            let tracker = public_tracker();
+
+            tracker
+                .update_torrent_with_peer_and_get_stats(&sample_info_hash(), &leecher())
+                .await;
+
+            let torrent_metrics = tracker.get_torrents_metrics().await;
+
+            assert_eq!(
+                torrent_metrics,
+                TorrentsMetrics {
+                    seeders: 0,
+                    completed: 0,
+                    leechers: 1,
+                    torrents: 1,
+                }
+            );
+        }
+
         mod for_all_config_modes {
 
             mod handling_an_announce_request {
@@ -984,6 +1036,55 @@ mod tests {
                 }
             }
 
+            mod handling_the_torrent_whitelist {
+                use crate::tracker::tests::the_tracker::{sample_info_hash, whitelisted_tracker};
+
+                #[tokio::test]
+                async fn it_should_add_a_torrent_to_the_whitelist() {
+                    let tracker = whitelisted_tracker();
+
+                    let info_hash = sample_info_hash();
+
+                    tracker.add_torrent_to_whitelist(&info_hash).await.unwrap();
+
+                    assert!(tracker.is_info_hash_whitelisted(&info_hash).await);
+                }
+
+                #[tokio::test]
+                async fn it_should_remove_a_torrent_from_the_whitelist() {
+                    let tracker = whitelisted_tracker();
+
+                    let info_hash = sample_info_hash();
+
+                    tracker.add_torrent_to_whitelist(&info_hash).await.unwrap();
+
+                    tracker.remove_torrent_from_whitelist(&info_hash).await.unwrap();
+
+                    assert!(!tracker.is_info_hash_whitelisted(&info_hash).await);
+                }
+
+                mod persistence {
+                    use crate::tracker::tests::the_tracker::{sample_info_hash, whitelisted_tracker};
+
+                    #[tokio::test]
+                    async fn it_should_load_the_whitelist_from_the_database() {
+                        let tracker = whitelisted_tracker();
+
+                        let info_hash = sample_info_hash();
+
+                        tracker.add_torrent_to_whitelist(&info_hash).await.unwrap();
+
+                        // Remove torrent from the in-memory whitelist
+                        tracker.whitelist.write().await.remove(&info_hash);
+                        assert!(!tracker.is_info_hash_whitelisted(&info_hash).await);
+
+                        tracker.load_whitelist_from_database().await.unwrap();
+
+                        assert!(tracker.is_info_hash_whitelisted(&info_hash).await);
+                    }
+                }
+            }
+
             mod handling_an_announce_request {}
 
             mod handling_an_scrape_request {
@@ -1112,7 +1213,7 @@ mod tests {
                     // Remove the newly generated key in memory
                     tracker.keys.write().await.remove(&key.id());
 
-                    let result = tracker.load_keys().await;
+                    let result = tracker.load_keys_from_database().await;
 
                     assert!(result.is_ok());
                     assert!(tracker.verify_auth_key(&key.id()).await.is_ok());
@@ -1152,13 +1253,10 @@ mod tests {
                 let swarm_stats = tracker.update_torrent_with_peer_and_get_stats(&info_hash, &peer).await;
                 assert_eq!(swarm_stats.completed, 1);
 
-                let torrents = tracker.get_all_torrent_peers(&info_hash).await;
-                assert_eq!(torrents.len(), 1);
-
                 // Remove the newly updated torrent from memory
                 tracker.torrents.write().await.remove(&info_hash);
 
-                tracker.load_persistent_torrents().await.unwrap();
+                tracker.load_torrents_from_database().await.unwrap();
 
                 let torrents = tracker.get_torrents().await;
                 assert!(torrents.contains_key(&info_hash));

src/tracker/torrent.rs

@@ -14,6 +14,7 @@ pub struct Entry {
     pub completed: u32,
 }
 
+/// Swarm statistics for one torrent.
 /// Swarm metadata dictionary in the scrape response.
 /// BEP 48: <https://www.bittorrent.org/beps/bep_0048.html>
 #[derive(Debug, PartialEq, Default)]
@@ -30,7 +31,8 @@ impl SwarmMetadata {
     }
 }
 
-/// Swarm statistics. Alternative struct for swarm metadata in scrape response.
+/// Swarm statistics for one torrent. 
+/// Alternative struct for swarm metadata in scrape response.
 #[derive(Debug, PartialEq, Default)]
 pub struct SwamStats {
     pub completed: u32, // The number of peers that have ever completed downloading