[Cps Path Parser] Fixes for parent path & normalization

This commit fixes issues with Cps Path Parser related to
path normalization and parent path generation when using
descendant paths and ancestor axis.

Issue-ID: CPS-2365
Signed-off-by: danielhanrahan <daniel.hanrahan@est.tech>
Change-Id: I728fc379b134bd62c39a7085650930450c8a8597

diff --git a/cps-path-parser/src/main/antlr4/org/onap/cps/cpspath/parser/antlr4/CpsPath.g4 b/cps-path-parser/src/main/antlr4/org/onap/cps/cpspath/parser/antlr4/CpsPath.g4
index be8d968..444702d 100644 (file)
--- a/cps-path-parser/src/main/antlr4/org/onap/cps/cpspath/parser/antlr4/CpsPath.g4
+++ b/cps-path-parser/src/main/antlr4/org/onap/cps/cpspath/parser/antlr4/CpsPath.g4
@@ -29,19 +29,21 @@ grammar CpsPath ;
 
 cpsPath : ( prefix | descendant ) multipleLeafConditions? textFunctionCondition? containsFunctionCondition? ancestorAxis? EOF ;
 
-ancestorAxis : SLASH KW_ANCESTOR COLONCOLON ancestorPath ;
+slash : SLASH ;
 
-ancestorPath : yangElement ( SLASH yangElement)* ;
+ancestorAxis : KW_ANCESTOR_AXIS_PREFIX ancestorPath ;
 
-textFunctionCondition : SLASH leafName OB KW_TEXT_FUNCTION EQ StringLiteral CB ;
+ancestorPath : yangElement ( slash yangElement)* ;
+
+textFunctionCondition : slash leafName OB KW_TEXT_FUNCTION EQ StringLiteral CB ;
 
 containsFunctionCondition : OB KW_CONTAINS_FUNCTION OP AT leafName COMMA StringLiteral CP CB ;
 
-parent : ( SLASH yangElement)* ;
+parent : ( slash yangElement)* ;
 
-prefix : parent SLASH containerName ;
+prefix : parent slash containerName ;
 
-descendant : SLASH prefix ;
+descendant : slash prefix ;
 
 yangElement : containerName listElementRef? ;
 
@@ -85,7 +87,8 @@ KW_ANCESTOR : 'ancestor' ;
 KW_AND : 'and' ;
 KW_TEXT_FUNCTION: 'text()' ;
 KW_OR : 'or' ;
-KW_CONTAINS_FUNCTION: 'contains' ;
+KW_CONTAINS_FUNCTION : 'contains' ;
+KW_ANCESTOR_AXIS_PREFIX : SLASH KW_ANCESTOR COLONCOLON ;
 
 IntegerLiteral : FragDigits ;
 // Add below type definitions for leafvalue comparision in https://jira.onap.org/browse/CPS-440

diff --git a/cps-path-parser/src/main/java/org/onap/cps/cpspath/parser/CpsPathBuilder.java b/cps-path-parser/src/main/java/org/onap/cps/cpspath/parser/CpsPathBuilder.java
index ac535f5..ed7dbec 100644 (file)
--- a/cps-path-parser/src/main/java/org/onap/cps/cpspath/parser/CpsPathBuilder.java
+++ b/cps-path-parser/src/main/java/org/onap/cps/cpspath/parser/CpsPathBuilder.java
@@ -36,6 +36,8 @@ import org.onap.cps.cpspath.parser.antlr4.CpsPathParser.TextFunctionConditionCon
 
 public class CpsPathBuilder extends CpsPathBaseListener {
 
+    private static final String NO_PARENT_PATH = "";
+
     private static final String OPEN_BRACKET = "[";
 
     private static final String CLOSE_BRACKET = "]";
@@ -46,7 +48,7 @@ public class CpsPathBuilder extends CpsPathBaseListener {
 
     private final StringBuilder normalizedXpathBuilder = new StringBuilder();
 
-    private final StringBuilder normalizedAncestorPathBuilder = new StringBuilder();
+    private int startIndexOfAncestorSchemaNodeIdentifier = 0;
 
     private boolean processingAncestorAxis = false;
 
@@ -54,6 +56,11 @@ public class CpsPathBuilder extends CpsPathBaseListener {
 
     private final List<String> booleanOperators = new ArrayList<>();
 
+    @Override
+    public void exitSlash(final CpsPathParser.SlashContext ctx) {
+        normalizedXpathBuilder.append("/");
+    }
+
     @Override
     public void exitPrefix(final PrefixContext ctx) {
         cpsPathQuery.setXpathPrefix(normalizedXpathBuilder.toString());
@@ -61,7 +68,13 @@ public class CpsPathBuilder extends CpsPathBaseListener {
 
     @Override
     public void exitParent(final CpsPathParser.ParentContext ctx) {
-        cpsPathQuery.setNormalizedParentPath(normalizedXpathBuilder.toString());
+        final String normalizedParentPath;
+        if (normalizedXpathBuilder.toString().equals("/")) {
+            normalizedParentPath = NO_PARENT_PATH;
+        } else {
+            normalizedParentPath = normalizedXpathBuilder.toString();
+        }
+        cpsPathQuery.setNormalizedParentPath(normalizedParentPath);
     }
 
     @Override
@@ -87,8 +100,7 @@ public class CpsPathBuilder extends CpsPathBaseListener {
     @Override
     public void exitDescendant(final DescendantContext ctx) {
         cpsPathQuery.setCpsPathPrefixType(DESCENDANT);
-        cpsPathQuery.setDescendantName(normalizedXpathBuilder.substring(1));
-        normalizedXpathBuilder.insert(0, "/");
+        cpsPathQuery.setDescendantName(normalizedXpathBuilder.substring(2));
     }
 
     @Override
@@ -107,12 +119,15 @@ public class CpsPathBuilder extends CpsPathBaseListener {
     @Override
     public void enterAncestorAxis(final AncestorAxisContext ctx) {
         processingAncestorAxis = true;
+        normalizedXpathBuilder.append("/ancestor::");
+        startIndexOfAncestorSchemaNodeIdentifier = normalizedXpathBuilder.length();
     }
 
     @Override
     public void exitAncestorAxis(final AncestorAxisContext ctx) {
-        cpsPathQuery.setAncestorSchemaNodeIdentifier(normalizedAncestorPathBuilder.substring(1));
         processingAncestorAxis = false;
+        cpsPathQuery.setAncestorSchemaNodeIdentifier(
+                normalizedXpathBuilder.substring(startIndexOfAncestorSchemaNodeIdentifier));
     }
 
     @Override
@@ -130,17 +145,11 @@ public class CpsPathBuilder extends CpsPathBaseListener {
     @Override
     public void enterListElementRef(final CpsPathParser.ListElementRefContext ctx) {
         normalizedXpathBuilder.append(OPEN_BRACKET);
-        if (processingAncestorAxis) {
-            normalizedAncestorPathBuilder.append(OPEN_BRACKET);
-        }
     }
 
     @Override
     public void exitListElementRef(final CpsPathParser.ListElementRefContext ctx) {
         normalizedXpathBuilder.append(CLOSE_BRACKET);
-        if (processingAncestorAxis) {
-            normalizedAncestorPathBuilder.append(CLOSE_BRACKET);
-        }
     }
 
     CpsPathQuery build() {
@@ -153,20 +162,15 @@ public class CpsPathBuilder extends CpsPathBaseListener {
     @Override
     public void exitContainerName(final CpsPathParser.ContainerNameContext ctx) {
         final String containerName = ctx.getText();
-        normalizedXpathBuilder.append("/")
-                .append(containerName);
-        containerNames.add(containerName);
-        if (processingAncestorAxis) {
-            normalizedAncestorPathBuilder.append("/").append(containerName);
+        normalizedXpathBuilder.append(containerName);
+        if (!processingAncestorAxis) {
+            containerNames.add(containerName);
         }
     }
 
     private void leafContext(final String leafName, final String operator, final Object comparisonValue) {
         leafConditions.add(new CpsPathQuery.LeafCondition(leafName, operator, comparisonValue));
         appendCondition(normalizedXpathBuilder, leafName, operator, comparisonValue);
-        if (processingAncestorAxis) {
-            appendCondition(normalizedAncestorPathBuilder, leafName, operator, comparisonValue);
-        }
     }
 
     private void appendCondition(final StringBuilder currentNormalizedPathBuilder, final String name,

diff --git a/cps-path-parser/src/test/groovy/org/onap/cps/cpspath/parser/CpsPathQuerySpec.groovy b/cps-path-parser/src/test/groovy/org/onap/cps/cpspath/parser/CpsPathQuerySpec.groovy
index d0df3c7..16430d2 100644 (file)
--- a/cps-path-parser/src/test/groovy/org/onap/cps/cpspath/parser/CpsPathQuerySpec.groovy
+++ b/cps-path-parser/src/test/groovy/org/onap/cps/cpspath/parser/CpsPathQuerySpec.groovy
@@ -91,13 +91,14 @@ class CpsPathQuerySpec extends Specification {
             'descendant with leaf condition has "<" operator'             | '//cps-path[@key<10]'                                          || "//cps-path[@key<'10']"
             'descendant with leaf condition has ">=" operator'            | '//cps-path[@key>=8]'                                          || "//cps-path[@key>='8']"
             'descendant with leaf condition has "<=" operator'            | '//cps-path[@key<=12]'                                         || "//cps-path[@key<='12']"
-            'descendant with leaf value and ancestor'                     | '//cps-path[@key=1]/ancestor:parent[@key=1]'                   || "//cps-path[@key='1']/ancestor:parent[@key='1']"
+            'descendant with leaf value and ancestor'                     | '//cps-path[@key=1]/ancestor::parent[@key=1]'                  || "//cps-path[@key='1']/ancestor::parent[@key='1']"
             'parent & child'                                              | '/parent/child'                                                || '/parent/child'
             'parent leaf of type Integer & child'                         | '/parent/child[@code=1]/child2'                                || "/parent/child[@code='1']/child2"
             'parent leaf with double quotes'                              | '/parent/child[@code="1"]/child2'                              || "/parent/child[@code='1']/child2"
             'parent leaf with double quotes inside single quotes'         | '/parent/child[@code=\'"1"\']/child2'                          || "/parent/child[@code='\"1\"']/child2"
             'parent leaf with single quotes inside double quotes'         | '/parent/child[@code="\'1\'"]/child2'                          || "/parent/child[@code='''1''']/child2"
             'leaf with single quotes inside double quotes'                | '/parent/child[@code="\'1\'"]'                                 || "/parent/child[@code='''1''']"
+            'leaf with single quotes inside single quotes'                | "/parent/child[@code='I''m quoted']"                           || "/parent/child[@code='I''m quoted']"
             'leaf with more than one attribute'                           | '/parent/child[@key1=1 and @key2="abc"]'                       || "/parent/child[@key1='1' and @key2='abc']"
             'parent & child with more than one attribute'                 | '/parent/child[@key1=1 and @key2="abc"]/child2'                || "/parent/child[@key1='1' and @key2='abc']/child2"
             'leaf with more than one attribute has OR operator'           | '/parent/child[@key1=1 or @key2="abc"]'                        || "/parent/child[@key1='1' or @key2='abc']"

diff --git a/cps-path-parser/src/test/groovy/org/onap/cps/cpspath/parser/CpsPathUtilSpec.groovy b/cps-path-parser/src/test/groovy/org/onap/cps/cpspath/parser/CpsPathUtilSpec.groovy
index d62f337..29bb3c7 100644 (file)
--- a/cps-path-parser/src/test/groovy/org/onap/cps/cpspath/parser/CpsPathUtilSpec.groovy
+++ b/cps-path-parser/src/test/groovy/org/onap/cps/cpspath/parser/CpsPathUtilSpec.groovy
@@ -1,6 +1,6 @@
 /*
  *  ============LICENSE_START=======================================================
- *  Copyright (C) 2022 Nordix Foundation
+ *  Copyright (C) 2022-2024 Nordix Foundation
  *  ================================================================================
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
@@ -36,21 +36,40 @@ class CpsPathUtilSpec extends Specification {
             'single quotes' | "/parent/child[@common-leaf-name='123']"
     }
 
-    def 'Normalized parent xpaths'() {
-        when: 'a given xpath with #scenario is parsed'
-            def result = CpsPathUtil.getNormalizedParentXpath(xpath)
+    def 'Normalized parent paths of absolute paths'() {
+        when: 'a given cps path is parsed'
+            def result = CpsPathUtil.getNormalizedParentXpath(cpsPath)
         then: 'the result is the expected parent path'
             assert result == expectedParentPath
-        where: 'the following xpaths are used'
-            scenario                         | xpath                                 || expectedParentPath
-            'no child'                       | '/parent'                             || ''
-            'child and parent'               | '/parent/child'                       || '/parent'
-            'grand child'                    | '/parent/child/grandChild'            || '/parent/child'
-            'parent & top is list element'   | '/parent[@id=1]/child'                || "/parent[@id='1']"
-            'parent is list element'         | '/parent/child[@id=1]/grandChild'     || "/parent/child[@id='1']"
-            'parent is list element with /'  | "/parent/child[@id='a/b']/grandChild" || "/parent/child[@id='a/b']"
-            'parent is list element with ['  | "/parent/child[@id='a[b']/grandChild" || "/parent/child[@id='a[b']"
-            'parent is list element using "' | '/parent/child[@id="x"]/grandChild'   || "/parent/child[@id='x']"
+        where: 'the following absolute cps paths are used'
+            cpsPath                               || expectedParentPath
+            '/parent'                             || ''
+            '/parent/child'                       || '/parent'
+            '/parent/child/grandChild'            || '/parent/child'
+            '/parent[@id=1]/child'                || "/parent[@id='1']"
+            '/parent/child[@id=1]/grandChild'     || "/parent/child[@id='1']"
+            '/parent/child/grandChild[@id="x"]'   || "/parent/child"
+            '/parent/ancestor::grandparent'       || ''
+            '/parent/child/ancestor::grandparent' || '/parent'
+            '/parent/child/name[text()="value"]'  || '/parent'
+    }
+
+    def 'Normalized parent paths of descendant paths'() {
+        when: 'a given cps path is parsed'
+            def result = CpsPathUtil.getNormalizedParentXpath(cpsPath)
+        then: 'the result is the expected parent path'
+            assert result == expectedParentPath
+        where: 'the following descendant cps paths are used'
+            cpsPath                                || expectedParentPath
+            '//parent'                             || ''
+            '//parent/child'                       || '//parent'
+            '//parent/child/grandChild'            || '//parent/child'
+            '//parent[@id=1]/child'                || "//parent[@id='1']"
+            '//parent/child[@id=1]/grandChild'     || "//parent/child[@id='1']"
+            '//parent/child/grandChild[@id="x"]'   || "//parent/child"
+            '//parent/ancestor::grandparent'       || ''
+            '//parent/child/ancestor::grandparent' || '//parent'
+            '//parent/child/name[text()="value"]'  || '//parent'
     }
 
     def 'Get node ID sequence for given xpath'() {
@@ -67,17 +86,19 @@ class CpsPathUtilSpec extends Specification {
             'parent is list element'         | '/parent/child[@id=1]/grandChild'     || ["parent","child","grandChild"]
             'parent is list element with /'  | "/parent/child[@id='a/b']/grandChild" || ["parent","child","grandChild"]
             'parent is list element with ['  | "/parent/child[@id='a[b']/grandChild" || ["parent","child","grandChild"]
+            'does not include ancestor node' | '/parent/child/ancestor::grandparent' || ["parent","child"]
     }
 
     def 'Recognizing (absolute) xpaths to List elements'() {
         expect: 'check for list returns the correct values'
             assert CpsPathUtil.isPathToListElement(xpath) == expectList
         where: 'the following xpaths are used'
-            xpath                  || expectList
-            '/parent[@id=1]'       || true
-            '/parent[@id=1]/child' || false
-            '/parent/child[@id=1]' || true
-            '//child[@id=1]'       || false
+            xpath                                  || expectList
+            '/parent[@id=1]'                       || true
+            '/parent[@id=1]/child'                 || false
+            '/parent/child[@id=1]'                 || true
+            '//child[@id=1]'                       || false
+            '/parent/ancestor::grandparent[@id=1]' || false
     }
 
     def 'Parsing Exception'() {