public AssertContentDiffAction(ITokenSelectorProvider tokenSelectorProvider, string baseFile, string diffName, string jsonPath = null, string itemKey = null, string categoriesFile = null)
{
_baseFile = baseFile;
_jsonPath = jsonPath;
_itemKey = itemKey;
_categoriesFile = categoriesFile;
_diffName = diffName;
_tokenSelectorProvider = tokenSelectorProvider;
}
private static IDictionary <string, JToken> IdentifyElements(JArray array, string jsonPath, ITokenSelectorProvider idProvider)
{
return(array.Select((item, index) => (idProvider.GetTokenSelector(jsonPath, item, index), item)).ToDictionary(kvp => kvp.Item1, kvp => kvp.Item2));
}
private static IEnumerable <DiffItem> CompareChildren(string jsonPath, IEnumerable <string> lhsKeys, IEnumerable <string> rhsKeys, IDictionary <string, JToken> lhsElements, IDictionary <string, JToken> rhsElements, ITokenSelectorProvider idProvider)
{
foreach ((string lhsKey, string rhsKey) in lhsKeys.JoinWithNulls(rhsKeys))
{
if (lhsKey == null)
{
yield return(new DiffItem(JsonPathFormatter.AddToken(jsonPath, rhsKey), rhsElements[rhsKey]));
}
else if (rhsKey == null)
{
yield return(new DiffItem(JsonPathFormatter.AddToken(jsonPath, lhsKey), null));
}
else
{
foreach (var diff in Compare(lhsElements[lhsKey], rhsElements[rhsKey], JsonPathFormatter.AddToken(jsonPath, lhsKey), idProvider))
{
yield return(diff);
}
}
}
}
private static IEnumerable <DiffItem> Compare(JToken lhs, JToken rhs, string jsonPath, ITokenSelectorProvider idProvider)
{
if (rhs == null)
{
if (lhs != null)
{
yield return(new DiffItem(jsonPath, null));
}
yield break;
}
switch (lhs)
{
case null:
if (rhs != null)
{
yield return(new DiffItem(jsonPath, rhs));
}
break;
case JObject lhsJobj:
if (rhs is JObject rhsJobj)
{
var lhsOrderedKeys = lhsJobj.Properties().Select(p => p.Name);
var rhsOrderedKeys = rhsJobj.Properties().Select(p => p.Name);
foreach (var diff in CompareChildren(jsonPath, lhsOrderedKeys, rhsOrderedKeys, lhsJobj, rhsJobj, idProvider))
{
yield return(diff);
}
}
else
{
yield return(new DiffItem(jsonPath, rhs));
}
break;
case JArray lhsArray:
if (rhs is JArray rhsArray)
{
var lhsElements = IdentifyElements(lhsArray, jsonPath, idProvider);
var rhsElements = IdentifyElements(rhsArray, jsonPath, idProvider);
foreach (var diff in CompareChildren(jsonPath, lhsElements.Keys, rhsElements.Keys, lhsElements, rhsElements, idProvider))
{
yield return(diff);
}
}
else
{
yield return(new DiffItem(jsonPath, rhs));
}
break;
default:
if (lhs.Type != rhs.Type || lhs.ToString() != rhs.ToString()) //TODO compare type wise?
{
yield return(new DiffItem(jsonPath, rhs));
}
break;
}
}
public static IEnumerable <DiffItem> Compare(JToken lhs, JToken rhs, ITokenSelectorProvider idProvider)
{
return(Compare(lhs, rhs, "$", idProvider));
}
public static (IReadOnlyCollection <DiffItem> mismatches, JToken expected) CompareAndRebase(this TestCase testCase, JToken actual, JToken @base, IEnumerable <DiffItem> actualDiffs, string resultName, ITokenSelectorProvider idProvider, bool rebaseline)
{
var expectedDiffs = testCase.GetObjectFromJson <IEnumerable <DiffItem> >(resultName) ?? Enumerable.Empty <DiffItem>();
var expected = @base.DeepClone();
try
{
expected.ApplyPatch(expectedDiffs);
}
catch (Exception _)
{
testCase.RebaseContentOrStoreTmp(resultName, actualDiffs.ToIndentedJson(), rebaseline);
throw;
}
var mismatches = JsonPatchCreator.Compare(expected, actual, idProvider).ToList();
if (mismatches.Count > 0)
{
testCase.RebaseContentOrStoreTmp(resultName, actualDiffs.ToIndentedJson(), rebaseline);
}
testCase.AddTmpItem("full_" + resultName, actual.ToIndentedJson());
return(mismatches, expected);
}
public static void AssertContentAsDiff(this TestCase testCase, JToken actual, JToken expected, string resultName, ITokenSelectorProvider idProvider, bool rebaseline)
{
var diffs = JsonPatchCreator.Compare(expected, actual, idProvider);
(var mismatches, var _) = testCase.CompareAndRebase(actual, expected, diffs, resultName, idProvider, rebaseline);
if (mismatches.Count > 0)
{
throw new AssertException("Unexpected token changes:" + string.Join("\n", mismatches.Select(d => d.JsonPath)));
}
}
public static void AssertContentAsDiff(this TestCase testCase, JToken actual, string expectedName, string resultName, ITokenSelectorProvider idProvider, bool rebaseline)
{
AssertContentAsDiff(testCase, actual, testCase.GetObjectFromJson <JToken>(expectedName), resultName, idProvider, rebaseline);
}
public static Task AssertContentAsDiffAsync(this TestCase testCase, JToken actual, string expectedName, string resultName, ITokenSelectorProvider idProvider, bool rebaseline)
{
return(testCase.AssertContentAsDiffAsync(actual, testCase.GetObjectFromJson <JToken>(expectedName), resultName, idProvider, rebaseline));
}
public Tracker(ITokenSelectorProvider idProvider)
{
_idProvider = idProvider;
}
