azure-cli-diff-tool 0.0.4__tar.gz → 0.0.6__tar.gz

{azure-cli-diff-tool-0.0.4 → azure-cli-diff-tool-0.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: azure-cli-diff-tool
-Version: 0.0.4
+Version: 0.0.6
 Summary: A tool for cli metadata management
 Author: Microsoft Corporation
 Author-email: azpycli@microsoft.com
@@ -98,6 +98,15 @@ License
 
 Release History
 ===============
+0.0.6
+++++++
+* Add diff support for deprecate_info in subgroup, cmd, parameters and options
+
+0.0.5
+++++++
+* Add `DiffLevel` to meta comparison
+* Downgrade change level according to warn list
+
 0.0.4
 ++++++
 * Add meta change parameter update warn list

{azure-cli-diff-tool-0.0.4 → azure-cli-diff-tool-0.0.6}/azure_cli_diff_tool/__init__.py

@@ -16,9 +16,9 @@ from deepdiff import DeepDiff
 from .meta_change_detect import MetaChangeDetect
 from .utils import get_blob_config, load_blob_config_file, get_target_version_modules, get_target_version_module, \
     extract_module_name_from_meta_file, export_meta_changes_to_csv, export_meta_changes_to_json, \
-    export_meta_changes_to_dict
+    export_meta_changes_to_dict, expand_deprecate_obj
 
-__VERSION__ = '0.0.4'
+__VERSION__ = '0.0.6'
 
 logger = logging.getLogger(__name__)
 
@@ -61,7 +61,8 @@ def meta_diff(base_meta_file, diff_meta_file, only_break=False, output_type="tex
     if command_tree_after.get("compat_version", None) \
             and check_meta_tool_compatibility(command_tree_after["compat_version"]):
         raise Exception("Please update your azure cli diff tool")
-
+    expand_deprecate_obj(command_tree_before)
+    expand_deprecate_obj(command_tree_after)
     diff = DeepDiff(command_tree_before, command_tree_after)
     if not diff:
         print(f"No meta diffs from {diff_meta_file} to {base_meta_file}")
@@ -116,7 +117,8 @@ def version_diff(base_version, diff_version, only_break=False, version_diff_file
         if command_tree_after.get("compat_version", None) \
                 and check_meta_tool_compatibility(command_tree_after["compat_version"]):
             raise Exception("Please update your azure cli diff tool")
-
+        expand_deprecate_obj(command_tree_before)
+        expand_deprecate_obj(command_tree_after)
         diff = DeepDiff(command_tree_before, command_tree_after)
         if not diff:
             print(f"No meta diffs from version: {diff_version}/{base_meta_file} for module: {module_name}")

{azure-cli-diff-tool-0.0.4 → azure-cli-diff-tool-0.0.6}/azure_cli_diff_tool/_const.py

@@ -17,22 +17,47 @@ DOWNLOAD_THREADS = 30
 BREAKING_CHANE_RULE_LINK_URL_PREFIX = "https://github.com/Azure/azure-cli/blob/dev/doc/breaking_change_rules/"
 BREAKING_CHANE_RULE_LINK_URL_SUFFIX = ".md"
 
+CMD_REMOVE_SUFFIX_WARN_LIST = ["wait"]
+
+SUBGROUP_PROPERTY_REMOVE_BREAK_LIST = []
+SUBGROUP_PROPERTY_REMOVE_WARN_LIST = ["deprecate_info_redirect"]
+
+SUBGROUP_PROPERTY_ADD_BREAK_LIST = []
+SUBGROUP_PROPERTY_ADD_WARN_LIST = ["deprecate_info_hide", "deprecate_info_expiration"]
+
+SUBGROUP_PROPERTY_UPDATE_BREAK_LIST = []
+SUBGROUP_PROPERTY_UPDATE_WARN_LIST = ["deprecate_info_expiration"]
+
+SUBGROUP_PROPERTY_IGNORED_LIST = []
+
 CMD_PROPERTY_REMOVE_BREAK_LIST = []
+CMD_PROPERTY_REMOVE_WARN_LIST = ["deprecate_info_redirect"]
+
 CMD_PROPERTY_ADD_BREAK_LIST = ["confirmation"]
+CMD_PROPERTY_ADD_WARN_LIST = ["deprecate_info_hide", "deprecate_info_expiration"]
+
 CMD_PROPERTY_UPDATE_BREAK_LIST = []
+CMD_PROPERTY_UPDATE_WARN_LIST = ["deprecate_info_expiration", "deprecate_info_redirect"]
+
 CMD_PROPERTY_IGNORED_LIST = ["is_aaz", "supports_no_wait"]
 
-PARA_PROPERTY_REMOVE_BREAK_LIST = ["options", "id_part", "nargs"]
-PARA_PROPERTY_ADD_BREAK_LIST = ["required", "choices"]
-PARA_PROPERTY_UPDATE_BREAK_LIST = ["default", "aaz_default", "type", "aaz_type"]
-PARA_PROPERTY_UPDATE_WARN_LIST = ["type", "aaz_type"]
+PARA_PROPERTY_REMOVE_BREAK_LIST = ["options"]
+PARA_PROPERTY_REMOVE_WARN_LIST = ["id_part", "nargs", "deprecate_info_redirect"]
+
+PARA_PROPERTY_ADD_BREAK_LIST = ["required"]
+PARA_PROPERTY_ADD_WARN_LIST = ["choices", "deprecate_info_expiration", "deprecate_info_hide", "options_deprecate_info"]
+
+PARA_PROPERTY_UPDATE_BREAK_LIST = ["default", "aaz_default"]
+PARA_PROPERTY_UPDATE_WARN_LIST = ["type", "aaz_type", "choices", "nargs",
+                                  "deprecate_info_expiration", "deprecate_info_redirect", "options_deprecate_info"]
+
 PARA_NAME_IGNORED_LIST = ["force_string"]
 PARA_PROPERTY_IGNORED_LIST = []
 PARA_VALUE_IGNORED_LIST = ["generic_update_set", "generic_update_add", "generic_update_remove",
                            "generic_update_force_string"]
 
-EXPORTED_CSV_META_HEADER = ["module", "cmd_name", "rule_id", "rule_name", "is_break", "rule_link_url",
-                            "rule_message", "suggest_message"]
+EXPORTED_CSV_META_HEADER = ["module", "cmd_name", "rule_id", "rule_name", "is_break", "diff_level",
+                            "rule_link_url", "rule_message", "suggest_message"]
 
 CHANGE_RULE_MESSAGE_MAPPING = {
     "1000": "default Message",
@@ -48,6 +73,9 @@ CHANGE_RULE_MESSAGE_MAPPING = {
     "1010": "cmd `{0}` update parameter `{1}`: updated property `{2}` from `{3}` to `{4}`",
     "1011": "sub group `{0}` added",
     "1012": "sub group `{0}` removed",
+    "1013": "sub group `{0}` added property `{1}`",
+    "1014": "sub group `{0}` removed property `{1}`",
+    "1015": "sub group `{0}` updated property `{1}` from `{2}` to `{3}`",
 }
 
 CHANGE_SUGGEST_MESSAGE_MAPPING = {
@@ -64,5 +92,8 @@ CHANGE_SUGGEST_MESSAGE_MAPPING = {
     "1010": "please change property `{0}` from `{1}` to `{2}` for parameter `{3}` of cmd `{4}`",
     "1011": "please confirm sub group `{0}` added",
     "1012": "please confirm sub group `{0}` removed",
+    "1013": "please remove property `{0}` for sub group `{1}`",
+    "1014": "please add back property `{0}` for sub group `{1}`",
+    "1015": "please change property `{0}` from `{1}` to `{2}` for sub group `{3}`",
 }
 

{azure-cli-diff-tool-0.0.4 → azure-cli-diff-tool-0.0.6}/azure_cli_diff_tool/meta_change.py

@@ -4,17 +4,19 @@
 # license information.
 # -----------------------------------------------------------------------------
 
-from .utils import get_change_rule_template, get_change_suggest_template
+from .utils import get_change_rule_template, get_change_suggest_template, DiffLevel
 from ._const import BREAKING_CHANE_RULE_LINK_URL_PREFIX, BREAKING_CHANE_RULE_LINK_URL_SUFFIX, \
-    CMD_PROPERTY_IGNORED_LIST, PARA_NAME_IGNORED_LIST, PARA_PROPERTY_IGNORED_LIST, PARA_VALUE_IGNORED_LIST
+    SUBGROUP_PROPERTY_IGNORED_LIST, CMD_PROPERTY_IGNORED_LIST, PARA_NAME_IGNORED_LIST, \
+    PARA_PROPERTY_IGNORED_LIST, PARA_VALUE_IGNORED_LIST
 
 
 class MetaChange:
 
-    def __init__(self, rule_id="1000", is_break=False, rule_message="", suggest_message="",
+    def __init__(self, rule_id="1000", is_break=False, diff_level=DiffLevel.INFO, rule_message="", suggest_message="",
                  is_ignore=False, filter_key=None):
         self.rule_id = rule_id
         self.is_break = is_break
+        self.diff_level = diff_level
         self.rule_message = rule_message
         self.suggest_message = suggest_message
         self.rule_link_url = BREAKING_CHANE_RULE_LINK_URL_PREFIX + self.rule_id + BREAKING_CHANE_RULE_LINK_URL_SUFFIX
@@ -22,7 +24,7 @@ class MetaChange:
         self.filter_key = filter_key
 
     def __str__(self):
-        res = [self.rule_message]
+        res = [self.rule_message, "diff_level: " + str(self.diff_level.value)]
         if self.is_break:
             res.append("is_break: {0}".format(self.is_break))
             res.append(self.suggest_message)
@@ -30,57 +32,139 @@ class MetaChange:
 
 
 class SubgroupAdd(MetaChange):
-    def __init__(self, subgroup_name, is_break=False):
+    def __init__(self, subgroup_name, is_break=False, diff_level=DiffLevel.INFO):
         if not subgroup_name:
             raise Exception("sub group name needed")
         self.rule_id = "1011"
         self.subgroup_name = subgroup_name
         self.is_break = is_break
+        self.diff_level = diff_level
         self.rule_message = get_change_rule_template(self.rule_id).format(self.subgroup_name)
         self.suggest_message = get_change_suggest_template(self.rule_id).format(self.subgroup_name) \
             if self.is_break else ""
-        super().__init__(self.rule_id, is_break, self.rule_message, self.suggest_message)
+        super().__init__(self.rule_id, is_break, diff_level, self.rule_message, self.suggest_message)
 
 
 class SubgroupRemove(MetaChange):
-    def __init__(self, subgroup_name, is_break=True):
+    def __init__(self, subgroup_name, is_break=True, diff_level=DiffLevel.BREAK):
         if not subgroup_name:
             raise Exception("sub group name needed")
         self.rule_id = "1012"
         self.subgroup_name = subgroup_name
         self.is_break = is_break
+        self.diff_level = diff_level
         self.rule_message = get_change_rule_template(self.rule_id).format(self.subgroup_name)
         self.suggest_message = get_change_suggest_template(self.rule_id).format(self.subgroup_name) \
             if self.is_break else ""
-        super().__init__(self.rule_id, is_break, self.rule_message, self.suggest_message)
+        super().__init__(self.rule_id, is_break, diff_level, self.rule_message, self.suggest_message)
+
+
+class SubgroupPropAdd(MetaChange):
+    def __init__(self, subgroup_name, subgroup_property, is_break=False, diff_level=DiffLevel.INFO):
+        if not subgroup_name or not subgroup_property:
+            raise Exception("sub group name needed")
+        self.rule_id = "1013"
+        self.is_ignore = False
+        self.subgroup_name = subgroup_name
+        self.subgroup_property = subgroup_property
+        self.is_break = is_break
+        self.diff_level = diff_level
+        self.rule_message = get_change_rule_template(self.rule_id).format(self.subgroup_name, self.subgroup_property)
+        self.suggest_message = get_change_suggest_template(self.rule_id).format(self.subgroup_property, self.subgroup_name) \
+            if self.is_break else ""
+        if subgroup_property in SUBGROUP_PROPERTY_IGNORED_LIST:
+            self.is_ignore = True
+        self.filter_key = [self.rule_id, self.subgroup_name, self.subgroup_property]
+        super().__init__(self.rule_id, is_break, diff_level, self.rule_message, self.suggest_message, self.is_ignore,
+                         self.filter_key)
+
+
+class SubgroupPropRemove(MetaChange):
+    def __init__(self, subgroup_name, subgroup_property, is_break=False, diff_level=DiffLevel.BREAK):
+        if not subgroup_name or not subgroup_property:
+            raise Exception("sub group name needed")
+        self.rule_id = "1014"
+        self.is_ignore = False
+        self.subgroup_name = subgroup_name
+        self.subgroup_property = subgroup_property
+        self.is_break = is_break
+        self.diff_level = diff_level
+        self.rule_message = get_change_rule_template(self.rule_id).format(self.subgroup_name, self.subgroup_property)
+        if self.is_break:
+            self.suggest_message = get_change_suggest_template(self.rule_id).format(self.subgroup_property,
+                                                                                    self.subgroup_name)
+        else:
+            self.suggest_message = ""
+        if subgroup_property in CMD_PROPERTY_IGNORED_LIST:
+            self.is_ignore = True
+        self.filter_key = [self.rule_id, self.subgroup_name, self.subgroup_property]
+        super().__init__(self.rule_id, is_break, diff_level, self.rule_message, self.suggest_message,
+                         self.is_ignore, self.filter_key)
+
+
+class SubgroupPropUpdate(MetaChange):
+
+    def __init__(self, subgroup_name, subgroup_property, is_break=False, diff_level=DiffLevel.INFO,
+                 old_value=None, new_value=None):
+        if not subgroup_name or not subgroup_property:
+            raise Exception("sub group name and sub group prop needed")
+        self.rule_id = "1015"
+        self.is_ignore = False
+        self.subgroup_name = subgroup_name
+        self.is_break = is_break
+        self.diff_level = diff_level
+        self.subgroup_prop_updated = subgroup_property
+        self.old_value = ""
+        self.new_value = ""
+
+        if old_value is not None:
+            self.old_value = old_value
+        if new_value is not None:
+            self.new_value = new_value
+        self.rule_message = get_change_rule_template(self.rule_id).format(self.subgroup_name,
+                                                                          self.subgroup_prop_updated,
+                                                                          self.old_value, self.new_value)
+        if self.is_break:
+            self.suggest_message = get_change_suggest_template(self.rule_id).format(self.subgroup_prop_updated,
+                                                                                    self.new_value, self.old_value,
+                                                                                    self.subgroup_name)
+        else:
+            self.suggest_message = ""
+        if subgroup_property in SUBGROUP_PROPERTY_IGNORED_LIST:
+            self.is_ignore = True
+        self.filter_key = [self.rule_id, self.subgroup_name, self.subgroup_prop_updated]
+        super().__init__(self.rule_id, is_break, diff_level, self.rule_message, self.suggest_message,
+                         self.is_ignore, self.filter_key)
 
 
 class CmdAdd(MetaChange):
-    def __init__(self, cmd_name, is_break=False):
+    def __init__(self, cmd_name, is_break=False, diff_level=DiffLevel.INFO):
         if not cmd_name:
             raise Exception("cmd name needed")
         self.rule_id = "1001"
         self.cmd_name = cmd_name
         self.is_break = is_break
+        self.diff_level = diff_level
         self.rule_message = get_change_rule_template(self.rule_id).format(self.cmd_name)
         self.suggest_message = get_change_suggest_template(self.rule_id).format(self.cmd_name) if self.is_break else ""
-        super().__init__(self.rule_id, is_break, self.rule_message, self.suggest_message)
+        super().__init__(self.rule_id, is_break, diff_level, self.rule_message, self.suggest_message)
 
 
 class CmdRemove(MetaChange):
-    def __init__(self, cmd_name, is_break=True):
+    def __init__(self, cmd_name, is_break=True, diff_level=DiffLevel.BREAK):
         if not cmd_name:
             raise Exception("cmd name needed")
         self.cmd_name = cmd_name
         self.rule_id = "1002"
         self.is_break = is_break
+        self.diff_level = diff_level
         self.rule_message = get_change_rule_template(self.rule_id).format(self.cmd_name)
         self.suggest_message = get_change_suggest_template(self.rule_id).format(self.cmd_name) if self.is_break else ""
-        super().__init__(self.rule_id, is_break, self.rule_message, self.suggest_message)
+        super().__init__(self.rule_id, is_break, diff_level, self.rule_message, self.suggest_message)
 
 
 class CmdPropAdd(MetaChange):
-    def __init__(self, cmd_name, cmd_property, is_break=False):
+    def __init__(self, cmd_name, cmd_property, is_break=False, diff_level=DiffLevel.INFO):
         if not cmd_name or not cmd_property:
             raise Exception("cmd name needed")
         self.rule_id = "1003"
@@ -88,18 +172,19 @@ class CmdPropAdd(MetaChange):
         self.cmd_name = cmd_name
         self.cmd_property = cmd_property
         self.is_break = is_break
+        self.diff_level = diff_level
         self.rule_message = get_change_rule_template(self.rule_id).format(self.cmd_name, self.cmd_property)
         self.suggest_message = get_change_suggest_template(self.rule_id).format(self.cmd_property, self.cmd_name) \
             if self.is_break else ""
         if cmd_property in CMD_PROPERTY_IGNORED_LIST:
             self.is_ignore = True
         self.filter_key = [self.rule_id, self.cmd_name, self.cmd_property]
-        super().__init__(self.rule_id, is_break, self.rule_message, self.suggest_message, self.is_ignore,
+        super().__init__(self.rule_id, is_break, diff_level, self.rule_message, self.suggest_message, self.is_ignore,
                          self.filter_key)
 
 
 class CmdPropRemove(MetaChange):
-    def __init__(self, cmd_name, cmd_property, is_break=False):
+    def __init__(self, cmd_name, cmd_property, is_break=False, diff_level=DiffLevel.BREAK):
         if not cmd_name or not cmd_property:
             raise Exception("cmd name needed")
         self.rule_id = "1004"
@@ -107,25 +192,28 @@ class CmdPropRemove(MetaChange):
         self.cmd_name = cmd_name
         self.cmd_property = cmd_property
         self.is_break = is_break
+        self.diff_level = diff_level
         self.rule_message = get_change_rule_template(self.rule_id).format(self.cmd_name, self.cmd_property)
         self.suggest_message = get_change_suggest_template(self.rule_id).format(self.cmd_property, self.cmd_name) \
             if self.is_break else ""
         if cmd_property in CMD_PROPERTY_IGNORED_LIST:
             self.is_ignore = True
         self.filter_key = [self.rule_id, self.cmd_name, self.cmd_property]
-        super().__init__(self.rule_id, is_break, self.rule_message, self.suggest_message,
+        super().__init__(self.rule_id, is_break, diff_level, self.rule_message, self.suggest_message,
                          self.is_ignore, self.filter_key)
 
 
 class CmdPropUpdate(MetaChange):
 
-    def __init__(self, cmd_name, cmd_property, is_break=False, old_value=None, new_value=None):
+    def __init__(self, cmd_name, cmd_property, is_break=False, diff_level=DiffLevel.INFO,
+                 old_value=None, new_value=None):
         if not cmd_name or not cmd_property:
             raise Exception("cmd name and cmd prop needed")
         self.rule_id = "1005"
         self.is_ignore = False
         self.cmd_name = cmd_name
         self.is_break = is_break
+        self.diff_level = diff_level
         self.cmd_prop_updated = cmd_property
         self.old_value = ""
         self.new_value = ""
@@ -142,43 +230,45 @@ class CmdPropUpdate(MetaChange):
         if cmd_property in CMD_PROPERTY_IGNORED_LIST:
             self.is_ignore = True
         self.filter_key = [self.rule_id, self.cmd_name, self.cmd_prop_updated]
-        super().__init__(self.rule_id, is_break, self.rule_message, self.suggest_message,
+        super().__init__(self.rule_id, is_break, diff_level, self.rule_message, self.suggest_message,
                          self.is_ignore, self.filter_key)
 
 
 class ParaAdd(MetaChange):
 
-    def __init__(self, cmd_name, para_name, is_break=False):
+    def __init__(self, cmd_name, para_name, is_break=False, diff_level=DiffLevel.INFO):
         if not cmd_name or not para_name:
             raise Exception("cmd name, parameter name needed")
         self.rule_id = "1006"
         self.cmd_name = cmd_name
         self.para_name = para_name
         self.is_break = is_break
+        self.diff_level = diff_level
         self.rule_message = get_change_rule_template(self.rule_id).format(self.cmd_name, self.para_name)
         self.suggest_message = get_change_suggest_template(self.rule_id).format(self.para_name,
                                                                                 self.cmd_name) if self.is_break else ""
-        super().__init__(self.rule_id, is_break, self.rule_message, self.suggest_message)
+        super().__init__(self.rule_id, is_break, diff_level, self.rule_message, self.suggest_message)
 
 
 class ParaRemove(MetaChange):
 
-    def __init__(self, cmd_name, para_name, is_break=False):
+    def __init__(self, cmd_name, para_name, is_break=False, diff_level=DiffLevel.BREAK):
         if not cmd_name or not para_name:
             raise Exception("cmd name, parameter name needed")
         self.rule_id = "1007"
         self.cmd_name = cmd_name
         self.para_name = para_name
         self.is_break = is_break
+        self.diff_level = diff_level
         self.rule_message = get_change_rule_template(self.rule_id).format(self.cmd_name, self.para_name)
         self.suggest_message = get_change_suggest_template(self.rule_id).format(self.para_name,
                                                                                 self.cmd_name) if self.is_break else ""
-        super().__init__(self.rule_id, is_break, self.rule_message, self.suggest_message)
+        super().__init__(self.rule_id, is_break, diff_level, self.rule_message, self.suggest_message)
 
 
 class ParaPropAdd(MetaChange):
 
-    def __init__(self, cmd_name, para_name, para_property, para_prop_value, is_break=False):
+    def __init__(self, cmd_name, para_name, para_property, para_prop_value, is_break=False, diff_level=DiffLevel.INFO):
         if not cmd_name or not para_name or not para_property:
             raise Exception("cmd name, parameter name and parameter property needed")
         self.rule_id = "1008"
@@ -188,6 +278,7 @@ class ParaPropAdd(MetaChange):
         self.para_prop = para_property
         self.para_prop_value = para_prop_value
         self.is_break = is_break
+        self.diff_level = diff_level
 
         self.rule_message = get_change_rule_template(self.rule_id).format(self.cmd_name, self.para_name,
                                                                           self.para_prop, self.para_prop_value)
@@ -197,12 +288,12 @@ class ParaPropAdd(MetaChange):
                                                                                 self.cmd_name) if self.is_break else ""
         if para_property in PARA_PROPERTY_IGNORED_LIST or para_name in PARA_NAME_IGNORED_LIST:
             self.is_ignore = True
-        super().__init__(self.rule_id, is_break, self.rule_message, self.suggest_message, self.is_ignore)
+        super().__init__(self.rule_id, is_break, diff_level, self.rule_message, self.suggest_message, self.is_ignore)
 
 
 class ParaPropRemove(MetaChange):
 
-    def __init__(self, cmd_name, para_name, para_property, para_prop_value, is_break=False):
+    def __init__(self, cmd_name, para_name, para_property, para_prop_value, is_break=False, diff_level=DiffLevel.BREAK):
         if not cmd_name or not para_name or not para_property:
             raise Exception("cmd name, parameter name and parameter property needed")
         self.rule_id = "1009"
@@ -212,6 +303,7 @@ class ParaPropRemove(MetaChange):
         self.para_prop = para_property
         self.para_prop_value = para_prop_value
         self.is_break = is_break
+        self.diff_level = diff_level
 
         self.rule_message = get_change_rule_template(self.rule_id).format(self.cmd_name, self.para_name,
                                                                           self.para_prop, self.para_prop_value)
@@ -221,12 +313,13 @@ class ParaPropRemove(MetaChange):
                                                                                 self.cmd_name) if self.is_break else ""
         if para_property in PARA_PROPERTY_IGNORED_LIST or para_name in PARA_NAME_IGNORED_LIST:
             self.is_ignore = True
-        super().__init__(self.rule_id, is_break, self.rule_message, self.suggest_message, self.is_ignore)
+        super().__init__(self.rule_id, is_break, diff_level, self.rule_message, self.suggest_message, self.is_ignore)
 
 
 class ParaPropUpdate(MetaChange):
 
-    def __init__(self, cmd_name, para_name, para_property, is_break=False, old_value=None, new_value=None):
+    def __init__(self, cmd_name, para_name, para_property, is_break=False, diff_level=DiffLevel.INFO,
+                 old_value=None, new_value=None):
         if not cmd_name or not para_name or not para_property:
             raise Exception("cmd name, parameter name and parameter property needed")
         self.rule_id = "1010"
@@ -235,6 +328,7 @@ class ParaPropUpdate(MetaChange):
         self.para_name = para_name
         self.para_prop_updated = para_property
         self.is_break = is_break
+        self.diff_level = diff_level
         self.old_value = None
         self.new_value = None
         if old_value is not None:
@@ -254,5 +348,5 @@ class ParaPropUpdate(MetaChange):
         if self.new_value in PARA_VALUE_IGNORED_LIST or self.old_value in PARA_VALUE_IGNORED_LIST:
             self.is_ignore = True
         self.filter_key = [self.rule_id, self.cmd_name, self.para_name, self.para_prop_updated]
-        super().__init__(self.rule_id, is_break, self.rule_message, self.suggest_message,
+        super().__init__(self.rule_id, is_break, diff_level, self.rule_message, self.suggest_message,
                          self.is_ignore, self.filter_key)

{azure-cli-diff-tool-0.0.4 → azure-cli-diff-tool-0.0.6}/azure_cli_diff_tool/meta_change_detect.py

@@ -7,22 +7,35 @@
 import logging
 import os.path
 
-from .utils import get_command_tree, ChangeType, extract_cmd_name, extract_subgroup_name, extract_cmd_property
+from .utils import get_command_tree, ChangeType, extract_cmd_name, extract_subgroup_name, extract_subgroup_property, \
+    extract_subgroup_deprecate_property, extract_cmd_property, extract_cmd_deprecate_property, DiffLevel
 from .meta_change import (CmdAdd, CmdRemove, CmdPropAdd, CmdPropRemove, CmdPropUpdate,
                           ParaAdd, ParaRemove, ParaPropAdd, ParaPropRemove, ParaPropUpdate,
-                          SubgroupAdd, SubgroupRemove)
-from ._const import (CMD_PROPERTY_ADD_BREAK_LIST, CMD_PROPERTY_REMOVE_BREAK_LIST,
-                     CMD_PROPERTY_UPDATE_BREAK_LIST, PARA_PROPERTY_REMOVE_BREAK_LIST,
-                     PARA_PROPERTY_ADD_BREAK_LIST, PARA_PROPERTY_UPDATE_BREAK_LIST, META_CHANDE_WHITELIST_FILE_PATH)
+                          SubgroupAdd, SubgroupRemove, SubgroupPropAdd, SubgroupPropRemove, SubgroupPropUpdate)
+from ._const import (SUBGROUP_PROPERTY_ADD_BREAK_LIST, SUBGROUP_PROPERTY_ADD_WARN_LIST,
+                     SUBGROUP_PROPERTY_REMOVE_BREAK_LIST, SUBGROUP_PROPERTY_REMOVE_WARN_LIST,
+                     SUBGROUP_PROPERTY_UPDATE_BREAK_LIST, SUBGROUP_PROPERTY_UPDATE_WARN_LIST,
+                     CMD_PROPERTY_ADD_BREAK_LIST, CMD_PROPERTY_ADD_WARN_LIST,
+                     CMD_PROPERTY_REMOVE_BREAK_LIST, CMD_PROPERTY_REMOVE_WARN_LIST,
+                     CMD_PROPERTY_UPDATE_BREAK_LIST, CMD_PROPERTY_UPDATE_WARN_LIST,
+                     PARA_PROPERTY_REMOVE_BREAK_LIST, PARA_PROPERTY_REMOVE_WARN_LIST,
+                     PARA_PROPERTY_ADD_BREAK_LIST, PARA_PROPERTY_ADD_WARN_LIST,
+                     PARA_PROPERTY_UPDATE_BREAK_LIST, PARA_PROPERTY_UPDATE_WARN_LIST,
+                     CMD_REMOVE_SUFFIX_WARN_LIST,
+                     META_CHANDE_WHITELIST_FILE_PATH)
 
 logger = logging.getLogger(__name__)
 
 
 class MetaChangeDetect:
 
-    EXPORTED_META_PROPERTY = ["rule_id", "rule_link_url", "is_break", "rule_message", "suggest_message", "cmd_name", "subgroup_name"]
+    EXPORTED_META_PROPERTY = ["rule_id", "rule_link_url", "is_break", "diff_level",
+                              "rule_message", "suggest_message", "cmd_name", "subgroup_name"]
     CHECKED_PARA_PROPERTY = ["name", "options", "required", "choices", "id_part", "nargs", "default", "desc",
-                             "aaz_type", "type", "aaz_default", "aaz_choices"]
+                             "aaz_type", "type", "aaz_default", "aaz_choices",
+                             "deprecate_info_target", "deprecate_info_redirect", "deprecate_info_hide",
+                             "deprecate_info_expiration",
+                             "options_deprecate_info"]
 
     def __init__(self, deep_diff=None, base_meta=None, diff_meta=None):
         self.deep_diff = {}
@@ -68,6 +81,69 @@ class MetaChangeDetect:
     def __log_cmd_with_parameter_change(self, cmd_name):
         self.cmd_set_with_parameter_change.add(cmd_name)
 
+    def __process_subgroup_items(self, dict_key, subgroup_name, diff_type):
+        has_subgroup_key, subgroup_property = extract_subgroup_property(dict_key, subgroup_name)
+        if not has_subgroup_key:
+            if diff_type == ChangeType.REMOVE:
+                diff_obj = SubgroupRemove(subgroup_name)
+            else:
+                diff_obj = SubgroupAdd(subgroup_name)
+            self.diff_objs.append(diff_obj)
+            return
+
+        # deal with deprecate_info expanded key's add/remove/update
+        if diff_type == ChangeType.ADD:
+            if subgroup_property in SUBGROUP_PROPERTY_ADD_WARN_LIST:
+                diff_obj = SubgroupPropAdd(subgroup_name, subgroup_property, False, DiffLevel.WARN)
+            elif subgroup_property in SUBGROUP_PROPERTY_ADD_BREAK_LIST:
+                diff_obj = SubgroupPropAdd(subgroup_name, subgroup_property, True, DiffLevel.BREAK)
+            else:
+                diff_obj = SubgroupPropAdd(subgroup_name, subgroup_property, False, DiffLevel.INFO)
+            self.diff_objs.append(diff_obj)
+        else:
+            if subgroup_property in SUBGROUP_PROPERTY_REMOVE_WARN_LIST:
+                diff_obj = SubgroupPropRemove(subgroup_name, subgroup_property, False, DiffLevel.WARN)
+            elif subgroup_property in SUBGROUP_PROPERTY_REMOVE_BREAK_LIST:
+                diff_obj = SubgroupPropRemove(subgroup_name, subgroup_property, True, DiffLevel.BREAK)
+            else:
+                diff_obj = SubgroupPropRemove(subgroup_name, subgroup_property, False, DiffLevel.INFO)
+            self.diff_objs.append(diff_obj)
+
+    def __process_cmd_items(self, dict_key, cmd_name, diff_type):
+        has_cmd_key, cmd_property = extract_cmd_property(dict_key, cmd_name)
+        if not has_cmd_key:
+            if diff_type == ChangeType.REMOVE:
+                if cmd_name.split()[-1] in CMD_REMOVE_SUFFIX_WARN_LIST:
+                    diff_obj = CmdRemove(cmd_name, False, DiffLevel.WARN)
+                else:
+                    diff_obj = CmdRemove(cmd_name, True, DiffLevel.BREAK)
+            else:
+                diff_obj = CmdAdd(cmd_name)
+
+            self.diff_objs.append(diff_obj)
+            return
+
+        if cmd_property == "parameters":
+            self.__log_cmd_with_parameter_change(cmd_name)
+            return
+
+        if diff_type == ChangeType.ADD:
+            if cmd_property in CMD_PROPERTY_ADD_WARN_LIST:
+                diff_obj = CmdPropAdd(cmd_name, cmd_property, False, DiffLevel.WARN)
+            elif cmd_property in CMD_PROPERTY_ADD_BREAK_LIST:
+                diff_obj = CmdPropAdd(cmd_name, cmd_property, True, DiffLevel.BREAK)
+            else:
+                diff_obj = CmdPropAdd(cmd_name, cmd_property, False, DiffLevel.INFO)
+            self.diff_objs.append(diff_obj)
+        else:
+            if cmd_property in CMD_PROPERTY_REMOVE_WARN_LIST:
+                diff_obj = CmdPropRemove(cmd_name, cmd_property, False, DiffLevel.WARN)
+            elif cmd_property in CMD_PROPERTY_REMOVE_BREAK_LIST:
+                diff_obj = CmdPropRemove(cmd_name, cmd_property, True, DiffLevel.BREAK)
+            else:
+                diff_obj = CmdPropRemove(cmd_name, cmd_property, False, DiffLevel.INFO)
+            self.diff_objs.append(diff_obj)
+
     def __iter_dict_items(self, dict_items, diff_type):
         if diff_type not in [ChangeType.REMOVE, ChangeType.ADD]:
             raise Exception("Unsupported dict item type")
@@ -78,42 +154,16 @@ class MetaChangeDetect:
                 has_subgroup, subgroup_name = extract_subgroup_name(dict_key)
                 if not has_subgroup or not subgroup_name:
                     continue
-                if diff_type == ChangeType.REMOVE:
-                    diff_obj = SubgroupRemove(subgroup_name)
-                else:
-                    diff_obj = SubgroupAdd(subgroup_name)
-                self.diff_objs.append(diff_obj)
+                self.__process_subgroup_items(dict_key, subgroup_name, diff_type)
                 continue
-
-            has_cmd_key, cmd_property = extract_cmd_property(dict_key, cmd_name)
-            if has_cmd_key:
-                if cmd_property == "parameters":
-                    self.__log_cmd_with_parameter_change(cmd_name)
-                elif diff_type == ChangeType.ADD:
-                    if cmd_property in CMD_PROPERTY_ADD_BREAK_LIST:
-                        diff_obj = CmdPropAdd(cmd_name, cmd_property, True)
-                    else:
-                        diff_obj = CmdPropAdd(cmd_name, cmd_property, False)
-                    self.diff_objs.append(diff_obj)
-                else:
-                    if cmd_property in CMD_PROPERTY_REMOVE_BREAK_LIST:
-                        diff_obj = CmdPropRemove(cmd_name, cmd_property, True)
-                    else:
-                        diff_obj = CmdPropRemove(cmd_name, cmd_property, False)
-                    self.diff_objs.append(diff_obj)
-            else:
-                if diff_type == ChangeType.REMOVE:
-                    diff_obj = CmdRemove(cmd_name)
-                else:
-                    diff_obj = CmdAdd(cmd_name)
-
-                self.diff_objs.append(diff_obj)
+            self.__process_cmd_items(dict_key, cmd_name, diff_type)
 
     def __iter_list_items(self, list_items, diff_type):
         """
+        ['parameters'][3]
         ['parameters'][0]['options'][1]
         ['parameters'][0]['choices'][0]
-        ['parameters'][3]
+        ['parameters'][5]['options_deprecate_info'][1]
         """
         if diff_type not in [ChangeType.REMOVE, ChangeType.ADD]:
             raise Exception("Unsupported dict item type")
@@ -154,7 +204,41 @@ class MetaChangeDetect:
         list_item_add = self.deep_diff["iterable_item_added"]
         self.__iter_list_items(list_item_add, ChangeType.ADD)
 
+    def __process_subgroup_value_change(self, key, subgroup_name, old_value, new_value):
+        has_subgroup_prop, subgroup_property = extract_subgroup_property(key, subgroup_name)
+        if not has_subgroup_prop:
+            # subgroup key does not change independently, it must be followed by some cmd property
+            return
+        if subgroup_property in SUBGROUP_PROPERTY_UPDATE_WARN_LIST:
+            diff_obj = SubgroupPropUpdate(subgroup_name, subgroup_property, False, DiffLevel.WARN, old_value, new_value)
+        elif subgroup_property in SUBGROUP_PROPERTY_UPDATE_BREAK_LIST:
+            diff_obj = SubgroupPropUpdate(subgroup_name, subgroup_property, True, DiffLevel.BREAK, old_value, new_value)
+        else:
+            diff_obj = SubgroupPropUpdate(subgroup_name, subgroup_property, False, DiffLevel.INFO, old_value, new_value)
+        self.diff_objs.append(diff_obj)
+
+    def __process_cmd_value_change(self, key, cmd_name, old_value, new_value):
+        has_cmd_prop, cmd_property = extract_cmd_property(key, cmd_name)
+        if not has_cmd_prop:
+            # cmd key does not change independently, it must followed by some cmd property
+            return
+        if cmd_property == "parameters":
+            self.__log_cmd_with_parameter_change(cmd_name)
+            return
+
+        if cmd_property in CMD_PROPERTY_UPDATE_WARN_LIST:
+            diff_obj = CmdPropUpdate(cmd_name, cmd_property, False, DiffLevel.WARN, old_value, new_value)
+        elif cmd_property in CMD_PROPERTY_UPDATE_BREAK_LIST:
+            diff_obj = CmdPropUpdate(cmd_name, cmd_property, True, DiffLevel.BREAK, old_value, new_value)
+        else:
+            diff_obj = CmdPropUpdate(cmd_name, cmd_property, False, DiffLevel.INFO, old_value, new_value)
+        self.diff_objs.append(diff_obj)
+
     def check_value_change(self):
+        """
+        ['sub_groups']['acr']['deprecate_info_redirect']
+        ['commands']['acr helm show']['deprecate_info_redirect']
+        """
         if not self.deep_diff.get("values_changed", None):
             return
         value_changes = self.deep_diff["values_changed"]
@@ -163,20 +247,13 @@ class MetaChangeDetect:
             new_value = value_obj["new_value"]
             has_cmd, cmd_name = extract_cmd_name(key)
             if not has_cmd or not cmd_name:
-                print("extract cmd failed for " + key)
+                has_subgroup, subgroup_name = extract_subgroup_name(key)
+                if not has_subgroup or not subgroup_name:
+                    print("extract cmd or sub group failed for " + key)
+                    continue
+                self.__process_subgroup_value_change(key, subgroup_name, old_value, new_value)
                 continue
-
-            has_cmd_prop, cmd_property = extract_cmd_property(key, cmd_name)
-            if not has_cmd_prop:
-                return
-            if cmd_property == "parameters":
-                self.__log_cmd_with_parameter_change(cmd_name)
-            else:
-                if cmd_property in CMD_PROPERTY_UPDATE_BREAK_LIST:
-                    diff_obj = CmdPropUpdate(cmd_name, cmd_property, True, old_value, new_value)
-                else:
-                    diff_obj = CmdPropUpdate(cmd_name, cmd_property, False, old_value, new_value)
-                self.diff_objs.append(diff_obj)
+            self.__process_cmd_value_change(key, cmd_name, old_value, new_value)
 
     @staticmethod
     def __search_para_with_name_and_options(base_para_obj, search_parameters):
@@ -192,6 +269,39 @@ class MetaChangeDetect:
                 return para_obj
         return None
 
+    def __process_parameter_value_update(self, cmd_name, prop, base_para_obj, base_val, cmp_val):
+        if base_val == cmp_val:
+            return
+        if prop == "options_deprecate_info":
+            diff_obj = ParaPropUpdate(cmd_name, base_para_obj["name"], prop, False, DiffLevel.INFO,
+                                      base_val, cmp_val)
+            self.diff_objs.append(diff_obj)
+            return
+        if isinstance(base_val, list) and isinstance(cmp_val, list):
+            if set(base_val).issubset(set(cmp_val)):
+                diff_obj = ParaPropUpdate(cmd_name, base_para_obj["name"], prop, False, DiffLevel.INFO,
+                                          base_val, cmp_val)
+            else:
+                if prop in PARA_PROPERTY_UPDATE_WARN_LIST:
+                    diff_obj = ParaPropUpdate(cmd_name, base_para_obj["name"], prop, False, DiffLevel.WARN,
+                                              base_val, cmp_val)
+                else:
+                    diff_obj = ParaPropUpdate(cmd_name, base_para_obj["name"], prop, True, DiffLevel.BREAK,
+                                              base_val, cmp_val)
+            self.diff_objs.append(diff_obj)
+            return
+
+        if prop in PARA_PROPERTY_UPDATE_WARN_LIST:
+            diff_obj = ParaPropUpdate(cmd_name, base_para_obj["name"], prop, False, DiffLevel.WARN,
+                                      base_val, cmp_val)
+        elif prop in PARA_PROPERTY_UPDATE_BREAK_LIST:
+            diff_obj = ParaPropUpdate(cmd_name, base_para_obj["name"], prop, True, DiffLevel.BREAK,
+                                      base_val, cmp_val)
+        else:
+            diff_obj = ParaPropUpdate(cmd_name, base_para_obj["name"], prop, False, DiffLevel.INFO,
+                                      base_val, cmp_val)
+        self.diff_objs.append(diff_obj)
+
     def check_cmd_parameter_diff(self, cmd_name, base_parameters, cmp_parameters):
         """check cmd parameter diff"""
         for base_para_obj in base_parameters:
@@ -199,7 +309,7 @@ class MetaChangeDetect:
             cmp_para_obj = self.__search_para_with_name_and_options(base_para_obj, cmp_parameters)
             if cmp_para_obj is None:
                 # cmd lost parameter obj, is break
-                diff_obj = ParaRemove(cmd_name, base_para_obj["name"], True)
+                diff_obj = ParaRemove(cmd_name, base_para_obj["name"], True, DiffLevel.BREAK)
                 # add flag to avoid duplicate compare
                 self.diff_objs.append(diff_obj)
                 continue
@@ -210,36 +320,36 @@ class MetaChangeDetect:
                 if prop in base_para_obj and prop not in cmp_para_obj:
                     # prop dropped in new para obj
                     prop_value = base_para_obj[prop]
-                    if prop in PARA_PROPERTY_REMOVE_BREAK_LIST:
-                        diff_obj = ParaPropRemove(cmd_name, base_para_obj["name"], prop, prop_value, True)
+                    if prop in PARA_PROPERTY_REMOVE_WARN_LIST:
+                        diff_obj = ParaPropRemove(cmd_name, base_para_obj["name"], prop, prop_value,
+                                                  False, DiffLevel.WARN)
+                    elif prop in PARA_PROPERTY_REMOVE_BREAK_LIST:
+                        diff_obj = ParaPropRemove(cmd_name, base_para_obj["name"], prop, prop_value,
+                                                  True, DiffLevel.BREAK)
                     else:
-                        diff_obj = ParaPropRemove(cmd_name, base_para_obj["name"], prop, prop_value, False)
+                        diff_obj = ParaPropRemove(cmd_name, base_para_obj["name"], prop, prop_value,
+                                                  False, DiffLevel.INFO)
                     self.diff_objs.append(diff_obj)
                     continue
                 if prop not in base_para_obj and prop in cmp_para_obj:
                     # prop added in new para obj
                     prop_value = cmp_para_obj[prop]
-                    if prop in PARA_PROPERTY_ADD_BREAK_LIST:
-                        diff_obj = ParaPropAdd(cmd_name, base_para_obj["name"], prop, prop_value, True)
+                    if prop in PARA_PROPERTY_ADD_WARN_LIST:
+                        diff_obj = ParaPropAdd(cmd_name, base_para_obj["name"], prop, prop_value,
+                                               False, DiffLevel.WARN)
+                    elif prop in PARA_PROPERTY_ADD_BREAK_LIST:
+                        diff_obj = ParaPropAdd(cmd_name, base_para_obj["name"], prop, prop_value,
+                                               True, DiffLevel.BREAK)
                     else:
-                        diff_obj = ParaPropAdd(cmd_name, base_para_obj["name"], prop, prop_value, False)
+                        diff_obj = ParaPropAdd(cmd_name, base_para_obj["name"], prop, prop_value,
+                                               False, DiffLevel.INFO)
                     self.diff_objs.append(diff_obj)
                     continue
                 # prop exists in both new and old para obj, value needs to be checked
                 base_val = base_para_obj[prop]
                 cmp_val = cmp_para_obj[prop]
-
-                if base_val != cmp_val:
-                    if isinstance(base_val, list) and isinstance(cmp_val, list):
-                        if set(base_val).issubset(set(cmp_val)):
-                            diff_obj = ParaPropUpdate(cmd_name, base_para_obj["name"], prop, False, base_val, cmp_val)
-                        else:
-                            diff_obj = ParaPropUpdate(cmd_name, base_para_obj["name"], prop, True, base_val, cmp_val)
-                    elif prop in PARA_PROPERTY_UPDATE_BREAK_LIST:
-                        diff_obj = ParaPropUpdate(cmd_name, base_para_obj["name"], prop, True, base_val, cmp_val)
-                    else:
-                        diff_obj = ParaPropUpdate(cmd_name, base_para_obj["name"], prop, False, base_val, cmp_val)
-                    self.diff_objs.append(diff_obj)
+                self.__process_parameter_value_update(cmd_name, prop, base_para_obj, base_val, cmp_val)
+                continue
 
         # check added parameter obj, if obj is required, then is break
         for cmp_para_obj in cmp_parameters:
@@ -248,9 +358,9 @@ class MetaChangeDetect:
             para_name = cmp_para_obj["name"]
             required = cmp_para_obj.get("required", None)
             if required:
-                diff_obj = ParaAdd(cmd_name, para_name, True)
+                diff_obj = ParaAdd(cmd_name, para_name, True, DiffLevel.BREAK)
             else:
-                diff_obj = ParaAdd(cmd_name, para_name, False)
+                diff_obj = ParaAdd(cmd_name, para_name, False, DiffLevel.INFO)
             self.diff_objs.append(diff_obj)
 
     def check_cmds_parameter_diff(self):
@@ -276,6 +386,9 @@ class MetaChangeDetect:
         self.diff_objs = new_diff_objs
 
     def check_deep_diffs(self):
+        for diff_type, diff_key in self.deep_diff.items():
+            for it in diff_key:
+                    print(diff_type, ": ", it)
         self.check_dict_item_remove()
         self.check_dict_item_add()
         self.check_list_item_remove()

{azure-cli-diff-tool-0.0.4 → azure-cli-diff-tool-0.0.6}/azure_cli_diff_tool/utils.py

@@ -54,6 +54,13 @@ class ChangeType(int, Enum):
     REMOVE = 3
 
 
+class DiffLevel(int, Enum):
+    DEFAULT = 0
+    INFO = 1
+    WARN = 2
+    BREAK = 3
+
+
 def get_command_tree(command_name):
     """
     input: monitor log-profiles create
@@ -158,6 +165,22 @@ def extract_subgroup_name(key):
     return True, subgroup_ame_res[-1]
 
 
+def extract_subgroup_property(key, subgroup_name):
+    subgroup_key_pattern = re.compile(subgroup_name + r"\'\]\[\'([a-zA-Z0-9\-\_]+)\'\]")
+    subgroup_key_res = re.findall(subgroup_key_pattern, key)
+    if not subgroup_key_res or len(subgroup_key_res) == 0:
+        return False, None
+    return True, subgroup_key_res[0]
+
+
+def extract_subgroup_deprecate_property(key, deprecate_key):
+    subgroup_deprecate_key_pattern = re.compile(deprecate_key + r"\'\]\[\'([a-zA-Z0-9\-\_]+)\'\]")
+    subgroup_deprecate_key_res = re.findall(subgroup_deprecate_key_pattern, key)
+    if not subgroup_deprecate_key_res or len(subgroup_deprecate_key_res) == 0:
+        return False, None
+    return True, subgroup_deprecate_key_res[0]
+
+
 def extract_cmd_name(key):
     cmd_name_res = re.findall(CMD_NAME_PATTERN, key)
     if not cmd_name_res or len(cmd_name_res) == 0:
@@ -173,6 +196,13 @@ def extract_cmd_property(key, cmd_name):
     return True, cmd_key_res[0]
 
 
+def extract_cmd_deprecate_property(key, deprecate_key):
+    cmd_deprecate_key_pattern = re.compile(deprecate_key + r"\'\]\[\'([a-zA-Z0-9\-\_]+)\'\]")
+    cmd_deprecate_key_res = re.findall(cmd_deprecate_key_pattern, key)
+    if not cmd_deprecate_key_res or len(cmd_deprecate_key_res) == 0:
+        return False, None
+    return True, cmd_deprecate_key_res[0]
+
 def extract_para_info(key):
     parameters_ind = key.find("['parameters']")
     property_ind = key.find("[", parameters_ind + 1)
@@ -244,3 +274,22 @@ def export_meta_changes_to_dict(module_diffs, version_diff_file):
         writer = csv.writer(f)
         writer.writerows(dict_res)
     return None
+
+
+def expand_deprecate_obj(meta_obj):
+    if type(meta_obj) is not dict:
+        return
+    for key, obj in meta_obj.items():
+        if type(obj) is dict:
+            if obj.get("deprecate_info", None):
+                for dekey, devalue in obj["deprecate_info"].items():
+                    obj["deprecate_info_" + dekey] = devalue
+                del obj["deprecate_info"]
+            expand_deprecate_obj(obj)
+        elif type(obj) is list:
+            for ind, item in enumerate(obj):
+                if type(item) is dict and item.get("deprecate_info", None):
+                    for dekey, devalue in item["deprecate_info"].items():
+                        obj[ind]["deprecate_info_" + dekey] = devalue
+                    del item["deprecate_info"]
+                expand_deprecate_obj(item)

{azure-cli-diff-tool-0.0.4 → azure-cli-diff-tool-0.0.6}/azure_cli_diff_tool.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: azure-cli-diff-tool
-Version: 0.0.4
+Version: 0.0.6
 Summary: A tool for cli metadata management
 Author: Microsoft Corporation
 Author-email: azpycli@microsoft.com
@@ -98,6 +98,15 @@ License
 
 Release History
 ===============
+0.0.6
+++++++
+* Add diff support for deprecate_info in subgroup, cmd, parameters and options
+
+0.0.5
+++++++
+* Add `DiffLevel` to meta comparison
+* Downgrade change level according to warn list
+
 0.0.4
 ++++++
 * Add meta change parameter update warn list

azure-cli-diff-tool-0.0.6/tests/test_break_change.py

@@ -0,0 +1,168 @@
+# -----------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# -----------------------------------------------------------------------------
+# pylint: disable=line-too-long
+
+import unittest
+import os
+from azure_cli_diff_tool import meta_diff
+from azure_cli_diff_tool.utils import get_command_tree, extract_cmd_name, extract_cmd_property, extract_para_info, \
+    extract_subgroup_name, extract_subgroup_deprecate_property, expand_deprecate_obj
+
+
+class MyTestCase(unittest.TestCase):
+
+    def test_parse_cmd_tree(self):
+        cmd_name = "monitor log-profiles create"
+        ret = get_command_tree(cmd_name)
+        self.assertTrue(ret["is_group"], "group parse failed")
+        self.assertFalse(ret["sub_info"]["sub_info"]["is_group"], "group parse failed")
+        self.assertTrue(ret["sub_info"]["sub_info"]["cmd_name"] == "monitor log-profiles create", "group parse failed")
+
+    def test_diff_dict_key_parse(self):
+        test_key = "root['sub_groups']['monitor']['sub_groups']['monitor private-link-scope']['sub_groups']" \
+                   "['monitor private-link-scope scoped-resource']['commands']" \
+                   "['monitor private-link-scope scoped-resource list']['parameters'][0]['options'][1]"
+        has_cmd, cmd_name = extract_cmd_name(test_key)
+        self.assertTrue(has_cmd, "cmd parse failed from diff dict key")
+        self.assertEqual(cmd_name, "monitor private-link-scope scoped-resource list", "cmd name extract failed")
+        has_cmd_key, cmd_key = extract_cmd_property(test_key, cmd_name)
+        self.assertTrue(has_cmd_key, "cmd property parse failed from diff dict key")
+        self.assertEqual(cmd_key, "parameters", "cmd property extract failed")
+        para_res = extract_para_info(test_key)
+        self.assertEqual(para_res[0], "0", "cmd parameter parse failed")
+
+    def test_diff_dict_key_for_subgroups(self):
+        test_key = "root['sub_groups']['monitor']['sub_groups']['monitor account']"
+        has_cmd, _ = extract_cmd_name(test_key)
+        self.assertFalse(has_cmd, "cmd parse error from diff dict key")
+        has_subgroup, subgroup_name = extract_subgroup_name(test_key)
+        self.assertTrue(has_subgroup, "sub group parse failed from diff dict key")
+        self.assertEqual(subgroup_name, "monitor account", "sub group name extract failed")
+
+    def test_diff_dict_key_for_subgroups_deprecate_info(self):
+        test_key = "root['sub_groups']['acr']['deprecate_info']['hide']"
+        has_cmd, _ = extract_cmd_name(test_key)
+        self.assertFalse(has_cmd, "cmd parse error from diff dict key")
+        has_subgroup, subgroup_name = extract_subgroup_name(test_key)
+        self.assertTrue(has_subgroup, "sub group parse failed from diff dict key")
+        self.assertEqual(subgroup_name, "acr", "sub group name extract failed")
+        has_subgroup_deprecate_prop, subgroup_deprecate_prop = extract_subgroup_deprecate_property(test_key, "deprecate_info")
+        self.assertTrue(has_subgroup_deprecate_prop, "sub group deprecate info prop parse failed from diff dict key")
+        self.assertEqual(subgroup_deprecate_prop, "hide", "sub group deprecate prop extract failed")
+
+    def test_diff_meta(self):
+        if not os.path.exists("./jsons/az_monitor_meta_before.json") \
+                or not os.path.exists("./jsons/az_monitor_meta_after.json"):
+            return
+        result = meta_diff(base_meta_file="./jsons/az_monitor_meta_before.json",
+                           diff_meta_file="./jsons/az_monitor_meta_after.json",
+                           output_type="text")
+        target_message = [
+            "please confirm cmd `monitor private-link-scope scoped-resource show` removed",
+            "sub group `monitor private-link-scope private-endpoint-connection cust` removed",
+            "cmd `monitor private-link-scope private-link-resource list` update parameter `scope_name`: added property `type=string`",
+            "cmd `monitor private-link-scope private-link-resource list` update parameter `resource_group_name`: removed property `id_part=resource_group` | diff_level: 2"
+        ]
+        for mes in target_message:
+            found = False
+            for line in result:
+                if line.find(mes) > -1:
+                    found = True
+                    break
+            self.assertTrue(found, "target message not found")
+
+        ignored_message = [
+            "updated property `is_aaz` from `False` to `True`"
+        ]
+        for mes in ignored_message:
+            ignored = True
+            for line in result:
+                if line.find(mes) > -1:
+                    ignored = False
+                    break
+            self.assertTrue(ignored, "ignored message found")
+
+    def test_diff_meta_whitelist(self):
+        if not os.path.exists("./jsons/az_ams_meta_before.json") \
+                or not os.path.exists("./jsons/az_ams_meta_after.json"):
+            return
+        result = meta_diff(base_meta_file="./jsons/az_ams_meta_before.json",
+                           diff_meta_file="./jsons/az_ams_meta_after.json",
+                           output_type="text")
+        self.assertEqual(result, [], "returned change isn't empty")
+
+    def test_expand_deprecate_obj(self):
+        example_obj = {
+            "module_name": "acr",
+            "name": "az",
+            "commands": {},
+            "sub_groups": {
+                "acr": {
+                    "name": "acr",
+                    "commands": {
+                        "acr helm list": {
+                            "name": "acr helm list",
+                            "parameters": [{
+                                "name": "resource_group_name",
+                                "deprecate_info": {
+                                    "redirect": "resource_group_name2",
+                                },
+                                "options": ["--resource-group", "-g"],
+                                "id_part": "resource_group"
+                            }, {
+                                "name": "password",
+                                "options": ["--password", "-p"],
+                                "options_deprecate_info": [{
+                                    "target": "--password",
+                                    "redirect": "--registry-password",
+                                }]
+                            }]
+                        }
+                    },
+                    "deprecate_info": {
+                        "target": "acr",
+                        "redirect": "acr3",
+                        "hide": True
+                    }
+                }
+            }
+        }
+        expand_deprecate_obj(example_obj)
+        self.assertEqual(example_obj["sub_groups"]["acr"]["deprecate_info_target"], "acr",
+                        "deprecate info expand not working properly")
+        self.assertEqual(example_obj["sub_groups"]["acr"]["deprecate_info_redirect"], "acr3",
+                        "deprecate info expand not working properly")
+        self.assertEqual(example_obj["sub_groups"]["acr"]["commands"]["acr helm list"]["parameters"][0]["deprecate_info_redirect"], "resource_group_name2", "deprecate info expand not working properly")
+
+    def test_diff_meta_for_deprecate_info(self):
+        if not os.path.exists("./jsons/az_acr_meta_before.json") or not os.path.exists("./jsons/az_acr_meta_after.json"):
+            return
+        result = meta_diff(base_meta_file="./jsons/az_acr_meta_before.json",
+                           diff_meta_file="./jsons/az_acr_meta_after.json",
+                           output_type="text")
+        target_message = [
+            "sub group `acr` added property `deprecate_info_hide` | diff_level: 2",
+            "sub group `acr` updated property `deprecate_info_redirect` from `acr2` to `acr3` | diff_level: 1",
+            "sub group `acr helm` removed property `deprecate_info_target` | diff_level: 1",
+            "sub group `acr helm` removed property `deprecate_info_redirect` | diff_level: 2",
+            "cmd `acr helm list` removed property `deprecate_info_target` | diff_level: 1",
+            "cmd `acr helm list` removed property `deprecate_info_redirect` | diff_level: 2",
+            "cmd `acr helm list` removed property `deprecate_info_hide` | diff_level: 1",
+            "cmd `acr helm show` updated property `deprecate_info_redirect` from `acr helm show2` to `acr helm show3` | diff_level: 2",
+            "cmd `acr helm list` update parameter `repository`: removed property `options_deprecate_info=",
+        ]
+        for mes in target_message:
+            found = False
+            for line in result:
+                if line.find(mes) > -1:
+                    found = True
+                    break
+            print(mes)
+            self.assertTrue(found, "target message not found")
+
+
+if __name__ == '__main__':
+    unittest.main()

azure-cli-diff-tool-0.0.4/tests/test_break_change.py

@@ -1,88 +0,0 @@
-# -----------------------------------------------------------------------------
-# Copyright (c) Microsoft Corporation. All rights reserved.
-# Licensed under the MIT License. See License.txt in the project root for
-# license information.
-# -----------------------------------------------------------------------------
-# pylint: disable=line-too-long
-
-import unittest
-import os
-from azure_cli_diff_tool import meta_diff
-from azure_cli_diff_tool.utils import get_command_tree, extract_cmd_name, extract_cmd_property, extract_para_info, \
-    extract_subgroup_name
-
-
-class MyTestCase(unittest.TestCase):
-
-    def test_parse_cmd_tree(self):
-        cmd_name = "monitor log-profiles create"
-        ret = get_command_tree(cmd_name)
-        self.assertTrue(ret["is_group"], "group parse failed")
-        self.assertFalse(ret["sub_info"]["sub_info"]["is_group"], "group parse failed")
-        self.assertTrue(ret["sub_info"]["sub_info"]["cmd_name"] == "monitor log-profiles create", "group parse failed")
-
-    def test_diff_dict_key_parse(self):
-        test_key = "root['sub_groups']['monitor']['sub_groups']['monitor private-link-scope']['sub_groups']" \
-                   "['monitor private-link-scope scoped-resource']['commands']" \
-                   "['monitor private-link-scope scoped-resource list']['parameters'][0]['options'][1]"
-        has_cmd, cmd_name = extract_cmd_name(test_key)
-        self.assertTrue(has_cmd, "cmd parse failed from diff dict key")
-        self.assertEqual(cmd_name, "monitor private-link-scope scoped-resource list", "cmd name extract failed")
-        has_cmd_key, cmd_key = extract_cmd_property(test_key, cmd_name)
-        self.assertTrue(has_cmd_key, "cmd property parse failed from diff dict key")
-        self.assertEqual(cmd_key, "parameters", "cmd property extract failed")
-        para_res = extract_para_info(test_key)
-        self.assertEqual(para_res[0], "0", "cmd parameter parse failed")
-
-    def test_diff_dict_key_for_subgroups(self):
-        test_key = "root['sub_groups']['monitor']['sub_groups']['monitor account']"
-        has_cmd, _ = extract_cmd_name(test_key)
-        self.assertFalse(has_cmd, "cmd parse error from diff dict key")
-        has_subgroup, subgroup_name = extract_subgroup_name(test_key)
-        self.assertTrue(has_subgroup, "sub group parse failed from diff dict key")
-        self.assertEqual(subgroup_name, "monitor account", "sub group name extract failed")
-
-    def test_diff_meta(self):
-        if not os.path.exists("./jsons/az_monitor_meta_before.json") \
-                or not os.path.exists("./jsons/az_monitor_meta_after.json"):
-            return
-        result = meta_diff(base_meta_file="./jsons/az_monitor_meta_before.json",
-                           diff_meta_file="./jsons/az_monitor_meta_after.json",
-                           output_type="text")
-        target_message = [
-            "please confirm cmd `monitor private-link-scope scoped-resource show` removed",
-            "sub group `monitor private-link-scope private-endpoint-connection cust` removed",
-            "cmd `monitor private-link-scope private-link-resource list` update parameter `scope_name`: added property `type=string`",
-            "cmd `monitor private-link-scope private-link-resource list` update parameter `resource_group_name`: removed property `id_part=resource_group`"
-        ]
-        for mes in target_message:
-            found = False
-            for line in result:
-                if line.find(mes) > -1:
-                    found = True
-                    break
-            self.assertTrue(found, "target message not found")
-
-        ignored_message = [
-            "updated property `is_aaz` from `False` to `True`"
-        ]
-        for mes in ignored_message:
-            ignored = True
-            for line in result:
-                if line.find(mes) > -1:
-                    ignored = False
-                    break
-            self.assertTrue(ignored, "ignored message found")
-
-    def test_diff_meta_whitelist(self):
-        if not os.path.exists("./jsons/az_ams_meta_before.json") \
-                or not os.path.exists("./jsons/az_ams_meta_after.json"):
-            return
-        result = meta_diff(base_meta_file="./jsons/az_ams_meta_before.json",
-                           diff_meta_file="./jsons/az_ams_meta_after.json",
-                           output_type="text")
-        self.assertEqual(result, [], "returned change isn't empty")
-
-
-if __name__ == '__main__':
-    unittest.main()