+++ /dev/null
-import argparse
-import logging
-import jsonpatch
-import json
-from jsonpathl import jsonpath
-import types
-import sys
-
-
-"""
-Library for checking differences between json files,
-allowing pre-filtering those files using a number
-of jsonpath expressions
-This library supports the automated verification
-of backup & restore use cases for applications
-Updated: 2017-04-10
-"""
-
-__author__ = "Diego Granados"
-__copyright__ = "Copyright(c) 2017, Ericsson."
-__license__ = "New-style BSD"
-__email__ = "diego.jesus.granados.lopez@ericsson.com"
-
-
-def from_path_to_jsonpatch(matchedpath):
- """Given a json path (using jsonpath notation), to a json patch (RFC 6902)
- which can be used to remove the document fragment pointed by the input path
- Note that such conversion is not formally specified anywhere, so the conversion
- rules are experimentation-based
-
- :param matchedpath: the input path (using jsonpath notation, see http://goessner.net/articles/JsonPath)
- :return: the corresponding json patch for removing the fragment
- """
-
- logging.info("starting. filter path: %s", matchedpath)
-
- # First step: path format change
- # typical input: $['ietf-yang-library:modules-state']['module'][57]
- # desired output: /ietf-yang-library:modules-state/module/57
-
- matchedpath = matchedpath.replace("$.", "/")
- matchedpath = matchedpath.replace("$['", "/")
- matchedpath = matchedpath.replace("']['", "/")
- matchedpath = matchedpath.replace("']", "/")
-
- # this one is for the $[2] pattern
- if "$[" in matchedpath and "]" in matchedpath:
- matchedpath = matchedpath.replace("$[", "/")
- matchedpath = matchedpath.replace("]", "")
-
- matchedpath = matchedpath.replace("[", "")
- matchedpath = matchedpath.replace("]", "")
- matchedpath = matchedpath.rstrip("/")
-
- # Now, for input: /ietf-yang-library:modules-state/module/57
- # desired output: [{"op":"remove","path":"/ietf-yang-library:modules-state/module/57"}]
-
- logging.info("final filter path: %s", matchedpath)
- as_patch = '[{{"op":"remove","path":"{0}"}}]'.format(matchedpath)
- logging.info("generated patch line: %s", as_patch)
- return as_patch
-
-
-def apply_filter(json_arg, filtering_line):
- """Filters a json document by removing the elements identified by a filtering pattern
-
- :param json_arg: the document to filter
- :param filtering_line: The filtering pattern. This is specified using jsonpath notation grammar
- (see http://goessner.net/articles/JsonPath/)
- :return: the filtered document
- """
-
- logging.info("apply_filter:starting. jsonPath filter=[%s]", filtering_line)
-
- res = jsonpath(json_arg, filtering_line, result_type="PATH")
- if isinstance(res, types.BooleanType) or len(res) == 0:
- logging.info("apply_filter: The prefilter [%s] matched nothing", filtering_line)
- return json_arg
- if len(res) > 1:
- raise AssertionError(
- "Bad pre-filter [%s] (returned [%d] entries, should return one at most",
- filtering_line,
- len(res),
- )
- as_json_patch = from_path_to_jsonpatch(res[0])
- logging.info("apply_filter: applying patch! resolved patch =%s", as_json_patch)
- patched_json = jsonpatch.apply_patch(json_arg, as_json_patch)
-
- logging.info("apply_filter: json after patching: %s", patched_json)
- return patched_json
-
-
-def prefilter(json_arg, initial_prefilter):
- """Performs the prefiltering of a json file
- :param json_arg: the json document to filter (as string)
- :type json_arg: str
- :param initial_prefilter: a file containing a number of filtering patterns (using jsonpath notation)
- :return: the original document, python-deserialized and having the fragments
- matched by the filtering patterns removed
- """
-
- if not initial_prefilter:
- logging.info("prefilter not found!")
- # whether it is filtered or not, return as json so it can be handled uniformly from now on
- return json.loads(json_arg)
-
- with open(initial_prefilter) as f:
- lines = f.read().splitlines()
- logging.info("prefilter:lines in prefilter file: %d ", len(lines))
- lines = filter(lambda k: not k.startswith("#"), lines)
- logging.info("prefilter:lines after removing comments: %d ", len(lines))
- json_args_as_json = json.loads(json_arg)
- for filtering_line in lines:
- json_args_as_json = apply_filter(json_args_as_json, filtering_line)
-
- return json_args_as_json
-
-
-def prefilter_json_files_then_compare(args):
- """Main function. Prefilters the input files using provided prefiltering patterns,
- then returns number of differences (and the differences themselves, when requested)
-
- :param args: Input arguments, already parsed
- :return: the number of differences (from a jsonpatch standpoint) between the input
- json files (those input files can be prefiltered using a number of patterns when
- requested)
- """
-
- logging.info("prefilter_json_files_then_compare: starting!")
- with open(args.initialFile) as f:
- json_initial = file.read(f)
- with open(args.finalFile) as f2:
- json_final = file.read(f2)
-
- patch = jsonpatch.JsonPatch.from_diff(json_initial, json_final)
- logging.info(
- "prefilter_json_files_then_compare:differences before patching: %d",
- len(list(patch)),
- )
-
- json_initial_filtered = prefilter(json_initial, args.initial_prefilter)
- json_final_filtered = prefilter(json_final, args.finalPreFilter)
-
- patch_after_filtering = jsonpatch.JsonPatch.from_diff(
- json_initial_filtered, json_final_filtered
- )
- differences_after_patching = list(patch_after_filtering)
- logging.info(
- "prefilter_json_files_then_compare: differences after patching: %d",
- len(differences_after_patching),
- )
-
- if args.printDifferences:
- for patchline in differences_after_patching:
- print(json.dumps(patchline))
-
- print(len(differences_after_patching))
- return len(differences_after_patching)
-
-
-def Json_Diff_Check_Keyword(json_before, json_after, filter_before, filter_after):
- input_argv = [
- "-i",
- json_before,
- "-f",
- json_after,
- "-ipf",
- filter_before,
- "-fpf",
- filter_after,
- "-pd",
- ]
- sys.argv[1:] = input_argv
- logging.info("starting. constructed command line: %s", sys.argv)
- return Json_Diff_Check()
-
-
-def parse_args(args):
- parser = argparse.ArgumentParser(
- description="both initial and final json files are compared for differences. "
- "The program returns 0 when the json contents are the same, or the "
- "number of"
- " differences otherwise. Both json files can be prefiltered for "
- "certain patterns"
- " before checking the differences"
- )
-
- parser.add_argument(
- "-i",
- "--initialFile",
- required="true",
- dest="initialFile",
- action="store",
- help="initial json file",
- )
- parser.add_argument(
- "-f",
- "--finalFile",
- required="true",
- dest="finalFile",
- action="store",
- help="final json file",
- )
- parser.add_argument(
- "-ipf",
- "--initial_prefilter",
- dest="initial_prefilter",
- help="File with pre-filtering patterns to apply to the initial json file before comparing",
- )
- parser.add_argument(
- "-fpf",
- "--finalPreFilter",
- dest="finalPreFilter",
- help="File with pre-filtering patterns to apply to the final json file before comparing",
- )
- parser.add_argument(
- "-pd",
- "--printDifferences",
- action="store_true",
- help="on differences found, prints the list of paths for the found differences before exitting",
- )
- parser.add_argument(
- "-v",
- "--verbose",
- dest="verbose",
- action="store_true",
- help="generate log information",
- )
- return parser.parse_args(args)
-
-
-def Json_Diff_Check():
- args = parse_args(sys.argv[1:])
-
- if hasattr(args, "verbose"):
- if args.verbose:
- logging.basicConfig(level=logging.DEBUG)
-
- if args.printDifferences:
- logging.info("(will print differences)")
-
- result = prefilter_json_files_then_compare(args)
- return result
-
-
-if __name__ == "__main__":
- Json_Diff_Check()
Code Review / integration / test.git / blobdiff