Add tons of elementary tests.

Tests now should cover all basics of JSON format.
Also added a method _run_test_strings for simple tests.
Created a parent class OurTestCase containing the above helper methods.
Moved static strings to special module.

3 files changed, 310 insertions, 232 deletions

diff --git a/json_diff.py b/json_diff.py
index d636562..b9d5470 100755
--- a/json_diff.py
+++ b/json_diff.py
@@ -23,14 +23,15 @@ IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 """
 from __future__ import division, absolute_import, print_function, unicode_literals
-import json
+import json, sys
+# import pdb
 import logging
 from optparse import OptionParser
 
 __author__ = "Matěj Cepl"
 __version__ = "0.1.0"
 
-logging.basicConfig(format='%(levelname)s:%(funcName)s:%(message)s', level=logging.INFO)
+logging.basicConfig(format='%(levelname)s:%(funcName)s:%(message)s', level=logging.DEBUG)
 
 STYLE_MAP = {
     "_append": "append_class",
@@ -66,12 +67,14 @@ td {
   %s
 """
 
+# I would love to have better solution for this ...
+if sys.version_info[0] == 3: unicode = str
+
 def is_scalar(value):
     """
     Primitive version, relying on the fact that JSON cannot
     contain any more complicated data structures.
     """
-    logging.debug("? = %s", not isinstance(value, (list, tuple, dict)))
     return not isinstance(value, (list, tuple, dict))
 
 class HTMLFormatter(object):
@@ -108,13 +111,6 @@ class HTMLFormatter(object):
     # doesn't have level and neither concept of it, much
     def _format_dict(self, diff_dict, typch="unknown_change", level=0):
         out_str = ""
-        logging.debug("out_str = %s", out_str)
-
-        logging.debug("----------------------------------------------------------------")
-        logging.debug("diff_dict = %s", unicode(diff_dict))
-        logging.debug("level = %s", unicode(level))
-        logging.debug("diff_dict.keys() = %s", unicode(diff_dict.keys()))
-
         # For all STYLE_MAP keys which are present in diff_dict
         for typechange in set(diff_dict.keys()) & INTERNAL_KEYS:
             out_str += self._format_dict(diff_dict[typechange], typechange, level)
@@ -135,7 +131,7 @@ class Comparator(object):
     """
     Main workhorse, the object itself
     """
-    def __init__(self, fn1=None, fn2=None, excluded_attrs=(), included_attrs=()):
+    def __init__(self, fn1=None, fn2=None, included_attrs=(), excluded_attrs=()):
         self.obj1 = None
         self.obj2 = None
         if fn1:
@@ -159,9 +155,9 @@ class Comparator(object):
         """
         Be careful with the result of this function. Negative answer from this function
         is really None, not False, so deciding based on the return value like in
-        
+
         if self._compare_scalars(...):
-        
+
         leads to wrong answer (it should be if self._compare_scalars(...) is not None:)
         """
         # Explicitly excluded arguments
@@ -170,8 +166,10 @@ class Comparator(object):
                 (name in self.excluded_attributes)):
             return None
         elif old != new:
+            logging.debug("Comparing result (name=%s) is %s", name, new)
             return new
         else:
+            logging.debug("Comparing result (name=%s) is None", name)
             return None
 
     def _compare_arrays(self, old_arr, new_arr):
@@ -189,8 +187,6 @@ class Comparator(object):
             "_update": {}
         }
         for idx in range(inters):
-            logging.debug("idx = %s, old_arr[idx] = %s, new_arr[idx] = %s",
-                idx, old_arr[idx], new_arr[idx])
             # changed objects, new value is new_arr
             if (type(old_arr[idx]) != type(new_arr[idx])):
                 result['_update'][idx] = new_arr[idx]
@@ -259,15 +255,15 @@ class Comparator(object):
             # new_obj is missing
             elif name not in new_obj:
                 result['_remove'][name] = old_obj[name]
+            # We want to go through the tree post-order
+            elif isinstance(old_obj[name], dict):
+                res_dict = self.compare_dicts(old_obj[name], new_obj[name])
+                if (len(res_dict) > 0):
+                    result['_update'][name] = res_dict
+            # Now we are on the same level
             # changed objects, new value is new_obj
             elif (type(old_obj[name]) != type(new_obj[name])):
                 result['_update'][name] = new_obj[name]
-            # last simple variant ... scalars
-            elif (is_scalar(old_obj[name])):
-                # Explicitly excluded arguments
-                res_scal = self._compare_scalars(old_obj[name], new_obj[name], name)
-                if res_scal is not None:
-                    result['_update'][name] = res_scal
             # now arrays (we can be sure, that both old_obj and
             # new_obj are of the same type)
             elif (isinstance(old_obj[name], list)):
@@ -275,11 +271,12 @@ class Comparator(object):
                     new_obj[name])
                 if (len(res_arr) > 0):
                     result['_update'][name] = res_arr
-            # and now nested dicts
-            elif isinstance(old_obj[name], dict):
-                res_dict = self.compare_dicts(old_obj[name], new_obj[name])
-                if (len(res_dict) > 0):
-                    result['_update'][name] = res_dict
+            # the only thing remaining are scalars
+            else:
+                # Explicitly excluded arguments
+                res_scal = self._compare_scalars(old_obj[name], new_obj[name], name)
+                if res_scal is not None:
+                    result['_update'][name] = res_scal
 
         # Clear out unused keys in result
         out_result = {}
@@ -311,7 +308,7 @@ if __name__ == "__main__":
     diff = Comparator(file(args[0]), file(args[1]), options.exclude, options.include)
     if options.HTMLoutput:
         diff_res = diff.compare_dicts()
-        logging.debug("diff_res:\n%s", json.dumps(diff_res, indent=True))
+        # logging.debug("diff_res:\n%s", json.dumps(diff_res, indent=True))
         print(HTMLFormatter(diff_res))
     else:
         outs = json.dumps(diff.compare_dicts(), indent=4, ensure_ascii=False).encode("utf-8")
diff --git a/test_json_diff.py b/test_json_diff.py
index 453eba4..2d073ea 100644
--- a/test_json_diff.py
+++ b/test_json_diff.py
@@ -3,195 +3,16 @@
 PyUnit unit tests
 """
 from __future__ import division, absolute_import, unicode_literals
-import unittest
+import unittest, sys
+if sys.version_info[0] == 3: unicode = str
 import json
 import json_diff
 from io import StringIO
 import codecs
 
-SIMPLE_OLD = """
-{
-    "a": 1,
-    "b": true,
-    "c": "Janošek"
-}
-"""
-
-SIMPLE_NEW = """
-{
-    "b": false,
-    "c": "Maruška",
-    "d": "přidáno"
-}
-"""
-
-SIMPLE_DIFF =  """
-{
-    "_append": {
-        "d": "přidáno"
-    },
-    "_remove": {
-        "a": 1
-    },
-    "_update": {
-        "c": "Maruška",
-        "b": false
-    }
-}
-"""
-
-SIMPLE_DIFF_HTML="""
-<!DOCTYPE html>
-<html lang='en'>
-<meta charset="utf-8" />
-<title>json_diff result</title>
-<style>
-td {
-text-align: center;
-}
-.append_class {
-color: green;
-}
-.remove_class {
-color: red;
-}
-.update_class {
-color: navy;
-}
-</style>
-<body>
-<h1>json_diff result</h1>
-<table>
-<tr>
-<td class='remove_class'>a = 1</td>
-</tr><tr>
-<td class='update_class'>c = Maruška</td>
-</tr><tr>
-<td class='update_class'>b = False</td>
-</tr><tr>
-<td class='append_class'>d = přidáno</td>
-</tr>
-</table>
-</body>
-</html>
-"""
-
-SIMPLE_ARRAY_OLD = """
-{
-   "a": [ 1 ]
-}
-"""
-
-SIMPLE_ARRAY_NEW = """
-{
-   "a": [ 1, 2 ]
-}
-"""
-
-SIMPLE_ARRAY_DIFF = """
-{
-    "_update": {
-        "a": {
-            "_append": {
-                "1": 2
-            }
-        }
-    }
-}
-"""
+from test_strings import * #@UnusedWildImport
 
-NESTED_OLD = """
-{
-    "a": 1,
-    "b": 2,
-    "son": {
-        "name": "Janošek"
-    }
-}
-"""
-
-NESTED_NEW = """
-{
-    "a": 2,
-    "c": 3,
-    "daughter": {
-        "name": "Maruška"
-    }
-}
-"""
-
-NESTED_DIFF = """
-{
-    "_append": {
-        "c": 3,
-        "daughter": {
-            "name": "Maruška"
-        }
-    },
-    "_remove": {
-        "b": 2,
-        "son": {
-            "name": "Janošek"
-        }
-    },
-    "_update": {
-        "a": 2
-    }
-}
-"""
-NESTED_DIFF_EXCL = """
-{
-    "_append": {
-        "c": 3
-    },
-    "_remove": {
-        "b": 2
-    },
-    "_update": {
-        "a": 2
-    }
-}
-"""
-
-ARRAY_OLD = """
-{
-    "a": 1,
-    "b": 2,
-    "children": [
-        "Pepíček", "Anička", "Maruška"
-    ]
-}
-"""
-
-ARRAY_NEW = """
-{
-    "a": 1,
-    "children": [
-        "Pepíček", "Tonička", "Maruška"
-    ],
-    "c": 3
-}
-"""
-
-ARRAY_DIFF = """
-{
-    "_remove": {
-        "b": 2
-    },
-    "_append": {
-        "c": 3
-    },
-    "_update": {
-        "children": [
-            "Pepíček",
-            "Tonička",
-            "Maruška"
-        ]
-    }
-}
-"""
-
-class TestHappyPath(unittest.TestCase):
+class OurTestCase(unittest.TestCase):
     def _run_test(self, oldf, newf, difff, msg="", inc=(), exc=()):
         diffator = json_diff.Comparator(oldf, newf, inc, exc)
         diff = diffator.compare_dicts()
@@ -201,15 +22,32 @@ class TestHappyPath(unittest.TestCase):
                          (json.dumps(expected, sort_keys=True, indent=4, ensure_ascii=False),
                           json.dumps(diff, sort_keys=True, indent=4, ensure_ascii=False)))
 
+    def _run_test_strings(self, olds, news, diffs, msg="", inc=(), exc=()):
+        self._run_test(StringIO(olds), StringIO(news), StringIO(diffs), msg, inc, exc)
+
     def _run_test_formatted(self, oldf, newf, difff, msg=""):
         diffator = json_diff.Comparator(oldf, newf)
         diff = ("\n".join([line.strip() \
-                for line in unicode(json_diff.HTMLFormatter(diffator.compare_dicts())).split("\n")])).strip()
+                for line in unicode( \
+                    json_diff.HTMLFormatter(diffator.compare_dicts())).split("\n")])).strip()
         expected = ("\n".join([line.strip() for line in difff if line])).strip()
         self.assertEqual(diff, expected, msg +
                          "\n\nexpected = %s\n\nobserved = %s" %
                          (expected, diff))
 
+#class TestUtilities(unittest.TestCase):
+#    def test_is_dict_interesting(self):
+#        diffator = json_diff.Comparator(StringIO(NESTED_OLD), StringIO(NESTED_NEW),
+#                    included_attrs=('nome',))
+#        old_res = diffator.dict_no_key_included(diffator.obj1)
+#        self.assertFalse(old_res,
+#            "check whether the old dict should be excluded or not") # or True? FIXME
+#        new_res = diffator.dict_no_key_included(diffator.obj2)
+#        self.assertFalse(new_res,
+#            "check whether the new dict should be excluded or not") # or True? FIXME
+
+
+class TestBasicJSONHappyPath(OurTestCase):
     def test_empty(self):
         diffator = json_diff.Comparator({}, {})
         diff = diffator.compare_dicts()
@@ -217,8 +55,32 @@ class TestHappyPath(unittest.TestCase):
              "Empty objects diff.\n\nexpected = %s\n\nobserved = %s" %
              ({}, diff))
 
+    def test_null(self):
+        self._run_test_strings('{"a": null}', '{"a": null}',
+            '{}', "Nulls")
+
+    def test_null_to_string(self):
+        self._run_test_strings('{"a": null}', '{"a": "something"}',
+            '{"_update": {"a": "something"}}', "Null changed to string")
+
+    def test_boolean(self):
+        self._run_test_strings('{"a": true}', '{"a": false}',
+            '{"_update": {"a": false}}', "Booleans")
+
+    def test_integer(self):
+        self._run_test_strings('{"a": 1}', '{"a": 2}',
+            '{"_update": {"a": 2}}', "Integers")
+
+    def test_float(self):
+        self._run_test_strings('{"a": 1.0}', '{"a": 1.1}',
+            '{"_update": {"a": 1.1}}', "Floats")
+
+    def test_int_to_float(self):
+        self._run_test_strings('{"a": 1}', '{"a": 1.0}',
+            '{"_update": {"a": 1.0}}', "Integer changed to float")
+
     def test_simple(self):
-        self._run_test(StringIO(SIMPLE_OLD), StringIO(SIMPLE_NEW), StringIO(SIMPLE_DIFF),
+        self._run_test_strings(SIMPLE_OLD, SIMPLE_NEW, SIMPLE_DIFF,
                 "All-scalar objects diff.")
 
     def test_simple_formatted(self):
@@ -227,44 +89,50 @@ class TestHappyPath(unittest.TestCase):
             "All-scalar objects diff (formatted).")
 
     def test_simple_array(self):
-        self._run_test(StringIO(SIMPLE_ARRAY_OLD), StringIO(SIMPLE_ARRAY_NEW),
-            StringIO(SIMPLE_ARRAY_DIFF), "Simple array objects diff.")
+        self._run_test_strings(SIMPLE_ARRAY_OLD, SIMPLE_ARRAY_NEW,
+            SIMPLE_ARRAY_DIFF, "Simple array objects diff.")
 
     def test_realFile(self):
         self._run_test(open("test/old.json"), open("test/new.json"),
             open("test/diff.json"), "Simply nested objects (from file) diff.")
 
     def test_nested(self):
-        self._run_test(StringIO(NESTED_OLD), StringIO(NESTED_NEW),
-            StringIO(NESTED_DIFF), "Nested objects diff.")
-
-    # def test_nested_excluded(self):
-        # self._run_test(StringIO(NESTED_OLD), StringIO(NESTED_NEW),
-            # StringIO(NESTED_DIFF_EXCL), "Nested objects diff.", exc=("name"))
-
-#    def test_piglit_results(self):
-#        self._run_test(open("test/old-testing-data.json"), open("test/new-testing-data.json"),
-#            open("test/diff-testing-data.json"), "Large piglit results diff.")
+        self._run_test_strings(NESTED_OLD, NESTED_NEW, NESTED_DIFF, "Nested objects diff.")
 
     def test_nested_formatted(self):
         self._run_test_formatted(open("test/old.json"), open("test/new.json"),
             codecs.open("test/nested_html_output.html", "r", "utf-8"),
             "Simply nested objects (from file) diff formatted as HTML.")
 
-NO_JSON_OLD = """
-THIS IS NOT A JSON STRING
-"""
-
-NO_JSON_NEW = """
-AND THIS NEITHER
-"""
+    def test_nested_excluded(self):
+        self._run_test_strings(NESTED_OLD, NESTED_NEW, NESTED_DIFF_EXCL,
+            "Nested objects diff.", exc=("nome",))
 
+#    def test_nested_included(self):
+#        self._run_test_strings(NESTED_OLD, NESTED_NEW, NESTED_DIFF_INCL,
+#            "Nested objects diff.", inc=("nome",))
 
-class TestSadPath(unittest.TestCase):
+class TestBasicJSONSadPath(OurTestCase):
     def test_no_JSON(self):
         self.assertRaises(json_diff.BadJSONError,
                 json_diff.Comparator, StringIO(NO_JSON_OLD), StringIO(NO_JSON_NEW))
 
+    def test_bad_JSON_no_hex(self):
+        self.assertRaises(json_diff.BadJSONError, self._run_test_strings,
+            '{"a": 0x1}', '{"a": 2}', '{"_update": {"a": 2}}',
+            "Hex numbers not supported")
+
+    def test_bad_JSON_no_octal(self):
+        self.assertRaises(json_diff.BadJSONError, self._run_test_strings,
+            '{"a": 01}', '{"a": 2}', '{"_update": {"a": 2}}',
+            "Octal numbers not supported")
+
+
+#class TestPiglitData(OurTestCase):
+#    pass
+#    def test_piglit_results(self):
+#        self._run_test(open("test/old-testing-data.json"), open("test/new-testing-data.json"),
+#            open("test/diff-testing-data.json"), "Large piglit results diff.")
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/test_strings.py b/test_strings.py
new file mode 100644
index 0000000..c96db7a
--- /dev/null
+++ b/test_strings.py
@@ -0,0 +1,213 @@
+# -*- coding: utf-8 -*-
+from __future__ import division, absolute_import, unicode_literals
+
+NO_JSON_OLD = """
+THIS IS NOT A JSON STRING
+"""
+
+NO_JSON_NEW = """
+AND THIS NEITHER
+"""
+
+SIMPLE_OLD = """
+{
+    "a": 1,
+    "b": true,
+    "c": "Janošek"
+}
+"""
+
+SIMPLE_NEW = """
+{
+    "b": false,
+    "c": "Maruška",
+    "d": "přidáno"
+}
+"""
+
+SIMPLE_DIFF =  """
+{
+    "_append": {
+        "d": "přidáno"
+    },
+    "_remove": {
+        "a": 1
+    },
+    "_update": {
+        "c": "Maruška",
+        "b": false
+    }
+}
+"""
+
+SIMPLE_DIFF_HTML="""
+<!DOCTYPE html>
+<html lang='en'>
+<meta charset="utf-8" />
+<title>json_diff result</title>
+<style>
+td {
+text-align: center;
+}
+.append_class {
+color: green;
+}
+.remove_class {
+color: red;
+}
+.update_class {
+color: navy;
+}
+</style>
+<body>
+<h1>json_diff result</h1>
+<table>
+<tr>
+<td class='remove_class'>a = 1</td>
+</tr><tr>
+<td class='update_class'>c = Maruška</td>
+</tr><tr>
+<td class='update_class'>b = False</td>
+</tr><tr>
+<td class='append_class'>d = přidáno</td>
+</tr>
+</table>
+</body>
+</html>
+"""
+
+SIMPLE_ARRAY_OLD = """
+{
+   "a": [ 1 ]
+}
+"""
+
+SIMPLE_ARRAY_NEW = """
+{
+   "a": [ 1, 2 ]
+}
+"""
+
+SIMPLE_ARRAY_DIFF = """
+{
+    "_update": {
+        "a": {
+            "_append": {
+                "1": 2
+            }
+        }
+    }
+}
+"""
+
+NESTED_OLD = """
+{
+    "a": 1,
+    "b": 2,
+    "ignore": {
+        "else": true
+    },
+    "child": {
+        "nome": "Janošek"
+    }
+}
+"""
+
+NESTED_NEW = """
+{
+    "a": 2,
+    "c": 3,
+    "child": {
+        "nome": "Maruška"
+    }
+}
+"""
+
+NESTED_DIFF = """
+{
+    "_append": {
+        "c": 3
+    },
+    "_remove": {
+        "b": 2,
+        "ignore": {
+            "else": true
+        }
+    },
+    "_update": {
+        "a": 2,
+        "child": {
+            "_update": {
+                "nome": "Maruška"
+            }
+        }
+    }
+}
+"""
+
+NESTED_DIFF_EXCL = """
+{
+    "_append": {
+        "c": 3
+    },
+    "_remove": {
+        "b": 2,
+        "ignore": {
+            "else": true
+        }
+    },
+    "_update": {
+        "a": 2
+    }
+}
+"""
+
+NESTED_DIFF_INCL = """
+{
+    "_update": {
+        "child": {
+            "_update": {
+                "nome": "Maruška"
+            }
+        }
+    }
+}
+"""
+
+ARRAY_OLD = """
+{
+    "a": 1,
+    "b": 2,
+    "children": [
+        "Pepíček", "Anička", "Maruška"
+    ]
+}
+"""
+
+ARRAY_NEW = """
+{
+    "a": 1,
+    "children": [
+        "Pepíček", "Tonička", "Maruška"
+    ],
+    "c": 3
+}
+"""
+
+ARRAY_DIFF = """
+{
+    "_remove": {
+        "b": 2
+    },
+    "_append": {
+        "c": 3
+    },
+    "_update": {
+        "children": [
+            "Pepíček",
+            "Tonička",
+            "Maruška"
+        ]
+    }
+}
+"""