cumulusci-plus 5.0.21__py3-none-any.whl → 5.0.43__py3-none-any.whl

cumulusci/tasks/salesforce/tests/test_Deploy.py

@@ -6,10 +6,11 @@ from unittest import mock
 
 import pytest
 
+from cumulusci.core.config import BaseProjectConfig, UniversalConfig
 from cumulusci.core.exceptions import TaskOptionsError
 from cumulusci.core.flowrunner import StepSpec
 from cumulusci.core.source_transforms.transforms import CleanMetaXMLTransform
-from cumulusci.tasks.salesforce import Deploy
+from cumulusci.tasks.salesforce import Deploy, DeployUnpackagedMetadata
 from cumulusci.utils import temporary_dir, touch
 
 from .util import create_task
@@ -468,3 +469,317 @@ class TestDeploy:
         )
 
         assert all(s["kind"] == "metadata" for s in task.freeze(step))
+
+
+class TestDeployUnpackagedMetadata:
+    @mock.patch(
+        "cumulusci.core.config.org_config.OrgConfig.installed_packages", return_value=[]
+    )
+    def test_task_options_excludes_path(self, mock_org_config):
+        """Test that path is removed from task_options."""
+        assert "path" not in DeployUnpackagedMetadata.task_options
+        # Verify other options are still present
+        assert "check_only" in DeployUnpackagedMetadata.task_options
+        assert "namespace_inject" in DeployUnpackagedMetadata.task_options
+
+    @mock.patch(
+        "cumulusci.core.config.org_config.OrgConfig.installed_packages", return_value=[]
+    )
+    @mock.patch("cumulusci.tasks.salesforce.Deploy.consolidate_metadata")
+    def test_init_options_sets_path_from_consolidate_metadata(
+        self, mock_consolidate, mock_org_config
+    ):
+        """Test that _init_options sets path using consolidate_metadata."""
+        with temporary_dir() as path:
+            mock_consolidate.return_value = (path, 1)
+            universal_config = UniversalConfig()
+            project_config = BaseProjectConfig(
+                universal_config,
+                config={"noyaml": True, "project": {"package": {}}},
+                repo_info={"root": path},
+            )
+            project_config.project__package__unpackaged_metadata_path = "unpackaged/pre"
+
+            task = create_task(
+                DeployUnpackagedMetadata,
+                {"unmanaged": True},
+                project_config=project_config,
+            )
+
+            mock_consolidate.assert_called_once_with("unpackaged/pre", path)
+            assert task.options["path"] == path
+
+    @mock.patch(
+        "cumulusci.core.config.org_config.OrgConfig.installed_packages", return_value=[]
+    )
+    @mock.patch("cumulusci.tasks.salesforce.Deploy.consolidate_metadata")
+    def test_init_options_calls_consolidate_metadata_with_correct_params(
+        self, mock_consolidate, mock_org_config
+    ):
+        """Test that consolidate_metadata is called with correct parameters."""
+        with temporary_dir() as path:
+            consolidated_path = os.path.join(path, "consolidated")
+            os.makedirs(consolidated_path)
+            mock_consolidate.return_value = (consolidated_path, 5)
+
+            repo_root = "/repo/root"
+            universal_config = UniversalConfig()
+            project_config = BaseProjectConfig(
+                universal_config,
+                config={"noyaml": True, "project": {"package": {}}},
+                repo_info={"root": repo_root},
+            )
+            project_config.project__package__unpackaged_metadata_path = "unpackaged/pre"
+
+            task = create_task(
+                DeployUnpackagedMetadata,
+                {"unmanaged": True},
+                project_config=project_config,
+            )
+
+            mock_consolidate.assert_called_once_with("unpackaged/pre", repo_root)
+            assert task.options["path"] == consolidated_path
+
+    @mock.patch(
+        "cumulusci.core.config.org_config.OrgConfig.installed_packages", return_value=[]
+    )
+    @mock.patch("cumulusci.tasks.salesforce.Deploy.consolidate_metadata")
+    @mock.patch("cumulusci.tasks.salesforce.Deploy.clean_temp_directory")
+    def test_run_task_calls_parent_and_cleans_up(
+        self, mock_clean_temp, mock_consolidate, mock_org_config
+    ):
+        """Test that _run_task calls parent's _run_task and cleans up."""
+        with temporary_dir() as path:
+            touch("package.xml")
+            consolidated_path = os.path.join(path, "consolidated")
+            os.makedirs(consolidated_path)
+            mock_consolidate.return_value = (consolidated_path, 3)
+
+            universal_config = UniversalConfig()
+            project_config = BaseProjectConfig(
+                universal_config,
+                config={"noyaml": True, "project": {"package": {}}},
+                repo_info={"root": path},
+            )
+            project_config.project__package__unpackaged_metadata_path = "unpackaged/pre"
+
+            task = create_task(
+                DeployUnpackagedMetadata,
+                {"unmanaged": True},
+                project_config=project_config,
+            )
+
+            # Mock parent's _run_task to avoid actual deployment
+            task._get_api = mock.Mock(return_value=mock.Mock())
+            task._run_task()
+
+            # Verify cleanup was called
+            mock_clean_temp.assert_called_once_with(consolidated_path)
+
+    @mock.patch(
+        "cumulusci.core.config.org_config.OrgConfig.installed_packages", return_value=[]
+    )
+    @mock.patch("cumulusci.tasks.salesforce.Deploy.consolidate_metadata")
+    @mock.patch("cumulusci.tasks.salesforce.Deploy.clean_temp_directory")
+    def test_run_task_cleans_up_on_exception(
+        self, mock_clean_temp, mock_consolidate, mock_org_config
+    ):
+        """Test that cleanup happens even when parent's _run_task raises exception."""
+        with temporary_dir() as path:
+            consolidated_path = os.path.join(path, "consolidated")
+            os.makedirs(consolidated_path)
+            mock_consolidate.return_value = (consolidated_path, 2)
+
+            universal_config = UniversalConfig()
+            project_config = BaseProjectConfig(
+                universal_config,
+                config={"noyaml": True, "project": {"package": {}}},
+                repo_info={"root": path},
+            )
+            project_config.project__package__unpackaged_metadata_path = "unpackaged/pre"
+
+            task = create_task(
+                DeployUnpackagedMetadata,
+                {"unmanaged": True},
+                project_config=project_config,
+            )
+
+            # Mock parent's _run_task to raise an exception
+            task._get_api = mock.Mock(side_effect=Exception("Test exception"))
+
+            with pytest.raises(Exception, match="Test exception"):
+                task._run_task()
+
+            # Verify cleanup was still called despite exception
+            mock_clean_temp.assert_called_once_with(consolidated_path)
+
+    @mock.patch(
+        "cumulusci.core.config.org_config.OrgConfig.installed_packages", return_value=[]
+    )
+    @mock.patch("cumulusci.tasks.salesforce.Deploy.consolidate_metadata")
+    def test_init_options_inherits_parent_options(
+        self, mock_consolidate, mock_org_config
+    ):
+        """Test that _init_options properly calls parent's _init_options."""
+        with temporary_dir() as path:
+            consolidated_path = os.path.join(path, "consolidated")
+            os.makedirs(consolidated_path)
+            mock_consolidate.return_value = (consolidated_path, 4)
+
+            universal_config = UniversalConfig()
+            project_config = BaseProjectConfig(
+                universal_config,
+                config={"noyaml": True, "project": {"package": {}}},
+                repo_info={"root": path},
+            )
+            project_config.project__package__unpackaged_metadata_path = "unpackaged/pre"
+
+            task = create_task(
+                DeployUnpackagedMetadata,
+                {
+                    "unmanaged": True,
+                    "check_only": True,
+                    "test_level": "RunLocalTests",
+                },
+                project_config=project_config,
+            )
+
+            # Verify parent options were processed
+            assert task.check_only is True
+            assert task.test_level == "RunLocalTests"
+            # Verify path was set from consolidate_metadata
+            assert task.options["path"] == consolidated_path
+
+    @mock.patch(
+        "cumulusci.core.config.org_config.OrgConfig.installed_packages", return_value=[]
+    )
+    @mock.patch("cumulusci.tasks.salesforce.Deploy.consolidate_metadata")
+    @pytest.mark.parametrize("rest_deploy", [True, False])
+    def test_inherits_rest_deploy_option(
+        self, mock_consolidate, mock_org_config, rest_deploy
+    ):
+        """Test that rest_deploy option is properly inherited from parent."""
+        with temporary_dir() as path:
+            consolidated_path = os.path.join(path, "consolidated")
+            os.makedirs(consolidated_path)
+            mock_consolidate.return_value = (consolidated_path, 6)
+
+            universal_config = UniversalConfig()
+            project_config = BaseProjectConfig(
+                universal_config,
+                config={"noyaml": True, "project": {"package": {}}},
+                repo_info={"root": path},
+            )
+            project_config.project__package__unpackaged_metadata_path = "unpackaged/pre"
+
+            task = create_task(
+                DeployUnpackagedMetadata,
+                {"unmanaged": True, "rest_deploy": rest_deploy},
+                project_config=project_config,
+            )
+
+            assert task.rest_deploy == rest_deploy
+
+    @mock.patch(
+        "cumulusci.core.config.org_config.OrgConfig.installed_packages", return_value=[]
+    )
+    @mock.patch("cumulusci.tasks.salesforce.Deploy.consolidate_metadata")
+    def test_no_unpackaged_metadata_path(self, mock_consolidate, mock_org_config):
+        """Test that when unpackaged_metadata_path is None, consolidate_metadata is not called and path is not set."""
+        with temporary_dir() as path:
+            universal_config = UniversalConfig()
+            project_config = BaseProjectConfig(
+                universal_config,
+                config={"noyaml": True, "project": {"package": {}}},
+                repo_info={"root": path},
+            )
+            project_config.project__package__unpackaged_metadata_path = None
+
+            task = create_task(
+                DeployUnpackagedMetadata,
+                {},
+                project_config=project_config,
+            )
+
+            # Verify consolidate_metadata was not called
+            mock_consolidate.assert_not_called()
+            # When unpackaged_metadata_path is None, _init_options returns early
+            # so parent's _init_options is not called and options may not be initialized
+            # or path is not set if options exists
+            if hasattr(task, "options"):
+                assert "path" not in task.options
+
+    @mock.patch(
+        "cumulusci.core.config.org_config.OrgConfig.installed_packages", return_value=[]
+    )
+    def test_consolidate_metadata_integration(self, mock_org_config):
+        """Integration test that actually calls consolidate_metadata without mocking."""
+        with temporary_dir() as path:
+            # Create a realistic metadata structure
+            metadata_dir = os.path.join(path, "unpackaged", "pre")
+            os.makedirs(metadata_dir)
+
+            # Create package.xml
+            package_xml_path = os.path.join(metadata_dir, "package.xml")
+            with open(package_xml_path, "w") as f:
+                f.write(
+                    """<?xml version="1.0" encoding="UTF-8"?>
+<Package xmlns="http://soap.sforce.com/2006/04/metadata">
+    <types>
+        <members>*</members>
+        <name>ApexClass</name>
+    </types>
+    <version>60.0</version>
+</Package>"""
+                )
+
+            # Create some metadata files
+            classes_dir = os.path.join(metadata_dir, "classes")
+            os.makedirs(classes_dir)
+
+            # Create an Apex class
+            with open(os.path.join(classes_dir, "TestClass.cls"), "w") as f:
+                f.write("public class TestClass { }")
+
+            # Create an Apex class metadata file
+            with open(os.path.join(classes_dir, "TestClass.cls-meta.xml"), "w") as f:
+                f.write(
+                    """<?xml version="1.0" encoding="UTF-8"?>
+<ApexClass xmlns="http://soap.sforce.com/2006/04/metadata">
+    <apiVersion>60.0</apiVersion>
+    <status>Active</status>
+</ApexClass>"""
+                )
+
+            universal_config = UniversalConfig()
+            project_config = BaseProjectConfig(
+                universal_config,
+                config={"noyaml": True, "project": {"package": {}}},
+                repo_info={"root": path},
+            )
+            project_config.project__package__unpackaged_metadata_path = "unpackaged/pre"
+
+            # Create task without mocking consolidate_metadata
+            task = create_task(
+                DeployUnpackagedMetadata,
+                {"unmanaged": True},
+                project_config=project_config,
+            )
+
+            # Verify that path was set to a temporary directory (not the original)
+            assert task.options["path"] != metadata_dir
+            # The path should exist
+            assert os.path.exists(task.options["path"])
+            # The consolidated path should contain our files
+            consolidated_package_xml = os.path.join(task.options["path"], "package.xml")
+            assert os.path.exists(consolidated_package_xml)
+            # Verify the consolidated directory contains the classes directory
+            consolidated_classes_dir = os.path.join(task.options["path"], "classes")
+            assert os.path.exists(consolidated_classes_dir)
+            # Verify our test class exists in consolidated directory
+            assert os.path.exists(
+                os.path.join(consolidated_classes_dir, "TestClass.cls")
+            )
+            assert os.path.exists(
+                os.path.join(consolidated_classes_dir, "TestClass.cls-meta.xml")
+            )