cumulusci-plus 5.0.16__py3-none-any.whl → 5.0.18__py3-none-any.whl

cumulusci/__about__.py

@@ -1 +1 @@
-__version__ = "5.0.16"
+__version__ = "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/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/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/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/tasks/utility/env_management.py

@@ -1,4 +1,5 @@
 import json
+import logging
 import os
 from datetime import date
 from pathlib import Path
@@ -23,16 +24,12 @@ class EnvManagementOption(CCIOptions):
     )
     datatype: str = Field(
         default="string",
-        description="The datatype of the environment variable. Defaults to string. Valid values are string, bool, int, float, date, list, dict, path, directory, filename, vcs_branch",
+        description="The datatype of the environment variable. Defaults to string. Valid values are string, bool, int, float, date, list, dict, path, directory, filename, vcs_repo",
     )
     set: bool = Field(
         default=False,
         description="If True, sets the value of the environment variable if it is not already set. Defaults to False",
     )
-    url: str = Field(
-        default="",
-        description="The url of the repository to get the branch value from, Applicable only for vcs_branch datatype. Defaults to empty string",
-    )
 
     @validator("datatype")
     def validate_datatype(cls, v):
@@ -47,62 +44,77 @@ class EnvManagementOption(CCIOptions):
             "path",
             "directory",
             "filename",
-            "vcs_branch",
+            "vcs_repo",
         ]:
             raise ValueError(f"Invalid datatype: {v}")
         return v
 
     def formated_value(
         self,
+        task_values: dict[str, Any],
         project_config: Optional[BaseProjectConfig],
         org_config: Optional[OrgConfig],
-    ) -> tuple[Any, str]:
+        logger: logging.Logger,
+    ) -> None:
         value = os.getenv(self.name, self.default)
         datatype = self.datatype or "string"
 
         try:
-            match datatype:
-                case "string":
-                    return str(value), str(value)
-                case "bool":
-                    v = DummyValidatorModel(b=value).b
-                    return v, str(v)
-                case "int":
-                    v = DummyValidatorModel(i=value).i
-                    return v, str(v)
-                case "float":
-                    v = DummyValidatorModel(f=value).f
-                    return v, str(v)
-                case "date":
-                    v = DummyValidatorModel(d=date.fromisoformat(str(value))).d
-                    return v, str(v)
-                case "list":
-                    v = value if isinstance(value, list) else value.split(",")
-                    return v, str(v)
-                case "dict":
-                    v = value if isinstance(value, dict) else json.loads(str(value))
-                    return v, str(v)
-                case "path":
-                    v = Path(str(value))
-                    return v.absolute(), str(v.absolute())
-                case "directory":
-                    v = Path(str(value)).parent.absolute()
-                    return v, str(v.absolute())
-                case "filename":
-                    v = Path(str(value)).name
-                    return v, str(v)
-                case "vcs_branch":
-                    task_config = TaskConfig({"options": {"url": self.url}})
-                    task = VcsRemoteBranch(project_config, task_config, org_config)
-                    result = task()
-                    return result["remote_branch"], str(result["remote_branch"])
-                case _:
-                    raise ValueError(f"Invalid datatype: {datatype}")
+            if self.name not in task_values:
+                match datatype:
+                    case "string":
+                        task_values[self.name] = str(value)
+                    case "bool":
+                        v = DummyValidatorModel(b=value).b
+                        task_values[self.name] = v
+                    case "int":
+                        v = DummyValidatorModel(i=value).i
+                        task_values[self.name] = v
+                    case "float":
+                        v = DummyValidatorModel(f=value).f
+                        task_values[self.name] = v
+                    case "date":
+                        v = DummyValidatorModel(d=date.fromisoformat(str(value))).d
+                        task_values[self.name] = v
+                    case "list":
+                        v = value if isinstance(value, list) else value.split(",")
+                        task_values[self.name] = v
+                    case "dict":
+                        v = value if isinstance(value, dict) else json.loads(str(value))
+                        task_values[self.name] = v
+                    case "path":
+                        v = Path(str(value))
+                        task_values[self.name] = v.absolute()
+                    case "directory":
+                        v = Path(str(value)).parent.absolute()
+                        task_values[self.name] = v.absolute()
+                    case "filename":
+                        v = Path(str(value)).name
+                        task_values[self.name] = v
+                    case "vcs_repo":
+                        task_config = TaskConfig(
+                            {"options": {"url": self.default, "name": self.name}}
+                        )
+                        task = VcsRemoteBranch(project_config, task_config, org_config)
+                        result = task()
+                        task_values[self.name] = result["url"]
+                        task_values[f"{self.name}_BRANCH"] = result["branch"]
+                    case _:
+                        raise ValueError(f"Invalid datatype: {datatype}")
+            else:
+                logger.info(f"Variable {self.name} already set. Skipping.")
+
         except Exception as e:
             raise ValueError(
                 f"Formatting Error: {value} for datatype: {datatype} - {e}"
             )
 
+        if self.set:
+            os.environ[self.name] = str(task_values[self.name])
+
+        if self.set and self.datatype == "vcs_repo":
+            os.environ[f"{self.name}_BRANCH"] = str(task_values[f"{self.name}_BRANCH"])
+
 
 class DummyValidatorModel(BaseModel):
     b: Optional[bool]
@@ -124,11 +136,9 @@ class EnvManagement(BaseTask):
         self.return_values = {}
 
         for env_option in self.parsed_options.envs:
-            self.return_values[env_option.name], str_value = env_option.formated_value(
-                self.project_config, self.org_config
+            env_option.formated_value(
+                self.return_values, self.project_config, self.org_config, self.logger
             )
-            if env_option.set and env_option.name not in os.environ:
-                os.environ[env_option.name] = str_value
 
         return self.return_values
 
@@ -139,19 +149,38 @@ class VcsRemoteBranch(BaseTask):
             ...,
             description="Gets if the remote branch name exist with the same name in the remote repository.",
         )
+        name: str = Field(
+            ...,
+            description="The name of the environment variable.",
+        )
 
     parsed_options: Options
 
     def _run_task(self):
         self.return_values = {}
-        # Get current branch name.
-        local_branch = self.project_config.repo_branch
-        repo = get_repo_from_url(self.project_config, self.parsed_options.url)
+
+        # Get current branch name. Based on Local Git Branch if not available from Environment Variable
+        local_branch = os.getenv(
+            f"{self.parsed_options.name}_BRANCH", self.project_config.repo_branch
+        )
+
+        # Get repository URL from Environment Variable
+        self.return_values["url"] = os.getenv(
+            self.parsed_options.name, self.parsed_options.url
+        )
+
+        repo = get_repo_from_url(self.project_config, self.return_values["url"])
 
         try:
             branch = repo.branch(local_branch)
-            self.return_values["remote_branch"] = branch.name
+            self.logger.info(
+                f"Branch {local_branch} found in repository {self.return_values['url']}."
+            )
+            self.return_values["branch"] = branch.name
         except Exception:
-            self.return_values["remote_branch"] = repo.default_branch
+            self.logger.warning(
+                f"Branch {local_branch} not found in repository {self.return_values['url']}. Using default branch {repo.default_branch}"
+            )
+            self.return_values["branch"] = repo.default_branch
 
         return self.return_values

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()

cumulusci/tasks/utility/tests/test_env_management.py

@@ -18,7 +18,12 @@ class TestVcsRemoteBranch(unittest.TestCase):
         project_config = create_project_config()
         project_config.repo_info["branch"] = "feature/branch-1"
         task_config = TaskConfig(
-            {"options": {"url": "https://github.com/TestOwner/TestRepo"}}
+            {
+                "options": {
+                    "url": "https://github.com/TestOwner/TestRepo",
+                    "name": "VCS_URL",
+                }
+            }
         )
 
         with patch(
@@ -32,14 +37,22 @@ class TestVcsRemoteBranch(unittest.TestCase):
 
             task = VcsRemoteBranch(project_config, task_config)
             task()
-            self.assertEqual(task.return_values["remote_branch"], "feature/branch-1")
+            self.assertEqual(
+                task.return_values["url"], "https://github.com/TestOwner/TestRepo"
+            )
+            self.assertEqual(task.return_values["branch"], "feature/branch-1")
             repo_mock.branch.assert_called_once_with("feature/branch-1")
 
     def test_run_task_branch_not_exist(self):
         project_config = create_project_config()
         project_config.repo_info["branch"] = "feature/branch-1"
         task_config = TaskConfig(
-            {"options": {"url": "https://github.com/TestOwner/TestRepo"}}
+            {
+                "options": {
+                    "url": "https://github.com/TestOwner/TestRepo",
+                    "name": "VCS_URL",
+                }
+            }
         )
 
         with patch(
@@ -52,7 +65,10 @@ class TestVcsRemoteBranch(unittest.TestCase):
 
             task = VcsRemoteBranch(project_config, task_config)
             task()
-            self.assertEqual(task.return_values["remote_branch"], "main")
+            self.assertEqual(
+                task.return_values["url"], "https://github.com/TestOwner/TestRepo"
+            )
+            self.assertEqual(task.return_values["branch"], "main")
             repo_mock.branch.assert_called_once_with("feature/branch-1")
 
 
@@ -177,20 +193,21 @@ class TestEnvManagement(unittest.TestCase):
             task()
 
     @patch("cumulusci.tasks.utility.env_management.VcsRemoteBranch")
-    def test_vcs_branch_datatype(self, vcs_mock):
-        os.environ["TEST_VAR"] = ""  # vcs_branch doesn't use env var
-
+    def test_vcs_repo_datatype(self, vcs_mock):
         vcs_instance_mock = vcs_mock.return_value
-        vcs_instance_mock.return_value = {"remote_branch": "my-feature-branch"}
+        vcs_instance_mock.return_value = {
+            "url": "https://github.com/TestOwner/TestRepo",
+            "branch": "my-feature-branch",
+        }
 
         task_config = TaskConfig(
             {
                 "options": {
                     "envs": [
                         {
-                            "name": "VCS_BRANCH",
-                            "datatype": "vcs_branch",
-                            "url": "https://github.com/TestOwner/TestRepo",
+                            "name": "VCS_URL",
+                            "datatype": "vcs_repo",
+                            "default": "https://github.com/TestOwner/TestRepo",
                         }
                     ]
                 }
@@ -199,7 +216,8 @@ class TestEnvManagement(unittest.TestCase):
         task = EnvManagement(self.project_config, task_config, self.org_config)
         result = task()
 
-        self.assertEqual(result["VCS_BRANCH"], "my-feature-branch")
+        self.assertEqual(result["VCS_URL"], "https://github.com/TestOwner/TestRepo")
+        self.assertEqual(result["VCS_URL_BRANCH"], "my-feature-branch")
         vcs_mock.assert_called_once()
 
     @patch.dict(os.environ, {}, clear=True)

{cumulusci_plus-5.0.16.dist-info → cumulusci_plus-5.0.18.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cumulusci-plus
-Version: 5.0.16
+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.16 (2025-08-20)
+## 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 configure_env task and fix failing test classes. by [@rupeshjSFDC](https://github.com/rupeshjSFDC) in [#57](https://github.com/jorgesolebur/CumulusCI/pull/57)
+- 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.15...v5.0.16
+**Full Changelog**: https://github.com/jorgesolebur/CumulusCI/compare/v5.0.17...v5.0.18

{cumulusci_plus-5.0.16.dist-info → cumulusci_plus-5.0.18.dist-info}/RECORD

@@ -1,8 +1,8 @@
-cumulusci/__about__.py,sha256=6Zfa5_jynCBYIvtkYN0Ygch4VWXnobnaeed612gFG18,23
+cumulusci/__about__.py,sha256=rNEejWvxeGfAnWPU00R1oUZaWa42-NuQA6ta50JVBY0,23
 cumulusci/__init__.py,sha256=jdanFQ_i8vbdO7Eltsf4pOfvV4mwa_Osyc4gxWKJ8ng,764
 cumulusci/__main__.py,sha256=kgRH-n5AJrH_daCK_EJwH7azAUxdXEmpi-r-dPGMR6Y,43
 cumulusci/conftest.py,sha256=AIL98BDwNAQtdo8YFmLKwav0tmrQ5dpbw1cX2FyGouQ,5108
-cumulusci/cumulusci.yml,sha256=h4Ywck_HV5PXqjdTvA6jMm8dxPLZi2tmFdwGmssnhdo,72617
+cumulusci/cumulusci.yml,sha256=RQN4mskRwSYaP33g-b9SZg8j62rU5ynpCE7ZBxfDqFY,73476
 cumulusci/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cumulusci/cli/cci.py,sha256=yAq8jFoGde6g_1TeAAjzZYsk77itiONCQGBFe3g3nOs,11836
 cumulusci/cli/error.py,sha256=znj0YN8D2Grozm1u7mZAsJlmmdGebbuy0c1ofQluL4Q,4410
@@ -516,6 +516,7 @@ cumulusci/tasks/salesforce/RetrievePackaged.py,sha256=XMdA3qBIuGJaZnPNeZBKupz9N6
 cumulusci/tasks/salesforce/RetrieveReportsAndDashboards.py,sha256=-pVD0RJ4vsB1TM9b7VcPQAV-pO4LTAm-YoESq4bM2dA,3289
 cumulusci/tasks/salesforce/RetrieveUnpackaged.py,sha256=_9jglbNWmjg9kq5EkvCusprrt14czurBtNM2hbU9RFI,1174
 cumulusci/tasks/salesforce/SOQLQuery.py,sha256=RFV-bLzvAx_m4SWWLMyCKuA3ie08iLwLyrOVyhpNCPE,1730
+cumulusci/tasks/salesforce/SfDataCommands.py,sha256=tCrjvxZDk4vrVmeJo7BR5uTEZUUbhbAGNoRuwt4zn1k,6094
 cumulusci/tasks/salesforce/UninstallLocal.py,sha256=6nnRDyFrwIcXd9WygDHIMhMQYBZMFEQ75Sh6nNxivfg,492
 cumulusci/tasks/salesforce/UninstallLocalBundles.py,sha256=eG4yoDJdjruo9kwfcQU-i5_AVt473uWF7SvLD7IQoSw,759
 cumulusci/tasks/salesforce/UninstallLocalNamespacedBundles.py,sha256=KgM6TPSkczAdeM10fOAtijs4uszJ_f219lGgVNwJ1eM,2210
@@ -561,6 +562,7 @@ cumulusci/tasks/salesforce/tests/test_RetrievePackaged.py,sha256=jhXYXv6I54HUfOf
 cumulusci/tasks/salesforce/tests/test_RetrieveReportsAndDashboards.py,sha256=6ePEXIqMdNLKcnxUkwnpWSqJ1TaWFfAcl3lEhbsqFFI,1730
 cumulusci/tasks/salesforce/tests/test_RetrieveUnpackaged.py,sha256=mXMcw0a1til3R8eMm7KGZ5oftqKT5XLFoZ047UAO0Z8,668
 cumulusci/tasks/salesforce/tests/test_SOQLQuery.py,sha256=YHsdSzFNEY8R5qbT0al9I0mYHWNT8P4hqYji2gDVnEU,849
+cumulusci/tasks/salesforce/tests/test_SfDataCommands.py,sha256=JdM7P-lDXKtvxK4UlHMOIfzCVz6uH2eaIyyJEZKenuk,13353
 cumulusci/tasks/salesforce/tests/test_UninstallLocal.py,sha256=v7UtmVPFGeH13mSnuZi8eI5vaDeO7WlDu1bhM3s9-fk,582
 cumulusci/tasks/salesforce/tests/test_UninstallLocalBundles.py,sha256=oz8xuYGda4aYXskIAB0mUAJpgroOhV9Ahb-a4oNJtio,557
 cumulusci/tasks/salesforce/tests/test_UninstallLocalNamespacedBundles.py,sha256=oj_OpxDnTRSX782aWSGsttnybrO3cZh3Mtk_NiLZiOs,907
@@ -611,8 +613,10 @@ cumulusci/tasks/tests/test_pushfails.py,sha256=9JG9D0iD4dR-1fKheaRN7BEy3lzzuOKeR
 cumulusci/tasks/tests/test_salesforce.py,sha256=yCGtuHapxyAEmXQhuF2g2fh2naknTu7Md4OfEJQvGAA,2594
 cumulusci/tasks/tests/test_sfdx.py,sha256=oUbHo28d796m5RuskXMLitJw2rCLjjXIfxggzr4gsso,3545
 cumulusci/tasks/tests/test_util.py,sha256=D1T0QnvPTS0PHeZWo2xiVgE1jVTYcLzGTGHwEIoVmxk,7296
-cumulusci/tasks/utility/env_management.py,sha256=RIxciQHPVMnJjwNvYkeq30QrMISagF4qx2zSRiXjExQ,5382
-cumulusci/tasks/utility/tests/test_env_management.py,sha256=e0cVAohNzpDUPDvS5LrIcd2Cqv0pkQ_KYvjX6qsREj8,8155
+cumulusci/tasks/utility/data_management.py,sha256=7DbK0uxMxj_e4WuH08gWFVxr_ZBMrvHvumHnM_oi2YM,443
+cumulusci/tasks/utility/env_management.py,sha256=hJX6ySEiXD2oFW38JqbGQKMj89ucxdSBsPwytSdkgO8,6591
+cumulusci/tasks/utility/tests/test_data_management.py,sha256=f3F1yFikaNEkzllMXZa67gNX0T_PCC-4zEoL8kUII_Q,1363
+cumulusci/tasks/utility/tests/test_env_management.py,sha256=fw34meWGOe1YYZO449MMCi2O7BgSaOA_I_wScrIr1Uk,8702
 cumulusci/tasks/vcs/__init__.py,sha256=ZzpMZnhooXZ6r_ywBVTS3UNw9uMcXW6h33LylRqTDK0,700
 cumulusci/tasks/vcs/commit_status.py,sha256=hgPUVHeQyIfMsCuwrw2RI-ufnbjdRARc6HI3BEgdcxI,2332
 cumulusci/tasks/vcs/create_commit_status.py,sha256=kr_OFM3J32jxusS1og-K91Kl1F_Nr7SlevRsJKBhifs,1565
@@ -738,9 +742,9 @@ cumulusci/vcs/tests/dummy_service.py,sha256=RltOUpMIhSDNrfxk0LhLqlH4ppC0sK6NC2cO
 cumulusci/vcs/tests/test_vcs_base.py,sha256=9mp6uZ3lTxY4onjUNCucp9N9aB3UylKS7_2Zu_hdAZw,24331
 cumulusci/vcs/tests/test_vcs_bootstrap.py,sha256=N0NA48-rGNIIjY3Z7PtVnNwHObSlEGDk2K55TQGI8g4,27954
 cumulusci/vcs/utils/__init__.py,sha256=py4fEcHM7Vd0M0XWznOlywxaeCtG3nEVGmELmEKVGU8,869
-cumulusci_plus-5.0.16.dist-info/METADATA,sha256=1w8L_cNeKkI7tHu_r8PY7nltM-adAck3ZpmjDqihHCk,5773
-cumulusci_plus-5.0.16.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-cumulusci_plus-5.0.16.dist-info/entry_points.txt,sha256=nTtu04b9iLXhzADcTrb5PwmdXE6e2MTUAMh9OK6Z2pg,80
-cumulusci_plus-5.0.16.dist-info/licenses/AUTHORS.rst,sha256=PvewjKImdKPhhJ6xR2EEZ4T7GbpY2ZeAeyWm2aLtiMQ,676
-cumulusci_plus-5.0.16.dist-info/licenses/LICENSE,sha256=NFsF_s7RVXk2dU6tmRAN8wF45pnD98VZ5IwqOsyBcaU,1499
-cumulusci_plus-5.0.16.dist-info/RECORD,,
+cumulusci_plus-5.0.18.dist-info/METADATA,sha256=EjWQpoxW3IMvVViclvXJR9WyKkDlsnxTxZrsX6m0Zwk,5769
+cumulusci_plus-5.0.18.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+cumulusci_plus-5.0.18.dist-info/entry_points.txt,sha256=nTtu04b9iLXhzADcTrb5PwmdXE6e2MTUAMh9OK6Z2pg,80
+cumulusci_plus-5.0.18.dist-info/licenses/AUTHORS.rst,sha256=PvewjKImdKPhhJ6xR2EEZ4T7GbpY2ZeAeyWm2aLtiMQ,676
+cumulusci_plus-5.0.18.dist-info/licenses/LICENSE,sha256=NFsF_s7RVXk2dU6tmRAN8wF45pnD98VZ5IwqOsyBcaU,1499
+cumulusci_plus-5.0.18.dist-info/RECORD,,