#5: Fix cheapDiff's handling of list addition, new test case, better test errors.

Author: Lattyware

src/Json/Diff.elm

@@ -146,10 +146,21 @@ cheapDiffList root ( a, b ) =
     let
         diffIndex index =
             diffField internalCheapDiff root (String.fromInt index) (get index a) (get index b)
+
+        aLen =
+            List.length a
+
+        bLen =
+            List.length b
+
+        range =
+            if aLen >= bLen then
+                List.range 0 (aLen - 1) |> List.reverse
+
+            else
+                List.range 0 (bLen - 1)
     in
-    List.range 0 (max (List.length a - 1) (List.length b - 1))
-        |> List.reverse
-        |> List.concatMap diffIndex
+    range |> List.concatMap diffIndex
 
 
 get : Int -> List a -> Maybe a

tests/Cases.elm

@@ -365,6 +365,12 @@ cases =
                 "a": {"a": 1},
                 "b": {"a": 1, "b": {"c": 2}},
                 "patch": [{"op": "add", "path": "/b", "value": {"c": 2}}]
+            },
+            {
+                "description": "add values to list",
+                "a": [1, 2, 3, 4],
+                "b": [1, 2, 3, 4, 5, 6],
+                "patch": [{"op": "add", "path": "/4", "value": 5}, {"op": "add", "path": "/5", "value": 6}]
             }
         ]
     """

tests/CheapDiff.elm

@@ -7,6 +7,7 @@ import Json.Encode as JsonE
 import Json.Patch as Json
 import Json.Patch.Invertible as Invertible
 import Test exposing (..)
+import Util.Expect as Expect
 
 
 suite : Test
@@ -21,21 +22,16 @@ toTest { description, a, b, patch } =
             let
                 applyPatchToA p =
                     Json.apply p a
+
+                diffedPatch =
+                    Diff.cheapDiff a b |> Invertible.toMinimalPatch
             in
-            case Diff.cheapDiff a b |> Invertible.toMinimalPatch |> applyPatchToA of
+            case diffedPatch |> applyPatchToA of
                 Ok hopefullyB ->
-                    expectJsonEqual b hopefullyB
+                    Expect.jsonEqual b hopefullyB
 
                 Err err ->
-                    Expect.fail ("Couldn't apply patch: " ++ err)
+                    Expect.fail ("Couldn't apply patch:\n\tPatch: " ++ (diffedPatch |> Json.encoder |> JsonE.encode 0) ++ "\n\tError: " ++ err)
     in
     test (description ++ " | a: " ++ (a |> JsonE.encode 0) ++ " | b: " ++ (b |> JsonE.encode 0))
         doTest
-
-
-expectJsonEqual : JsonE.Value -> JsonE.Value -> Expectation
-expectJsonEqual a =
-    Expect.all
-        [ Expect.equal a
-        , \b -> Expect.equal b a
-        ]

tests/Diff.elm

@@ -6,6 +6,7 @@ import Json.Diff as Diff
 import Json.Encode as JsonE
 import Json.Patch as Json
 import Test exposing (..)
+import Util.Expect as Expect
 
 
 suite : Test
@@ -20,8 +21,5 @@ toTest { description, a, b, patch } =
 
 
 expectPatchEqual : Json.Patch -> Json.Patch -> Expectation
-expectPatchEqual a =
-    Expect.all
-        [ Expect.equal a
-        , \b -> Expect.equal b a
-        ]
+expectPatchEqual a b =
+    Expect.jsonEqual (Json.encoder a) (Json.encoder b)

tests/Invertible.elm

@@ -2,11 +2,11 @@ module Invertible exposing (invertSuite, mergeSuite)
 
 import Cases exposing (TestCase, suiteUsingTestCases)
 import Expect exposing (Expectation)
-import Json.Decode as Json
 import Json.Diff as Diff
 import Json.Encode as JsonE
 import Json.Patch.Invertible as Invertable
 import Test exposing (..)
+import Util.Expect as Expect
 
 
 invertSuite : Test
@@ -27,7 +27,7 @@ invertTest { a, b } =
             in
             case a |> Invertable.apply diff |> Result.andThen (Invertable.apply inverted) of
                 Ok aAgain ->
-                    expectJsonEqual a aAgain
+                    Expect.jsonEqual a aAgain
 
                 Err err ->
                     Expect.fail err
@@ -54,19 +54,11 @@ mergeTest { a, b } =
                 Ok patched ->
                     case a |> Invertable.apply mergedDiff of
                         Ok mergePatched ->
-                            expectJsonEqual patched mergePatched
+                            Expect.jsonEqual patched mergePatched
 
                         Err err ->
                             Expect.fail err
 
                 Err err ->
                     Expect.fail err
         )
-
-
-expectJsonEqual : Json.Value -> Json.Value -> Expectation
-expectJsonEqual a =
-    Expect.all
-        [ Expect.equal a
-        , \b -> Expect.equal b a
-        ]

tests/Util/Expect.elm

@@ -0,0 +1,14 @@
+module Util.Expect exposing (jsonEqual)
+
+import Expect exposing (Expectation)
+import Json.Encode as JsonE
+
+
+jsonEqual : JsonE.Value -> JsonE.Value -> Expectation
+jsonEqual a b =
+    Expect.all
+        [ Expect.equal a
+        , \c -> Expect.equal c a
+        ]
+        b
+        |> Expect.onFail ("Expect.jsonEqual\nExpected: " ++ JsonE.encode 0 a ++ "\nActual: " ++ JsonE.encode 0 b)