test(commands): remove per-command tests

1 files changed, 0 insertions, 327 deletions

diff --git a/crates/mozart/src/commands/require.rs b/crates/mozart/src/commands/require.rs
index f92442c..62c6a28 100644
--- a/crates/mozart/src/commands/require.rs
+++ b/crates/mozart/src/commands/require.rs
@@ -1123,330 +1123,3 @@ pub async fn execute(
 
     Ok(())
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn make_locked_package(name: &str, version: &str) -> lockfile::LockedPackage {
-        lockfile::LockedPackage {
-            name: name.to_string(),
-            version: version.to_string(),
-            version_normalized: Some(format!("{}.0", version)),
-            source: None,
-            dist: None,
-            require: indexmap::IndexMap::new(),
-            require_dev: indexmap::IndexMap::new(),
-            conflict: indexmap::IndexMap::new(),
-            provide: indexmap::IndexMap::new(),
-            replace: indexmap::IndexMap::new(),
-            suggest: None,
-            package_type: Some("library".to_string()),
-            autoload: None,
-            autoload_dev: None,
-            license: None,
-            description: None,
-            homepage: None,
-            keywords: None,
-            authors: None,
-            support: None,
-            funding: None,
-            time: None,
-            extra_fields: indexmap::IndexMap::new(),
-        }
-    }
-
-    fn minimal_lock(packages: Vec<lockfile::LockedPackage>) -> lockfile::LockFile {
-        lockfile::LockFile {
-            readme: lockfile::LockFile::default_readme(),
-            content_hash: "abc123".to_string(),
-            packages,
-            packages_dev: Some(vec![]),
-            aliases: vec![],
-            minimum_stability: "stable".to_string(),
-            stability_flags: serde_json::json!({}),
-            prefer_stable: false,
-            prefer_lowest: false,
-            platform: serde_json::json!({}),
-            platform_dev: serde_json::json!({}),
-            plugin_api_version: Some("2.6.0".to_string()),
-        }
-    }
-
-    /// Verify that compute_update_changes produces correct Install entries for new packages.
-    #[test]
-    fn test_require_change_report_new_packages() {
-        let new_lock = minimal_lock(vec![
-            make_locked_package("psr/log", "3.0.0"),
-            make_locked_package("monolog/monolog", "3.8.0"),
-        ]);
-
-        let changes = super::super::update::compute_update_changes(None, &new_lock, false);
-        assert_eq!(changes.len(), 2);
-        for change in &changes {
-            assert!(
-                matches!(
-                    change.kind,
-                    super::super::update::ChangeKind::Install { .. }
-                ),
-                "Expected Install, got {:?} for {}",
-                change.kind,
-                change.name
-            );
-        }
-    }
-
-    /// Verify the dry-run path does not write lock file.
-    #[test]
-    fn test_no_update_skips_lock_generation() {
-        let dir = tempfile::tempdir().unwrap();
-        let lock_path = dir.path().join("composer.lock");
-        assert!(!lock_path.exists());
-    }
-
-    #[test]
-    fn test_require_dry_run_modifies_nothing() {
-        use tempfile::tempdir;
-
-        let dir = tempdir().unwrap();
-        let composer_path = dir.path().join("composer.json");
-        let lock_path = dir.path().join("composer.lock");
-        let vendor_dir = dir.path().join("vendor");
-
-        let original_content = r#"{"name": "test/project", "require": {}}"#;
-        std::fs::write(&composer_path, original_content).unwrap();
-
-        assert_eq!(
-            std::fs::read_to_string(&composer_path).unwrap(),
-            original_content
-        );
-        assert!(
-            !lock_path.exists(),
-            "Lock file should not be created by dry run"
-        );
-        assert!(
-            !vendor_dir.exists(),
-            "Vendor dir should not be created by dry run"
-        );
-    }
-
-    /// Verify firstRequire is true when require and require-dev are both empty.
-    #[test]
-    fn test_first_require_empty_sections() {
-        use mozart_core::package::RawPackageData;
-
-        let raw = RawPackageData::new("test/project".to_string());
-        let first_require = raw.require.is_empty() && raw.require_dev.is_empty();
-        assert!(
-            first_require,
-            "firstRequire should be true when both sections are empty"
-        );
-    }
-
-    /// Verify firstRequire is false when require is non-empty.
-    #[test]
-    fn test_first_require_non_empty_require() {
-        use mozart_core::package::RawPackageData;
-
-        let mut raw = RawPackageData::new("test/project".to_string());
-        raw.require
-            .insert("some/pkg".to_string(), "^1.0".to_string());
-        let first_require = raw.require.is_empty() && raw.require_dev.is_empty();
-        assert!(
-            !first_require,
-            "firstRequire should be false when require is non-empty"
-        );
-    }
-
-    /// Verify get_packages_by_require_key returns correct section for each package.
-    #[test]
-    fn test_get_packages_by_require_key() {
-        use mozart_core::package::RawPackageData;
-
-        let mut raw = RawPackageData::new("test/project".to_string());
-        raw.require
-            .insert("vendor/a".to_string(), "^1.0".to_string());
-        raw.require_dev
-            .insert("vendor/b".to_string(), "^2.0".to_string());
-
-        let map = get_packages_by_require_key(&raw);
-        assert_eq!(map.get("vendor/a"), Some(&"require".to_string()));
-        assert_eq!(map.get("vendor/b"), Some(&"require-dev".to_string()));
-        assert_eq!(map.get("vendor/c"), None);
-    }
-
-    /// Verify get_inconsistent_require_keys returns packages in the opposite section.
-    #[test]
-    fn test_get_inconsistent_require_keys() {
-        let mut packages_by_key = IndexMap::new();
-        packages_by_key.insert("vendor/a".to_string(), "require".to_string());
-        packages_by_key.insert("vendor/b".to_string(), "require-dev".to_string());
-
-        // Adding vendor/a to require-dev while it's in require → inconsistent
-        let new_pkgs = vec!["vendor/a".to_string(), "vendor/c".to_string()];
-        let inconsistent =
-            get_inconsistent_require_keys(&new_pkgs, "require-dev", &packages_by_key);
-        assert_eq!(inconsistent, vec!["vendor/a"]);
-
-        // Adding vendor/b to require while it's in require-dev → inconsistent
-        let new_pkgs2 = vec!["vendor/b".to_string()];
-        let inconsistent2 = get_inconsistent_require_keys(&new_pkgs2, "require", &packages_by_key);
-        assert_eq!(inconsistent2, vec!["vendor/b"]);
-    }
-
-    #[tokio::test]
-    #[ignore]
-    async fn test_require_full_e2e() {
-        use indexmap::IndexSet;
-        use mozart_core::package::RawPackageData;
-        use mozart_core::repository::lockfile::{LockFileGenerationRequest, generate_lock_file};
-
-        let composer_json_content = r#"{"name": "test/project", "require": {"psr/log": "^3.0"}}"#;
-        let composer_json: RawPackageData = serde_json::from_str(composer_json_content).unwrap();
-
-        let request = ResolveRequest {
-            root_name: String::new(),
-            root_version: None,
-            require: vec![("psr/log".to_string(), "^3.0".to_string())],
-            require_dev: vec![],
-            include_dev: false,
-            minimum_stability: Stability::Stable,
-            stability_flags: IndexMap::new(),
-            prefer_stable: true,
-            prefer_lowest: false,
-            platform: PlatformConfig::new(),
-            ignore_platform_reqs: false,
-            ignore_platform_req_list: vec![],
-            repositories: std::sync::Arc::new(
-                mozart_core::repository::repository::RepositorySet::with_packagist(
-                    mozart_core::repository::cache::Cache::new(
-                        std::env::temp_dir().join("mozart-test-cache"),
-                        false,
-                    ),
-                ),
-            ),
-            temporary_constraints: IndexMap::new(),
-            raw_repositories: vec![],
-            root_provide: IndexMap::new(),
-            root_replace: IndexMap::new(),
-            root_conflict: IndexMap::new(),
-            locked_package_names: IndexSet::new(),
-            locked_packages: Vec::new(),
-            block_abandoned: false,
-            root_branch_alias: None,
-            preferred_versions: indexmap::IndexMap::new(),
-            block_insecure: false,
-        };
-
-        let resolved = resolver::resolve(&request)
-            .await
-            .expect("Resolution should succeed");
-        assert!(!resolved.is_empty());
-        assert!(resolved.iter().any(|p| p.name == "psr/log"));
-
-        let lock = generate_lock_file(&LockFileGenerationRequest {
-            resolved_packages: resolved,
-            composer_json_content: composer_json_content.to_string(),
-            composer_json,
-            include_dev: false,
-            repositories: std::sync::Arc::new(
-                mozart_core::repository::repository::RepositorySet::with_packagist(
-                    mozart_core::repository::cache::Cache::new(
-                        std::env::temp_dir().join("mozart-test-cache"),
-                        false,
-                    ),
-                ),
-            ),
-            previous_lock: None,
-            lock_pinned_names: IndexSet::new(),
-        })
-        .await
-        .expect("Lock file generation should succeed");
-
-        assert!(!lock.content_hash.is_empty());
-        assert!(!lock.packages.is_empty());
-        assert!(lock.packages.iter().any(|p| p.name == "psr/log"));
-    }
-
-    #[tokio::test]
-    #[ignore]
-    async fn test_require_no_install_writes_lock_only() {
-        use indexmap::IndexSet;
-        use mozart_core::package::RawPackageData;
-        use tempfile::tempdir;
-
-        let dir = tempdir().unwrap();
-        let composer_path = dir.path().join("composer.json");
-        let lock_path = dir.path().join("composer.lock");
-        let vendor_dir = dir.path().join("vendor");
-
-        let content = r#"{"name": "test/project", "require": {"psr/log": "^3.0"}}"#;
-        std::fs::write(&composer_path, content).unwrap();
-
-        let raw: RawPackageData = serde_json::from_str(content).unwrap();
-
-        let request = ResolveRequest {
-            root_name: String::new(),
-            root_version: None,
-            require: vec![("psr/log".to_string(), "^3.0".to_string())],
-            require_dev: vec![],
-            include_dev: false,
-            minimum_stability: Stability::Stable,
-            stability_flags: IndexMap::new(),
-            prefer_stable: true,
-            prefer_lowest: false,
-            platform: PlatformConfig::new(),
-            ignore_platform_reqs: false,
-            ignore_platform_req_list: vec![],
-            repositories: std::sync::Arc::new(
-                mozart_core::repository::repository::RepositorySet::with_packagist(
-                    mozart_core::repository::cache::Cache::new(
-                        std::env::temp_dir().join("mozart-test-cache"),
-                        false,
-                    ),
-                ),
-            ),
-            temporary_constraints: IndexMap::new(),
-            raw_repositories: vec![],
-            root_provide: IndexMap::new(),
-            root_replace: IndexMap::new(),
-            root_conflict: IndexMap::new(),
-            locked_package_names: IndexSet::new(),
-            locked_packages: Vec::new(),
-            block_abandoned: false,
-            root_branch_alias: None,
-            preferred_versions: indexmap::IndexMap::new(),
-            block_insecure: false,
-        };
-
-        let resolved = resolver::resolve(&request)
-            .await
-            .expect("Resolution should succeed");
-        let new_lock = lockfile::generate_lock_file(&lockfile::LockFileGenerationRequest {
-            resolved_packages: resolved,
-            composer_json_content: content.to_string(),
-            composer_json: raw,
-            include_dev: false,
-            repositories: std::sync::Arc::new(
-                mozart_core::repository::repository::RepositorySet::with_packagist(
-                    mozart_core::repository::cache::Cache::new(
-                        std::env::temp_dir().join("mozart-test-cache"),
-                        false,
-                    ),
-                ),
-            ),
-            previous_lock: None,
-            lock_pinned_names: IndexSet::new(),
-        })
-        .await
-        .expect("Lock file generation should succeed");
-
-        new_lock.write_to_file(&lock_path).unwrap();
-
-        assert!(lock_path.exists(), "Lock file should be written");
-        assert!(
-            !vendor_dir.exists(),
-            "Vendor dir should NOT exist with --no-install"
-        );
-    }
-}