refactor: [torrust#1495] renamings to follow latest changes in torrent-repository pkg

Author: josecelano

packages/torrent-repository/tests/integration.rs

@@ -7,8 +7,8 @@
 use torrust_tracker_clock::clock;
 
 pub mod common;
-mod entry;
-mod repository;
+mod swarm;
+mod swarms;
 
 /// This code needs to be copied into each crate.
 /// Working version, for production.

…es/torrent-repository/tests/entry/mod.rs …es/torrent-repository/tests/swarm/mod.rspackages/torrent-repository/tests/entry/mod.rs renamed to packages/torrent-repository/tests/swarm/mod.rs packages/torrent-repository/tests/entry/mod.rs renamed to packages/torrent-repository/tests/swarm/mod.rs

@@ -15,7 +15,7 @@ use crate::common::torrent_peer_builder::{a_completed_peer, a_started_peer};
 use crate::CurrentClock;
 
 #[fixture]
-fn single() -> Swarm {
+fn swarm() -> Swarm {
     Swarm::default()
 }
 
@@ -47,39 +47,39 @@ pub enum Makes {
     Three,
 }
 
-fn make(torrent: &mut Swarm, makes: &Makes) -> Vec<Peer> {
+fn make(swarm: &mut Swarm, makes: &Makes) -> Vec<Peer> {
     match makes {
         Makes::Empty => vec![],
         Makes::Started => {
             let peer = a_started_peer(1);
-            torrent.handle_announcement(&peer);
+            swarm.handle_announcement(&peer);
             vec![peer]
         }
         Makes::Completed => {
             let peer = a_completed_peer(2);
-            torrent.handle_announcement(&peer);
+            swarm.handle_announcement(&peer);
             vec![peer]
         }
         Makes::Downloaded => {
             let mut peer = a_started_peer(3);
-            torrent.handle_announcement(&peer);
+            swarm.handle_announcement(&peer);
             peer.event = AnnounceEvent::Completed;
             peer.left = NumberOfBytes::new(0);
-            torrent.handle_announcement(&peer);
+            swarm.handle_announcement(&peer);
             vec![peer]
         }
         Makes::Three => {
             let peer_1 = a_started_peer(1);
-            torrent.handle_announcement(&peer_1);
+            swarm.handle_announcement(&peer_1);
 
             let peer_2 = a_completed_peer(2);
-            torrent.handle_announcement(&peer_2);
+            swarm.handle_announcement(&peer_2);
 
             let mut peer_3 = a_started_peer(3);
-            torrent.handle_announcement(&peer_3);
+            swarm.handle_announcement(&peer_3);
             peer_3.event = AnnounceEvent::Completed;
             peer_3.left = NumberOfBytes::new(0);
-            torrent.handle_announcement(&peer_3);
+            swarm.handle_announcement(&peer_3);
             vec![peer_1, peer_2, peer_3]
         }
     }
@@ -88,10 +88,10 @@ fn make(torrent: &mut Swarm, makes: &Makes) -> Vec<Peer> {
 #[rstest]
 #[case::empty(&Makes::Empty)]
 #[tokio::test]
-async fn it_should_be_empty_by_default(#[values(single())] mut torrent: Swarm, #[case] makes: &Makes) {
-    make(&mut torrent, makes);
+async fn it_should_be_empty_by_default(#[values(swarm())] mut swarm: Swarm, #[case] makes: &Makes) {
+    make(&mut swarm, makes);
 
-    assert_eq!(torrent.len(), 0);
+    assert_eq!(swarm.len(), 0);
 }
 
 #[rstest]
@@ -102,33 +102,33 @@ async fn it_should_be_empty_by_default(#[values(single())] mut torrent: Swarm, #
 #[case::three(&Makes::Three)]
 #[tokio::test]
 async fn it_should_check_if_entry_should_be_retained_based_on_the_tracker_policy(
-    #[values(single())] mut torrent: Swarm,
+    #[values(swarm())] mut swarm: Swarm,
     #[case] makes: &Makes,
     #[values(policy_none(), policy_persist(), policy_remove(), policy_remove_persist())] policy: TrackerPolicy,
 ) {
-    make(&mut torrent, makes);
+    make(&mut swarm, makes);
 
-    let has_peers = !torrent.is_empty();
-    let has_downloads = torrent.metadata().downloaded != 0;
+    let has_peers = !swarm.is_empty();
+    let has_downloads = swarm.metadata().downloaded != 0;
 
     match (policy.remove_peerless_torrents, policy.persistent_torrent_completed_stat) {
         // remove torrents without peers, and keep completed download stats
         (true, true) => match (has_peers, has_downloads) {
             // no peers, but has downloads
             // peers, with or without downloads
-            (false, true) | (true, true | false) => assert!(torrent.meets_retaining_policy(&policy)),
+            (false, true) | (true, true | false) => assert!(swarm.meets_retaining_policy(&policy)),
             // no peers and no downloads
-            (false, false) => assert!(!torrent.meets_retaining_policy(&policy)),
+            (false, false) => assert!(!swarm.meets_retaining_policy(&policy)),
         },
         // remove torrents without peers and drop completed download stats
         (true, false) => match (has_peers, has_downloads) {
             // peers, with or without downloads
-            (true, true | false) => assert!(torrent.meets_retaining_policy(&policy)),
+            (true, true | false) => assert!(swarm.meets_retaining_policy(&policy)),
             // no peers and with or without downloads
-            (false, true | false) => assert!(!torrent.meets_retaining_policy(&policy)),
+            (false, true | false) => assert!(!swarm.meets_retaining_policy(&policy)),
         },
         // keep torrents without peers, but keep or drop completed download stats
-        (false, true | false) => assert!(torrent.meets_retaining_policy(&policy)),
+        (false, true | false) => assert!(swarm.meets_retaining_policy(&policy)),
     }
 }
 
@@ -139,10 +139,10 @@ async fn it_should_check_if_entry_should_be_retained_based_on_the_tracker_policy
 #[case::downloaded(&Makes::Downloaded)]
 #[case::three(&Makes::Three)]
 #[tokio::test]
-async fn it_should_get_peers_for_torrent_entry(#[values(single())] mut torrent: Swarm, #[case] makes: &Makes) {
-    let peers = make(&mut torrent, makes);
+async fn it_should_get_peers_for_torrent_entry(#[values(swarm())] mut swarm: Swarm, #[case] makes: &Makes) {
+    let peers = make(&mut swarm, makes);
 
-    let torrent_peers = torrent.peers(None);
+    let torrent_peers = swarm.peers(None);
 
     assert_eq!(torrent_peers.len(), peers.len());
 
@@ -158,15 +158,15 @@ async fn it_should_get_peers_for_torrent_entry(#[values(single())] mut torrent:
 #[case::downloaded(&Makes::Downloaded)]
 #[case::three(&Makes::Three)]
 #[tokio::test]
-async fn it_should_update_a_peer(#[values(single())] mut torrent: Swarm, #[case] makes: &Makes) {
-    make(&mut torrent, makes);
+async fn it_should_update_a_peer(#[values(swarm())] mut swarm: Swarm, #[case] makes: &Makes) {
+    make(&mut swarm, makes);
 
     // Make and insert a new peer.
     let mut peer = a_started_peer(-1);
-    torrent.handle_announcement(&peer);
+    swarm.handle_announcement(&peer);
 
     // Get the Inserted Peer by Id.
-    let peers = torrent.peers(None);
+    let peers = swarm.peers(None);
     let original = peers
         .iter()
         .find(|p| peer::ReadInfo::get_id(*p) == peer::ReadInfo::get_id(&peer))
@@ -176,10 +176,10 @@ async fn it_should_update_a_peer(#[values(single())] mut torrent: Swarm, #[case]
 
     // Announce "Completed" torrent download event.
     peer.event = AnnounceEvent::Completed;
-    torrent.handle_announcement(&peer);
+    swarm.handle_announcement(&peer);
 
     // Get the Updated Peer by Id.
-    let peers = torrent.peers(None);
+    let peers = swarm.peers(None);
     let updated = peers
         .iter()
         .find(|p| peer::ReadInfo::get_id(*p) == peer::ReadInfo::get_id(&peer))
@@ -195,17 +195,17 @@ async fn it_should_update_a_peer(#[values(single())] mut torrent: Swarm, #[case]
 #[case::downloaded(&Makes::Downloaded)]
 #[case::three(&Makes::Three)]
 #[tokio::test]
-async fn it_should_remove_a_peer_upon_stopped_announcement(#[values(single())] mut torrent: Swarm, #[case] makes: &Makes) {
+async fn it_should_remove_a_peer_upon_stopped_announcement(#[values(swarm())] mut swarm: Swarm, #[case] makes: &Makes) {
     use torrust_tracker_primitives::peer::ReadInfo as _;
 
-    make(&mut torrent, makes);
+    make(&mut swarm, makes);
 
     let mut peer = a_started_peer(-1);
 
-    torrent.handle_announcement(&peer);
+    swarm.handle_announcement(&peer);
 
     // The started peer should be inserted.
-    let peers = torrent.peers(None);
+    let peers = swarm.peers(None);
     let original = peers
         .iter()
         .find(|p| p.get_id() == peer.get_id())
@@ -215,10 +215,10 @@ async fn it_should_remove_a_peer_upon_stopped_announcement(#[values(single())] m
 
     // Change peer to "Stopped" and insert.
     peer.event = AnnounceEvent::Stopped;
-    torrent.handle_announcement(&peer);
+    swarm.handle_announcement(&peer);
 
     // It should be removed now.
-    let peers = torrent.peers(None);
+    let peers = swarm.peers(None);
 
     assert_eq!(
         peers.iter().find(|p| p.get_id() == peer.get_id()),
@@ -234,7 +234,7 @@ async fn it_should_remove_a_peer_upon_stopped_announcement(#[values(single())] m
 #[case::three(&Makes::Three)]
 #[tokio::test]
 async fn it_should_handle_a_peer_completed_announcement_and_update_the_downloaded_statistic(
-    #[values(single())] mut torrent: Swarm,
+    #[values(swarm())] mut torrent: Swarm,
     #[case] makes: &Makes,
 ) {
     make(&mut torrent, makes);
@@ -264,19 +264,19 @@ async fn it_should_handle_a_peer_completed_announcement_and_update_the_downloade
 #[case::downloaded(&Makes::Downloaded)]
 #[case::three(&Makes::Three)]
 #[tokio::test]
-async fn it_should_update_a_peer_as_a_seeder(#[values(single())] mut torrent: Swarm, #[case] makes: &Makes) {
-    let peers = make(&mut torrent, makes);
+async fn it_should_update_a_peer_as_a_seeder(#[values(swarm())] mut swarm: Swarm, #[case] makes: &Makes) {
+    let peers = make(&mut swarm, makes);
     let completed = u32::try_from(peers.iter().filter(|p| p.is_seeder()).count()).expect("it_should_not_be_so_many");
 
-    let peers = torrent.peers(None);
+    let peers = swarm.peers(None);
     let mut peer = **peers.first().expect("there should be a peer");
 
     let is_already_non_left = peer.left == NumberOfBytes::new(0);
 
     // Set Bytes Left to Zero
     peer.left = NumberOfBytes::new(0);
-    torrent.handle_announcement(&peer);
-    let stats = torrent.metadata();
+    swarm.handle_announcement(&peer);
+    let stats = swarm.metadata();
 
     if is_already_non_left {
         // it was already complete
@@ -293,19 +293,19 @@ async fn it_should_update_a_peer_as_a_seeder(#[values(single())] mut torrent: Sw
 #[case::downloaded(&Makes::Downloaded)]
 #[case::three(&Makes::Three)]
 #[tokio::test]
-async fn it_should_update_a_peer_as_incomplete(#[values(single())] mut torrent: Swarm, #[case] makes: &Makes) {
-    let peers = make(&mut torrent, makes);
+async fn it_should_update_a_peer_as_incomplete(#[values(swarm())] mut swarm: Swarm, #[case] makes: &Makes) {
+    let peers = make(&mut swarm, makes);
     let incomplete = u32::try_from(peers.iter().filter(|p| !p.is_seeder()).count()).expect("it should not be so many");
 
-    let peers = torrent.peers(None);
+    let peers = swarm.peers(None);
     let mut peer = **peers.first().expect("there should be a peer");
 
     let completed_already = peer.left == NumberOfBytes::new(0);
 
     // Set Bytes Left to no Zero
     peer.left = NumberOfBytes::new(1);
-    torrent.handle_announcement(&peer);
-    let stats = torrent.metadata();
+    swarm.handle_announcement(&peer);
+    let stats = swarm.metadata();
 
     if completed_already {
         // now it is incomplete
@@ -322,10 +322,10 @@ async fn it_should_update_a_peer_as_incomplete(#[values(single())] mut torrent:
 #[case::downloaded(&Makes::Downloaded)]
 #[case::three(&Makes::Three)]
 #[tokio::test]
-async fn it_should_get_peers_excluding_the_client_socket(#[values(single())] mut torrent: Swarm, #[case] makes: &Makes) {
-    make(&mut torrent, makes);
+async fn it_should_get_peers_excluding_the_client_socket(#[values(swarm())] mut swarm: Swarm, #[case] makes: &Makes) {
+    make(&mut swarm, makes);
 
-    let peers = torrent.peers(None);
+    let peers = swarm.peers(None);
     let mut peer = **peers.first().expect("there should be a peer");
 
     let socket = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8081);
@@ -334,14 +334,14 @@ async fn it_should_get_peers_excluding_the_client_socket(#[values(single())] mut
     assert_ne!(peer.peer_addr, socket);
 
     // it should get the peer as it dose not share the socket.
-    assert!(torrent.peers_excluding(&socket, None).contains(&peer.into()));
+    assert!(swarm.peers_excluding(&socket, None).contains(&peer.into()));
 
     // set the address to the socket.
     peer.peer_addr = socket;
-    torrent.handle_announcement(&peer); // Add peer
+    swarm.handle_announcement(&peer); // Add peer
 
     // It should not include the peer that has the same socket.
-    assert!(!torrent.peers_excluding(&socket, None).contains(&peer.into()));
+    assert!(!swarm.peers_excluding(&socket, None).contains(&peer.into()));
 }
 
 #[rstest]
@@ -351,16 +351,16 @@ async fn it_should_get_peers_excluding_the_client_socket(#[values(single())] mut
 #[case::downloaded(&Makes::Downloaded)]
 #[case::three(&Makes::Three)]
 #[tokio::test]
-async fn it_should_limit_the_number_of_peers_returned(#[values(single())] mut torrent: Swarm, #[case] makes: &Makes) {
-    make(&mut torrent, makes);
+async fn it_should_limit_the_number_of_peers_returned(#[values(swarm())] mut swarm: Swarm, #[case] makes: &Makes) {
+    make(&mut swarm, makes);
 
     // We add one more peer than the scrape limit
     for peer_number in 1..=74 + 1 {
         let peer = a_started_peer(peer_number);
-        torrent.handle_announcement(&peer);
+        swarm.handle_announcement(&peer);
     }
 
-    let peers = torrent.peers(Some(TORRENT_PEERS_LIMIT));
+    let peers = swarm.peers(Some(TORRENT_PEERS_LIMIT));
 
     assert_eq!(peers.len(), 74);
 }
@@ -372,11 +372,11 @@ async fn it_should_limit_the_number_of_peers_returned(#[values(single())] mut to
 #[case::downloaded(&Makes::Downloaded)]
 #[case::three(&Makes::Three)]
 #[tokio::test]
-async fn it_should_remove_inactive_peers_beyond_cutoff(#[values(single())] mut torrent: Swarm, #[case] makes: &Makes) {
+async fn it_should_remove_inactive_peers_beyond_cutoff(#[values(swarm())] mut swarm: Swarm, #[case] makes: &Makes) {
     const TIMEOUT: Duration = Duration::from_secs(120);
     const EXPIRE: Duration = Duration::from_secs(121);
 
-    let peers = make(&mut torrent, makes);
+    let peers = make(&mut swarm, makes);
 
     let mut peer = a_completed_peer(-1);
 
@@ -385,12 +385,12 @@ async fn it_should_remove_inactive_peers_beyond_cutoff(#[values(single())] mut t
 
     peer.updated = now.sub(EXPIRE);
 
-    torrent.handle_announcement(&peer);
+    swarm.handle_announcement(&peer);
 
-    assert_eq!(torrent.len(), peers.len() + 1);
+    assert_eq!(swarm.len(), peers.len() + 1);
 
     let current_cutoff = CurrentClock::now_sub(&TIMEOUT).unwrap_or_default();
-    torrent.remove_inactive(current_cutoff);
+    swarm.remove_inactive(current_cutoff);
 
-    assert_eq!(torrent.len(), peers.len());
+    assert_eq!(swarm.len(), peers.len());
 }