✨ feat(commands)：为所有命令添加config_path参数支持，实现自定义配置文件路径

♻️ refactor(config)：重构ConfigManager，添加with_path_fresh方法用于初始化新配置
🔧 fix(git)：改进跨平台路径处理，增强git仓库检测的鲁棒性
✅ test(tests)：添加全面的集成测试，覆盖所有命令和跨平台场景

tests/integration_tests.rs

@@ -1,64 +1,642 @@
 use assert_cmd::Command;
 use predicates::prelude::*;
 use std::fs;
+use std::path::PathBuf;
 use tempfile::TempDir;
 
-#[test]
-fn test_cli_help() {
-    let mut cmd = Command::cargo_bin("quicommit").unwrap();
-    cmd.arg("--help");
-    cmd.assert()
-        .success()
-        .stdout(predicate::str::contains("QuiCommit"));
+fn create_git_repo(dir: &PathBuf) -> std::process::Output {
+    std::process::Command::new("git")
+        .args(&["init"])
+        .current_dir(dir)
+        .output()
+        .expect("Failed to init git repo")
 }
 
-#[test]
-fn test_version() {
-    let mut cmd = Command::cargo_bin("quicommit").unwrap();
-    cmd.arg("--version");
-    cmd.assert()
-        .success()
-        .stdout(predicate::str::contains("0.1.0"));
+fn configure_git_user(dir: &PathBuf) {
+    std::process::Command::new("git")
+        .args(&["config", "user.name", "Test User"])
+        .current_dir(dir)
+        .output()
+        .expect("Failed to configure git user name");
+
+    std::process::Command::new("git")
+        .args(&["config", "user.email", "test@example.com"])
+        .current_dir(dir)
+        .output()
+        .expect("Failed to configure git user email");
 }
 
-#[test]
-fn test_config_show() {
-    let temp_dir = TempDir::new().unwrap();
-    let config_dir = temp_dir.path().join("config");
-    fs::create_dir(&config_dir).unwrap();
-    
-    let mut cmd = Command::cargo_bin("quicommit").unwrap();
-    cmd.env("QUICOMMIT_CONFIG", config_dir.join("config.toml"))
-        .arg("config")
-        .arg("show");
-    
-    cmd.assert().success();
+fn create_test_file(dir: &PathBuf, name: &str, content: &str) {
+    let file_path = dir.join(name);
+    fs::write(&file_path, content).expect("Failed to create test file");
 }
 
-#[test]
-fn test_profile_list_empty() {
-    let temp_dir = TempDir::new().unwrap();
-    
-    let mut cmd = Command::cargo_bin("quicommit").unwrap();
-    cmd.env("QUICOMMIT_CONFIG", temp_dir.path().join("config.toml"))
-        .arg("profile")
-        .arg("list");
-    
-    cmd.assert()
-        .success()
-        .stdout(predicate::str::contains("No profiles configured"));
+fn stage_file(dir: &PathBuf, name: &str) {
+    std::process::Command::new("git")
+        .args(&["add", name])
+        .current_dir(dir)
+        .output()
+        .expect("Failed to stage file");
 }
 
-#[test]
-fn test_init_quick() {
-    let temp_dir = TempDir::new().unwrap();
-    
-    let mut cmd = Command::cargo_bin("quicommit").unwrap();
-    cmd.env("QUICOMMIT_CONFIG", temp_dir.path().join("config.toml"))
-        .arg("init")
-        .arg("--yes");
-    
-    cmd.assert()
-        .success()
-        .stdout(predicate::str::contains("initialized successfully"));
+fn create_commit(dir: &PathBuf, message: &str) {
+    std::process::Command::new("git")
+        .args(&["commit", "-m", message])
+        .current_dir(dir)
+        .output()
+        .expect("Failed to create commit");
+}
+
+mod cli_basic {
+    use super::*;
+
+    #[test]
+    fn test_help() {
+        let mut cmd = Command::cargo_bin("quicommit").unwrap();
+        cmd.arg("--help");
+        cmd.assert()
+            .success()
+            .stdout(predicate::str::contains("QuiCommit"))
+            .stdout(predicate::str::contains("AI-powered Git assistant"));
+    }
+
+    #[test]
+    fn test_version() {
+        let mut cmd = Command::cargo_bin("quicommit").unwrap();
+        cmd.arg("--version");
+        cmd.assert()
+            .success()
+            .stdout(predicate::str::contains("quicommit"));
+    }
+
+    #[test]
+    fn test_no_args_shows_help() {
+        let mut cmd = Command::cargo_bin("quicommit").unwrap();
+        cmd.assert()
+            .failure()
+            .stderr(predicate::str::contains("Usage:"));
+    }
+
+    #[test]
+    fn test_verbose_flag() {
+        let temp_dir = TempDir::new().unwrap();
+        let repo_path = temp_dir.path().to_path_buf();
+        let config_path = repo_path.join("config.toml");
+        create_git_repo(&repo_path);
+        configure_git_user(&repo_path);
+
+        let mut cmd = Command::cargo_bin("quicommit").unwrap();
+        cmd.args(&["-vv", "init", "--yes", "--config", config_path.to_str().unwrap()])
+            .current_dir(&repo_path);
+
+        cmd.assert().success();
+    }
+}
+
+mod init_command {
+    use super::*;
+
+    #[test]
+    fn test_init_quick() {
+        let temp_dir = TempDir::new().unwrap();
+        let config_path = temp_dir.path().join("config.toml");
+
+        let mut cmd = Command::cargo_bin("quicommit").unwrap();
+        cmd.args(&["init", "--yes", "--config", config_path.to_str().unwrap()]);
+
+        cmd.assert()
+            .success()
+            .stdout(predicate::str::contains("initialized successfully"));
+    }
+
+    #[test]
+    fn test_init_creates_config_file() {
+        let temp_dir = TempDir::new().unwrap();
+        let config_path = temp_dir.path().join("config.toml");
+
+        let mut cmd = Command::cargo_bin("quicommit").unwrap();
+        cmd.args(&["init", "--yes", "--config", config_path.to_str().unwrap()]);
+
+        cmd.assert().success();
+
+        assert!(config_path.exists(), "Config file should be created");
+    }
+
+    #[test]
+    fn test_init_in_git_repo() {
+        let temp_dir = TempDir::new().unwrap();
+        let repo_path = temp_dir.path().to_path_buf();
+        create_git_repo(&repo_path);
+        configure_git_user(&repo_path);
+
+        let config_path = repo_path.join("test_config.toml");
+
+        let mut cmd = Command::cargo_bin("quicommit").unwrap();
+        cmd.args(&["init", "--yes", "--config", config_path.to_str().unwrap()])
+            .current_dir(&repo_path);
+
+        cmd.assert().success();
+    }
+
+    #[test]
+    fn test_init_reset() {
+        let temp_dir = TempDir::new().unwrap();
+        let config_path = temp_dir.path().join("config.toml");
+
+        let mut cmd = Command::cargo_bin("quicommit").unwrap();
+        cmd.args(&["init", "--yes", "--config", config_path.to_str().unwrap()]);
+        cmd.assert().success();
+
+        let mut cmd = Command::cargo_bin("quicommit").unwrap();
+        cmd.args(&["init", "--yes", "--reset", "--config", config_path.to_str().unwrap()]);
+        cmd.assert()
+            .success()
+            .stdout(predicate::str::contains("initialized successfully"));
+    }
+}
+
+mod profile_command {
+    use super::*;
+
+    #[test]
+    fn test_profile_list_empty() {
+        let temp_dir = TempDir::new().unwrap();
+        let config_path = temp_dir.path().join("config.toml");
+
+        let mut cmd = Command::cargo_bin("quicommit").unwrap();
+        cmd.args(&["profile", "list", "--config", config_path.to_str().unwrap()]);
+
+        cmd.assert()
+            .success()
+            .stdout(predicate::str::contains("No profiles"));
+    }
+
+    #[test]
+    fn test_profile_list_with_profile() {
+        let temp_dir = TempDir::new().unwrap();
+        let config_path = temp_dir.path().join("config.toml");
+
+        let mut cmd = Command::cargo_bin("quicommit").unwrap();
+        cmd.args(&["init", "--yes", "--config", config_path.to_str().unwrap()]);
+        cmd.assert().success();
+
+        let mut cmd = Command::cargo_bin("quicommit").unwrap();
+        cmd.args(&["profile", "list", "--config", config_path.to_str().unwrap()]);
+
+        cmd.assert()
+            .success()
+            .stdout(predicate::str::contains("default"));
+    }
+}
+
+mod config_command {
+    use super::*;
+
+    #[test]
+    fn test_config_show() {
+        let temp_dir = TempDir::new().unwrap();
+        let config_path = temp_dir.path().join("config.toml");
+
+        let mut cmd = Command::cargo_bin("quicommit").unwrap();
+        cmd.args(&["init", "--yes", "--config", config_path.to_str().unwrap()]);
+        cmd.assert().success();
+
+        let mut cmd = Command::cargo_bin("quicommit").unwrap();
+        cmd.args(&["config", "show", "--config", config_path.to_str().unwrap()]);
+
+        cmd.assert()
+            .success()
+            .stdout(predicate::str::contains("Configuration"));
+    }
+
+    #[test]
+    fn test_config_path() {
+        let temp_dir = TempDir::new().unwrap();
+        let config_path = temp_dir.path().join("config.toml");
+
+        let mut cmd = Command::cargo_bin("quicommit").unwrap();
+        cmd.args(&["init", "--yes", "--config", config_path.to_str().unwrap()]);
+        cmd.assert().success();
+
+        let mut cmd = Command::cargo_bin("quicommit").unwrap();
+        cmd.args(&["config", "path", "--config", config_path.to_str().unwrap()]);
+
+        cmd.assert()
+            .success()
+            .stdout(predicate::str::contains("config.toml"));
+    }
+}
+
+mod commit_command {
+    use super::*;
+
+    #[test]
+    fn test_commit_no_repo() {
+        let temp_dir = TempDir::new().unwrap();
+        let config_path = temp_dir.path().join("config.toml");
+
+        let mut cmd = Command::cargo_bin("quicommit").unwrap();
+        cmd.args(&["init", "--yes", "--config", config_path.to_str().unwrap()]);
+        cmd.assert().success();
+
+        let mut cmd = Command::cargo_bin("quicommit").unwrap();
+        cmd.args(&["commit", "--dry-run", "--yes", "--config", config_path.to_str().unwrap()])
+            .current_dir(temp_dir.path());
+
+        cmd.assert()
+            .failure()
+            .stderr(predicate::str::contains("git").or(predicate::str::contains("repository")));
+    }
+
+    #[test]
+    fn test_commit_no_changes() {
+        let temp_dir = TempDir::new().unwrap();
+        let repo_path = temp_dir.path().to_path_buf();
+        create_git_repo(&repo_path);
+        configure_git_user(&repo_path);
+
+        let config_path = repo_path.join("config.toml");
+
+        let mut cmd = Command::cargo_bin("quicommit").unwrap();
+        cmd.args(&["init", "--yes", "--config", config_path.to_str().unwrap()])
+            .current_dir(&repo_path);
+        cmd.assert().success();
+
+        let mut cmd = Command::cargo_bin("quicommit").unwrap();
+        cmd.args(&["commit", "--manual", "-m", "test: empty", "--dry-run", "--yes", "--config", config_path.to_str().unwrap()])
+            .current_dir(&repo_path);
+
+        cmd.assert()
+            .success()
+            .stdout(predicate::str::contains("Dry run"));
+    }
+
+    #[test]
+    fn test_commit_with_staged_changes() {
+        let temp_dir = TempDir::new().unwrap();
+        let repo_path = temp_dir.path().to_path_buf();
+        create_git_repo(&repo_path);
+        configure_git_user(&repo_path);
+
+        create_test_file(&repo_path, "test.txt", "Hello, World!");
+        stage_file(&repo_path, "test.txt");
+
+        let config_path = repo_path.join("config.toml");
+
+        let mut cmd = Command::cargo_bin("quicommit").unwrap();
+        cmd.args(&["init", "--yes", "--config", config_path.to_str().unwrap()])
+            .current_dir(&repo_path);
+        cmd.assert().success();
+
+        let mut cmd = Command::cargo_bin("quicommit").unwrap();
+        cmd.args(&["commit", "--manual", "-m", "test: add test file", "--dry-run", "--yes", "--config", config_path.to_str().unwrap()])
+            .current_dir(&repo_path);
+
+        cmd.assert()
+            .success()
+            .stdout(predicate::str::contains("Dry run"));
+    }
+
+    #[test]
+    fn test_commit_date_mode() {
+        let temp_dir = TempDir::new().unwrap();
+        let repo_path = temp_dir.path().to_path_buf();
+        create_git_repo(&repo_path);
+        configure_git_user(&repo_path);
+
+        create_test_file(&repo_path, "daily.txt", "Daily update");
+        stage_file(&repo_path, "daily.txt");
+
+        let config_path = repo_path.join("config.toml");
+
+        let mut cmd = Command::cargo_bin("quicommit").unwrap();
+        cmd.args(&["init", "--yes", "--config", config_path.to_str().unwrap()])
+            .current_dir(&repo_path);
+        cmd.assert().success();
+
+        let mut cmd = Command::cargo_bin("quicommit").unwrap();
+        cmd.args(&["commit", "--date", "--dry-run", "--yes", "--config", config_path.to_str().unwrap()])
+            .current_dir(&repo_path);
+
+        cmd.assert()
+            .success()
+            .stdout(predicate::str::contains("Dry run"));
+    }
+}
+
+mod tag_command {
+    use super::*;
+
+    #[test]
+    fn test_tag_no_repo() {
+        let temp_dir = TempDir::new().unwrap();
+        let config_path = temp_dir.path().join("config.toml");
+
+        let mut cmd = Command::cargo_bin("quicommit").unwrap();
+        cmd.args(&["init", "--yes", "--config", config_path.to_str().unwrap()]);
+        cmd.assert().success();
+
+        let mut cmd = Command::cargo_bin("quicommit").unwrap();
+        cmd.args(&["tag", "--dry-run", "--yes", "--config", config_path.to_str().unwrap()])
+            .current_dir(temp_dir.path());
+
+        cmd.assert()
+            .failure()
+            .stderr(predicate::str::contains("git").or(predicate::str::contains("repository")));
+    }
+
+    #[test]
+    fn test_tag_list_empty() {
+        let temp_dir = TempDir::new().unwrap();
+        let repo_path = temp_dir.path().to_path_buf();
+        create_git_repo(&repo_path);
+        configure_git_user(&repo_path);
+
+        create_test_file(&repo_path, "test.txt", "content");
+        stage_file(&repo_path, "test.txt");
+        create_commit(&repo_path, "feat: initial commit");
+
+        let config_path = repo_path.join("config.toml");
+
+        let mut cmd = Command::cargo_bin("quicommit").unwrap();
+        cmd.args(&["init", "--yes", "--config", config_path.to_str().unwrap()])
+            .current_dir(&repo_path);
+        cmd.assert().success();
+
+        let mut cmd = Command::cargo_bin("quicommit").unwrap();
+        cmd.args(&["tag", "--name", "v0.1.0", "--dry-run", "--yes", "--config", config_path.to_str().unwrap()])
+            .current_dir(&repo_path);
+
+        cmd.assert()
+            .success()
+            .stdout(predicate::str::contains("v0.1.0"));
+    }
+}
+
+mod changelog_command {
+    use super::*;
+
+    #[test]
+    fn test_changelog_init() {
+        let temp_dir = TempDir::new().unwrap();
+        let repo_path = temp_dir.path().to_path_buf();
+        create_git_repo(&repo_path);
+        configure_git_user(&repo_path);
+
+        let config_path = repo_path.join("config.toml");
+        let changelog_path = repo_path.join("CHANGELOG.md");
+
+        let mut cmd = Command::cargo_bin("quicommit").unwrap();
+        cmd.args(&["init", "--yes", "--config", config_path.to_str().unwrap()])
+            .current_dir(&repo_path);
+        cmd.assert().success();
+
+        let mut cmd = Command::cargo_bin("quicommit").unwrap();
+        cmd.args(&["changelog", "--init", "--output", changelog_path.to_str().unwrap(), "--config", config_path.to_str().unwrap()])
+            .current_dir(&repo_path);
+
+        cmd.assert().success();
+
+        assert!(changelog_path.exists(), "Changelog file should be created");
+    }
+
+    #[test]
+    fn test_changelog_dry_run() {
+        let temp_dir = TempDir::new().unwrap();
+        let repo_path = temp_dir.path().to_path_buf();
+        create_git_repo(&repo_path);
+        configure_git_user(&repo_path);
+
+        create_test_file(&repo_path, "test.txt", "content");
+        stage_file(&repo_path, "test.txt");
+        create_commit(&repo_path, "feat: add feature");
+
+        let config_path = repo_path.join("config.toml");
+
+        let mut cmd = Command::cargo_bin("quicommit").unwrap();
+        cmd.args(&["init", "--yes", "--config", config_path.to_str().unwrap()])
+            .current_dir(&repo_path);
+        cmd.assert().success();
+
+        let mut cmd = Command::cargo_bin("quicommit").unwrap();
+        cmd.args(&["changelog", "--dry-run", "--yes", "--config", config_path.to_str().unwrap()])
+            .current_dir(&repo_path);
+
+        cmd.assert()
+            .success();
+    }
+}
+
+mod cross_platform {
+    use super::*;
+
+    #[test]
+    fn test_path_handling_windows_style() {
+        let temp_dir = TempDir::new().unwrap();
+        let config_path = temp_dir.path().join("subdir").join("config.toml");
+
+        let mut cmd = Command::cargo_bin("quicommit").unwrap();
+        cmd.args(&["init", "--yes", "--config", config_path.to_str().unwrap()]);
+
+        cmd.assert().success();
+        assert!(config_path.exists());
+    }
+
+    #[test]
+    fn test_config_with_spaces_in_path() {
+        let temp_dir = TempDir::new().unwrap();
+        let space_dir = temp_dir.path().join("path with spaces");
+        fs::create_dir_all(&space_dir).unwrap();
+        let config_path = space_dir.join("config.toml");
+
+        let mut cmd = Command::cargo_bin("quicommit").unwrap();
+        cmd.args(&["init", "--yes", "--config", config_path.to_str().unwrap()]);
+
+        cmd.assert().success();
+        assert!(config_path.exists());
+    }
+
+    #[test]
+    fn test_config_with_unicode_path() {
+        let temp_dir = TempDir::new().unwrap();
+        let unicode_dir = temp_dir.path().join("路径测试");
+        fs::create_dir_all(&unicode_dir).unwrap();
+        let config_path = unicode_dir.join("config.toml");
+
+        let mut cmd = Command::cargo_bin("quicommit").unwrap();
+        cmd.args(&["init", "--yes", "--config", config_path.to_str().unwrap()]);
+
+        cmd.assert().success();
+        assert!(config_path.exists());
+    }
+}
+
+mod git_operations {
+    use super::*;
+
+    #[test]
+    fn test_git_repo_detection() {
+        let temp_dir = TempDir::new().unwrap();
+        let repo_path = temp_dir.path().to_path_buf();
+        create_git_repo(&repo_path);
+        configure_git_user(&repo_path);
+
+        let git_dir = repo_path.join(".git");
+        assert!(git_dir.exists(), ".git directory should exist");
+    }
+
+    #[test]
+    fn test_git_status_clean() {
+        let temp_dir = TempDir::new().unwrap();
+        let repo_path = temp_dir.path().to_path_buf();
+        create_git_repo(&repo_path);
+        configure_git_user(&repo_path);
+
+        let output = std::process::Command::new("git")
+            .args(&["status", "--porcelain"])
+            .current_dir(&repo_path)
+            .output()
+            .expect("Failed to run git status");
+
+        assert!(output.status.success());
+        assert!(String::from_utf8_lossy(&output.stdout).is_empty());
+    }
+
+    #[test]
+    fn test_git_commit_creation() {
+        let temp_dir = TempDir::new().unwrap();
+        let repo_path = temp_dir.path().to_path_buf();
+        create_git_repo(&repo_path);
+        configure_git_user(&repo_path);
+
+        create_test_file(&repo_path, "test.txt", "content");
+        stage_file(&repo_path, "test.txt");
+        create_commit(&repo_path, "feat: initial commit");
+
+        let output = std::process::Command::new("git")
+            .args(&["log", "--oneline"])
+            .current_dir(&repo_path)
+            .output()
+            .expect("Failed to run git log");
+
+        assert!(output.status.success());
+        let log = String::from_utf8_lossy(&output.stdout);
+        assert!(log.contains("initial commit"));
+    }
+}
+
+mod validators {
+    use super::*;
+
+    #[test]
+    fn test_commit_message_validation() {
+        let temp_dir = TempDir::new().unwrap();
+        let repo_path = temp_dir.path().to_path_buf();
+        create_git_repo(&repo_path);
+        configure_git_user(&repo_path);
+
+        create_test_file(&repo_path, "test.txt", "content");
+        stage_file(&repo_path, "test.txt");
+
+        let config_path = repo_path.join("config.toml");
+
+        let mut cmd = Command::cargo_bin("quicommit").unwrap();
+        cmd.args(&["init", "--yes", "--config", config_path.to_str().unwrap()])
+            .current_dir(&repo_path);
+        cmd.assert().success();
+
+        let mut cmd = Command::cargo_bin("quicommit").unwrap();
+        cmd.args(&["commit", "--manual", "-m", "invalid commit message without type", "--dry-run", "--yes", "--config", config_path.to_str().unwrap()])
+            .current_dir(&repo_path);
+
+        cmd.assert()
+            .failure()
+            .stderr(predicate::str::contains("Invalid").or(predicate::str::contains("format")));
+    }
+
+    #[test]
+    fn test_valid_conventional_commit() {
+        let temp_dir = TempDir::new().unwrap();
+        let repo_path = temp_dir.path().to_path_buf();
+        create_git_repo(&repo_path);
+        configure_git_user(&repo_path);
+
+        create_test_file(&repo_path, "test.txt", "content");
+        stage_file(&repo_path, "test.txt");
+
+        let config_path = repo_path.join("config.toml");
+
+        let mut cmd = Command::cargo_bin("quicommit").unwrap();
+        cmd.args(&["init", "--yes", "--config", config_path.to_str().unwrap()])
+            .current_dir(&repo_path);
+        cmd.assert().success();
+
+        let mut cmd = Command::cargo_bin("quicommit").unwrap();
+        cmd.args(&["commit", "--manual", "-m", "feat: add new feature", "--dry-run", "--yes", "--config", config_path.to_str().unwrap()])
+            .current_dir(&repo_path);
+
+        cmd.assert()
+            .success()
+            .stdout(predicate::str::contains("Dry run"));
+    }
+}
+
+mod subcommands {
+    use super::*;
+
+    #[test]
+    fn test_commit_alias() {
+        let temp_dir = TempDir::new().unwrap();
+        let repo_path = temp_dir.path().to_path_buf();
+        create_git_repo(&repo_path);
+        configure_git_user(&repo_path);
+
+        create_test_file(&repo_path, "test.txt", "content");
+        stage_file(&repo_path, "test.txt");
+
+        let config_path = repo_path.join("config.toml");
+
+        let mut cmd = Command::cargo_bin("quicommit").unwrap();
+        cmd.args(&["init", "--yes", "--config", config_path.to_str().unwrap()])
+            .current_dir(&repo_path);
+        cmd.assert().success();
+
+        let mut cmd = Command::cargo_bin("quicommit").unwrap();
+        cmd.args(&["c", "--manual", "-m", "fix: test", "--dry-run", "--yes", "--config", config_path.to_str().unwrap()])
+            .current_dir(&repo_path);
+
+        cmd.assert()
+            .success()
+            .stdout(predicate::str::contains("Dry run"));
+    }
+
+    #[test]
+    fn test_init_alias() {
+        let temp_dir = TempDir::new().unwrap();
+        let config_path = temp_dir.path().join("config.toml");
+
+        let mut cmd = Command::cargo_bin("quicommit").unwrap();
+        cmd.args(&["i", "--yes", "--config", config_path.to_str().unwrap()]);
+
+        cmd.assert()
+            .success()
+            .stdout(predicate::str::contains("initialized successfully"));
+    }
+
+    #[test]
+    fn test_profile_alias() {
+        let temp_dir = TempDir::new().unwrap();
+        let config_path = temp_dir.path().join("config.toml");
+
+        let mut cmd = Command::cargo_bin("quicommit").unwrap();
+        cmd.args(&["init", "--yes", "--config", config_path.to_str().unwrap()]);
+        cmd.assert().success();
+
+        let mut cmd = Command::cargo_bin("quicommit").unwrap();
+        cmd.args(&["p", "list", "--config", config_path.to_str().unwrap()]);
+
+        cmd.assert()
+            .success()
+            .stdout(predicate::str::contains("default"));
+    }
 }