parser, replace: Support path as replace value

One of the feature is replacing with the captured state from a capture
entry path. This change add support for it at the parser and create a
unit test for the resolver since resolver has the feature already.

Signed-off-by: Quique Llorente <ellorent@redhat.com>

Author: qinqon

nmpolicy/internal/parser/errors.go

@@ -58,17 +58,17 @@ func invalidPathError(msg string) *parserError {
 	}
 }
 
-func invalidEqualityFilterError(msg string) *parserError {
+func wrapWithInvalidEqualityFilterError(err error) *parserError {
 	return &parserError{
 		prefix: "invalid equality filter",
-		msg:    msg,
+		inner:  err,
 	}
 }
 
-func invalidReplaceError(msg string) *parserError {
+func wrapWithInvalidReplaceError(err error) *parserError {
 	return &parserError{
 		prefix: "invalid replace",
-		msg:    msg,
+		inner:  err,
 	}
 }
 

nmpolicy/internal/parser/parser.go

@@ -200,34 +200,8 @@ func (p *parser) parseEqFilter() error {
 		Meta:     ast.Meta{Position: p.currentToken().Position},
 		EqFilter: &ast.TernaryOperator{},
 	}
-	if p.lastNode == nil {
-		return invalidEqualityFilterError("missing left hand argument")
-	}
-	if p.lastNode.Path == nil {
-		return invalidEqualityFilterError("left hand argument is not a path")
-	}
-
-	p.fillInPipedInOrCurrentState(&operator.EqFilter[0])
-
-	operator.EqFilter[1] = *p.lastNode
-
-	p.nextToken()
-
-	if p.currentToken().Type == lexer.STRING {
-		if err := p.parseString(); err != nil {
-			return err
-		}
-		operator.EqFilter[2] = *p.lastNode
-	} else if p.currentToken().Type == lexer.IDENTITY {
-		err := p.parsePath()
-		if err != nil {
-			return err
-		}
-		operator.EqFilter[2] = *p.lastNode
-	} else if p.currentToken().Type == lexer.EOF {
-		return invalidEqualityFilterError("missing right hand argument")
-	} else {
-		return invalidEqualityFilterError("right hand argument is not a string or identity")
+	if err := p.fillInTernaryOperator(operator.EqFilter); err != nil {
+		return wrapWithInvalidEqualityFilterError(err)
 	}
 	p.lastNode = operator
 	return nil
@@ -238,29 +212,42 @@ func (p *parser) parseReplace() error {
 		Meta:    ast.Meta{Position: p.currentToken().Position},
 		Replace: &ast.TernaryOperator{},
 	}
+	if err := p.fillInTernaryOperator(operator.Replace); err != nil {
+		return wrapWithInvalidReplaceError(err)
+	}
+	p.lastNode = operator
+	return nil
+}
+
+func (p *parser) fillInTernaryOperator(operator *ast.TernaryOperator) error {
 	if p.lastNode == nil {
-		return invalidReplaceError("missing left hand argument")
+		return fmt.Errorf("missing left hand argument")
 	}
 	if p.lastNode.Path == nil {
-		return invalidReplaceError("left hand argument is not a path")
+		return fmt.Errorf("left hand argument is not a path")
 	}
 
-	p.fillInPipedInOrCurrentState(&operator.Replace[0])
+	p.fillInPipedInOrCurrentState(&operator[0])
 
-	operator.Replace[1] = *p.lastNode
+	operator[1] = *p.lastNode
 
 	p.nextToken()
 	if p.currentToken().Type == lexer.STRING {
 		if err := p.parseString(); err != nil {
 			return err
 		}
-		operator.Replace[2] = *p.lastNode
+		operator[2] = *p.lastNode
+	} else if p.currentToken().Type == lexer.IDENTITY {
+		err := p.parsePath()
+		if err != nil {
+			return err
+		}
+		operator[2] = *p.lastNode
 	} else if p.currentToken().Type == lexer.EOF {
-		return invalidReplaceError("missing right hand argument")
+		return fmt.Errorf("missing right hand argument")
 	} else {
-		return invalidReplaceError("right hand argument is not a string")
+		return fmt.Errorf("right hand argument is not a string or identity")
 	}
-	p.lastNode = operator
 	return nil
 }
 

nmpolicy/internal/parser/parser_test.go

@@ -32,6 +32,7 @@ func TestParser(t *testing.T) {
 	testParsePath(t)
 	testParseEqFilter(t)
 	testParseReplace(t)
+	testParseReplaceWithPath(t)
 	testParseCapturePipeReplace(t)
 
 	testParseBasicFailures(t)
@@ -222,7 +223,7 @@ func testParseReplaceFailure(t *testing.T) {
 			),
 		),
 
-		expectError(`invalid replace: right hand argument is not a string
+		expectError(`invalid replace: right hand argument is not a string or identity
 | routes.running.destination:=:=
 | ............................^`,
 			fromTokens(
@@ -376,6 +377,57 @@ replace:
 	runTest(t, tests)
 }
 
+func testParseReplaceWithPath(t *testing.T) {
+	var tests = []test{
+		expectAST(t, `
+pos: 33
+replace:
+- pos: 0
+  identity: currentState
+- pos: 0 
+  path: 
+  - pos: 0 
+    identity: routes
+  - pos: 7
+    identity: running
+  - pos: 15
+    identity: next-hop-interface
+- pos: 35
+  path:
+  - pos: 35
+    identity: capture
+  - pos: 43
+    identity: primary-nic
+  - pos: 55
+    identity: interfaces
+  - pos: 66
+    number: 0
+  - pos: 68
+    identity: name
+`,
+			fromTokens(
+				identity("routes"),
+				dot(),
+				identity("running"),
+				dot(),
+				identity("next-hop-interface"),
+				replace(),
+				identity("capture"),
+				dot(),
+				identity("primary-nic"),
+				dot(),
+				identity("interfaces"),
+				dot(),
+				number(0),
+				dot(),
+				identity("name"),
+				eof(),
+			),
+		),
+	}
+	runTest(t, tests)
+}
+
 func testParseCapturePipeReplace(t *testing.T) {
 	var tests = []test{
 		expectAST(t, `

nmpolicy/internal/resolver/resolver_test.go

@@ -135,8 +135,10 @@ func TestFilter(t *testing.T) {
 		testFilterInvalidTypeOnPath(t)
 		testFilterOptionalField(t)
 		testFilterNonCaptureRefPathAtThirdArg(t)
+
 		testReplaceCurrentState(t)
 		testReplaceCapturedState(t)
+		testReplaceWithCaptureRef(t)
 	})
 }
 
@@ -727,3 +729,97 @@ bridge-routes:
 		runTest(t, &testToRun)
 	})
 }
+
+func testReplaceWithCaptureRef(t *testing.T) {
+	t.Run("Replace list of structs field from capture reference with capture reference value", func(t *testing.T) {
+		testToRun := test{
+			capturedStatesCache: `
+default-gw:
+  state:
+    routes:
+      running:
+      - destination: 0.0.0.0/0
+        next-hop-address: 192.168.100.1
+        next-hop-interface: br1
+        table-id: 254
+
+br1-bridge:
+  state:
+    interfaces:
+    - name: br1
+      type: linux-bridge
+      bridge:
+        port:
+        - name: eth3
+`,
+
+			captureASTPool: `
+default-gw-br1-first-port:
+  pos: 1
+  replace:
+  - pos: 2
+    path:
+    - pos: 3
+      identity: capture
+    - pos: 4
+      identity: default-gw
+  - pos: 3
+    path:
+    - pos: 4
+      identity: routes
+    - pos: 5
+      identity: running
+    - pos: 6
+      identity: next-hop-interface
+  - pos: 7
+    path:
+    - pos: 8
+      identity: capture
+    - pos: 9
+      identity: br1-bridge
+    - pos: 10
+      identity: interfaces
+    - pos: 11
+      number: 0
+    - pos: 12
+      identity: bridge
+    - pos: 13
+      identity: port
+    - pos: 14
+      number: 0
+    - pos: 15
+      identity: name
+`,
+
+			expectedCapturedStates: `
+default-gw:
+  state:
+    routes:
+      running:
+      - destination: 0.0.0.0/0
+        next-hop-address: 192.168.100.1
+        next-hop-interface: br1
+        table-id: 254
+
+br1-bridge:
+  state:
+    interfaces:
+    - name: br1
+      type: linux-bridge
+      bridge:
+        port:
+        - name: eth3
+
+default-gw-br1-first-port:
+  state:
+    routes:
+      running:
+      - destination: 0.0.0.0/0
+        next-hop-address: 192.168.100.1
+        next-hop-interface: eth3
+        table-id: 254
+`,
+		}
+		runTest(t, &testToRun)
+	})
+}