feat(qbittorrent-e2e): verify tracker swarm participation via REST API after transfer

Author: josecelano

Cargo.toml

@@ -58,6 +58,7 @@ torrust-axum-health-check-api-server = { version = "3.0.0-develop", path = "pack
 torrust-axum-http-tracker-server = { version = "3.0.0-develop", path = "packages/axum-http-tracker-server" }
 torrust-axum-rest-tracker-api-server = { version = "3.0.0-develop", path = "packages/axum-rest-tracker-api-server" }
 torrust-axum-server = { version = "3.0.0-develop", path = "packages/axum-server" }
+torrust-rest-tracker-api-client = { version = "3.0.0-develop", path = "packages/rest-tracker-api-client" }
 torrust-rest-tracker-api-core = { version = "3.0.0-develop", path = "packages/rest-tracker-api-core" }
 torrust-server-lib = { version = "3.0.0-develop", path = "packages/server-lib" }
 torrust-tracker-clock = { version = "3.0.0-develop", path = "packages/clock" }
@@ -72,7 +73,6 @@ bittorrent-primitives = "0.1.0"
 bittorrent-tracker-client = { version = "3.0.0-develop", path = "packages/tracker-client" }
 local-ip-address = "0"
 mockall = "0"
-torrust-rest-tracker-api-client = { version = "3.0.0-develop", path = "packages/rest-tracker-api-client" }
 torrust-tracker-test-helpers = { version = "3.0.0-develop", path = "packages/test-helpers" }
 
 [workspace]

compose.qbittorrent-e2e.yaml

@@ -19,6 +19,7 @@ services:
     ports:
       - "0:${QBT_E2E_TRACKER_HTTP_TRACKER_PORT:?QBT_E2E_TRACKER_HTTP_TRACKER_PORT is required}"
       - "0:${QBT_E2E_TRACKER_UDP_PORT:?QBT_E2E_TRACKER_UDP_PORT is required}/udp"
+      - "0:${QBT_E2E_TRACKER_HTTP_API_PORT:?QBT_E2E_TRACKER_HTTP_API_PORT is required}"
       - "0:${QBT_E2E_TRACKER_HEALTH_CHECK_API_PORT:?QBT_E2E_TRACKER_HEALTH_CHECK_API_PORT is required}"
 
   qbittorrent-seeder:

src/console/ci/qbittorrent_e2e/runner.rs

@@ -68,7 +68,7 @@ pub async fn run() -> anyhow::Result<()> {
     let tracker_image = TrackerImage::new(&args.tracker_image);
     let qbittorrent_image = QbittorrentImage::new(&args.qbittorrent_image);
 
-    let (mut running_compose, seeder, leecher) = services_setup::start(
+    let (mut running_compose, seeder, leecher, tracker) = services_setup::start(
         &args.compose_file,
         &project_name,
         &tracker_image,
@@ -78,7 +78,7 @@ pub async fn run() -> anyhow::Result<()> {
     )
     .await?;
 
-    scenarios::seeder_to_leecher_transfer::run(&seeder, &leecher, resources).await?;
+    scenarios::seeder_to_leecher_transfer::run(&seeder, &leecher, &tracker, resources).await?;
 
     // POST-SCENARIO: optionally keep containers for debugging.
     if args.keep_containers {

src/console/ci/qbittorrent_e2e/scenario_steps/mod.rs

@@ -9,11 +9,13 @@
 
 mod fixtures;
 mod qbittorrent;
+mod tracker;
 mod verify_payload_integrity;
 
 pub(super) use fixtures::{build_payload_fixture, build_torrent_fixture};
 pub(super) use qbittorrent::{
     add_torrent_file_to_client, ensure_torrent_is_absent, login_client, wait_until_download_completes,
     wait_until_torrent_appears_in_client,
 };
+pub(super) use tracker::verify_tracker_swarm;
 pub(super) use verify_payload_integrity::verify_payload_integrity;

src/console/ci/qbittorrent_e2e/scenario_steps/tracker/mod.rs

@@ -0,0 +1,7 @@
+//! Tracker API verification steps for E2E scenarios.
+//!
+//! Each file contains one explicit step so available actions are discoverable in the IDE tree.
+
+mod verify_tracker_swarm;
+
+pub(in super::super) use verify_tracker_swarm::verify_tracker_swarm;

src/console/ci/qbittorrent_e2e/scenario_steps/tracker/verify_tracker_swarm.rs

@@ -0,0 +1,47 @@
+use anyhow::Context;
+use torrust_axum_rest_tracker_api_server::v1::context::torrent::resources::torrent::Torrent;
+
+use super::super::super::tracker::TrackerApiClient;
+use super::super::super::types::InfoHash;
+
+/// Queries the tracker REST API and asserts that the torrent shows at least one
+/// seeder and at least one completed transfer.
+///
+/// This confirms that:
+/// - the seeder announced itself to the tracker (`seeders >= 1`)
+/// - the leecher sent a `completed` event after finishing the download (`completed >= 1`)
+///
+/// # Errors
+///
+/// Returns an error if the API request fails or either assertion does not hold.
+pub async fn verify_tracker_swarm(client: &TrackerApiClient, hash: &InfoHash) -> anyhow::Result<()> {
+    let torrent: Torrent = client
+        .get_torrent(hash)
+        .await
+        .with_context(|| format!("failed to query tracker swarm for torrent {hash}"))?;
+
+    tracing::info!(
+        "Tracker swarm for {hash}: seeders={}, completed={}, leechers={}",
+        torrent.seeders,
+        torrent.completed,
+        torrent.leechers
+    );
+
+    anyhow::ensure!(
+        torrent.seeders >= 1,
+        "expected at least 1 seeder in tracker for torrent {hash}, got {} \
+         — seeder did not announce to the tracker",
+        torrent.seeders
+    );
+
+    anyhow::ensure!(
+        torrent.completed >= 1,
+        "expected at least 1 completed transfer in tracker for torrent {hash}, got {} \
+         — leecher did not send a completed event",
+        torrent.completed
+    );
+
+    tracing::info!("Tracker swarm verification passed for {hash}");
+
+    Ok(())
+}

src/console/ci/qbittorrent_e2e/scenarios/seeder_to_leecher_transfer.rs

@@ -8,9 +8,10 @@ use anyhow::Context;
 
 use super::super::qbittorrent::QbittorrentClient;
 use super::super::scenario_steps::{
-    add_torrent_file_to_client, ensure_torrent_is_absent, login_client, verify_payload_integrity, wait_until_download_completes,
-    wait_until_torrent_appears_in_client,
+    add_torrent_file_to_client, ensure_torrent_is_absent, login_client, verify_payload_integrity, verify_tracker_swarm,
+    wait_until_download_completes, wait_until_torrent_appears_in_client,
 };
+use super::super::tracker::TrackerApiClient;
 use super::super::workspace::WorkspaceResources;
 
 /// Runs the seeder-to-leecher transfer scenario.
@@ -21,6 +22,7 @@ use super::super::workspace::WorkspaceResources;
 pub(crate) async fn run(
     seeder: &QbittorrentClient,
     leecher: &QbittorrentClient,
+    tracker: &TrackerApiClient,
     workspace: &WorkspaceResources,
 ) -> anyhow::Result<()> {
     let info_hash = workspace.shared.torrent.info_hash.clone();
@@ -123,5 +125,11 @@ pub(crate) async fn run(
     )
     .context("downloaded payload does not match the original")?;
 
+    // ASSERT: tracker registered both peers (seeder announced; leecher completed).
+
+    verify_tracker_swarm(tracker, &info_hash)
+        .await
+        .context("tracker swarm verification failed")?;
+
     Ok(())
 }

src/console/ci/qbittorrent_e2e/services_setup.rs

@@ -11,7 +11,7 @@ use anyhow::Context;
 
 use super::client_role::ClientRole;
 use super::qbittorrent::QbittorrentClient;
-use super::tracker::TrackerConfig;
+use super::tracker::{TrackerApiClient, TrackerConfig};
 use super::types::{ComposeProjectName, QbittorrentImage, TrackerImage};
 use super::workspace::WorkspaceResources;
 use crate::console::ci::compose::{DockerCompose, RunningCompose};
@@ -33,7 +33,7 @@ pub(crate) async fn start(
     qbittorrent_image: &QbittorrentImage,
     resources: &WorkspaceResources,
     tracker_config: &TrackerConfig,
-) -> anyhow::Result<(RunningCompose, QbittorrentClient, QbittorrentClient)> {
+) -> anyhow::Result<(RunningCompose, QbittorrentClient, QbittorrentClient, TrackerApiClient)> {
     let compose = configure_compose(
         compose_file,
         project_name,
@@ -44,8 +44,10 @@ pub(crate) async fn start(
     )?;
     compose.build().context("failed to build local tracker image")?;
     let running_compose = compose.up().context("failed to start qBittorrent compose stack")?;
-    let (seeder, leecher) = build_clients(&compose, resources.timing.polling_deadline.as_duration()).await?;
-    Ok((running_compose, seeder, leecher))
+    let timeout = resources.timing.polling_deadline.as_duration();
+    let (seeder, leecher) = build_clients(&compose, timeout).await?;
+    let tracker = build_tracker_api_client(&compose, tracker_config, timeout).await?;
+    Ok((running_compose, seeder, leecher, tracker))
 }
 
 async fn build_clients(compose: &DockerCompose, timeout: Duration) -> anyhow::Result<(QbittorrentClient, QbittorrentClient)> {
@@ -54,6 +56,22 @@ async fn build_clients(compose: &DockerCompose, timeout: Duration) -> anyhow::Re
     Ok((seeder, leecher))
 }
 
+async fn build_tracker_api_client(
+    compose: &DockerCompose,
+    tracker_config: &TrackerConfig,
+    timeout: Duration,
+) -> anyhow::Result<TrackerApiClient> {
+    let container_port = tracker_config.http_api_bind_address().port();
+    let host_port = compose
+        .wait_for_port_mapping("tracker", container_port, timeout, COMPOSE_PORT_POLL_INTERVAL, &[])
+        .await
+        .context("failed to resolve tracker REST API host port")?;
+
+    tracing::info!("Tracker REST API host port: {host_port}");
+
+    TrackerApiClient::new(host_port, tracker_config).context("failed to build tracker REST API client")
+}
+
 async fn build_seeder_client(compose: &DockerCompose, timeout: Duration) -> anyhow::Result<QbittorrentClient> {
     let port = wait_for_client_port(compose, ClientRole::Seeder, timeout).await?;
     build_client(ClientRole::Seeder, port, timeout)
@@ -98,13 +116,15 @@ fn configure_compose(
 ) -> anyhow::Result<DockerCompose> {
     let tracker_http_tracker_port = tracker_config.http_tracker_bind_address().port().to_string();
     let tracker_udp_port = tracker_config.udp_bind_address().port().to_string();
+    let tracker_http_api_port = tracker_config.http_api_bind_address().port().to_string();
     let tracker_health_check_api_port = tracker_config.health_check_api_bind_address().port().to_string();
 
     Ok(DockerCompose::new(compose_file, project_name.as_str())
         .with_env("QBT_E2E_TRACKER_IMAGE", tracker_image.as_str())
         .with_env("QBT_E2E_QBITTORRENT_IMAGE", qbittorrent_image.as_str())
         .with_env("QBT_E2E_TRACKER_HTTP_TRACKER_PORT", tracker_http_tracker_port.as_str())
         .with_env("QBT_E2E_TRACKER_UDP_PORT", tracker_udp_port.as_str())
+        .with_env("QBT_E2E_TRACKER_HTTP_API_PORT", tracker_http_api_port.as_str())
         .with_env(
             "QBT_E2E_TRACKER_HEALTH_CHECK_API_PORT",
             tracker_health_check_api_port.as_str(),

src/console/ci/qbittorrent_e2e/tracker/client.rs

@@ -0,0 +1,61 @@
+//! Tracker REST API client, scoped to E2E test needs.
+//!
+//! Wraps the official [`torrust_rest_tracker_api_client::v1::Client`] so that
+//! future scenario steps can call any REST API endpoint through the same client
+//! without having to reconstruct connection details each time.
+use anyhow::Context;
+use torrust_axum_rest_tracker_api_server::v1::context::torrent::resources::torrent::Torrent;
+use torrust_rest_tracker_api_client::connection_info::{ConnectionInfo, Origin};
+use torrust_rest_tracker_api_client::v1::client::Client;
+
+use super::super::types::InfoHash;
+use super::config_builder::TrackerConfig;
+
+/// Wrapper around the official Torrust Tracker REST API client.
+///
+/// Provides typed, high-level helpers for the endpoints used in E2E test scenarios.
+/// All other endpoints are still reachable through the inner [`Client`].
+pub(crate) struct TrackerApiClient {
+    inner: Client,
+}
+
+impl TrackerApiClient {
+    /// Creates a new client connected to the tracker REST API on the given host port.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the origin URL cannot be parsed or the HTTP client
+    /// cannot be built.
+    pub(crate) fn new(host_port: u16, tracker_config: &TrackerConfig) -> anyhow::Result<Self> {
+        let origin = Origin::new(&format!("http://127.0.0.1:{host_port}")) // DevSkim: ignore DS137138
+            .context("failed to parse tracker REST API origin")?;
+
+        let connection_info = ConnectionInfo::authenticated(origin, tracker_config.access_token());
+
+        let inner = Client::new(connection_info).context("failed to build tracker REST API client")?;
+
+        Ok(Self { inner })
+    }
+
+    /// Returns the full [`Torrent`] resource for the torrent identified by `hash`.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the HTTP request fails, the server returns a non-2xx
+    /// status, or the response body cannot be deserialized.
+    pub(crate) async fn get_torrent(&self, hash: &InfoHash) -> anyhow::Result<Torrent> {
+        let response = self.inner.get_torrent(hash.as_str(), None).await;
+
+        if !response.status().is_success() {
+            return Err(anyhow::anyhow!(
+                "tracker REST API returned status {} for torrent {hash}",
+                response.status()
+            ));
+        }
+
+        response
+            .json::<Torrent>()
+            .await
+            .with_context(|| format!("failed to deserialize tracker torrent response for {hash}"))
+    }
+}

src/console/ci/qbittorrent_e2e/tracker/config_builder.rs

@@ -52,6 +52,14 @@ impl TrackerConfig {
         self.health_check_api_bind_address
     }
 
+    pub(crate) fn http_api_bind_address(&self) -> SocketAddr {
+        self.http_api_bind_address
+    }
+
+    pub(crate) fn access_token(&self) -> &str {
+        &self.access_token
+    }
+
     pub(crate) fn announce_url_for_compose_service(&self) -> String {
         let announce_url = format!("http://tracker:{}/announce", self.http_tracker_bind_address.port()); // DevSkim: ignore DS137138