XmlDiffHelper (Groovy Documentation)

src.main.groovy.com.silly_diff.Helpers.XmlDiffHelper

Some useful hints for this Helper
****************************************************************************
By default CalcDiff() function works in "NonOrderlySafe" mode. It means, that nodes in Lists will be compared without
checking order of nodes.
You can change that by setting "orderlySafeMode" == True.
For example:
XmlList1:
```
<Nodes>
 <Node1/>
 <Node2/>
 <Node3/>
 </Nodes>
 
```
Xml2List2:
```
<Nodes>
 <Node1/>
 <Node3/>
 <Node2/>
 </Nodes>
 
```
1) orderlySafeMode = false; // Default
Result: XmlLists match. No differences where found.
2) orderlySafeMode = true;
Result: Only
matches.
and
are marked as differences.
*****************************************************************************
By default compareNodes() works in "OrderlySafe" mode. It means, that ChildrenNodes will be compared in order as they comes
in original XML feed.
You can change that by setting "orderlySafeCompareChildrenMode" == False.
NOTE! All children will be compared according to selected Mode. Even children included in child included in child etc.
For example:
- Xml1:
 
 <Dealers> <Dealer id="1"> <Prop1> <Prop2> <Prop3> </Dealer> <Dealer id="2"> <Prop1> <Prop2> <Prop3> </Dealer> </Dealers>
- Xml2:
 
 <Dealers> <Dealer id="1"> <Prop1> <Prop3> <Prop2> </Dealer> <Dealer id="2"> <Prop1> <Prop2> <Prop3> </Dealer> </Dealers> 
- 1) orderlySafeCompareChildrenMode = false;
 Result: Xmls match. No differences where found.
- 2) orderlySafeCompareChildrenMode = true; //Default
 Result: Only matches. is marked as differences.
*****************************************************************************
NOTE! You can control orderSafe Modes separately for XmlList and XmlChildren in reason, that as per Autodata's workflow
some WebServices (e.g. "marketing") do not have any default sorting of entities. But internal structure of these entities must follow specific structure.
According to these requirements, default values in Helper are set to
orderableSafeMode = false; // <----- Elements in List can be in any order
orderableSafeCompareChildrenMode = true; // <----- But order of internal elements (children) must match
*****************************************************************************
Note! At the moment Attribute matching is always NON orderableSafe!
Unfortunately, Groovy->ChildNode->attributes() returns Map
that is sorted by AttributeName.
As result, I don't have access to original order of attributes.
*****************************************************************************
Use these attributes to exclude from comparing ChildNodes and NodeAttributes:

a) Ignorable Lists:

1) Attributes.
Put java.util.List<java.lang.String> to ignoreAttrs with xmlPath to Attribute(s) that you want to ignore during comparing.
xmlPath in this case in list of NodeNames, separated with dot "." to your Attribute.
You don't have to put whole path to Attribute.
If you aware, that AttributeName is unique in XML, you can put it to the map.
If you want to exclude Attribute from specific ParentNode only, then you have to put ParentNodeName into the xmlPath.
Note! That last element in tree must be Attribute name and it must be marked with "@". Mostly, it's done for making distinction with #ignoreNodes
For example:

<dealer count="235"> <SpecialProperties count="0"/> </dealer>
xdh.ignoreAttrs = ["SpecialProperties.@count"]; // "count" Attribute from "SpecialProperties" only will be ignored

2) Nodes.
Put java.util.List<java.lang.String> to ignoreNodes with xmlPath to Node(s) that you want to ignore during comparing.
xmlPath in this case in list of NodeNames, separated with dot "." to your Node.
You don't have to put whole path to Node.
If you aware, that NodeName is unique in XML, you can put it to the map.
If you want to exclude Node from specific ParentNode only, then you have to put ParentNodeName into the xmlPath.
Also you can delete Node that has groovy.util.slurpersupport.Attribute. In this case last element in Path must be marked with '@' symbol.
Also you can delete Node that has another groovy.util.slurpersupport.NodeChild or groovy.util.slurpersupport.Attribute.
For doing that, separate your path with '>' symbol. Everything before '>' is related to current groovy.util.slurpersupport.NodeChild itself,
everything after is related to groovy.util.slurpersupport.NodeChildren. In this case you have to put whole path to children element.
For example:

<dealer> <property1/> <SpecialProperties> <property1> <property2> </SpecialProperties> </dealer>
xdh.ignoreAttrs = ["SpecialProperties.property1"]; // "property1" Node from "SpecialProperties" only will be ignored

3) Nodes with Value:
Put java.util.Map<java.lang.String, java.lang.String> to ignoreNodesWValues, where
Key - xmlPath to Node(s) that you want to ignore during comparing,
Value - value that specified Node must have to be ignored.
You don't have to put whole path to Node.
If you aware, that NodeName is unique in XML, you can put it to the map.
If you want to exclude Node from specific ParentNode only, then you have to put ParentNodeName into the xmlPath.
Also you can delete Node that has groovy.util.slurpersupport.Attribute equal to specified Value. In this case last element in Path must be marked with '@' symbol.
Also you can delete Node that has another groovy.util.slurpersupport.NodeChild or groovy.util.slurpersupport.Attribute that is equal to specified Value.
For doing that, separate your path with '>' symbol. Everything before '>' is related to current groovy.util.slurpersupport.NodeChild itself,
everything after is related to groovy.util.slurpersupport.NodeChildren. In this case you have to put whole path to children element.
For example:

<dealer> <SpecialProperties> <property>NVD</property> </SpecialProperties> </dealer> <dealer> <SpecialProperties> <property>Special</property> </SpecialProperties> </dealer> 
xdh.ignoreNodesWValues = ["dealer.SpecialProperties.property" = "Special"]; // Only Dealer2 will be ignored.

b) Ignorable Closures

1) Attributes:
Assign groovy.lang.Closure that accepts 1 groovy.util.slurpersupport.NodeChild parameter to #ignoreCommand.
groovy.lang.Closure must return java.lang.Boolean value only.
true -> Attribute will be ignored
false -> Attribute will be used for comparing
For example:

<dealer count="235"> <SpecialProperties count="0"/> </dealer> xdh.ignoreCommand = {NodeChild XML -> return XML.@count != "" && XML.parent().name() == "SpecialProperties";; }
"count" Attribute from "SpecialProperties" only will be ignored

2) Nodes:
Assign groovy.lang.Closure that accepts 1 groovy.util.slurpersupport.NodeChild parameter to ignoreCommand.
groovy.lang.Closure must return Boolean value only.
true -> Node will be ignored
false -> Node will be used for comparing
For example:

<dealer> <SpecialProperties> <property>NVD</property> <property>Special</property> </SpecialProperties> </dealer> xdh.ignoreCommand = {NodeChild XML -> return XML.name() == "property" && XML.localText()[0] == "NVD";; }
"property" Node with text "NVD" only will be ignored. "property" Node with text "Special" will be compared.

*********************************************
You can use static function MyXmlUtil#walkXmlByPath(String listPath, NodeChild Xml)#walkXmlByPath(String listPath, NodeChild Xml) that accepts 2 parameters

listPath - string of NodeNames separated with "." (dots)

xml - original XML

to get List of nodes that will be consumed by class itself.
*********************************************
Use that to Tests XmlDiffHelper for ignoreFilter

public Tests(){ NodeChild qaXML = new XmlSlurper().parse(new File(props.outputDir+"/example/qa_diff-getDealers")); NodeChild prodXML = new XmlSlurper().parse(new File(props.outputDir+"/example/prod_diff-getDealers")); XmlDiffHelper xdh = new XmlDiffHelper(XmlDiffHelper.walkXmlByPath(listPath, qaXML), XmlDiffHelper.walkXmlByPath(listPath, prodXML)); xdh.setIgnoreAttrs(["SpecialProperties.@count"]); xdh.ignoreCommand = this.&filter; xdh.calcDiff(); public filter(){ return XML.name() == "property" && XML.localText()[0] == "NCV"; } }
****************************************************

Field Summary

Fields
Modifiers	Name	Description
`java.util.List<java.lang.String>`	`ignoreAttrs`	Put java.util.List<java.lang.String> to ignoreAttrs with xmlPath to Attribute(s) that you want to ignore during comparing.
`groovy.lang.Closure<groovy.util.slurpersupport.NodeChild>`	`ignoreCommand`	Assign groovy.lang.Closure that accepts 1 groovy.util.slurpersupport.NodeChild parameter to `ignoreCommand`.
`java.util.List<java.lang.String>`	`ignoreNodes`	Put java.util.List<java.lang.String> to ignoreNodes with xmlPath to Node(s) that you want to ignore during comparing.
`java.util.HashMap<java.lang.String, java.lang.String>`	`ignoreNodesWValues`	Put java.util.Map<java.lang.String, java.lang.String> to `ignoreNodesWValues`, where `Key` - xmlPath to Node(s) that you want to ignore during comparing, `Value` - value that specified Node must have to be ignored.
`java.util.List<java.lang.String>`	`needleHelper`
`java.lang.Boolean`	`orderlySafeChildrenMode`	By default compareNodes() works in "OrderlySafe" mode.
`java.lang.Boolean`	`orderlySafeMode`	By default CalcDiff() function works in "NonOrderlySafe" mode.
`private java.util.List<groovy.util.slurpersupport.NodeChild>`	`source1`
`private java.util.List<groovy.util.slurpersupport.NodeChild>`	`source2`

Constructor Summary

Constructors
Constructor and description
`XmlDiffHelper (java.util.List<groovy.util.slurpersupport.NodeChild> xml1, java.util.List<groovy.util.slurpersupport.NodeChild> xml2)`

Methods Summary

Methods
Type	Name and description
`private java.lang.Boolean`	`_compareAttrs(java.util.Map<java.lang.String, java.lang.String> attrs1, java.util.Map<java.lang.String, java.lang.String> attrs2, java.util.Map<java.lang.String, java.util.List<java.lang.String>> debug)`
`private java.lang.Boolean`	`_compareChildren(java.util.List<groovy.util.slurpersupport.NodeChild> nodeChildren1, java.util.List<groovy.util.slurpersupport.NodeChild> nodeChildren2)`
`private java.lang.Object`	`_deleteIgnoredAttrs(groovy.util.slurpersupport.NodeChild node, java.util.List<java.lang.String> _ref = null)`
`protected groovy.util.slurpersupport.NodeChild`	`_deleteIgnoredElements(groovy.util.slurpersupport.NodeChild node)`
`private java.util.List<groovy.util.slurpersupport.NodeChild>`	`_deleteIgnoredNodes(java.util.List<groovy.util.slurpersupport.NodeChild> Xml, java.util.List<groovy.util.slurpersupport.NodeChild> _ref = null)`
`private java.lang.Boolean`	`_isAttrIgnorable(groovy.util.slurpersupport.NodeChild node)`
`private java.lang.Boolean`	`_isNodeIgnorable(groovy.util.slurpersupport.NodeChild node)`
`void`	`calcDiff()` Performs calculation of differences between consumed java.util.List of groovy.util.slurpersupport.NodeChild.
`java.lang.Boolean`	`compareNodes(groovy.util.slurpersupport.NodeChild node1, groovy.util.slurpersupport.NodeChild node2)` Performs comparison between specified groovy.util.slurpersupport.NodeChild.
`java.lang.String`	`getDiffString(java.lang.Boolean source)` Returns java.lang.String with XML that shows diff found in specified element
`java.util.List<groovy.util.slurpersupport.NodeChild>`	`retainNodes(java.lang.Boolean source)` Performing Diff calculation between consumed java.util.List of groovy.util.slurpersupport.NodeChild and deletion from `source` elements that match with second list.
`void`	`setupFromConfig(java.util.Map params)` Automatically scans `params` for elements that match with names of `public` parameters of XmlDiffHelper and assigns values to them.

- Field Detail
 - public java.util.List<java.lang.String> ignoreAttrs
 
 Put java.util.List<java.lang.String> to ignoreAttrs with xmlPath to Attribute(s) that you want to ignore during comparing.
 xmlPath in this case in list of NodeNames, separated with dot "." to your Attribute.
 You don't have to put whole path to Attribute.
 If you aware, that AttributeName is unique in XML, you can put it to the map.
 If you want to exclude Attribute from specific ParentNode only, then you have to put ParentNodeName into the xmlPath.
 Note! That last element in tree must be Attribute name and it must be marked with "@". Mostly, it's done for making distinction with #ignoreNodes
 For example:
```
<dealer count="235">
 <SpecialProperties count="0"/>
 </dealer>
 
```
 xdh.ignoreAttrs = ["SpecialProperties.@count"]; // "count" Attribute from "SpecialProperties" only will be ignored
 - public groovy.lang.Closure<groovy.util.slurpersupport.NodeChild> ignoreCommand
 
 Assign groovy.lang.Closure that accepts 1 groovy.util.slurpersupport.NodeChild parameter to ignoreCommand.
 groovy.lang.Closure must return Boolean value only.
 true -> Node will be ignored
 false -> Node will be used for comparing
 For example:
```
<dealer>
 <SpecialProperties>
 <property>NVD</property>
 <property>Special</property>
 </SpecialProperties>
 </dealer>
 xdh.ignoreCommand = {NodeChild XML ->
 return XML.name() == "property" && XML.localText()[0] == "NVD";
 ;
 }
```
 "property" Node with text "NVD" only will be ignored. "property" Node with text "Special" will be compared.
 - public java.util.List<java.lang.String> ignoreNodes
 
 Put java.util.List<java.lang.String> to ignoreNodes with xmlPath to Node(s) that you want to ignore during comparing.
 xmlPath in this case in list of NodeNames, separated with dot "." to your Node.
 You don't have to put whole path to Node.
 If you aware, that NodeName is unique in XML, you can put it to the map.
 If you want to exclude Node from specific ParentNode only, then you have to put ParentNodeName into the xmlPath.
 Also you can delete Node that has groovy.util.slurpersupport.Attribute. In this case last element in Path must be marked with '@' symbol.
 Also you can delete Node that has another groovy.util.slurpersupport.NodeChild or groovy.util.slurpersupport.Attribute.
 For doing that, separate your path with '>' symbol. Everything before '>' is related to current groovy.util.slurpersupport.NodeChild itself,
 everything after is related to groovy.util.slurpersupport.NodeChildren. In this case you have to put whole path to children element.
 For example:
```
<dealer>
 <property1/>
 <SpecialProperties>
 <property1>
 <property2>
 </SpecialProperties>
 </dealer>
 
```
 xdh.ignoreAttrs = ["SpecialProperties.property1"]; // "property1" Node from "SpecialProperties" only will be ignored
 - public java.util.HashMap<java.lang.String, java.lang.String> ignoreNodesWValues
 
 Put java.util.Map<java.lang.String, java.lang.String> to ignoreNodesWValues, where
 Key - xmlPath to Node(s) that you want to ignore during comparing,
 Value - value that specified Node must have to be ignored. RegExp expression are also accepted and will be tested.
 You don't have to put whole path to Node.
 If you aware, that NodeName is unique in XML, you can put it to the map.
 If you want to exclude Node from specific ParentNode only, then you have to put ParentNodeName into the xmlPath.
 Also you can delete Node that has groovy.util.slurpersupport.Attribute equal to specified Value. In this case last element in Path must be marked with '@' symbol.
 Also you can delete Node that has another groovy.util.slurpersupport.NodeChild or groovy.util.slurpersupport.Attribute that is equal to specified Value.
 For doing that, separate your path with '>' symbol. Everything before '>' is related to current groovy.util.slurpersupport.NodeChild itself,
 everything after is related to groovy.util.slurpersupport.NodeChildren. In this case you have to put whole path to children element.
 For example:
```
<dealer> 
 <SpecialProperties> 
 <property>NVD</property> 
 </SpecialProperties> 
 </dealer> 
 <dealer> 
 <SpecialProperties> 
 <property>Special</property> 
 </SpecialProperties> 
 </dealer> 
 
```
 xdh.ignoreNodesWValues = ["dealer.SpecialProperties.property" = "Special"]; // Only Dealer2 will be ignored.
 - public java.util.List<java.lang.String> needleHelper
 - public java.lang.Boolean orderlySafeChildrenMode
 
 By default compareNodes() works in "OrderlySafe" mode. It means, that ChildrenNodes will be compared in order as they comes
 in original XML feed.
 You can change that by setting "orderlySafeCompareChildrenMode" == False.
 NOTE! All children will be compared according to selected Mode. Even children included in child included in child etc.
 For example:
 - Xml1:
```
<Dealers>
 <Dealer id="1">
 <Prop1>
 <Prop2>
 <Prop3>
 </Dealer>
 <Dealer id="2">
 <Prop1>
 <Prop2>
 <Prop3>
 </Dealer>
 </Dealers>
 
```
 - Xml2:
```
<Dealers> 
 <Dealer id="1"> 
 <Prop1> 
 <Prop3> 
 <Prop2> 
 </Dealer> 
 <Dealer id="2"> 
 <Prop1> 
 <Prop2> 
 <Prop3> 
 </Dealer> 
 </Dealers> 
 
```
 - 1) orderlySafeCompareChildrenMode = false;
 Result: Xmls match. No differences where found.
 - 2) orderlySafeCompareChildrenMode = true; //Default
 Result: Only matches. is marked as differences.
 - public java.lang.Boolean orderlySafeMode
 
 By default CalcDiff() function works in "NonOrderlySafe" mode. It means, that nodes in Lists will be compared without
 checking order of nodes.
 You can change that by setting "orderlySafeMode" == True.
 For example:
 XmlList1:
```
<Nodes>
 <Node1/>
 <Node2/>
 <Node3/>
 </Nodes>
 
```
 Xml2List2:
```
<Nodes>
 <Node1/>
 <Node3/>
 <Node2/>
 </Nodes>
 
```
 1) orderlySafeMode = false; // Default
 Result: XmlLists match. No differences where found.
 2) orderlySafeMode = true;
 Result: Only matches. and are marked as differences.
 - private java.util.List<groovy.util.slurpersupport.NodeChild> source1
 - private java.util.List<groovy.util.slurpersupport.NodeChild> source2
- Constructor Detail
 - XmlDiffHelper(java.util.List<groovy.util.slurpersupport.NodeChild> xml1, java.util.List<groovy.util.slurpersupport.NodeChild> xml2)
- Method Detail
 - private java.lang.Boolean _compareAttrs(java.util.Map<java.lang.String, java.lang.String> attrs1, java.util.Map<java.lang.String, java.lang.String> attrs2, java.util.Map<java.lang.String, java.util.List<java.lang.String>> debug)
 - private java.lang.Boolean _compareChildren(java.util.List<groovy.util.slurpersupport.NodeChild> nodeChildren1, java.util.List<groovy.util.slurpersupport.NodeChild> nodeChildren2)
 - private java.lang.Object _deleteIgnoredAttrs(groovy.util.slurpersupport.NodeChild node, java.util.List<java.lang.String> _ref = null)
 - protected groovy.util.slurpersupport.NodeChild _deleteIgnoredElements(groovy.util.slurpersupport.NodeChild node)
 - private java.util.List<groovy.util.slurpersupport.NodeChild> _deleteIgnoredNodes(java.util.List<groovy.util.slurpersupport.NodeChild> Xml, java.util.List<groovy.util.slurpersupport.NodeChild> _ref = null)
 - private java.lang.Boolean _isAttrIgnorable(groovy.util.slurpersupport.NodeChild node)
 - private java.lang.Boolean _isNodeIgnorable(groovy.util.slurpersupport.NodeChild node)
 - void calcDiff()
 
 Performs calculation of differences between consumed java.util.List of groovy.util.slurpersupport.NodeChild. Result of Diff calculation depends on parameters specified before calling this method. Every time when called, overrides Diff and output Xml.
 - java.lang.Boolean compareNodes(groovy.util.slurpersupport.NodeChild node1, groovy.util.slurpersupport.NodeChild node2)
 
 Performs comparison between specified groovy.util.slurpersupport.NodeChild. Result of comparison depends on parameters specified before calling this method. If notifications are enabled, may create Console messages with additional info if Diff found. Console messages may appear even if result is true. It depends on orderlySafeChildrenMode. If orderlySafeChildrenMode = false, Diff could be found between 2 child nodes, but match may happen with other child node in future as system will continue comparison with all children on the same level.
 Returns:
 true if both groovy.util.slurpersupport.NodeChild matches
 Parameters:
 node1
 node2
 - @java.lang.Deprecated java.lang.String getDiffString(java.lang.Boolean source)
 
 Returns java.lang.String with XML that shows diff found in specified element
 deprecated:
 This method will not be updated anymore. May be broken in future.
 
 Returns:
 Returns java.lang.String with XML that shows diff found in specified element
 Parameters:
 source - true to use #source1, false to use #source2
 - @java.lang.Deprecated java.util.List<groovy.util.slurpersupport.NodeChild> retainNodes(java.lang.Boolean source)
 
 Performing Diff calculation between consumed java.util.List of groovy.util.slurpersupport.NodeChild and deletion from source elements that match with second list.
 deprecated:
 This method will not be updated anymore. May be broken in future.
 
 Returns:
 Returns java.util.List of groovy.util.slurpersupport.NodeChild with nodes that do not match with second list.
 Parameters:
 source - true to use #source1, false to use #source2
 - void setupFromConfig(java.util.Map params)
 
 Automatically scans params for elements that match with names of public parameters of XmlDiffHelper and assigns values to them.
 Parameters:
 params - java.util.Map of parameters that will be automatically mapped to public parameters of XmlDiffHelper

Summary:
Field
Constructor
Method

| Detail:
Field
Constructor
Method

Groovy Documentation

[Groovy] Class XmlDiffHelper

Field Summary

Constructor Summary

Methods Summary

Field Detail

public java.util.List<java.lang.String> ignoreAttrs

public groovy.lang.Closure<groovy.util.slurpersupport.NodeChild> ignoreCommand

public java.util.List<java.lang.String> ignoreNodes

public java.util.HashMap<java.lang.String, java.lang.String> ignoreNodesWValues

public java.util.List<java.lang.String> needleHelper

public java.lang.Boolean orderlySafeChildrenMode

public java.lang.Boolean orderlySafeMode

private java.util.List<groovy.util.slurpersupport.NodeChild> source1

private java.util.List<groovy.util.slurpersupport.NodeChild> source2

Constructor Detail

XmlDiffHelper(java.util.List<groovy.util.slurpersupport.NodeChild> xml1, java.util.List<groovy.util.slurpersupport.NodeChild> xml2)

Method Detail

private java.lang.Boolean _compareAttrs(java.util.Map<java.lang.String, java.lang.String> attrs1, java.util.Map<java.lang.String, java.lang.String> attrs2, java.util.Map<java.lang.String, java.util.List<java.lang.String>> debug)

private java.lang.Boolean _compareChildren(java.util.List<groovy.util.slurpersupport.NodeChild> nodeChildren1, java.util.List<groovy.util.slurpersupport.NodeChild> nodeChildren2)

private java.lang.Object _deleteIgnoredAttrs(groovy.util.slurpersupport.NodeChild node, java.util.List<java.lang.String> _ref = null)

protected groovy.util.slurpersupport.NodeChild _deleteIgnoredElements(groovy.util.slurpersupport.NodeChild node)

private java.util.List<groovy.util.slurpersupport.NodeChild> _deleteIgnoredNodes(java.util.List<groovy.util.slurpersupport.NodeChild> Xml, java.util.List<groovy.util.slurpersupport.NodeChild> _ref = null)

private java.lang.Boolean _isAttrIgnorable(groovy.util.slurpersupport.NodeChild node)

private java.lang.Boolean _isNodeIgnorable(groovy.util.slurpersupport.NodeChild node)

void calcDiff()

java.lang.Boolean compareNodes(groovy.util.slurpersupport.NodeChild node1, groovy.util.slurpersupport.NodeChild node2)

@java.lang.Deprecated java.lang.String getDiffString(java.lang.Boolean source)

@java.lang.Deprecated java.util.List<groovy.util.slurpersupport.NodeChild> retainNodes(java.lang.Boolean source)

void setupFromConfig(java.util.Map params)