cumulusci-plus 5.0.19__py3-none-any.whl → 5.0.35__py3-none-any.whl

cumulusci/tasks/bulkdata/tests/test_mapping_parser.py

@@ -599,6 +599,7 @@ class TestMappingParser:
             mock.ANY,  # This is a function def
             mock.ANY,
             DataOperationType.INSERT,
+            None,  # validation_result
         )
 
         ms._validate_field_dict.assert_has_calls(
@@ -612,6 +613,7 @@ class TestMappingParser:
                     mock.ANY,  # local function def
                     False,
                     DataOperationType.INSERT,
+                    None,
                 ),
                 mock.call(
                     {"ns__Test__c": {"name": "ns__Test__c", "createable": True}},
@@ -620,6 +622,7 @@ class TestMappingParser:
                     mock.ANY,  # local function def
                     False,
                     DataOperationType.INSERT,
+                    None,
                 ),
             ]
         )
@@ -668,6 +671,7 @@ class TestMappingParser:
             mock.ANY,  # local function def
             mock.ANY,
             DataOperationType.INSERT,
+            None,
         )
 
         ms._validate_field_dict.assert_has_calls(
@@ -686,6 +690,7 @@ class TestMappingParser:
                     mock.ANY,  # local function def.
                     False,
                     DataOperationType.INSERT,
+                    None,
                 ),
                 mock.call(
                     {
@@ -701,6 +706,7 @@ class TestMappingParser:
                     mock.ANY,  # local function def.
                     False,
                     DataOperationType.INSERT,
+                    None,
                 ),
             ]
         )
@@ -734,6 +740,7 @@ class TestMappingParser:
             None,
             None,
             DataOperationType.INSERT,
+            None,
         )
 
         ms._validate_field_dict.assert_has_calls(
@@ -745,6 +752,7 @@ class TestMappingParser:
                     None,
                     False,
                     DataOperationType.INSERT,
+                    None,
                 ),
                 mock.call(
                     {"Field__c": {"name": "Field__c", "createable": True}},
@@ -753,6 +761,7 @@ class TestMappingParser:
                     None,
                     False,
                     DataOperationType.INSERT,
+                    None,
                 ),
             ]
         )
@@ -788,6 +797,7 @@ class TestMappingParser:
             None,
             None,
             DataOperationType.INSERT,
+            None,
         )
 
         ms._validate_field_dict.assert_not_called()
@@ -823,6 +833,7 @@ class TestMappingParser:
             None,
             None,
             DataOperationType.INSERT,
+            None,
         )
 
         ms._validate_field_dict.assert_has_calls(
@@ -834,6 +845,7 @@ class TestMappingParser:
                     None,
                     False,
                     DataOperationType.INSERT,
+                    None,
                 )
             ]
         )
@@ -881,6 +893,7 @@ class TestMappingParser:
             None,
             None,
             DataOperationType.INSERT,
+            None,
         )
 
         ms._validate_field_dict.assert_has_calls(
@@ -899,6 +912,7 @@ class TestMappingParser:
                     None,
                     False,
                     DataOperationType.INSERT,
+                    None,
                 ),
                 mock.call(
                     {
@@ -914,6 +928,7 @@ class TestMappingParser:
                     None,
                     False,
                     DataOperationType.INSERT,
+                    None,
                 ),
             ]
         )
@@ -962,6 +977,7 @@ class TestMappingParser:
             None,
             None,
             DataOperationType.INSERT,
+            None,
         )
 
         ms._validate_field_dict.assert_has_calls(
@@ -980,6 +996,7 @@ class TestMappingParser:
                     None,
                     False,
                     DataOperationType.INSERT,
+                    None,
                 ),
                 mock.call(
                     {
@@ -995,6 +1012,7 @@ class TestMappingParser:
                     None,
                     False,
                     DataOperationType.INSERT,
+                    None,
                 ),
             ]
         )
@@ -1185,15 +1203,58 @@ class TestMappingParser:
             {"instance_url": "https://example.com", "access_token": "abc123"}, "test"
         )
 
+        # Should raise BulkDataException when drop_missing=False
+        with pytest.raises(
+            BulkDataException,
+            match="One or more schema or permissions errors blocked the operation",
+        ):
+            validate_and_inject_mapping(
+                mapping=mapping,
+                sf=org_config.salesforce_client,
+                namespace="",
+                data_operation=DataOperationType.INSERT,
+                inject_namespaces=False,
+                drop_missing=False,
+            )
+
+        # Verify the error was logged
+        expected_error_message = (
+            "One or more required fields are missing for loading on Account :{'Name'}"
+        )
+        error_logs = [
+            record.message for record in caplog.records if record.levelname == "ERROR"
+        ]
+        assert any(expected_error_message in error_log for error_log in error_logs)
+
+    @responses.activate
+    def test_validate_and_inject_mapping_allows_missing_required_fields_with_drop_missing(
+        self, caplog
+    ):
+        """Test that drop_missing=True allows missing required fields (with warning)."""
+        caplog.set_level(logging.ERROR)
+        mock_describe_calls()
+        mapping = parse_from_yaml(
+            StringIO(
+                (
+                    "Insert Accounts:\n  sf_object: Account\n  table: Account\n  fields:\n    - ns__Description__c\n"
+                )
+            )
+        )
+        org_config = DummyOrgConfig(
+            {"instance_url": "https://example.com", "access_token": "abc123"}, "test"
+        )
+
+        # Should NOT raise exception when drop_missing=True, even with missing required fields
         validate_and_inject_mapping(
             mapping=mapping,
             sf=org_config.salesforce_client,
             namespace="",
             data_operation=DataOperationType.INSERT,
             inject_namespaces=False,
-            drop_missing=False,
+            drop_missing=True,
         )
 
+        # Verify the error was still logged as a warning
         expected_error_message = (
             "One or more required fields are missing for loading on Account :{'Name'}"
         )
@@ -1656,3 +1717,704 @@ class TestUpsertKeyValidations:
             record.message for record in caplog.records if record.levelname == "ERROR"
         ]
         assert any(expected_error_message in error_log for error_log in error_logs)
+
+
+class TestValidationResult:
+    """Tests for ValidationResult class"""
+
+    def test_validation_result_initialization(self):
+        """Test ValidationResult initializes with empty lists"""
+        from cumulusci.tasks.bulkdata.mapping_parser import ValidationResult
+
+        result = ValidationResult()
+        assert result.errors == []
+        assert result.warnings == []
+        assert not result.has_errors()
+
+    def test_validation_result_add_error(self, caplog):
+        """Test adding errors to ValidationResult"""
+        from cumulusci.tasks.bulkdata.mapping_parser import ValidationResult
+
+        caplog.set_level(logging.ERROR)
+        result = ValidationResult()
+
+        result.add_error("Test error 1")
+        result.add_error("Test error 2")
+
+        assert len(result.errors) == 2
+        assert "Test error 1" in result.errors
+        assert "Test error 2" in result.errors
+        assert result.has_errors()
+
+        # Verify errors are also logged
+        assert "Test error 1" in caplog.text
+        assert "Test error 2" in caplog.text
+
+    def test_validation_result_add_warning(self, caplog):
+        """Test adding warnings to ValidationResult"""
+        from cumulusci.tasks.bulkdata.mapping_parser import ValidationResult
+
+        caplog.set_level(logging.WARNING)
+        result = ValidationResult()
+
+        result.add_warning("Test warning 1")
+        result.add_warning("Test warning 2")
+
+        assert len(result.warnings) == 2
+        assert "Test warning 1" in result.warnings
+        assert "Test warning 2" in result.warnings
+        assert not result.has_errors()  # Warnings don't count as errors
+
+        # Verify warnings are also logged
+        assert "Test warning 1" in caplog.text
+        assert "Test warning 2" in caplog.text
+
+    def test_validation_result_mixed_errors_and_warnings(self):
+        """Test ValidationResult with both errors and warnings"""
+        from cumulusci.tasks.bulkdata.mapping_parser import ValidationResult
+
+        result = ValidationResult()
+
+        result.add_warning("Warning message")
+        result.add_error("Error message")
+        result.add_warning("Another warning")
+
+        assert len(result.errors) == 1
+        assert len(result.warnings) == 2
+        assert result.has_errors()
+
+
+class TestValidateOnlyMode:
+    """Tests for validate_only mode in validate_and_inject_mapping"""
+
+    @responses.activate
+    def test_validate_only_returns_validation_result(self):
+        """Test that validate_only=True returns ValidationResult"""
+        from cumulusci.tasks.bulkdata.mapping_parser import ValidationResult
+
+        mock_describe_calls()
+        mapping = parse_from_yaml(
+            StringIO(
+                "Insert Accounts:\n  sf_object: Account\n  table: Account\n  fields:\n    - Name"
+            )
+        )
+        org_config = DummyOrgConfig(
+            {"instance_url": "https://example.com", "access_token": "abc123"}, "test"
+        )
+
+        result = validate_and_inject_mapping(
+            mapping=mapping,
+            sf=org_config.salesforce_client,
+            namespace=None,
+            data_operation=DataOperationType.INSERT,
+            inject_namespaces=False,
+            drop_missing=False,
+            validate_only=True,
+        )
+
+        assert result is not None
+        assert isinstance(result, ValidationResult)
+        assert not result.has_errors()
+
+    @responses.activate
+    def test_validate_only_false_returns_none(self):
+        """Test that validate_only=False returns None"""
+        mock_describe_calls()
+        mapping = parse_from_yaml(
+            StringIO(
+                "Insert Accounts:\n  sf_object: Account\n  table: Account\n  fields:\n    - Name"
+            )
+        )
+        org_config = DummyOrgConfig(
+            {"instance_url": "https://example.com", "access_token": "abc123"}, "test"
+        )
+
+        result = validate_and_inject_mapping(
+            mapping=mapping,
+            sf=org_config.salesforce_client,
+            namespace=None,
+            data_operation=DataOperationType.INSERT,
+            inject_namespaces=False,
+            drop_missing=False,
+            validate_only=False,
+        )
+
+        assert result is None
+
+    @responses.activate
+    def test_validate_only_collects_missing_field_errors(self):
+        """Test that validate_only collects missing field errors"""
+        from cumulusci.tasks.bulkdata.mapping_parser import ValidationResult
+
+        mock_describe_calls()
+        mapping = parse_from_yaml(
+            StringIO(
+                "Insert Accounts:\n  sf_object: Account\n  table: Account\n  fields:\n    - Nonsense__c"
+            )
+        )
+        org_config = DummyOrgConfig(
+            {"instance_url": "https://example.com", "access_token": "abc123"}, "test"
+        )
+
+        result = validate_and_inject_mapping(
+            mapping=mapping,
+            sf=org_config.salesforce_client,
+            namespace=None,
+            data_operation=DataOperationType.INSERT,
+            inject_namespaces=False,
+            drop_missing=False,
+            validate_only=True,
+        )
+
+        assert result is not None
+        assert isinstance(result, ValidationResult)
+        # Should have warnings about missing field
+        assert any("Nonsense__c" in warning for warning in result.warnings)
+
+    @responses.activate
+    def test_validate_only_collects_missing_required_field_errors(self):
+        """Test that validate_only collects missing required field errors"""
+        from cumulusci.tasks.bulkdata.mapping_parser import ValidationResult
+
+        mock_describe_calls()
+        mapping = parse_from_yaml(
+            StringIO(
+                "Insert Accounts:\n  sf_object: Account\n  table: Account\n  fields:\n    - Description"
+            )
+        )
+        org_config = DummyOrgConfig(
+            {"instance_url": "https://example.com", "access_token": "abc123"}, "test"
+        )
+
+        result = validate_and_inject_mapping(
+            mapping=mapping,
+            sf=org_config.salesforce_client,
+            namespace=None,
+            data_operation=DataOperationType.INSERT,
+            inject_namespaces=False,
+            drop_missing=False,
+            validate_only=True,
+        )
+
+        assert result is not None
+        assert isinstance(result, ValidationResult)
+        assert result.has_errors()
+        # Should have error about missing required field 'Name'
+        assert any("required fields" in error.lower() for error in result.errors)
+        assert any("Name" in error for error in result.errors)
+
+    @responses.activate
+    def test_validate_only_early_return_on_sobject_error(self):
+        """Test that validate_only returns early when sObject doesn't exist"""
+        from cumulusci.tasks.bulkdata.mapping_parser import ValidationResult
+
+        mock_describe_calls()
+        mapping = parse_from_yaml(
+            StringIO(
+                "Insert Invalid:\n  sf_object: InvalidObject__c\n  table: InvalidObject\n  fields:\n    - Name"
+            )
+        )
+        org_config = DummyOrgConfig(
+            {"instance_url": "https://example.com", "access_token": "abc123"}, "test"
+        )
+
+        result = validate_and_inject_mapping(
+            mapping=mapping,
+            sf=org_config.salesforce_client,
+            namespace=None,
+            data_operation=DataOperationType.INSERT,
+            inject_namespaces=False,
+            drop_missing=False,
+            validate_only=True,
+        )
+
+        assert result is not None
+        assert isinstance(result, ValidationResult)
+        # Should have warning about missing object
+        assert any("InvalidObject__c" in warning for warning in result.warnings)
+
+    @responses.activate
+    def test_validate_only_collects_lookup_errors(self):
+        """Test that validate_only collects lookup validation errors"""
+        from cumulusci.tasks.bulkdata.mapping_parser import ValidationResult
+
+        mock_describe_calls()
+        mapping = parse_from_yaml(
+            StringIO(
+                (
+                    "Insert Contacts:\n  sf_object: Contact\n  table: Contact\n  fields:\n    - LastName\n  lookups:\n    AccountId:\n      table: Account"
+                )
+            )
+        )
+        org_config = DummyOrgConfig(
+            {"instance_url": "https://example.com", "access_token": "abc123"}, "test"
+        )
+
+        result = validate_and_inject_mapping(
+            mapping=mapping,
+            sf=org_config.salesforce_client,
+            namespace=None,
+            data_operation=DataOperationType.INSERT,
+            inject_namespaces=False,
+            drop_missing=False,
+            validate_only=True,
+        )
+
+        assert result is not None
+        assert isinstance(result, ValidationResult)
+        assert result.has_errors()
+        # Should have error about missing Account table
+        assert any(
+            "Account" in error and "does not exist" in error for error in result.errors
+        )
+
+    @responses.activate
+    def test_validate_only_without_load_skips_lookup_validation(self):
+        """Test that validate_only skips lookup validation for QUERY operations"""
+        from cumulusci.tasks.bulkdata.mapping_parser import ValidationResult
+
+        mock_describe_calls()
+        mapping = parse_from_yaml(
+            StringIO(
+                (
+                    "Insert Contacts:\n  sf_object: Contact\n  table: Contact\n  fields:\n    - LastName\n  lookups:\n    AccountId:\n      table: Account"
+                )
+            )
+        )
+        org_config = DummyOrgConfig(
+            {"instance_url": "https://example.com", "access_token": "abc123"}, "test"
+        )
+
+        result = validate_and_inject_mapping(
+            mapping=mapping,
+            sf=org_config.salesforce_client,
+            namespace=None,
+            data_operation=DataOperationType.QUERY,  # Not a load operation
+            inject_namespaces=False,
+            drop_missing=False,
+            validate_only=True,
+        )
+
+        assert result is not None
+        assert isinstance(result, ValidationResult)
+        # Should not have lookup validation errors since it's a QUERY
+        assert not any(
+            "Account" in error and "does not exist" in error for error in result.errors
+        )
+
+
+class TestValidationResultParameter:
+    """Tests for optional ValidationResult parameter in validation methods"""
+
+    def test_check_required_with_validation_result(self):
+        """Test check_required adds errors to ValidationResult when provided"""
+        from cumulusci.tasks.bulkdata.mapping_parser import ValidationResult
+
+        ms = MappingStep(
+            sf_object="Account",
+            fields=["Description"],
+            action=DataOperationType.INSERT,
+        )
+        fields_describe = CaseInsensitiveDict(
+            {
+                "Name": {
+                    "createable": True,
+                    "nillable": False,
+                    "defaultedOnCreate": False,
+                    "defaultValue": None,
+                },
+                "Description": {
+                    "createable": True,
+                    "nillable": True,
+                    "defaultedOnCreate": False,
+                    "defaultValue": None,
+                },
+            }
+        )
+
+        validation_result = ValidationResult()
+        result = ms.check_required(fields_describe, validation_result)
+
+        assert not result  # Should return False due to missing required field
+        assert validation_result.has_errors()
+        assert any(
+            "required fields" in error.lower() for error in validation_result.errors
+        )
+        assert any("Name" in error for error in validation_result.errors)
+
+    def test_check_required_without_validation_result_logs(self, caplog):
+        """Test check_required logs errors when ValidationResult not provided"""
+        caplog.set_level(logging.ERROR)
+        ms = MappingStep(
+            sf_object="Account",
+            fields=["Description"],
+            action=DataOperationType.INSERT,
+        )
+        fields_describe = CaseInsensitiveDict(
+            {
+                "Name": {
+                    "createable": True,
+                    "nillable": False,
+                    "defaultedOnCreate": False,
+                    "defaultValue": None,
+                },
+            }
+        )
+
+        result = ms.check_required(fields_describe, None)
+
+        assert not result
+        assert "required fields" in caplog.text.lower()
+        assert "Name" in caplog.text
+
+    def test_validate_sobject_with_validation_result(self):
+        """Test _validate_sobject adds warnings to ValidationResult"""
+        from cumulusci.tasks.bulkdata.mapping_parser import ValidationResult
+
+        ms = MappingStep(
+            sf_object="InvalidObject__c",
+            fields=["Name"],
+            action=DataOperationType.INSERT,
+        )
+
+        validation_result = ValidationResult()
+        result = ms._validate_sobject(
+            CaseInsensitiveDict({"Account": {"createable": True}}),
+            None,
+            None,
+            DataOperationType.INSERT,
+            validation_result,
+        )
+
+        assert not result
+        assert len(validation_result.warnings) > 0
+        assert any(
+            "InvalidObject__c" in warning for warning in validation_result.warnings
+        )
+
+    def test_validate_field_dict_with_validation_result(self):
+        """Test _validate_field_dict adds warnings to ValidationResult"""
+        from cumulusci.tasks.bulkdata.mapping_parser import ValidationResult
+
+        ms = MappingStep(
+            sf_object="Account",
+            fields=["Name", "NonexistentField__c"],
+            action=DataOperationType.INSERT,
+        )
+
+        validation_result = ValidationResult()
+        result = ms._validate_field_dict(
+            describe=CaseInsensitiveDict({"Name": {"createable": True}}),
+            field_dict=ms.fields_,
+            inject=None,
+            strip=None,
+            drop_missing=False,
+            data_operation_type=DataOperationType.INSERT,
+            validation_result=validation_result,
+        )
+
+        assert not result
+        assert len(validation_result.warnings) > 0
+        assert any(
+            "NonexistentField__c" in warning for warning in validation_result.warnings
+        )
+
+    def test_infer_and_validate_lookups_with_validation_result(self):
+        """Test _infer_and_validate_lookups adds errors to ValidationResult"""
+        from cumulusci.tasks.bulkdata.mapping_parser import ValidationResult
+
+        mock_sf = mock.Mock()
+        mock_sf.Contact.describe.return_value = {
+            "fields": [
+                {
+                    "name": "AccountId",
+                    "referenceTo": ["Account"],
+                }
+            ]
+        }
+
+        mapping = {
+            "Insert Contacts": MappingStep(
+                sf_object="Contact",
+                table="Contact",
+                fields=["LastName"],
+                lookups={"AccountId": MappingLookup(table="Account", name="AccountId")},
+            )
+        }
+
+        validation_result = ValidationResult()
+        _infer_and_validate_lookups(mapping, mock_sf, validation_result)
+
+        # Should have error about missing Account table
+        assert validation_result.has_errors()
+        assert any(
+            "Account" in error and "does not exist" in error
+            for error in validation_result.errors
+        )
+
+    def test_infer_and_validate_lookups_without_validation_result_raises(self):
+        """Test _infer_and_validate_lookups raises exception when ValidationResult not provided"""
+        mock_sf = mock.Mock()
+        mock_sf.Contact.describe.return_value = {
+            "fields": [
+                {
+                    "name": "AccountId",
+                    "referenceTo": ["Account"],
+                }
+            ]
+        }
+
+        mapping = {
+            "Insert Contacts": MappingStep(
+                sf_object="Contact",
+                table="Contact",
+                fields=["LastName"],
+                lookups={"AccountId": MappingLookup(table="Account", name="AccountId")},
+            )
+        }
+
+        with pytest.raises(BulkDataException) as e:
+            _infer_and_validate_lookups(mapping, mock_sf, None)
+
+        assert "relationship errors" in str(e.value).lower()
+
+
+class TestValidationResultCoverage:
+    """Additional tests to achieve full coverage of ValidationResult code paths"""
+
+    def test_validate_field_dict_duplicate_field_with_validation_result(self):
+        """Test _validate_field_dict with duplicate fields (injected and original) using ValidationResult"""
+        from cumulusci.tasks.bulkdata.mapping_parser import ValidationResult
+
+        ms = MappingStep(
+            sf_object="Account",
+            fields=["Test__c"],
+            action=DataOperationType.INSERT,
+        )
+
+        validation_result = ValidationResult()
+        # Both Test__c and ns__Test__c exist in describe
+        result = ms._validate_field_dict(
+            describe=CaseInsensitiveDict(
+                {"Test__c": {"createable": True}, "ns__Test__c": {"createable": True}}
+            ),
+            field_dict=ms.fields_,
+            inject=lambda field: f"ns__{field}",
+            strip=None,
+            drop_missing=False,
+            data_operation_type=DataOperationType.INSERT,
+            validation_result=validation_result,
+        )
+
+        assert result
+        # Should have warning about both fields being present
+        assert any(
+            "Both" in warning and "Test__c" in warning
+            for warning in validation_result.warnings
+        )
+
+    def test_validate_field_dict_permission_error_with_validation_result(self):
+        """Test _validate_field_dict with field permission errors using ValidationResult"""
+        from cumulusci.tasks.bulkdata.mapping_parser import ValidationResult
+
+        ms = MappingStep(
+            sf_object="Account",
+            fields=["Name"],
+            action=DataOperationType.INSERT,
+        )
+
+        validation_result = ValidationResult()
+        result = ms._validate_field_dict(
+            describe=CaseInsensitiveDict({"Name": {"createable": False}}),
+            field_dict=ms.fields_,
+            inject=None,
+            strip=None,
+            drop_missing=False,
+            data_operation_type=DataOperationType.INSERT,
+            validation_result=validation_result,
+        )
+
+        assert not result
+        # Should have warning about incorrect permissions
+        assert any(
+            "does not have the correct permissions" in warning
+            for warning in validation_result.warnings
+        )
+
+    def test_validate_sobject_permission_error_with_validation_result(self):
+        """Test _validate_sobject with permission errors using ValidationResult"""
+        from cumulusci.tasks.bulkdata.mapping_parser import ValidationResult
+
+        ms = MappingStep(
+            sf_object="Account",
+            fields=["Name"],
+            action=DataOperationType.INSERT,
+        )
+
+        validation_result = ValidationResult()
+        result = ms._validate_sobject(
+            CaseInsensitiveDict({"Account": {"createable": False}}),
+            None,
+            None,
+            DataOperationType.INSERT,
+            validation_result,
+        )
+
+        assert not result
+        # Should have warning about incorrect permissions
+        assert any(
+            "does not have the correct permissions" in warning
+            for warning in validation_result.warnings
+        )
+
+    def test_infer_and_validate_lookups_invalid_reference_with_validation_result(self):
+        """Test _infer_and_validate_lookups with invalid reference using ValidationResult"""
+        from cumulusci.tasks.bulkdata.mapping_parser import ValidationResult
+
+        mock_sf = mock.Mock()
+        # Mock Event.describe
+        mock_sf.Event.describe.return_value = {
+            "fields": [
+                {
+                    "name": "Description",
+                    "referenceTo": [],
+                }
+            ]
+        }
+        # Mock Contact.describe
+        mock_sf.Contact.describe.return_value = {
+            "fields": [
+                {
+                    "name": "AccountId",
+                    "referenceTo": ["Account"],  # Only Account is valid
+                }
+            ]
+        }
+
+        mapping = {
+            "Insert Events": MappingStep(
+                sf_object="Event",
+                table="Event",
+                fields=["Description"],
+            ),
+            "Insert Contacts": MappingStep(
+                sf_object="Contact",
+                table="Contact",
+                fields=["LastName"],
+                lookups={
+                    "AccountId": MappingLookup(table="Event", name="AccountId")
+                },  # Invalid - Event is not a valid lookup
+            ),
+        }
+
+        validation_result = ValidationResult()
+        _infer_and_validate_lookups(mapping, mock_sf, validation_result)
+
+        # Should have error about invalid lookup
+        assert validation_result.has_errors()
+        assert any(
+            "is not a valid lookup" in error for error in validation_result.errors
+        )
+
+    def test_infer_and_validate_lookups_polymorphic_incorrect_order_with_validation_result(
+        self,
+    ):
+        """Test _infer_and_validate_lookups with polymorphic lookups in incorrect order using ValidationResult"""
+        from cumulusci.tasks.bulkdata.mapping_parser import ValidationResult
+
+        mock_sf = mock.Mock()
+        # Mock Account.describe
+        mock_sf.Account.describe.return_value = {
+            "fields": [
+                {
+                    "name": "Name",
+                    "referenceTo": [],
+                }
+            ]
+        }
+        # Mock Event.describe
+        mock_sf.Event.describe.return_value = {
+            "fields": [
+                {
+                    "name": "WhatId",
+                    "referenceTo": ["Account", "Opportunity"],
+                }
+            ]
+        }
+        # Mock Opportunity.describe
+        mock_sf.Opportunity.describe.return_value = {
+            "fields": [
+                {
+                    "name": "Name",
+                    "referenceTo": [],
+                }
+            ]
+        }
+
+        # Event comes before Opportunity, but WhatId references both Account and Opportunity
+        mapping = {
+            "Insert Account": MappingStep(
+                sf_object="Account",
+                table="Account",
+                fields=["Name"],
+            ),
+            "Insert Events": MappingStep(
+                sf_object="Event",
+                table="Event",
+                fields=["Description"],
+                lookups={
+                    "WhatId": MappingLookup(
+                        table=["Account", "Opportunity"], name="WhatId"
+                    )
+                },
+            ),
+            "Insert Opportunity": MappingStep(
+                sf_object="Opportunity",
+                table="Opportunity",
+                fields=["Name"],
+            ),
+        }
+
+        validation_result = ValidationResult()
+        _infer_and_validate_lookups(mapping, mock_sf, validation_result)
+
+        # Should have error about incorrect order
+        assert validation_result.has_errors()
+        assert any("must precede" in error for error in validation_result.errors)
+
+    @responses.activate
+    def test_validate_and_inject_mapping_required_lookup_dropped_with_validate_only(
+        self,
+    ):
+        """Test validate_and_inject_mapping when a required lookup is dropped in validate_only mode"""
+        from cumulusci.tasks.bulkdata.mapping_parser import ValidationResult
+
+        mock_describe_calls()
+        # Using Id field as a required lookup (it's non-nillable)
+        mapping = parse_from_yaml(
+            StringIO(
+                (
+                    "Insert Accounts:\n  sf_object: NotAccount\n  table: Account\n  fields:\n    - Nonsense__c\n"
+                    "Insert Contacts:\n  sf_object: Contact\n  table: Contact\n  fields:\n    - LastName\n  lookups:\n    Id:\n      table: Account"
+                )
+            )
+        )
+        org_config = DummyOrgConfig(
+            {"instance_url": "https://example.com", "access_token": "abc123"}, "test"
+        )
+
+        result = validate_and_inject_mapping(
+            mapping=mapping,
+            sf=org_config.salesforce_client,
+            namespace=None,
+            data_operation=DataOperationType.INSERT,
+            inject_namespaces=False,
+            drop_missing=True,
+            validate_only=True,
+        )
+
+        assert result is not None
+        assert isinstance(result, ValidationResult)
+        assert result.has_errors()
+        # Should have error about required field being dropped
+        assert any("is a required field" in error for error in result.errors)