feat: support mikan rss links

crates/torrent/.gitignore

@@ -0,0 +1,17 @@
+**/config/local.yaml
+**/config/*.local.yaml
+
+# Generated by Cargo
+# will have compiled files and executables
+debug/
+target/
+
+# Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
+# More information here https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html
+Cargo.lock
+
+# These are backup files generated by rustfmt
+**/*.rs.bk
+
+# MSVC Windows builds of rustc generate these, which store debugging information
+*.pdb

crates/torrent/Cargo.toml

@@ -0,0 +1,38 @@
+[package]
+name = "torrent"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+[lib]
+name = "torrent"
+path = "src/lib.rs"
+
+[features]
+default = []
+testcontainers = []
+
+[dependencies]
+async-trait = "0.1.83"
+chrono = "0.4.39"
+eyre = "0.6.12"
+futures = "0.3.31"
+itertools = "0.13.0"
+lazy_static = "1.5.0"
+librqbit-core = "4"
+qbit-rs = { git = "https://github.com/lonelyhentxi/qbit.git", rev = "a2c70aa", features = [
+  "default",
+  "builder",
+] }
+regex = "1.11.1"
+serde = "1.0.216"
+thiserror = "2.0.9"
+tokio = "1.42.0"
+url = "2.5.4"
+quirks_path = { path = "../quirks-path" }
+reqwest = "0.12.11"
+bytes = "1.9.0"
+
+[dev-dependencies]
+testcontainers = { version = "0.23.1" }
+testcontainers-modules = { version = "0.11.4" }

crates/torrent/src/core.rs

@@ -0,0 +1,269 @@
+use bytes::Bytes;
+use itertools::Itertools;
+use lazy_static::lazy_static;
+use librqbit_core::{
+    magnet::Magnet,
+    torrent_metainfo::{torrent_from_bytes, TorrentMetaV1Owned},
+};
+use quirks_path::{Path, PathBuf};
+use regex::Regex;
+use reqwest::IntoUrl;
+use serde::{Deserialize, Serialize};
+use url::Url;
+
+use crate::{QbitTorrent, QbitTorrentContent, TorrentDownloadError};
+
+pub const BITTORRENT_MIME_TYPE: &str = "application/x-bittorrent";
+pub const MAGNET_SCHEMA: &str = "magnet";
+pub const DEFAULT_TORRENT_USER_AGENT: &str = "Wget/1.13.4 (linux-gnu)";
+
+async fn download_torrent_file<T: IntoUrl>(url: T) -> eyre::Result<Bytes> {
+    let request_client = reqwest::Client::builder()
+        .user_agent(DEFAULT_TORRENT_USER_AGENT)
+        .build()?;
+    let bytes = request_client.get(url).send().await?.bytes().await?;
+    Ok(bytes)
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum TorrentFilter {
+    All,
+    Downloading,
+    Completed,
+    Paused,
+    Active,
+    Inactive,
+    Resumed,
+    Stalled,
+    StalledUploading,
+    StalledDownloading,
+    Errored,
+}
+
+lazy_static! {
+    static ref TORRENT_HASH_RE: Regex = Regex::new(r"[a-fA-F0-9]{40}").unwrap();
+    static ref TORRENT_EXT_RE: Regex = Regex::new(r"\.torrent$").unwrap();
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum TorrentSource {
+    MagnetUrl {
+        url: Url,
+        hash: String,
+    },
+    TorrentUrl {
+        url: Url,
+        hash: String,
+    },
+    TorrentFile {
+        torrent: Vec<u8>,
+        hash: String,
+        name: Option<String>,
+    },
+}
+
+impl TorrentSource {
+    pub async fn parse(url: &str) -> eyre::Result<Self> {
+        let url = Url::parse(url)?;
+        let source = if url.scheme() == MAGNET_SCHEMA {
+            TorrentSource::from_magnet_url(url)?
+        } else if let Some(basename) = url
+            .clone()
+            .path_segments()
+            .and_then(|segments| segments.last())
+        {
+            if let (Some(match_hash), true) = (
+                TORRENT_HASH_RE.find(basename),
+                TORRENT_EXT_RE.is_match(basename),
+            ) {
+                TorrentSource::from_torrent_url(url, match_hash.as_str().to_string())?
+            } else {
+                let contents = download_torrent_file(url).await?;
+                TorrentSource::from_torrent_file(contents.to_vec(), Some(basename.to_string()))?
+            }
+        } else {
+            let contents = download_torrent_file(url).await?;
+            TorrentSource::from_torrent_file(contents.to_vec(), None)?
+        };
+        Ok(source)
+    }
+
+    pub fn from_torrent_file(file: Vec<u8>, name: Option<String>) -> eyre::Result<Self> {
+        let torrent: TorrentMetaV1Owned = torrent_from_bytes(&file)
+            .map_err(|_| TorrentDownloadError::InvalidTorrentFileFormat)?;
+        let hash = torrent.info_hash.as_string();
+        Ok(TorrentSource::TorrentFile {
+            torrent: file,
+            hash,
+            name,
+        })
+    }
+
+    pub fn from_magnet_url(url: Url) -> eyre::Result<Self> {
+        if url.scheme() != MAGNET_SCHEMA {
+            Err(TorrentDownloadError::InvalidUrlSchema {
+                found: url.scheme().to_string(),
+                expected: MAGNET_SCHEMA.to_string(),
+            }
+            .into())
+        } else {
+            let magnet = Magnet::parse(url.as_str()).map_err(|_| {
+                TorrentDownloadError::InvalidMagnetFormat {
+                    url: url.as_str().to_string(),
+                }
+            })?;
+
+            let hash = magnet
+                .as_id20()
+                .ok_or_else(|| TorrentDownloadError::InvalidMagnetFormat {
+                    url: url.as_str().to_string(),
+                })?
+                .as_string();
+            Ok(TorrentSource::MagnetUrl { url, hash })
+        }
+    }
+
+    pub fn from_torrent_url(url: Url, hash: String) -> eyre::Result<Self> {
+        Ok(TorrentSource::TorrentUrl { url, hash })
+    }
+
+    pub fn hash(&self) -> &str {
+        match self {
+            TorrentSource::MagnetUrl { hash, .. } => hash,
+            TorrentSource::TorrentUrl { hash, .. } => hash,
+            TorrentSource::TorrentFile { hash, .. } => hash,
+        }
+    }
+}
+
+pub trait TorrentContent {
+    fn get_name(&self) -> &str;
+
+    fn get_all_size(&self) -> u64;
+
+    fn get_progress(&self) -> f64;
+
+    fn get_curr_size(&self) -> u64;
+}
+
+impl TorrentContent for QbitTorrentContent {
+    fn get_name(&self) -> &str {
+        self.name.as_str()
+    }
+
+    fn get_all_size(&self) -> u64 {
+        self.size
+    }
+
+    fn get_progress(&self) -> f64 {
+        self.progress
+    }
+
+    fn get_curr_size(&self) -> u64 {
+        u64::clamp(
+            f64::round(self.get_all_size() as f64 * self.get_progress()) as u64,
+            0,
+            self.get_all_size(),
+        )
+    }
+}
+
+#[derive(Debug, Clone)]
+pub enum Torrent {
+    Qbit {
+        torrent: QbitTorrent,
+        contents: Vec<QbitTorrentContent>,
+    },
+}
+
+impl Torrent {
+    pub fn iter_files(&self) -> impl Iterator<Item = &dyn TorrentContent> {
+        match self {
+            Torrent::Qbit { contents, .. } => {
+                contents.iter().map(|item| item as &dyn TorrentContent)
+            }
+        }
+    }
+
+    pub fn get_name(&self) -> Option<&str> {
+        match self {
+            Torrent::Qbit { torrent, .. } => torrent.name.as_deref(),
+        }
+    }
+
+    pub fn get_hash(&self) -> Option<&str> {
+        match self {
+            Torrent::Qbit { torrent, .. } => torrent.hash.as_deref(),
+        }
+    }
+
+    pub fn get_save_path(&self) -> Option<&str> {
+        match self {
+            Torrent::Qbit { torrent, .. } => torrent.save_path.as_deref(),
+        }
+    }
+
+    pub fn get_content_path(&self) -> Option<&str> {
+        match self {
+            Torrent::Qbit { torrent, .. } => torrent.content_path.as_deref(),
+        }
+    }
+
+    pub fn get_tags(&self) -> Vec<&str> {
+        match self {
+            Torrent::Qbit { torrent, .. } => torrent.tags.as_deref().map_or_else(Vec::new, |s| {
+                s.split(',')
+                    .map(|s| s.trim())
+                    .filter(|s| !s.is_empty())
+                    .collect_vec()
+            }),
+        }
+    }
+
+    pub fn get_category(&self) -> Option<&str> {
+        match self {
+            Torrent::Qbit { torrent, .. } => torrent.category.as_deref(),
+        }
+    }
+}
+
+#[async_trait::async_trait]
+pub trait TorrentDownloader {
+    async fn get_torrents_info(
+        &self,
+        status_filter: TorrentFilter,
+        category: Option<String>,
+        tag: Option<String>,
+    ) -> eyre::Result<Vec<Torrent>>;
+
+    async fn add_torrents(
+        &self,
+        source: TorrentSource,
+        save_path: String,
+        category: Option<&str>,
+    ) -> eyre::Result<()>;
+
+    async fn delete_torrents(&self, hashes: Vec<String>) -> eyre::Result<()>;
+
+    async fn rename_torrent_file(
+        &self,
+        hash: &str,
+        old_path: &str,
+        new_path: &str,
+    ) -> eyre::Result<()>;
+
+    async fn move_torrents(&self, hashes: Vec<String>, new_path: &str) -> eyre::Result<()>;
+
+    async fn get_torrent_path(&self, hashes: String) -> eyre::Result<Option<String>>;
+
+    async fn check_connection(&self) -> eyre::Result<()>;
+
+    async fn set_torrents_category(&self, hashes: Vec<String>, category: &str) -> eyre::Result<()>;
+
+    async fn add_torrent_tags(&self, hashes: Vec<String>, tags: Vec<String>) -> eyre::Result<()>;
+
+    async fn add_category(&self, category: &str) -> eyre::Result<()>;
+
+    fn get_save_path(&self, sub_path: &Path) -> PathBuf;
+}

crates/torrent/src/error.rs

@@ -0,0 +1,26 @@
+use std::{borrow::Cow, time::Duration};
+
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub enum TorrentDownloadError {
+    #[error("Invalid mime (expected {expected:?}, got {found:?})")]
+    InvalidMime { expected: String, found: String },
+    #[error("Invalid url schema (expected {expected:?}, got {found:?})")]
+    InvalidUrlSchema { expected: String, found: String },
+    #[error("Invalid url parse: {0:?}")]
+    InvalidUrlParse(#[from] url::ParseError),
+    #[error("Invalid url format: {reason}")]
+    InvalidUrlFormat { reason: Cow<'static, str> },
+    #[error("QBit api error: {0:?}")]
+    QBitAPIError(#[from] qbit_rs::Error),
+    #[error("Timeout error ({action} timeouts out of {timeout:?})")]
+    TimeoutError {
+        action: Cow<'static, str>,
+        timeout: Duration,
+    },
+    #[error("Invalid torrent file format")]
+    InvalidTorrentFileFormat,
+    #[error("Invalid magnet file format (url = {url})")]
+    InvalidMagnetFormat { url: String },
+}

crates/torrent/src/lib.rs

@@ -0,0 +1,11 @@
+pub mod core;
+pub mod error;
+pub mod qbit;
+
+pub use core::{Torrent, TorrentContent, TorrentDownloader, TorrentFilter, TorrentSource};
+
+pub use error::TorrentDownloadError;
+pub use qbit::{
+    QBittorrentDownloader, QBittorrentDownloaderCreation, QbitTorrent, QbitTorrentContent,
+    QbitTorrentFile, QbitTorrentFilter, QbitTorrentSource,
+};

crates/torrent/src/qbit.rs

@@ -0,0 +1,631 @@
+use std::{
+    borrow::Cow, collections::HashSet, fmt::Debug, future::Future, sync::Arc, time::Duration,
+};
+
+use eyre::OptionExt;
+use futures::future::try_join_all;
+pub use qbit_rs::model::{
+    Torrent as QbitTorrent, TorrentContent as QbitTorrentContent, TorrentFile as QbitTorrentFile,
+    TorrentFilter as QbitTorrentFilter, TorrentSource as QbitTorrentSource,
+};
+use qbit_rs::{
+    model::{AddTorrentArg, Credential, GetTorrentListArg, NonEmptyStr, SyncData},
+    Qbit,
+};
+use quirks_path::{path_equals_as_file_url, Path, PathBuf};
+use tokio::time::sleep;
+use url::Url;
+
+use crate::{Torrent, TorrentDownloadError, TorrentDownloader, TorrentFilter, TorrentSource};
+
+impl From<TorrentSource> for QbitTorrentSource {
+    fn from(value: TorrentSource) -> Self {
+        match value {
+            TorrentSource::MagnetUrl { url, .. } => QbitTorrentSource::Urls {
+                urls: qbit_rs::model::Sep::from([url]),
+            },
+            TorrentSource::TorrentUrl { url, .. } => QbitTorrentSource::Urls {
+                urls: qbit_rs::model::Sep::from([url]),
+            },
+            TorrentSource::TorrentFile {
+                torrent: torrents,
+                name,
+                ..
+            } => QbitTorrentSource::TorrentFiles {
+                torrents: vec![QbitTorrentFile {
+                    filename: name.unwrap_or_default(),
+                    data: torrents,
+                }],
+            },
+        }
+    }
+}
+
+impl From<TorrentFilter> for QbitTorrentFilter {
+    fn from(val: TorrentFilter) -> Self {
+        match val {
+            TorrentFilter::All => QbitTorrentFilter::All,
+            TorrentFilter::Downloading => QbitTorrentFilter::Downloading,
+            TorrentFilter::Completed => QbitTorrentFilter::Completed,
+            TorrentFilter::Paused => QbitTorrentFilter::Paused,
+            TorrentFilter::Active => QbitTorrentFilter::Active,
+            TorrentFilter::Inactive => QbitTorrentFilter::Inactive,
+            TorrentFilter::Resumed => QbitTorrentFilter::Resumed,
+            TorrentFilter::Stalled => QbitTorrentFilter::Stalled,
+            TorrentFilter::StalledUploading => QbitTorrentFilter::StalledUploading,
+            TorrentFilter::StalledDownloading => QbitTorrentFilter::StalledDownloading,
+            TorrentFilter::Errored => QbitTorrentFilter::Errored,
+        }
+    }
+}
+
+pub struct QBittorrentDownloaderCreation {
+    pub endpoint: String,
+    pub username: String,
+    pub password: String,
+    pub save_path: String,
+    pub subscriber_id: i32,
+}
+
+pub struct QBittorrentDownloader {
+    pub subscriber_id: i32,
+    pub endpoint_url: Url,
+    pub client: Arc<Qbit>,
+    pub save_path: PathBuf,
+    pub wait_sync_timeout: Duration,
+}
+
+impl QBittorrentDownloader {
+    pub async fn from_creation(
+        creation: QBittorrentDownloaderCreation,
+    ) -> Result<Self, TorrentDownloadError> {
+        let endpoint_url =
+            Url::parse(&creation.endpoint).map_err(TorrentDownloadError::InvalidUrlParse)?;
+        let credential = Credential::new(creation.username, creation.password);
+        let client = Qbit::new(endpoint_url.clone(), credential);
+
+        client
+            .login(false)
+            .await
+            .map_err(TorrentDownloadError::QBitAPIError)?;
+
+        client.sync(None).await?.rid;
+
+        Ok(Self {
+            client: Arc::new(client),
+            endpoint_url,
+            subscriber_id: creation.subscriber_id,
+            save_path: creation.save_path.into(),
+            wait_sync_timeout: Duration::from_millis(10000),
+        })
+    }
+
+    pub async fn api_version(&self) -> eyre::Result<String> {
+        let result = self.client.get_webapi_version().await?;
+        Ok(result)
+    }
+
+    pub async fn wait_until<G, Fut, F, D, H, E>(
+        &self,
+        capture_fn: H,
+        fetch_data_fn: G,
+        mut stop_wait_fn: F,
+        timeout: Option<Duration>,
+    ) -> eyre::Result<()>
+    where
+        H: FnOnce() -> E,
+        G: Fn(Arc<Qbit>, E) -> Fut,
+        Fut: Future<Output = eyre::Result<D>>,
+        F: FnMut(D) -> bool,
+        E: Clone,
+    {
+        let mut next_wait_ms = 32u64;
+        let mut all_wait_ms = 0u64;
+        let timeout = timeout.unwrap_or(self.wait_sync_timeout);
+        let env = capture_fn();
+        loop {
+            sleep(Duration::from_millis(next_wait_ms)).await;
+            all_wait_ms += next_wait_ms;
+            if all_wait_ms >= timeout.as_millis() as u64 {
+                // full update
+                let sync_data = fetch_data_fn(self.client.clone(), env.clone()).await?;
+                if stop_wait_fn(sync_data) {
+                    break;
+                } else {
+                    return Err(TorrentDownloadError::TimeoutError {
+                        action: Cow::Borrowed("QBittorrentDownloader::wait_unit"),
+                        timeout,
+                    }
+                    .into());
+                }
+            }
+            let sync_data = fetch_data_fn(self.client.clone(), env.clone()).await?;
+            if stop_wait_fn(sync_data) {
+                break;
+            }
+            next_wait_ms *= 2;
+        }
+        Ok(())
+    }
+
+    pub async fn wait_torrents_until<F>(
+        &self,
+        arg: GetTorrentListArg,
+        stop_wait_fn: F,
+        timeout: Option<Duration>,
+    ) -> eyre::Result<()>
+    where
+        F: FnMut(Vec<QbitTorrent>) -> bool,
+    {
+        self.wait_until(
+            || arg,
+            async move |client: Arc<Qbit>,
+                        arg: GetTorrentListArg|
+                        -> eyre::Result<Vec<QbitTorrent>> {
+                let data = client.get_torrent_list(arg).await?;
+                Ok(data)
+            },
+            stop_wait_fn,
+            timeout,
+        )
+        .await
+    }
+
+    pub async fn wait_sync_until<F: FnMut(SyncData) -> bool>(
+        &self,
+        stop_wait_fn: F,
+        timeout: Option<Duration>,
+    ) -> eyre::Result<()> {
+        self.wait_until(
+            || (),
+            async move |client: Arc<Qbit>, _| -> eyre::Result<SyncData> {
+                let data = client.sync(None).await?;
+                Ok(data)
+            },
+            stop_wait_fn,
+            timeout,
+        )
+        .await
+    }
+
+    async fn wait_torrent_contents_until<F: FnMut(Vec<QbitTorrentContent>) -> bool>(
+        &self,
+        hash: &str,
+        stop_wait_fn: F,
+        timeout: Option<Duration>,
+    ) -> eyre::Result<()> {
+        self.wait_until(
+            || Arc::new(hash.to_string()),
+            async move |client: Arc<Qbit>,
+                        hash_arc: Arc<String>|
+                        -> eyre::Result<Vec<QbitTorrentContent>> {
+                let data = client.get_torrent_contents(hash_arc.as_str(), None).await?;
+                Ok(data)
+            },
+            stop_wait_fn,
+            timeout,
+        )
+        .await
+    }
+}
+
+#[async_trait::async_trait]
+impl TorrentDownloader for QBittorrentDownloader {
+    async fn get_torrents_info(
+        &self,
+        status_filter: TorrentFilter,
+        category: Option<String>,
+        tag: Option<String>,
+    ) -> eyre::Result<Vec<Torrent>> {
+        let arg = GetTorrentListArg {
+            filter: Some(status_filter.into()),
+            category,
+            tag,
+            ..Default::default()
+        };
+        let torrent_list = self.client.get_torrent_list(arg).await?;
+        let torrent_contents = try_join_all(torrent_list.iter().map(|s| async {
+            if let Some(hash) = &s.hash {
+                self.client.get_torrent_contents(hash as &str, None).await
+            } else {
+                Ok(vec![])
+            }
+        }))
+        .await?;
+        Ok(torrent_list
+            .into_iter()
+            .zip(torrent_contents)
+            .map(|(torrent, contents)| Torrent::Qbit { torrent, contents })
+            .collect::<Vec<_>>())
+    }
+
+    async fn add_torrents(
+        &self,
+        source: TorrentSource,
+        save_path: String,
+        category: Option<&str>,
+    ) -> eyre::Result<()> {
+        let arg = AddTorrentArg {
+            source: source.clone().into(),
+            savepath: Some(save_path),
+            category: category.map(String::from),
+            auto_torrent_management: Some(false),
+            ..Default::default()
+        };
+        let add_result = self.client.add_torrent(arg.clone()).await;
+        if let (
+            Err(qbit_rs::Error::ApiError(qbit_rs::ApiError::CategoryNotFound)),
+            Some(category),
+        ) = (&add_result, category)
+        {
+            self.add_category(category).await?;
+            self.client.add_torrent(arg).await?;
+        } else {
+            add_result?;
+        }
+        let source_hash = source.hash();
+        self.wait_sync_until(
+            |sync_data| {
+                sync_data
+                    .torrents
+                    .map_or(false, |t| t.contains_key(source_hash))
+            },
+            None,
+        )
+        .await?;
+        Ok(())
+    }
+
+    async fn delete_torrents(&self, hashes: Vec<String>) -> eyre::Result<()> {
+        self.client
+            .delete_torrents(hashes.clone(), Some(true))
+            .await?;
+        self.wait_torrents_until(
+            GetTorrentListArg::builder()
+                .hashes(hashes.join("|"))
+                .build(),
+            |torrents| -> bool { torrents.is_empty() },
+            None,
+        )
+        .await?;
+        Ok(())
+    }
+
+    async fn rename_torrent_file(
+        &self,
+        hash: &str,
+        old_path: &str,
+        new_path: &str,
+    ) -> eyre::Result<()> {
+        self.client.rename_file(hash, old_path, new_path).await?;
+        let new_path = self.save_path.join(new_path);
+        let save_path = self.save_path.as_path();
+        self.wait_torrent_contents_until(
+            hash,
+            |contents| -> bool {
+                contents.iter().any(|c| {
+                    path_equals_as_file_url(save_path.join(&c.name), &new_path).unwrap_or(false)
+                })
+            },
+            None,
+        )
+        .await?;
+        Ok(())
+    }
+
+    async fn move_torrents(&self, hashes: Vec<String>, new_path: &str) -> eyre::Result<()> {
+        self.client
+            .set_torrent_location(hashes.clone(), new_path)
+            .await?;
+        self.wait_torrents_until(
+            GetTorrentListArg::builder()
+                .hashes(hashes.join("|"))
+                .build(),
+            |torrents| -> bool {
+                torrents.iter().all(|t| {
+                    t.save_path.as_ref().map_or(false, |p| {
+                        path_equals_as_file_url(p, new_path).unwrap_or(false)
+                    })
+                })
+            },
+            None,
+        )
+        .await?;
+        Ok(())
+    }
+
+    async fn get_torrent_path(&self, hashes: String) -> eyre::Result<Option<String>> {
+        let mut torrent_list = self
+            .client
+            .get_torrent_list(GetTorrentListArg {
+                hashes: Some(hashes),
+                ..Default::default()
+            })
+            .await?;
+        let torrent = torrent_list.first_mut().ok_or_eyre("No torrent found")?;
+        Ok(torrent.save_path.take())
+    }
+
+    async fn check_connection(&self) -> eyre::Result<()> {
+        self.api_version().await?;
+        Ok(())
+    }
+
+    async fn set_torrents_category(&self, hashes: Vec<String>, category: &str) -> eyre::Result<()> {
+        let result = self
+            .client
+            .set_torrent_category(hashes.clone(), category)
+            .await;
+        if let Err(qbit_rs::Error::ApiError(qbit_rs::ApiError::CategoryNotFound)) = &result {
+            self.add_category(category).await?;
+            self.client
+                .set_torrent_category(hashes.clone(), category)
+                .await?;
+        } else {
+            result?;
+        }
+        self.wait_torrents_until(
+            GetTorrentListArg::builder()
+                .hashes(hashes.join("|"))
+                .build(),
+            |torrents| {
+                torrents
+                    .iter()
+                    .all(|t| t.category.as_ref().map_or(false, |c| c == category))
+            },
+            None,
+        )
+        .await?;
+        Ok(())
+    }
+
+    async fn add_torrent_tags(&self, hashes: Vec<String>, tags: Vec<String>) -> eyre::Result<()> {
+        if tags.is_empty() {
+            return Err(eyre::eyre!("add torrent tags can not be empty"));
+        }
+        self.client
+            .add_torrent_tags(hashes.clone(), tags.clone())
+            .await?;
+        let tag_sets = tags.iter().map(|s| s.as_str()).collect::<HashSet<&str>>();
+        self.wait_torrents_until(
+            GetTorrentListArg::builder()
+                .hashes(hashes.join("|"))
+                .build(),
+            |torrents| {
+                torrents.iter().all(|t| {
+                    t.tags.as_ref().map_or(false, |t| {
+                        t.split(',')
+                            .map(|s| s.trim())
+                            .filter(|s| !s.is_empty())
+                            .collect::<HashSet<&str>>()
+                            .is_superset(&tag_sets)
+                    })
+                })
+            },
+            None,
+        )
+        .await?;
+        Ok(())
+    }
+
+    async fn add_category(&self, category: &str) -> eyre::Result<()> {
+        self.client
+            .add_category(
+                NonEmptyStr::new(category).ok_or_eyre("category can not be empty")?,
+                self.save_path.as_str(),
+            )
+            .await?;
+        self.wait_sync_until(
+            |sync_data| {
+                sync_data
+                    .categories
+                    .map_or(false, |s| s.contains_key(category))
+            },
+            None,
+        )
+        .await?;
+
+        Ok(())
+    }
+
+    fn get_save_path(&self, sub_path: &Path) -> PathBuf {
+        self.save_path.join(sub_path)
+    }
+}
+
+impl Debug for QBittorrentDownloader {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("QBittorrentDownloader")
+            .field("subscriber_id", &self.subscriber_id)
+            .field("client", &self.endpoint_url.as_str())
+            .finish()
+    }
+}
+
+#[cfg(test)]
+pub mod tests {
+    use itertools::Itertools;
+
+    use super::*;
+
+    fn get_tmp_qbit_test_folder() -> &'static str {
+        if cfg!(windows) {
+            "C:\\Windows\\Temp\\konobangu\\qbit"
+        } else {
+            "/tmp/konobangu/qbit"
+        }
+    }
+
+    #[cfg(feature = "testcontainers")]
+    pub fn create_qbit_testcontainer() -> testcontainers::RunnableImage<testcontainers::GenericImage>
+    {
+        let image = testcontainers::RunnableImage::from(
+            testcontainers::GenericImage::new("linuxserver/qbittorrent", "latest")
+                .with_wait_for(testcontainers::core::WaitFor::message_on_stderr(
+                    "Connection to localhost",
+                ))
+                .with_env_var("WEBUI_PORT", "8080")
+                .with_env_var("TZ", "Asia/Singapore")
+                .with_env_var("TORRENTING_PORT", "6881")
+                .with_exposed_port(8080)
+                .with_exposed_port(6881),
+        );
+
+        image
+    }
+
+    #[cfg(not(feature = "testcontainers"))]
+    #[tokio::test]
+    async fn test_qbittorrent_downloader() {
+        test_qbittorrent_downloader_impl().await;
+    }
+
+    // @TODO: not support now, testcontainers crate not support to read logs to get
+    // password
+    #[cfg(feature = "testcontainers")]
+    #[tokio::test]
+    async fn test_qbittorrent_downloader() {
+        let docker = testcontainers::clients::Cli::default();
+        let image = create_qbit_testcontainer();
+
+        let _container = docker.run(image);
+
+        test_qbittorrent_downloader_impl().await;
+    }
+
+    async fn test_qbittorrent_downloader_impl() {
+        let base_save_path = Path::new(get_tmp_qbit_test_folder());
+
+        let downloader = QBittorrentDownloader::from_creation(QBittorrentDownloaderCreation {
+            endpoint: "http://localhost:8080".to_string(),
+            password: "".to_string(),
+            username: "".to_string(),
+            subscriber_id: 0,
+            save_path: base_save_path.to_string(),
+        })
+        .await
+        .unwrap();
+
+        downloader.check_connection().await.unwrap();
+
+        downloader
+            .delete_torrents(vec!["47ee2d69e7f19af783ad896541a07b012676f858".to_string()])
+            .await
+            .unwrap();
+
+        let torrent_source = TorrentSource::parse(
+          "https://mikanani.me/Download/20240301/47ee2d69e7f19af783ad896541a07b012676f858.torrent"
+      ).await.unwrap();
+
+        let save_path = base_save_path.join(format!(
+            "test_add_torrents_{}",
+            chrono::Utc::now().timestamp()
+        ));
+
+        downloader
+            .add_torrents(torrent_source, save_path.to_string(), Some("bangumi"))
+            .await
+            .unwrap();
+
+        let get_torrent = async || -> eyre::Result<Torrent> {
+            let torrent_infos = downloader
+                .get_torrents_info(TorrentFilter::All, None, None)
+                .await?;
+
+            let result = torrent_infos
+                .into_iter()
+                .find(|t| {
+                    t.get_hash()
+                        .map_or(false, |s| s == "47ee2d69e7f19af783ad896541a07b012676f858")
+                })
+                .ok_or_eyre("no torrent")?;
+
+            Ok(result)
+        };
+
+        let target_torrent = get_torrent().await.unwrap();
+
+        let files = target_torrent.iter_files().collect_vec();
+        assert!(!files.is_empty());
+
+        let first_file = files[0];
+        assert_eq!(
+            first_file.get_name(),
+            r#"[Nekomoe kissaten&LoliHouse] Boku no Kokoro no Yabai Yatsu - 20 [WebRip 1080p HEVC-10bit AAC ASSx2].mkv"#
+        );
+
+        let test_tag = format!("test_tag_{}", chrono::Utc::now().timestamp());
+
+        downloader
+            .add_torrent_tags(
+                vec!["47ee2d69e7f19af783ad896541a07b012676f858".to_string()],
+                vec![test_tag.clone()],
+            )
+            .await
+            .unwrap();
+
+        let target_torrent = get_torrent().await.unwrap();
+
+        assert!(target_torrent.get_tags().iter().any(|s| s == &test_tag));
+
+        let test_category = format!("test_category_{}", chrono::Utc::now().timestamp());
+
+        downloader
+            .set_torrents_category(
+                vec!["47ee2d69e7f19af783ad896541a07b012676f858".to_string()],
+                &test_category,
+            )
+            .await
+            .unwrap();
+
+        let target_torrent = get_torrent().await.unwrap();
+
+        assert_eq!(Some(test_category.as_str()), target_torrent.get_category());
+
+        let moved_save_path = base_save_path.join(format!(
+            "moved_test_add_torrents_{}",
+            chrono::Utc::now().timestamp()
+        ));
+
+        downloader
+            .move_torrents(
+                vec!["47ee2d69e7f19af783ad896541a07b012676f858".to_string()],
+                moved_save_path.as_str(),
+            )
+            .await
+            .unwrap();
+
+        let target_torrent = get_torrent().await.unwrap();
+
+        let content_path = target_torrent.iter_files().next().unwrap().get_name();
+
+        let new_content_path = &format!("new_{}", content_path);
+
+        downloader
+            .rename_torrent_file(
+                "47ee2d69e7f19af783ad896541a07b012676f858",
+                content_path,
+                new_content_path,
+            )
+            .await
+            .unwrap();
+
+        let target_torrent = get_torrent().await.unwrap();
+
+        let content_path = target_torrent.iter_files().next().unwrap().get_name();
+
+        assert_eq!(content_path, new_content_path);
+
+        downloader
+            .delete_torrents(vec!["47ee2d69e7f19af783ad896541a07b012676f858".to_string()])
+            .await
+            .unwrap();
+
+        let torrent_infos1 = downloader
+            .get_torrents_info(TorrentFilter::All, None, None)
+            .await
+            .unwrap();
+
+        assert!(torrent_infos1.is_empty());
+    }
+}