Merge pull request #160 from CiscoTestAutomation/default

Consider default in use

Author: Taarini

ncdiff/src/yang/ncdiff/device.py

@@ -726,6 +726,77 @@ def get_xpath(self, node, type=Tag.XPATH, instance=True):
 
         return Composer(self, node).get_xpath(type, instance=instance)
 
+    def default_in_use(self, schema_node):
+        '''
+        High-level api: Given a schema node, return a list of schema nodes
+        that are descendants and their default values are in use, if the given
+        schema node exists in a data tree. This method is useful to determine
+        if a default value for a leaf or leaf-list is in use in a data tree.
+        Parameters
+        ----------
+        schema_node : `Element`
+            A schema node in question.
+        Returns
+        -------
+        list
+            A list of schema nodes that are descendants of the given schema
+            node and their default values are in use if the given schema node
+            exists in a data tree. If such schema node does not exist, it
+            returns an empty list.
+        Code Example::
+            >>> m.load_model('openconfig-interfaces')
+            >>> prefixes = {n[1]: n[2] for n in m.namespaces}
+            >>> nodes = m.models["openconfig-interfaces"].tree.xpath(
+                    "//oc-if:interfaces/oc-if:interface",
+                    namespaces=prefixes,
+                )
+            >>> print(nodes)
+            [<Element {http://openconfig.net/yang/interfaces}interface at 0x7ff632320ac0>]
+            >>> defaults = m.default_in_use(nodes[0])
+            >>> print([m.get_xpath(n) for n in defaults])
+            ...
+        '''
+
+        default_nodes = []
+        for child in schema_node:
+            if (
+                child.get('type') in ('leaf', 'leaf-list') and
+                child.get('default') is not None
+            ):
+                default_nodes.append(child)
+            elif (
+                child.get('type') == 'choice' and
+                child.get('default') is not None
+            ):
+                default_case = child.get('default')
+                default_ns, _ = self.convert_tag(
+                    default_ns='',
+                    tag=child.tag,
+                    src=Tag.LXML_ETREE,
+                    dst=Tag.LXML_XPATH,
+                )
+                default_ns = self.convert_ns(
+                    ns=default_ns,
+                    src=Tag.NAMESPACE,
+                    dst=Tag.PREFIX,
+                )
+                _, tag = self.convert_tag(
+                    default_ns=default_ns,
+                    tag=default_case,
+                    src=Tag.XPATH,
+                    dst=Tag.LXML_ETREE,
+                )
+                default_case_node = child.find(tag)
+                if default_case_node is not None:
+                    default_nodes.append(default_case_node)
+                    default_nodes += self.default_in_use(default_case_node)
+            elif (
+                child.get('type') == 'container' and
+                child.get('presence') != 'true'
+            ):
+                default_nodes += self.default_in_use(child)
+        return default_nodes
+
     def convert_tag(self, default_ns, tag, src=Tag.LXML_ETREE, dst=Tag.YTOOL):
         '''convert_tag
 

ncdiff/src/yang/ncdiff/netconf.py

@@ -141,7 +141,7 @@ class NetconfCalculator(BaseCalculator):
         the specified level, depending on situations. Consider roots in a YANG
         module are level 0, their children are level 1, and so on so forth.
         The default value of replace_depth is 0.
-    
+
     replace_xpath: `str` or `list
         Specify the xpath of the node to be replaced when diff_type is
         'minimum-replace'. The default value of replace_xpath is None.
@@ -1068,10 +1068,12 @@ def node_sub(self, node_self, node_other, depth=0):
             child_other = etree.Element(child_self.tag,
                                         {operation_tag: self.preferred_delete},
                                         nsmap=child_self.nsmap)
-            if self.preferred_create != 'merge':
-                child_self.set(operation_tag, self.preferred_create)
             if self.diff_type == 'replace':
                 child_self.set(operation_tag, 'replace')
+            elif self.preferred_create == 'replace':
+                child_self.set(operation_tag, self.preferred_create)
+            elif self.preferred_create == 'create':
+                self.set_create_operation(child_self)
             siblings = list(node_other.iterchildren(tag=child_self.tag))
             if siblings:
                 siblings[-1].addnext(child_other)
@@ -1100,8 +1102,10 @@ def node_sub(self, node_self, node_other, depth=0):
             child_self = etree.Element(child_other.tag,
                                        {operation_tag: self.preferred_delete},
                                        nsmap=child_other.nsmap)
-            if self.preferred_create != 'merge':
+            if self.preferred_create == 'replace':
                 child_other.set(operation_tag, self.preferred_create)
+            elif self.preferred_create == 'create':
+                self.set_create_operation(child_other)
             siblings = list(node_self.iterchildren(tag=child_other.tag))
             s_node = self.device.get_schema_node(child_other)
             if siblings:
@@ -1226,6 +1230,32 @@ def node_sub(self, node_self, node_other, depth=0):
                             ]
                             item.set(key_tag, ''.join(id_list))
 
+    def set_create_operation(self, node):
+        '''set_create_operation
+        Low-level api: Set the `operation` attribute of a node to `create` when
+        it is not already set. This method is used when the preferred_create is
+        `create`.
+        Parameters
+        ----------
+        node : `Element`
+            A config node in a config tree.
+        Returns
+        -------
+        None
+            There is no return of this method.
+        '''
+
+        schema_node = self.device.get_schema_node(node)
+        if (
+            schema_node.get('type') == 'container' and
+            schema_node.get('presence') != 'true' and
+            len(self.device.default_in_use(schema_node)) > 0
+        ):
+            for child in node:
+                self.set_create_operation(child)
+        else:
+            node.set(operation_tag, 'create')
+
     @staticmethod
     def _url_to_prefix(node, id):
         '''_url_to_prefix

ncdiff/src/yang/ncdiff/tests/test_ncdiff.py

@@ -1367,6 +1367,136 @@ def test_delta_10(self):
         self.assertEqual(str(delta1).strip(), expected_delta1.strip())
         self.assertEqual(str(delta2).strip(), expected_delta2.strip())
 
+    def test_delta_11(self):
+        xml1 = """
+            <rpc-reply xmlns="urn:ietf:params:xml:ns:netconf:base:1.0" message-id="101">
+              <data>
+                <numbers xmlns="urn:jon">
+                  <first>one</first>
+                </numbers>
+                <location xmlns="urn:jon">
+                  <ontario>
+                    <name>Ottawa</name>
+                  </ontario>
+                </location>
+              </data>
+            </rpc-reply>
+            """
+        xml2 = """
+            <rpc-reply xmlns="urn:ietf:params:xml:ns:netconf:base:1.0" message-id="101">
+              <data>
+                <numbers xmlns="urn:jon">
+                  <first>one</first>
+                  <third>three</third>
+                </numbers>
+                <location xmlns="urn:jon">
+                  <alberta>
+                    <name>Calgary</name>
+                  </alberta>
+                  <other-info>
+                    <detail>Some detail</detail>
+                  </other-info>
+                </location>
+              </data>
+            </rpc-reply>
+            """
+        config1 = Config(self.d, xml1)
+        config2 = Config(self.d, xml2)
+        delta1 = config2 - config1
+        delta2 = config1 - config2
+        delta1.preferred_create = "create"
+        delta2.preferred_create = "create"
+        verification = [
+            (delta1, "/nc:config/jon:numbers/jon:third"),
+
+            # Create operation at list alberta is allowed as it does not have
+            # default.
+            (delta1, "/nc:config/jon:location/jon:alberta"),
+
+            # Create operation at other-info is not allowed as it has defaults.
+            (delta1, "/nc:config/jon:location/jon:other-info/jon:detail"),
+
+            (delta2, "/nc:config/jon:location/jon:ontario"),
+        ]
+        for delta, xpath in verification:
+            nodes = delta.nc.xpath(
+                xpath,
+                namespaces=delta.ns)
+            self.assertEqual(
+                len(nodes),
+                1,
+                f"Expected to find xpath '{xpath}' in delta "
+                f"but the delta is {delta.nc}",
+            )
+            for node in nodes:
+                self.assertEqual(
+                    node.get(operation_tag),
+                    "create",
+                    f"Expected 'create' operation at {xpath} "
+                    f"but got the delta {delta.nc} instead.",
+                )
+
+    def test_delta_12(self):
+        xml1 = """
+            <rpc-reply xmlns="urn:ietf:params:xml:ns:netconf:base:1.0" message-id="101">
+              <data>
+                <numbers xmlns="urn:jon">
+                  <first>one</first>
+                </numbers>
+              </data>
+            </rpc-reply>
+            """
+        xml2 = """
+            <rpc-reply xmlns="urn:ietf:params:xml:ns:netconf:base:1.0" message-id="101">
+              <data>
+                <numbers xmlns="urn:jon">
+                  <first>one</first>
+                  <third>three</third>
+                </numbers>
+                <location xmlns="urn:jon">
+                  <alberta>
+                    <name>Calgary</name>
+                  </alberta>
+                  <other-info>
+                    <detail>Some detail</detail>
+                  </other-info>
+                </location>
+              </data>
+            </rpc-reply>
+            """
+        config1 = Config(self.d, xml1)
+        config2 = Config(self.d, xml2)
+        delta1 = config2 - config1
+        delta2 = config1 - config2
+        delta1.preferred_create = "create"
+        delta2.preferred_create = "create"
+        verification = [
+            (delta1, "/nc:config/jon:numbers/jon:third"),
+
+            # Create operation at location is not allowed as it has defaults.
+            (delta1, "/nc:config/jon:location/jon:alberta"),
+
+            # Create operation at other-info is not allowed as it has defaults.
+            (delta1, "/nc:config/jon:location/jon:other-info/jon:detail"),
+        ]
+        for delta, xpath in verification:
+            nodes = delta.nc.xpath(
+                xpath,
+                namespaces=delta.ns)
+            self.assertEqual(
+                len(nodes),
+                1,
+                f"Expected to find xpath '{xpath}' in delta "
+                f"but the delta is {delta.nc}",
+            )
+            for node in nodes:
+                self.assertEqual(
+                    node.get(operation_tag),
+                    "create",
+                    f"Expected 'create' operation at {xpath} "
+                    f"but got the delta {delta.nc} instead.",
+                )
+
     def test_delta_replace_1(self):
         config_xml1 = """
             <rpc-reply xmlns="urn:ietf:params:xml:ns:netconf:base:1.0" message-id="101">
@@ -4512,3 +4642,65 @@ def test_get_1(self):
                        '/oc-netinst:config/oc-netinst:name/text()')
         self.assertEqual(name, ['Mgmt-intf'])
 
+    def test_default_in_use_1(self):
+      prefixes = {n[1]: n[2] for n in self.d.namespaces if n[1] is not None}
+      nodes = self.d.models["jon"].tree.xpath(
+          "/jon/jon:address",
+          namespaces=prefixes,
+      )
+      self.assertEqual(len(nodes), 1)
+      address = nodes[0]
+      defaults = self.d.default_in_use(address)
+      self.assertEqual(len(defaults), 1)
+      self.assertEqual(
+          defaults[0].tag,
+          "{urn:jon}city"
+      )
+
+    def test_default_in_use_2(self):
+      xpaths = [
+          "/jon:location/city/alberta",
+          "/jon:location/city/alberta/other-info/geo-facts/code",
+      ]
+      prefixes = {n[1]: n[2] for n in self.d.namespaces if n[1] is not None}
+      nodes = self.d.models["jon"].tree.xpath(
+          "/jon/jon:location",
+          namespaces=prefixes,
+      )
+      self.assertEqual(len(nodes), 1)
+      address = nodes[0]
+      defaults = self.d.default_in_use(address)
+      xpaths = [
+          self.d.get_xpath(n)
+          for n in defaults
+      ]
+      self.assertEqual(len(defaults), 2)
+      for xpath in xpaths:
+          self.assertIn(xpath, xpaths)
+
+    def test_default_in_use_3(self):
+      xpaths = [
+          "/oc-if:interfaces/interface/oc-vlan:routed-vlan/oc-ip:ipv4"
+          "/unnumbered/config/enabled",
+          "/oc-if:interfaces/interface/oc-vlan:routed-vlan/oc-ip:ipv4"
+          "/unnumbered/state/enabled",
+          "/oc-if:interfaces/interface/oc-vlan:routed-vlan/oc-ip:ipv4"
+          "/config/enabled",
+          "/oc-if:interfaces/interface/oc-vlan:routed-vlan/oc-ip:ipv4"
+          "/state/enabled",
+      ]
+      prefixes = {n[1]: n[2] for n in self.d.namespaces if n[1] is not None}
+      nodes = self.d.models["openconfig-interfaces"].tree.xpath(
+          "//oc-if:interfaces/oc-if:interface/oc-vlan:routed-vlan/oc-ip:ipv4",
+          namespaces=prefixes,
+      )
+      self.assertEqual(len(nodes), 1)
+      interface = nodes[0]
+      defaults = self.d.default_in_use(interface)
+      xpaths = [
+          self.d.get_xpath(n)
+          for n in defaults
+      ]
+      self.assertEqual(len(defaults), 4)
+      for xpath in xpaths:
+          self.assertIn(xpath, xpaths)