cumulusci 4.2.0__tar.gz → 4.3.0.dev0__tar.gz

{cumulusci-4.2.0 → cumulusci-4.3.0.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cumulusci
-Version: 4.2.0
+Version: 4.3.0.dev0
 Summary: Build and release tools for Salesforce developers
 Project-URL: Homepage, https://github.com/SFDO-Tooling/CumulusCI
 Project-URL: Changelog, https://cumulusci.readthedocs.io/en/stable/history.html
@@ -126,7 +126,7 @@ license](https://github.com/SFDO-Tooling/CumulusCI/blob/main/LICENSE)
 and is not covered by the Salesforce Master Subscription Agreement.
 
 <!-- Changelog -->
-## v4.2.0 (2025-01-20)
+## v4.3.0.dev0 (2025-02-19)
 
 <!-- Release notes generated using configuration in .github/release.yml at main -->
 
@@ -134,12 +134,8 @@ and is not covered by the Salesforce Master Subscription Agreement.
 
 ### Changes 🎉
 
--   fix: Prevent 'directory not empty' error in `snowfakery` on Linux by [@schenkkp](https://github.com/schenkkp) in [#3864](https://github.com/SFDO-Tooling/CumulusCI/pull/3864)
--   @W-17621812: Update \_get_required_permission_types to handle SELECT operations by [@aditya-balachander](https://github.com/aditya-balachander) in [#3870](https://github.com/SFDO-Tooling/CumulusCI/pull/3870)
+-   @W-17717398: Fix for Error When Local Records Are Empty During SELECT Action by [@aditya-balachander](https://github.com/aditya-balachander) in [#3877](https://github.com/SFDO-Tooling/CumulusCI/pull/3877)
+-   Changed Check Components to add a get repo components function by [@jain-naman-sf](https://github.com/jain-naman-sf) in [#3881](https://github.com/SFDO-Tooling/CumulusCI/pull/3881)
+-   Fixed the mdapi issue for Check Components by [@jain-naman-sf](https://github.com/jain-naman-sf) in [#3882](https://github.com/SFDO-Tooling/CumulusCI/pull/3882)
 
-## New Contributors
-
--   @RupertBarrow made their first contribution in [#3490](https://github.com/SFDO-Tooling/CumulusCI/pull/3490)
--   @schenkkp made their first contribution in [#3864](https://github.com/SFDO-Tooling/CumulusCI/pull/3864)
-
-**Full Changelog**: https://github.com/SFDO-Tooling/CumulusCI/compare/v4.1.0...v4.2.0
+**Full Changelog**: https://github.com/SFDO-Tooling/CumulusCI/compare/v4.3.0...v4.3.0.dev0

cumulusci-4.3.0.dev0/cumulusci/__about__.py

@@ -0,0 +1 @@
+__version__ = "4.3.0.dev0"

{cumulusci-4.2.0 → cumulusci-4.3.0.dev0}/cumulusci/tasks/bulkdata/step.py

@@ -463,6 +463,18 @@ class BulkApiDmlOperation(BaseDmlOperation, BulkJobMixin):
         records, records_copy = tee(records)
         # Count total number of records to fetch using the copy
         total_num_records = sum(1 for _ in records_copy)
+
+        # In the case that records are zero, return success
+        if total_num_records == 0:
+            self.logger.info(f"No records present for {self.sobject}")
+            self.job_result = DataOperationJobResult(
+                status=DataOperationStatus.SUCCESS,
+                job_errors=[],
+                records_processed=0,
+                total_row_errors=0,
+            )
+            return
+
         limit_clause = self._determine_limit_clause(total_num_records=total_num_records)
 
         # Generate and execute SOQL query
@@ -882,6 +894,17 @@ class RestApiDmlOperation(BaseDmlOperation):
         # Count total number of records to fetch using the copy
         total_num_records = sum(1 for _ in records_copy)
 
+        # In the case that records are zero, return success
+        self.logger.info(f"No records present for {self.sobject}")
+        if total_num_records == 0:
+            self.job_result = DataOperationJobResult(
+                status=DataOperationStatus.SUCCESS,
+                job_errors=[],
+                records_processed=0,
+                total_row_errors=0,
+            )
+            return
+
         # Set LIMIT condition
         limit_clause = self._determine_limit_clause(total_num_records)
 

{cumulusci-4.2.0 → cumulusci-4.3.0.dev0}/cumulusci/tasks/bulkdata/tests/test_step.py

@@ -591,6 +591,47 @@ class TestBulkApiDmlOperation:
             == 3
         )
 
+    @mock.patch("cumulusci.tasks.bulkdata.step.download_file")
+    def test_select_records_zero_load_records(self, download_mock):
+        # Set up mock context and BulkApiDmlOperation
+        context = mock.Mock()
+        step = BulkApiDmlOperation(
+            sobject="Contact",
+            operation=DataOperationType.QUERY,
+            api_options={"batch_size": 10, "update_key": "LastName"},
+            context=context,
+            fields=["LastName"],
+            selection_strategy=SelectStrategy.STANDARD,
+            content_type="JSON",
+        )
+
+        # Mock Bulk API responses
+        step.bulk.endpoint = "https://test"
+        step.bulk.create_query_job.return_value = "JOB"
+        step.bulk.query.return_value = "BATCH"
+        step.bulk.get_query_batch_result_ids.return_value = ["RESULT"]
+
+        # Mock the downloaded CSV content with a single record
+        download_mock.return_value = io.StringIO('[{"Id":"003000000000001"}]')
+
+        # Mock the _wait_for_job method to simulate a successful job
+        step._wait_for_job = mock.Mock()
+        step._wait_for_job.return_value = DataOperationJobResult(
+            DataOperationStatus.SUCCESS, [], 0, 0
+        )
+
+        # Prepare input records
+        records = iter([])
+
+        # Execute the select_records operation
+        step.start()
+        step.select_records(records)
+        step.end()
+
+        # Get the results and assert their properties
+        results = list(step.get_results())
+        assert len(results) == 0  # Expect 0 results (no records to process)
+
     @mock.patch("cumulusci.tasks.bulkdata.step.download_file")
     def test_select_records_standard_strategy_failure__no_records(self, download_mock):
         # Set up mock context and BulkApiDmlOperation
@@ -1927,6 +1968,45 @@ class TestRestApiDmlOperation:
             == 3
         )
 
+    @responses.activate
+    def test_select_records_zero_load_records(self):
+        mock_describe_calls()
+        task = _make_task(
+            LoadData,
+            {
+                "options": {
+                    "database_url": "sqlite:///test.db",
+                    "mapping": "mapping.yml",
+                }
+            },
+        )
+        task.project_config.project__package__api_version = CURRENT_SF_API_VERSION
+        task._init_task()
+
+        step = RestApiDmlOperation(
+            sobject="Contact",
+            operation=DataOperationType.UPSERT,
+            api_options={"batch_size": 10, "update_key": "LastName"},
+            context=task,
+            fields=["LastName"],
+            selection_strategy=SelectStrategy.STANDARD,
+        )
+
+        results = {
+            "records": [],
+            "done": True,
+        }
+        step.sf.restful = mock.Mock()
+        step.sf.restful.return_value = results
+        records = iter([])
+        step.start()
+        step.select_records(records)
+        step.end()
+
+        # Get the results and assert their properties
+        results = list(step.get_results())
+        assert len(results) == 0  # Expect 0 results (matching the input records count)
+
     @responses.activate
     def test_select_records_standard_strategy_success_pagination(self):
         mock_describe_calls()

{cumulusci-4.2.0 → cumulusci-4.3.0.dev0}/cumulusci/tasks/metadata/package.py

@@ -45,15 +45,19 @@ def process_common_components(response_messages: List, components: Dict):
     """Compare compoents in the api responce object with list of components and return common common components"""
     if not response_messages or not components:
         return components
-
     for message in response_messages:
+
         message_list = message.firstChild.nextSibling.firstChild.nodeValue.split("'")
         if len(message_list) > 1:
             component_type = message_list[1]
             message_txt = message_list[2]
-
             if "is not available in this organization" in message_txt:
                 del components[component_type]
+            elif "is unknown" in message_txt:
+                component_type = message_list[0].split(" ")
+                components[component_type[0]].remove(message_list[1])
+                if len(components[component_type]) == 0:
+                    del components[component_type]
             else:
                 component_name = message_list[3]
                 if component_name in components[component_type]:

{cumulusci-4.2.0 → cumulusci-4.3.0.dev0}/cumulusci/tasks/preflight/sobjects.py

@@ -17,9 +17,9 @@ class CheckSObjectsAvailable(BaseSalesforceApiTask):
                   action: error
                   message: "Enhanced Notes are not turned on."
     """
-    api_version = "48.0"
 
     def _run_task(self):
+
         self.return_values = {entry["name"] for entry in self.sf.describe()["sobjects"]}
 
         self.logger.info(

{cumulusci-4.2.0 → cumulusci-4.3.0.dev0}/cumulusci/tasks/salesforce/check_components.py

@@ -3,6 +3,7 @@ import os
 import shutil
 import tempfile
 from collections import defaultdict
+from itertools import chain
 from xml.etree.ElementTree import ParseError
 
 from defusedxml.minidom import parseString
@@ -47,6 +48,35 @@ class CheckComponents(BaseSalesforceTask):
         paths = self.options.get("paths")
         plan_or_flow_name = self.options.get("name")
 
+        (
+            components,
+            api_retrieve_unpackaged_response,
+        ) = self.get_repo_existing_components(plan_or_flow_name, paths)
+
+        if not components:
+            self.logger.info("No components found in deploy path")
+            raise TaskOptionsError("No plan or paths options provided")
+
+        self.logger.debug("Components detected at source")
+        for component_type, component_names in components.items():
+            self.logger.debug(f"{component_type}: {', '.join(component_names)}")
+        # check common components
+        components.pop("Settings", None)
+        existing_components = process_common_components(
+            api_retrieve_unpackaged_response, components
+        )
+
+        if existing_components:
+            self.logger.info("Components exists in the target org:")
+            for component_type, component_names in existing_components.items():
+                self.logger.info(f"{component_type}: {', '.join(component_names)}")
+            self.return_values["existing_components"] = existing_components
+        else:
+            self.logger.info(
+                "No components from the deploy paths exist in the target org."
+            )
+
+    def get_repo_existing_components(self, plan_or_flow_name, paths=""):
         if paths:
             paths = process_list_arg(paths)
             self.logger.info(f"Using provided paths: {paths}")
@@ -71,16 +101,37 @@ class CheckComponents(BaseSalesforceTask):
             self.logger.debug(
                 f"deploy paths found in the plan or flow.{self.deploy_paths}"
             )
-
         # Temp dir to copy all deploy paths from task options
         temp_dir = tempfile.mkdtemp()
         self.logger.info(f"Temporary deploy directory created: {temp_dir}")
-
+        mdapi_components = {}
+        mdapi_response_messages = []
         for path in self.deploy_paths:
             full_path = os.path.join(self.project_config.repo_root, path)
             if not os.path.exists(full_path):
                 self.logger.info(f"Skipping path: '{path}' - path doesn't exist")
                 continue
+            elif "package.xml" in os.listdir(full_path):
+                package_xml_path = os.path.join(full_path, "package.xml")
+                source_xml_tree = metadata_tree.parse(package_xml_path)
+                components = metadata_tree.parse_package_xml_types(
+                    "name", source_xml_tree
+                )
+                response_messages = self._get_api_object_responce(
+                    package_xml_path, source_xml_tree.version.text
+                )
+                merged = {}
+                for key in set(components).union(mdapi_components):
+                    merged[key] = list(
+                        set(
+                            chain(
+                                components.get(key, []), mdapi_components.get(key, [])
+                            )
+                        )
+                    )
+                mdapi_components = merged
+                mdapi_response_messages.extend(response_messages)
+                continue
             self._copy_to_tempdir(path, temp_dir)
 
         (
@@ -90,28 +141,22 @@ class CheckComponents(BaseSalesforceTask):
 
         # remove temp dir
         shutil.rmtree(temp_dir)
+        merged = {}
+        if components:
+            for key in set(components).union(mdapi_components):
+                merged[key] = list(
+                    set(chain(components.get(key, []), mdapi_components.get(key, [])))
+                )
+            components = merged
+        else:
+            components = mdapi_components
 
-        if not components:
-            self.logger.info(f"No components found in deploy path{path}")
-            raise TaskOptionsError("No plan or paths options provided")
-
-        self.logger.debug("Components detected at source")
-        for component_type, component_names in components.items():
-            self.logger.debug(f"{component_type}: {', '.join(component_names)}")
-        # check common components
-        existing_components = process_common_components(
-            api_retrieve_unpackaged_response, components
-        )
-
-        if existing_components:
-            self.logger.info("Components exists in the target org:")
-            for component_type, component_names in existing_components.items():
-                self.logger.info(f"{component_type}: {', '.join(component_names)}")
-            self.return_values["existing_components"] = existing_components
+        if api_retrieve_unpackaged_response:
+            api_retrieve_unpackaged_response.extend(mdapi_response_messages)
         else:
-            self.logger.info(
-                "No components from the deploy paths exist in the target org."
-            )
+            api_retrieve_unpackaged_response = mdapi_response_messages
+
+        return [components, api_retrieve_unpackaged_response]
 
     def _copy_to_tempdir(self, src_dir, temp_dir):
         for item in os.listdir(src_dir):

{cumulusci-4.2.0 → cumulusci-4.3.0.dev0}/cumulusci/tasks/salesforce/tests/test_check_components.py

@@ -1,4 +1,4 @@
-from unittest.mock import ANY, MagicMock, mock_open, patch
+from unittest.mock import ANY, MagicMock, Mock, mock_open, patch
 
 import pytest
 
@@ -11,6 +11,210 @@ from .util import create_task
 
 
 class TestCheckComponents:
+    @patch("os.path.exists", return_value=True)
+    @patch("os.remove")
+    @patch("os.path.isdir", return_value=True)
+    @patch("os.listdir", return_value=["package.xml"])
+    @patch("os.path.join", side_effect=lambda *args: "/".join(args))
+    @patch("cumulusci.core.sfdx.convert_sfdx_source")
+    @patch(
+        "cumulusci.tasks.salesforce.check_components.CheckComponents._is_plan",
+        return_value=False,
+    )
+    @patch(
+        "cumulusci.tasks.salesforce.check_components.CheckComponents._freeze_steps",
+        return_value=[],
+    )
+    @patch(
+        "cumulusci.tasks.salesforce.check_components.CheckComponents._collect_components_from_paths",
+        return_value=[{"Type1": ["Comp1"]}, []],
+    )
+    @patch(
+        "cumulusci.tasks.salesforce.check_components.CheckComponents._get_api_object_responce",
+        return_value=[],
+    )
+    @patch(
+        "builtins.open",
+        new_callable=mock_open,
+        read_data="""
+        <Package xmlns="http://soap.sforce.com/2006/04/metadata">
+            <types>
+                <members>Delivery</members>
+                <name>ApexClass</name>
+            </types>
+            <types>
+                <members>Delivery__c</members>
+                <name>CustomObject</name>
+            </types>
+            <version>58.0</version>
+        </Package>
+    """,
+    )
+    @patch("cumulusci.utils.xml.metadata_tree.parse")
+    @patch(
+        "cumulusci.utils.xml.metadata_tree.parse_package_xml_types",
+        return_value={"Type2": ["Comp2"]},
+    )
+    def test_get_repo_existing_components(
+        self,
+        mock_metadata_parse,
+        mock_open_file,
+        mock_convert_sfdx_source,
+        mock_path_join,
+        mock_listdir,
+        mock_isdir,
+        mock_remove,
+        mock_path_exists,
+        mock_is_plan,
+        mock_freeze_steps,
+        mock_get_api_object,
+        mock_parse,
+        mock_collect_components,
+    ):
+        org_config = Mock(scratch=True, config={})
+        org_config.username = "test_user"
+        org_config.org_id = "test_org_id"
+        self.org_config = Mock(return_value=("test", org_config))
+        project_config = create_project_config()
+        flow_config = {
+            "test": {
+                "steps": {
+                    1: {
+                        "flow": "test2",
+                    }
+                }
+            },
+            "test2": {
+                "steps": {
+                    1: {
+                        "task": "deploy",
+                        "options": {"path": "force-app/main/default"},
+                    }
+                }
+            },
+        }
+        plan_config = {
+            "title": "Test Install",
+            "slug": "install",
+            "tier": "primary",
+            "steps": {1: {"flow": "test"}},
+        }
+        project_config.config["plans"] = {
+            "Test Install": plan_config,
+        }
+        project_config.config["flows"] = flow_config
+
+        task = create_task(CheckComponents, {"name": "test2"})
+        task.deploy_paths = ["test"]
+
+        (components, response_messages) = task.get_repo_existing_components("test2")
+        assert "Type1" in components
+        assert "Type2" in components
+        assert "Comp1" in components["Type1"]
+        assert "Comp2" in components["Type2"]
+
+    @patch("os.path.exists", return_value=True)
+    @patch("os.remove")
+    @patch("os.path.isdir", return_value=True)
+    @patch("os.listdir", return_value=["package.xml"])
+    @patch("os.path.join", side_effect=lambda *args: "/".join(args))
+    @patch("cumulusci.core.sfdx.convert_sfdx_source")
+    @patch(
+        "cumulusci.tasks.salesforce.check_components.CheckComponents._is_plan",
+        return_value=False,
+    )
+    @patch(
+        "cumulusci.tasks.salesforce.check_components.CheckComponents._freeze_steps",
+        return_value=[],
+    )
+    @patch(
+        "cumulusci.tasks.salesforce.check_components.CheckComponents._collect_components_from_paths",
+        return_value=[{"Type1": ["Comp1"]}, []],
+    )
+    @patch(
+        "cumulusci.tasks.salesforce.check_components.CheckComponents._get_api_object_responce",
+        return_value=[],
+    )
+    @patch(
+        "builtins.open",
+        new_callable=mock_open,
+        read_data="""
+        <Package xmlns="http://soap.sforce.com/2006/04/metadata">
+            <types>
+                <members>Delivery</members>
+                <name>ApexClass</name>
+            </types>
+            <types>
+                <members>Delivery__c</members>
+                <name>CustomObject</name>
+            </types>
+            <version>58.0</version>
+        </Package>
+    """,
+    )
+    @patch("cumulusci.utils.xml.metadata_tree.parse")
+    @patch(
+        "cumulusci.utils.xml.metadata_tree.parse_package_xml_types",
+        return_value={"Type2": ["Comp2"]},
+    )
+    def test_get_repo_existing_components_paths_paramter(
+        self,
+        mock_metadata_parse,
+        mock_open_file,
+        mock_convert_sfdx_source,
+        mock_path_join,
+        mock_listdir,
+        mock_isdir,
+        mock_remove,
+        mock_path_exists,
+        mock_is_plan,
+        mock_freeze_steps,
+        mock_get_api_object,
+        mock_parse,
+        mock_collect_components,
+    ):
+        org_config = Mock(scratch=True, config={})
+        org_config.username = "test_user"
+        org_config.org_id = "test_org_id"
+        self.org_config = Mock(return_value=("test", org_config))
+        project_config = create_project_config()
+        flow_config = {
+            "test": {
+                "steps": {
+                    1: {
+                        "flow": "test2",
+                    }
+                }
+            },
+            "test2": {
+                "steps": {
+                    1: {
+                        "task": "deploy",
+                        "options": {"path": "force-app/main/default"},
+                    }
+                }
+            },
+        }
+        plan_config = {
+            "title": "Test Install",
+            "slug": "install",
+            "tier": "primary",
+            "steps": {1: {"flow": "test"}},
+        }
+        project_config.config["plans"] = {
+            "Test Install": plan_config,
+        }
+        project_config.config["flows"] = flow_config
+
+        task = create_task(CheckComponents, {"name": "test2"})
+        task.deploy_paths = ["test"]
+
+        (components, response_messages) = task.get_repo_existing_components("", "src")
+        assert "Type1" in components
+        assert "Type2" in components
+        assert "Comp1" in components["Type1"]
+        assert "Comp2" in components["Type2"]
+
     @patch("os.path.exists", return_value=True)
     @patch("os.remove")
     @patch("os.path.isdir", return_value=True)