test: mock file storage and HTTP clients for repository tests

Add proper mocking for all repository tests:
- Mock OssInsightClient using test-mocks feature (same pattern as GitHubApiClient)
- Add new_test() methods to ChallengeRepository, TrendingRepository, and VersionRepository
- Update all repository tests to use test instances
- Remove ignore attributes from trending repository tests

This ensures no real file system or HTTP requests during tests.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: unhappychoice

src/domain/repositories/challenge_repository.rs

@@ -50,6 +50,12 @@ impl ChallengeRepository {
         }
     }
 
+    /// Create a new repository for testing
+    #[doc(hidden)]
+    pub fn new_test() -> Self {
+        Self::with_cache_dir(PathBuf::from("/mock/cache"))
+    }
+
     pub fn save_challenges(
         &self,
         repo: &GitRepository,

src/domain/repositories/session_repository.rs

@@ -27,6 +27,16 @@ impl SessionRepository {
         })
     }
 
+    /// Create a new repository with an in-memory database for testing
+    #[doc(hidden)]
+    pub fn new_test() -> Result<Self> {
+        let database = Database::new_test()?;
+        database.init()?;
+        Ok(Self {
+            database: Arc::new(Mutex::new(database)),
+        })
+    }
+
     /// Record a completed session to the database
     pub fn record_session(
         &self,

src/domain/repositories/trending_repository.rs

@@ -60,6 +60,12 @@ impl TrendingRepository {
         }
     }
 
+    /// Create a new repository for testing that doesn't make HTTP requests
+    #[doc(hidden)]
+    pub fn new_test() -> Self {
+        Self::with_cache_dir(PathBuf::from("/mock/trending_cache"))
+    }
+
     /// Get trending repositories with caching and fallback to fresh data
     pub async fn get_trending_repositories(
         &self,

src/domain/repositories/version_repository.rs

@@ -20,6 +20,15 @@ impl VersionRepository {
         })
     }
 
+    /// Create a new repository for testing that doesn't make HTTP requests
+    #[doc(hidden)]
+    pub fn new_test() -> Result<Self> {
+        Ok(Self {
+            github_client: GitHubApiClient::new()?,
+            file_storage: FileStorage::new(),
+        })
+    }
+
     /// Fetch the latest version from cache or API
     pub async fn fetch_latest_version(&self) -> Result<String> {
         const CHECK_FREQUENCY_HOURS: u64 = 24;

src/infrastructure/http/oss_insight_client.rs

@@ -1,124 +1,167 @@
-use reqwest::Client;
-use serde::Deserialize;
-use std::time::Duration;
-
-use crate::domain::error::{GitTypeError, Result};
 use crate::domain::repositories::trending_repository::TrendingRepositoryInfo;
-
-#[derive(Debug, Clone)]
-pub struct OssInsightClient {
-    client: Client,
-}
-
-impl OssInsightClient {
-    pub fn new() -> Self {
-        Self {
-            client: Client::new(),
-        }
+#[cfg(feature = "test-mocks")]
+use crate::Result;
+#[cfg(not(feature = "test-mocks"))]
+use crate::{GitTypeError, Result};
+
+#[cfg(not(feature = "test-mocks"))]
+mod real_impl {
+    use super::*;
+    use reqwest::Client;
+    use serde::Deserialize;
+    use std::time::Duration;
+
+    #[derive(Debug, Clone)]
+    pub struct OssInsightClient {
+        client: Client,
     }
 
-    pub async fn fetch_trending_repositories(
-        &self,
-        language: Option<&str>,
-        period: &str,
-    ) -> Result<Vec<TrendingRepositoryInfo>> {
-        let api_period = match period {
-            "daily" => "past_24_hours",
-            "weekly" => "past_week",
-            "monthly" => "past_month",
-            _ => "past_24_hours",
-        };
-
-        let mut url = format!(
-            "https://api.ossinsight.io/v1/trends/repos/?period={}",
-            api_period
-        );
-
-        if let Some(lang) = language {
-            let api_lang = self.map_language_name(lang);
-            url = format!("{}&language={}", url, urlencoding::encode(&api_lang));
+    impl OssInsightClient {
+        pub fn new() -> Self {
+            Self {
+                client: Client::new(),
+            }
         }
 
-        let response = self
-            .client
-            .get(&url)
-            .header("User-Agent", "gittype")
-            .header("Accept", "application/json")
-            .timeout(Duration::from_secs(10))
-            .send()
-            .await?;
-
-        if !response.status().is_success() {
-            return Err(GitTypeError::ApiError(format!(
-                "OSS Insight API request failed: {}",
-                response.status()
-            )));
-        }
+        pub async fn fetch_trending_repositories(
+            &self,
+            language: Option<&str>,
+            period: &str,
+        ) -> Result<Vec<TrendingRepositoryInfo>> {
+            let api_period = match period {
+                "daily" => "past_24_hours",
+                "weekly" => "past_week",
+                "monthly" => "past_month",
+                _ => "past_24_hours",
+            };
+
+            let mut url = format!(
+                "https://api.ossinsight.io/v1/trends/repos/?period={}",
+                api_period
+            );
+
+            if let Some(lang) = language {
+                let api_lang = self.map_language_name(lang);
+                url = format!("{}&language={}", url, urlencoding::encode(&api_lang));
+            }
 
-        let api_response: ApiResponse = response.json().await?;
-        let repositories = self.convert_api_response(api_response);
+            let response = self
+                .client
+                .get(&url)
+                .header("User-Agent", "gittype")
+                .header("Accept", "application/json")
+                .timeout(Duration::from_secs(10))
+                .send()
+                .await?;
+
+            if !response.status().is_success() {
+                return Err(GitTypeError::ApiError(format!(
+                    "OSS Insight API request failed: {}",
+                    response.status()
+                )));
+            }
 
-        Ok(repositories)
-    }
+            let api_response: ApiResponse = response.json().await?;
+            let repositories = self.convert_api_response(api_response);
+
+            Ok(repositories)
+        }
 
-    fn map_language_name(&self, lang: &str) -> String {
-        match lang.to_lowercase().as_str() {
-            "javascript" => "JavaScript".to_string(),
-            "typescript" => "TypeScript".to_string(),
-            "c++" => "C++".to_string(),
-            "c#" => "C#".to_string(),
-            "php" => "PHP".to_string(),
-            _ => {
-                let mut chars = lang.chars();
-                match chars.next() {
-                    None => lang.to_string(),
-                    Some(first) => {
-                        first.to_uppercase().collect::<String>() + &chars.as_str().to_lowercase()
+        fn map_language_name(&self, lang: &str) -> String {
+            match lang.to_lowercase().as_str() {
+                "javascript" => "JavaScript".to_string(),
+                "typescript" => "TypeScript".to_string(),
+                "c++" => "C++".to_string(),
+                "c#" => "C#".to_string(),
+                "php" => "PHP".to_string(),
+                _ => {
+                    let mut chars = lang.chars();
+                    match chars.next() {
+                        None => lang.to_string(),
+                        Some(first) => {
+                            first.to_uppercase().collect::<String>()
+                                + &chars.as_str().to_lowercase()
+                        }
                     }
                 }
             }
         }
+
+        fn convert_api_response(&self, api_response: ApiResponse) -> Vec<TrendingRepositoryInfo> {
+            api_response
+                .data
+                .rows
+                .into_iter()
+                .map(|row| TrendingRepositoryInfo {
+                    repo_name: row.repo_name,
+                    primary_language: row.primary_language,
+                    description: row.description,
+                    stars: row.stars.unwrap_or_else(|| "0".to_string()),
+                    forks: row.forks.unwrap_or_else(|| "0".to_string()),
+                    total_score: row.total_score.unwrap_or_else(|| "0".to_string()),
+                })
+                .collect()
+        }
     }
 
-    fn convert_api_response(&self, api_response: ApiResponse) -> Vec<TrendingRepositoryInfo> {
-        api_response
-            .data
-            .rows
-            .into_iter()
-            .map(|row| TrendingRepositoryInfo {
-                repo_name: row.repo_name,
-                primary_language: row.primary_language,
-                description: row.description,
-                stars: row.stars.unwrap_or_else(|| "0".to_string()),
-                forks: row.forks.unwrap_or_else(|| "0".to_string()),
-                total_score: row.total_score.unwrap_or_else(|| "0".to_string()),
-            })
-            .collect()
+    impl Default for OssInsightClient {
+        fn default() -> Self {
+            Self::new()
+        }
     }
-}
 
-impl Default for OssInsightClient {
-    fn default() -> Self {
-        Self::new()
+    #[derive(Deserialize)]
+    struct ApiResponse {
+        data: ApiData,
     }
-}
 
-#[derive(Deserialize)]
-struct ApiResponse {
-    data: ApiData,
-}
+    #[derive(Deserialize)]
+    struct ApiData {
+        rows: Vec<RowData>,
+    }
 
-#[derive(Deserialize)]
-struct ApiData {
-    rows: Vec<RowData>,
+    #[derive(Deserialize)]
+    struct RowData {
+        repo_name: String,
+        primary_language: Option<String>,
+        description: Option<String>,
+        stars: Option<String>,
+        forks: Option<String>,
+        total_score: Option<String>,
+    }
 }
 
-#[derive(Deserialize)]
-struct RowData {
-    repo_name: String,
-    primary_language: Option<String>,
-    description: Option<String>,
-    stars: Option<String>,
-    forks: Option<String>,
-    total_score: Option<String>,
+#[cfg(feature = "test-mocks")]
+mod mock_impl {
+    use super::*;
+
+    #[derive(Debug, Clone)]
+    pub struct OssInsightClient;
+
+    impl OssInsightClient {
+        pub fn new() -> Self {
+            Self
+        }
+
+        pub async fn fetch_trending_repositories(
+            &self,
+            _language: Option<&str>,
+            _period: &str,
+        ) -> Result<Vec<TrendingRepositoryInfo>> {
+            // Return empty vec for tests (no HTTP requests)
+            Ok(Vec::new())
+        }
+    }
+
+    impl Default for OssInsightClient {
+        fn default() -> Self {
+            Self::new()
+        }
+    }
 }
+
+#[cfg(not(feature = "test-mocks"))]
+pub use real_impl::OssInsightClient;
+
+#[cfg(feature = "test-mocks")]
+pub use mock_impl::OssInsightClient;

tests/unit/domain/repositories/challenge_repository_tests.rs

@@ -32,7 +32,7 @@ mod tests {
     use super::*;
 
     fn create_test_cache() -> ChallengeRepository {
-        ChallengeRepository::with_cache_dir(PathBuf::from("/mock/cache"))
+        ChallengeRepository::new_test()
     }
 
     #[test]