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

cumulusci/tasks/bulkdata/tests/test_select_utils.py

@@ -1,3 +1,5 @@
+import sys
+
 import pytest
 
 from cumulusci.tasks.bulkdata.select_utils import (
@@ -618,6 +620,14 @@ def test_vectorize_records_mixed_numerical_boolean_categorical():
     not PANDAS_AVAILABLE or not OPTIONAL_DEPENDENCIES_AVAILABLE,
     reason="requires optional dependencies for annoy",
 )
+@pytest.mark.skipif(
+    sys.platform == "darwin" and sys.version_info[:2] in [(3, 11), (3, 13)],
+    reason="Annoy library has known compatibility issues on macOS with Python 3.11 and 3.13",
+)
+@pytest.mark.skipif(
+    sys.platform == "linux" and sys.version_info[:2] == (3, 12),
+    reason="Annoy library has known compatibility issues on Linux with Python 3.12",
+)
 def test_annoy_post_process():
     # Test data
     load_records = [["Alice", "Engineer"], ["Bob", "Doctor"]]
@@ -648,6 +658,14 @@ def test_annoy_post_process():
     not PANDAS_AVAILABLE or not OPTIONAL_DEPENDENCIES_AVAILABLE,
     reason="requires optional dependencies for annoy",
 )
+@pytest.mark.skipif(
+    sys.platform == "darwin" and sys.version_info[:2] in [(3, 11), (3, 13)],
+    reason="Annoy library has known compatibility issues on macOS with Python 3.11 and 3.13",
+)
+@pytest.mark.skipif(
+    sys.platform == "linux" and sys.version_info[:2] == (3, 12),
+    reason="Annoy library has known compatibility issues on Linux with Python 3.12",
+)
 def test_annoy_post_process__insert_records():
     # Test data
     load_records = [["Alice", "Engineer"], ["Bob", "Doctor"]]
@@ -689,6 +707,18 @@ def test_annoy_post_process__insert_records():
         assert insert_record in [["Alice", "Engineer"], ["Bob", "Doctor"]]
 
 
+@pytest.mark.skipif(
+    not PANDAS_AVAILABLE or not OPTIONAL_DEPENDENCIES_AVAILABLE,
+    reason="requires optional dependencies for annoy",
+)
+@pytest.mark.skipif(
+    sys.platform == "darwin" and sys.version_info[:2] in [(3, 11), (3, 13)],
+    reason="Annoy library has known compatibility issues on macOS with Python 3.11 and 3.13",
+)
+@pytest.mark.skipif(
+    sys.platform == "linux" and sys.version_info[:2] == (3, 12),
+    reason="Annoy library has known compatibility issues on Linux with Python 3.12",
+)
 def test_annoy_post_process__no_query_records():
     # Test data
     load_records = [["Alice", "Engineer"], ["Bob", "Doctor"]]
@@ -721,6 +751,14 @@ def test_annoy_post_process__no_query_records():
     not PANDAS_AVAILABLE or not OPTIONAL_DEPENDENCIES_AVAILABLE,
     reason="requires optional dependencies for annoy",
 )
+@pytest.mark.skipif(
+    sys.platform == "darwin" and sys.version_info[:2] in [(3, 11), (3, 13)],
+    reason="Annoy library has known compatibility issues on macOS with Python 3.11 and 3.13",
+)
+@pytest.mark.skipif(
+    sys.platform == "linux" and sys.version_info[:2] == (3, 12),
+    reason="Annoy library has known compatibility issues on Linux with Python 3.12",
+)
 def test_annoy_post_process__insert_records_with_polymorphic_fields():
     # Test data
     load_records = [
@@ -778,6 +816,14 @@ def test_annoy_post_process__insert_records_with_polymorphic_fields():
     not PANDAS_AVAILABLE or not OPTIONAL_DEPENDENCIES_AVAILABLE,
     reason="requires optional dependencies for annoy",
 )
+@pytest.mark.skipif(
+    sys.platform == "darwin" and sys.version_info[:2] in [(3, 11), (3, 13)],
+    reason="Annoy library has known compatibility issues on macOS with Python 3.11 and 3.13",
+)
+@pytest.mark.skipif(
+    sys.platform == "linux" and sys.version_info[:2] == (3, 12),
+    reason="Annoy library has known compatibility issues on Linux with Python 3.12",
+)
 def test_single_record_match_annoy_post_process():
     # Mock data where only the first query record matches the first load record
     load_records = [["Alice", "Engineer"], ["Bob", "Doctor"]]

cumulusci/tasks/bulkdata/tests/test_snowfakery.py

@@ -824,6 +824,139 @@ class TestSnowfakery:
                 "Account",
             }
 
+    @mock.patch(
+        "cumulusci.tasks.bulkdata.snowfakery.Snowfakery._run_generate_and_load_subtask"
+    )
+    def test_validate_only_mode(self, mock_subtask, create_task):
+        """Test that validate_only mode validates without loading data"""
+        from cumulusci.tasks.bulkdata.mapping_parser import ValidationResult
+
+        # Mock subtask return value
+        validation_result = ValidationResult()
+        mock_subtask.return_value = {"validation_result": validation_result}
+
+        task = create_task(
+            Snowfakery,
+            {
+                "recipe": sample_yaml,
+                "validate_only": True,
+            },
+        )
+
+        task()
+
+        # Verify subtask was called with validate_only=True
+        mock_subtask.assert_called_once()
+        call_args = mock_subtask.call_args
+        assert call_args.kwargs.get("validate_only")
+
+        # Verify return values contain validation_result
+        assert "validation_result" in task.return_values
+        assert task.return_values["validation_result"] == validation_result
+
+    @mock.patch(
+        "cumulusci.tasks.bulkdata.snowfakery.Snowfakery._run_generate_and_load_subtask"
+    )
+    def test_validate_only_with_errors(self, mock_subtask, create_task):
+        """Test that validate_only mode returns errors without raising exception"""
+        from cumulusci.tasks.bulkdata.mapping_parser import ValidationResult
+
+        # Mock ValidationResult with errors
+        validation_result = ValidationResult()
+        validation_result.add_error("Test error: Field does not exist")
+        validation_result.add_warning("Test warning: Field has no permissions")
+        mock_subtask.return_value = {"validation_result": validation_result}
+
+        task = create_task(
+            Snowfakery,
+            {
+                "recipe": sample_yaml,
+                "validate_only": True,
+            },
+        )
+
+        # Should not raise exception even with errors
+        task()
+
+        # Verify subtask was called
+        mock_subtask.assert_called_once()
+
+        # Verify return values contain validation_result with errors
+        assert "validation_result" in task.return_values
+        assert task.return_values["validation_result"].has_errors()
+        assert len(task.return_values["validation_result"].errors) == 1
+        assert len(task.return_values["validation_result"].warnings) == 1
+
+    def test_validate_only_false_loads_data(self, mock_load_data, create_task):
+        """Test that validate_only=False performs normal data loading"""
+        task = create_task(
+            Snowfakery,
+            {
+                "recipe": sample_yaml,
+                "validate_only": False,
+            },
+        )
+
+        task()
+
+        # Verify load WAS called
+        assert len(mock_load_data.mock_calls) > 0
+
+        # Verify return values do not contain validation_result
+        assert "validation_result" not in task.return_values
+
+    @mock.patch(
+        "cumulusci.tasks.bulkdata.snowfakery.Snowfakery._run_generate_and_load_subtask"
+    )
+    def test_validate_only_with_working_directory(self, mock_subtask, snowfakery):
+        """Test that validate_only respects working_directory option"""
+        from cumulusci.tasks.bulkdata.mapping_parser import ValidationResult
+
+        validation_result = ValidationResult()
+        mock_subtask.return_value = {"validation_result": validation_result}
+
+        with TemporaryDirectory() as t:
+            working_dir = Path(t) / "snowfakery_validation"
+            task = snowfakery(
+                recipe=sample_yaml,
+                validate_only=True,
+                working_directory=str(working_dir),
+            )
+
+            task()
+
+            # Verify subtask was called
+            mock_subtask.assert_called_once()
+
+            # Verify working directory was created
+            assert working_dir.exists()
+
+            # Verify return values contain validation_result
+            assert "validation_result" in task.return_values
+
+    @mock.patch(
+        "cumulusci.tasks.bulkdata.snowfakery.Snowfakery._run_generate_and_load_subtask"
+    )
+    def test_validate_only_skips_channels_and_queues(self, mock_subtask, create_task):
+        """Test that validate_only does not set up channels and queues"""
+        from cumulusci.tasks.bulkdata.mapping_parser import ValidationResult
+
+        validation_result = ValidationResult()
+        mock_subtask.return_value = {"validation_result": validation_result}
+
+        task = create_task(
+            Snowfakery,
+            {
+                "recipe": sample_yaml,
+                "validate_only": True,
+            },
+        )
+
+        task()
+
+        # Verify queue_manager was never created
+        assert not hasattr(task, "queue_manager")
+
     @mock.patch("cumulusci.tasks.bulkdata.snowfakery.MIN_PORTION_SIZE", 2)
     def test_serial_mode(self, mock_load_data, create_task):
         task = create_task(

cumulusci/tasks/create_package_version.py

@@ -3,9 +3,9 @@ import io
 import json
 import pathlib
 import zipfile
-from typing import List, Optional
+from typing import Dict, List, Optional, Union
 
-from pydantic import BaseModel, validator
+from pydantic.v1 import BaseModel, validator
 from simple_salesforce.exceptions import SalesforceMalformedRequest
 
 from cumulusci.core.config.util import get_devhub_config
@@ -29,7 +29,7 @@ from cumulusci.core.exceptions import (
     VcsException,
 )
 from cumulusci.core.sfdx import convert_sfdx_source
-from cumulusci.core.utils import process_bool_arg
+from cumulusci.core.utils import process_bool_arg, process_list_arg
 from cumulusci.core.versions import PackageType, PackageVersionNumber, VersionTypeEnum
 from cumulusci.salesforce_api.package_zip import (
     BasePackageZipBuilder,
@@ -38,6 +38,10 @@ from cumulusci.salesforce_api.package_zip import (
 from cumulusci.salesforce_api.utils import get_simple_salesforce_connection
 from cumulusci.tasks.salesforce.BaseSalesforceApiTask import BaseSalesforceApiTask
 from cumulusci.tasks.salesforce.org_settings import build_settings_package
+from cumulusci.tasks.utility.copyContents import (
+    clean_temp_directory,
+    consolidate_metadata,
+)
 from cumulusci.utils.salesforce.soql import (
     format_subscriber_package_version_where_clause,
 )
@@ -68,6 +72,11 @@ class PackageConfig(BaseModel):
     version_name: str
     version_base: Optional[str] = None
     version_type: VersionTypeEnum = VersionTypeEnum.minor
+    apex_test_access: Optional[dict[str, list[str]]] = None
+    package_metadata_access: Optional[dict[str, list[str]]] = None
+    unpackaged_metadata_path: Optional[
+        Union[str, List[str], Dict[str, Union[str, List[str]]]]
+    ] = None
 
     @validator("org_dependent")
     def org_dependent_must_be_unlocked(cls, v, values):
@@ -87,6 +96,20 @@ class PackageConfig(BaseModel):
             raise ValueError("Only managed packages can have an uninstall script.")
         return v
 
+    @validator("apex_test_access")
+    def apex_test_access_must_be_managed(cls, v, values):
+        if v and values["package_type"] != PackageTypeEnum.managed:
+            raise ValueError(
+                "Only managed packages can have Apex Test Access. Assign permission sets and permission set licenses to the user in context when your Apex tests run at package version creation."
+            )
+        return v
+
+    @validator("package_metadata_access")
+    def package_metadata_access_must_be_managed(cls, v, values):
+        if v and values["package_type"] != PackageTypeEnum.managed:
+            raise ValueError("Only managed packages can have Package Metadata Access.")
+        return v
+
 
 class CreatePackageVersion(BaseSalesforceApiTask):
     """Creates a new second-generation package version.
@@ -114,15 +137,21 @@ class CreatePackageVersion(BaseSalesforceApiTask):
         "version_base": {
             "description": "The version number to use as a base before incrementing. "
             "Optional; defaults to the highest existing version number of this package. "
-            "Can be set to ``latest_vcs_release`` to use the version of the most recent release published to GitHub."
+            "Can be set to ``latest_vcs_release`` to use the version of the most recent release published to VCS."
+            "If version_number is set, version_base and version_type will be ignored"
         },
         "version_type": {
             "description": "The part of the version number to increment. "
             "Options are major, minor, patch, build.  Defaults to build"
+            "If version_number is set, version_base and version_type will be ignored"
+        },
+        "version_number": {
+            "description": "Set a fixed version number, if not using version_base and version_type"
         },
         "skip_validation": {
             "description": "If true, skip validation of the package version. Default: false. "
             "Skipping validation creates packages more quickly, but they cannot be promoted for release."
+            "And package version is created without reference to dependencies."
         },
         "org_dependent": {
             "description": "If true, create an org-dependent unlocked package. Default: false."
@@ -156,6 +185,17 @@ class CreatePackageVersion(BaseSalesforceApiTask):
             "description": "If True, create unlocked packages for unpackaged metadata in this project and dependencies. "
             "Defaults to False."
         },
+        "dependencies": {
+            "description": "The list of dependencies to use when creating the package version. Defaults to None."
+            "If not provided, the dependencies will be resolved using the resolution_strategy."
+            "The format should be a pcakge version Ids i.e '04t...,04t...'"
+        },
+        "async_validation": {
+            "description": "If True, validate the package version asynchronously. Defaults to False. You also can't specify both skip validation and async validation at the same time."
+        },
+        "is_dev_use_pkg_zip_requested": {
+            "description": "If True, request a dev use package zip. Defaults to False. If true, a downloadable package zip file containing package metadata is generated when a new package version is created."
+        },
     }
 
     def _init_options(self, kwargs):
@@ -190,16 +230,40 @@ class CreatePackageVersion(BaseSalesforceApiTask):
             version_name=self.options.get("version_name") or "Release",
             version_base=self.options.get("version_base"),
             version_type=self.options.get("version_type") or VersionTypeEnum("build"),
+            apex_test_access=self.project_config.project__package__apex_test_access,
+            package_metadata_access=self.project_config.project__package__package_metadata_access,
+            unpackaged_metadata_path=self.project_config.project__package__unpackaged_metadata_path,
         )
         self.options["skip_validation"] = process_bool_arg(
             self.options.get("skip_validation") or False
         )
+        self.options["async_validation"] = process_bool_arg(
+            self.options.get("async_validation") or False
+        )
+        self.options["is_dev_use_pkg_zip_requested"] = process_bool_arg(
+            self.options.get("is_dev_use_pkg_zip_requested") or False
+        )
         self.options["force_upload"] = process_bool_arg(
             self.options.get("force_upload") or False
         )
         self.options["create_unlocked_dependency_packages"] = process_bool_arg(
             self.options.get("create_unlocked_dependency_packages") or False
         )
+        self.options["version_number"] = (
+            PackageVersionNumber.parse(
+                self.options.get("version_number"), package_type=PackageType.SECOND_GEN
+            )
+            if self.options.get("version_number")
+            else None
+        )
+        self.options["dependencies"] = (
+            [
+                {"subscriberPackageVersionId": x}
+                for x in process_list_arg(self.options.get("dependencies"))
+            ]
+            if self.options.get("dependencies")
+            else None
+        )
 
     def _init_task(self):
         self.tooling = get_simple_salesforce_connection(
@@ -223,13 +287,7 @@ class CreatePackageVersion(BaseSalesforceApiTask):
         self.return_values["package_id"] = self.package_id
 
         # submit request to create package version
-        options = {
-            "package_type": self.package_config.package_type.value,
-            "namespace_inject": self.package_config.namespace,
-            "namespaced_org": self.package_config.namespace is not None,
-        }
-        if "static_resource_path" in self.options:
-            options["static_resource_path"] = self.options["static_resource_path"]
+        options = self._get_package_zip_builder_options()
 
         package_zip_builder = None
         with convert_sfdx_source(
@@ -292,6 +350,20 @@ class CreatePackageVersion(BaseSalesforceApiTask):
         self.logger.info(f"  Version Number: {self.return_values['version_number']}")
         self.logger.info(f"  Dependencies: {self.return_values['dependencies']}")
 
+    def _get_package_zip_builder_options(self):
+        if not self.package_config:
+            return {}
+
+        options = {
+            "package_type": self.package_config.package_type.value,
+            "namespace_inject": self.package_config.namespace,
+            "namespaced_org": self.package_config.namespace is not None,
+        }
+        if "static_resource_path" in self.options:
+            options["static_resource_path"] = self.options["static_resource_path"]
+
+        return options
+
     def _get_or_create_package(self, package_config: PackageConfig):
         """Find or create the Package2
 
@@ -384,9 +456,13 @@ class CreatePackageVersion(BaseSalesforceApiTask):
                     return res["records"][0]["Id"]
 
             # Create the package descriptor
-            version_number = self._get_base_version_number(
+            version_number = self.options.get(
+                "version_number"
+            ) or self._get_base_version_number(
                 package_config.version_base, package_id
-            ).increment(package_config.version_type)
+            ).increment(
+                package_config.version_type
+            )
 
             package_descriptor = {
                 "id": package_id,
@@ -403,6 +479,57 @@ class CreatePackageVersion(BaseSalesforceApiTask):
             if package_config.uninstall_script:
                 package_descriptor["uninstallScript"] = package_config.uninstall_script
 
+            if package_config.apex_test_access:
+                if "permission_set_names" in package_config.apex_test_access:
+                    perm_sets = package_config.apex_test_access["permission_set_names"]
+                    if isinstance(perm_sets, str):
+                        perm_sets = perm_sets.split(",")
+
+                    package_descriptor["permissionSetNames"] = [
+                        s.strip() for s in perm_sets
+                    ]
+                if "permission_set_license_names" in package_config.apex_test_access:
+                    psl = package_config.apex_test_access[
+                        "permission_set_license_names"
+                    ]
+                    if isinstance(psl, str):
+                        psl = psl.split(",")
+                    package_descriptor["permissionSetLicenseDeveloperNames"] = [
+                        s.strip() for s in psl
+                    ]
+
+            if package_config.package_metadata_access:
+                if "permission_set_names" in package_config.package_metadata_access:
+                    perm_sets = package_config.package_metadata_access[
+                        "permission_set_names"
+                    ]
+                    if isinstance(perm_sets, str):
+                        perm_sets = perm_sets.split(",")
+
+                    if isinstance(perm_sets, list):
+                        package_descriptor["packageMetadataPermissionSetNames"] = [
+                            s.strip() for s in perm_sets
+                        ]
+
+                if (
+                    "permission_set_license_names"
+                    in package_config.package_metadata_access
+                ):
+                    psl = package_config.package_metadata_access[
+                        "permission_set_license_names"
+                    ]
+                    if isinstance(psl, str):
+                        psl = psl.split(",")
+                    if isinstance(psl, list):
+                        package_descriptor[
+                            "packageMetadataPermissionSetLicenseNames"
+                        ] = [s.strip() for s in psl]
+
+            if package_config.unpackaged_metadata_path:
+                self._get_unpackaged_metadata_path(
+                    package_config.unpackaged_metadata_path, version_info
+                )
+
             # Add org shape
             with open(self.org_config.config_file, "r") as f:
                 scratch_org_def = json.load(f)
@@ -442,7 +569,9 @@ class CreatePackageVersion(BaseSalesforceApiTask):
                 and not is_dependency
             ):
                 self.logger.info("Determining dependencies for package")
-                dependencies = self._get_dependencies()
+                dependencies = (
+                    self.options.get("dependencies") or self._get_dependencies()
+                )
             if dependencies:
                 package_descriptor["dependencies"] = dependencies
 
@@ -458,12 +587,25 @@ class CreatePackageVersion(BaseSalesforceApiTask):
         )
         request = {
             "Package2Id": package_id,
-            "SkipValidation": skip_validation,
             "Tag": f"hash:{package_hash}",
             "VersionInfo": version_info,
-            "CalculateCodeCoverage": not skip_validation,
+            "IsDevUsePkgZipRequested": self.options.get("is_dev_use_pkg_zip_requested"),
         }
 
+        if self.options.get("async_validation") is not True:
+            request.update(
+                {
+                    "SkipValidation": skip_validation,
+                    "CalculateCodeCoverage": not skip_validation,
+                }
+            )
+        else:
+            request.update(
+                {
+                    "AsyncValidation": True,
+                }
+            )
+
         install_key = self.options.get("install_key")
         if install_key:
             request["InstallKey"] = install_key
@@ -785,3 +927,35 @@ class CreatePackageVersion(BaseSalesforceApiTask):
             ]
 
         return []
+
+    def _get_unpackaged_metadata_path(
+        self,
+        metadata_path: Union[str, List[str], Dict[str, Union[str, List[str]]]],
+        version_info: zipfile.ZipFile,
+    ) -> zipfile.ZipFile:
+
+        final_metadata_path, file_count = consolidate_metadata(
+            metadata_path, self.project_config.repo_root, logger=self.logger
+        )
+
+        if file_count == 0:
+            return version_info
+
+        # Use the consolidated temp directory with convert_sfdx_source
+        with convert_sfdx_source(
+            final_metadata_path, "unpackaged-metadata-package", self.logger
+        ) as src_path:
+            unpackaged_metadata_zip_builder = MetadataPackageZipBuilder(
+                path=src_path,
+                name="unpackaged-metadata-package",
+                context=self.context,
+                options=self._get_package_zip_builder_options(),
+            )
+            version_info.writestr(
+                "unpackaged-metadata-package.zip",
+                unpackaged_metadata_zip_builder.as_bytes(),
+            )
+
+        clean_temp_directory(final_metadata_path)
+
+        return version_info

cumulusci/tasks/datadictionary.py

@@ -5,7 +5,7 @@ from typing import List, Optional, Union
 from unittest.mock import Mock
 from zipfile import ZipFile
 
-from pydantic import BaseModel
+from pydantic.v1 import BaseModel
 
 from cumulusci.core.config.project_config import BaseProjectConfig
 from cumulusci.core.dependencies import parse_dependencies

cumulusci/tasks/metadata_etl/__init__.py

@@ -6,6 +6,7 @@ from cumulusci.tasks.metadata_etl.base import (
     MetadataOperation,
     UpdateMetadataFirstChildTextTask,
 )
+from cumulusci.tasks.metadata_etl.applications import AddProfileActionOverrides
 from cumulusci.tasks.metadata_etl.duplicate_rules import SetDuplicateRuleStatus
 from cumulusci.tasks.metadata_etl.layouts import AddRelatedLists
 from cumulusci.tasks.metadata_etl.objects import SetObjectSettings
@@ -18,6 +19,7 @@ flake8 = (
     BaseMetadataSynthesisTask,
     BaseMetadataTransformTask,
     MetadataSingleEntityTransformTask,
+    AddProfileActionOverrides,
     AddRelatedLists,
     AddPermissionSetPermissions,
     AddValueSetEntries,