import unittest
import sys
import JsonDiffTool

"""
Unit tests for the Json Diff Tool library
Updated: 2017-04-24
"""

__author__ = "Diego Granados"
__copyright__ = "Copyright(c) 2017, Ericsson."
__license__ = "New-style BSD"
__email__ = "diego.jesus.granados.lopez@ericsson.com"


class PathConversionTest(unittest.TestCase):
    """
    Conversions from jsonpath paths to jsonpatch patches used to remove the element pointed by the path
    """

    def testArrayElementConversion(self):
        self.assertEquals(
            '[{"op":"remove","path":"/ietf-yang-library:modules-state/module/56"}]',
            JsonDiffTool.from_path_to_jsonpatch(
                "/ietf-yang-library:modules-state/module/56"
            ),
            "Array element conversion failed!",
        )

    def testMapValueElementConversion(self):
        self.assertEquals(
            '[{"op":"remove","path":"/ietf-yang-library:modules-state/module/blablah"}]',
            JsonDiffTool.from_path_to_jsonpatch(
                "/ietf-yang-library:modules-state/module/blablah"
            ),
            "Array element conversion failed!",
        )


class JsonDiffToolTest(unittest.TestCase):
    """
    Tests for the tool itself, including both command-line and RIDE keyword invokation style
    """

    def testSimpleDifferenceCountingWithoutFiltering(self):
        """
        Identical documents
        """
        self.assertEquals(
            0,
            JsonDiffTool.Json_Diff_Check_Keyword(
                "testinput/arrayTwoNames.json",
                "testinput/arrayTwoNamesCopy.json",
                "",
                "",
            ),
            "failed! (expected 0 differences)",
        )

    def testEqualFilesWithScrambledArrayOrder(self):
        """
        This is moving an array element from one position to other. RFC 6902 describes this as "moving
        a value", but this jsonpatch implementation constructs a patch using remove + add. Acceptable though
        """
        self.assertEquals(
            2,
            JsonDiffTool.Json_Diff_Check_Keyword(
                "testinput/arrayTwoNames.json",
                "testinput/arrayTwoNamesReversed.json",
                "",
                "",
            ),
            "failed! (expected 2 differences)",
        )

    def testEqualFilesWithChangedAttributeOrder(self):
        """
        Attributes in different order. It's not a difference
        """
        self.assertEquals(
            0,
            JsonDiffTool.Json_Diff_Check_Keyword(
                "testinput/setTwoNames.json",
                "testinput/setTwoNamesReversed.json",
                "",
                "",
            ),
            "failed! (expected 0 differences)",
        )

    def testSimpleDifferenceSecondFileWithExtraAttrib(self):
        self.assertEquals(
            1,
            JsonDiffTool.Json_Diff_Check_Keyword(
                "testinput/setTwoNames.json",
                "testinput/setTwoNamesExtraAttrib.json",
                "",
                "",
            ),
            "failed! (expected 1 differences)",
        )

    def testSimpleDifferenceCountingWithoutFiltering(self):
        """
        Example coming from a true daexim export. No prefilters used
        """
        input_argv = [
            "-i",
            "testinput/mainTestCase/odl_backup_operational_before.json",
            "-f",
            "testinput/mainTestCase/odl_backup_operational_after.json",
        ]
        sys.argv[1:] = input_argv
        self.assertEquals(
            16,
            JsonDiffTool.Json_Diff_Check(),
            "main failed! expected 16 differences, result was: "
            + str(JsonDiffTool.Json_Diff_Check()),
        )

    def testSimpleDifferenceCountingUsingSingleMatchingBeforeFilter(self):
        """
        Using a prefilter for the initial file The prefilter contains one expression only
        """
        input_argv = [
            "-i",
            "testinput/mainTestCase/odl_backup_operational_before.json",
            "-f",
            "testinput/mainTestCase/odl_backup_operational_after.json",
            "-ipf",
            "testinput/mainTestCase/json_prefilter.conf",
            "-v",
        ]
        sys.argv[1:] = input_argv
        self.assertEquals(
            15,
            JsonDiffTool.Json_Diff_Check(),
            "main failed! expected 15 differences, result was: "
            + str(JsonDiffTool.Json_Diff_Check()),
        )

    def testSimpleDifferenceCountingUsingMatchingBeforeFilterMatchingTwoEntries(self):
        """
        Using a prefilter for the initial file The prefilter contains two expressions
        """
        input_argv = [
            "-i",
            "testinput/mainTestCase/odl_backup_operational_before.json",
            "-f",
            "testinput/mainTestCase/odl_backup_operational_after.json",
            "-ipf",
            "testinput/mainTestCase/json_prefilter_two_matches.conf",
            "-v",
        ]
        sys.argv[1:] = input_argv
        self.assertEquals(
            14,
            JsonDiffTool.Json_Diff_Check(),
            "main failed! expected 14 differences, result was: "
            + str(JsonDiffTool.Json_Diff_Check()),
        )

    def testSimpleDifferenceCountingUsingSingleMatchingBeforeFilter(self):
        """
        Using a prefilter for both initial and final files
        """
        input_argv = [
            "-i",
            "testinput/mainTestCase/odl_backup_operational_before.json",
            "-f",
            "testinput/mainTestCase/odl_backup_operational_after.json",
            "-ipf",
            "testinput/mainTestCase/json_prefilter.conf",
            "-fpf",
            "testinput/mainTestCase/json_postfilter.conf",
            "-v",
        ]
        sys.argv[1:] = input_argv
        self.assertEquals(
            16,
            JsonDiffTool.Json_Diff_Check(),
            "main failed! expected 16 differences, result was: "
            + str(JsonDiffTool.Json_Diff_Check()),
        )

    def testUsingANonExistingFile(self):
        """
        The second file does not exist. Exception expected
        """
        self.assertRaises(
            IOError,
            JsonDiffTool.Json_Diff_Check_Keyword,
            "testinput/arrayTwoNames.json",
            "testinput/thisFileDoesNotExist.json",
            "",
            "",
        )

    def testNotPassingAMandatoryParameter(self):
        """
        Both initial and final json files are mandatory
        """
        input_argv = ["-f", "testinput/mainTestCase/odl_backup_operational_after.json"]
        # parser = JsonDiffTool.parseArgs(input_argv)

        with self.assertRaises(SystemExit) as cm:
            JsonDiffTool.parse_args(input_argv)

        # 2 for missing argument
        self.assertEqual(cm.exception.code, 2)

    def testUsingNotMatchingFilterExpressions(self):
        """
        Using prefilter files whose expressions match nothing
        """
        input_argv = [
            "-i",
            "testinput/mainTestCase/odl_backup_operational_before.json",
            "-f",
            "testinput/mainTestCase/odl_backup_operational_after.json",
            "-ipf",
            "testinput/mainTestCase/json_prefilter_zero_matches.conf",
            "-fpf",
            "testinput/mainTestCase/json_prefilter_zero_matches.conf",
            "-v",
        ]
        sys.argv[1:] = input_argv
        self.assertEquals(
            16,
            JsonDiffTool.Json_Diff_Check(),
            "main failed! expected 16 differences, result was: "
            + str(JsonDiffTool.Json_Diff_Check()),
        )


if __name__ == "__main__":
    unittest.main()