ros_remove 0.1.5

//! Tests for the `ros_remove` crate.
//!
//! This module contains unit and integration tests for the `ros_remove` crate.
//! It tests the functionality of removing dependencies from `Cargo.toml` and `package.xml` files,
//! as well as the command-line argument parsing.

#[cfg(test)]
mod tests {

    use ros_remove::{env_to_matches, remove_from_cargo_toml, remove_from_package_xml};

    use std::{
        env,
        fs::{self},
        io::ErrorKind,
        sync::Mutex,
    };
    use tempfile::tempdir;

    // Mutex to prevent tests from interfering with each other when changing the current directory
    static DIR_MUTEX: Mutex<()> = Mutex::new(());

    fn standard_args() -> Vec<String> {
        ["cargo", "ros-remove"]
            .into_iter()
            .map(|item| item.to_string())
            .collect::<Vec<String>>()
    }

    /// Tests the `env_to_matches` function for basic dependency removal.
    #[test]
    fn test_env_to_matches_basic() {
        let args = standard_args()
            .into_iter()
            .chain(["serde"].into_iter().map(|item| item.to_string()))
            .collect::<Vec<String>>();
        let matches = env_to_matches(args);
        assert_eq!(matches.get_one::<String>("dependency").unwrap(), "serde");
        assert!(!matches.get_flag("no_cargo_toml"));
        assert!(!matches.get_flag("no_package_xml"));
        assert!(!matches.get_flag("build"));
        assert!(!matches.get_flag("dev"));
    }

    /// Tests the `env_to_matches` function with `--no-cargo-toml` flag.
    #[test]
    fn test_env_to_matches_no_cargo_toml() {
        let args = standard_args()
            .into_iter()
            .chain(
                ["serde", "--no-cargo-toml"]
                    .into_iter()
                    .map(|item| item.to_string()),
            )
            .collect::<Vec<String>>();
        let matches = env_to_matches(args);
        assert!(matches.get_flag("no_cargo_toml"));
        assert!(!matches.get_flag("no_package_xml"));
    }

    /// Tests the `env_to_matches` function with `--no-package-xml` flag.
    #[test]
    fn test_env_to_matches_no_package_xml() {
        let args = standard_args()
            .into_iter()
            .chain(
                ["serde", "--no-package-xml"]
                    .into_iter()
                    .map(|item| item.to_string()),
            )
            .collect::<Vec<String>>();
        let matches = env_to_matches(args);
        assert!(!matches.get_flag("no_cargo_toml"));
        assert!(matches.get_flag("no_package_xml"));
    }

    /// Tests the `env_to_matches` function with `--build` flag.
    #[test]
    fn test_env_to_matches_build() {
        let args = standard_args()
            .into_iter()
            .chain(
                ["serde", "--build"]
                    .into_iter()
                    .map(|item| item.to_string()),
            )
            .collect::<Vec<String>>();
        let matches = env_to_matches(args);
        assert!(matches.get_flag("build"));
        assert!(!matches.get_flag("dev"));
    }

    /// Tests the `env_to_matches` function with `--dev` flag.
    #[test]
    fn test_env_to_matches_dev() {
        let args: Vec<String> = standard_args()
            .into_iter()
            .chain(["serde", "--dev"].map(String::from))
            .collect();
        let matches = env_to_matches(args);
        assert!(!matches.get_flag("build"));
        assert!(matches.get_flag("dev"));
    }

    /// Tests the `remove_from_cargo_toml` function.
    #[test]
    fn test_remove_from_cargo_toml() -> Result<(), ErrorKind> {
        let dir = tempdir().unwrap();
        let cargo_toml_path = dir.path().join("Cargo.toml");
        let cargo_toml_content = r#"
            [package]
            name = "test_package"
            version = "0.1.0"

            [dependencies]
            serde = "1.0"

            [build-dependencies]
            tokio = "1.0"

            [dev-dependencies]
            tempfile = "3.0"
        "#;
        fs::write(&cargo_toml_path, cargo_toml_content).map_err(|e| e.kind())?;

        // Remove `serde` from `dependencies`.
        remove_from_cargo_toml(&cargo_toml_path, "serde", vec!["dependencies"])?;
        let updated_content = fs::read_to_string(&cargo_toml_path).map_err(|e| e.kind())?;
        assert!(!updated_content.contains("serde = \"1.0\""));

        // Remove `tokio` from `build-dependencies`.
        remove_from_cargo_toml(&cargo_toml_path, "tokio", vec!["build-dependencies"])?;
        let updated_content = fs::read_to_string(&cargo_toml_path).map_err(|e| e.kind())?;
        assert!(!updated_content.contains("tokio = \"1.0\""));

        // Remove `tempfile` from `dev-dependencies`.
        remove_from_cargo_toml(&cargo_toml_path, "tempfile", vec!["dev-dependencies"])?;
        let updated_content = fs::read_to_string(&cargo_toml_path).map_err(|e| e.kind())?;
        assert!(!updated_content.contains("tempfile = \"3.0\""));
        Ok(())
    }

    /// Tests the `remove_from_package_xml` function.
    #[test]
    fn test_remove_from_package_xml() -> Result<(), ErrorKind> {
        let dir = tempdir().unwrap();
        let package_xml_path = dir.path().join("package.xml");
        let package_xml_content = r#"
            <package format="3">
                <name>test_package</name>
                <version>0.1.0</version>
                <description>Test package</description>
                <maintainer email="test@example.com">Test Maintainer</maintainer>
                <license>MIT</license>
                <depend>serde</depend>
                <build_depend>tokio</build_depend>
                <exec_depend>tempfile</exec_depend>
                <test_depend>mockall</test_depend>
                <doc_depend>rustdoc</doc_depend>
                <export>
                    <build_type>ament_cmake</build_type>
                </export>
            </package>
        "#;
        fs::write(&package_xml_path, package_xml_content).map_err(|e| e.kind())?;

        // Remove `serde` from `depend`.
        remove_from_package_xml(&package_xml_path, "serde")?;
        let updated_content = fs::read_to_string(&package_xml_path).map_err(|e| e.kind())?;
        assert!(!updated_content.contains("<depend>serde</depend>"));

        // Remove `tokio` from `build_depend`.
        remove_from_package_xml(&package_xml_path, "tokio")?;
        let updated_content = fs::read_to_string(&package_xml_path).map_err(|e| e.kind())?;
        assert!(!updated_content.contains("<build_depend>tokio</build_depend>"));

        // Remove `tempfile` from `exec_depend`.
        remove_from_package_xml(&package_xml_path, "tempfile")?;
        let updated_content = fs::read_to_string(&package_xml_path).map_err(|e| e.kind())?;
        assert!(!updated_content.contains("<exec_depend>tempfile</exec_depend>"));
        Ok(())
    }

    /// Tests the `remove_dependency` function with a mock `Cargo.toml` and `package.xml`.
    #[test]
    fn test_remove_dependency() -> Result<(), ErrorKind> {
        let _lock = DIR_MUTEX.lock().unwrap();

        let dir = tempdir().unwrap();
        let original_dir = env::current_dir().map_err(|e| e.kind())?;

        // Change to temp directory
        env::set_current_dir(&dir).map_err(|e| e.kind())?;

        // Create files in temp directory (current directory)
        let cargo_toml_path = dir.path().join("Cargo.toml");
        let package_xml_path = dir.path().join("package.xml");

        // Create a mock `Cargo.toml`.
        let cargo_toml_content = r#"
            [package]
            name = "test_package"
            version = "0.1.0"

            [dependencies]
            serde = "1.0"

            [build-dependencies]
            tokio = "1.0"
            [dev-dependencies]
            tempfile = "3.0"
        "#;
        fs::write(&cargo_toml_path, cargo_toml_content).map_err(|e| e.kind())?;

        // Create a mock `package.xml`.
        let package_xml_content = r#"
            <package format="3">
                <name>test_package</name>
                <version>0.1.0</version>
                <description>Test package</description>
                <maintainer email="test@example.com">Test Maintainer</maintainer>
                <license>MIT</license>
                <depend>serde</depend>
                <build_depend>tokio</build_depend>
                <exec_depend>tempfile</exec_depend>
            </package>
        "#;
        fs::write(&package_xml_path, package_xml_content).map_err(|e| e.kind())?;

        // Test removing `serde` from both files.
        let args = vec![
            "cargo".to_string(),
            "ros-remove".to_string(),
            "serde".to_string(),
        ];
        let matches = env_to_matches(args);
        ros_remove::remove_dependency(&matches)?;
        // Change back to original directory
        env::set_current_dir(&original_dir).map_err(|e| e.kind())?;

        // Verify `serde` was removed from `Cargo.toml`.
        let updated_cargo_toml = fs::read_to_string(&cargo_toml_path).map_err(|e| e.kind())?;
        assert!(!updated_cargo_toml.contains("serde = \"1.0\""));

        // Verify `serde` was removed from `package.xml`.
        let updated_package_xml = fs::read_to_string(&package_xml_path).map_err(|e| e.kind())?;
        assert!(!updated_package_xml.contains("<depend>serde</depend>"));
        Ok(())
    }

    /// Tests the `remove_dependency` function with `--build` flag (Cargo.toml only).
    #[test]
    fn test_remove_dependency_build() -> Result<(), ErrorKind> {
        let _lock = DIR_MUTEX.lock().unwrap(); // Locking cannot fail; unwrap is safe.

        let dir = tempdir().unwrap();
        let original_dir = env::current_dir().map_err(|e| e.kind())?;

        env::set_current_dir(&dir).map_err(|e| e.kind())?;

        let cargo_toml_path = dir.path().join("Cargo.toml");
        let cargo_toml_content = r#"
            [package]
            name = "test_package"
            version = "0.1.0"

            [dependencies]
            rclrs = "*"

            [build-dependencies]
            tokio = "1.0"
        "#;
        fs::write(&cargo_toml_path, cargo_toml_content).map_err(|e| e.kind())?;

        // Remove only from Cargo.toml – explicitly skip package.xml
        let args = [
            "cargo",
            "ros-remove",
            "tokio",
            "--build",
            "--no-package-xml",
        ]
        .into_iter()
        .map(String::from)
        .collect::<Vec<String>>();
        let matches = env_to_matches(args);
        ros_remove::remove_dependency(&matches)?;

        env::set_current_dir(&original_dir).map_err(|e| e.kind())?;

        let updated = fs::read_to_string(&cargo_toml_path).map_err(|e| e.kind())?;
        assert!(!updated.contains("tokio = \"1.0\""));
        Ok(())
    }

    /// Tests the `remove_dependency` function with `--dev` flag (Cargo.toml only).
    #[test]
    fn test_remove_dependency_dev() -> Result<(), ErrorKind> {
        let _lock = DIR_MUTEX.lock().unwrap();

        let dir = tempdir().unwrap();
        let original_dir = env::current_dir().map_err(|e| e.kind())?;

        env::set_current_dir(&dir).map_err(|e| e.kind())?;

        let cargo_toml_path = dir.path().join("Cargo.toml");
        let package_xml_path = dir.path().join("package.xml");
        let cargo_toml_content = r#"
            [package]
            name = "test_package"
            version = "0.1.0"

            [dependencies]
            rclrs = "*"

            [dev-dependencies]
            tempfile = "3.0"
        "#;
        let package_content = r#"
            <package format="3">
                <name>test_package</name>
                <version>0.1.0</version>
                <description>Test package</description>
                <maintainer email="test@example.com">Test Maintainer</maintainer>
                <license>MIT</license>
                <depend>serde</depend>
            </package>
        "#;
        fs::write(&cargo_toml_path, cargo_toml_content).map_err(|e| e.kind())?;

        fs::write(&package_xml_path, package_content).map_err(|e| e.kind())?;

        // Remove only from Cargo.toml – skip package.xml
        let args = [
            "cargo",
            "ros-remove",
            "tempfile",
            "--dev",
            "--no-package-xml",
        ]
        .into_iter()
        .map(String::from)
        .collect::<Vec<_>>();
        let matches = env_to_matches(args);
        ros_remove::remove_dependency(&matches)?;

        env::set_current_dir(&original_dir).map_err(|e| e.kind())?;

        let updated = fs::read_to_string(&cargo_toml_path).map_err(|e| e.kind())?;
        assert!(!updated.contains("tempfile = \"3.0\""));
        Ok(())
    }

    /// Tests the `remove_dependency` function with `--no-cargo-toml` flag.
    #[test]
    fn test_remove_dependency_no_cargo_toml() -> Result<(), ErrorKind> {
        let _lock = DIR_MUTEX.lock().unwrap();

        let dir = tempdir().unwrap();
        let original_dir = env::current_dir().map_err(|e| e.kind())?;

        env::set_current_dir(&dir).map_err(|e| e.kind())?;

        // Both files are created
        let cargo_toml_path = dir.path().join("Cargo.toml");
        let package_xml_path = dir.path().join("package.xml");

        let cargo_content = r#"
            [package]
            name = "test_package"
            version = "0.1.0"
            [dependencies]
            serde = "1.0"

            [build-dependencies]
            rclrs = "*"
        "#;
        fs::write(&cargo_toml_path, cargo_content).map_err(|e| e.kind())?;

        let package_content = r#"
            <package format="3">
                <name>test_package</name>
                <version>0.1.0</version>
                <description>Test package</description>
                <maintainer email="test@example.com">Test Maintainer</maintainer>
                <license>MIT</license>
                <depend>serde</depend>
            </package>
        "#;
        fs::write(&package_xml_path, package_content).map_err(|e| e.kind())?;

        // Remove from package.xml only
        let args = ["cargo", "ros-remove", "serde", "--no-cargo-toml"]
            .into_iter()
            .map(String::from)
            .collect::<Vec<_>>();
        let matches = env_to_matches(args);
        ros_remove::remove_dependency(&matches)?;

        env::set_current_dir(&original_dir).map_err(|e| e.kind())?;

        // Verify Cargo.toml unchanged
        let cargo = fs::read_to_string(&cargo_toml_path).map_err(|e| e.kind())?;
        assert!(cargo.contains("serde = \"1.0\""));

        // Verify package.xml updated
        let package = fs::read_to_string(&package_xml_path).map_err(|e| e.kind())?;
        assert!(!package.contains("<depend>serde</depend>"));
        Ok(())
    }

    /// Tests the `remove_dependency` function with `--no-package-xml` flag.
    #[test]
    fn test_remove_dependency_no_package_xml() -> Result<(), ErrorKind> {
        let _lock = DIR_MUTEX.lock().unwrap();

        let dir = tempdir().unwrap();
        let original_dir = env::current_dir().map_err(|e| e.kind())?;

        env::set_current_dir(&dir).map_err(|e| e.kind())?;

        let cargo_toml_path = dir.path().join("Cargo.toml");
        let package_xml_path = dir.path().join("package.xml");

        let cargo_content = r#"
            [package]
            name = "test_package"
            version = "0.1.0"
            [dependencies]
            serde = "1.0"
        "#;
        fs::write(&cargo_toml_path, cargo_content).map_err(|e| e.kind())?;

        let package_content = r#"
            <package format="3">
                <name>test_package</name>
                <version>0.1.0</version>
                <description>Test package</description>
                <maintainer email="test@example.com">Test Maintainer</maintainer>
                <license>MIT</license>
                <depend>serde</depend>
            </package>
        "#;
        fs::write(&package_xml_path, package_content).map_err(|e| e.kind())?;

        // Remove from Cargo.toml only
        let args = standard_args()
            .into_iter()
            .chain(["serde", "--no-package-xml"].into_iter().map(String::from))
            .collect::<Vec<_>>();
        let matches = env_to_matches(args);
        ros_remove::remove_dependency(&matches)?;

        env::set_current_dir(&original_dir).map_err(|e| e.kind())?;

        // Verify Cargo.toml updated
        let cargo = fs::read_to_string(&cargo_toml_path).map_err(|e| e.kind())?;
        assert!(!cargo.contains("serde = \"1.0\""));

        // Verify package.xml unchanged
        let package = fs::read_to_string(&package_xml_path).map_err(|e| e.kind())?;
        assert!(package.contains("<depend>serde</depend>"));
        Ok(())
    }

    // Add these imports at the top of the tests module if not already present

    // ============== Error Handling Tests ==============

    /// Test that `remove_dependency` returns `NotFound` when Cargo.toml is missing.
    #[test]
    fn test_remove_dependency_cargo_toml_not_found() -> Result<(), ErrorKind> {
        let _lock = DIR_MUTEX.lock().unwrap();
        let dir = tempdir().unwrap();
        let original_dir = env::current_dir().map_err(|e| e.kind())?;
        env::set_current_dir(&dir).map_err(|e| e.kind())?;

        // Only create package.xml, no Cargo.toml
        let package_xml_path = dir.path().join("package.xml");
        fs::write(&package_xml_path, r#"<package format="3"><name>pkg</name><version>0.1</version><description>desc</description><maintainer email="a@b.c">m</maintainer><license>MIT</license></package>"#)
        .map_err(|e| e.kind())?;

        let args = standard_args()
            .into_iter()
            .chain(["serde"].map(String::from))
            .collect::<Vec<_>>();
        let matches = env_to_matches(args);
        let result = ros_remove::remove_dependency(&matches);

        env::set_current_dir(&original_dir).map_err(|e| e.kind())?;
        assert!(matches!(result, Err(ErrorKind::NotFound)));
        Ok(())
    }

    /// Test that `remove_dependency` returns `NotFound` when package.xml is missing.
    #[test]
    fn test_remove_dependency_package_xml_not_found() -> Result<(), ErrorKind> {
        let _lock = DIR_MUTEX.lock().unwrap();
        let dir = tempdir().unwrap();
        let original_dir = env::current_dir().map_err(|e| e.kind())?;
        env::set_current_dir(&dir).map_err(|e| e.kind())?;

        // Only create Cargo.toml, no package.xml
        let cargo_toml_path = dir.path().join("Cargo.toml");
        fs::write(
            &cargo_toml_path,
            "[package]\nname=\"pkg\"\nversion=\"0.1\"\n[dependencies]\nserde=\"1.0\"",
        )
        .map_err(|e| e.kind())?;

        let args = standard_args()
            .into_iter()
            .chain(["serde"].map(String::from))
            .collect::<Vec<_>>();
        let matches = env_to_matches(args);
        let result = ros_remove::remove_dependency(&matches);

        env::set_current_dir(&original_dir).map_err(|e| e.kind())?;
        assert!(matches!(result, Err(ErrorKind::NotFound)));
        Ok(())
    }

    /// Test `remove_from_cargo_toml` with invalid TOML content.
    #[test]
    fn test_remove_from_cargo_toml_invalid_toml() {
        let dir = tempdir().unwrap();
        let cargo_toml_path = dir.path().join("Cargo.toml");
        // Invalid TOML: missing closing bracket
        fs::write(&cargo_toml_path, "[dependencies\nserde=\"1.0\"")
            .expect("Failed to write invalid TOML");

        let result = remove_from_cargo_toml(&cargo_toml_path, "serde", vec!["dependencies"]);
        assert!(matches!(result, Err(ErrorKind::InvalidData)));
    }

    /// Test `remove_from_package_xml` with invalid XML content.
    #[test]
    fn test_remove_from_package_xml_invalid_xml() {
        let dir = tempdir().unwrap();
        let package_xml_path = dir.path().join("package.xml");
        // Invalid XML: unclosed tag
        fs::write(&package_xml_path, "<package><name>pkg</name>")
            .expect("Failed to write invalid XML");

        let result = remove_from_package_xml(&package_xml_path, "serde");
        assert!(matches!(result, Err(ErrorKind::InvalidData)));
    }

    /// Test permission denied when writing to Cargo.toml (Unix only).
    #[cfg(unix)]
    #[test]
    fn test_remove_from_cargo_toml_permission_denied() -> Result<(), ErrorKind> {
        let dir = tempdir().unwrap();
        let cargo_toml_path = dir.path().join("Cargo.toml");
        let content = "[dependencies]\nserde=\"1.0\"\n";
        fs::write(&cargo_toml_path, content).map_err(|e| e.kind())?;

        // Make file read-only
        let mut perms = fs::metadata(&cargo_toml_path)
            .map_err(|e| e.kind())?
            .permissions();
        perms.set_readonly(true);
        fs::set_permissions(&cargo_toml_path, perms).map_err(|e| e.kind())?;

        let result = remove_from_cargo_toml(&cargo_toml_path, "serde", vec!["dependencies"]);
        assert!(matches!(result, Err(ErrorKind::PermissionDenied)));

        // Restore permissions for cleanup (tempdir will delete anyway)
        Ok(())
    }

    /// Test permission denied when writing to package.xml (Unix only).
    #[cfg(unix)]
    #[test]
    fn test_remove_from_package_xml_permission_denied() -> Result<(), ErrorKind> {
        let dir = tempdir().unwrap();
        let package_xml_path = dir.path().join("package.xml");
        let content = r#"<package format="3"><name>pkg</name><version>0.1</version><description>d</description><maintainer email="a@b.c">m</maintainer><license>MIT</license><depend>serde</depend></package>"#;
        fs::write(&package_xml_path, content).map_err(|e| e.kind())?;

        let mut perms = fs::metadata(&package_xml_path)
            .map_err(|e| e.kind())?
            .permissions();
        perms.set_readonly(true);
        fs::set_permissions(&package_xml_path, perms).map_err(|e| e.kind())?;

        let result = remove_from_package_xml(&package_xml_path, "serde");
        assert!(matches!(result, Err(ErrorKind::PermissionDenied)));
        Ok(())
    }

    // ============== Edge Cases ==============

    /// Test removing a dependency that does not exist in Cargo.toml.
    #[test]
    fn test_remove_from_cargo_toml_dependency_not_present() -> Result<(), ErrorKind> {
        let dir = tempdir().unwrap();
        let cargo_toml_path = dir.path().join("Cargo.toml");
        let content = "[dependencies]\ntokio=\"1.0\"\n";
        fs::write(&cargo_toml_path, content).map_err(|e| e.kind())?;

        remove_from_cargo_toml(&cargo_toml_path, "serde", vec!["dependencies"])?;

        let updated = fs::read_to_string(&cargo_toml_path).map_err(|e| e.kind())?;
        assert_eq!(updated, content); // File unchanged
        Ok(())
    }

    /// Test removing a dependency that does not exist in package.xml.
    #[test]
    fn test_remove_from_package_xml_dependency_not_present() -> Result<(), ErrorKind> {
        let dir = tempdir().unwrap();
        let package_xml_path = dir.path().join("package.xml");
        let content = r#"<package format="3"><name>pkg</name><version>0.1</version><description>d</description><maintainer email="a@b.c">m</maintainer><license>MIT</license><depend>tokio</depend></package>"#;
        fs::write(&package_xml_path, content).map_err(|e| e.kind())?;

        remove_from_package_xml(&package_xml_path, "serde")?;

        let updated = fs::read_to_string(&package_xml_path).map_err(|e| e.kind())?;
        assert_eq!(updated, content); // File unchanged
        Ok(())
    }

    // ============== Cargo.toml Variants ==============

    /// Test removing an inline table dependency from Cargo.toml.
    #[test]
    fn test_remove_from_cargo_toml_inline_table() -> Result<(), ErrorKind> {
        let dir = tempdir().unwrap();
        let cargo_toml_path = dir.path().join("Cargo.toml");
        let content = r#"
        [package]
        name = "test"
        version = "0.1.0"
        [dependencies]
        serde = { version = "1.0", features = ["derive"] }
        tokio = "1.0"
    "#;
        fs::write(&cargo_toml_path, content).map_err(|e| e.kind())?;

        remove_from_cargo_toml(&cargo_toml_path, "serde", vec!["dependencies"])?;

        let updated = fs::read_to_string(&cargo_toml_path).map_err(|e| e.kind())?;
        assert!(!updated.contains("serde = {"));
        assert!(updated.contains("tokio = \"1.0\""));
        Ok(())
    }

    /// Test removing a dependency from an empty dependencies section (no panic).
    #[test]
    fn test_remove_from_cargo_toml_empty_section() -> Result<(), ErrorKind> {
        let dir = tempdir().unwrap();
        let cargo_toml_path = dir.path().join("Cargo.toml");
        let content = "[dependencies]\n";
        fs::write(&cargo_toml_path, content).map_err(|e| e.kind())?;

        // Should not panic and file should remain unchanged
        remove_from_cargo_toml(&cargo_toml_path, "serde", vec!["dependencies"])?;
        let updated = fs::read_to_string(&cargo_toml_path).map_err(|e| e.kind())?;
        assert_eq!(updated, content);
        Ok(())
    }

    /// Test that after removing the last dependency, the table header remains.
    #[test]
    fn test_remove_from_cargo_toml_last_dependency_keeps_section() -> Result<(), ErrorKind> {
        let dir = tempdir().unwrap();
        let cargo_toml_path = dir.path().join("Cargo.toml");
        let content = "[dependencies]\nserde = \"1.0\"\n";
        fs::write(&cargo_toml_path, content).map_err(|e| e.kind())?;

        remove_from_cargo_toml(&cargo_toml_path, "serde", vec!["dependencies"])?;

        let updated = fs::read_to_string(&cargo_toml_path).map_err(|e| e.kind())?;
        assert_eq!(updated, "[dependencies]\n"); // Header remains
        Ok(())
    }

    #[test]
    fn test_remove_from_cargo_toml_multiple_sections_selective() -> Result<(), ErrorKind> {
        let _lock = DIR_MUTEX.lock().unwrap();
        let dir = tempdir().unwrap();
        let original_dir = env::current_dir().map_err(|e| e.kind())?;
        env::set_current_dir(&dir).map_err(|e| e.kind())?;

        let cargo_toml_path = dir.path().join("Cargo.toml");
        let content = r#"
        [dependencies]
        serde = "1.0"
        [build-dependencies]
        serde = "1.0"
        [dev-dependencies]
        serde = "1.0"
    "#;
        fs::write(&cargo_toml_path, content).map_err(|e| e.kind())?;

        let args = standard_args()
            .into_iter()
            .chain(["serde", "--build", "--no-package-xml"].map(String::from))
            .collect::<Vec<_>>();
        let matches = env_to_matches(args);
        ros_remove::remove_dependency(&matches)?;

        env::set_current_dir(&original_dir).map_err(|e| e.kind())?;

        let updated = fs::read_to_string(&cargo_toml_path).map_err(|e| e.kind())?;

        // Parse the document and verify the actual tables
        let doc = updated
            .parse::<toml_edit::DocumentMut>()
            .map_err(|_| ErrorKind::InvalidData)?;

        // 1. [dependencies] still contains serde
        let deps = doc
            .get("dependencies")
            .and_then(toml_edit::Item::as_table)
            .expect("[dependencies] table should exist");
        assert!(deps.contains_key("serde"));

        // 2. [build-dependencies] either doesn't exist OR exists without "serde"
        if let Some(build_table) = doc
            .get("build-dependencies")
            .and_then(toml_edit::Item::as_table)
        {
            assert!(!build_table.contains_key("serde"));
        }

        // 3. [dev-dependencies] still contains serde
        let dev_deps = doc
            .get("dev-dependencies")
            .and_then(toml_edit::Item::as_table)
            .expect("[dev-dependencies] table should exist");
        assert!(dev_deps.contains_key("serde"));

        Ok(())
    }

    // ============== package.xml Variants ==============

    /// Test removal from <test_depend>.
    #[test]
    fn test_remove_from_package_xml_test_depend() -> Result<(), ErrorKind> {
        let dir = tempdir().unwrap();
        let package_xml_path = dir.path().join("package.xml");
        let content = r#"
        <package format="3">
            <name>test_package</name>
            <version>0.1.0</version>
            <description>Test</description>
            <maintainer email="a@b.c">m</maintainer>
            <license>MIT</license>
            <test_depend>mockall</test_depend>
        </package>
    "#;
        fs::write(&package_xml_path, content).map_err(|e| e.kind())?;

        remove_from_package_xml(&package_xml_path, "mockall")?;

        let updated = fs::read_to_string(&package_xml_path).map_err(|e| e.kind())?;
        assert!(!updated.contains("<test_depend>mockall</test_depend>"));
        Ok(())
    }

    /// Test removal from <doc_depend>.
    #[test]
    fn test_remove_from_package_xml_doc_depend() -> Result<(), ErrorKind> {
        let dir = tempdir().unwrap();
        let package_xml_path = dir.path().join("package.xml");
        let content = r#"
        <package format="3">
            <name>test_package</name>
            <version>0.1.0</version>
            <description>Test</description>
            <maintainer email="a@b.c">m</maintainer>
            <license>MIT</license>
            <doc_depend>rustdoc</doc_depend>
        </package>
    "#;
        fs::write(&package_xml_path, content).map_err(|e| e.kind())?;

        remove_from_package_xml(&package_xml_path, "rustdoc")?;

        let updated = fs::read_to_string(&package_xml_path).map_err(|e| e.kind())?;
        assert!(!updated.contains("<doc_depend>rustdoc</doc_depend>"));
        Ok(())
    }

    /// Test that removing a dependency does not alter other fields in package.xml.
    #[test]
    fn test_remove_from_package_xml_preserve_other_fields() -> Result<(), ErrorKind> {
        let dir = tempdir().unwrap();
        let package_xml_path = dir.path().join("package.xml");
        let content = r#"
        <package format="3">
            <name>test_package</name>
            <version>0.1.0</version>
            <description>Test description</description>
            <maintainer email="test@example.com">Test Maintainer</maintainer>
            <license>MIT</license>
            <depend>serde</depend>
        </package>
    "#;
        fs::write(&package_xml_path, content).map_err(|e| e.kind())?;

        remove_from_package_xml(&package_xml_path, "serde")?;

        let updated = fs::read_to_string(&package_xml_path).map_err(|e| e.kind())?;
        // Check that other fields are still there with correct values
        assert!(updated.contains("<name>test_package</name>"));
        assert!(updated.contains("<version>0.1.0</version>"));
        assert!(updated.contains("<description>Test description</description>"));
        assert!(
            updated.contains("<maintainer email=\"test@example.com\">Test Maintainer</maintainer>")
        );
        assert!(updated.contains("<license>MIT</license>"));
        Ok(())
    }

    /// Test package.xml with no dependency sections at all.
    #[test]
    fn test_remove_from_package_xml_no_dependency_sections() -> Result<(), ErrorKind> {
        let dir = tempdir().unwrap();
        let package_xml_path = dir.path().join("package.xml");
        let content = r#"
        <package format="3">
            <name>test_package</name>
            <version>0.1.0</version>
            <description>Test</description>
            <maintainer email="a@b.c">m</maintainer>
            <license>MIT</license>
        </package>
    "#;
        fs::write(&package_xml_path, content).map_err(|e| e.kind())?;

        // Should not error, and file should remain unchanged
        remove_from_package_xml(&package_xml_path, "serde")?;
        let updated = fs::read_to_string(&package_xml_path).map_err(|e| e.kind())?;
        assert_eq!(updated, content);
        Ok(())
    }

    // ============== Flag Combinations & Corner Cases ==============

    /// Test that `--build` and `--dev` together cause removal from both sections.
    #[test]
    fn test_remove_dependency_build_and_dev() -> Result<(), ErrorKind> {
        let _lock = DIR_MUTEX.lock().unwrap();
        let dir = tempdir().unwrap();
        let original_dir = env::current_dir().map_err(|e| e.kind())?;
        env::set_current_dir(&dir).map_err(|e| e.kind())?;

        let cargo_toml_path = dir.path().join("Cargo.toml");
        let content = r#"
        [build-dependencies]
        tokio = "1.0"
        [dev-dependencies]
        tokio = "1.0"
    "#;
        fs::write(&cargo_toml_path, content).map_err(|e| e.kind())?;

        // Add a dummy package.xml to avoid NotFound error (tool expects it)
        fs::write(dir.path().join("package.xml"), r#"<package format="3"><name>p</name><version>0.1</version><description>d</description><maintainer email="a@b.c">m</maintainer><license>MIT</license></package>"#)
        .map_err(|e| e.kind())?;

        let args = standard_args()
            .into_iter()
            .chain(["tokio", "--build", "--dev", "--no-package-xml"].map(String::from))
            .collect::<Vec<_>>();
        let matches = env_to_matches(args);
        ros_remove::remove_dependency(&matches)?;

        env::set_current_dir(&original_dir).map_err(|e| e.kind())?;

        let updated = fs::read_to_string(&cargo_toml_path).map_err(|e| e.kind())?;
        assert!(!updated.contains("[build-dependencies]\ntokio = \"1.0\""));
        assert!(!updated.contains("[dev-dependencies]\ntokio = \"1.0\""));
        Ok(())
    }

    /// Test both --no-cargo-toml and --no-package-xml together (should do nothing).
    #[test]
    fn test_remove_dependency_no_files() -> Result<(), ErrorKind> {
        let _lock = DIR_MUTEX.lock().unwrap();
        let dir = tempdir().unwrap();
        let original_dir = env::current_dir().map_err(|e| e.kind())?;
        env::set_current_dir(&dir).map_err(|e| e.kind())?;

        let cargo_toml_path = dir.path().join("Cargo.toml");
        let package_xml_path = dir.path().join("package.xml");
        let cargo_content = "[dependencies]\nserde = \"1.0\"\n";
        let package_content = r#"<package format="3"><name>p</name><version>0.1</version><description>d</description><maintainer email="a@b.c">m</maintainer><license>MIT</license><depend>serde</depend></package>"#;
        fs::write(&cargo_toml_path, cargo_content).map_err(|e| e.kind())?;
        fs::write(&package_xml_path, package_content).map_err(|e| e.kind())?;

        let args = standard_args()
            .into_iter()
            .chain(["serde", "--no-cargo-toml", "--no-package-xml"].map(String::from))
            .collect::<Vec<_>>();
        let matches = env_to_matches(args);
        ros_remove::remove_dependency(&matches)?;

        env::set_current_dir(&original_dir).map_err(|e| e.kind())?;

        let cargo_after = fs::read_to_string(&cargo_toml_path).map_err(|e| e.kind())?;
        let package_after = fs::read_to_string(&package_xml_path).map_err(|e| e.kind())?;
        assert_eq!(cargo_after, cargo_content);
        assert_eq!(package_after, package_content);
        Ok(())
    }

    /// Test that --color flag is accepted without error.
    #[test]
    fn test_env_to_matches_color_flag() {
        let args = standard_args()
            .into_iter()
            .chain(["serde", "--color", "auto"].map(String::from))
            .collect::<Vec<_>>();
        let matches = env_to_matches(args);
        assert_eq!(matches.get_one::<String>("dependency").unwrap(), "serde");
        // No assertion on color because it's unused, but this ensures parsing doesn't panic
    }
}