From 02b450865ba8fcadd1cae11e3fb62bb61dfb64b1 Mon Sep 17 00:00:00 2001 From: glitchySid Date: Sat, 10 Jan 2026 22:24:05 +0530 Subject: [PATCH] Refactor cache API and expand installation docs - Remove CacheCheckResult and simplify Cache::check_cache to return Option - Replace cache_response_with_metadata with cache_response that takes a base path; update Gemini client and tests to use new API - Improve load_or_create error handling and early-return when cache file missing - Expand README/docs/INSTALLATION.md with detailed per-OS install and PATH instructions --- README.md | 47 +++++-- docs/INSTALLATION.md | 273 ++++++++++++++++++++++++++++++------ src/gemini/client.rs | 24 ++-- src/storage/cache.rs | 180 +++++++----------------- src/storage/mod.rs | 2 +- tests/integration_online.rs | 34 +++-- 6 files changed, 347 insertions(+), 213 deletions(-) diff --git a/README.md b/README.md index 31b5d49..0a884fb 100644 --- a/README.md +++ b/README.md @@ -26,26 +26,53 @@ NoEntropy is a smart command-line tool that organizes your cluttered Downloads f ### Installation -**Option 1: Download Pre-built Binary** +### Download Pre-built Binary -Download the binary for your operating system from [releases](https://github.com/glitchySid/noentropy/releases): +Download the latest release for your operating system from [releases](https://github.com/glitchySid/noentropy/releases): +| OS | Download | +|----|----------| +| Linux x86_64 | `noentropy-x86_64-unknown-linux-gnu.tar.gz` | +| macOS x86_64 | `noentropy-x86_64-apple-darwin.tar.gz` | +| macOS arm64 | `noentropy-aarch64-apple-darwin.tar.gz` | +| Windows x86_64 | `noentropy-x86_64-pc-windows-msvc.zip` | + +**Linux/macOS:** ```bash -# Linux/macOS: Give execute permissions -chmod +x noentropy +# Download and extract +curl -LO https://github.com/glitchySid/noentropy/releases/latest/download/noentropy-x86_64-unknown-linux-gnu.tar.gz +tar -xzf noentropy-x86_64-unknown-linux-gnu.tar.gz -# Run NoEntropy -./noentropy +# Add to PATH (user-level) +mkdir -p ~/.local/bin +mv noentropy ~/.local/bin/ +echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.bashrc # or ~/.zshrc +source ~/.bashrc + +# Verify +noentropy --help ``` -**Option 2: Build from Source** +**Windows:** +```powershell +# Download and extract +Invoke-WebRequest -Uri "https://github.com/glitchySid/noentropy/releases/latest/download/noentropy-x86_64-pc-windows-msvc.zip" -OutFile "noentropy.zip" +Expand-Archive -Path "noentropy.zip" -DestinationPath "noentropy" + +# Add to PATH (User-level) +$env:PATH += ";$env:USERPROFILE\AppData\Local\NoEntropy" + +# Or add via System Properties: +# Win + R → sysdm.cpl → Environment Variables → Edit PATH +``` + +See the [Installation Guide](docs/INSTALLATION.md) for detailed instructions. + +### Build from Source ```bash -# Clone repository git clone https://github.com/glitchySid/noentropy.git cd noentropy - -# Build and run cargo build --release ./target/release/noentropy ``` diff --git a/docs/INSTALLATION.md b/docs/INSTALLATION.md index 170c127..87be26e 100644 --- a/docs/INSTALLATION.md +++ b/docs/INSTALLATION.md @@ -6,7 +6,6 @@ This guide covers different ways to install and set up NoEntropy on your system. Before installing NoEntropy, ensure you have: -- **Rust 2024 Edition** or later (if building from source) - **Google Gemini API Key** - Get one at [https://ai.google.dev/](https://ai.google.dev/) - A folder full of unorganized files to clean up! @@ -14,48 +13,207 @@ Before installing NoEntropy, ensure you have: The easiest way to get started is to download a pre-built binary for your operating system. -1. **Download Binary** - - Visit the releases page and download the binary for your operating system (Windows, Linux, or macOS): - ```bash - https://github.com/glitchySid/noentropy/releases +### Step 1: Download the Binary + +Visit the [releases page](https://github.com/glitchySid/noentropy/releases) and download the appropriate archive for your system: + +| Operating System | Architecture | File to Download | +|------------------|--------------|------------------| +| Linux | x86_64 | `noentropy-x86_64-unknown-linux-gnu.tar.gz` | +| macOS | x86_64 (Intel) | `noentropy-x86_64-apple-darwin.tar.gz` | +| macOS | arm64 (Apple Silicon) | `noentropy-aarch64-apple-darwin.tar.gz` | +| Windows | x86_64 | `noentropy-x86_64-pc-windows-msvc.zip` | + +Or download directly from the command line: + +**Linux:** +```bash +curl -LO https://github.com/glitchySid/noentropy/releases/latest/download/noentropy-x86_64-unknown-linux-gnu.tar.gz +``` + +**macOS (Intel):** +```bash +curl -LO https://github.com/glitchySid/noentropy/releases/latest/download/noentropy-x86_64-apple-darwin.tar.gz +``` + +**macOS (Apple Silicon):** +```bash +curl -LO https://github.com/glitchySid/noentropy/releases/latest/download/noentropy-aarch64-apple-darwin.tar.gz +``` + +**Windows (PowerShell):** +```powershell +Invoke-WebRequest -Uri "https://github.com/glitchySid/noentropy/releases/latest/download/noentropy-x86_64-pc-windows-msvc.zip" -OutFile "noentropy.zip" +``` + +### Step 2: Extract the Archive + +**Linux/macOS:** +```bash +tar -xzf noentropy-x86_64-unknown-linux-gnu.tar.gz +``` + +**Windows:** +Right-click the downloaded zip file and select "Extract All..." or use PowerShell: +```powershell +Expand-Archive -Path "noentropy.zip" -DestinationPath "noentropy" +``` + +### Step 3: Add to PATH + +You need to add the folder containing `noentropy` to your system's PATH so you can run it from anywhere. + +#### Linux/macOS + +**Option A: User-level (recommended, no sudo required)** + +```bash +# Create local bin directory if it doesn't exist +mkdir -p ~/.local/bin + +# Move the binary to a location in your PATH +mv noentropy ~/.local/bin/ + +# Add to PATH temporarily for this session +export PATH="$HOME/.local/bin:$PATH" + +# Verify it works +noentropy --help +``` + +To make this permanent, add this line to your shell configuration file: + +**For bash (`~/.bashrc` or `~/.bash_profile`):** +```bash +echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.bashrc +source ~/.bashrc +``` + +**For zsh (`~/.zshrc`):** +```bash +echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.zshrc +source ~/.zshrc +``` + +**Option B: System-wide (requires sudo)** + +```bash +# Move to system bin (requires sudo on most systems) +sudo mv noentropy /usr/local/bin/ + +# Verify it works +noentropy --help +``` + +#### Windows + +**Option A: User-level (recommended)** + +1. Move the extracted `noentropy.exe` to a folder, for example: + ``` + C:\Users\\AppData\Local\NoEntropy ``` -2. **Give Permission (Linux/macOS only)** - - Make the binary executable: - ```bash - chmod +x noentropy +2. Add to User PATH: + - Press `Win + R`, type `sysdm.cpl`, press Enter + - Click "Environment Variables" + - Under "User variables", select "Path", click "Edit" + - Click "New" and add: + ``` + C:\Users\\AppData\Local\NoEntropy + ``` + - Click "OK" on all dialogs + +3. **Alternative using PowerShell (Admin):** + ```powershell + # Create installation directory + New-Item -ItemType Directory -Force -Path "$env:USERPROFILE\AppData\Local\NoEntropy" + + # Move the binary + Move-Item -Path ".\noentropy.exe" -Destination "$env:USERPROFILE\AppData\Local\NoEntropy\" + + # Add to PATH (User level) + $path = [Environment]::GetEnvironmentVariable("PATH", "User") + $newPath = "$path;$env:USERPROFILE\AppData\Local\NoEntropy" + [Environment]::SetEnvironmentVariable("PATH", $newPath, "User") + + # Verify + noentropy --help ``` -3. **Run NoEntropy** - - ```bash - ./noentropy - ``` +4. **Restart your terminal** or start a new Command Prompt/PowerShell window for the PATH changes to take effect. + +**Option B: System-wide (requires Administrator)** + +```powershell +# Run PowerShell as Administrator +Move-Item -Path ".\noentropy.exe" -Destination "C:\Program Files\NoEntropy\noentropy.exe" + +# Add to system PATH +$path = [Environment]::GetEnvironmentVariable("PATH", "Machine") +$newPath = "$path;C:\Program Files\NoEntropy" +[Environment]::SetEnvironmentVariable("PATH", $newPath, "Machine") + +# Verify +noentropy --help +``` + +### Step 4: Verify Installation + +```bash +noentropy --help +``` + +You should see the help message with available options. + +--- ## Option 2: Build from Source If you prefer to build from source or want the latest development version: -1. **Clone the Repository** - - ```bash - git clone https://github.com/glitchySid/noentropy.git - cd noentropy - ``` +### Prerequisites -2. **Build the Application** - - ```bash - cargo build --release - ``` +- **Rust 2024 Edition** or later - Install from [rustup.rs](https://rustup.rs/) +- **Git** - For cloning the repository -3. **Run the Application** - - ```bash - ./target/release/noentropy - ``` +### Step 1: Clone the Repository + +```bash +git clone https://github.com/glitchySid/noentropy.git +cd noentropy +``` + +### Step 2: Build the Application + +```bash +cargo build --release +``` + +The binary will be located at `target/release/noentropy`. + +### Step 3: Install Globally (Optional) + +**Linux/macOS:** +```bash +# User-level installation +mkdir -p ~/.local/bin +cp target/release/noentropy ~/.local/bin/ +noentropy --help +``` + +**Windows:** +```powershell +# Create installation directory +New-Item -ItemType Directory -Force -Path "$env:USERPROFILE\AppData\Local\NoEntropy" + +# Copy the binary +Copy-Item -Path ".\target\release\noentropy.exe" -Destination "$env:USERPROFILE\AppData\Local\NoEntropy\" + +# Add to PATH (see Windows instructions above) +``` + +--- ## First-Run Setup @@ -69,19 +227,40 @@ NoEntropy provides an interactive setup if configuration is missing: - **Missing download folder?** → You'll be prompted to specify it (with default suggestion) - **Both missing?** → You'll be guided through complete setup -Configuration is automatically saved to `~/.config/noentropy/config.toml` after interactive setup. +Configuration is automatically saved to: + +| OS | Path | +|----|------| +| Linux/macOS | `~/.config/noentropy/config.toml` | +| Windows | `%APPDATA%\NoEntropy\config.toml` | ### Manual Configuration Alternatively, you can manually create the configuration file: +**Linux/macOS:** ```bash +mkdir -p ~/.config/noentropy cp config.example.toml ~/.config/noentropy/config.toml nano ~/.config/noentropy/config.toml ``` +**Windows:** +```powershell +# Create config directory +New-Item -ItemType Directory -Force -Path "$env:APPDATA\NoEntropy" + +# Copy example config +Copy-Item -Path ".\config.example.toml" -Destination "$env:APPDATA\NoEntropy\config.toml" + +# Edit with Notepad +notepad "$env:APPDATA\NoEntropy\config.toml" +``` + See the [Configuration Guide](CONFIGURATION.md) for detailed configuration options. +--- + ## Getting Your Gemini API Key 1. Visit [Google AI Studio](https://ai.google.dev/) @@ -89,16 +268,28 @@ See the [Configuration Guide](CONFIGURATION.md) for detailed configuration optio 3. Create a new API key 4. Copy the key to your configuration file or enter it during interactive setup +--- + ## Verification To verify your installation works correctly: -1. Run NoEntropy with the `--dry-run` flag: - ```bash - ./noentropy --dry-run - ``` +```bash +noentropy --help +``` -2. You should see NoEntropy scan your downloads folder and display an organization plan without moving any files. +If you see the help output, installation was successful! + +To test file organization: + +```bash +# Organize your downloads folder (or configured folder) +noentropy --dry-run +``` + +You should see NoEntropy scan your folder and display an organization plan without moving any files. + +--- ## Next Steps @@ -106,15 +297,19 @@ To verify your installation works correctly: - [Usage Guide](USAGE.md) - Learn how to use NoEntropy effectively - [How It Works](HOW_IT_WORKS.md) - Understand the organization process +--- + ## Troubleshooting If you encounter issues during installation, check the [Troubleshooting Guide](TROUBLESHOOTING.md). Common installation issues: +- **"noentropy: command not found"**: The folder is not in your PATH. Restart your terminal or run `source ~/.bashrc` (or `source ~/.zshrc`). +- **Permission denied (Linux/macOS)**: Make sure the binary has execute permissions: `chmod +x noentropy` +- **Windows PATH not updating**: Restart your terminal or computer after adding to PATH. - **Rust not installed**: Install Rust from [rustup.rs](https://rustup.rs/) - **Build errors**: Ensure you have the latest Rust toolchain: `rustup update` -- **Permission denied**: Make sure the binary has execute permissions (Linux/macOS) --- diff --git a/src/gemini/client.rs b/src/gemini/client.rs index 3ddbf36..ba27a81 100644 --- a/src/gemini/client.rs +++ b/src/gemini/client.rs @@ -93,17 +93,13 @@ impl GeminiClient { ) -> Result { let url = self.build_url(); - // Check cache and get pre-fetched metadata in one pass - let cache_result = match (cache.as_ref(), base_path) { - (Some(c), Some(bp)) => Some(c.check_cache(&filenames, bp)), - _ => None, - }; - - // Return cached response if valid - if let Some(ref result) = cache_result - && let Some(ref cached_response) = result.cached_response - { - return Ok(cached_response.clone()); + // Check cache first + if let Some(ref mut c) = cache { + if let Some(bp) = base_path { + if let Some(cached) = c.check_cache(&filenames, bp) { + return Ok(cached); + } + } } let prompt = PromptBuilder::new(&filenames).build_categorization_prompt(&self.categories); @@ -112,9 +108,9 @@ impl GeminiClient { let res = self.send_request_with_retry(&url, &request_body).await?; let plan = self.parse_categorization_response(res).await?; - // Cache response using pre-fetched metadata (no second metadata lookup) - if let (Some(cache), Some(result)) = (cache.as_mut(), cache_result) { - cache.cache_response_with_metadata(&filenames, plan.clone(), result.file_metadata); + // Cache the response + if let (Some(cache), Some(base_path)) = (cache, base_path) { + cache.cache_response(&filenames, plan.clone(), base_path); } Ok(plan) diff --git a/src/storage/cache.rs b/src/storage/cache.rs index a8cc5d3..13d2ec1 100644 --- a/src/storage/cache.rs +++ b/src/storage/cache.rs @@ -6,12 +6,6 @@ use std::fs; use std::path::Path; use std::time::{SystemTime, UNIX_EPOCH}; -/// Result of checking the cache - includes pre-fetched metadata to avoid double lookups -pub struct CacheCheckResult { - pub cached_response: Option, - pub file_metadata: HashMap, -} - #[derive(Serialize, Deserialize, Debug)] pub struct Cache { entries: HashMap, @@ -37,26 +31,25 @@ impl Cache { } pub fn load_or_create(cache_path: &Path) -> Self { - if cache_path.exists() { - match fs::read_to_string(cache_path) { - Ok(content) => match serde_json::from_str::(&content) { - Ok(cache) => { - println!("Loaded cache with {} entries", cache.entries.len()); - cache - } - Err(_) => { - println!("Cache corrupted, creating new cache"); - Self::new() - } - }, + if !cache_path.exists() { + return Self::new(); + } + + match fs::read_to_string(cache_path) { + Ok(content) => match serde_json::from_str::(&content) { + Ok(cache) => { + println!("Loaded cache with {} entries", cache.entries.len()); + cache + } Err(_) => { - println!("Failed to read cache, creating new cache"); + println!("Cache corrupted, creating new cache"); Self::new() } + }, + Err(_) => { + println!("Failed to read cache, creating new cache"); + Self::new() } - } else { - println!("Creating new cache file"); - Self::new() } } @@ -70,107 +63,40 @@ impl Cache { Ok(()) } - /// Checks cache and returns pre-fetched metadata to avoid double lookups. - /// The returned metadata can be passed to `cache_response_with_metadata` on cache miss. - pub fn check_cache(&self, filenames: &[String], base_path: &Path) -> CacheCheckResult { - // Fetch metadata once for all files - let file_metadata: HashMap = filenames - .iter() - .filter_map(|filename| { - let file_path = base_path.join(filename); - Self::get_file_metadata(&file_path) - .ok() - .map(|m| (filename.clone(), m)) - }) - .collect(); + pub fn check_cache(&self, filenames: &[String], base_path: &Path) -> Option { + let cache_key = Self::generate_cache_key(filenames); + let entry = self.entries.get(&cache_key)?; - let cache_key = self.generate_cache_key(filenames); - - let cached_response = self.entries.get(&cache_key).and_then(|entry| { - // Validate all files are unchanged using pre-fetched metadata - let all_unchanged = filenames.iter().all(|filename| { - match ( - file_metadata.get(filename), - entry.file_metadata.get(filename), - ) { - (Some(current), Some(cached)) => current == cached, - _ => false, - } - }); - - if all_unchanged { - println!("Using cached response (timestamp: {})", entry.timestamp); - Some(entry.response.clone()) - } else { - None - } + let all_unchanged = filenames.iter().all(|filename| { + let file_path = base_path.join(filename); + FileMetadata::from_path(&file_path).ok().as_ref() == entry.file_metadata.get(filename) }); - CacheCheckResult { - cached_response, - file_metadata, + if all_unchanged { + println!("Using cached response (timestamp: {})", entry.timestamp); + Some(entry.response.clone()) + } else { + None } } - /// Cache response using pre-fetched metadata (avoids double metadata lookup) - pub fn cache_response_with_metadata( - &mut self, - filenames: &[String], - response: OrganizationPlan, - file_metadata: HashMap, - ) { - let cache_key = self.generate_cache_key(filenames); - - let timestamp = SystemTime::now() - .duration_since(UNIX_EPOCH) - .unwrap_or_default() - .as_secs(); - - let entry = CacheEntry { - response, - timestamp, - file_metadata, - }; - - self.entries.insert(cache_key, entry); - - if self.entries.len() > self.max_entries { - self.evict_oldest(); - } - - println!("Cached response for {} files", filenames.len()); - } - - /// Legacy method - checks cache for a response (fetches metadata internally) - #[deprecated( - note = "Use check_cache() + cache_response_with_metadata() to avoid double metadata lookups" - )] - pub fn get_cached_response( - &self, - filenames: &[String], - base_path: &Path, - ) -> Option { - let result = self.check_cache(filenames, base_path); - result.cached_response - } - - /// Legacy method - caches a response (fetches metadata internally) - #[deprecated(note = "Use cache_response_with_metadata() with pre-fetched metadata")] pub fn cache_response( &mut self, filenames: &[String], response: OrganizationPlan, base_path: &Path, ) { - let cache_key = self.generate_cache_key(filenames); - let mut file_metadata = HashMap::new(); + let cache_key = Self::generate_cache_key(filenames); - for filename in filenames { - let file_path = base_path.join(filename); - if let Ok(metadata) = Self::get_file_metadata(&file_path) { - file_metadata.insert(filename.clone(), metadata); - } - } + let file_metadata: HashMap = filenames + .iter() + .filter_map(|filename| { + let file_path = base_path.join(filename); + FileMetadata::from_path(&file_path) + .ok() + .map(|m| (filename.clone(), m)) + }) + .collect(); let timestamp = SystemTime::now() .duration_since(UNIX_EPOCH) @@ -192,12 +118,12 @@ impl Cache { println!("Cached response for {} files", filenames.len()); } - fn generate_cache_key(&self, filenames: &[String]) -> String { - let mut sorted_filenames = filenames.to_vec(); - sorted_filenames.sort(); - + fn generate_cache_key(filenames: &[String]) -> String { let mut hasher = Hasher::new(); - for filename in &sorted_filenames { + let mut sorted: Vec<_> = filenames.iter().collect(); + sorted.sort(); + + for filename in sorted { hasher.update(filename.as_bytes()); hasher.update(b"|"); } @@ -205,16 +131,6 @@ impl Cache { hasher.finalize().to_hex().to_string() } - fn get_file_metadata(file_path: &Path) -> Result> { - let metadata = fs::metadata(file_path)?; - let modified = metadata.modified()?.duration_since(UNIX_EPOCH)?.as_secs(); - - Ok(FileMetadata { - size: metadata.len(), - modified, - }) - } - pub fn cleanup_old_entries(&mut self, max_age_seconds: u64) { let current_time = SystemTime::now() .duration_since(UNIX_EPOCH) @@ -231,8 +147,8 @@ impl Cache { println!("Cleaned up {} old cache entries", removed_count); } - if self.entries.len() > self.max_entries { - self.compact_cache(); + while self.entries.len() > self.max_entries { + self.evict_oldest(); } } @@ -248,9 +164,11 @@ impl Cache { } } - fn compact_cache(&mut self) { - while self.entries.len() > self.max_entries { - self.evict_oldest(); - } + pub fn len(&self) -> usize { + self.entries.len() + } + + pub fn is_empty(&self) -> bool { + self.entries.is_empty() } } diff --git a/src/storage/mod.rs b/src/storage/mod.rs index 8c97dde..3e9d278 100644 --- a/src/storage/mod.rs +++ b/src/storage/mod.rs @@ -1,7 +1,7 @@ pub mod cache; pub mod undo_log; -pub use cache::{Cache, CacheCheckResult}; +pub use cache::Cache; pub use undo_log::UndoLog; #[cfg(test)] diff --git a/tests/integration_online.rs b/tests/integration_online.rs index 48675c9..19b3399 100644 --- a/tests/integration_online.rs +++ b/tests/integration_online.rs @@ -11,7 +11,7 @@ //! - File reading for deep inspection //! - Integration between components -use noentropy::files::{FileBatch, is_text_file, read_file_sample}; +use noentropy::files::{is_text_file, read_file_sample, FileBatch}; use noentropy::models::{FileCategory, OrganizationPlan}; use noentropy::storage::{Cache, UndoLog}; use std::collections::HashMap; @@ -53,18 +53,18 @@ fn test_cache_stores_and_retrieves_organization_plans() { }], }; - // Check cache (will also fetch metadata) - let check_result = cache.check_cache(&filenames, temp_dir.path()); - assert!(check_result.cached_response.is_none()); + // Check cache (returns None on miss) + let cached = cache.check_cache(&filenames, temp_dir.path()); + assert!(cached.is_none()); - // Store in cache with metadata - cache.cache_response_with_metadata(&filenames, plan.clone(), check_result.file_metadata); + // Store in cache + cache.cache_response(&filenames, plan.clone(), temp_dir.path()); // Retrieve from cache - let check_result2 = cache.check_cache(&filenames, temp_dir.path()); - assert!(check_result2.cached_response.is_some()); + let cached2 = cache.check_cache(&filenames, temp_dir.path()); + assert!(cached2.is_some()); - let cached = check_result2.cached_response.unwrap(); + let cached = cached2.unwrap(); assert_eq!(cached.files.len(), 1); assert_eq!(cached.files[0].filename, "test.txt"); } @@ -84,8 +84,7 @@ fn test_cache_invalidates_on_file_modification() { }; // Cache the response - let check_result = cache.check_cache(&filenames, temp_dir.path()); - cache.cache_response_with_metadata(&filenames, plan, check_result.file_metadata); + cache.cache_response(&filenames, plan, temp_dir.path()); // Wait longer to ensure filesystem timestamp changes (at least 1 second for most filesystems) std::thread::sleep(std::time::Duration::from_secs(2)); @@ -101,14 +100,14 @@ fn test_cache_invalidates_on_file_modification() { let _ = fs::metadata(temp_dir.path().join("test.txt")); // Cache should be invalidated due to modification time change - let check_result2 = cache.check_cache(&filenames, temp_dir.path()); + let cached = cache.check_cache(&filenames, temp_dir.path()); // Note: Cache invalidation depends on file metadata (size/mtime) changing. // If the filesystem has coarse timestamp granularity, this test may be flaky. // The important behavior is that the cache CAN detect file changes. // For a more robust test, we check that the cache at least loads without error. // In production, files are typically modified minutes/hours apart. - if check_result2.cached_response.is_some() { + if cached.is_some() { // If cache wasn't invalidated, it means the filesystem timestamp // didn't change within our sleep window - this is acceptable // as long as the mechanism works for real-world use cases @@ -151,12 +150,11 @@ fn test_cache_handles_multiple_files() { ], }; - let check_result = cache.check_cache(&filenames, temp_dir.path()); - cache.cache_response_with_metadata(&filenames, plan.clone(), check_result.file_metadata); + cache.cache_response(&filenames, plan.clone(), temp_dir.path()); - let check_result2 = cache.check_cache(&filenames, temp_dir.path()); - assert!(check_result2.cached_response.is_some()); - assert_eq!(check_result2.cached_response.unwrap().files.len(), 3); + let cached = cache.check_cache(&filenames, temp_dir.path()); + assert!(cached.is_some()); + assert_eq!(cached.unwrap().files.len(), 3); } #[test]