[DataRow(new Type[] { typeof(DateTime_Local_Parser), typeof(DateTimeOffset_Local_Parser) }, new Type[] { typeof(DateTime_Local_Parser) }, false)] // RHS is subset of LHS public void Equals_And_ParserEquals_Returns_Expected_Value(Type[] lhsTypes, Type[] rhsTypes, bool expected) { ITypeParser[] typeParsers(Type[] types) { var parsers = new List <ITypeParser>(); foreach (var type in types) { parsers.Add((ITypeParser)Activator.CreateInstance(type)); } return(parsers.ToArray()); } var lhsResolver = new TypeParserResolver(typeParsers(lhsTypes)); var rhsParsers = rhsTypes == null ? null : typeParsers(rhsTypes); var rhsResolver = rhsTypes == null ? null : new TypeParserResolver(rhsParsers); var equalsActual = lhsResolver.Equals(rhsResolver); Assert.AreEqual(expected, equalsActual); // Bit naughty to be testing two functions but Equals is basically a wrapper around ParserEquals and // I don't want to be doubling up the DataRows var parserEqualsActual = lhsResolver.ParsersEquals(rhsParsers); Assert.AreEqual(expected, parserEqualsActual); // 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(TypeParserResolver resolver) { JsonSerializerSettings result; if (resolver == null) { result = _DefaultParserSettings; } else { var cache = _ParserCache; if (!cache.TryGetValue(resolver, out result)) { lock (_SyncLock) { if (!_ParserCache.TryGetValue(resolver, out result)) { result = CreateSettingsFromParserResolver(resolver); var newCache = new Dictionary <TypeParserResolver, JsonSerializerSettings>(_ParserCache) { [resolver] = result, }; _ParserCache = newCache; } } } } return(result); }
/// <summary> /// See interface docs. /// </summary> /// <param name="modelType"></param> /// <param name="typeParserResolver"></param> /// <param name="values"></param> /// <returns></returns> public object BuildModel(Type modelType, TypeParserResolver typeParserResolver, QueryStringDictionary values) { if (modelType == null) { throw new ArgumentNullException(nameof(modelType)); } if (values == null) { throw new ArgumentNullException(nameof(values)); } var result = Activator.CreateInstance(modelType); foreach (var propertyInfo in modelType.GetProperties()) { if (values.ContainsKey(propertyInfo.Name)) { var valueText = values.GetValue(propertyInfo.Name); var parsedValue = Parser.ParseType( propertyInfo.PropertyType, valueText, typeParserResolver ); propertyInfo.SetValue(result, parsedValue); } } return(result); }
public void GetParsers_Returns_Empty_Collection_For_Empty_Resolver() { var resolver = new TypeParserResolver(); var parsers = resolver.GetParsers(); Assert.AreEqual(0, parsers.Length); }
public void Find_Returns_Null_If_Parser_Assigned_To_Different_Type() { var resolver = new TypeParserResolver(new DateTimeOffset_Iso8601_Parser()); var parser = resolver.Find <DateTime>(); Assert.IsNull(parser); }
public void Find_Returns_Assigned_Generic_Parser() { var resolver = new TypeParserResolver(new DateTime_Iso8601_Parser()); var parser = resolver.Find <DateTime>(); Assert.IsInstanceOfType(parser, typeof(DateTime_Iso8601_Parser)); }
public void Find_Returns_Null_If_No_Parser_Assigned() { var resolver = new TypeParserResolver(); var parser = resolver.Find <DateTime>(); Assert.IsNull(parser); }
private static JsonSerializerSettings CreateSettingsFromParserResolver(TypeParserResolver typeParserResolver) { return(new JsonSerializerSettings() { Converters = new JsonConverter[] { new ParserJsonConverter(typeParserResolver) }, DateParseHandling = DateParseHandling.None, }); }
public void Parsers_Ctor_Assigns_Parsers_During_Construction() { var resolver = new TypeParserResolver(new DateTime_Iso8601_Parser()); var parser = resolver.Find <DateTime>(); Assert.IsInstanceOfType(parser, typeof(DateTime_Iso8601_Parser)); }
/// <summary> /// See interface docs. /// </summary> /// <param name="modelType"></param> /// <param name="resolver"></param> /// <param name="jsonText"></param> /// <returns></returns> public object Deserialise(Type modelType, TypeParserResolver resolver, string jsonText) { return(JsonConvert.DeserializeObject( jsonText, modelType, JsonSerialiserSettingsCache.Fetch(resolver) )); }
public void ToTypeParserResolver_WithDefault_Returns_Default_When_Attribute_Is_Null() { var defaultResolver = new TypeParserResolver(new DateTime_Local_Parser(), new ByteArray_Mime64_Parser()); var resolver = UseParserAttribute.ToTypeParserResolver(null, defaultResolver); Assert.AreEqual(2, resolver.GetParsers().Length); Assert.IsInstanceOfType(resolver.DateTimeParser, typeof(DateTime_Local_Parser)); Assert.IsInstanceOfType(resolver.ByteArrayParser, typeof(ByteArray_Mime64_Parser)); }
public void BuildModel_QueryStringDictionary_Uses_TypeParserResolver() { var dictionary = new QueryStringDictionary("A=Abc"); var resolver = new TypeParserResolver(new String_Reverse_Parser()); var actual = _ModelBuilder.BuildModel(typeof(StringA), resolver, dictionary) as StringA; Assert.AreEqual("cbA", actual.A); }
public void GetAugmentedParsers_Returns_Parsers() { var parser = new DateTime_Local_Parser(); var resolver = new TypeParserResolver(parser); var parsers = resolver.GetAugmentedParsers(null); Assert.AreEqual(1, parsers.Length); Assert.AreSame(parser, parsers[0]); }
public void ToTypeParserResolver_WithDefault_Returns_Default_If_Invalid() { var attr = new UseParserAttribute(typeof(string)); var defaultResolver = new TypeParserResolver(new DateTime_Local_Parser(), new ByteArray_Mime64_Parser()); var resolver = UseParserAttribute.ToTypeParserResolver(attr, defaultResolver); Assert.AreEqual(2, resolver.GetParsers().Length); Assert.IsInstanceOfType(resolver.DateTimeParser, typeof(DateTime_Local_Parser)); Assert.IsInstanceOfType(resolver.ByteArrayParser, typeof(ByteArray_Mime64_Parser)); }
public void MethodParameter_Ctor_Fills_TypeParserResolver_Property_When_Default_Passed_And_Not_Overridden() { var resolver = new TypeParserResolver(new DateTime_Local_Parser()); var param = new MethodParameter(_ExampleMethod_optionalInt, resolver); Assert.IsNotNull(param.TypeParserResolver); var parsers = param.TypeParserResolver.GetParsers(); Assert.AreEqual(1, parsers.Length); Assert.IsInstanceOfType(parsers[0], typeof(DateTime_Local_Parser)); }
public void ToTypeParserResolver_WithDefault_Returns_Resolver_Filled_With_Parsers_From_Ctor() { var attr = new UseParserAttribute(typeof(DateTime_Iso8601_Parser), typeof(DateTimeOffset_Iso8601_Parser)); var defaultResolver = new TypeParserResolver(new DateTime_Local_Parser(), new ByteArray_Mime64_Parser()); var resolver = UseParserAttribute.ToTypeParserResolver(attr, defaultResolver); Assert.AreEqual(3, resolver.GetParsers().Length); Assert.IsInstanceOfType(resolver.DateTimeParser, typeof(DateTime_Iso8601_Parser)); Assert.IsInstanceOfType(resolver.DateTimeOffsetParser, typeof(DateTimeOffset_Iso8601_Parser)); Assert.IsInstanceOfType(resolver.ByteArrayParser, typeof(ByteArray_Mime64_Parser)); }
public void GetParsers_Returns_Collection_Of_All_Registered_Parsers() { var parser1 = new DateTime_Invariant_Parser(); var parser2 = new DateTimeOffset_Local_Parser(); var resolver = new TypeParserResolver(parser1, parser2); var parsers = resolver.GetParsers(); Assert.AreEqual(2, parsers.Length); Assert.IsTrue(parsers.Contains(parser1)); Assert.IsTrue(parsers.Contains(parser2)); }
public void DiscoverControllers_Uses_Default_TypeParserResolver() { _AllTypes.Add(typeof(MockController1)); var resolver = new TypeParserResolver(new DateTime_Local_Parser()); _ControllerFinder.DefaultTypeParserResolver = resolver; var controllerTypes = _ControllerFinder.DiscoverControllers().ToArray(); _AppDomainWrapper.Verify(r => r.GetAllTypes(), Times.Once()); Assert.AreEqual(resolver, controllerTypes[0].TypeParserResolver); }
public void MethodParameter_Ctor_Fills_TypeParserResolver_Property_When_Default_Passed_And_Overridden() { var resolver = new TypeParserResolver(new DateTime_Local_Parser(), new ByteArray_HexString_Parser()); var param = new MethodParameter(_ExampleMethod_byteArrayWithExpect, resolver); Assert.IsNotNull(param.TypeParserResolver); var parsers = param.TypeParserResolver.GetParsers(); Assert.AreEqual(2, parsers.Length); Assert.IsTrue(parsers.Any(r => r.GetType() == typeof(DateTime_Local_Parser))); Assert.IsTrue(parsers.Any(r => r.GetType() == typeof(ByteArray_Mime64_Parser))); }
public void GetHashCode_Is_Equal_For_All_Equal_Instances() { var resolver1 = new TypeParserResolver( new DateTime_Local_Parser(), new DateTimeOffset_Local_Parser() ); var resolver2 = new TypeParserResolver( new DateTimeOffset_Local_Parser(), new DateTime_Local_Parser() ); Assert.AreEqual(resolver1.GetHashCode(), resolver2.GetHashCode()); }
public void Parsers_Ctor_Sets_Direct_Access_Property(Type mockType, string parserPropertyName) { var mockParser = MockHelper.CreateMock(mockType); var mockTypeParser = (ITypeParser)mockParser.Object; var resolver = new TypeParserResolver(mockTypeParser); var parserProperty = resolver .GetType() .GetProperty(parserPropertyName); var parserValue = parserProperty.GetValue(resolver, null); Assert.AreSame(mockTypeParser, parserValue); }
public void BuildRouteParameters_Uses_TypeParserResolver_When_Parsing_Array_Elements() { var resolver = new TypeParserResolver(new ModelBuilder_Tests.String_Reverse_Parser()); var route = Route_Tests.CreateRoute(typeof(QueryStringController), nameof(QueryStringController.StringArrayParam), parserResolver: resolver); _RouteMapper.Initialise(new Route[] { route }); _Environment.RequestQueryString = "param=Abc"; _Environment.SetRequestPath(route.PathParts[0].Part); var parameters = _RouteMapper.BuildRouteParameters(route, _Environment.Environment); Assert.AreEqual(true, parameters.IsValid); Assert.AreEqual(1, parameters.Parameters.Length); Assert.AreEqual("cbA", ((string[])parameters.Parameters[0])[0]); }
public void Parser_ParseInt32_With_Resolver_And_Parser() { #if RUN_TIMING_TESTS var resolver = new TypeParserResolver(new Int32Parser()); var stopWatch = Stopwatch.StartNew(); for (var i = 0; i < Parser_ParseInt32_Iterations; ++i) { Parser.ParseInt32("32019", resolver); } stopWatch.Stop(); Assert.Inconclusive($"{Parser_ParseInt32_Iterations:N0} calls to {nameof(Parser)}.{nameof(Parser.ParseInt32)}(string, {nameof(TypeParserResolver)}) took {stopWatch.ElapsedMilliseconds} ms"); #endif }
public void Ctor_Uses_Default_TypeParserResolver_When_No_Overrides_Supplied() { var defaultResolver = new TypeParserResolver( new ByteArray_Mime64_Parser(), new DateTime_Local_Parser() ); var controllerType = new ControllerType(typeof(SampleController1), defaultResolver, null); var parsers = controllerType.TypeParserResolver.GetParsers(); Assert.AreEqual(2, parsers.Length); Assert.IsTrue(parsers.Any(r => r.GetType() == typeof(ByteArray_Mime64_Parser))); Assert.IsTrue(parsers.Any(r => r.GetType() == typeof(DateTime_Local_Parser))); }
/// <summary> /// Creates a new object. /// </summary> /// <param name="parameterInfo"></param> /// <param name="defaultParserResolver"></param> public MethodParameter(ParameterInfo parameterInfo, TypeParserResolver defaultParserResolver) { Name = parameterInfo.Name; NormalisedName = PathPart.Normalise(parameterInfo.Name); ParameterType = parameterInfo.ParameterType; ElementType = parameterInfo.ParameterType.IsArray ? parameterInfo.ParameterType.GetElementType() : null; IsArray = ElementType != null; IsOptional = parameterInfo.IsOptional; IsObject = !IsArray && ParameterType.IsClass && ParameterType != typeof(string); DefaultValue = parameterInfo.DefaultValue; TypeParserResolver = BuildTypeParserResolver(parameterInfo, defaultParserResolver); IsArrayPassedAsSingleValue = IsArray && ElementType == typeof(byte) && parameterInfo.GetCustomAttribute(typeof(ExpectArrayAttribute), inherit: false) == null; }
public void BuildModelFromJson_Uses_JsonSerialiser_To_Build_Model() { var jsonText = "{ \"Int\": 12345 }"; var resolver = new TypeParserResolver(); var deserialised = new object(); _JsonSerialiser .Setup(r => r.Deserialise(typeof(AllNativeTypes), resolver, jsonText)) .Returns(deserialised); var model = _ModelBuilder.BuildModelFromJson(typeof(AllNativeTypes), resolver, jsonText); _JsonSerialiser.Verify(r => r.Deserialise(typeof(AllNativeTypes), resolver, jsonText), Times.Once()); Assert.AreSame(deserialised, model); }
public void Ctor_Applies_Overrides_Default_TypeParserResolver() { var defaultResolver = new TypeParserResolver( new ByteArray_HexString_Parser(), new DateTime_Local_Parser() ); var controllerType = new ControllerType(typeof(SampleController2), defaultResolver, null); var parsers = controllerType.TypeParserResolver.GetParsers(); Assert.AreEqual(3, parsers.Length); Assert.IsTrue(parsers.Any(r => r.GetType() == typeof(ByteArray_HexString_Parser))); Assert.IsTrue(parsers.Any(r => r.GetType() == typeof(DateTime_Iso8601_Parser))); Assert.IsTrue(parsers.Any(r => r.GetType() == typeof(DateTimeOffset_Iso8601_Parser))); }
public void BuildRouteParameters_Passes_TypeParserResolver_To_Model_Builder_For_Query_String_Models() { var resolver = new TypeParserResolver(new ModelBuilder_Tests.String_Reverse_Parser()); var route = Route_Tests.CreateRoute(typeof(QueryStringModelController), nameof(QueryStringModelController.StringModelFunc), parserResolver: resolver); _RouteMapper.Initialise(new Route[] { route }); _Environment.SetRequestPath(route.PathParts[0].Part); _Environment.RequestQueryString = "StringValue=Ab"; var parameters = _RouteMapper.BuildRouteParameters(route, _Environment.Environment); Assert.IsTrue(parameters.IsValid); Assert.AreEqual(1, parameters.Parameters.Length); var model = parameters.Parameters[0] as StringModel; Assert.AreEqual("bA", model.StringValue); }
public void BuildRouteParameters_Uses_Full_TypeParserResolver_When_Building_Model_From_Form_Body() { var resolver = new TypeParserResolver(new ModelBuilder_Tests.String_Reverse_Parser()); var route = Route_Tests.CreateRoute(typeof(FormBodyModelController), nameof(FormBodyModelController.PostStringModel), parserResolver: resolver); _RouteMapper.Initialise(new Route[] { route }); _Environment.RequestMethod = "POST"; _Environment.SetRequestPath(route.PathParts[0].Part); _Environment.SetRequestBody("StringValue=Ab", contentType: "application/x-www-form-urlencoded"); var parameters = _RouteMapper.BuildRouteParameters(route, _Environment.Environment); Assert.IsTrue(parameters.IsValid); Assert.AreEqual(1, parameters.Parameters.Length); var model = parameters.Parameters[0] as StringModel; Assert.AreEqual("bA", model.StringValue); }
/// <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); }