[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)); }