remove tests from import.rs

Author: abergs

crates/bitwarden-exporters/src/cxf/import.rs

@@ -441,128 +441,4 @@ mod tests {
         assert_eq!(card.brand, Some("Mastercard".to_string()));
         assert_eq!(card.number, Some("1234 5678 9012 3456".to_string()));
     }
-
-    #[test]
-    fn test_passport_complete_mapping_with_custom_fields() {
-        let result = load_sample_cxf();
-        assert!(result.is_ok());
-        let ciphers = result.unwrap();
-        let passport_cipher = ciphers
-            .iter()
-            .find(|c| c.name == "Passport")
-            .expect("Should find Passport item");
-        let identity = match &passport_cipher.r#type {
-            CipherType::Identity(identity) => identity,
-            _ => panic!("Expected Identity cipher"),
-        };
-
-        // Verify Identity field mappings
-        assert_eq!(identity.passport_number, Some("A12345678".to_string()));
-        assert_eq!(identity.first_name, Some("John".to_string()));
-        assert_eq!(identity.last_name, Some("Doe".to_string()));
-        assert_eq!(identity.ssn, Some("ID123456789".to_string()));
-        assert_eq!(identity.country, None); // Now custom field
-
-        // Verify custom fields preserve all other data
-        assert!(
-            passport_cipher.fields.len() >= 4,
-            "Should have multiple custom fields"
-        );
-        let issuing_country = passport_cipher
-            .fields
-            .iter()
-            .find(|f| f.name.as_deref() == Some("Issuing Country"))
-            .expect("Should have Issuing Country");
-        assert_eq!(issuing_country.value, Some("US".to_string()));
-        let nationality = passport_cipher
-            .fields
-            .iter()
-            .find(|f| f.name.as_deref() == Some("Nationality"))
-            .expect("Should have Nationality");
-        assert_eq!(nationality.value, Some("American".to_string()));
-    }
-
-    #[test]
-    fn test_drivers_license_complete_mapping_with_custom_fields() {
-        let result = load_sample_cxf();
-        assert!(result.is_ok());
-        let ciphers = result.unwrap();
-        let drivers_license_cipher = ciphers
-            .iter()
-            .find(|c| c.name == "Driver License")
-            .expect("Should find Driver License item");
-        let identity = match &drivers_license_cipher.r#type {
-            CipherType::Identity(identity) => identity,
-            _ => panic!("Expected Identity cipher"),
-        };
-
-        // Verify Identity field mappings
-        assert_eq!(identity.license_number, Some("D12345678".to_string()));
-        assert_eq!(identity.first_name, Some("John".to_string()));
-        assert_eq!(identity.last_name, Some("Doe".to_string()));
-        assert_eq!(identity.state, Some("CA".to_string()));
-        assert_eq!(identity.country, Some("US".to_string()));
-        assert_eq!(identity.company, None); // Now custom field
-
-        // Verify custom fields preserve all other data
-        assert!(
-            drivers_license_cipher.fields.len() >= 3,
-            "Should have multiple custom fields"
-        );
-        let issuing_authority = drivers_license_cipher
-            .fields
-            .iter()
-            .find(|f| f.name.as_deref() == Some("Issuing Authority"))
-            .expect("Should have Issuing Authority");
-        assert_eq!(
-            issuing_authority.value,
-            Some("Department of Motor Vehicles".to_string())
-        );
-        let license_class = drivers_license_cipher
-            .fields
-            .iter()
-            .find(|f| f.name.as_deref() == Some("License Class"))
-            .expect("Should have License Class");
-        assert_eq!(license_class.value, Some("C".to_string()));
-    }
-
-    #[test]
-    fn test_person_name_complete_mapping_with_custom_fields() {
-        let result = load_sample_cxf();
-        assert!(result.is_ok());
-        let ciphers = result.unwrap();
-        let person_name_cipher = ciphers
-            .iter()
-            .find(|c| c.name == "John Doe")
-            .expect("Should find John Doe item");
-        let identity = match &person_name_cipher.r#type {
-            CipherType::Identity(identity) => identity,
-            _ => panic!("Expected Identity cipher"),
-        };
-
-        // Verify Identity field mappings
-        assert_eq!(identity.title, Some("Dr.".to_string()));
-        assert_eq!(identity.first_name, Some("John".to_string()));
-        assert_eq!(identity.middle_name, Some("Michael".to_string()));
-        assert_eq!(identity.last_name, Some("van Doe Smith".to_string()));
-        assert_eq!(identity.company, Some("PhD".to_string()));
-
-        // Verify custom fields preserve unmapped data
-        assert!(
-            person_name_cipher.fields.len() >= 2,
-            "Should have custom fields"
-        );
-        let informal_given = person_name_cipher
-            .fields
-            .iter()
-            .find(|f| f.name.as_deref() == Some("Informal Given Name"))
-            .expect("Should have Informal Given Name");
-        assert_eq!(informal_given.value, Some("Johnny".to_string()));
-        let generation = person_name_cipher
-            .fields
-            .iter()
-            .find(|f| f.name.as_deref() == Some("Generation"))
-            .expect("Should have Generation");
-        assert_eq!(generation.value, Some("III".to_string()));
-    }
 }