>(config_path: Option) -> Result<()
log::info!("Loading init config from: {}", path.as_ref().display());
InitConfig::load(path.as_ref())?
} else {
- InitConfig::load_default()?
- .ok_or_else(|| anyhow::anyhow!("No init config file found"))?
+ InitConfig::load_default()?.ok_or_else(|| anyhow::anyhow!("No init config file found"))?
};
- println!(
- "{}",
- "📄 Initializing from config file...".cyan().bold()
- );
+ println!("{}", "📄 Initializing from config file...".cyan().bold());
// Convert to onboarding config
let onboarding_config = init_config.to_onboarding_config()?;
@@ -122,7 +118,11 @@ pub fn run_init_from_config>(config_path: Option) -> Result<()
.context("Failed to save filter configuration")?;
println!("{}", "✓ Initialization complete!".green().bold());
- println!(" {} {}", "Repo:".cyan(), onboarding_config.repo_path.display());
+ println!(
+ " {} {}",
+ "Repo:".cyan(),
+ onboarding_config.repo_path.display()
+ );
if let Some(ref url) = onboarding_config.remote_url {
println!(" {} {}", "Remote:".cyan(), url);
}
diff --git a/src/logger.rs b/src/logger.rs
index b6898b16..b1e1b14b 100644
--- a/src/logger.rs
+++ b/src/logger.rs
@@ -61,9 +61,7 @@ pub fn init_logger() -> Result<()> {
.ok(); // Ignore error if logger is already initialized
// Also log initialization to file
- log_to_file(&format!(
- "Logger initialized with level: {default_level:?}"
- ))?;
+ log_to_file(&format!("Logger initialized with level: {default_level:?}"))?;
Ok(())
}
diff --git a/src/main.rs b/src/main.rs
index d4329cdc..87c9e050 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -403,7 +403,12 @@ fn main() -> Result<()> {
}
match command {
- Commands::Init { local, remote, clone, config } => {
+ Commands::Init {
+ local,
+ remote,
+ clone,
+ config,
+ } => {
// If config file is provided, use non-interactive init
if config.is_some() {
run_init_from_config(config)?;
@@ -434,10 +439,7 @@ fn main() -> Result<()> {
filter::FilterConfig::default().save()?;
}
- println!(
- "{}",
- "Clone and initialization complete!".green().bold()
- );
+ println!("{}", "Clone and initialization complete!".green().bold());
} else if let Some(local_path) = local {
// Use CLI args for init (local path)
sync::init_sync_repo(&local_path, remote.as_deref())?;
@@ -447,7 +449,12 @@ fn main() -> Result<()> {
println!(
"{}",
- format!("Cloning from {} to {}...", remote_url, default_path.display()).cyan()
+ format!(
+ "Cloning from {} to {}...",
+ remote_url,
+ default_path.display()
+ )
+ .cyan()
);
scm::clone(&remote_url, &default_path)?;
@@ -459,10 +466,7 @@ fn main() -> Result<()> {
filter::FilterConfig::default().save()?;
}
- println!(
- "{}",
- "Clone and initialization complete!".green().bold()
- );
+ println!("{}", "Clone and initialization complete!".green().bold());
} else {
// No args provided, try config file first, then fall back to interactive onboarding
if !try_init_from_config()? {
@@ -622,7 +626,11 @@ fn main() -> Result<()> {
sync::remove_remote(&name)?;
}
},
- Commands::Undo { operation, verbose, quiet } => {
+ Commands::Undo {
+ operation,
+ verbose,
+ quiet,
+ } => {
// Determine verbosity level
let verbosity = if verbose {
VerbosityLevel::Verbose
@@ -640,7 +648,7 @@ fn main() -> Result<()> {
handle_undo_push(preview, verbosity)?;
}
}
- },
+ }
Commands::History { action } => match action {
HistoryAction::List { limit } => {
handle_history_list(limit)?;
diff --git a/src/merge.rs b/src/merge.rs
index d9ae21f8..aa7eb01f 100644
--- a/src/merge.rs
+++ b/src/merge.rs
@@ -275,8 +275,7 @@ impl<'a> SmartMerger<'a> {
) -> MessageNode {
// Phase 1: BFS to collect all UUIDs reachable from this root
let mut processing_order: Vec = Vec::new();
- let mut queue: std::collections::VecDeque =
- std::collections::VecDeque::new();
+ let mut queue: std::collections::VecDeque = std::collections::VecDeque::new();
queue.push_back(root_uuid.to_string());
while let Some(uuid) = queue.pop_front() {
diff --git a/src/onboarding.rs b/src/onboarding.rs
index 8c3244b3..badd96a6 100644
--- a/src/onboarding.rs
+++ b/src/onboarding.rs
@@ -128,7 +128,10 @@ impl InitConfig {
if let Ok(path) = std::env::var("CLAUDE_CODE_SYNC_INIT_CONFIG") {
let path = PathBuf::from(&path);
if path.exists() {
- log::info!("Loading init config from CLAUDE_CODE_SYNC_INIT_CONFIG: {}", path.display());
+ log::info!(
+ "Loading init config from CLAUDE_CODE_SYNC_INIT_CONFIG: {}",
+ path.display()
+ );
return Ok(Some(Self::load(&path)?));
}
}
@@ -553,7 +556,10 @@ mod tests {
"#;
let config: InitConfig = toml::from_str(toml).unwrap();
assert_eq!(config.repo_path, "~/claude-sync");
- assert_eq!(config.remote_url, Some("https://github.com/user/repo.git".to_string()));
+ assert_eq!(
+ config.remote_url,
+ Some("https://github.com/user/repo.git".to_string())
+ );
assert!(config.clone);
assert!(config.exclude_attachments);
assert_eq!(config.exclude_older_than_days, Some(30));
@@ -629,7 +635,10 @@ mod tests {
};
let onboarding = config.to_onboarding_config().unwrap();
assert_eq!(onboarding.repo_path, PathBuf::from("/tmp/test"));
- assert_eq!(onboarding.remote_url, Some("https://github.com/user/repo.git".to_string()));
+ assert_eq!(
+ onboarding.remote_url,
+ Some("https://github.com/user/repo.git".to_string())
+ );
assert!(onboarding.is_cloned);
assert!(onboarding.exclude_attachments);
assert_eq!(onboarding.exclude_older_than_days, Some(30));
diff --git a/src/scm/git.rs b/src/scm/git.rs
index be90d8c9..e8510215 100644
--- a/src/scm/git.rs
+++ b/src/scm/git.rs
@@ -60,8 +60,9 @@ impl GitScm {
/// Clone a remote repository.
pub fn clone(url: &str, path: &Path) -> Result {
if let Some(parent) = path.parent() {
- std::fs::create_dir_all(parent)
- .with_context(|| format!("Failed to create parent directory for '{}'", path.display()))?;
+ std::fs::create_dir_all(parent).with_context(|| {
+ format!("Failed to create parent directory for '{}'", path.display())
+ })?;
}
let output = Command::new("git")
@@ -184,7 +185,8 @@ impl Scm for GitScm {
4. Remote branch protection rules\n\n\
For HTTPS: Run 'git config --global credential.helper store' and try again\n\
For SSH: Ensure SSH keys are set up with 'ssh -T git@github.com'",
- remote, stderr
+ remote,
+ stderr
));
}
@@ -202,7 +204,8 @@ impl Scm for GitScm {
let stderr = String::from_utf8_lossy(&output.stderr);
return Err(anyhow!(
"Failed to pull from remote '{}': {}",
- remote, stderr
+ remote,
+ stderr
));
}
@@ -275,7 +278,8 @@ mod tests {
assert!(!scm.has_remote("origin"));
- scm.add_remote("origin", "https://github.com/test/repo.git").unwrap();
+ scm.add_remote("origin", "https://github.com/test/repo.git")
+ .unwrap();
assert!(scm.has_remote("origin"));
assert!(!scm.has_remote("upstream"));
}
diff --git a/src/scm/hg.rs b/src/scm/hg.rs
index b2100552..f38d0d92 100644
--- a/src/scm/hg.rs
+++ b/src/scm/hg.rs
@@ -86,7 +86,6 @@ impl HgScm {
Ok(String::from_utf8_lossy(&output.stdout).trim().to_string())
}
-
/// Get path to .hg/hgrc config file.
fn hgrc_path(&self) -> PathBuf {
self.path.join(".hg").join("hgrc")
@@ -348,13 +347,15 @@ mod tests {
assert!(!scm.has_remote("origin"));
- scm.add_remote("origin", "https://example.com/repo").unwrap();
+ scm.add_remote("origin", "https://example.com/repo")
+ .unwrap();
assert!(scm.has_remote("origin"));
let url = scm.get_remote_url("origin").unwrap();
assert_eq!(url, "https://example.com/repo");
- scm.set_remote_url("origin", "https://example.com/new").unwrap();
+ scm.set_remote_url("origin", "https://example.com/new")
+ .unwrap();
let new_url = scm.get_remote_url("origin").unwrap();
assert_eq!(new_url, "https://example.com/new");
@@ -374,8 +375,10 @@ mod tests {
assert!(scm.list_remotes().unwrap().is_empty());
- scm.add_remote("origin", "https://example.com/origin").unwrap();
- scm.add_remote("upstream", "https://example.com/upstream").unwrap();
+ scm.add_remote("origin", "https://example.com/origin")
+ .unwrap();
+ scm.add_remote("upstream", "https://example.com/upstream")
+ .unwrap();
let remotes = scm.list_remotes().unwrap();
assert_eq!(remotes.len(), 2);
diff --git a/src/sync/discovery.rs b/src/sync/discovery.rs
index eb435cf7..8a8e00f4 100644
--- a/src/sync/discovery.rs
+++ b/src/sync/discovery.rs
@@ -12,6 +12,14 @@ pub(crate) const LARGE_FILE_WARNING_THRESHOLD: u64 = 10 * 1024 * 1024;
/// Get the Claude Code home directory (`~/.claude`)
pub(crate) fn claude_home_dir() -> Result {
+ // Override for tests/automation, mirroring CLAUDE_CODE_SYNC_CONFIG_DIR:
+ // faking HOME cannot redirect dirs::home_dir() on Windows, where the
+ // profile comes from the known-folder API rather than the environment.
+ if let Ok(override_dir) = std::env::var("CLAUDE_CODE_SYNC_CLAUDE_DIR") {
+ if !override_dir.is_empty() {
+ return Ok(PathBuf::from(override_dir));
+ }
+ }
let home = dirs::home_dir().context("Failed to get home directory")?;
Ok(home.join(".claude"))
}
@@ -118,7 +126,10 @@ pub fn extract_project_name(encoded_path: &str) -> &str {
/// # Returns
/// - `Some(PathBuf)` if exactly one matching project directory is found
/// - `None` if no match found or multiple matches (ambiguous)
-pub fn find_local_project_by_name(claude_projects_dir: &Path, project_name: &str) -> Option {
+pub fn find_local_project_by_name(
+ claude_projects_dir: &Path,
+ project_name: &str,
+) -> Option {
let entries = std::fs::read_dir(claude_projects_dir).ok()?;
let matches: Vec = entries
diff --git a/src/sync/mod.rs b/src/sync/mod.rs
index d1014eb4..268935a1 100644
--- a/src/sync/mod.rs
+++ b/src/sync/mod.rs
@@ -46,7 +46,14 @@ pub fn sync_bidirectional(
}
// Then, push local changes
- push_history(commit_message, true, branch, exclude_attachments, interactive, verbosity)?;
+ push_history(
+ commit_message,
+ true,
+ branch,
+ exclude_attachments,
+ interactive,
+ verbosity,
+ )?;
if verbosity == VerbosityLevel::Quiet {
println!("Sync complete");
diff --git a/src/sync/pull.rs b/src/sync/pull.rs
index 4375dc18..ac4bd48a 100644
--- a/src/sync/pull.rs
+++ b/src/sync/pull.rs
@@ -91,11 +91,8 @@ pub fn pull_history(
// ============================================================================
// ARTIFACT PULL PLAN (read-only, so the snapshot below can cover it)
// ============================================================================
- let artifact_plan = crate::artifacts::engine::plan_pull(
- &claude_home_dir()?,
- &state.sync_repo_path,
- &filter,
- )?;
+ let artifact_plan =
+ crate::artifacts::engine::plan_pull(&claude_home_dir()?, &state.sync_repo_path, &filter)?;
// ============================================================================
// SNAPSHOT CREATION: Only backup files that will actually change
@@ -162,7 +159,11 @@ pub fn pull_history(
println!();
println!("{}", "Pull Summary:".bold().cyan());
println!(" {} Local sessions: {}", "•".cyan(), local_sessions.len());
- println!(" {} Remote sessions: {}", "•".cyan(), remote_sessions.len());
+ println!(
+ " {} Remote sessions: {}",
+ "•".cyan(),
+ remote_sessions.len()
+ );
println!();
}
@@ -174,7 +175,12 @@ pub fn pull_history(
.strip_prefix(&remote_projects_dir)
.unwrap_or(Path::new(&session.file_path));
- println!(" {}. {} ({} messages)", idx + 1, relative_path.display(), session.message_count());
+ println!(
+ " {}. {} ({} messages)",
+ idx + 1,
+ relative_path.display(),
+ session.message_count()
+ );
}
if remote_sessions.len() > 20 {
println!(" ... and {} more", remote_sessions.len() - 20);
@@ -184,11 +190,14 @@ pub fn pull_history(
// Interactive confirmation
if interactive && interactive_conflict::is_interactive() {
- let confirm = Confirm::new("Do you want to proceed with pulling and merging these changes?")
- .with_default(true)
- .with_help_message("This will merge remote sessions into your local Claude Code history")
- .prompt()
- .context("Failed to get confirmation")?;
+ let confirm =
+ Confirm::new("Do you want to proceed with pulling and merging these changes?")
+ .with_default(true)
+ .with_help_message(
+ "This will merge remote sessions into your local Claude Code history",
+ )
+ .prompt()
+ .context("Failed to get confirmation")?;
if !confirm {
println!("\n{}", "Pull cancelled.".yellow());
@@ -465,7 +474,10 @@ pub fn pull_history(
.unwrap_or_else(|_| remote_relative.to_path_buf());
(dest, tracking_path)
} else {
- log::warn!("Could not extract filename from remote path: {:?}", remote_relative);
+ log::warn!(
+ "Could not extract filename from remote path: {:?}",
+ remote_relative
+ );
skipped_no_local_match += 1;
continue; // Skip this session
}
@@ -534,10 +546,7 @@ pub fn pull_history(
artifact_report.total_modified()
);
if artifact_report.total_modified() > 0 {
- println!(
- " {}",
- "Undo with: claude-code-sync undo pull".dimmed()
- );
+ println!(" {}", "Undo with: claude-code-sync undo pull".dimmed());
}
}
diff --git a/src/sync/push.rs b/src/sync/push.rs
index 5f8ad051..cac6167b 100644
--- a/src/sync/push.rs
+++ b/src/sync/push.rs
@@ -186,12 +186,15 @@ pub fn push_history(
println!();
println!(
"{}",
- "Warning: Multiple projects map to the same name:".yellow().bold()
+ "Warning: Multiple projects map to the same name:"
+ .yellow()
+ .bold()
);
for (name, paths) in &collisions {
println!(" {} -> {} locations:", name.cyan(), paths.len());
for path in paths.iter().take(3) {
- let display_path = path.file_name()
+ let display_path = path
+ .file_name()
.and_then(|n| n.to_str())
.unwrap_or("unknown");
println!(" - {}", display_path);
@@ -243,11 +246,7 @@ pub fn push_history(
entry.operation,
) {
Ok(summary) => pushed_conversations.push(summary),
- Err(e) => log::warn!(
- "Failed to create summary for {}: {}",
- relative_path_str,
- e
- ),
+ Err(e) => log::warn!("Failed to create summary for {}: {}", relative_path_str, e),
}
}
@@ -342,11 +341,7 @@ pub fn push_history(
if let Some(ref hash) = commit_before_push {
if verbosity != VerbosityLevel::Quiet {
- println!(
- " {} Recorded commit {} for undo",
- "✓".green(),
- &hash[..8]
- );
+ println!(" {} Recorded commit {} for undo", "✓".green(), &hash[..8]);
}
} else if verbosity != VerbosityLevel::Quiet {
println!(
diff --git a/src/sync/remote.rs b/src/sync/remote.rs
index 8bda7100..f9cfc138 100644
--- a/src/sync/remote.rs
+++ b/src/sync/remote.rs
@@ -63,7 +63,11 @@ pub fn set_remote(name: &str, url: &str) -> Result<()> {
let repo = scm::open(&state.sync_repo_path)?;
// Validate URL format
- if !url.starts_with("http://") && !url.starts_with("https://") && !url.starts_with("git@") && !url.starts_with("ssh://") {
+ if !url.starts_with("http://")
+ && !url.starts_with("https://")
+ && !url.starts_with("git@")
+ && !url.starts_with("ssh://")
+ {
return Err(anyhow!(
"Invalid URL format: {url}\n\
\n\
diff --git a/src/undo/cleanup.rs b/src/undo/cleanup.rs
index 1ab0fd59..ce04c5e8 100644
--- a/src/undo/cleanup.rs
+++ b/src/undo/cleanup.rs
@@ -3,8 +3,8 @@ use log::warn;
use std::fs;
use std::path::Path;
-use crate::history::OperationType;
use super::snapshot::Snapshot;
+use crate::history::OperationType;
/// Configuration for snapshot cleanup
pub struct SnapshotCleanupConfig {
diff --git a/src/undo/mod.rs b/src/undo/mod.rs
index 7f9a2d86..8cdf5f94 100644
--- a/src/undo/mod.rs
+++ b/src/undo/mod.rs
@@ -4,28 +4,30 @@
//! Snapshots enable undoing pull operations (by restoring files) and push operations
//! (by resetting Git commits). Includes validation and security checks for safe restoration.
-mod snapshot;
-mod restore;
-mod preview;
-mod operations;
mod cleanup;
+mod operations;
+mod preview;
+mod restore;
+mod snapshot;
// Re-export public types and functions to maintain API compatibility
-pub use snapshot::Snapshot;
-pub use preview::{VerbosityLevel, preview_undo_pull, preview_undo_push};
+pub use cleanup::{cleanup_old_snapshots, SnapshotCleanupConfig};
pub use operations::{undo_pull, undo_push};
-pub use cleanup::{SnapshotCleanupConfig, cleanup_old_snapshots};
+pub use preview::{preview_undo_pull, preview_undo_push, VerbosityLevel};
+pub use snapshot::Snapshot;
// These are part of the public API but currently only used in tests
#[allow(unused_imports)]
-pub use preview::UndoPreview;
-#[allow(unused_imports)]
pub use cleanup::cleanup_old_snapshots_with_dir;
+#[allow(unused_imports)]
+pub use preview::UndoPreview;
#[cfg(test)]
mod tests {
use super::*;
- use crate::history::{ConversationSummary, OperationRecord, OperationType, SyncOperation, OperationHistory};
+ use crate::history::{
+ ConversationSummary, OperationHistory, OperationRecord, OperationType, SyncOperation,
+ };
use crate::scm::{self, Scm};
use std::collections::HashMap;
use std::fs;
@@ -707,7 +709,6 @@ mod tests {
);
}
-
#[test]
fn test_undo_pull_transaction_safety() {
// This test verifies that history is updated FIRST, then files are restored.
@@ -897,9 +898,19 @@ mod tests {
snapshot.save_to_disk(Some(&snapshots_dir)).unwrap();
// Verify it's a full snapshot
- assert!(snapshot.base_snapshot_id.is_none(), "First snapshot should not have a base");
- assert_eq!(snapshot.files.len(), 2, "First snapshot should contain all files");
- assert!(snapshot.deleted_files.is_empty(), "First snapshot should have no deleted files");
+ assert!(
+ snapshot.base_snapshot_id.is_none(),
+ "First snapshot should not have a base"
+ );
+ assert_eq!(
+ snapshot.files.len(),
+ 2,
+ "First snapshot should contain all files"
+ );
+ assert!(
+ snapshot.deleted_files.is_empty(),
+ "First snapshot should have no deleted files"
+ );
}
#[test]
@@ -939,7 +950,10 @@ mod tests {
snapshot2.save_to_disk(Some(&snapshots_dir)).unwrap();
// Verify it's a differential snapshot
- assert!(snapshot2.base_snapshot_id.is_some(), "Second snapshot should have a base");
+ assert!(
+ snapshot2.base_snapshot_id.is_some(),
+ "Second snapshot should have a base"
+ );
assert_eq!(
snapshot2.base_snapshot_id.as_ref().unwrap(),
&snapshot1.snapshot_id,
@@ -947,10 +961,20 @@ mod tests {
);
// Should only contain changed file (file1) and new file (file3), not file2
- assert_eq!(snapshot2.files.len(), 2, "Should only contain changed and new files");
- assert!(snapshot2.files.contains_key(&file1.to_string_lossy().to_string()));
- assert!(snapshot2.files.contains_key(&file3.to_string_lossy().to_string()));
- assert!(!snapshot2.files.contains_key(&file2.to_string_lossy().to_string()));
+ assert_eq!(
+ snapshot2.files.len(),
+ 2,
+ "Should only contain changed and new files"
+ );
+ assert!(snapshot2
+ .files
+ .contains_key(&file1.to_string_lossy().to_string()));
+ assert!(snapshot2
+ .files
+ .contains_key(&file3.to_string_lossy().to_string()));
+ assert!(!snapshot2
+ .files
+ .contains_key(&file2.to_string_lossy().to_string()));
}
#[test]
@@ -988,9 +1012,15 @@ mod tests {
snapshot2.save_to_disk(Some(&snapshots_dir)).unwrap();
// Verify deletion tracking
- assert_eq!(snapshot2.deleted_files.len(), 1, "Should track one deleted file");
+ assert_eq!(
+ snapshot2.deleted_files.len(),
+ 1,
+ "Should track one deleted file"
+ );
assert!(
- snapshot2.deleted_files.contains(&file2.to_string_lossy().to_string()),
+ snapshot2
+ .deleted_files
+ .contains(&file2.to_string_lossy().to_string()),
"Should track file2 as deleted"
);
}
@@ -1030,13 +1060,34 @@ mod tests {
snapshot2.save_to_disk(Some(&snapshots_dir)).unwrap();
// Reconstruct full state from differential snapshot
- let full_state = snapshot2.reconstruct_full_state_with_dir(Some(&snapshots_dir)).unwrap();
+ let full_state = snapshot2
+ .reconstruct_full_state_with_dir(Some(&snapshots_dir))
+ .unwrap();
// Should contain all three files with correct content
- assert_eq!(full_state.len(), 3, "Should have 3 files after reconstruction");
- assert_eq!(full_state.get(&file1.to_string_lossy().to_string()).unwrap(), b"v2");
- assert_eq!(full_state.get(&file2.to_string_lossy().to_string()).unwrap(), b"v1"); // Unchanged from base
- assert_eq!(full_state.get(&file3.to_string_lossy().to_string()).unwrap(), b"v2"); // New file
+ assert_eq!(
+ full_state.len(),
+ 3,
+ "Should have 3 files after reconstruction"
+ );
+ assert_eq!(
+ full_state
+ .get(&file1.to_string_lossy().to_string())
+ .unwrap(),
+ b"v2"
+ );
+ assert_eq!(
+ full_state
+ .get(&file2.to_string_lossy().to_string())
+ .unwrap(),
+ b"v1"
+ ); // Unchanged from base
+ assert_eq!(
+ full_state
+ .get(&file3.to_string_lossy().to_string())
+ .unwrap(),
+ b"v2"
+ ); // New file
}
#[test]
@@ -1075,7 +1126,9 @@ mod tests {
fs::write(&file2, b"should_be_deleted").unwrap();
// Restore snapshot2 which should delete file2
- snapshot2.restore_with_base_and_snapshots(Some(temp_dir.path()), Some(&snapshots_dir)).unwrap();
+ snapshot2
+ .restore_with_base_and_snapshots(Some(temp_dir.path()), Some(&snapshots_dir))
+ .unwrap();
// Verify file1 exists and file2 was deleted
assert!(file1.exists(), "file1 should exist after restore");
@@ -1107,7 +1160,10 @@ mod tests {
let result = snapshot.reconstruct_full_state();
assert!(result.is_err(), "Should fail when base snapshot is missing");
assert!(
- result.unwrap_err().to_string().contains("Base snapshot not found"),
+ result
+ .unwrap_err()
+ .to_string()
+ .contains("Base snapshot not found"),
"Error should mention missing base snapshot"
);
}
@@ -1136,19 +1192,28 @@ mod tests {
}
// Verify chain structure
- assert!(snapshots[0].base_snapshot_id.is_none(), "First should have no base");
+ assert!(
+ snapshots[0].base_snapshot_id.is_none(),
+ "First should have no base"
+ );
for i in 1..5 {
assert_eq!(
snapshots[i].base_snapshot_id.as_ref().unwrap(),
&snapshots[i - 1].snapshot_id,
- "Snapshot {} should reference snapshot {}", i, i - 1
+ "Snapshot {} should reference snapshot {}",
+ i,
+ i - 1
);
}
// Reconstruct from the last snapshot
- let full_state = snapshots[4].reconstruct_full_state_with_dir(Some(&snapshots_dir)).unwrap();
+ let full_state = snapshots[4]
+ .reconstruct_full_state_with_dir(Some(&snapshots_dir))
+ .unwrap();
assert_eq!(
- full_state.get(&file1.to_string_lossy().to_string()).unwrap(),
+ full_state
+ .get(&file1.to_string_lossy().to_string())
+ .unwrap(),
b"version_5",
"Should reconstruct to the latest version"
);
@@ -1185,7 +1250,8 @@ mod tests {
max_age_days: 0, // Only count matters, not age
};
- let deleted = cleanup_old_snapshots_with_dir(Some(config), false, Some(&snapshots_dir)).unwrap();
+ let deleted =
+ cleanup_old_snapshots_with_dir(Some(config), false, Some(&snapshots_dir)).unwrap();
assert_eq!(deleted, 5, "Should delete 5 old snapshots");
// Count remaining snapshots
@@ -1224,7 +1290,8 @@ mod tests {
max_age_days: 50,
};
- let deleted = cleanup_old_snapshots_with_dir(Some(config), false, Some(&snapshots_dir)).unwrap();
+ let deleted =
+ cleanup_old_snapshots_with_dir(Some(config), false, Some(&snapshots_dir)).unwrap();
// Snapshots are at days: 5, 15, 25, 35, 45, 55, 65, 75, 85, 95
// Age threshold is now - 50 days
@@ -1275,14 +1342,18 @@ mod tests {
max_age_days: 0, // Don't keep by age
};
- let deleted = cleanup_old_snapshots_with_dir(Some(config), false, Some(&snapshots_dir)).unwrap();
+ let deleted =
+ cleanup_old_snapshots_with_dir(Some(config), false, Some(&snapshots_dir)).unwrap();
// Should delete 7 pull + 7 push = 14 total
assert_eq!(deleted, 14, "Should delete 14 old snapshots");
// Should keep 3 pull + 3 push = 6 total
let remaining = fs::read_dir(&snapshots_dir).unwrap().count();
- assert_eq!(remaining, 6, "Should have 6 snapshots remaining (3 per type)");
+ assert_eq!(
+ remaining, 6,
+ "Should have 6 snapshots remaining (3 per type)"
+ );
}
#[test]
@@ -1312,11 +1383,15 @@ mod tests {
};
// Dry run should report but not delete
- let deleted = cleanup_old_snapshots_with_dir(Some(config), true, Some(&snapshots_dir)).unwrap();
+ let deleted =
+ cleanup_old_snapshots_with_dir(Some(config), true, Some(&snapshots_dir)).unwrap();
assert_eq!(deleted, 7, "Should report 7 snapshots would be deleted");
// All snapshots should still exist
let remaining = fs::read_dir(&snapshots_dir).unwrap().count();
- assert_eq!(remaining, 10, "All snapshots should still exist after dry run");
+ assert_eq!(
+ remaining, 10,
+ "All snapshots should still exist after dry run"
+ );
}
}
diff --git a/src/undo/operations.rs b/src/undo/operations.rs
index dea3af03..d3e75343 100644
--- a/src/undo/operations.rs
+++ b/src/undo/operations.rs
@@ -2,9 +2,9 @@ use anyhow::{anyhow, Context, Result};
use std::fs;
use std::path::{Path, PathBuf};
+use super::snapshot::Snapshot;
use crate::history::{OperationHistory, OperationType};
use crate::scm;
-use super::snapshot::Snapshot;
/// Undo the last pull operation
///
@@ -140,9 +140,9 @@ pub fn undo_push(repo_path: &Path, history_path: Option) -> Result "Pull",
OperationType::Push => "Push",
};
- println!("Undo {}: {} conversations affected", op_type, self.conversation_count);
+ println!(
+ "Undo {}: {} conversations affected",
+ op_type, self.conversation_count
+ );
if !self.affected_files.is_empty() {
println!(" {} files will be restored", self.affected_files.len());
}
@@ -151,7 +154,12 @@ impl UndoPreview {
} else {
commit.as_str()
};
- println!("{} {} (full: {})", "Will reset to:".bold(), short_hash.yellow(), commit.dimmed());
+ println!(
+ "{} {} (full: {})",
+ "Will reset to:".bold(),
+ short_hash.yellow(),
+ commit.dimmed()
+ );
}
println!(
@@ -161,7 +169,11 @@ impl UndoPreview {
);
if !self.affected_files.is_empty() {
- println!("\n{} ({} total)", "Files to be restored:".bold(), self.affected_files.len());
+ println!(
+ "\n{} ({} total)",
+ "Files to be restored:".bold(),
+ self.affected_files.len()
+ );
for (idx, file) in self.affected_files.iter().enumerate() {
println!(" {}. {}", idx + 1, file);
@@ -187,9 +199,12 @@ impl UndoPreview {
let days = time_diff.num_days();
let hours = time_diff.num_hours() % 24;
let mins = time_diff.num_minutes() % 60;
- println!(" {} {} days, {} hours, {} minutes ago",
+ println!(
+ " {} {} days, {} hours, {} minutes ago",
"Age:".dimmed(),
- days, hours, mins
+ days,
+ hours,
+ mins
);
}
diff --git a/src/undo/restore.rs b/src/undo/restore.rs
index dc12d12f..5508a766 100644
--- a/src/undo/restore.rs
+++ b/src/undo/restore.rs
@@ -51,9 +51,8 @@ impl Snapshot {
// Validate the path is within allowed directory
if let Ok(canonical) = path.canonicalize() {
if canonical.starts_with(&allowed_base) && path.exists() {
- fs::remove_file(&path).with_context(|| {
- format!("Failed to delete file: {}", path.display())
- })?;
+ fs::remove_file(&path)
+ .with_context(|| format!("Failed to delete file: {}", path.display()))?;
}
}
}
diff --git a/src/undo/snapshot.rs b/src/undo/snapshot.rs
index d372b6dd..e172d914 100644
--- a/src/undo/snapshot.rs
+++ b/src/undo/snapshot.rs
@@ -310,7 +310,10 @@ impl Snapshot {
/// # Returns
/// The most recent snapshot, or None if no snapshots exist
#[allow(dead_code)] // used via the library target; the bin compiles this module separately
- pub(crate) fn find_latest_snapshot(operation_type: OperationType, custom_dir: Option<&Path>) -> Result> {
+ pub(crate) fn find_latest_snapshot(
+ operation_type: OperationType,
+ custom_dir: Option<&Path>,
+ ) -> Result> {
let snapshots_dir = if let Some(dir) = custom_dir {
dir.to_path_buf()
} else {
@@ -483,7 +486,10 @@ impl Snapshot {
///
/// # Returns
/// A HashMap containing the full state of all files
- pub fn reconstruct_full_state_with_dir(&self, snapshots_dir: Option<&Path>) -> Result>> {
+ pub fn reconstruct_full_state_with_dir(
+ &self,
+ snapshots_dir: Option<&Path>,
+ ) -> Result>> {
let mut state = HashMap::new();
// If this is a differential snapshot, load the base chain
@@ -533,5 +539,4 @@ impl Snapshot {
pub(crate) fn snapshots_dir() -> Result {
crate::config::ConfigManager::snapshots_dir()
}
-
}
diff --git a/tests/integration_sync_tests.rs b/tests/integration_sync_tests.rs
index 15b025ee..212409b5 100644
--- a/tests/integration_sync_tests.rs
+++ b/tests/integration_sync_tests.rs
@@ -4,11 +4,11 @@ use tempfile::TempDir;
use walkdir::WalkDir;
// Import the necessary modules from claude_code_sync
-use claude_code_sync::scm;
use claude_code_sync::history::{
ConversationSummary, OperationHistory, OperationType, SyncOperation,
};
use claude_code_sync::parser::ConversationSession;
+use claude_code_sync::scm;
use claude_code_sync::sync::SyncState;
use claude_code_sync::undo::{undo_pull, undo_push, Snapshot};
@@ -514,7 +514,9 @@ fn test_conflict_handling() {
fs::write(&m1_file, &m1_modified).unwrap();
let m1_session = ConversationSession::from_file(&m1_file).unwrap();
- let sync_file = sync_projects.join("test").join(format!("{session_id}.jsonl"));
+ let sync_file = sync_projects
+ .join("test")
+ .join(format!("{session_id}.jsonl"));
fs::create_dir_all(sync_file.parent().unwrap()).unwrap();
m1_session.write_to_file(&sync_file).unwrap();
@@ -876,11 +878,8 @@ fn test_operation_record_with_no_commit_hash() {
)
.unwrap();
- let mut record = OperationRecord::new(
- OperationType::Push,
- Some("main".to_string()),
- vec![conv],
- );
+ let mut record =
+ OperationRecord::new(OperationType::Push, Some("main".to_string()), vec![conv]);
// commit_hash should be None by default
assert!(record.commit_hash.is_none());
diff --git a/tests/integration_tests.rs b/tests/integration_tests.rs
index 65e98579..99ae7ab6 100644
--- a/tests/integration_tests.rs
+++ b/tests/integration_tests.rs
@@ -66,6 +66,7 @@ fn test_end_to_end_sync_workflow() {
}
#[test]
+#[cfg(unix)]
fn test_file_permissions() {
use std::os::unix::fs::PermissionsExt;
@@ -193,6 +194,7 @@ fn test_path_handling_with_spaces() {
}
#[test]
+#[cfg(unix)]
fn test_symlink_handling() {
let temp_dir = TempDir::new().unwrap();
let real_file = temp_dir.path().join("real.jsonl");
@@ -200,11 +202,8 @@ fn test_symlink_handling() {
fs::write(&real_file, r#"{"test":"data"}"#).unwrap();
- #[cfg(unix)]
- {
- std::os::unix::fs::symlink(&real_file, &link_file).unwrap();
- assert!(link_file.exists());
- }
+ std::os::unix::fs::symlink(&real_file, &link_file).unwrap();
+ assert!(link_file.exists());
}
#[test]
diff --git a/tests/scm_backend_tests.rs b/tests/scm_backend_tests.rs
index 2d81839b..bd073a0a 100644
--- a/tests/scm_backend_tests.rs
+++ b/tests/scm_backend_tests.rs
@@ -444,10 +444,7 @@ fn test_backend_selection_invalid() {
scm_backend: "svn".to_string(),
..Default::default()
};
- assert!(
- config.backend().is_err(),
- "Invalid backend should fail"
- );
+ assert!(config.backend().is_err(), "Invalid backend should fail");
}
#[test]
diff --git a/tests/test_artifact_e2e.rs b/tests/test_artifact_e2e.rs
index 34e8ac5b..3eff9d45 100644
--- a/tests/test_artifact_e2e.rs
+++ b/tests/test_artifact_e2e.rs
@@ -1,6 +1,6 @@
//! Full-pipeline end-to-end tests for artifact sync: the real push_history /
//! pull_history / sync_bidirectional / undo_pull entry points, real git
-//! commits, and two simulated machines (distinct HOME +
+//! commits, and two simulated machines (distinct CLAUDE_CODE_SYNC_CLAUDE_DIR +
//! CLAUDE_CODE_SYNC_CONFIG_DIR sharing one sync repository).
//!
//! Serialized: HOME and the config-dir override are process-global.
@@ -63,6 +63,9 @@ impl Machine {
fn activate(&self) {
std::env::set_var("HOME", &self.home);
+ // HOME alone is not enough on Windows (dirs::home_dir() ignores it
+ // there), so point the product at this machine's .claude explicitly.
+ std::env::set_var("CLAUDE_CODE_SYNC_CLAUDE_DIR", self.home.join(".claude"));
std::env::set_var("CLAUDE_CODE_SYNC_CONFIG_DIR", &self.config);
}
@@ -73,6 +76,7 @@ impl Machine {
struct EnvRestore {
home: Option,
+ claude: Option,
cfg: Option,
}
@@ -80,6 +84,7 @@ impl EnvRestore {
fn capture() -> Self {
Self {
home: std::env::var("HOME").ok(),
+ claude: std::env::var("CLAUDE_CODE_SYNC_CLAUDE_DIR").ok(),
cfg: std::env::var("CLAUDE_CODE_SYNC_CONFIG_DIR").ok(),
}
}
@@ -91,6 +96,10 @@ impl Drop for EnvRestore {
Some(v) => std::env::set_var("HOME", v),
None => std::env::remove_var("HOME"),
}
+ match &self.claude {
+ Some(v) => std::env::set_var("CLAUDE_CODE_SYNC_CLAUDE_DIR", v),
+ None => std::env::remove_var("CLAUDE_CODE_SYNC_CLAUDE_DIR"),
+ }
match &self.cfg {
Some(v) => std::env::set_var("CLAUDE_CODE_SYNC_CONFIG_DIR", v),
None => std::env::remove_var("CLAUDE_CODE_SYNC_CONFIG_DIR"),
@@ -176,9 +185,7 @@ fn test_full_pipeline_push_pull_undo_across_two_machines() {
// The push record carries per-category artifact counts.
let history = OperationHistory::load().unwrap();
- let last = history.get_last_operation_by_type(
- claude_code_sync::history::OperationType::Push,
- );
+ let last = history.get_last_operation_by_type(claude_code_sync::history::OperationType::Push);
assert!(!last.unwrap().artifact_counts.is_empty());
// ---- Machine B pulls the environment onto a fresh home ----
@@ -187,18 +194,26 @@ fn test_full_pipeline_push_pull_undo_across_two_machines() {
pull_history(false, None, false, VerbosityLevel::Quiet).unwrap();
let b = machine_b.claude();
- assert_eq!(fs::read(b.join("settings.json")).unwrap(), b"{\"model\":\"opus\"}");
+ assert_eq!(
+ fs::read(b.join("settings.json")).unwrap(),
+ b"{\"model\":\"opus\"}"
+ );
assert_eq!(fs::read(b.join("CLAUDE.md")).unwrap(), b"# global memory\n");
assert!(b.join("skills/deploy/SKILL.md").is_file());
assert!(b.join("projects/-home-user-webapp/diagram.png").is_file());
- assert!(b.join("projects/-home-user-webapp/memory/MEMORY.md").is_file());
+ assert!(b
+ .join("projects/-home-user-webapp/memory/MEMORY.md")
+ .is_file());
assert!(b.join("history.jsonl").is_file());
assert!(!b.join(".credentials.json").exists());
// ---- Undo the pull: every artifact the pull created disappears ----
let summary = claude_code_sync::undo::undo_pull(None, Some(&machine_b.home)).unwrap();
assert!(summary.contains("undone"), "undo summary: {summary}");
- assert!(!b.join("settings.json").exists(), "created settings removed");
+ assert!(
+ !b.join("settings.json").exists(),
+ "created settings removed"
+ );
assert!(!b.join("skills/deploy/SKILL.md").exists());
assert!(!b.join("CLAUDE.md").exists());
@@ -218,9 +233,24 @@ fn test_full_pipeline_second_push_creates_no_commit() {
machine.activate();
seed_full_claude_home(&machine.claude());
- push_history(Some("first"), false, None, false, false, VerbosityLevel::Quiet).unwrap();
- let report = push_history(Some("second"), false, None, false, false, VerbosityLevel::Quiet)
- .unwrap();
+ push_history(
+ Some("first"),
+ false,
+ None,
+ false,
+ false,
+ VerbosityLevel::Quiet,
+ )
+ .unwrap();
+ let report = push_history(
+ Some("second"),
+ false,
+ None,
+ false,
+ false,
+ VerbosityLevel::Quiet,
+ )
+ .unwrap();
// Issue #68 end-to-end: nothing changed, nothing is added/modified,
// and git records no second commit.
@@ -266,7 +296,11 @@ fn test_full_pipeline_sync_converges_prompt_history() {
assert!(a_history.contains("from B"));
let ts: Vec = a_history
.lines()
- .map(|l| serde_json::from_str::(l).unwrap()["timestamp"].as_u64().unwrap())
+ .map(|l| {
+ serde_json::from_str::(l).unwrap()["timestamp"]
+ .as_u64()
+ .unwrap()
+ })
.collect();
assert_eq!(ts, vec![1000, 2000], "chronological order");
}
diff --git a/tests/test_artifact_sync.rs b/tests/test_artifact_sync.rs
index 182243fe..d3d85b1e 100644
--- a/tests/test_artifact_sync.rs
+++ b/tests/test_artifact_sync.rs
@@ -147,7 +147,11 @@ fn test_modified_detection_on_changed_settings() {
let filter = all_on_filter();
push_artifacts(claude.path(), repo.path(), &filter).unwrap();
- fs::write(claude.path().join("settings.json"), b"{\"model\":\"sonnet\"}").unwrap();
+ fs::write(
+ claude.path().join("settings.json"),
+ b"{\"model\":\"sonnet\"}",
+ )
+ .unwrap();
let report = push_artifacts(claude.path(), repo.path(), &filter).unwrap();
let settings = report
@@ -246,14 +250,21 @@ fn test_push_unions_prompt_history() {
fs::create_dir_all(repo_history.parent().unwrap()).unwrap();
fs::write(
&repo_history,
- format!("{}{}", history_line(500, "other-machine"), history_line(1000, "one")),
+ format!(
+ "{}{}",
+ history_line(500, "other-machine"),
+ history_line(1000, "one")
+ ),
)
.unwrap();
let report = push_artifacts(claude.path(), repo.path(), &filter).unwrap();
let merged = fs::read_to_string(&repo_history).unwrap();
- assert!(merged.contains("other-machine"), "repo-only line survives push");
+ assert!(
+ merged.contains("other-machine"),
+ "repo-only line survives push"
+ );
assert!(merged.contains("one"));
assert_eq!(merged.lines().count(), 2, "shared line dedups");
@@ -301,7 +312,10 @@ fn test_ignore_file_managed_block_is_idempotent_and_preserving() {
assert!(changed_first, "first run writes the block");
assert!(!changed_second, "second run is a no-op");
assert_eq!(after_first, after_second);
- assert!(after_first.starts_with("user-stuff/\n"), "user content preserved");
+ assert!(
+ after_first.starts_with("user-stuff/\n"),
+ "user content preserved"
+ );
assert!(after_first.contains(".credentials.json"));
assert!(after_first.contains("settings.local.json"));
assert!(after_first.contains("*.pem"));
@@ -339,7 +353,10 @@ fn test_pull_restores_artifacts_to_fresh_machine() {
let plan = plan_pull(machine_b.path(), repo.path(), &filter).unwrap();
assert!(!plan.is_empty());
- assert!(plan.overwrites.is_empty(), "fresh machine has nothing to overwrite");
+ assert!(
+ plan.overwrites.is_empty(),
+ "fresh machine has nothing to overwrite"
+ );
let report = apply_pull(&plan, false).unwrap();
assert_eq!(
@@ -351,7 +368,10 @@ fn test_pull_restores_artifacts_to_fresh_machine() {
b"# skill\n"
);
assert!(machine_b.path().join("CLAUDE.md").is_file());
- assert!(machine_b.path().join("plugins/installed_plugins.json").is_file());
+ assert!(machine_b
+ .path()
+ .join("plugins/installed_plugins.json")
+ .is_file());
assert!(machine_b.path().join("history.jsonl").is_file());
assert!(report.total_added() >= 12);
assert_eq!(report.total_modified(), 0);
@@ -367,7 +387,11 @@ fn test_pull_remote_wins_when_bytes_differ() {
push_artifacts(machine_a.path(), repo.path(), &filter).unwrap();
// Machine B has its own, different settings.
- fs::write(machine_b.path().join("settings.json"), b"{\"model\":\"local\"}").unwrap();
+ fs::write(
+ machine_b.path().join("settings.json"),
+ b"{\"model\":\"local\"}",
+ )
+ .unwrap();
let plan = plan_pull(machine_b.path(), repo.path(), &filter).unwrap();
let overwrite_targets: Vec<_> = plan
@@ -395,7 +419,10 @@ fn test_pull_does_not_rewrite_identical_files() {
// Pulling straight back into the same machine: everything identical.
let plan = plan_pull(machine_a.path(), repo.path(), &filter).unwrap();
- assert!(plan.is_empty(), "no writes planned when bytes match: {plan:?}");
+ assert!(
+ plan.is_empty(),
+ "no writes planned when bytes match: {plan:?}"
+ );
assert!(plan.unchanged >= 12);
}
@@ -407,8 +434,20 @@ fn test_pull_unions_prompt_history_with_local() {
let repo_history = repo.path().join("artifacts/prompt-history/history.jsonl");
fs::create_dir_all(repo_history.parent().unwrap()).unwrap();
- fs::write(&repo_history, format!("{}{}", history_line(500, "remote-old"), history_line(2000, "remote-new"))).unwrap();
- fs::write(machine_b.path().join("history.jsonl"), history_line(1000, "local-only")).unwrap();
+ fs::write(
+ &repo_history,
+ format!(
+ "{}{}",
+ history_line(500, "remote-old"),
+ history_line(2000, "remote-new")
+ ),
+ )
+ .unwrap();
+ fs::write(
+ machine_b.path().join("history.jsonl"),
+ history_line(1000, "local-only"),
+ )
+ .unwrap();
let plan = plan_pull(machine_b.path(), repo.path(), &filter).unwrap();
let report = apply_pull(&plan, false).unwrap();
@@ -416,10 +455,23 @@ fn test_pull_unions_prompt_history_with_local() {
let merged = fs::read_to_string(machine_b.path().join("history.jsonl")).unwrap();
let displays: Vec<_> = merged
.lines()
- .map(|l| serde_json::from_str::(l).unwrap()["display"].as_str().unwrap().to_string())
+ .map(|l| {
+ serde_json::from_str::(l).unwrap()["display"]
+ .as_str()
+ .unwrap()
+ .to_string()
+ })
.collect();
- assert_eq!(displays, vec!["remote-old", "local-only", "remote-new"], "union, chronological");
- let ph = report.counts.iter().find(|c| c.category == CategoryId::PromptHistory).unwrap();
+ assert_eq!(
+ displays,
+ vec!["remote-old", "local-only", "remote-new"],
+ "union, chronological"
+ );
+ let ph = report
+ .counts
+ .iter()
+ .find(|c| c.category == CategoryId::PromptHistory)
+ .unwrap();
assert_eq!(ph.merged_entries, 2, "two remote lines were new locally");
}
@@ -432,7 +484,11 @@ fn test_pull_refuses_denied_files_planted_in_repo() {
// A poisoned sync repo tries to deliver credentials and key material.
fs::create_dir_all(repo.path().join("artifacts/settings")).unwrap();
fs::write(repo.path().join("artifacts/settings/settings.json"), b"{}").unwrap();
- fs::write(repo.path().join("artifacts/settings/.credentials.json"), b"{\"t\":1}").unwrap();
+ fs::write(
+ repo.path().join("artifacts/settings/.credentials.json"),
+ b"{\"t\":1}",
+ )
+ .unwrap();
fs::create_dir_all(repo.path().join("artifacts/skills/s")).unwrap();
fs::write(repo.path().join("artifacts/skills/s/evil.pem"), b"PEM").unwrap();
fs::write(repo.path().join("artifacts/skills/s/ok.md"), b"fine").unwrap();
@@ -444,7 +500,10 @@ fn test_pull_refuses_denied_files_planted_in_repo() {
assert!(machine_b.path().join("skills/s/ok.md").is_file());
assert!(!machine_b.path().join(".credentials.json").exists());
assert!(!machine_b.path().join("skills/s/evil.pem").exists());
- assert!(plan.skipped >= 2, "denied repo files are counted as skipped");
+ assert!(
+ plan.skipped >= 2,
+ "denied repo files are counted as skipped"
+ );
}
#[test]
@@ -462,16 +521,16 @@ fn test_pull_plan_snapshot_paths_enable_exact_undo() {
push_artifacts(machine_a.path(), repo.path(), &filter).unwrap();
// Machine B: one file that will be overwritten, everything else created.
- fs::write(machine_b.path().join("settings.json"), b"{\"model\":\"mine\"}").unwrap();
+ fs::write(
+ machine_b.path().join("settings.json"),
+ b"{\"model\":\"mine\"}",
+ )
+ .unwrap();
let plan = plan_pull(machine_b.path(), repo.path(), &filter).unwrap();
- let mut snapshot = Snapshot::create(
- OperationType::Pull,
- plan.paths_to_snapshot().iter(),
- None,
- )
- .unwrap();
+ let mut snapshot =
+ Snapshot::create(OperationType::Pull, plan.paths_to_snapshot().iter(), None).unwrap();
snapshot.deleted_files = plan.created_paths();
apply_pull(&plan, false).unwrap();
@@ -525,7 +584,10 @@ fn test_attachments_push_copies_non_jsonl_into_session_tree() {
let report = push_artifacts(claude.path(), repo.path(), &filter).unwrap();
let proj = repo.path().join("projects/-home-user-myproj");
- assert!(proj.join("diagram.png").is_file(), "attachment lands in session tree");
+ assert!(
+ proj.join("diagram.png").is_file(),
+ "attachment lands in session tree"
+ );
assert!(
proj.join("memory/MEMORY.md").is_file(),
"project memory syncs as attachment"
@@ -534,7 +596,10 @@ fn test_attachments_push_copies_non_jsonl_into_session_tree() {
!proj.join("abc-123.jsonl").exists(),
"session transcripts belong to the session pipeline, not the engine"
);
- assert!(!repo.path().join("artifacts").exists(), "no artifacts dir needed");
+ assert!(
+ !repo.path().join("artifacts").exists(),
+ "no artifacts dir needed"
+ );
let att = report
.counts
@@ -655,7 +720,11 @@ fn test_pull_refuses_unlisted_files_in_allowlist_categories() {
)
.unwrap();
fs::create_dir_all(repo.path().join("artifacts/plugins")).unwrap();
- fs::write(repo.path().join("artifacts/plugins/rogue-manifest.json"), b"{}").unwrap();
+ fs::write(
+ repo.path().join("artifacts/plugins/rogue-manifest.json"),
+ b"{}",
+ )
+ .unwrap();
let plan = plan_pull(machine_b.path(), repo.path(), &filter).unwrap();
apply_pull(&plan, false).unwrap();
@@ -663,8 +732,14 @@ fn test_pull_refuses_unlisted_files_in_allowlist_categories() {
assert!(machine_b.path().join("settings.json").is_file());
for entry in walkdir::WalkDir::new(machine_b.path()) {
let name = entry.unwrap().file_name().to_string_lossy().to_string();
- assert_ne!(name, "unexpected.json", "unlisted file must not be restored");
+ assert_ne!(
+ name, "unexpected.json",
+ "unlisted file must not be restored"
+ );
assert_ne!(name, "rogue-manifest.json");
}
- assert!(plan.skipped >= 2, "unlisted allowlist files count as skipped");
+ assert!(
+ plan.skipped >= 2,
+ "unlisted allowlist files count as skipped"
+ );
}
diff --git a/tests/test_differential_snapshots.rs b/tests/test_differential_snapshots.rs
index 24e3a3a2..884df204 100644
--- a/tests/test_differential_snapshots.rs
+++ b/tests/test_differential_snapshots.rs
@@ -3,9 +3,9 @@ use std::fs;
use std::path::{Path, PathBuf};
use tempfile::TempDir;
-use claude_code_sync::scm;
use claude_code_sync::history::OperationType;
use claude_code_sync::parser::ConversationEntry;
+use claude_code_sync::scm;
use claude_code_sync::undo::Snapshot;
// ============================================================================
@@ -106,7 +106,9 @@ fn modify_conversation(conv_path: &Path, additional_message: &str) -> Result<()>
// Parse existing content to get session_id
let first_line = content.lines().next().unwrap_or("{}");
let first_entry: ConversationEntry = serde_json::from_str(first_line)?;
- let session_id = first_entry.session_id.unwrap_or_else(|| "session-unknown".to_string());
+ let session_id = first_entry
+ .session_id
+ .unwrap_or_else(|| "session-unknown".to_string());
// Count existing entries to generate unique UUID
let entry_count = content.lines().filter(|l| !l.trim().is_empty()).count();
@@ -187,11 +189,8 @@ fn test_differential_snapshots_minimize_disk_usage() {
// First Push: Creates full snapshot
// ========================================================================
println!("\nFirst push: Creating full snapshot...");
- let (snapshot1, snapshot1_path) = push_and_get_snapshot(
- &snapshots_dir,
- &all_files,
- None,
- ).unwrap();
+ let (snapshot1, snapshot1_path) =
+ push_and_get_snapshot(&snapshots_dir, &all_files, None).unwrap();
assert!(
snapshot1.base_snapshot_id.is_none(),
@@ -199,7 +198,11 @@ fn test_differential_snapshots_minimize_disk_usage() {
);
let size1 = calculate_snapshot_size(&snapshot1_path).unwrap();
- println!(" Snapshot 1 size: {} bytes ({:.2} MB)", size1, size1 as f64 / 1_000_000.0);
+ println!(
+ " Snapshot 1 size: {} bytes ({:.2} MB)",
+ size1,
+ size1 as f64 / 1_000_000.0
+ );
println!(" Files in snapshot: {}", snapshot1.files.len());
// Full snapshot should contain all files
@@ -220,11 +223,8 @@ fn test_differential_snapshots_minimize_disk_usage() {
// Second Push: No changes, should create tiny differential
// ========================================================================
println!("\nSecond push: No changes, creating differential snapshot...");
- let (snapshot2, snapshot2_path) = push_and_get_snapshot(
- &snapshots_dir,
- &all_files,
- None,
- ).unwrap();
+ let (snapshot2, snapshot2_path) =
+ push_and_get_snapshot(&snapshots_dir, &all_files, None).unwrap();
assert!(
snapshot2.base_snapshot_id.is_some(),
@@ -237,7 +237,11 @@ fn test_differential_snapshots_minimize_disk_usage() {
);
let size2 = calculate_snapshot_size(&snapshot2_path).unwrap();
- println!(" Snapshot 2 size: {} bytes ({:.2} KB)", size2, size2 as f64 / 1_000.0);
+ println!(
+ " Snapshot 2 size: {} bytes ({:.2} KB)",
+ size2,
+ size2 as f64 / 1_000.0
+ );
println!(" Files in snapshot: {}", snapshot2.files.len());
println!(" Deleted files: {}", snapshot2.deleted_files.len());
@@ -257,8 +261,10 @@ fn test_differential_snapshots_minimize_disk_usage() {
size2
);
- println!(" ✓ Space saved: {:.2}% compared to full snapshot",
- (1.0 - size2 as f64 / size1 as f64) * 100.0);
+ println!(
+ " ✓ Space saved: {:.2}% compared to full snapshot",
+ (1.0 - size2 as f64 / size1 as f64) * 100.0
+ );
// ========================================================================
// Third Push: Small change to one file
@@ -266,11 +272,8 @@ fn test_differential_snapshots_minimize_disk_usage() {
println!("\nThird push: Modifying one conversation...");
modify_conversation(&conv1, "This is a small additional message").unwrap();
- let (snapshot3, snapshot3_path) = push_and_get_snapshot(
- &snapshots_dir,
- &all_files,
- None,
- ).unwrap();
+ let (snapshot3, snapshot3_path) =
+ push_and_get_snapshot(&snapshots_dir, &all_files, None).unwrap();
assert!(
snapshot3.base_snapshot_id.is_some(),
@@ -283,7 +286,11 @@ fn test_differential_snapshots_minimize_disk_usage() {
);
let size3 = calculate_snapshot_size(&snapshot3_path).unwrap();
- println!(" Snapshot 3 size: {} bytes ({:.2} KB)", size3, size3 as f64 / 1_000.0);
+ println!(
+ " Snapshot 3 size: {} bytes ({:.2} KB)",
+ size3,
+ size3 as f64 / 1_000.0
+ );
println!(" Files in snapshot: {}", snapshot3.files.len());
// KEY ASSERTION: Only one file should be in differential
@@ -309,8 +316,10 @@ fn test_differential_snapshots_minimize_disk_usage() {
size1
);
- println!(" ✓ Space saved: {:.2}% compared to full snapshot",
- (1.0 - size3 as f64 / size1 as f64) * 100.0);
+ println!(
+ " ✓ Space saved: {:.2}% compared to full snapshot",
+ (1.0 - size3 as f64 / size1 as f64) * 100.0
+ );
// ========================================================================
// Fourth Push: Add a new file
@@ -319,14 +328,15 @@ fn test_differential_snapshots_minimize_disk_usage() {
let conv4 = create_large_conversation(&conversations_dir, "conv4", 1_000_000).unwrap();
let all_files_with_new = vec![conv1.clone(), conv2.clone(), conv3.clone(), conv4.clone()];
- let (snapshot4, snapshot4_path) = push_and_get_snapshot(
- &snapshots_dir,
- &all_files_with_new,
- None,
- ).unwrap();
+ let (snapshot4, snapshot4_path) =
+ push_and_get_snapshot(&snapshots_dir, &all_files_with_new, None).unwrap();
let size4 = calculate_snapshot_size(&snapshot4_path).unwrap();
- println!(" Snapshot 4 size: {} bytes ({:.2} KB)", size4, size4 as f64 / 1_000.0);
+ println!(
+ " Snapshot 4 size: {} bytes ({:.2} KB)",
+ size4,
+ size4 as f64 / 1_000.0
+ );
println!(" Files in snapshot: {}", snapshot4.files.len());
// Should contain only the new file
@@ -351,8 +361,14 @@ fn test_differential_snapshots_minimize_disk_usage() {
println!("\n=== Summary ===");
println!("Full snapshot size: {:.2} MB", size1 as f64 / 1_000_000.0);
- println!("Total differential size: {:.2} MB", total_differential_size as f64 / 1_000_000.0);
- println!("Would-be full size: {:.2} MB", would_be_full_size as f64 / 1_000_000.0);
+ println!(
+ "Total differential size: {:.2} MB",
+ total_differential_size as f64 / 1_000_000.0
+ );
+ println!(
+ "Would-be full size: {:.2} MB",
+ would_be_full_size as f64 / 1_000_000.0
+ );
println!("Space savings: {:.1}%", savings_ratio * 100.0);
assert!(
@@ -387,11 +403,8 @@ fn test_snapshot_chain_reconstruction() {
println!("Creating snapshot chain...");
// Snapshot 1: Initial state (file1, file2)
- let (snapshot1, _) = push_and_get_snapshot(
- &snapshots_dir,
- &[file1.clone(), file2.clone()],
- None,
- ).unwrap();
+ let (snapshot1, _) =
+ push_and_get_snapshot(&snapshots_dir, &[file1.clone(), file2.clone()], None).unwrap();
println!(" Snapshot 1: 2 files");
// Snapshot 2: Modify file1, add file3
@@ -402,8 +415,12 @@ fn test_snapshot_chain_reconstruction() {
&snapshots_dir,
&[file1.clone(), file2.clone(), file3.clone()],
None,
- ).unwrap();
- println!(" Snapshot 2: {} files (differential)", snapshot2.files.len());
+ )
+ .unwrap();
+ println!(
+ " Snapshot 2: {} files (differential)",
+ snapshot2.files.len()
+ );
// Snapshot 3: Modify file2
fs::write(&file2, b"version_3").unwrap();
@@ -412,8 +429,12 @@ fn test_snapshot_chain_reconstruction() {
&snapshots_dir,
&[file1.clone(), file2.clone(), file3.clone()],
None,
- ).unwrap();
- println!(" Snapshot 3: {} files (differential)", snapshot3.files.len());
+ )
+ .unwrap();
+ println!(
+ " Snapshot 3: {} files (differential)",
+ snapshot3.files.len()
+ );
// Snapshot 4: Modify file3
fs::write(&file3, b"version_4").unwrap();
@@ -422,11 +443,18 @@ fn test_snapshot_chain_reconstruction() {
&snapshots_dir,
&[file1.clone(), file2.clone(), file3.clone()],
None,
- ).unwrap();
- println!(" Snapshot 4: {} files (differential)", snapshot4.files.len());
+ )
+ .unwrap();
+ println!(
+ " Snapshot 4: {} files (differential)",
+ snapshot4.files.len()
+ );
// Verify chain structure
- assert!(snapshot1.base_snapshot_id.is_none(), "First snapshot should have no base");
+ assert!(
+ snapshot1.base_snapshot_id.is_none(),
+ "First snapshot should have no base"
+ );
assert_eq!(
snapshot2.base_snapshot_id.as_ref().unwrap(),
&snapshot1.snapshot_id,
@@ -445,7 +473,9 @@ fn test_snapshot_chain_reconstruction() {
// Reconstruct full state from snapshot 4
println!("\nReconstructing full state from snapshot 4...");
- let full_state = snapshot4.reconstruct_full_state_with_dir(Some(&snapshots_dir)).unwrap();
+ let full_state = snapshot4
+ .reconstruct_full_state_with_dir(Some(&snapshots_dir))
+ .unwrap();
println!(" Reconstructed {} files", full_state.len());
@@ -500,7 +530,8 @@ fn test_deleted_files_tracking() {
&snapshots_dir,
&[file1.clone(), file2.clone(), file3.clone()],
None,
- ).unwrap();
+ )
+ .unwrap();
assert_eq!(snapshot1.files.len(), 3);
assert!(snapshot1.deleted_files.is_empty());
@@ -509,11 +540,8 @@ fn test_deleted_files_tracking() {
println!("Deleting file2...");
fs::remove_file(&file2).unwrap();
- let (snapshot2, _) = push_and_get_snapshot(
- &snapshots_dir,
- &[file1.clone(), file3.clone()],
- None,
- ).unwrap();
+ let (snapshot2, _) =
+ push_and_get_snapshot(&snapshots_dir, &[file1.clone(), file3.clone()], None).unwrap();
println!(" Snapshot 2 deleted files: {:?}", snapshot2.deleted_files);
@@ -531,19 +559,25 @@ fn test_deleted_files_tracking() {
);
// Reconstruct and verify file2 is not in the state
- let full_state = snapshot2.reconstruct_full_state_with_dir(Some(&snapshots_dir)).unwrap();
- assert_eq!(full_state.len(), 2, "Should only have 2 files after deletion");
- assert!(!full_state.contains_key(&file2_key), "file2 should not be in reconstructed state");
+ let full_state = snapshot2
+ .reconstruct_full_state_with_dir(Some(&snapshots_dir))
+ .unwrap();
+ assert_eq!(
+ full_state.len(),
+ 2,
+ "Should only have 2 files after deletion"
+ );
+ assert!(
+ !full_state.contains_key(&file2_key),
+ "file2 should not be in reconstructed state"
+ );
// Delete another file
println!("Deleting file3...");
fs::remove_file(&file3).unwrap();
- let (snapshot3, _) = push_and_get_snapshot(
- &snapshots_dir,
- std::slice::from_ref(&file1),
- None,
- ).unwrap();
+ let (snapshot3, _) =
+ push_and_get_snapshot(&snapshots_dir, std::slice::from_ref(&file1), None).unwrap();
println!(" Snapshot 3 deleted files: {:?}", snapshot3.deleted_files);
@@ -555,7 +589,9 @@ fn test_deleted_files_tracking() {
);
// Reconstruct final state
- let final_state = snapshot3.reconstruct_full_state_with_dir(Some(&snapshots_dir)).unwrap();
+ let final_state = snapshot3
+ .reconstruct_full_state_with_dir(Some(&snapshots_dir))
+ .unwrap();
assert_eq!(final_state.len(), 1, "Should only have 1 file remaining");
let file1_key = file1.to_string_lossy().to_string();
@@ -579,27 +615,18 @@ fn test_broken_snapshot_chain() {
fs::write(&file1, b"content1").unwrap();
// Create snapshot 1
- let (snapshot1, _snapshot1_path) = push_and_get_snapshot(
- &snapshots_dir,
- std::slice::from_ref(&file1),
- None,
- ).unwrap();
+ let (snapshot1, _snapshot1_path) =
+ push_and_get_snapshot(&snapshots_dir, std::slice::from_ref(&file1), None).unwrap();
// Modify and create snapshot 2
fs::write(&file1, b"content2").unwrap();
- let (_snapshot2, snapshot2_path) = push_and_get_snapshot(
- &snapshots_dir,
- std::slice::from_ref(&file1),
- None,
- ).unwrap();
+ let (_snapshot2, snapshot2_path) =
+ push_and_get_snapshot(&snapshots_dir, std::slice::from_ref(&file1), None).unwrap();
// Modify and create snapshot 3
fs::write(&file1, b"content3").unwrap();
- let (snapshot3, _snapshot3_path) = push_and_get_snapshot(
- &snapshots_dir,
- std::slice::from_ref(&file1),
- None,
- ).unwrap();
+ let (snapshot3, _snapshot3_path) =
+ push_and_get_snapshot(&snapshots_dir, std::slice::from_ref(&file1), None).unwrap();
println!("Created chain: snapshot1 <- snapshot2 <- snapshot3");
@@ -615,13 +642,16 @@ fn test_broken_snapshot_chain() {
let error_msg = result.unwrap_err().to_string();
println!(" Error: {}", error_msg);
assert!(
- error_msg.contains("Base snapshot not found") || error_msg.contains("snapshot chain is broken"),
+ error_msg.contains("Base snapshot not found")
+ || error_msg.contains("snapshot chain is broken"),
"Error should mention missing base snapshot"
);
// Verify snapshot1 can still be reconstructed (it's a full snapshot)
println!("Verifying snapshot1 can still be reconstructed...");
- let state1 = snapshot1.reconstruct_full_state_with_dir(Some(&snapshots_dir)).unwrap();
+ let state1 = snapshot1
+ .reconstruct_full_state_with_dir(Some(&snapshots_dir))
+ .unwrap();
assert_eq!(state1.len(), 1, "Should successfully reconstruct snapshot1");
println!("\n✓ Test passed! Broken chain detection works correctly.\n");
@@ -656,9 +686,13 @@ fn test_differential_snapshot_with_scm() {
&snapshots_dir,
std::slice::from_ref(&file1),
Some(&initial_commit),
- ).unwrap();
+ )
+ .unwrap();
- assert!(snapshot1.git_commit_hash.is_some(), "Snapshot should capture commit hash");
+ assert!(
+ snapshot1.git_commit_hash.is_some(),
+ "Snapshot should capture commit hash"
+ );
assert_eq!(
snapshot1.git_commit_hash.as_ref().unwrap(),
&initial_commit,
@@ -678,9 +712,13 @@ fn test_differential_snapshot_with_scm() {
&snapshots_dir,
std::slice::from_ref(&file1),
Some(&second_commit),
- ).unwrap();
+ )
+ .unwrap();
- assert!(snapshot2.base_snapshot_id.is_some(), "Should be differential");
+ assert!(
+ snapshot2.base_snapshot_id.is_some(),
+ "Should be differential"
+ );
assert_eq!(
snapshot2.git_commit_hash.as_ref().unwrap(),
&second_commit,
@@ -705,23 +743,22 @@ fn test_performance_differential_vs_full() {
println!("Creating 5 large conversation files...");
let mut files = Vec::new();
for i in 0..5 {
- let file = create_large_conversation(&conversations_dir, &format!("perf_test_{}", i), 500_000).unwrap();
+ let file =
+ create_large_conversation(&conversations_dir, &format!("perf_test_{}", i), 500_000)
+ .unwrap();
files.push(file);
}
// Measure full snapshot creation time
println!("\nMeasuring full snapshot creation...");
let start = std::time::Instant::now();
- let snapshot = Snapshot::create(
- OperationType::Push,
- files.iter(),
- None,
- ).unwrap();
+ let snapshot = Snapshot::create(OperationType::Push, files.iter(), None).unwrap();
let full_duration = start.elapsed();
let snapshot_path = snapshot.save_to_disk(Some(&snapshots_dir)).unwrap();
let full_size = calculate_snapshot_size(&snapshot_path).unwrap();
- println!(" Full snapshot: {:.2}ms, {:.2} MB",
+ println!(
+ " Full snapshot: {:.2}ms, {:.2} MB",
full_duration.as_secs_f64() * 1000.0,
full_size as f64 / 1_000_000.0
);
@@ -737,12 +774,14 @@ fn test_performance_differential_vs_full() {
files.iter(),
None,
Some(&snapshots_dir),
- ).unwrap();
+ )
+ .unwrap();
let diff_duration = start.elapsed();
let diff_snapshot_path = diff_snapshot.save_to_disk(Some(&snapshots_dir)).unwrap();
let diff_size = calculate_snapshot_size(&diff_snapshot_path).unwrap();
- println!(" Differential snapshot: {:.2}ms, {:.2} KB",
+ println!(
+ " Differential snapshot: {:.2}ms, {:.2} KB",
diff_duration.as_secs_f64() * 1000.0,
diff_size as f64 / 1_000.0
);
@@ -782,31 +821,30 @@ fn test_empty_differential_snapshot() {
// Create first snapshot
println!("Creating initial snapshot...");
- let (_snapshot1, snapshot1_path) = push_and_get_snapshot(
- &snapshots_dir,
- std::slice::from_ref(&file1),
- None,
- ).unwrap();
+ let (_snapshot1, snapshot1_path) =
+ push_and_get_snapshot(&snapshots_dir, std::slice::from_ref(&file1), None).unwrap();
let size1 = calculate_snapshot_size(&snapshot1_path).unwrap();
println!(" Initial snapshot: {} bytes", size1);
// Create second snapshot with NO changes
println!("Creating differential snapshot with no changes...");
- let (snapshot2, snapshot2_path) = push_and_get_snapshot(
- &snapshots_dir,
- std::slice::from_ref(&file1),
- None,
- ).unwrap();
+ let (snapshot2, snapshot2_path) =
+ push_and_get_snapshot(&snapshots_dir, std::slice::from_ref(&file1), None).unwrap();
let size2 = calculate_snapshot_size(&snapshot2_path).unwrap();
println!(" Differential snapshot: {} bytes", size2);
// Should be nearly empty
assert!(snapshot2.files.is_empty(), "No files should have changed");
- assert!(snapshot2.deleted_files.is_empty(), "No files should be deleted");
+ assert!(
+ snapshot2.deleted_files.is_empty(),
+ "No files should be deleted"
+ );
assert!(size2 < 1_000, "Should be < 1KB (got {} bytes)", size2);
// Verify reconstruction still works
- let reconstructed = snapshot2.reconstruct_full_state_with_dir(Some(&snapshots_dir)).unwrap();
+ let reconstructed = snapshot2
+ .reconstruct_full_state_with_dir(Some(&snapshots_dir))
+ .unwrap();
assert_eq!(reconstructed.len(), 1, "Should reconstruct 1 file");
let file1_key = file1.to_string_lossy().to_string();
diff --git a/tests/test_interactive_handlers.rs b/tests/test_interactive_handlers.rs
index 1e4645b5..571036b7 100644
--- a/tests/test_interactive_handlers.rs
+++ b/tests/test_interactive_handlers.rs
@@ -1,6 +1,6 @@
-use claude_code_sync::VerbosityLevel;
-use claude_code_sync::undo::{UndoPreview, VerbosityLevel as UndoVerbosity};
use claude_code_sync::history::OperationType;
+use claude_code_sync::undo::{UndoPreview, VerbosityLevel as UndoVerbosity};
+use claude_code_sync::VerbosityLevel;
/// Test VerbosityLevel enum basic functionality
#[test]
@@ -172,7 +172,10 @@ fn test_filter_config_clone() {
assert_eq!(config.max_file_size_bytes, cloned.max_file_size_bytes);
assert_eq!(config.exclude_attachments, cloned.exclude_attachments);
- assert_eq!(config.exclude_older_than_days, cloned.exclude_older_than_days);
+ assert_eq!(
+ config.exclude_older_than_days,
+ cloned.exclude_older_than_days
+ );
}
/// Test that FilterConfig can be modified (needed for wizard)
diff --git a/tests/test_onboarding.rs b/tests/test_onboarding.rs
index 5ebc796a..f15a9490 100644
--- a/tests/test_onboarding.rs
+++ b/tests/test_onboarding.rs
@@ -313,10 +313,7 @@ fn test_init_sync_repo_with_remote_creates_filter_config() -> Result<()> {
std::env::set_var("CLAUDE_CODE_SYNC_CONFIG_DIR", temp_dir.path());
// Initialize with remote URL using init_sync_repo (simulates --repo --remote flags)
- claude_code_sync::sync::init_sync_repo(
- &repo_path,
- Some("https://github.com/user/repo.git"),
- )?;
+ claude_code_sync::sync::init_sync_repo(&repo_path, Some("https://github.com/user/repo.git"))?;
// Verify state was saved with remote
let state = SyncState::load()?;
@@ -394,10 +391,18 @@ fn test_clone_with_invalid_url_fails() -> Result<()> {
#[test]
fn test_clone_creates_parent_directories() -> Result<()> {
let temp_dir = setup_test_config_env()?;
- let nested_path = temp_dir.path().join("deeply").join("nested").join("path").join("repo");
+ let nested_path = temp_dir
+ .path()
+ .join("deeply")
+ .join("nested")
+ .join("path")
+ .join("repo");
// Even though clone will fail (invalid URL), it should create parent directories
- let result = scm::clone("https://invalid-url-that-wont-work.example.com/repo.git", &nested_path);
+ let result = scm::clone(
+ "https://invalid-url-that-wont-work.example.com/repo.git",
+ &nested_path,
+ );
// Clone fails but parent directory should be created
assert!(result.is_err());
@@ -430,7 +435,10 @@ fn test_init_from_onboarding_sets_is_cloned_flag() -> Result<()> {
let state = SyncState::load()?;
assert_eq!(state.sync_repo_path, repo_path);
assert!(state.has_remote);
- assert!(state.is_cloned_repo, "is_cloned_repo should be true for cloned repos");
+ assert!(
+ state.is_cloned_repo,
+ "is_cloned_repo should be true for cloned repos"
+ );
// Clean up env var
std::env::remove_var("CLAUDE_CODE_SYNC_CONFIG_DIR");
@@ -452,16 +460,17 @@ fn test_init_from_onboarding_local_repo_not_cloned() -> Result<()> {
// Test init_from_onboarding with is_cloned = false (local repo)
claude_code_sync::sync::init_from_onboarding(
- &repo_path,
- None,
- false, // not cloned
+ &repo_path, None, false, // not cloned
)?;
// Verify state was saved with is_cloned_repo = false
let state = SyncState::load()?;
assert_eq!(state.sync_repo_path, repo_path);
assert!(!state.has_remote);
- assert!(!state.is_cloned_repo, "is_cloned_repo should be false for local repos");
+ assert!(
+ !state.is_cloned_repo,
+ "is_cloned_repo should be false for local repos"
+ );
// Clean up env var
std::env::remove_var("CLAUDE_CODE_SYNC_CONFIG_DIR");
diff --git a/tests/test_push_plan.rs b/tests/test_push_plan.rs
index b2c2d906..1c4c1278 100644
--- a/tests/test_push_plan.rs
+++ b/tests/test_push_plan.rs
@@ -78,7 +78,10 @@ fn test_second_push_plan_is_all_unchanged_despite_shared_session_id() {
let sessions2 = discover_sessions(claude.path(), &filter).unwrap();
let plan2 = plan_push(&sessions2, claude.path(), repo_projects.path(), &filter).unwrap();
assert_eq!(plan2.added, 0, "second push must add nothing");
- assert_eq!(plan2.modified, 0, "second push must modify nothing (issue #68)");
+ assert_eq!(
+ plan2.modified, 0,
+ "second push must modify nothing (issue #68)"
+ );
assert_eq!(plan2.unchanged, 3, "all three files are unchanged");
}
@@ -116,6 +119,9 @@ fn test_push_plan_detects_real_modification() {
let sessions2 = discover_sessions(claude.path(), &filter).unwrap();
let plan2 = plan_push(&sessions2, claude.path(), repo_projects.path(), &filter).unwrap();
assert_eq!(plan2.added, 0);
- assert_eq!(plan2.modified, 1, "only the appended transcript is modified");
+ assert_eq!(
+ plan2.modified, 1,
+ "only the appended transcript is modified"
+ );
assert_eq!(plan2.unchanged, 2);
}
diff --git a/tests/test_sync_verbosity.rs b/tests/test_sync_verbosity.rs
index 9de35d61..6e0f0f2d 100644
--- a/tests/test_sync_verbosity.rs
+++ b/tests/test_sync_verbosity.rs
@@ -128,11 +128,9 @@ fn test_verbose_mode_extra_logic() {
#[test]
fn test_display_count_by_verbosity() {
let files = vec![
- "file1", "file2", "file3", "file4", "file5",
- "file6", "file7", "file8", "file9", "file10",
- "file11", "file12", "file13", "file14", "file15",
- "file16", "file17", "file18", "file19", "file20",
- "file21", "file22", "file23", "file24", "file25",
+ "file1", "file2", "file3", "file4", "file5", "file6", "file7", "file8", "file9", "file10",
+ "file11", "file12", "file13", "file14", "file15", "file16", "file17", "file18", "file19",
+ "file20", "file21", "file22", "file23", "file24", "file25",
];
// In verbose mode, show more files (20 in implementation)
@@ -173,7 +171,11 @@ fn test_three_way_verbosity_distinction() {
seen.insert(format!("{:?}", normal));
seen.insert(format!("{:?}", verbose));
- assert_eq!(seen.len(), 3, "All three verbosity levels should be distinct");
+ assert_eq!(
+ seen.len(),
+ 3,
+ "All three verbosity levels should be distinct"
+ );
}
/// Test verbosity level can be passed as function parameter