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