feat: include more information in exception (introduce new type PatchingException which wraps the original exception) (#108)

Author: hf-kklein

.gitignore

@@ -17,4 +17,4 @@ ChronoJsonDiffPatch/ChronoJsonDiffPatch/bin/Debug/ChronoJsonDiffPatch.xml
 
 *.exe
 
-*.xml
+*.xml

ChronoJsonDiffPatch/ChronoJsonDiffPatch/PatchingException.cs

@@ -0,0 +1,61 @@
+using Newtonsoft.Json.Linq;
+
+namespace ChronoJsonDiffPatch;
+
+/// <summary>
+/// is thrown when something fails to be patched
+/// </summary>
+/// <remarks>
+/// it's basically a wrapper around the inner exception with some helpful debugging information
+/// </remarks>
+public class PatchingException<TEntity> : Exception
+{
+    /// <summary>
+    /// state of the entity at +/- infinity (before any patch was applied)
+    /// </summary>
+    public TEntity StateOfEntityBeforeAnyPatch { get; }
+
+    /// <summary>
+    /// state of the entity at the point where Applying <see cref="FailedPatch"/> failed
+    /// </summary>
+    public JToken StateOfEntityBeforePatch { get; }
+
+    /// <summary>
+    /// patch that could not be applied
+    /// </summary>
+    public JToken? FailedPatch { get; }
+
+    /// <summary>
+    /// index of the patch inside the chain
+    /// </summary>
+    public int Index { get; }
+
+    /// <summary>
+    /// instantiate with all the necessary information
+    /// </summary>
+    /// <param name="stateOfEntityBeforeAnyPatch"></param>
+    /// <param name="left"></param>
+    /// <param name="patch"></param>
+    /// <param name="index"></param>
+    /// <param name="message"></param>
+    /// <param name="innerException"></param>
+    public PatchingException(
+        TEntity stateOfEntityBeforeAnyPatch,
+        JToken left,
+        JToken? patch,
+        int index,
+        string message,
+        Exception innerException
+    )
+        : base(message, innerException)
+    {
+        StateOfEntityBeforeAnyPatch = stateOfEntityBeforeAnyPatch;
+        StateOfEntityBeforePatch = left;
+        FailedPatch = patch;
+        Index = index;
+    }
+
+    /// <inheritdoc />
+    public override string Message =>
+        $"{base.Message}. Patch (index {Index}): {FailedPatch ?? "<null>"}; State: {StateOfEntityBeforePatch}";
+}

ChronoJsonDiffPatch/ChronoJsonDiffPatch/TimeRangePatchChain.cs

@@ -1,4 +1,4 @@
-using System.Diagnostics.Contracts;
+using System.Diagnostics.Contracts;
 using Itenso.TimePeriod;
 using JsonDiffPatchDotNet;
 using Newtonsoft.Json;
@@ -559,6 +559,8 @@ public TEntity PatchToDate(TEntity initialEntity, DateTimeOffset keyDate)
         {
             case PatchingDirection.ParallelWithTime:
             {
+                var index = -1;
+
                 foreach (
                     var existingPatch in GetAll()
                         .Where(p =>
@@ -573,16 +575,18 @@ var existingPatch in GetAll()
                         )
                 )
                 {
+                    index += 1;
                     var jtokenPatch = JsonConvert.DeserializeObject<JToken>(
                         existingPatch.Patch!.RootElement.GetRawText()
                     );
                     try
                     {
                         left = jdp.Patch(left, jtokenPatch);
                     }
-                    catch (Exception exc) when (_skipConditions?.Any() == true)
+                    catch (Exception exc)
                     {
                         var entityBeforePatch = _deserialize(left.ToString());
+
                         if (
                             _skipConditions?.Any(sc =>
                                 sc.ShouldSkipPatch(entityBeforePatch, existingPatch, exc)
@@ -593,14 +597,22 @@ var existingPatch in GetAll()
                             continue;
                         }
 
-                        throw; // re-throw
+                        throw new PatchingException<TEntity>(
+                            stateOfEntityBeforeAnyPatch: initialEntity,
+                            left: left,
+                            patch: jtokenPatch,
+                            index: index,
+                            message: $"Failed to apply patches ({PatchingDirection}): {exc.Message}; None of the {_skipConditions?.Count() ?? 0} skip conditions applied",
+                            innerException: exc
+                        );
                     }
                 }
 
                 return _deserialize(JsonConvert.SerializeObject(left));
             }
             case PatchingDirection.AntiParallelWithTime:
             {
+                var index = 0;
                 foreach (
                     var existingPatch in GetAll()
                         .Where(p => p.End > keyDate)
@@ -610,14 +622,15 @@ var existingPatch in GetAll()
                         )
                 )
                 {
+                    index += 1;
                     var jtokenPatch = JsonConvert.DeserializeObject<JToken>(
                         existingPatch.Patch!.RootElement.GetRawText()
                     );
                     try
                     {
                         left = jdp.Unpatch(left, jtokenPatch);
                     }
-                    catch (Exception exc) when (_skipConditions?.Any() == true)
+                    catch (Exception exc)
                     {
                         var entityBeforePatch = _deserialize(left.ToString());
                         if (
@@ -630,7 +643,14 @@ var existingPatch in GetAll()
                             continue;
                         }
 
-                        throw; // re-throw
+                        throw new PatchingException<TEntity>(
+                            stateOfEntityBeforeAnyPatch: initialEntity,
+                            left: left,
+                            patch: jtokenPatch,
+                            index: index,
+                            message: $"Failed to apply patches ({PatchingDirection}): {exc.Message}; None of the {_skipConditions?.Count() ?? 0} skip conditions applied",
+                            innerException: exc
+                        );
                     }
                 }
 

ChronoJsonDiffPatch/ChronoJsonDiffPatchTests/ListPatchingTests.cs

@@ -127,7 +127,11 @@ public void Reproduce_ArgumentOutOfRangeException()
             antiparallelChain.PatchToDate(corruptedInitialEntity, keyDate1 - TimeSpan.FromDays(10));
         applyingPatchesToACorruptedInitialEntity
             .Should()
-            .ThrowExactly<ArgumentOutOfRangeException>();
+            .ThrowExactly<PatchingException<EntityWithList>>()
+            .Which.InnerException.Should()
+            .NotBeNull()
+            .And.Subject.Should()
+            .BeOfType<ArgumentOutOfRangeException>();
         antiparallelChain.PatchesHaveBeenSkipped.Should().BeFalse();
     }