cli: Remove dead test code and unused helpers

Remove obsolete tests and helper functions that are no longer used

Author: davidabram

cli/src/services/hooks/tests.rs

@@ -16,10 +16,10 @@ use super::{
     apply_commit_msg_coauthor_policy, finalize_post_commit_trace, finalize_post_rewrite_remap,
     finalize_pre_commit_checkpoint, finalize_rewrite_trace, process_trace_retry_queue,
     resolve_pre_commit_checkpoint_path, run_commit_msg_subcommand_in_repo, run_hooks_subcommand,
-    run_pre_commit_subcommand_in_repo, CommitMsgRuntimeState, HookSubcommand, PendingCheckpoint,
-    PendingFileCheckpoint, PendingLineRange, PersistenceErrorClass, PersistenceFailure,
-    PersistenceTarget, PersistenceWriteResult, PostCommitFinalization, PostCommitInput,
-    PostCommitNoOpReason, PostCommitRuntimeState, PostRewriteFinalization, PostRewriteNoOpReason,
+    CommitMsgRuntimeState, HookSubcommand, PendingCheckpoint, PendingFileCheckpoint,
+    PendingLineRange, PersistenceErrorClass, PersistenceFailure, PersistenceTarget,
+    PersistenceWriteResult, PostCommitFinalization, PostCommitInput, PostCommitNoOpReason,
+    PostCommitRuntimeState, PostRewriteFinalization, PostRewriteNoOpReason,
     PostRewriteRuntimeState, PreCommitFinalization, PreCommitNoOpReason, PreCommitRuntimeState,
     PreCommitTreeAnchors, RetryMetricsSink, RetryProcessingMetric, RewriteMethod,
     RewriteRemapIngestion, RewriteRemapRequest, RewriteTraceFinalization, RewriteTraceInput,
@@ -792,44 +792,6 @@ fn pre_commit_finalization_uses_only_staged_ranges_and_captures_anchors() {
     );
 }
 
-#[test]
-fn pre_commit_runtime_persists_staged_only_checkpoint_artifact() -> Result<()> {
-    let repo = create_temp_repo()?;
-    let tracked_file = repo.join("src").join("lib.rs");
-    fs::create_dir_all(
-        tracked_file
-            .parent()
-            .expect("tracked file path should have parent"),
-    )?;
-    fs::write(&tracked_file, "one\ntwo\nthree\nfour\n")?;
-    run_git_in_repo(&repo, &["add", "."])?;
-    run_git_in_repo(&repo, &["commit", "-m", "initial"])?;
-
-    fs::write(&tracked_file, "one\ntwo-staged\nthree\nfour\n")?;
-    run_git_in_repo(&repo, &["add", "src/lib.rs"])?;
-    fs::write(&tracked_file, "one\ntwo-staged\nthree\nfour-unstaged\n")?;
-
-    let message = run_pre_commit_subcommand_in_repo(&repo)?;
-    assert_eq!(
-        message,
-        "pre-commit hook executed and finalized staged checkpoint for 1 file(s)."
-    );
-
-    let checkpoint_path = resolve_pre_commit_checkpoint_path(&repo)?;
-    let checkpoint = serde_json::from_slice::<serde_json::Value>(&fs::read(&checkpoint_path)?)?;
-
-    assert_eq!(checkpoint["version"], 1);
-    assert_eq!(checkpoint["files"].as_array().map(Vec::len), Some(1));
-    assert_eq!(checkpoint["files"][0]["path"], "src/lib.rs");
-    assert_eq!(
-        checkpoint["files"][0]["ranges"].as_array().map(Vec::len),
-        Some(1)
-    );
-    assert_eq!(checkpoint["files"][0]["ranges"][0]["start_line"], 2);
-    assert_eq!(checkpoint["files"][0]["ranges"][0]["end_line"], 2);
-    Ok(())
-}
-
 fn sample_commit_msg_runtime() -> CommitMsgRuntimeState {
     CommitMsgRuntimeState {
         sce_disabled: false,

cli/src/services/local_db.rs

@@ -286,21 +286,7 @@ mod tests {
     use crate::test_support::TestTempDir;
     use anyhow::Result;
 
-    use super::{apply_core_schema_migrations, run_smoke_check, LocalDatabaseTarget};
-
-    async fn fetch_single_integer(target: LocalDatabaseTarget<'_>, query: &str) -> Result<i64> {
-        let conn = super::connect_local(target).await?;
-        let mut rows = conn.query(query, ()).await?;
-        let row = rows
-            .next()
-            .await?
-            .ok_or_else(|| anyhow::anyhow!("integer query returned no rows"))?;
-        let value = row.get_value(0)?;
-        let value = *value
-            .as_integer()
-            .ok_or_else(|| anyhow::anyhow!("integer query returned non-integer"))?;
-        Ok(value)
-    }
+    use super::{run_smoke_check, LocalDatabaseTarget};
 
     #[test]
     fn in_memory_smoke_check_succeeds() -> Result<()> {
@@ -320,116 +306,4 @@ mod tests {
         assert!(path.exists());
         Ok(())
     }
-
-    #[test]
-    fn reconciliation_schema_supports_replay_safe_runs_and_mapping_queries() -> Result<()> {
-        let temp = TestTempDir::new("sce-reconciliation-schema-tests")?;
-        let path = temp.path().join("reconciliation.db");
-        let runtime = tokio::runtime::Builder::new_current_thread().build()?;
-
-        runtime.block_on(apply_core_schema_migrations(LocalDatabaseTarget::Path(
-            &path,
-        )))?;
-
-        runtime.block_on(async {
-            let location = super::target_location(LocalDatabaseTarget::Path(&path))?;
-            let db = turso::Builder::new_local(location).build().await?;
-            let conn = db.connect()?;
-
-            conn.execute(
-                "INSERT INTO repositories (canonical_root) VALUES (?1)",
-                ["/tmp/reconciliation-repo"],
-            )
-            .await?;
-
-            conn.execute(
-                "INSERT INTO reconciliation_runs (repository_id, provider, idempotency_key, status) \
-                 VALUES (?1, ?2, ?3, ?4)",
-                (1_i64, "github", "run:key:1", "completed"),
-            )
-            .await?;
-
-            conn.execute(
-                "INSERT INTO conversations (repository_id, url, source) VALUES (?1, ?2, ?3)",
-                (1_i64, "https://example.dev/conversations/abc", "github"),
-            )
-            .await?;
-
-            conn.execute(
-                "INSERT INTO rewrite_mappings (\
-                    reconciliation_run_id, repository_id, old_commit_sha, new_commit_sha,\
-                    mapping_status, confidence, idempotency_key\
-                 ) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7)",
-                (
-                    1_i64,
-                    1_i64,
-                    "1111111111111111111111111111111111111111",
-                    "2222222222222222222222222222222222222222",
-                    "mapped",
-                    0.98_f64,
-                    "map:key:1",
-                ),
-            )
-            .await?;
-
-            let duplicate_run = conn
-                .execute(
-                    "INSERT INTO reconciliation_runs (repository_id, provider, idempotency_key, status) \
-                     VALUES (?1, ?2, ?3, ?4)",
-                    (1_i64, "github", "run:key:1", "completed"),
-                )
-                .await;
-            assert!(duplicate_run.is_err(), "run idempotency key should be unique");
-
-            let duplicate_mapping = conn
-                .execute(
-                    "INSERT INTO rewrite_mappings (\
-                        reconciliation_run_id, repository_id, old_commit_sha, new_commit_sha,\
-                        mapping_status, confidence, idempotency_key\
-                     ) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7)",
-                    (
-                        1_i64,
-                        1_i64,
-                        "1111111111111111111111111111111111111111",
-                        "3333333333333333333333333333333333333333",
-                        "mapped",
-                        0.70_f64,
-                        "map:key:1",
-                    ),
-                )
-                .await;
-            assert!(
-                duplicate_mapping.is_err(),
-                "mapping idempotency key should be unique"
-            );
-
-            Ok::<(), anyhow::Error>(())
-        })?;
-
-        let run_count = runtime.block_on(fetch_single_integer(
-            LocalDatabaseTarget::Path(&path),
-            "SELECT COUNT(*) FROM reconciliation_runs WHERE repository_id = 1 AND status = 'completed'",
-        ))?;
-        assert_eq!(run_count, 1);
-
-        let mapped_count = runtime.block_on(fetch_single_integer(
-            LocalDatabaseTarget::Path(&path),
-            "SELECT COUNT(*) FROM rewrite_mappings WHERE repository_id = 1 AND old_commit_sha = '1111111111111111111111111111111111111111'",
-        ))?;
-        assert_eq!(mapped_count, 1);
-
-        let joined_mapping_count = runtime.block_on(fetch_single_integer(
-            LocalDatabaseTarget::Path(&path),
-            "SELECT COUNT(*) FROM rewrite_mappings m JOIN reconciliation_runs r ON r.id = m.reconciliation_run_id JOIN repositories repo ON repo.id = m.repository_id WHERE r.repository_id = repo.id AND m.old_commit_sha = '1111111111111111111111111111111111111111'",
-        ))?;
-        assert_eq!(joined_mapping_count, 1);
-
-        let conversation_count = runtime.block_on(fetch_single_integer(
-            LocalDatabaseTarget::Path(&path),
-            "SELECT COUNT(*) FROM conversations WHERE repository_id = 1 AND source = 'github'",
-        ))?;
-        assert_eq!(conversation_count, 1);
-
-        Ok(())
-    }
 }

cli/src/services/setup/tests.rs

@@ -94,23 +94,6 @@ fn setup_options_reject_repo_without_hooks() {
     );
 }
 
-#[test]
-fn run_setup_hooks_reports_per_hook_statuses() -> Result<()> {
-    let temp = TestTempDir::new("sce-setup-hook-install-tests")?;
-    init_git_repo(temp.path())?;
-
-    let message = run_setup_hooks(temp.path())?;
-    assert!(message.contains("Hook setup completed successfully."));
-    assert!(message.contains("Repository root:"));
-    assert!(message.contains("Hooks directory:"));
-    assert!(message.contains("commit-msg: installed"));
-    assert!(message.contains("post-commit: installed"));
-    assert!(message.contains("pre-commit: installed"));
-    assert!(message.contains("backup: not needed"));
-
-    Ok(())
-}
-
 #[test]
 fn run_setup_hooks_rejects_missing_repo_path() {
     let missing_path = PathBuf::from("/definitely/missing/sce-test-repo");

cli/src/services/token_storage.rs

@@ -273,7 +273,7 @@ fn apply_secure_file_permissions(_path: &Path) -> Result<(), TokenStorageError>
 
 #[cfg(test)]
 mod tests {
-    use super::{delete_tokens_at_path, load_tokens_from_path, save_tokens_at_path, StoredTokens};
+    use super::{delete_tokens_at_path, load_tokens_from_path};
     use std::fs;
     use std::path::PathBuf;
 
@@ -290,17 +290,6 @@ mod tests {
         std::env::temp_dir().join(unique).join("tokens.json")
     }
 
-    fn fixture_tokens() -> StoredTokens {
-        StoredTokens {
-            access_token: "access-token".to_string(),
-            token_type: "Bearer".to_string(),
-            expires_in: 3600,
-            refresh_token: "refresh-token".to_string(),
-            scope: Some("openid profile".to_string()),
-            stored_at_unix_seconds: 1_700_000_000,
-        }
-    }
-
     #[test]
     fn load_missing_token_file_returns_none() {
         let token_path = unique_test_path("missing-file");
@@ -327,24 +316,6 @@ mod tests {
         );
     }
 
-    #[test]
-    fn delete_existing_token_file_returns_true() {
-        let token_path = unique_test_path("delete-existing");
-        save_tokens_at_path(&token_path, &fixture_tokens()).expect("tokens should save");
-
-        let deleted = delete_tokens_at_path(&token_path).expect("delete should succeed");
-
-        assert!(deleted);
-        assert!(!token_path.exists());
-
-        let _ = fs::remove_dir_all(
-            token_path
-                .parent()
-                .and_then(|path| path.parent())
-                .expect("temp tree should have two parent levels"),
-        );
-    }
-
     #[test]
     fn delete_missing_token_file_returns_false() {
         let token_path = unique_test_path("delete-missing");
@@ -353,24 +324,4 @@ mod tests {
 
         assert!(!deleted);
     }
-
-    #[cfg(unix)]
-    #[test]
-    fn save_sets_unix_file_permissions_to_0600() {
-        use std::os::unix::fs::PermissionsExt;
-
-        let token_path = unique_test_path("unix-perms");
-        save_tokens_at_path(&token_path, &fixture_tokens()).expect("tokens should save");
-
-        let metadata = fs::metadata(&token_path).expect("token file should exist");
-        let mode = metadata.permissions().mode() & 0o777;
-        assert_eq!(mode, 0o600);
-
-        let _ = fs::remove_dir_all(
-            token_path
-                .parent()
-                .and_then(|path| path.parent())
-                .expect("temp tree should have two parent levels"),
-        );
-    }
 }