cumulusci-plus 5.0.17__tar.gz → 5.0.18__tar.gz

{cumulusci_plus-5.0.17 → cumulusci_plus-5.0.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cumulusci-plus
-Version: 5.0.17
+Version: 5.0.18
 Summary: Build and release tools for Salesforce developers
 Project-URL: Homepage, https://github.com/jorgesolebur/CumulusCI
 Project-URL: Changelog, https://cumulusci.readthedocs.io/en/stable/history.html
@@ -127,7 +127,7 @@ license](https://github.com/SFDO-Tooling/CumulusCI/blob/main/LICENSE)
 and is not covered by the Salesforce Master Subscription Agreement.
 
 <!-- Changelog -->
-## v5.0.17 (2025-08-21)
+## v5.0.18 (2025-08-23)
 
 <!-- Release notes generated using configuration in .github/release.yml at main -->
 
@@ -135,6 +135,6 @@ and is not covered by the Salesforce Master Subscription Agreement.
 
 ### Changes
 
-- Add custom data type vcs_repo. by [@rupeshjSFDC](https://github.com/rupeshjSFDC) in [#59](https://github.com/jorgesolebur/CumulusCI/pull/59)
+- Add sf data command of create, query and delete. by [@rupeshjSFDC](https://github.com/rupeshjSFDC) in [#61](https://github.com/jorgesolebur/CumulusCI/pull/61)
 
-**Full Changelog**: https://github.com/jorgesolebur/CumulusCI/compare/v5.0.16...v5.0.17
+**Full Changelog**: https://github.com/jorgesolebur/CumulusCI/compare/v5.0.17...v5.0.18

cumulusci_plus-5.0.18/cumulusci/__about__.py

@@ -0,0 +1 @@
+__version__ = "5.0.18"

{cumulusci_plus-5.0.17 → cumulusci_plus-5.0.18}/cumulusci/cumulusci.yml

@@ -811,6 +811,22 @@ tasks:
         class_path: cumulusci.tasks.vlocity.vlocity.VlocityDeployTask
         description: "Executes the `vlocity packDeploy` command against an org"
         group: OmniStudio
+    data_query:
+        class_path: cumulusci.tasks.salesforce.SfDataCommands.DataQueryTask
+        description: "Executes the `sf data query` command against an org"
+        group: SalesforceDX Data Commands
+    data_delete:
+        class_path: cumulusci.tasks.salesforce.SfDataCommands.DataDeleteRecordTask
+        description: "Executes the `sf data delete` command against an org"
+        group: SalesforceDX Data Commands
+    data_create:
+        class_path: cumulusci.tasks.salesforce.SfDataCommands.DataCreateRecordTask
+        description: "Executes the `sf data create` command against an org"
+        group: SalesforceDX Data Commands
+    get_first_item_from_record_list:
+        class_path: cumulusci.tasks.utility.data_management.GetFirstItemFromRecordListTask
+        description: "Get the first item from a record list"
+        group: Utilities
 flows:
     ci_beta:
         group: Continuous Integration

cumulusci_plus-5.0.18/cumulusci/tasks/salesforce/SfDataCommands.py

@@ -0,0 +1,166 @@
+import json
+
+import sarge
+
+from cumulusci.core.exceptions import SalesforceDXException
+from cumulusci.core.sfdx import sfdx
+from cumulusci.tasks.salesforce import BaseSalesforceApiTask
+from cumulusci.utils.options import CCIOptions, Field
+
+
+class SfDataCommands(BaseSalesforceApiTask):
+    class Options(CCIOptions):
+        json_output: bool = Field(
+            None, description="Whether to return the result as a JSON object"
+        )
+        api_version: str = Field(None, description="API version to use for the command")
+        flags_dir: str = Field(None, description="Import flag values from a directory")
+
+    parsed_options: Options
+
+    def _init_task(self):
+        super()._init_task()
+
+    def _init_options(self, kwargs):
+        self.args = []
+        self.data_command = "data "
+        super()._init_options(kwargs)
+        if self.parsed_options.flags_dir:
+            self.args.extend(["--flags-dir ", self.parsed_options.flags_dir])
+        if self.parsed_options.json_output:
+            self.args.extend(["--json"])
+        if self.parsed_options.api_version:
+            self.args.extend(["--api_version", self.parsed_options.api_version])
+
+    def _run_task(self):
+        self.return_values = {}
+
+        self.p: sarge.Command = sfdx(
+            self.data_command,
+            log_note="Running data command",
+            args=self.args,
+            check_return=True,
+            username=self.org_config.username,
+        )
+
+        if self.parsed_options.json_output:
+            self.return_values = self._load_json_output(self.p)
+
+        for line in self.p.stdout_text:
+            self.logger.info(line)
+
+        for line in self.p.stderr_text:
+            self.logger.error(line)
+
+    def _load_json_output(self, p: sarge.Command, stdout: str = None):
+        try:
+            stdout = stdout or p.stdout_text.read()
+            return json.loads(stdout)
+        except json.decoder.JSONDecodeError:
+            raise SalesforceDXException(
+                f"Failed to parse the output of the {self.data_command} command"
+            )
+
+
+class SfDataToolingAPISupportedCommands(SfDataCommands):
+    class Options(SfDataCommands.Options):
+        use_tooling_api: bool = Field(
+            None,
+            description="Use Tooling API so you can run queries on Tooling API objects.",
+        )
+
+
+class DataQueryTask(SfDataToolingAPISupportedCommands):
+    class Options(SfDataToolingAPISupportedCommands.Options):
+        query: str = Field(None, description="SOQL query to execute")
+        file: str = Field(None, description="File that contains the SOQL query")
+        all_rows: bool = Field(
+            None,
+            description="Include deleted records. By default, deleted records are not returned.",
+        )
+        result_format: str = Field(
+            None,
+            description="Format to display the results; the --json_output flag overrides this flag. Permissible values are: human, csv, json.",
+        )
+        output_file: str = Field(
+            None,
+            description="File where records are written; only CSV and JSON output formats are supported.",
+        )
+
+    def _init_task(self):
+        super()._init_task()
+        self.data_command += "query"
+
+    def _init_options(self, kwargs):
+        super()._init_options(kwargs)
+        if self.parsed_options.query:
+            self.args.extend(["--query", self.parsed_options.query])
+        if self.parsed_options.file:
+            self.args.extend(["--file", self.parsed_options.file])
+        if self.parsed_options.all_rows:
+            self.args.extend(["--all-rows", self.parsed_options.all_rows])
+        if self.parsed_options.result_format:
+            self.args.extend(["--result-format", self.parsed_options.result_format])
+        if self.parsed_options.output_file:
+            self.args.extend(["--output-file", self.parsed_options.output_file])
+
+    def _run_task(self):
+        super()._run_task()
+
+        if self.parsed_options.json_output:
+            self.logger.info(self.return_values)
+
+
+class DataCreateRecordTask(SfDataToolingAPISupportedCommands):
+    class Options(SfDataToolingAPISupportedCommands.Options):
+        sobject: str = Field(
+            ...,
+            description="API name of the Salesforce or Tooling API object that you're inserting a record into.",
+        )
+        values: str = Field(
+            ...,
+            description="Values for the flags in the form <fieldName>=<value>, separate multiple pairs with spaces.",
+        )
+
+    def _init_task(self):
+        super()._init_task()
+        self.data_command += "create record"
+
+    def _init_options(self, kwargs):
+        super()._init_options(kwargs)
+        if self.options.get("sobject"):
+            self.args.extend(["--sobject", self.options.get("sobject")])
+        if self.options.get("values"):
+            self.args.extend(["--values", self.options.get("values")])
+
+    def _run_task(self):
+        return super()._run_task()
+
+
+class DataDeleteRecordTask(SfDataToolingAPISupportedCommands):
+    class Options(SfDataToolingAPISupportedCommands.Options):
+        sobject: str = Field(
+            ...,
+            description="API name of the Salesforce or Tooling API object that you're deleting a record from.",
+        )
+        record_id: str = Field(None, description="ID of the record you’re deleting.")
+        where: str = Field(
+            None,
+            description="List of <fieldName>=<value> pairs that identify the record you want to delete.",
+        )
+
+    def _init_task(self):
+        super()._init_task()
+        self.data_command += "delete record"
+
+    def _init_options(self, kwargs):
+        super()._init_options(kwargs)
+        if self.options.get("sobject"):
+            self.args.extend(["--sobject", self.options.get("sobject")])
+        if self.options.get("record_id"):
+            self.args.extend(["--record-id", self.options.get("record_id")])
+        if self.options.get("where"):
+            self.args.extend(["--where", self.options.get("where")])
+
+    def _run_task(self):
+        return super()._run_task()

cumulusci_plus-5.0.18/cumulusci/tasks/salesforce/tests/test_SfDataCommands.py

@@ -0,0 +1,363 @@
+import json
+from unittest import mock
+
+import pytest
+import sarge
+
+from cumulusci.core.exceptions import SalesforceDXException
+from cumulusci.tasks.salesforce.SfDataCommands import (
+    DataCreateRecordTask,
+    DataDeleteRecordTask,
+    DataQueryTask,
+    SfDataCommands,
+    SfDataToolingAPISupportedCommands,
+)
+
+from . import create_task
+
+
+def create_mock_sarge_command(stdout="", stderr="", returncode=0):
+    """Create a mock sarge.Command that satisfies type checking"""
+    mock_command = mock.Mock(spec=sarge.Command)
+    mock_command.returncode = returncode
+
+    # Mock stdout_text
+    stdout_lines = stdout.split("\n") if stdout else []
+    mock_stdout_text = mock.Mock()
+    mock_stdout_text.__iter__ = mock.Mock(return_value=iter(stdout_lines))
+    mock_stdout_text.read = mock.Mock(return_value=stdout)
+    mock_command.stdout_text = mock_stdout_text
+
+    # Mock stderr_text
+    stderr_lines = stderr.split("\n") if stderr else []
+    mock_stderr_text = mock.Mock()
+    mock_stderr_text.__iter__ = mock.Mock(return_value=iter(stderr_lines))
+    mock_stderr_text.read = mock.Mock(return_value=stderr)
+    mock_command.stderr_text = mock_stderr_text
+
+    return mock_command
+
+
+@mock.patch("cumulusci.tasks.salesforce.SfDataCommands.sfdx")
+class TestSfDataCommands:
+    def test_init_options_basic(self, mock_sfdx):
+        mock_sfdx.return_value = create_mock_sarge_command()
+        task = create_task(SfDataCommands, {})
+        task()
+        assert task.data_command == "data "
+        assert task.args == []
+
+    def test_init_options_all_flags(self, mock_sfdx):
+        json_response = {"status": 0, "result": {}}
+        mock_sfdx.return_value = create_mock_sarge_command(
+            stdout=json.dumps(json_response)
+        )
+        task = create_task(
+            SfDataCommands,
+            {
+                "json_output": True,
+                "api_version": "50.0",
+                "flags_dir": "/tmp/flags",
+            },
+        )
+        task()
+        expected_args = [
+            "--flags-dir ",
+            "/tmp/flags",
+            "--json",
+            "--api_version",
+            "50.0",
+        ]
+        assert all(arg in task.args for arg in expected_args)
+
+    def test_load_json_output_success(self, mock_sfdx):
+        json_response = {"status": 0, "result": {"records": []}}
+        stdout = json.dumps(json_response)
+        mock_command = create_mock_sarge_command(stdout=stdout)
+        mock_sfdx.return_value = mock_command
+
+        task = create_task(SfDataCommands, {"json_output": True})
+        task()
+
+        assert task.return_values == json_response
+
+    def test_load_json_output_decode_error(self, mock_sfdx):
+        mock_command = create_mock_sarge_command(stdout="invalid json")
+        mock_sfdx.return_value = mock_command
+
+        task = create_task(SfDataCommands, {"json_output": True})
+
+        with pytest.raises(SalesforceDXException, match="Failed to parse the output"):
+            task()
+
+    def test_logging_stdout_and_stderr(self, mock_sfdx):
+        mock_command = create_mock_sarge_command(
+            stdout="Success: Query completed\nFound 5 records",
+            stderr="Warning: Some non-critical issue",
+        )
+        mock_sfdx.return_value = mock_command
+
+        task = create_task(SfDataCommands, {})
+        with mock.patch.object(task, "logger") as mock_logger:
+            task()
+
+            # Check that stdout lines were logged as info
+            mock_logger.info.assert_any_call("Success: Query completed")
+            mock_logger.info.assert_any_call("Found 5 records")
+
+            # Check that stderr lines were logged as error
+            mock_logger.error.assert_called_with("Warning: Some non-critical issue")
+
+
+@mock.patch("cumulusci.tasks.salesforce.SfDataCommands.sfdx")
+class TestSfDataToolingAPISupportedCommands:
+    def test_inherits_from_base(self, mock_sfdx):
+        mock_sfdx.return_value = create_mock_sarge_command()
+        task = create_task(SfDataToolingAPISupportedCommands, {})
+        assert isinstance(task, SfDataCommands)
+
+    def test_use_tooling_api_option(self, mock_sfdx):
+        mock_sfdx.return_value = create_mock_sarge_command()
+        task = create_task(SfDataToolingAPISupportedCommands, {"use_tooling_api": True})
+        # Test that the option is available (would be tested in subclasses that use it)
+        assert hasattr(task.parsed_options, "use_tooling_api")
+
+
+@mock.patch("cumulusci.tasks.salesforce.SfDataCommands.sfdx")
+class TestDataQueryTask:
+    def test_init_task_sets_command(self, mock_sfdx):
+        mock_sfdx.return_value = create_mock_sarge_command()
+        task = create_task(DataQueryTask, {"query": "SELECT Id FROM Account"})
+        task()
+        assert task.data_command == "data query"
+
+    def test_init_options_all_parameters(self, mock_sfdx):
+        json_response = {"status": 0, "result": {"records": []}}
+        mock_sfdx.return_value = create_mock_sarge_command(
+            stdout=json.dumps(json_response)
+        )
+        task = create_task(
+            DataQueryTask,
+            {
+                "query": "SELECT Id FROM Account",
+                "file": "/tmp/query.soql",
+                "all_rows": True,
+                "result_format": "csv",
+                "output_file": "/tmp/output.csv",
+                "api_version": "50.0",
+                "flags_dir": "/tmp/flags",
+                "json_output": True,
+                "use_tooling_api": True,
+            },
+        )
+        task()
+
+        call_args = mock_sfdx.call_args[1]["args"]
+        assert mock_sfdx.call_args[1]["log_note"] == "Running data command"
+        assert "--query" in call_args
+        assert "SELECT Id FROM Account" in call_args
+        assert "--file" in call_args
+        assert "/tmp/query.soql" in call_args
+        assert "--all-rows" in call_args
+        assert "--result-format" in call_args
+        assert "csv" in call_args
+        assert "--output-file" in call_args
+        assert "/tmp/output.csv" in call_args
+        assert "--api_version" in call_args
+        assert "50.0" in call_args
+        assert "--flags-dir " in call_args
+        assert "/tmp/flags" in call_args
+        assert "--json" in call_args
+
+    def test_minimal_options(self, mock_sfdx):
+        mock_sfdx.return_value = create_mock_sarge_command()
+        task = create_task(DataQueryTask, {"query": "SELECT Id FROM Account"})
+        task()
+
+        call_args = mock_sfdx.call_args[1]["args"]
+        assert "--query" in call_args
+        assert "SELECT Id FROM Account" in call_args
+
+    def test_json_output_logging(self, mock_sfdx):
+        json_response = {"status": 0, "result": {"records": [{"Id": "123"}]}}
+        stdout = json.dumps(json_response)
+        mock_sfdx.return_value = create_mock_sarge_command(stdout=stdout)
+
+        task = create_task(
+            DataQueryTask,
+            {"query": "SELECT Id FROM Account", "json_output": True},
+        )
+
+        with mock.patch.object(task, "logger") as mock_logger:
+            task()
+            mock_logger.info.assert_called_with(json_response)
+
+    def test_run_task_json_decode_error(self, mock_sfdx):
+        mock_sfdx.return_value = create_mock_sarge_command(stdout="this is not json")
+        task = create_task(
+            DataQueryTask,
+            {"query": "SELECT Id FROM Account", "json_output": True},
+        )
+        with pytest.raises(
+            SalesforceDXException,
+            match="Failed to parse the output of the data query command",
+        ):
+            task()
+
+
+@mock.patch("cumulusci.tasks.salesforce.SfDataCommands.sfdx")
+class TestDataCreateRecordTask:
+    def test_init_task_sets_command(self, mock_sfdx):
+        mock_sfdx.return_value = create_mock_sarge_command()
+        task = create_task(
+            DataCreateRecordTask,
+            {"sobject": "Account", "values": "Name='Test Account'"},
+        )
+        task()
+        assert task.data_command == "data create record"
+
+    def test_init_options_all_parameters(self, mock_sfdx):
+        json_response = {"status": 0, "result": {"id": "001000000000001"}}
+        mock_sfdx.return_value = create_mock_sarge_command(
+            stdout=json.dumps(json_response)
+        )
+        task = create_task(
+            DataCreateRecordTask,
+            {
+                "sobject": "Account",
+                "values": "Name='Test Account' Industry='Technology'",
+                "api_version": "50.0",
+                "flags_dir": "/tmp/flags",
+                "json_output": True,
+                "use_tooling_api": True,
+            },
+        )
+        task()
+
+        call_args = mock_sfdx.call_args[1]["args"]
+        assert mock_sfdx.call_args[1]["log_note"] == "Running data command"
+        assert "--sobject" in call_args
+        assert "Account" in call_args
+        assert "--values" in call_args
+        assert "Name='Test Account' Industry='Technology'" in call_args
+        assert "--api_version" in call_args
+        assert "50.0" in call_args
+        assert "--flags-dir " in call_args
+        assert "/tmp/flags" in call_args
+        assert "--json" in call_args
+
+    def test_minimal_options(self, mock_sfdx):
+        mock_sfdx.return_value = create_mock_sarge_command()
+        task = create_task(
+            DataCreateRecordTask,
+            {"sobject": "Contact", "values": "LastName='Doe'"},
+        )
+        task()
+
+        call_args = mock_sfdx.call_args[1]["args"]
+        assert "--sobject" in call_args
+        assert "Contact" in call_args
+        assert "--values" in call_args
+        assert "LastName='Doe'" in call_args
+
+    def test_missing_required_options(self, mock_sfdx):
+        # Test that required field validation works as expected
+        mock_sfdx.return_value = create_mock_sarge_command()
+        from cumulusci.core.exceptions import TaskOptionsError
+
+        with pytest.raises(TaskOptionsError, match="field required"):
+            create_task(DataCreateRecordTask, {})
+
+
+@mock.patch("cumulusci.tasks.salesforce.SfDataCommands.sfdx")
+class TestDataDeleteRecordTask:
+    def test_init_task_sets_command(self, mock_sfdx):
+        mock_sfdx.return_value = create_mock_sarge_command()
+        task = create_task(
+            DataDeleteRecordTask, {"sobject": "Account", "record_id": "001000000000001"}
+        )
+        task()
+        assert task.data_command == "data delete record"
+
+    def test_delete_by_record_id(self, mock_sfdx):
+        json_response = {"status": 0, "result": {}}
+        mock_sfdx.return_value = create_mock_sarge_command(
+            stdout=json.dumps(json_response)
+        )
+        task = create_task(
+            DataDeleteRecordTask,
+            {
+                "sobject": "Account",
+                "record_id": "001000000000001AAA",
+                "api_version": "50.0",
+                "flags_dir": "/tmp/flags",
+                "json_output": True,
+            },
+        )
+        task()
+
+        call_args = mock_sfdx.call_args[1]["args"]
+        assert mock_sfdx.call_args[1]["log_note"] == "Running data command"
+        assert "--sobject" in call_args
+        assert "Account" in call_args
+        assert "--record-id" in call_args
+        assert "001000000000001AAA" in call_args
+        assert "--api_version" in call_args
+        assert "50.0" in call_args
+        assert "--flags-dir " in call_args
+        assert "/tmp/flags" in call_args
+        assert "--json" in call_args
+
+    def test_delete_by_where_clause(self, mock_sfdx):
+        mock_sfdx.return_value = create_mock_sarge_command()
+        task = create_task(
+            DataDeleteRecordTask,
+            {
+                "sobject": "Account",
+                "where": "Name='Test Account' AND Industry='Technology'",
+                "use_tooling_api": True,
+            },
+        )
+        task()
+
+        call_args = mock_sfdx.call_args[1]["args"]
+        # Check that sfdx was called with the right log_note
+        assert mock_sfdx.call_args[1]["log_note"] == "Running data command"
+        assert "--sobject" in call_args
+        assert "Account" in call_args
+        assert "--where" in call_args
+        assert "Name='Test Account' AND Industry='Technology'" in call_args
+
+    def test_minimal_options(self, mock_sfdx):
+        mock_sfdx.return_value = create_mock_sarge_command()
+        task = create_task(
+            DataDeleteRecordTask,
+            {"sobject": "Contact"},
+        )
+        task()
+
+        call_args = mock_sfdx.call_args[1]["args"]
+        assert "--sobject" in call_args
+        assert "Contact" in call_args
+        # Should not have --record-id or --where if not provided
+        assert "--record-id" not in call_args
+        assert "--where" not in call_args
+
+    def test_both_record_id_and_where_provided(self, mock_sfdx):
+        # Test that both options can be provided (though this might not be practical)
+        mock_sfdx.return_value = create_mock_sarge_command()
+        task = create_task(
+            DataDeleteRecordTask,
+            {
+                "sobject": "Account",
+                "record_id": "001000000000001",
+                "where": "Name='Test Account'",
+            },
+        )
+        task()
+
+        call_args = mock_sfdx.call_args[1]["args"]
+        assert "--record-id" in call_args
+        assert "001000000000001" in call_args
+        assert "--where" in call_args
+        assert "Name='Test Account'" in call_args

cumulusci_plus-5.0.18/cumulusci/tasks/utility/data_management.py

@@ -0,0 +1,16 @@
+from typing import Any
+
+from cumulusci.core.tasks import BaseTask
+from cumulusci.utils.options import CCIOptions, Field
+
+
+class GetFirstItemFromRecordListTask(BaseTask):
+    class Options(CCIOptions):
+        result: dict[str, Any] = Field(
+            None, description="The result from SF CLI operations."
+        )
+
+    parsed_options: Options
+
+    def _run_task(self):
+        self.return_values = self.parsed_options.result["records"][0]

{cumulusci_plus-5.0.17 → cumulusci_plus-5.0.18}/cumulusci/tasks/utility/env_management.py

@@ -109,14 +109,10 @@ class EnvManagementOption(CCIOptions):
                 f"Formatting Error: {value} for datatype: {datatype} - {e}"
             )
 
-        if self.set and self.name not in os.environ:
+        if self.set:
             os.environ[self.name] = str(task_values[self.name])
 
-        if (
-            self.set
-            and self.datatype == "vcs_repo"
-            and f"{self.name}_BRANCH" not in os.environ
-        ):
+        if self.set and self.datatype == "vcs_repo":
             os.environ[f"{self.name}_BRANCH"] = str(task_values[f"{self.name}_BRANCH"])
 
 

cumulusci_plus-5.0.18/cumulusci/tasks/utility/tests/test_data_management.py

@@ -0,0 +1,43 @@
+import pytest
+
+from cumulusci.core.config import (
+    BaseProjectConfig,
+    OrgConfig,
+    TaskConfig,
+    UniversalConfig,
+)
+from cumulusci.tasks.utility.data_management import GetFirstItemFromRecordListTask
+
+
+@pytest.fixture
+def a_task():
+    universal_config = UniversalConfig()
+    project_config = BaseProjectConfig(universal_config, config={"noyaml": True})
+    org_config = OrgConfig({}, "test")
+
+    def _a_task(options):
+        task_config = TaskConfig({"options": options})
+        return GetFirstItemFromRecordListTask(project_config, task_config, org_config)
+
+    return _a_task
+
+
+class TestGetFirstItemFromRecordListTask:
+    def test_returns_first_item(self, a_task):
+        """Tests that the task returns the first item from the 'records' list."""
+        result_input = {
+            "records": [
+                {"Id": "001", "Name": "Test Account"},
+                {"Id": "002", "Name": "Another Account"},
+            ]
+        }
+        task = a_task({"result": result_input})
+        task()
+        assert task.return_values == {"Id": "001", "Name": "Test Account"}
+
+    def test_empty_record_list(self, a_task):
+        """Tests that an IndexError is raised for an empty 'records' list."""
+        result_input = {"records": []}
+        task = a_task({"result": result_input})
+        with pytest.raises(IndexError):
+            task()