public static void DeserializeToDateTime___Should_deserialize_DateTime___When_called()
{
// Arrange
// note that this will return "+00:00" if machine is on UTC time, which is what we expect
var offset = DateTime.Now.ToString("%K");
var scenarios = new List <(DateTime Expected, string SerializedString)>
{
(new DateTime(2019, 1, 5, 12, 14, 58, 192, DateTimeKind.Utc), "2019-01-05T12:14:58.1920000Z"),
(new DateTime(2019, 1, 5, 12, 14, 58, 192, DateTimeKind.Utc).AddTicks(1), "2019-01-05T12:14:58.1920001Z"),
(new DateTime(2019, 1, 5, 12, 14, 58, 192, DateTimeKind.Utc).AddTicks(20), "2019-01-05T12:14:58.1920020Z"),
(new DateTime(2019, 1, 5, 12, 14, 58, 192, DateTimeKind.Unspecified), "2019-01-05T12:14:58.1920000"),
(new DateTime(2019, 1, 5, 12, 14, 58, 192, DateTimeKind.Unspecified).AddTicks(1), "2019-01-05T12:14:58.1920001"),
(new DateTime(2019, 1, 5, 12, 14, 58, 192, DateTimeKind.Unspecified).AddTicks(20), "2019-01-05T12:14:58.1920020"),
(new DateTime(2019, 1, 5, 12, 14, 58, 192, DateTimeKind.Local), "2019-01-05T12:14:58.1920000" + offset),
(new DateTime(2019, 1, 5, 12, 14, 58, 192, DateTimeKind.Local).AddTicks(1), "2019-01-05T12:14:58.1920001" + offset),
(new DateTime(2019, 1, 5, 12, 14, 58, 192, DateTimeKind.Local).AddTicks(20), "2019-01-05T12:14:58.1920020" + offset),
};
// Act
var actuals = scenarios.Select(_ => ObcDateTimeStringSerializer.DeserializeToDateTime(_.SerializedString)).ToList();
// Assert
actuals.Must().BeEqualTo(scenarios.Select(_ => _.Expected).ToList());
}
public static void DeserializeToDateTime___Should_throw_InvalidOperationException___When_serializedString_is_malformed()
{
// Arrange
var serializedDateTimes = new[]
{
"2017-05-06T02:28:46", // no precision not supported for Unspecified
"2017-05-06T02:28:46+00:00", // no precision not supported for Local
"2017-05-06T02:28:46.270488", // less than 7 precision not supported for Unspecified
"2017-05-06T02:28:46.270488+00:00", // less than 7 precision not supported for Local
"2017-05-06T02:28:46.27048838", // too much precision
"2017-05-06T02:28:46.27048838+00:00", // too much precision
"2017-05-06T02:28:46.27048838Z", // too much precision
"2017-05-06T02:28:46.2704883K", // shouldn't end in K
"some-string", // random string
"2017-05-06", // only date
"2017-05-06+00:00", // only date
"2017-05-06Z", // only date
"02:28:46.1938283", // only time
"02:28:46.1938283+00:00", // only time
"02:28:46.1938283Z", // only time
};
// Act
var actuals = serializedDateTimes.Select(_ => Record.Exception(() => ObcDateTimeStringSerializer.DeserializeToDateTime(_))).ToList();
// Assert
actuals.Must().Each().BeOfType <InvalidOperationException>();
actuals.Select(_ => _.Message).Must().Each().ContainString("is malformed; it's not in a supported format and cannot be deserialized.");
}
public static void DeserializeToDateTime___Should_throw_ArgumentNullException___When_parameter_serializedString_is_null()
{
// Arrange, Act
var actual = Record.Exception(() => ObcDateTimeStringSerializer.DeserializeToDateTime(null));
// Assert
actual.Must().BeOfType <ArgumentNullException>();
actual.Message.Must().ContainString("serializedString");
}
public static void DeserializeToDateTime___Should_throw_ArgumentException___When_parameter_serializedString_is_white_space()
{
// Arrange, Act
var actual = Record.Exception(() => ObcDateTimeStringSerializer.DeserializeToDateTime(Invariant($" {Environment.NewLine} ")));
// Assert
actual.Must().BeOfType <ArgumentException>();
actual.Message.Must().ContainString("serializedString");
actual.Message.Must().ContainString("white space");
}
private object MakeObjectFromString(
string value,
Type type)
{
if (value == null)
{
return(null);
}
if (this.configuredTypeToSerializerMap.ContainsKey(type))
{
var serializer = this.configuredTypeToSerializerMap[type];
var result = serializer.Deserialize(value, type);
return(result);
}
else if (type.IsEnum)
{
var result = Enum.Parse(type, value);
return(result);
}
else if (type.IsArray)
{
var arrayItemType = type.GetElementType() ?? throw new SerializationException(Invariant($"Found array type that cannot extract element type: {type}"));
var asList = (IList)this.MakeObjectFromString(value, typeof(List <>).MakeGenericType(arrayItemType));
var asArrayList = new ArrayList(asList);
var result = asArrayList.ToArray(arrayItemType);
return(result);
}
else if (type == typeof(DateTime) || type == typeof(DateTime?))
{
var result = ObcDateTimeStringSerializer.DeserializeToDateTime(value);
return(result);
}
else if ((type != typeof(string)) && typeof(IEnumerable).IsAssignableFrom(type))
{
var itemType = type.GenericTypeArguments.SingleOrDefault() ?? throw new SerializationException(Invariant($"Found {typeof(IEnumerable)} type that cannot extract element type: {type}"));
var stringValues = value.FromCsv(this.dictionaryStringSerializer.NullValueEncoding);
var result = (IList)typeof(List <>).MakeGenericType(itemType).Construct();
foreach (var stringValue in stringValues)
{
var itemValue = stringValue == null
? null
: this.MakeObjectFromString(stringValue, itemType);
result.Add(itemValue);
}
return(result);
}
else
{
var typeToSearchForParse = type;
if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable <>))
{
typeToSearchForParse = type.GenericTypeArguments.Single();
}
var parseMethod = typeToSearchForParse
.GetMethodsFiltered(MemberRelationships.DeclaredOrInherited, MemberOwners.All, MemberAccessModifiers.Public)
.SingleOrDefault(_ =>
{
var parameters = _.GetParameters();
return((_.Name == "Parse") && (parameters.Length == 1) && (parameters.Single().ParameterType == typeof(string)));
});
var result = parseMethod == null
? value
: parseMethod.Invoke(null, new object[] { value });
return(result);
}
}