[DataRow(new Type[] { typeof(DateTime_MicrosoftJson_Formatter), typeof(DateTimeOffset_MicrosoftJson_Formatter) }, new Type[] { typeof(DateTime_MicrosoftJson_Formatter) }, false)] // RHS is subset of LHS
public void Equals_And_FormattersEquals_Returns_Expected_Value(Type[] lhsTypes, Type[] rhsTypes, bool expected)
{
ITypeFormatter[] typeFormatters(Type[] types)
{
var formatters = new List <ITypeFormatter>();
foreach (var type in types)
{
formatters.Add((ITypeFormatter)Activator.CreateInstance(type));
}
return(formatters.ToArray());
}
var lhsResolver = new TypeFormatterResolver(typeFormatters(lhsTypes));
var rhsFormatters = rhsTypes == null ? null : typeFormatters(rhsTypes);
var rhsResolver = rhsTypes == null ? null : new TypeFormatterResolver(rhsFormatters);
var equalsActual = lhsResolver.Equals(rhsResolver);
Assert.AreEqual(expected, equalsActual);
// Bit naughty to be testing two functions but Equals is basically a wrapper around FormatterEquals and
// I don't want to be doubling up the DataRows
var formattersEqualsActual = lhsResolver.FormattersEquals(rhsFormatters);
Assert.AreEqual(expected, formattersEqualsActual);
// Check that the == and != operators are calling down to .Equals
Assert.AreEqual(expected, lhsResolver == rhsResolver);
Assert.AreEqual(!expected, lhsResolver != rhsResolver);
}
/// <summary>
/// Either returns the existing settings for the resolver passed across or creates a
/// new settings object, caches it for future use and then returns it.
/// </summary>
/// <param name="resolver"></param>
/// <returns></returns>
public static JsonSerializerSettings Fetch(TypeFormatterResolver resolver)
{
JsonSerializerSettings result;
if (resolver == null)
{
result = _DefaultFormatterSettings;
}
else
{
var cache = _FormatterCache;
if (!cache.TryGetValue(resolver, out result))
{
lock (_SyncLock) {
if (!_FormatterCache.TryGetValue(resolver, out result))
{
result = CreateSettingsFromFormatterResolver(resolver);
var newCache = new Dictionary <TypeFormatterResolver, JsonSerializerSettings>(_FormatterCache)
{
[resolver] = result,
};
_FormatterCache = newCache;
}
}
}
}
return(result);
}
/// <summary>
/// See interface docs.
/// </summary>
/// <param name="obj"></param>
/// <param name="resolver"></param>
/// <returns></returns>
public string Serialise(object obj, TypeFormatterResolver resolver)
{
return(JsonConvert.SerializeObject(
obj,
JsonSerialiserSettingsCache.Fetch(resolver)
));
}
public void Find_Returns_Null_If_Formatter_Assigned_To_Different_Type()
{
var resolver = new TypeFormatterResolver(new DateTimeOffset_Iso8601_Formatter());
var formatter = resolver.Find <DateTime>();
Assert.IsNull(formatter);
}
public void Find_Returns_Assigned_Generic_TypeFormatterResolver()
{
var resolver = new TypeFormatterResolver(new DateTime_Iso8601_Formatter());
var formatter = resolver.Find <DateTime>();
Assert.IsInstanceOfType(formatter, typeof(DateTime_Iso8601_Formatter));
}
public void Find_Returns_Null_If_No_Formatter_Assigned()
{
var resolver = new TypeFormatterResolver();
var formatter = resolver.Find <DateTime>();
Assert.IsNull(formatter);
}
public void Formatters_Ctor_Assigns_Formatters_During_Construction()
{
var resolver = new TypeFormatterResolver(new DateTime_Iso8601_Formatter());
var formatter = resolver.Find <DateTime>();
Assert.IsInstanceOfType(formatter, typeof(DateTime_Iso8601_Formatter));
}
private static JsonSerializerSettings CreateSettingsFromFormatterResolver(TypeFormatterResolver typeFormatterResolver)
{
return(new JsonSerializerSettings()
{
Converters = new JsonConverter[] { new FormatterJsonConverter(typeFormatterResolver) },
DateParseHandling = DateParseHandling.None,
});
}
public void GetFormatters_Returns_Empty_Collection_For_Empty_Resolver()
{
var resolver = new TypeFormatterResolver();
var formatters = resolver.GetFormatters();
Assert.AreEqual(0, formatters.Length);
}
public void ToTypeFormatterResolver_WithDefault_Returns_Default_When_Attribute_Is_Null()
{
var defaultResolver = new TypeFormatterResolver(new DateTime_MicrosoftJson_Formatter(), new ByteArray_Mime64_Formatter());
var resolver = UseFormatterAttribute.ToTypeFormatterResolver(null, defaultResolver);
Assert.AreEqual(2, resolver.GetFormatters().Length);
Assert.IsInstanceOfType(resolver.DateTimeFormatter, typeof(DateTime_MicrosoftJson_Formatter));
Assert.IsInstanceOfType(resolver.ByteArrayFormatter, typeof(ByteArray_Mime64_Formatter));
}
public void GetAugmentedFormatters_Returns_Formatters()
{
var formatter = new DateTime_JavaScriptTicks_Formatter();
var resolver = new TypeFormatterResolver(formatter);
var formatters = resolver.GetAugmentedFormatters(null);
Assert.AreEqual(1, formatters.Length);
Assert.AreSame(formatter, formatters[0]);
}
public void ToTypeFormatterResolver_WithDefault_Returns_Resolver_Filled_With_Formatters_From_Ctor()
{
var attr = new UseFormatterAttribute(typeof(DateTime_Iso8601_Formatter), typeof(DateTimeOffset_Iso8601_Formatter));
var defaultResolver = new TypeFormatterResolver(new DateTime_MicrosoftJson_Formatter(), new ByteArray_Mime64_Formatter());
var resolver = UseFormatterAttribute.ToTypeFormatterResolver(attr, defaultResolver);
Assert.AreEqual(3, resolver.GetFormatters().Length);
Assert.IsInstanceOfType(resolver.DateTimeFormatter, typeof(DateTime_Iso8601_Formatter));
Assert.IsInstanceOfType(resolver.DateTimeOffsetFormatter, typeof(DateTimeOffset_Iso8601_Formatter));
Assert.IsInstanceOfType(resolver.ByteArrayFormatter, typeof(ByteArray_Mime64_Formatter));
}
public void DiscoverControllers_Uses_Default_TypeFormatterResolver()
{
_AllTypes.Add(typeof(MockController1));
var resolver = new TypeFormatterResolver(new DateTime_MicrosoftJson_Formatter());
_ControllerFinder.DefaultTypeFormatterResolver = resolver;
var controllerTypes = _ControllerFinder.DiscoverControllers().ToArray();
_AppDomainWrapper.Verify(r => r.GetAllTypes(), Times.Once());
Assert.AreEqual(resolver, controllerTypes[0].TypeFormatterResolver);
}
public void GetFormatters_Returns_Collection_Of_All_Registered_Formatters()
{
var formatter1 = new DateTime_Iso8601_Formatter();
var formatter2 = new DateTimeOffset_JavaScriptTicks_Formatter();
var resolver = new TypeFormatterResolver(formatter1, formatter2);
var formatters = resolver.GetFormatters();
Assert.AreEqual(2, formatters.Length);
Assert.IsTrue(formatters.Contains(formatter1));
Assert.IsTrue(formatters.Contains(formatter2));
}
public void GetHashCode_Is_Equal_For_All_Equal_Instances()
{
var resolver1 = new TypeFormatterResolver(
new DateTime_MicrosoftJson_Formatter(),
new DateTimeOffset_MicrosoftJson_Formatter()
);
var resolver2 = new TypeFormatterResolver(
new DateTimeOffset_MicrosoftJson_Formatter(),
new DateTime_MicrosoftJson_Formatter()
);
Assert.AreEqual(resolver1.GetHashCode(), resolver2.GetHashCode());
}
/// <summary>
/// See interface docs.
/// </summary>
/// <param name="context"></param>
/// <param name="obj"></param>
/// <param name="resolver"></param>
/// <param name="encoding"></param>
/// <param name="mimeType"></param>
public void ReturnJsonObject(OwinContext context, object obj, TypeFormatterResolver resolver, Encoding encoding, string mimeType)
{
if (String.IsNullOrEmpty(context.ResponseHeadersDictionary.CacheControl))
{
context.ResponseHeadersDictionary.CacheControl = "max-age=0,no-cache,no-store,must-revalidate";
}
context.ReturnText(
_JsonSerialiser.Serialise(obj, resolver),
encoding ?? Encoding.UTF8,
String.IsNullOrEmpty(mimeType) ? Formatter.FormatMediaType(MediaType.Json) : mimeType
);
}
public void Ctor_Uses_Default_TypeFormatterResolver_When_No_Overrides_Supplied()
{
var defaultResolver = new TypeFormatterResolver(
new ByteArray_HexString_Formatter(),
new DateTime_MicrosoftJson_Formatter()
);
var controllerType = new ControllerType(typeof(SampleController1), null, defaultResolver);
var formatters = controllerType.TypeFormatterResolver.GetFormatters();
Assert.AreEqual(2, formatters.Length);
Assert.IsTrue(formatters.Any(r => r.GetType() == typeof(ByteArray_HexString_Formatter)));
Assert.IsTrue(formatters.Any(r => r.GetType() == typeof(DateTime_MicrosoftJson_Formatter)));
}
public void Formatters_Ctor_Sets_Direct_Access_Property(Type mockType, string formatterPropertyName)
{
var mockFormatter = MockHelper.CreateMock(mockType);
var mockTypeFormatter = (ITypeFormatter)mockFormatter.Object;
var resolver = new TypeFormatterResolver(mockTypeFormatter);
var formatterProperty = resolver
.GetType()
.GetProperty(formatterPropertyName);
var formatterValue = formatterProperty.GetValue(resolver, null);
Assert.AreSame(mockTypeFormatter, formatterValue);
}
/// <summary>
/// Creates a new object.
/// </summary>
/// <param name="type"></param>
/// <param name="defaultParserResolver"></param>
/// <param name="defaultFormatterResolver"></param>
public ControllerType(Type type, TypeParserResolver defaultParserResolver, TypeFormatterResolver defaultFormatterResolver)
{
Type = type;
FilterAttributes = Type.GetCustomAttributes(inherit: true)
.OfType <IFilterAttribute>()
.ToArray();
var useParserAttr = Type.GetCustomAttributes(typeof(UseParserAttribute), inherit: true)
.OfType <UseParserAttribute>()
.FirstOrDefault();
TypeParserResolver = UseParserAttribute.ToTypeParserResolver(useParserAttr, defaultParserResolver);
var useFormatterAttr = Type.GetCustomAttributes(typeof(UseFormatterAttribute), inherit: true)
.OfType <UseFormatterAttribute>()
.FirstOrDefault();
TypeFormatterResolver = UseFormatterAttribute.ToTypeFormatterResolver(useFormatterAttr, defaultFormatterResolver);
}
public void GetAugmentedFormatters_Augments_Registered_Formatters_With_List_Passed_In()
{
var originalDateTimeFormatter = new DateTime_JavaScriptTicks_Formatter();
var originalDateTimeOffsetFormatter = new DateTimeOffset_JavaScriptTicks_Formatter();
var newDateTimeFormatter = new DateTime_Iso8601_Formatter();
var newByteArrayFormatter = new ByteArray_Mime64_Formatter();
var resolver = new TypeFormatterResolver(originalDateTimeFormatter, originalDateTimeOffsetFormatter);
var formatters = resolver.GetAugmentedFormatters(newDateTimeFormatter, null, newByteArrayFormatter);
Assert.AreEqual(3, formatters.Length);
Assert.IsTrue(formatters.Contains(newDateTimeFormatter));
Assert.IsTrue(formatters.Contains(originalDateTimeOffsetFormatter));
Assert.IsTrue(formatters.Contains(newByteArrayFormatter));
var originalFormatters = resolver.GetFormatters();
Assert.AreEqual(2, originalFormatters.Length);
Assert.IsTrue(originalFormatters.Contains(originalDateTimeFormatter));
Assert.IsTrue(originalFormatters.Contains(originalDateTimeOffsetFormatter));
}
public void Serialise_Uses_Formatter_For_Dates_And_Byte_Arrays_But_Not_Json_Spec_Types(Type valueType, bool mustUseFormatter, string propertyName, object originalValueRaw)
{
Mock mockFormatter = null;
void createMock <T>(T expectedValue)
{
var mock = MockHelper.CreateMock <ITypeFormatter <T> >();
mock.Setup(r => r.Format(expectedValue)).Returns("!!!");
mockFormatter = mock;
}
var expectedNormal = DataRowParser.ConvertExpected(valueType, originalValueRaw);
var valueProperty = typeof(ValueTypes).GetProperty(propertyName);
if (valueType == typeof(bool))
{
createMock <bool>((bool)expectedNormal);
}
else if (valueType == typeof(byte))
{
createMock <byte>((byte)expectedNormal);
}
else if (valueType == typeof(char))
{
createMock <char>((char)expectedNormal);
}
else if (valueType == typeof(Int16))
{
createMock <short>((short)expectedNormal);
}
else if (valueType == typeof(UInt16))
{
createMock <ushort>((ushort)expectedNormal);
}
else if (valueType == typeof(Int32))
{
createMock <int>((int)expectedNormal);
}
else if (valueType == typeof(UInt32))
{
createMock <uint>((uint)expectedNormal);
}
else if (valueType == typeof(Int64))
{
createMock <long>((long)expectedNormal);
}
else if (valueType == typeof(UInt64))
{
createMock <ulong>((ulong)expectedNormal);
}
else if (valueType == typeof(float))
{
createMock <float>((float)expectedNormal);
}
else if (valueType == typeof(double))
{
createMock <double>((double)expectedNormal);
}
else if (valueType == typeof(decimal))
{
createMock <decimal>((decimal)expectedNormal);
}
else if (valueType == typeof(DateTime))
{
createMock <DateTime>((DateTime)expectedNormal);
}
else if (valueType == typeof(DateTimeOffset))
{
createMock <DateTimeOffset>((DateTimeOffset)expectedNormal);
}
else if (valueType == typeof(Guid))
{
createMock <Guid>((Guid)expectedNormal);
}
else if (valueType == typeof(string))
{
createMock <string>((string)expectedNormal);
}
else if (valueType == typeof(byte[]))
{
createMock <byte[]>((byte[])expectedNormal);
}
else
{
throw new NotImplementedException();
}
var typeResolver = new TypeFormatterResolver((ITypeFormatter)mockFormatter.Object);
var originalInstance = new ValueTypes();
valueProperty.SetValue(originalInstance, expectedNormal);
var jsonText = _Serialiser.Serialise(originalInstance, typeResolver);
var jObject = JObject.Parse(jsonText);
var jProperty = jObject.Property(propertyName);
if (mustUseFormatter)
{
Assert.AreEqual("!!!", jProperty.Value.ToString());
}
else
{
Assert.AreEqual(expectedNormal, jProperty.Value.ToObject(valueProperty.PropertyType));
}
}
/// <summary>
/// Returns a <see cref="TypeParserResolver"/> filled with the parsers from the <see cref="UseParserAttribute"/> attribute.
/// </summary>
/// <param name="useFormatter"></param>
/// <param name="defaultResolver"></param>
/// <returns></returns>
public static TypeFormatterResolver ToTypeFormatterResolver(UseFormatterAttribute useFormatter, TypeFormatterResolver defaultResolver)
{
var result = defaultResolver;
if (useFormatter?.IsValid ?? false)
{
result = result == null
? TypeFormatterResolverCache.Find(useFormatter.Formatters)
: TypeFormatterResolverCache.Find(result.GetAugmentedFormatters(useFormatter.Formatters));
}
return(result);
}
/// <summary>
/// See interface docs.
/// </summary>
/// <param name="owinEnvironment"></param>
/// <param name="obj"></param>
/// <param name="resolver"></param>
/// <param name="encoding"></param>
/// <param name="mimeType"></param>
public void ReturnJsonObject(IDictionary <string, object> owinEnvironment, object obj, TypeFormatterResolver resolver, Encoding encoding, string mimeType)
{
ReturnJsonObject(
OwinContext.Create(owinEnvironment),
obj,
resolver,
encoding,
mimeType
);
}
/// <summary>
/// Creates a new object.
/// </summary>
/// <param name="typeParserResolver"></param>
public FormatterJsonConverter(TypeFormatterResolver typeFormatterResolver)
{
TypeFormatterResolver = typeFormatterResolver;
}
public void FormatType_With_Resolver_Uses_Resolver_When_Supplied(Type valueType, string formatterMethodName, object rawValue)
{
Mock mockFormatter = null;
void createMock <T>(T expectedValue)
{
var mock = MockHelper.CreateMock <ITypeFormatter <T> >();
mock.Setup(r => r.Format(expectedValue)).Returns("!!!");
mockFormatter = mock;
}
var formatterMethod = typeof(Formatter)
.GetMethods(BindingFlags.Static | BindingFlags.Public)
.Single(r => r.Name == formatterMethodName && r.GetParameters().Length == 2);
Func <object, TypeFormatterResolver, string> callFormatter;
callFormatter = (t, r) => formatterMethod.Invoke(null, new object[] { t, r }) as string;
var value = DataRowParser.ConvertExpected(valueType, rawValue);
if (valueType == typeof(bool))
{
createMock <bool>((bool)value);
}
else if (valueType == typeof(byte))
{
createMock <byte>((byte)value);
}
else if (valueType == typeof(char))
{
createMock <char>((char)value);
}
else if (valueType == typeof(Int16))
{
createMock <short>((short)value);
}
else if (valueType == typeof(UInt16))
{
createMock <ushort>((ushort)value);
}
else if (valueType == typeof(Int32))
{
createMock <int>((int)value);
}
else if (valueType == typeof(UInt32))
{
createMock <uint>((uint)value);
}
else if (valueType == typeof(Int64))
{
createMock <long>((long)value);
}
else if (valueType == typeof(UInt64))
{
createMock <ulong>((ulong)value);
}
else if (valueType == typeof(float))
{
createMock <float>((float)value);
}
else if (valueType == typeof(double))
{
createMock <double>((double)value);
}
else if (valueType == typeof(decimal))
{
createMock <decimal>((decimal)value);
}
else if (valueType == typeof(DateTime))
{
createMock <DateTime>((DateTime)value);
}
else if (valueType == typeof(DateTimeOffset))
{
createMock <DateTimeOffset>((DateTimeOffset)value);
}
else if (valueType == typeof(Guid))
{
createMock <Guid>((Guid)value);
}
else if (valueType == typeof(byte[]))
{
createMock <byte[]>((byte[])value);
}
else if (valueType == typeof(string))
{
createMock <string>((string)value);
}
else
{
throw new NotImplementedException();
}
// Null type resolver should call normal formatter
Assert.AreNotEqual("!!!", callFormatter(value, null));
// Type resolver with no formatter for type should call normal formatter
var emptyTypeResolver = new TypeFormatterResolver();
Assert.AreNotEqual("!!!", callFormatter(value, emptyTypeResolver));
// If resolver contains formatter for type then it should be used
var typeResolver = new TypeFormatterResolver((ITypeFormatter)mockFormatter.Object);
Assert.AreEqual("!!!", callFormatter(value, typeResolver));
}
public static Route CreateRoute <T>(string methodName, string choosePath = null, TypeParserResolver parserResolver = null, TypeFormatterResolver formatterResolver = null)
{
return(CreateRoute(typeof(T), methodName, choosePath, parserResolver, formatterResolver));
}
public void Formatters_Ctor_Ignores_Null()
{
var resolver = new TypeFormatterResolver(new ITypeFormatter[] { null });
Assert.AreEqual(0, resolver.GetFormatters().Length);
}
public static Route CreateRoute(Type controllerNativeType, string methodName, string choosePath = null, TypeParserResolver parserResolver = null, TypeFormatterResolver formatterResolver = null)
{
var controllerType = new ControllerType(controllerNativeType, parserResolver, formatterResolver);
var method = controllerNativeType.GetMethod(methodName);
var routeAttributes = method.GetCustomAttributes(inherit: false).OfType <RouteAttribute>().ToArray();
var routeAttribute = routeAttributes.Length == 1
? routeAttributes[0]
: routeAttributes.Single(r => r.Route == choosePath);
return(new Route(controllerType, method, routeAttribute));
}
