public void WhenComparingJsonValue_AndTypeMismatch_AndCaptureSucceed_DoNotReturnsError()
        {
            var expectedJson = JObject.Parse("{}");
            var actualJson   = JToken.Parse("{}");

            _jsonSpecialHandler.HandleSpecialObject(expectedJson, actualJson, "", _jsonComparer)
            .Returns((true, null));

            var actualErrors = _jsonComparer.Compare(expectedJson, actualJson);

            actualErrors.Should().BeEmpty();
        }
        public IEnumerable <IJsonCompareError <JToken> > Compare(JToken expected, JToken actual, string path)
        {
            var(captureSucceeded, captureErrors) = _jsonSpecialHandler.HandleSpecialObject(expected, actual, path, this);
            if (captureSucceeded)
            {
                yield break;
            }
            if (captureErrors?.Count > 0)
            {
                foreach (var error in captureErrors)
                {
                    yield return(error);
                }
                yield break;
            }

            if (expected.Type != actual.Type)
            {
                yield return(new InvalidTypeJsonCompareError(path, expected, actual));

                yield break;
            }

            IEnumerable <IJsonCompareError <JToken> > errors;

            switch (actual.Type)
            {
            case JTokenType.Object:
                errors = _jsonObjectComparer.Compare(expected as JObject, actual as JObject, this, path);
                break;

            case JTokenType.Array:
                errors = _jsonArrayComparer.Compare(expected as JArray, actual as JArray, this, path);
                break;

            case JTokenType.Integer:
            case JTokenType.Float:
            case JTokenType.String:
            case JTokenType.Boolean:
            case JTokenType.Null:
            case JTokenType.Undefined:
            case JTokenType.Date:
                errors = _jsonValueComparer.Compare(expected as JValue, actual as JValue, path);
                break;

            default:
                throw new ArgumentOutOfRangeException(nameof(actual.Type), actual.Type, "Cannot compare this type");
            }

            foreach (var jsonCompareError in errors)
            {
                yield return(jsonCompareError);
            }
        }
示例#3
0
        public void SetUp()
        {
            _jsonObjectComparer = Substitute.For <IJsonObjectComparer>();
            _jsonArrayComparer  = Substitute.For <IJsonArrayComparer>();
            _jsonValueComparer  = Substitute.For <IJsonValueComparer>();
            _jsonSpecialHandler = Substitute.For <IJsonSpecialHandler>();
            _jsonComparer       = new JsonComparer(_jsonObjectComparer, _jsonArrayComparer, _jsonValueComparer, _jsonSpecialHandler);

            _jsonSpecialHandler.HandleSpecialObject(Arg.Any <JToken>(), Arg.Any <JToken>(), Arg.Any <string>())
            .Returns((false, null));
        }