//[Description("https://bitbucket.org/Readify/neo4jclient/issue/149/deserialization-of-type-decimal-fails-when")]
public void DecimalDeserializationIsCultureIndependent()
{
//SetupFixture defaults culture info so culture-dependent tests should preserve culture state
var currentNumberDecimalSeparator = CultureInfo.CurrentCulture.NumberFormat.NumberDecimalSeparator;
try
{
//Arange
var newCulture = new CultureInfo(CultureInfo.CurrentCulture.Name)
{
NumberFormat = { NumberDecimalSeparator = "," }
};
Thread.CurrentThread.CurrentCulture = newCulture;
const string serializedModelWithDecimal = "{'data':{'MyDecimalValue':0.5}}";
//Act
var customDeserializer = new CustomJsonDeserializer(GraphClient.DefaultJsonConverters);
var result = customDeserializer.Deserialize <ModelWithDecimal>(serializedModelWithDecimal);
//Assert
Assert.Equal(0.5m, result.MyDecimalValue);
}
finally
{
CultureInfo.CurrentCulture.NumberFormat.NumberDecimalSeparator = currentNumberDecimalSeparator;
}
}
public void CamelCaseListTest()
{
//setup
var model = new List<CamelModel>
{
new CamelModel
{
FirstName = "first",
DateOfBirth = new DateTime(1980, 4, 1),
Gender = Gender.Male
},
new CamelModel
{
FirstName = "second",
DateOfBirth = new DateTime(1981, 4, 1),
Gender = Gender.Female
}
};
var serializer = new CustomJsonSerializer();
serializer.JsonContractResolver = new CamelCasePropertyNamesContractResolver();
var st = serializer.Serialize(model);
//act
var deserializer = new CustomJsonDeserializer(GraphClient.DefaultJsonConverters, resolver: (DefaultContractResolver)serializer.JsonContractResolver);
var output = deserializer.Deserialize<List<CamelModel>>(st);
//assert
AssertCamelModel(model[0], output[0]);
AssertCamelModel(model[1], output[1]);
}
public void CamelCaseListTest()
{
//setup
var model = new List <CamelModel>
{
new CamelModel
{
FirstName = "first",
DateOfBirth = new DateTime(1980, 4, 1),
Gender = Gender.Male
},
new CamelModel
{
FirstName = "second",
DateOfBirth = new DateTime(1981, 4, 1),
Gender = Gender.Female
}
};
var serializer = new CustomJsonSerializer();
serializer.JsonContractResolver = new CamelCasePropertyNamesContractResolver();
var st = serializer.Serialize(model);
//act
var deserializer = new CustomJsonDeserializer(GraphClient.DefaultJsonConverters, resolver: (DefaultContractResolver)serializer.JsonContractResolver);
var output = deserializer.Deserialize <List <CamelModel> >(st);
//assert
AssertCamelModel(model[0], output[0]);
AssertCamelModel(model[1], output[1]);
}
public void DeserializeShouldPreserveDateValuesUsingIso8601Format(string input, string expectedResult, DateTimeKind expectedKind)
{
var culturesToTest = new[] { "en-AU", "en-US", "nb-NO" };
foreach (var cultureName in culturesToTest)
{
// Arrange
var deserializer = new CustomJsonDeserializer(GraphClient.DefaultJsonConverters, new CultureInfo(cultureName));
var content = string.Format("{{'Foo':'{0}'}}", input);
// Act
var result = deserializer.Deserialize <DateTimeModel>(content);
// Assert
if (expectedResult == null)
{
Assert.Null(result.Foo);
}
else
{
Assert.NotNull(result.Foo);
Assert.Equal(expectedKind, result.Foo.Value.Kind);
Assert.Equal(expectedResult, result.Foo.Value.ToString("o", CultureInfo.InvariantCulture));
}
}
}
public void DeserializeIEnumerableOfEnumWithDefaultJsonConverters(string content, Gender[] genders)
{
// Act
var deserializer = new CustomJsonDeserializer(GraphClient.DefaultJsonConverters);
// Assert
var result = deserializer.Deserialize <List <Gender> >(content);
CollectionAssert.AreEquivalent(result, genders);
}
public void DeserializeIEnumerableOfEnumWithDefaultJsonConverters(string content, Gender[] genders)
{
// Act
var deserializer = new CustomJsonDeserializer(GraphClient.DefaultJsonConverters);
// Assert
var result = deserializer.Deserialize <List <Gender> >(content);
result.Should().BeEquivalentTo(genders);
}
public void DeserializeEnumFromStringWithDefaultJsonConverters(string content, Gender expectedGender)
{
// Arrange
var deserializer = new CustomJsonDeserializer(GraphClient.DefaultJsonConverters);
// Act
var deserialziedGender = deserializer.Deserialize <EnumModel>(content);
// Assert
Assert.IsNotNull(deserialziedGender);
Assert.AreEqual(deserialziedGender.Gender, expectedGender);
}
public void DeserializeEnumFromStringWithDefaultJsonConverters(string content, Gender expectedGender)
{
// Arrange
var deserializer = new CustomJsonDeserializer(GraphClient.DefaultJsonConverters);
// Act
var deserialziedGender = deserializer.Deserialize<EnumModel>(content);
// Assert
Assert.IsNotNull(deserialziedGender);
Assert.AreEqual(deserialziedGender.Gender, expectedGender);
}
public void DeserializeNullableEnumFromStringWithDefaultJsonConverters(string content, Gender?expectedGender)
{
// Arrange
var deserializer = new CustomJsonDeserializer(GraphClient.DefaultJsonConverters);
// Act
var result = deserializer.Deserialize <EnumModel>(content);
// Assert
Assert.NotNull(result);
Assert.Equal(expectedGender, result.GenderNullable);
}
public void DeserializeShouldUseCustomSerializerBeforeDefault()
{
var deserializer = new CustomJsonDeserializer(new List <JsonConverter>(GraphClient.DefaultJsonConverters)
{
new DateTimeDeserializer()
});
var expected = new DateTime(2000, 1, 1).Date;
var deserializeDateTime = deserializer.Deserialize <DateTimeModel>("{\"Foo\":\"630822816000000000\"}");
Assert.NotNull(deserializeDateTime.Foo);
Assert.Equal(expected, deserializeDateTime.Foo.Value);
}
public void DeserializeTimeSpanWithDefaultJsonConverters(string value, int days, int hours, int minutes, int seconds, int milliseconds)
{
// Arrange
var deserializer = new CustomJsonDeserializer(GraphClient.DefaultJsonConverters);
var content = string.Format("{{'Foo':'{0}'}}", value);
// Act
var result = deserializer.Deserialize <TimeSpanModel>(content);
// Assert
Assert.NotNull(result.Foo);
Assert.Equal(new TimeSpan(days, hours, minutes, seconds, milliseconds), result.Foo);
}
private WxTeamsApi GetApi <TEntity>(HttpMethod method, string endpoint, string content, string json = null, MultipartFormDataContent formData = null)
{
var mockBaseClient = new Mock <IWxBaseClient>();
mockBaseClient.Setup(x => x.GetHttpResponse <TEntity>(method, endpoint, json, formData))
.ReturnsAsync(new HttpResponseMessage {
Content = new StringContent(content)
});
var logger = new Mock <ILogger <WxTeamsApi> >();
var deserializer = new CustomJsonDeserializer();
var teamsClient = new TeamsClient(deserializer, mockBaseClient.Object);
return(new WxTeamsApi(teamsClient, deserializer, logger.Object));
}
public void DeserializesCorrectlyDateTimes()
{
// Arrange
var deserializer = new CustomJsonDeserializer(new List <JsonConverter> {
new NeoDateTimeSerializer()
}, new CultureInfo("en-US"));
var content = $"{{'Dt':{630822816000000000}}}";
// Act
var result = deserializer.Deserialize <DtModel>(content);
// Assert
Assert.NotNull(result.Dt);
Assert.Equal(630822816000000000, result.Dt.Ticks);
}
//[Description("https://bitbucket.org/Readify/neo4jclient/issue/89")]
public void ShouldDeserializeBuiltInTypeThatHasTypeConverterUsingTypeConverterBasedJsonConverter()
{
//Arrange
string rawInput = $"{{{Environment.NewLine} \"MyPoint\": \"100, 200\"{Environment.NewLine}}}";
var serializer = new CustomJsonDeserializer(new JsonConverter[] { new TypeConverterBasedJsonConverter() });
//Act
var model = serializer.Deserialize <TestModelC>(rawInput);
//Assert
Assert.NotNull(model);
Assert.NotNull(model.MyPoint);
Assert.Equal(new System.Drawing.Point(100, 200), model.MyPoint);
}
public void DeserializeTimeZoneInfoWithDefaultJsonConverters()
{
// Arrange
var deserializer = new CustomJsonDeserializer(GraphClient.DefaultJsonConverters);
const string ausEasternStandardTime = "AUS Eastern Standard Time";
var content = string.Format("{{'Foo':'{0}'}}", ausEasternStandardTime);
// Act
var result = deserializer.Deserialize <TimeZoneModel>(content);
// Assert
Assert.NotNull(result.Foo);
Assert.Equal(TimeZoneInfo.FindSystemTimeZoneById(ausEasternStandardTime).DisplayName,
result.Foo.DisplayName);
}
protected T Deserialize <T>(string resp, string rootElement) where T : new()
{
var jsonDeserializer = new CustomJsonDeserializer();
jsonDeserializer.UseISOUniversalTime = true;//parses "2010-10-12T18:03:18Z"
if (rootElement != null)
{
jsonDeserializer.RootElement = rootElement;
}
T result = jsonDeserializer.Deserialize <T>(resp);
return(result);
}
public void ShouldDeserializeBuiltInTypeThatHasTypeConverterUsingTypeConverterBasedJsonConverter()
{
//Arrange
const string rawInput =
"{\r\n \"MyPoint\": \"100, 200\"\r\n}";
var serializer = new CustomJsonDeserializer(new JsonConverter[] { new TypeConverterBasedJsonConverter() });
//Act
var model = serializer.Deserialize <TestModelC>(rawInput);
//Assert
Assert.NotNull(model, "Deserialization failed.");
Assert.NotNull(model.MyPoint, "Model.MyPoint is unexpectedly null.");
Assert.AreEqual(new System.Drawing.Point(100, 200), model.MyPoint);
}
public void ShouldDeserializeBuiltInTypeThatHasTypeConverterUsingTypeConverterBasedJsonConverter()
{
//Arrange
const string rawInput =
"{\r\n \"MyPoint\": \"100, 200\"\r\n}";
var serializer = new CustomJsonDeserializer(new JsonConverter[] { new TypeConverterBasedJsonConverter() });
//Act
var model = serializer.Deserialize<TestModelC>(rawInput);
//Assert
Assert.NotNull(model, "Deserialization failed.");
Assert.NotNull(model.MyPoint, "Model.MyPoint is unexpectedly null.");
Assert.AreEqual(new System.Drawing.Point(100, 200), model.MyPoint);
}
public void DeserializeGuidWithDefaultJsonConverters()
{
//Arrage
var myGuid = Guid.NewGuid();
var foo = new EnumerableModel { Guids = new List<Guid> { myGuid } };
// Act
var customSerializer = new CustomJsonSerializer{JsonConverters = GraphClient.DefaultJsonConverters};
var testStr = customSerializer.Serialize(foo);
var customDeserializer = new CustomJsonDeserializer(GraphClient.DefaultJsonConverters);
var result = customDeserializer.Deserialize<EnumerableModel>(testStr);
// Assert
Assert.AreEqual(myGuid, result.Guids.First());
}
public void ShouldDeserializeCustomValueWithCustomJsonConverter()
{
//Arrange
const string rawInput =
"{\r\n \"CustomValue\": \"op\"\r\n}";
var serializer = new CustomJsonDeserializer(new []{new TestValueAConverter()});
//Act
var model = serializer.Deserialize<TestModelA>(rawInput);
//Assert
Assert.NotNull(model, "Deserialization failed.");
Assert.NotNull(model.CustomValue, "Model.CustomValue is unexpectedly null.");
Assert.AreEqual('o', model.CustomValue.A);
Assert.AreEqual('p', model.CustomValue.B);
}
//[Description("https://bitbucket.org/Readify/neo4jclient/issue/89")]
public void ShouldDeserializeCustomValueWithCustomJsonConverter()
{
//Arrange
string rawInput =
$"{{{Environment.NewLine} \"CustomValue\": \"op\"{Environment.NewLine}}}";
var serializer = new CustomJsonDeserializer(new [] { new TestValueAConverter() });
//Act
var model = serializer.Deserialize <TestModelA>(rawInput);
//Assert
Assert.NotNull(model);
Assert.NotNull(model.CustomValue);
Assert.Equal('o', model.CustomValue.A);
Assert.Equal('p', model.CustomValue.B);
}
//[Description("https://bitbucket.org/Readify/neo4jclient/issue/89")]
public void ShouldDeserializeCustomTypeThatHasTypeConverterUsingTypeConverterBasedJsonConverter()
{
//Arrange
const string rawInput =
"{\r\n \"CustomValue\": \"op\"\r\n}";
var serializer = new CustomJsonDeserializer(new JsonConverter[] { new TypeConverterBasedJsonConverter() });
//Act
var model = serializer.Deserialize <TestModelB>(rawInput);
//Assert
Assert.NotNull(model);
Assert.NotNull(model.CustomValue);
Assert.Equal('o', model.CustomValue.A);
Assert.Equal('p', model.CustomValue.B);
}
internal static void ConvertAndSetValue <TResult>(this TResult result, string value, PropertyInfo prop, IEnumerable <JsonConverter> jsonConverters)
where TResult : new()
{
var deserializer = new CustomJsonDeserializer(jsonConverters);
try
{
var validType = prop.PropertyType;
if (prop.PropertyType.GetTypeInfo().IsGenericType&&
prop.PropertyType.GetGenericTypeDefinition() == typeof(Nullable <>))
{
var nullableConverter = new NullableConverter(prop.PropertyType);
validType = nullableConverter.UnderlyingType;
}
if (value == null || value == "null" || string.IsNullOrEmpty(value))
{
prop.SetValue(result, null, null);
return;
}
object convertedData;
if (validType.GetTypeInfo().IsEnum)
{
convertedData = Enum.Parse(validType, value, false);
}
else if (validType == typeof(DateTimeOffset))
{
var rawValue = value.Replace("NeoDate", "Date");
convertedData = DateRegex.IsMatch(rawValue)
? deserializer.Deserialize <DateHolder>(string.Format(@"{{ DateTimeOffset: '{0}'}}", rawValue)).DateTimeOffset
: DateTimeOffset.Parse(rawValue);
}
else
{
convertedData = Convert.ChangeType(value, validType);
}
prop.SetValue(result, convertedData, null);
}
catch (Exception ex)
{
throw new Exception(string.Format("Could not set property {0} to value {1} for type {2}\n {3}",
prop.Name,
value, result.GetType().FullName, ex));
}
}
//[Description("https://bitbucket.org/Readify/neo4jclient/issue/89")]
public void ShouldDeserializeCustomValueWithCustomJsonConverter()
{
//Arrange
const string rawInput =
"{\r\n \"CustomValue\": \"op\"\r\n}";
var serializer = new CustomJsonDeserializer(new [] { new TestValueAConverter() });
//Act
var model = serializer.Deserialize <TestModelA>(rawInput);
//Assert
Assert.NotNull(model);
Assert.NotNull(model.CustomValue);
Assert.Equal('o', model.CustomValue.A);
Assert.Equal('p', model.CustomValue.B);
}
public void DeserializeShouldConvertTableCapResponseToGremlinTableCapResponse()
{
// Arrange
var deserializer = new CustomJsonDeserializer(GraphClient.DefaultJsonConverters);
const string content = @"{
""columns"" : [ ""ColumnA"" ],
""data"" : [ [ ""DataA"" ], [ ""DataB"" ] ]
}";
// Act
var result = deserializer.Deserialize <GremlinTableCapResponse>(content);
var data = result.Data.SelectMany(d => d).ToArray();
// Assert
Assert.True(result.Columns.Any(c => c == "ColumnA"));
Assert.True(data.Any(d => d == "DataA"));
Assert.True(data.Any(d => d == "DataB"));
}
public void DeserializeTimeZoneInfoWithDefaultJsonConverters()
{
// Arrange
var deserializer = new CustomJsonDeserializer(GraphClient.DefaultJsonConverters);
var chosenTimeZone = new [] { "AUS Eastern Standard Time", "Australia/Perth" }
.Where(s => TimeZoneInfo.GetSystemTimeZones().Any(tz => tz.Id.Equals(s)))
.FirstOrDefault(tz => tz != null);
Assert.NotNull(chosenTimeZone); // if this fails try adding a timezone that your platform has to the list above
var content = $"{{'Foo':'{chosenTimeZone}'}}";
// Act
var result = deserializer.Deserialize <TimeZoneModel>(content);
// Assert
Assert.NotNull(result.Foo);
Assert.Equal(TimeZoneInfo.FindSystemTimeZoneById(chosenTimeZone).DisplayName,
result.Foo.DisplayName);
}
public void CamelCaseTest()
{
//setup
var model = new CamelModel
{
FirstName = "first",
DateOfBirth = new DateTime(1980, 4, 1),
Gender = Gender.Male,
S = "short property"
};
var serializer = new CustomJsonSerializer();
serializer.JsonContractResolver = new CamelCasePropertyNamesContractResolver();
var st = serializer.Serialize(model);
//act
var deserializer = new CustomJsonDeserializer(GraphClient.DefaultJsonConverters, resolver: (DefaultContractResolver)serializer.JsonContractResolver);
var output = deserializer.Deserialize<CamelModel>(st);
//assert
AssertCamelModel(model, output);
}
public void CamelCaseTest()
{
//setup
var model = new CamelModel
{
FirstName = "first",
DateOfBirth = new DateTime(1980, 4, 1),
Gender = Gender.Male,
S = "short property"
};
var serializer = new CustomJsonSerializer();
serializer.JsonContractResolver = new CamelCasePropertyNamesContractResolver();
var st = serializer.Serialize(model);
//act
var deserializer = new CustomJsonDeserializer(GraphClient.DefaultJsonConverters, resolver: (DefaultContractResolver)serializer.JsonContractResolver);
var output = deserializer.Deserialize <CamelModel>(st);
//assert
AssertCamelModel(model, output);
}
public void DeserializeGuidWithDefaultJsonConverters()
{
//Arrage
var myGuid = Guid.NewGuid();
var foo = new EnumerableModel {
Guids = new List <Guid> {
myGuid
}
};
// Act
var customSerializer = new CustomJsonSerializer {
JsonConverters = GraphClient.DefaultJsonConverters
};
var testStr = customSerializer.Serialize(foo);
var customDeserializer = new CustomJsonDeserializer(GraphClient.DefaultJsonConverters);
var result = customDeserializer.Deserialize <EnumerableModel>(testStr);
// Assert
Assert.Equal(myGuid, result.Guids.First());
}
public void DecimalDeserializationIsCultureIndependent()
{
//SetupFixture defaults culture info so culture-dependent tests should preserve culture state
var currentNumberDecimalSeparator = CultureInfo.CurrentCulture.NumberFormat.NumberDecimalSeparator;
try
{
//Arrage
CultureInfo.CurrentCulture.NumberFormat.NumberDecimalSeparator = ",";
const string serializedModelWithDecimal = "{'data':{'MyDecimalValue':0.5}}";
//Act
var customDeserializer = new CustomJsonDeserializer(GraphClient.DefaultJsonConverters);
var result = customDeserializer.Deserialize<ModelWithDecimal>(serializedModelWithDecimal);
//Assert
Assert.AreEqual(0.5m, result.MyDecimalValue);
}
finally
{
CultureInfo.CurrentCulture.NumberFormat.CurrencyDecimalSeparator = currentNumberDecimalSeparator;
}
}
public void DeserializeShouldPreserveOffsetValuesUsingIso8601Format(string input, string expectedResult)
{
var culturesToTest = new[] {"en-AU", "en-US"};
foreach (var cultureName in culturesToTest)
{
// Arrange
var deserializer = new CustomJsonDeserializer(GraphClient.DefaultJsonConverters, new CultureInfo(cultureName));
var content = string.Format("{{'Foo':'{0}'}}", input);
// Act
var result = deserializer.Deserialize<DateTimeOffsetModel>(content);
// Assert
if (expectedResult == null)
Assert.IsNull(result.Foo);
else
{
Assert.IsNotNull(result.Foo);
Assert.AreEqual(expectedResult, result.Foo.Value.ToString("o", CultureInfo.InvariantCulture));
}
}
}
public void DeserializeTimeZoneInfoWithDefaultJsonConverters()
{
// Arrange
var deserializer = new CustomJsonDeserializer(GraphClient.DefaultJsonConverters);
const string ausEasternStandardTime = "AUS Eastern Standard Time";
var content = string.Format("{{'Foo':'{0}'}}", ausEasternStandardTime);
// Act
var result = deserializer.Deserialize<TimeZoneModel>(content);
// Assert
Assert.IsNotNull(result.Foo);
Assert.AreEqual(TimeZoneInfo.FindSystemTimeZoneById(ausEasternStandardTime).DisplayName,
result.Foo.DisplayName);
}
public void DeserializeTimeSpanWithDefaultJsonConverters(string value, int days, int hours, int minutes, int seconds, int milliseconds)
{
// Arrange
var deserializer = new CustomJsonDeserializer(GraphClient.DefaultJsonConverters);
var content = string.Format("{{'Foo':'{0}'}}", value);
// Act
var result = deserializer.Deserialize<TimeSpanModel>(content);
// Assert
Assert.IsNotNull(result.Foo);
Assert.AreEqual(new TimeSpan(days, hours, minutes, seconds, milliseconds), result.Foo);
}
public void DeserializeShouldConvertTableCapResponseToGremlinTableCapResponse()
{
// Arrange
var deserializer = new CustomJsonDeserializer(GraphClient.DefaultJsonConverters);
const string content = @"{
""columns"" : [ ""ColumnA"" ],
""data"" : [ [ ""DataA"" ], [ ""DataB"" ] ]
}";
// Act
var result = deserializer.Deserialize<GremlinTableCapResponse>(content);
var data = result.Data.SelectMany(d => d).ToArray();
// Assert
Assert.IsTrue(result.Columns.Any(c => c == "ColumnA"));
Assert.IsTrue(data.Any(d => d == "DataA"));
Assert.IsTrue(data.Any(d => d == "DataB"));
}
public void DeserializeIEnumerableOfEnumWithDefaultJsonConverters(string content, Gender[] genders)
{
// Act
var deserializer = new CustomJsonDeserializer(GraphClient.DefaultJsonConverters);
// Assert
var result = deserializer.Deserialize<List<Gender>>(content);
CollectionAssert.AreEquivalent(result, genders);
}
public void DeserializeShouldUseCustomSerializerBeforeDefault()
{
var deserializer = new CustomJsonDeserializer(new List<JsonConverter>(GraphClient.DefaultJsonConverters) { new DateTimeDeserializer() });
var expected = new DateTime(2000, 1, 1).Date;
var deserializeDateTime = deserializer.Deserialize<DateTimeModel>("{\"Foo\":\"630822816000000000\"}");
Assert.IsNotNull(deserializeDateTime.Foo);
Assert.AreEqual(expected, deserializeDateTime.Foo.Value);
}
