launchpy 0.5.3__tar.gz → 0.5.4__tar.gz

{launchpy-0.5.3 → launchpy-0.5.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: launchpy
-Version: 0.5.3
+Version: 0.5.4
 Summary: Adobe Launch API wrapper
 Author-email: Julien Piccini <piccini.julien@gmail.com>
 License: Apache License 2.0

{launchpy-0.5.3 → launchpy-0.5.4}/docs/cli.md

@@ -533,9 +533,12 @@ Arguments:
 `-r`, `--regex`: Regex pattern to filter rules by name (partial match, non-case sensitive). This is an optional parameter, if not provided, all rules are synced.
 `-c`, `--create` : Flag. Create rules that do not exist in the destination property. Default False.
 `-p`, `--published` : Flag. Sync the latest published version of the rules. Default False.
+`-i`, `--ignore_disabled` : Optional boolean. Skip disabled source rules. Default False; a bare flag means True. With `-p`, checks the latest published source revision.
 
 ```bash
 synchronizer:Base_Property_Name> sync_rules -r "Rule Name" -c
+synchronizer:Base_Property_Name> sync_rules -i
+synchronizer:Base_Property_Name> sync_rules --ignore_disabled True -p
 ```
 
 #### sync_data_elements
@@ -544,9 +547,12 @@ Arguments:
 `-r`, `--regex`: Regex pattern to filter data elements by name (partial match, non-case sensitive). This is an optional parameter, if not provided, all data elements are synced.
 `-c`, `--create` : Flag. Create data elements that do not exist in the destination property. Default False.
 `-p`, `--published` : Flag. Sync the latest published version of the data elements. Default False.
+`-i`, `--ignore_disabled` : Optional boolean. Skip disabled source data elements. Default False; a bare flag means True. With `-p`, checks the latest published source revision.
 
 ```bash
 synchronizer:Base_Property_Name> sync_data_elements -r "Data Element Name" -c
+synchronizer:Base_Property_Name> sync_data_elements -i
+synchronizer:Base_Property_Name> sync_data_elements --ignore_disabled False
 ```
 
 #### sync_extensions

{launchpy-0.5.3 → launchpy-0.5.4}/docs/releases.md

@@ -3,6 +3,13 @@
 This page gathered the changes made between version of the launchpy module.\
 This has been started after the 0.3.0 release.\
 
+## 0.5.4
+* Fixing enabled state handling for rules, data elements, and extensions during synchronization. Before release, state enablement was respected only during -published synchronization.
+* Ensuring that the verbose flag correctly displays detailed information for all synchronized entities, including those with enabled state changes.
+* Adding the `ignore_disabled` flag to the synchronization commands to allow skipping disabled source entities.
+* Adding `-i` / `--ignore_disabled` flag to the CLI synchronization commands.
+
+
 ## 0.5.3
 * Adding optional `proxy` support to `configure`, `importConfigFile`, `createConfigFile` and JSON configuration files. A single proxy URL is used for both HTTP and HTTPS, with separate settings per organization.
 * Applying proxy settings to OAuth token acquisition and refresh, all API requests and their retries, and asynchronous rule-component downloads during `extractProperty`.

{launchpy-0.5.3 → launchpy-0.5.4}/docs/synchronizer.md

@@ -150,6 +150,7 @@ synchronizor.syncComponent('my Component Name',publishedVersion=True)
 #### Data Elements
 The method will replace the existing configuration of a data element by the template configuration.\
 Completely overriding the existing element configuration in the target properties.
+When a data element is created, its enabled state is updated if needed to match the selected source revision. The response from that update is retained in the target cache and library stack.
 
 #### Rules
 The method will delete all rule components existing in the Target property for that rule.\
@@ -198,6 +199,7 @@ Arguments:
 *  regex : OPTIONAL : If you want to filter the data elements to sync based on a regex pattern. Default: None (sync all data elements)
 *  forceCreation : OPTIONAL : If set to True, it will sync the data elements even if they do not exist in the target properties. If set to False, it will only sync the data elements that already exist in the target properties. Default: False.
 *  publishedVersion : OPTIONAL : If set to True, it will sync the latest published version of the data elements. Default: False.
+*  ignoreDisabled : OPTIONAL : If set to True, skip data elements whose selected source revision has `enabled=False`. Default: False.
 
 ## SyncRules
 It will synchronize the rules in the base property to the target properties.
@@ -205,7 +207,14 @@ Arguments:
 *  regex : OPTIONAL : If you want to filter the rules to sync based on a regex pattern. Default: None (sync all rules)
 *  forceCreation : OPTIONAL : If set to True, it will sync the rules even if they do not exist in the target properties. If set to False, it will only sync the rules that already exist in the target properties. Default: False.
 *  publishedVersion : OPTIONAL : If set to True, it will sync the latest published version of the rules. Default: False.
+*  ignoreDisabled : OPTIONAL : If set to True, skip rules whose selected source revision has `enabled=False`. Default: False.
 
+For both methods, `ignoreDisabled=True` checks the source revision being synchronized, not the target's enabled state. With `publishedVersion=True`, it checks the latest published source revision rather than the current draft. Disabled components are not created or updated, even with `forceCreation=True`, and retain an empty per-target dictionary in the returned results.
+
+```python
+synchronizor.syncRules(ignoreDisabled=True)
+synchronizor.syncDataElements(ignoreDisabled=True, publishedVersion=True)
+```
 
 ## createTargetsLibrary
 
@@ -238,6 +247,7 @@ Check if the component,from the base property, is synced to the different target
 It can also check for the Extensions.\
 It will return a dictionary with the key being the target property and the value being the result of the evaluation, such as {targetProperty: 'similar'} when component have same settings or {targetPropery : '<difference>'} when component do not have same settings.\
 See below for differences.\
+For rules and data elements, enabled-state differences are checked in both current and published modes. A matching configuration does not override an enabled-state difference with `"Similar"`. When a data element has multiple differences, they are returned together as a comma-separated message. Library dry runs use the same comparison logic.
 Arguments:
 * componentName : REQUIRED : the name of the component to compare
 * componentID : REQUIRED : the id of the component to compare

launchpy-0.5.4/launchpy/__version__.py

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

{launchpy-0.5.3 → launchpy-0.5.4}/launchpy/cli/__main__.py

@@ -595,10 +595,11 @@ class SynchronizerCLI(cmd.Cmd):
         parser.add_argument("-r", "--regex", help="Regex pattern to filter rules by name (partial match, non-case sensitive). Default None.", type=str, default=None)
         parser.add_argument("-c", "--create", help="Create rules that do not exist in the destination property. Default False.", action="store_true", default=False)
         parser.add_argument("-p", "--published", help="Sync the latest published version of the rules. Default False.", action="store_true", default=False)
+        parser.add_argument("-i", "--ignore_disabled", help="Skip disabled source rules. Default False. A bare flag means True.", type=str2bool, nargs="?", const=True, default=False)
         parser.add_argument("-v", "--verbose", help="Print detailed information about the sync process, including successes. Default False.", action="store_true", default=False)
         try:
             args = parser.parse_args(shlex.split(args))
-            result = self.synchronizer.syncRules(regex=args.regex, forceCreation=args.create, publishedVersion=args.published)
+            result = self.synchronizer.syncRules(regex=args.regex, forceCreation=args.create, publishedVersion=args.published, ignoreDisabled=args.ignore_disabled)
             for ruleName, targetResults in result.items():
                 for prop, message in (targetResults or {}).items():
                     if "does not exist" in message:
@@ -617,10 +618,11 @@ class SynchronizerCLI(cmd.Cmd):
         parser.add_argument("-r", "--regex", help="Regex pattern to filter data elements by name (partial match, non-case sensitive). Default None.", type=str, default=None)
         parser.add_argument("-c", "--create", help="Create data elements that do not exist in the destination property. Default False.", action="store_true", default=False)
         parser.add_argument("-p", "--published", help="Sync the latest published version of the data elements. Default False.", action="store_true", default=False)
+        parser.add_argument("-i", "--ignore_disabled", help="Skip disabled source data elements. Default False. A bare flag means True.", type=str2bool, nargs="?", const=True, default=False)
         parser.add_argument("-v", "--verbose", help="Print detailed information about the sync process, including successes. Default False.", action="store_true", default=False)
         try:
             args = parser.parse_args(shlex.split(args))
-            result = self.synchronizer.syncDataElements(regex=args.regex, forceCreation=args.create, publishedVersion=args.published)
+            result = self.synchronizer.syncDataElements(regex=args.regex, forceCreation=args.create, publishedVersion=args.published, ignoreDisabled=args.ignore_disabled)
             for deName, targetResults in result.items():
                 for prop, message in (targetResults or {}).items():
                     if "does not exist" in message:

{launchpy-0.5.3 → launchpy-0.5.4}/launchpy/synchronizer.py

@@ -263,6 +263,7 @@ class Synchronizer:
             timeout : OPTIONAL : The timeout to be used for the rule component. If not provided, the existing timeout will be used.
             libraryLinked : OPTIONAL : If you want to take a component ID that are associated to a specific library. Default: False. If set to True, the method will look for the component in the library and take the version linked to the library instead of the latest version in the property. Do not work for Extensions.
             verbose : OPTIONAL : If set to True, it will print the synchronization status of each property. Default: False.
+            ignoreDisabled : OPTIONAL : Skip disabled source rules and data elements, returning an empty dictionary. Uses the selected revision. Default: False.
         """
         timeout = kwargs.get('timeout',None)
         libraryLinked = kwargs.get('libraryLinked',False)
@@ -271,6 +272,10 @@ class Synchronizer:
             raise ValueError('Require a component Name of a component ID')
         response = {}
         cmp_baseDict = self.__prepareBaseComponent__(componentName=componentName,componentId=componentId,publishedVersion=publishedVersion,libraryLinked=libraryLinked)
+        if (kwargs.get('ignoreDisabled',False)
+                and cmp_baseDict['component']['type'] in ('rules','data_elements')
+                and not cmp_baseDict['component']['attributes']['enabled']):
+            return response
         ## handling the data element
         if cmp_baseDict['component']['type'] == 'data_elements':
             for target in list(self.targets.keys()):
@@ -288,6 +293,16 @@ class Synchronizer:
                 if len(self.target_configs.get(target,{}).get('inclComponents',[]))==0 or flagAllowList:
                     with self._target_locks[target]:
                         translatedComponent = self.translator.translate(target,data_element=cmp_baseDict['copy'])
+                        attributes = {
+                            "name" : translatedComponent['name'],
+                            "enabled" : translatedComponent["enabled"],
+                            "delegate_descriptor_id" : translatedComponent["descriptor"],
+                            "storage_duration" : translatedComponent["storage_duration"],
+                            "force_lower_case" : translatedComponent["force_lower_case"],
+                            "clean_text" : translatedComponent["clean_text"],
+                            "settings" : translatedComponent["settings"],
+                            "default_value": translatedComponent["default_value"]
+                        }
                         ## if it does not exist
                         if cmp_baseDict['name'] not in [de.get('attributes',{}).get('name') for de in self.targets[target]['dataElements']]:
                             if forceCreation:
@@ -304,9 +319,9 @@ class Synchronizer:
                                     default_value= translatedComponent["default_value"]
                                     )
                                 if cmp_baseDict['component']['attributes']['enabled'] != comp['attributes']['enabled']:
-                                    updateDE = self.targets[target]['api'].updateDataElement(
+                                    comp = self.targets[target]['api'].updateDataElement(
                                         dataElement_id=comp['id'],
-                                        attr_dict=translatedComponent)
+                                        attr_dict=attributes)
                                 self.targets[target]['libraryStack']['dataElements'].append(comp)
                                 self.targets[target]['dataElements'].append(comp)
                                 response[target] = f'Data element "{cmp_baseDict["name"]}" created in "{target}".'
@@ -316,16 +331,6 @@ class Synchronizer:
                                 response[target] = message
                         else:
                             index,old_component = [(index,de) for index,de in enumerate(self.targets[target]['dataElements']) if de.get('attributes',{}).get('name') == cmp_baseDict['name']][0]
-                            attributes = {
-                                "name" : translatedComponent['name'],
-                                "enabled" : translatedComponent["enabled"],
-                                "delegate_descriptor_id" : translatedComponent["descriptor"],
-                                "storage_duration" : translatedComponent["storage_duration"],
-                                "force_lower_case" : translatedComponent["force_lower_case"],
-                                "clean_text" : translatedComponent["clean_text"],
-                                "settings" : translatedComponent["settings"],
-                                "default_value": translatedComponent["default_value"]
-                            }
                             comp = self.targets[target]['api'].updateDataElement(
                                 dataElement_id=old_component['id'],
                                 attr_dict=attributes,
@@ -513,7 +518,7 @@ class Synchronizer:
                 results[component] = self.syncComponent(componentId=component,publishedVersion=publishedVersion,forceCreation=forceCreation)
         return results
 
-    def syncRules(self,regex:str=None,forceCreation:bool=False,publishedVersion:bool=False)->dict:
+    def syncRules(self,regex:str=None,forceCreation:bool=False,publishedVersion:bool=False,ignoreDisabled:bool=False)->dict:
         """
         Synchronizing the rules in the base property to the target properties.
         Returns a dictionary keyed by rule name, with the per-target status (created, updated, or not synced because the rule does not exist and forceCreation is False).
@@ -521,18 +526,19 @@ class Synchronizer:
             regex : OPTIONAL : If you want to filter the rules to sync based on a regex pattern. Default: None (sync all rules)
             forceCreation : OPTIONAL : If set to True, it will sync the rules even if they do not exist in the target properties. If set to False, it will only sync the rules that already exist in the target properties. Default: False.
             publishedVersion : OPTIONAL : If set to True, it will sync the latest published version of the rules. Default: False.
+            ignoreDisabled : OPTIONAL : Skip rules whose selected source revision is disabled. Skipped rules have an empty per-target result. Default: False.
         """
         base_rule_names = [rule['attributes']['name'] for rule in self.base['rules']]
         if regex is not None:
             base_rule_names = [rule for rule in base_rule_names if re.search(regex,rule)]
         results = {}
         with ThreadPoolExecutor() as executor:
-            future_to_name = {executor.submit(self.syncComponent, componentName=rule, forceCreation=forceCreation, publishedVersion=publishedVersion): rule for rule in base_rule_names}
+            future_to_name = {executor.submit(self.syncComponent, componentName=rule, forceCreation=forceCreation, publishedVersion=publishedVersion, ignoreDisabled=ignoreDisabled): rule for rule in base_rule_names}
             for future in future_to_name:
                 results[future_to_name[future]] = future.result()
         return results
 
-    def syncDataElements(self,regex:str=None,forceCreation:bool=False,publishedVersion:bool=False)->dict:
+    def syncDataElements(self,regex:str=None,forceCreation:bool=False,publishedVersion:bool=False,ignoreDisabled:bool=False)->dict:
         """
         Synchronizing the data elements in the base property to the target properties.
         Returns a dictionary keyed by data element name, with the per-target status (created, updated, or not synced because the data element does not exist and forceCreation is False).
@@ -540,13 +546,14 @@ class Synchronizer:
             regex : OPTIONAL : If you want to filter the data elements to sync based on a regex pattern. Default: None (sync all data elements)
             forceCreation : OPTIONAL : If set to True, it will sync the data elements even if they do not exist in the target properties. If set to False, it will only sync the data elements that already exist in the target properties. Default: False.
             publishedVersion : OPTIONAL : If set to True, it will sync the latest published version of the data elements. Default: False.
+            ignoreDisabled : OPTIONAL : Skip data elements whose selected source revision is disabled. Skipped data elements have an empty per-target result. Default: False.
         """
         base_de_names = [de['attributes']['name'] for de in self.base['dataElements']]
         if regex is not None:
             base_de_names = [de for de in base_de_names if re.search(regex,de)]
         results = {}
         with ThreadPoolExecutor() as executor:
-            future_to_name = {executor.submit(self.syncComponent, componentName=de, forceCreation=forceCreation, publishedVersion=publishedVersion): de for de in base_de_names}
+            future_to_name = {executor.submit(self.syncComponent, componentName=de, forceCreation=forceCreation, publishedVersion=publishedVersion, ignoreDisabled=ignoreDisabled): de for de in base_de_names}
             for future in future_to_name:
                 results[future_to_name[future]] = future.result()
         return results
@@ -793,21 +800,23 @@ class Synchronizer:
                 else:
                     index,target_de = [(index,de) for index,de in enumerate(self.targets[target]['dataElements']) if de['attributes']['name'] == cmp_baseDict['name']][0]
                     issue_pub = ""
+                    differences: list[str] = []
                     if publishedVersion:
                         try:
                             revisions_dataElement = self.targets[target]["api"].getRevisions(target_de)
                             target_de = self.targets[target]["api"].getLatestPublishedVersion(revisions_dataElement) 
                         except:
                             issue_pub = " (draft)"
-                        if target_de['attributes']['enabled'] != cmp_baseDict['component']['attributes']['enabled']:
-                            dict_result[target] = "Data Element enabled status is different"+issue_pub
-                        if target_de['attributes']['published'] != cmp_baseDict['component']['attributes']['published']:
-                            dict_result[target] = "Data Element published status is different"+issue_pub
-                    if target_de['attributes']['settings'] == cmp_baseDict['component']['attributes']['settings']:
-                        if not excludeSimilar:
-                            dict_result[target] = "Similar"+issue_pub
-                    else:
-                        dict_result[target] = "Data Element settings are different"+issue_pub
+                    if target_de['attributes']['enabled'] != cmp_baseDict['component']['attributes']['enabled']:
+                        differences.append("Data Element enabled status is different")
+                    if publishedVersion and target_de['attributes']['published'] != cmp_baseDict['component']['attributes']['published']:
+                        differences.append("Data Element published status is different")
+                    if target_de['attributes']['settings'] != cmp_baseDict['component']['attributes']['settings']:
+                        differences.append("Data Element settings are different")
+                    if differences:
+                        dict_result[target] = ','.join(differences) + issue_pub
+                    elif not excludeSimilar:
+                        dict_result[target] = "Similar"+issue_pub
         if cmp_baseDict['component']['type'] == 'rules':
             rcsLink = cmp_baseDict['component'].get('relationships',{}).get('rule_components',{}).get('links',{}).get('related')
             resResource = self.base['api'].getRessource(rcsLink)
@@ -829,10 +838,10 @@ class Synchronizer:
                             targetRule = self.targets[target]["api"].getLatestPublishedVersion(revisions_targetRule) 
                         except:
                             issue_pub = " (not published)"
-                        if targetRule['attributes']['enabled'] != cmp_baseDict['component']['attributes']['enabled']:
-                            componentsDifferences.append("Rule enabled status is different")
-                        if targetRule['attributes']['published'] != cmp_baseDict['component']['attributes']['published']:
-                            componentsDifferences.append("Rule published status is different")
+                    if targetRule['attributes']['enabled'] != cmp_baseDict['component']['attributes']['enabled']:
+                        componentsDifferences.append("Rule enabled status is different")
+                    if publishedVersion and targetRule['attributes']['published'] != cmp_baseDict['component']['attributes']['published']:
+                        componentsDifferences.append("Rule published status is different")
                     rcsLinkTarget = targetRule.get('relationships',{}).get('rule_components',{}).get('links',{}).get('related')
                     resResource = self.targets[target]['api'].getRessource(rcsLinkTarget)
                     target_rule_components:list = resResource['data']

{launchpy-0.5.3 → launchpy-0.5.4}/launchpy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: launchpy
-Version: 0.5.3
+Version: 0.5.4
 Summary: Adobe Launch API wrapper
 Author-email: Julien Piccini <piccini.julien@gmail.com>
 License: Apache License 2.0

{launchpy-0.5.3 → launchpy-0.5.4}/launchpy.egg-info/SOURCES.txt

@@ -30,4 +30,5 @@ launchpy.egg-info/top_level.txt
 launchpy/cli/__init__.py
 launchpy/cli/__main__.py
 tests/test_connector.py
-tests/test_proxies.py
+tests/test_proxies.py
+tests/test_synchronizer.py

launchpy-0.5.4/tests/test_synchronizer.py

@@ -0,0 +1,428 @@
+from copy import deepcopy
+import threading
+import unittest
+from unittest.mock import Mock, patch
+
+from launchpy.cli.__main__ import SynchronizerCLI
+from launchpy.launchpy import Translator
+from launchpy.property import Property
+from launchpy.synchronizer import Synchronizer
+
+
+def component(kind: str, identifier: str, enabled: bool) -> dict:
+    data = {
+        "id": identifier,
+        "type": kind,
+        "attributes": {
+            "name": "Sample component",
+            "enabled": enabled,
+            "published": False,
+            "revision_number": 2,
+        },
+        "links": {
+            "self": "https://example.invalid/" + identifier,
+            "origin": "https://example.invalid/" + identifier,
+        },
+        "relationships": {
+            "rule_components": {"links": {"related": "mock:components"}},
+        },
+    }
+    if kind == "data_elements":
+        data["attributes"].update(
+            settings="{}",
+            delegate_descriptor_id="core::dataElements::custom-code",
+            storage_duration="pageview",
+            force_lower_case=False,
+            default_value="",
+            clean_text=False,
+        )
+        data["relationships"]["extension"] = {
+            "data": {"id": "EXbase", "type": "extensions"},
+        }
+    return data
+
+
+class SynchronizerTests(unittest.TestCase):
+    def make_sync(
+        self, kind: str, source_enabled: bool = False, target_enabled: bool = True
+    ) -> tuple[Synchronizer, dict, dict]:
+        prefix = "RL" if kind == "rules" else "DE"
+        source = component(kind, prefix + "base", source_enabled)
+        target = component(kind, prefix + "target", target_enabled)
+        key = "rules" if kind == "rules" else "dataElements"
+        source_api = Mock(spec=Property)
+        source_api.connector = Mock()
+        target_api = Mock(spec=Property)
+        source_api.getRessource.return_value = {"data": []}
+        target_api.getRessource.return_value = {"data": []}
+        source_api.getRevisions.return_value = [source]
+        target_api.getRevisions.return_value = [target]
+        source_api.getLatestPublishedVersion.return_value = source
+        target_api.getLatestPublishedVersion.return_value = target
+        target_api.updateDataElement.side_effect = (
+            lambda dataElement_id, attr_dict: self.updated(target, attr_dict)
+        )
+        target_api.updateRule.side_effect = (
+            lambda rule_id, attr_dict: self.updated(target, attr_dict)
+        )
+        sync = Synchronizer.__new__(Synchronizer)
+        sync.base = {
+            "name": "Base",
+            "api": source_api,
+            "rules": [],
+            "dataElements": [],
+            "extensions": [],
+        }
+        sync.base[key] = [source]
+        sync.targets = {
+            "Target": {
+                "api": target_api,
+                "rules": [],
+                "dataElements": [],
+                "libraryStack": {"rules": [], "dataElements": [], "extensions": []},
+            },
+        }
+        sync.targets["Target"][key] = [target]
+        sync.target_configs = {}
+        sync._base_lock = threading.Lock()
+        sync._target_locks = {"Target": threading.Lock()}
+        sync.translator = Translator()
+        sync.translator.setBaseExtensions(
+            [{"id": "EXbase", "attributes": {"name": "core"}}], "Base"
+        )
+        sync.translator.extendExtensions(
+            [{"id": "EXtarget", "attributes": {"name": "core"}}], "Target"
+        )
+        sync.translator.setBaseRules(sync.base["rules"], "Base")
+        sync.translator.extendRules(sync.targets["Target"]["rules"], "Target")
+        return sync, source, target
+
+    @staticmethod
+    def updated(target: dict, attributes: dict) -> dict:
+        result = deepcopy(target)
+        result["attributes"].update(attributes)
+        return result
+
+    def test_created_data_element_update_uses_api_attributes_and_tracks_response(self):
+        for source_enabled in (False, True):
+            with self.subTest(source_enabled=source_enabled):
+                sync, source, created = self.make_sync(
+                    "data_elements", source_enabled, not source_enabled
+                )
+                target = sync.targets["Target"]
+                target["dataElements"] = []
+                api = target["api"]
+                api.createDataElement.return_value = created
+                attributes = {
+                    "name": source["attributes"]["name"],
+                    "enabled": source_enabled,
+                    "delegate_descriptor_id": source["attributes"]["delegate_descriptor_id"],
+                    "storage_duration": source["attributes"]["storage_duration"],
+                    "force_lower_case": source["attributes"]["force_lower_case"],
+                    "clean_text": source["attributes"]["clean_text"],
+                    "settings": source["attributes"]["settings"],
+                    "default_value": source["attributes"]["default_value"],
+                }
+                updated = self.updated(created, attributes)
+                updated["attributes"]["revision_number"] += 1
+                api.updateDataElement.side_effect = None
+                api.updateDataElement.return_value = updated
+
+                result = sync.syncComponent(componentId=source["id"], forceCreation=True)
+
+                api.updateDataElement.assert_called_once_with(
+                    dataElement_id=created["id"], attr_dict=attributes
+                )
+                self.assertEqual(
+                    result,
+                    {"Target": 'Data element "Sample component" created in "Target".'},
+                )
+                self.assertEqual(len(target["dataElements"]), 1)
+                self.assertEqual(len(target["libraryStack"]["dataElements"]), 1)
+                self.assertIs(target["dataElements"][0], updated)
+                self.assertIs(target["libraryStack"]["dataElements"][0], updated)
+                self.assertIs(created["attributes"]["enabled"], not source_enabled)
+                self.assertEqual(
+                    sync.checkComponentSync(componentId=source["id"])["Target"], "Similar"
+                )
+
+    def test_created_data_element_needs_no_update_when_enabled_state_matches(self):
+        for enabled in (False, True):
+            with self.subTest(enabled=enabled):
+                sync, source, created = self.make_sync("data_elements", enabled, enabled)
+                target = sync.targets["Target"]
+                target["dataElements"] = []
+                api = target["api"]
+                api.createDataElement.return_value = created
+
+                sync.syncComponent(componentId=source["id"], forceCreation=True)
+
+                api.updateDataElement.assert_not_called()
+                self.assertEqual(target["dataElements"], [created])
+                self.assertEqual(target["libraryStack"]["dataElements"], [created])
+
+    def test_created_data_element_update_failure_is_not_cached_as_success(self):
+        sync, source, created = self.make_sync("data_elements")
+        target = sync.targets["Target"]
+        target["dataElements"] = []
+        api = target["api"]
+        api.createDataElement.return_value = created
+        api.updateDataElement.side_effect = RuntimeError("Data element update failed")
+
+        with self.assertRaisesRegex(RuntimeError, "Data element update failed"):
+            sync.syncComponent(componentId=source["id"], forceCreation=True)
+
+        self.assertEqual(target["dataElements"], [])
+        self.assertEqual(target["libraryStack"]["dataElements"], [])
+
+    def test_enabled_mismatches_are_reported_in_all_comparison_modes(self):
+        for kind, label in (("rules", "Rule"), ("data_elements", "Data Element")):
+            for enabled in (False, True):
+                for published in (False, True):
+                    for exclude_similar in (False, True):
+                        with self.subTest(
+                            kind=kind, enabled=enabled, published=published,
+                            exclude_similar=exclude_similar,
+                        ):
+                            sync, source, target = self.make_sync(
+                                kind, enabled, not enabled
+                            )
+                            result = sync.checkComponentSync(
+                                componentId=source["id"],
+                                publishedVersion=published,
+                                excludeSimilar=exclude_similar,
+                            )
+                            self.assertEqual(
+                                result["Target"], f"{label} enabled status is different"
+                            )
+
+    def test_matching_components_preserve_similar_and_exclude_similar_results(self):
+        for kind in ("rules", "data_elements"):
+            for published in (False, True):
+                for exclude_similar in (False, True):
+                    with self.subTest(
+                        kind=kind, published=published, exclude_similar=exclude_similar,
+                    ):
+                        sync, source, target = self.make_sync(kind, False, False)
+                        result = sync.checkComponentSync(
+                            componentId=source["id"],
+                            publishedVersion=published,
+                            excludeSimilar=exclude_similar,
+                        )
+                        self.assertEqual(result["Target"], "" if exclude_similar else "Similar")
+
+    def test_data_element_comparison_retains_all_differences(self):
+        sync, source, target = self.make_sync("data_elements")
+        source["attributes"]["published"] = True
+        target["attributes"]["settings"] = '{"different": true}'
+        result = sync.checkComponentSync(componentId=source["id"], publishedVersion=True)
+        self.assertEqual(
+            result["Target"],
+            "Data Element enabled status is different,"
+            "Data Element published status is different,"
+            "Data Element settings are different",
+        )
+
+    def test_data_element_published_difference_is_not_overwritten_by_similar_settings(self):
+        sync, source, target = self.make_sync("data_elements", False, False)
+        source["attributes"]["published"] = True
+        result = sync.checkComponentSync(componentId=source["id"], publishedVersion=True)
+        self.assertEqual(result["Target"], "Data Element published status is different")
+
+    def test_comparison_reports_enabled_difference_when_target_has_no_published_revision(self):
+        for kind, label, suffix in (
+            ("rules", "Rule", " (not published)"),
+            ("data_elements", "Data Element", " (draft)"),
+        ):
+            with self.subTest(kind=kind):
+                sync, source, target = self.make_sync(kind)
+                sync.targets["Target"]["api"].getLatestPublishedVersion.side_effect = (
+                    IndexError("No published revision")
+                )
+                result = sync.checkComponentSync(
+                    componentId=source["id"], publishedVersion=True
+                )
+                self.assertEqual(
+                    result["Target"], f"{label} enabled status is different{suffix}"
+                )
+
+    def test_library_dry_run_reports_enabled_differences(self):
+        for kind, label in (("rules", "Rule"), ("data_elements", "Data Element")):
+            for published in (False, True):
+                with self.subTest(kind=kind, published=published):
+                    sync, source, target = self.make_sync(kind)
+                    api = sync.base["api"]
+                    api.getLibraries.return_value = [
+                        {"id": "LBbase", "attributes": {"name": "Base library"}},
+                    ]
+                    api.getRule.return_value = source
+                    api.getDataElement.return_value = source
+                    library = Mock()
+                    library.getFullLibrary.return_value = {
+                        "rules": [source] if kind == "rules" else [],
+                        "data_elements": [source] if kind == "data_elements" else [],
+                        "extensions": [],
+                    }
+                    with patch("launchpy.synchronizer.Library", return_value=library):
+                        result = sync.syncFromLibrary(
+                            library="LBbase", dryRun=True, publishedVersion=published
+                        )
+                    self.assertEqual(
+                        result[source["attributes"]["name"]]["Target"],
+                        f"{label} enabled status is different",
+                    )
+                    sync.targets["Target"]["api"].updateRule.assert_not_called()
+                    sync.targets["Target"]["api"].updateDataElement.assert_not_called()
+
+    def test_bulk_sync_defaults_to_including_disabled_components(self):
+        for kind in ("rules", "data_elements"):
+            for options in ({}, {"ignoreDisabled": False}):
+                with self.subTest(kind=kind, options=options):
+                    sync, source, target = self.make_sync(kind)
+                    method = sync.syncRules if kind == "rules" else sync.syncDataElements
+                    result = method(**options)
+                    self.assertIn("Target", result[source["attributes"]["name"]])
+                    update = (
+                        sync.targets["Target"]["api"].updateRule
+                        if kind == "rules"
+                        else sync.targets["Target"]["api"].updateDataElement
+                    )
+                    self.assertIs(update.call_args.kwargs["attr_dict"]["enabled"], False)
+
+    def test_bulk_sync_ignores_disabled_components_without_touching_targets(self):
+        for kind in ("rules", "data_elements"):
+            for force_creation in (False, True):
+                for target_exists in (False, True):
+                    with self.subTest(
+                        kind=kind, force_creation=force_creation,
+                        target_exists=target_exists,
+                    ):
+                        sync, source, target = self.make_sync(kind)
+                        if not target_exists:
+                            key = "rules" if kind == "rules" else "dataElements"
+                            sync.targets["Target"][key] = []
+                        method = sync.syncRules if kind == "rules" else sync.syncDataElements
+                        result = method(ignoreDisabled=True, forceCreation=force_creation)
+                        self.assertEqual(result, {source["attributes"]["name"]: {}})
+                        self.assertEqual(sync.targets["Target"]["api"].mock_calls, [])
+                        self.assertEqual(sync.base["api"].mock_calls, [])
+                        self.assertEqual(
+                            sync.targets["Target"]["libraryStack"],
+                            {"rules": [], "dataElements": [], "extensions": []},
+                        )
+
+    def test_bulk_sync_only_updates_enabled_components_in_a_mixed_batch(self):
+        for kind in ("rules", "data_elements"):
+            with self.subTest(kind=kind):
+                sync, source, target = self.make_sync(kind)
+                key = "rules" if kind == "rules" else "dataElements"
+                enabled_source = deepcopy(source)
+                enabled_source["id"] += "enabled"
+                enabled_source["attributes"].update(name="Enabled component", enabled=True)
+                enabled_target = deepcopy(target)
+                enabled_target["id"] += "enabled"
+                enabled_target["attributes"].update(name="Enabled component", enabled=False)
+                sync.base[key].append(enabled_source)
+                sync.targets["Target"][key].append(enabled_target)
+                api = sync.targets["Target"]["api"]
+                update = api.updateRule if kind == "rules" else api.updateDataElement
+                update.side_effect = lambda **kwargs: self.updated(
+                    enabled_target, kwargs["attr_dict"]
+                )
+                method = sync.syncRules if kind == "rules" else sync.syncDataElements
+                result = method(ignoreDisabled=True)
+                self.assertEqual(result[source["attributes"]["name"]], {})
+                self.assertIn("Target", result["Enabled component"])
+                update.assert_called_once()
+                self.assertIs(update.call_args.kwargs["attr_dict"]["enabled"], True)
+
+    def test_bulk_sync_still_syncs_enabled_components_to_disabled_targets(self):
+        for kind in ("rules", "data_elements"):
+            with self.subTest(kind=kind):
+                sync, source, target = self.make_sync(kind, True, False)
+                method = sync.syncRules if kind == "rules" else sync.syncDataElements
+                result = method(ignoreDisabled=True)
+                self.assertIn("Target", result[source["attributes"]["name"]])
+                key = "rules" if kind == "rules" else "dataElements"
+                self.assertIs(
+                    sync.targets["Target"][key][0]["attributes"]["enabled"], True
+                )
+
+    def test_bulk_sync_filters_the_selected_published_revision(self):
+        for kind in ("rules", "data_elements"):
+            for published_enabled in (False, True):
+                with self.subTest(kind=kind, published_enabled=published_enabled):
+                    sync, source, target = self.make_sync(
+                        kind, not published_enabled, not published_enabled
+                    )
+                    revision = deepcopy(source)
+                    revision["id"] += "revision"
+                    revision["attributes"]["enabled"] = published_enabled
+                    revision["attributes"]["published"] = True
+                    sync.base["api"].getLatestPublishedVersion.return_value = revision
+                    method = sync.syncRules if kind == "rules" else sync.syncDataElements
+                    result = method(ignoreDisabled=True, publishedVersion=True)
+                    sync.base["api"].getRevisions.assert_called_once_with(source)
+                    if published_enabled:
+                        self.assertIn("Target", result[source["attributes"]["name"]])
+                    else:
+                        self.assertEqual(result[source["attributes"]["name"]], {})
+                        self.assertEqual(sync.targets["Target"]["api"].mock_calls, [])
+
+    def test_bulk_sync_keeps_regex_filtering(self):
+        for kind in ("rules", "data_elements"):
+            with self.subTest(kind=kind):
+                sync, source, target = self.make_sync(kind, True, False)
+                method = sync.syncRules if kind == "rules" else sync.syncDataElements
+                self.assertEqual(method(regex="Does not match", ignoreDisabled=True), {})
+                self.assertEqual(sync.targets["Target"]["api"].mock_calls, [])
+
+
+class SynchronizerCLITests(unittest.TestCase):
+    def test_ignore_disabled_accepts_optional_boolean_and_bare_flags(self):
+        options = (
+            ("", False),
+            ("-i", True),
+            ("--ignore_disabled", True),
+            ("-i True", True),
+            ("--ignore_disabled true", True),
+            ("-i False", False),
+            ("--ignore_disabled false", False),
+            ("--ignore_disabled=False", False),
+        )
+        for command, method_name in (
+            ("do_sync_rules", "syncRules"),
+            ("do_sync_data_elements", "syncDataElements"),
+        ):
+            for arguments, expected in options:
+                with self.subTest(command=command, arguments=arguments):
+                    sync = Mock(spec=Synchronizer)
+                    sync.base = {"name": "Base"}
+                    method = getattr(sync, method_name)
+                    method.return_value = {}
+                    shell = SynchronizerCLI(sync)
+                    with patch("launchpy.cli.__main__.console") as console:
+                        getattr(shell, command)(arguments + " -r Sample -c -p")
+                    method.assert_called_once_with(
+                        regex="Sample", forceCreation=True, publishedVersion=True,
+                        ignoreDisabled=expected,
+                    )
+                    console.print.assert_not_called()
+
+    def test_ignore_disabled_rejects_invalid_boolean_without_syncing(self):
+        for command, method_name in (
+            ("do_sync_rules", "syncRules"),
+            ("do_sync_data_elements", "syncDataElements"),
+        ):
+            with self.subTest(command=command):
+                sync = Mock(spec=Synchronizer)
+                sync.base = {"name": "Base"}
+                shell = SynchronizerCLI(sync)
+                with patch("sys.stderr") as stderr:
+                    getattr(shell, command)("--ignore_disabled invalid")
+                getattr(sync, method_name).assert_not_called()
+                self.assertTrue(stderr.write.called)
+
+
+if __name__ == "__main__":
+    unittest.main()

launchpy-0.5.3/launchpy/__version__.py

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