public static void Equal(Error expected, Error actual) { if (expected == null) { Assert.Null(actual); return; } Assert.NotNull(actual); // Id Assert.Equal(expected.Id, actual.Id); // Status Assert.Equal(expected.Status, actual.Status); // Code Assert.Equal(expected.Code, actual.Code); // Title Assert.Equal(expected.Title, actual.Title); // Detail Assert.Equal(expected.Detail, actual.Detail); // Source ClrObjectAssert.Equal(expected.Source, actual.Source); // Links LinksAssert.Equal(expected.Links, actual.Links); // Meta MetaAssert.Equal(expected.Meta, actual.Meta); }
public static void Equal(ResourceIdentifier expected, JToken actualJToken) { // Handle when 'expected' is null. if (expected == null) { ClrObjectAssert.IsNull(actualJToken); return; } // Handle when 'expected' is not null. Assert.NotNull(actualJToken); var actualJTokenType = actualJToken.Type; Assert.Equal(JTokenType.Object, actualJTokenType); var actualJObject = (JObject)actualJToken; Assert.Equal(expected.Type, (string)actualJObject.SelectToken(Keywords.Type)); Assert.Equal(expected.Id, (string)actualJObject.SelectToken(Keywords.Id)); var actualMetaJToken = actualJObject.SelectToken(Keywords.Meta); ClrObjectAssert.Equal(expected.Meta, actualMetaJToken); }
public static void Equal(ApiProperty expected, ApiProperty actual) { if (expected == null) { Assert.Null(actual); return; } Assert.NotNull(actual); Assert.Equal(expected.Name, actual.Name); ClrObjectAssert.Equal(expected.ValueAsObject(), actual.ValueAsObject()); }
public static void Equal(object expected, JObject actualJObject) { // Handle when 'expected' is null. if (expected == null) { ClrObjectAssert.IsNull(actualJObject); return; } // Handle when 'expected' is not null. Assert.NotNull(actualJObject); var expectedTypeInfo = expected.GetType().GetTypeInfo(); // .. Handle special case when expected type is 'Resource' if (expectedTypeInfo == ResourceTypeInfo) { var expectedResource = (Resource)expected; ResourceAssert.Equal(expectedResource, actualJObject); } // .. Handle special case when expected type is 'ResourceIdentifier' else if (expectedTypeInfo == ResourceIdentifierTypeInfo) { var expectedResourceIdentifier = (ResourceIdentifier)expected; ResourceIdentifierAssert.Equal(expectedResourceIdentifier, actualJObject); } // .. Handle special case when expected type is 'JObject' else if (expectedTypeInfo == JObjectTypeInfo) { var expectedJObject = (JObject)expected; Assert.Equal(expectedJObject, actualJObject); } // .. Handle normal case when expected type is an object that is // .. not 'Resource' or 'ResourceIdentifier'. else { var expectedProperties = expectedTypeInfo.GetProperties(); foreach (var expectedProperty in expectedProperties) { // ReSharper disable once UnusedVariable var expectedPropertyName = GetDotNetPropertyName(expectedProperty); var expectedPropertyValue = expectedProperty.GetValue(expected, null); var actualPropertyName = GetJsonApiPropertyName(expectedProperty); var actualJToken = actualJObject.SelectToken(actualPropertyName); ClrObjectAssert.Equal(expectedPropertyValue, actualJToken); } } }
public static void Equal(Error expected, JToken actualJToken) { // Handle when 'expected' is null. if (expected == null) { ClrObjectAssert.IsNull(actualJToken); return; } // Handle when 'expected' is not null. Assert.NotNull(actualJToken); var actualJTokenType = actualJToken.Type; Assert.Equal(JTokenType.Object, actualJTokenType); var actualJObject = (JObject)actualJToken; // Id Assert.Equal(expected.Id, (string)actualJObject.SelectToken(Keywords.Id)); // Status Assert.Equal(expected.Status, (string)actualJObject.SelectToken(Keywords.Status)); // Code Assert.Equal(expected.Code, (string)actualJObject.SelectToken(Keywords.Code)); // Title Assert.Equal(expected.Title, (string)actualJObject.SelectToken(Keywords.Title)); // Detail Assert.Equal(expected.Detail, (string)actualJObject.SelectToken(Keywords.Detail)); // Source var actualSourceJToken = actualJObject.SelectToken(Keywords.Source); ClrObjectAssert.Equal(expected.Source, actualSourceJToken); // Links var actualLinksJToken = actualJObject.SelectToken(Keywords.Links); LinksAssert.Equal(expected.Links, actualLinksJToken); // Meta var actualMetaJToken = actualJObject.SelectToken(Keywords.Meta); MetaAssert.Equal(expected.Meta, actualMetaJToken); }
public static void Equal(IReadOnlyList <object> expectedCollection, IReadOnlyList <object> actualCollection) { if (expectedCollection == null) { Assert.Null(actualCollection); return; } Assert.Equal(expectedCollection.Count, actualCollection.Count); var count = expectedCollection.Count; for (var index = 0; index < count; ++index) { var expected = expectedCollection[index]; var actual = actualCollection[index]; ClrObjectAssert.Equal(expected, actual); } }
// PUBLIC METHODS /////////////////////////////////////////////////// #region Assert Methods public static void Equal(ApiProperty expected, JToken actualJToken) { // Handle when 'expected' is null. if (expected == null) { ClrObjectAssert.IsNull(actualJToken); return; } // Handle when 'expected' is not null. Assert.NotNull(actualJToken); var actualJTokenType = actualJToken.Type; Assert.Equal(JTokenType.Property, actualJTokenType); var actualJProperty = (JProperty)actualJToken; Assert.Equal(expected.Name, actualJProperty.Name); ClrObjectAssert.Equal(expected.ValueAsObject(), actualJProperty.Value); }
public static void Equal(object expected, object actual) { // Handle when 'expected' is null. if (expected == null) { if (actual == null) { return; } var actualType1 = actual.GetType(); if (actualType1.IsSubclassOf(typeof(JToken))) { var actualJToken = (JToken)actual; ClrObjectAssert.IsNull(actualJToken); return; } } // Handle when 'expected' is not null. Assert.NotNull(actual); var actualType2 = actual.GetType(); if (actualType2.IsSubclassOf(typeof(JToken))) { var actualJToken = (JToken)actual; ClrObjectAssert.Equal(expected, actualJToken); } else { // Use FluentAssertions to compare for attribute equality // instead of reference equality in Assert.Equal(expectetd, actual) actual.ShouldBeEquivalentTo(expected); } }
public static void Equal(Link expected, JToken actualJToken) { // Handle when 'expected' is null. if (expected == null) { ClrObjectAssert.IsNull(actualJToken); return; } // Handle when 'expected' is not null. var expectedHRef = expected.HRef; var expectedMeta = expected.Meta; Assert.NotNull(actualJToken); var actualJTokenType = actualJToken.Type; switch (actualJTokenType) { case JTokenType.String: { var actualHRef = (string)actualJToken; Assert.Equal(expectedHRef, actualHRef); Assert.Null(expectedMeta); } break; case JTokenType.Object: { var actualJObject = (JObject)actualJToken; // HRef String var actualHRefJToken = actualJObject.SelectToken(Keywords.HRef); if (expectedHRef == null) { if (actualHRefJToken == null) { return; } var actualHRefJTokenType = actualHRefJToken.Type; Assert.Equal(JTokenType.Null, actualHRefJTokenType); } else { Assert.Equal(JTokenType.String, actualHRefJToken.Type); var actualHRef = (string)actualHRefJToken; Assert.Equal(expectedHRef, actualHRef); } // Meta Object var actualMetaJToken = actualJObject.SelectToken(Keywords.Meta); ClrObjectAssert.Equal(expectedMeta, actualMetaJToken); } break; case JTokenType.None: case JTokenType.Null: { Assert.Null(expectedHRef); Assert.Null(expectedMeta); } break; default: Assert.True(false, String.Format("Invalid JToken [type={0}] for link.", actualJTokenType)); return; } }
// PUBLIC METHODS /////////////////////////////////////////////////// #region Assert Methods public static void Equal(object expected, JToken actualJToken) { // Handle when 'expected' is null. if (expected == null) { ClrObjectAssert.IsNull(actualJToken); return; } // Handle when 'expected' is not null. Assert.NotNull(actualJToken); var actualJTokenType = actualJToken.Type; switch (actualJTokenType) { case JTokenType.Array: { var expectedArray = ((IEnumerable <object>)expected).ToList(); var actualJArray = (JArray)actualJToken; Assert.Equal(expectedArray.Count, actualJArray.Count); var count = expectedArray.Count; for (var i = 0; i < count; ++i) { var expectedItem = expectedArray[i]; var actualJTokenItem = actualJArray[i]; ClrObjectAssert.Equal(expectedItem, actualJTokenItem); } } break; case JTokenType.Object: { var actualJObject = (JObject)actualJToken; ClrObjectAssert.Equal(expected, actualJObject); } break; case JTokenType.Integer: { var expectedInteger = Convert.ToInt64(expected); var actualInteger = (long)actualJToken; Assert.Equal(expectedInteger, actualInteger); } break; case JTokenType.Float: { var expectedFloat = Convert.ToDecimal(expected); var actualFloat = (decimal)actualJToken; Assert.Equal(expectedFloat, actualFloat); } break; case JTokenType.String: { // Special case if expected is or derives from JToken. var expectedType = expected.GetType(); if (typeof(JToken).IsAssignableFrom(expectedType)) { Assert.Equal(expected, actualJToken); return; } var actualString = (string)actualJToken; var actual = TypeConverter.Convert(actualString, expectedType); Assert.Equal(expected, actual); } break; case JTokenType.Boolean: { var expectedBool = Convert.ToBoolean(expected); var actualBool = (bool)actualJToken; Assert.Equal(expectedBool, actualBool); } break; case JTokenType.Date: { var expectedType = expected.GetType(); if (expectedType == typeof(DateTime)) { var expectedDateTime = (DateTime)expected; var jsonSerializerSettings = new JsonSerializerSettings { DateParseHandling = DateParseHandling.DateTime }; var jsonSerializer = JsonSerializer.Create(jsonSerializerSettings); var actualDateTime = actualJToken.ToObject <DateTime>(jsonSerializer); Assert.Equal(expectedDateTime, actualDateTime); } else if (expectedType == typeof(DateTimeOffset)) { var expectedDateTimeOffset = (DateTimeOffset)expected; var jsonSerializerSettings = new JsonSerializerSettings { DateParseHandling = DateParseHandling.DateTimeOffset }; var jsonSerializer = JsonSerializer.Create(jsonSerializerSettings); var actualDateTimeOffset = actualJToken.ToObject <DateTimeOffset>(jsonSerializer); Assert.Equal(expectedDateTimeOffset, actualDateTimeOffset); } else { Assert.True(false, "Expected date type is not DateTime or DateTimeOffset."); } } break; default: Assert.True(false, String.Format("Unknown actual JTokenType [value={0}] in expected object to actual JToken assert method.", actualJTokenType)); break; } }
public static void Equal(Document expected, Document actual) { if (expected == null) { Assert.Null(actual); return; } Assert.NotNull(actual); // JsonApiVersion JsonApiVersionAssert.Equal(expected.JsonApiVersion, actual.JsonApiVersion); // Meta MetaAssert.Equal(expected.Meta, actual.Meta); // Links LinksAssert.Equal(expected.Links, actual.Links); // Data // Document types can be the following: // 1. Document // 2. EmptyDocument // 3. ErrorsDocument // 4. NullDocument // 5. ResourceDocument // 6. ResourceIdentifierDocument // 7. ResourceCollectionDocument // 8. ResourceIdentifierCollectionDocument var expectedDocumentTypeInfo = expected.GetType().GetTypeInfo(); if (expectedDocumentTypeInfo == DocumentTypeInfo) { // NOOP } else if (expectedDocumentTypeInfo == EmptyDocumentTypeInfo) { var expectedData = expected.GetData(); var actualData = actual.GetData(); ClrObjectAssert.Equal(expectedData, actualData); } else if (expectedDocumentTypeInfo == ErrorsDocumentTypeInfo) { var expectedErrors = expected.GetErrors(); var actualErrors = actual.GetErrors(); ErrorAssert.Equal(expectedErrors, actualErrors); } else if (expectedDocumentTypeInfo == NullDocumentTypeInfo) { var expectedData = expected.GetData(); var actualData = actual.GetData(); ClrObjectAssert.Equal(expectedData, actualData); } else if (expectedDocumentTypeInfo == ResourceDocumentTypeInfo) { var expectedResourceDocument = (ResourceDocument)expected; var expectedResource = expectedResourceDocument.Data; if (expectedResource == null) { Assert.True(actual.IsNullDocument() || (actual.IsResourceDocument() && actual.IsDataNullOrEmpty())); return; } var actualResourceDocument = (ResourceDocument)actual; var actualResource = actualResourceDocument.Data; ResourceAssert.Equal(expectedResource, actualResource); // Included var expectedIncluded = expected.GetIncludedResources(); var actualIncluded = actual.GetIncludedResources(); ResourceAssert.Equal(expectedIncluded, actualIncluded); } else if (expectedDocumentTypeInfo == ResourceIdentifierDocumentTypeInfo) { var expectedResourceIdentifierDocument = (ResourceIdentifierDocument)expected; var expectedResourceIdentifier = expectedResourceIdentifierDocument.Data; if (expectedResourceIdentifier == null) { Assert.True(actual.IsNullDocument() || (actual.IsResourceIdentifierDocument() && actual.IsDataNullOrEmpty())); return; } var actualResourceIdentifierDocument = (ResourceIdentifierDocument)actual; var actualResourceIdentifier = actualResourceIdentifierDocument.Data; ResourceIdentifierAssert.Equal(expectedResourceIdentifier, actualResourceIdentifier); } else if (expectedDocumentTypeInfo == ResourceCollectionDocumentTypeInfo) { var expectedResourceCollectionDocument = (ResourceCollectionDocument)expected; var expectedResourceCollection = expectedResourceCollectionDocument.Data; Assert.NotNull(expectedResourceCollection); if (!expectedResourceCollection.Any()) { Assert.True(actual.IsEmptyDocument() || (actual.IsResourceCollectionDocument() && actual.IsDataNullOrEmpty())); return; } var actualResourceCollectionDocument = (ResourceCollectionDocument)actual; var actualResourceCollection = actualResourceCollectionDocument.Data; ResourceAssert.Equal(expectedResourceCollection, actualResourceCollection); // Included var expectedIncludedResources = expected.GetIncludedResources(); var actualIncludedResources = actual.GetIncludedResources(); ResourceAssert.Equal(expectedIncludedResources, actualIncludedResources); } else if (expectedDocumentTypeInfo == ResourceIdentifierCollectionDocumentTypeInfo) { var expectedResourceIdentifierCollectionDocument = (ResourceIdentifierCollectionDocument)expected; var expectedResourceIdentifierCollection = expectedResourceIdentifierCollectionDocument.Data; Assert.NotNull(expectedResourceIdentifierCollection); if (!expectedResourceIdentifierCollection.Any()) { Assert.True(actual.IsEmptyDocument() || (actual.IsResourceIdentifierCollectionDocument() && actual.IsDataNullOrEmpty())); return; } var actualResourceIdentifierCollectionDocument = (ResourceIdentifierCollectionDocument)actual; var actualResourceIdentifierCollection = actualResourceIdentifierCollectionDocument.Data; ResourceIdentifierAssert.Equal(expectedResourceIdentifierCollection, actualResourceIdentifierCollection); } else { Assert.True(false, String.Format("Unknown document type={0}", expectedDocumentTypeInfo)); } }