test: move testing code out of src/

Author: Xevion

src/cache.rs

@@ -271,49 +271,3 @@ fn hash_cacheable<T: Cacheable>(item: &T) -> u64 {
     item.cache_key().hash(&mut hasher);
     hasher.finish()
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use tempfile::tempdir;
-
-    #[tokio::test]
-    async fn test_cache_basic_functionality() -> Result<()> {
-        let temp_dir = tempdir()
-            .map_err(|e| CacheError::Create(anyhow::anyhow!("Failed to create temp dir: {}", e)))?;
-        let config = CacheConfig {
-            disk_capacity: 1024 * 1024, // 1 MB
-            disk_path: temp_dir.path().to_string_lossy().to_string(),
-        };
-
-        let cache_manager = CacheManager::new(config).await?;
-
-        let meaning = Meaning {
-            owner: "test_owner".to_string(),
-            repo: "test_repo".to_string(),
-            theme: "dark".to_string(),
-        };
-
-        // Test cache miss and creation
-        let result = cache_manager
-            .get_or_create(meaning.clone(), || async {
-                Ok(b"test_image_data".to_vec())
-            })
-            .await?;
-
-        assert_eq!(result.image_data, b"test_image_data");
-        assert_eq!(result.meaning, meaning);
-        assert_eq!(result.access_count, 1);
-
-        // Test cache hit
-        let result2 = cache_manager
-            .get_or_create(meaning, || async {
-                panic!("This should not be called on cache hit");
-            })
-            .await?;
-
-        assert_eq!(result2.image_data, b"test_image_data");
-
-        Ok(())
-    }
-}

src/ratelimit.rs

@@ -12,61 +12,6 @@ use tokio::sync::RwLock;
 use tokio::time::interval;
 use tracing::{debug, warn};
 
-/// Time provider trait for mocking in tests
-#[cfg(test)]
-pub trait TimeProvider {
-    fn now(&self) -> Instant;
-    fn advance(&mut self, duration: Duration);
-}
-
-/// Real time provider for production
-#[cfg(test)]
-pub struct RealTimeProvider;
-
-#[cfg(test)]
-impl TimeProvider for RealTimeProvider {
-    fn now(&self) -> Instant {
-        Instant::now()
-    }
-
-    fn advance(&mut self, _duration: Duration) {
-        // No-op for real time
-    }
-}
-
-/// Mock time provider for tests
-#[cfg(test)]
-pub struct MockTimeProvider {
-    current_time: Instant,
-}
-
-#[cfg(test)]
-impl MockTimeProvider {
-    pub fn new() -> Self {
-        Self {
-            current_time: Instant::now(),
-        }
-    }
-}
-
-#[cfg(test)]
-impl Default for MockTimeProvider {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-#[cfg(test)]
-impl TimeProvider for MockTimeProvider {
-    fn now(&self) -> Instant {
-        self.current_time
-    }
-
-    fn advance(&mut self, duration: Duration) {
-        self.current_time += duration;
-    }
-}
-
 /// Configuration for rate limiting
 #[derive(Clone, Debug)]
 pub struct RateLimitConfig {
@@ -92,16 +37,6 @@ impl Default for RateLimitConfig {
 }
 
 /// Token bucket for rate limiting
-#[cfg(test)]
-pub struct TokenBucket {
-    tokens: AtomicU32,
-    max_tokens: u32,
-    refill_rate: u32, // tokens per refill interval
-    last_refill: RwLock<Instant>,
-    time_provider: Arc<RwLock<Box<dyn TimeProvider + Send + Sync>>>,
-}
-
-#[cfg(not(test))]
 struct TokenBucket {
     tokens: AtomicU32,
     max_tokens: u32,
@@ -128,7 +63,6 @@ impl std::fmt::Debug for TokenBucket {
 }
 
 impl TokenBucket {
-    #[cfg(not(test))]
     fn new(max_tokens: u32, refill_rate: u32) -> Self {
         Self {
             tokens: AtomicU32::new(max_tokens),
@@ -138,34 +72,7 @@ impl TokenBucket {
         }
     }
 
-    #[cfg(test)]
-    pub fn new(max_tokens: u32, refill_rate: u32) -> Self {
-        Self {
-            tokens: AtomicU32::new(max_tokens),
-            max_tokens,
-            refill_rate,
-            last_refill: RwLock::new(Instant::now()),
-            time_provider: Arc::new(RwLock::new(Box::new(RealTimeProvider))),
-        }
-    }
-
-    #[cfg(test)]
-    pub fn new_with_time_provider(
-        max_tokens: u32,
-        refill_rate: u32,
-        time_provider: Box<dyn TimeProvider + Send + Sync>,
-    ) -> Self {
-        Self {
-            tokens: AtomicU32::new(max_tokens),
-            max_tokens,
-            refill_rate,
-            last_refill: RwLock::new(Instant::now()),
-            time_provider: Arc::new(RwLock::new(time_provider)),
-        }
-    }
-
     /// Try to consume a token. Returns true if successful, false if rate limited.
-    #[cfg(not(test))]
     async fn try_consume(&self) -> bool {
         self.refill().await;
 
@@ -192,35 +99,7 @@ impl TokenBucket {
         }
     }
 
-    #[cfg(test)]
-    pub async fn try_consume(&self) -> bool {
-        self.refill().await;
-
-        // Use a loop instead of recursion to avoid boxing
-        loop {
-            let current_tokens = self.tokens.load(Ordering::Acquire);
-            if current_tokens > 0 {
-                // Try to decrement atomically
-                match self.tokens.compare_exchange_weak(
-                    current_tokens,
-                    current_tokens - 1,
-                    Ordering::Release,
-                    Ordering::Relaxed,
-                ) {
-                    Ok(_) => return true,
-                    Err(_) => {
-                        // Someone else consumed the token, try again
-                        continue;
-                    }
-                }
-            } else {
-                return false;
-            }
-        }
-    }
-
     /// Refill tokens based on elapsed time
-    #[cfg(not(test))]
     async fn refill(&self) {
         let now = Instant::now();
 
@@ -248,51 +127,10 @@ impl TokenBucket {
         }
     }
 
-    #[cfg(test)]
-    pub async fn refill(&self) {
-        #[cfg(test)]
-        let now = {
-            let time_provider = self.time_provider.read().await;
-            time_provider.now()
-        };
-        #[cfg(not(test))]
-        let now = Instant::now();
-
-        let mut last_refill = self.last_refill.write().await;
-
-        let elapsed = now.duration_since(*last_refill);
-        if elapsed >= Duration::from_secs(1) {
-            let seconds_passed = elapsed.as_secs() as u32;
-            let tokens_to_add = seconds_passed * self.refill_rate;
-
-            if tokens_to_add > 0 {
-                let current_tokens = self.tokens.load(Ordering::Acquire);
-                let new_tokens = (current_tokens + tokens_to_add).min(self.max_tokens);
-                self.tokens.store(new_tokens, Ordering::Release);
-                *last_refill = now;
-
-                // Only log if we actually added tokens and it's significant
-                if tokens_to_add > 0 && current_tokens < self.max_tokens / 2 {
-                    debug!(
-                        "Refilled {} tokens, current: {}/{}",
-                        tokens_to_add, new_tokens, self.max_tokens
-                    );
-                }
-            }
-        }
-    }
-
     /// Get current token count (for monitoring)
     fn current_tokens(&self) -> u32 {
         self.tokens.load(Ordering::Acquire)
     }
-
-    #[cfg(test)]
-    /// Advance time for testing
-    pub async fn advance_time(&self, duration: Duration) {
-        let mut time_provider = self.time_provider.write().await;
-        time_provider.advance(duration);
-    }
 }
 
 /// Rate limiter with global and per-IP limits

src/server.rs

@@ -77,11 +77,11 @@ impl SvgInputData {
 
 /// Query parameters for image generation
 #[derive(Debug, Deserialize)]
-struct ImageQuery {
+pub struct ImageQuery {
     #[serde(rename = "scale")]
-    scale: Option<String>,
+    pub scale: Option<String>,
     #[serde(rename = "s")]
-    s: Option<String>,
+    pub s: Option<String>,
 }
 
 /// Application state containing the rate limiter
@@ -506,7 +506,7 @@ pub fn parse_repo_name_and_format(repo_name: &str) -> (String, Option<ImageForma
 ///
 /// # Returns
 /// Optional scale factor (None if not provided or invalid)
-fn parse_scale_parameter(query: &ImageQuery) -> Option<f64> {
+pub fn parse_scale_parameter(query: &ImageQuery) -> Option<f64> {
     // Try 'scale' parameter first, then fallback to 's'
     let scale_str = query.scale.as_deref().or(query.s.as_deref())?;
 
@@ -709,74 +709,3 @@ pub fn parse_address_components(
         )))),
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_parse_scale_parameter() {
-        // Test valid scale parameters
-        let query = ImageQuery {
-            scale: Some("1.5".to_string()),
-            s: None,
-        };
-        assert_eq!(parse_scale_parameter(&query), Some(1.5));
-
-        let query = ImageQuery {
-            scale: None,
-            s: Some("2.0".to_string()),
-        };
-        assert_eq!(parse_scale_parameter(&query), Some(2.0));
-
-        // Test fallback from scale to s
-        let query = ImageQuery {
-            scale: None,
-            s: Some("1.2".to_string()),
-        };
-        assert_eq!(parse_scale_parameter(&query), Some(1.2));
-
-        // Test invalid parameters
-        let query = ImageQuery {
-            scale: Some("0.05".to_string()), // Below minimum - gets clamped to 0.1
-            s: None,
-        };
-        assert_eq!(parse_scale_parameter(&query), Some(0.1));
-
-        let query = ImageQuery {
-            scale: Some("12345678901".to_string()), // Too long after trimming (>10 chars)
-            s: None,
-        };
-        assert_eq!(parse_scale_parameter(&query), None);
-
-        let query = ImageQuery {
-            scale: Some("abc".to_string()), // Invalid number
-            s: None,
-        };
-        assert_eq!(parse_scale_parameter(&query), None);
-
-        // Test no parameters
-        let query = ImageQuery {
-            scale: None,
-            s: None,
-        };
-        assert_eq!(parse_scale_parameter(&query), None);
-    }
-
-    #[test]
-    fn test_scale_parameter_length_validation() {
-        // Test that trailing zeros are trimmed correctly
-        let query = ImageQuery {
-            scale: Some("1.2000".to_string()),
-            s: None,
-        };
-        assert_eq!(parse_scale_parameter(&query), Some(1.2));
-
-        // Test that long strings are rejected (>10 chars after trimming)
-        let query = ImageQuery {
-            scale: Some("1.2345678901".to_string()),
-            s: None,
-        };
-        assert_eq!(parse_scale_parameter(&query), None);
-    }
-}