public void GetServiceRoutes_CalledWithServiceTypeUsingDtoDecoratedWithMultipleRoutes_ExpectAllRoutesFromDtoAreReturned()
{
ResolvedServiceRoutesFor <ServiceUsingDtoDecoratedWithMultipleRoutes>()
.ShouldBeEquivalentTo(
new Route("GET", "/request/multiple/1", InfoOf.Method <ServiceUsingDtoDecoratedWithMultipleRoutes>(x => x.ServiceMethod(null))),
new Route("GET", "/request/multiple/2", InfoOf.Method <ServiceUsingDtoDecoratedWithMultipleRoutes>(x => x.ServiceMethod(null))));
}
/// <summary>
/// Gets the DebugView internal property value of provided expression.
/// </summary>
/// <param name="expression">Expression to get DebugView.</param>
/// <returns>DebugView value.</returns>
public static string GetDebugView([NotNull] this Expression expression)
{
Code.NotNull(expression, nameof(expression));
if (_getDebugView == null)
{
var p = Expression.Parameter(typeof(Expression));
try
{
var l = Expression.Lambda <Func <Expression, string> >(
Expression.PropertyOrField(p, "DebugView"),
p);
_getDebugView = l.Compile();
}
catch (ArgumentException)
{
var l = Expression.Lambda <Func <Expression, string> >(
Expression.Call(p, InfoOf <Expression> .Method(e => e.ToString())),
p);
_getDebugView = l.Compile();
}
}
return(_getDebugView(expression));
}
public void FieldAttribute()
{
var rd = new AttributeReader();
var attrs = rd.GetAttributes <MapValueAttribute>(InfoOf.Member <AttributeReaderTests>(a => a.Field1));
Assert.AreEqual(0, attrs.Length);
}
public void GetServiceRoutes_CalledWithServiceTypeContainingNonAsyncServiceMethodsThatReturnTasks_EmptyServiceMethodsAreReturned()
{
ResolvedServiceRoutesFor <ServiceContainingNonAsyncServiceMethodsThatReturnTasks>()
.ShouldBeEquivalentTo(
new Route(
"GET",
"/requestone",
InfoOf.Method <ServiceContainingNonAsyncServiceMethodsThatReturnTasks>(
x => x.ServiceMethod(new RequestOne()))),
new Route(
"GET",
"/requesttwo",
InfoOf.Method <ServiceContainingNonAsyncServiceMethodsThatReturnTasks>(
x => x.ServiceMethod(new RequestTwo()))),
new Route(
"GET",
"/requestthree",
InfoOf.Method <ServiceContainingNonAsyncServiceMethodsThatReturnTasks>(
x => x.ServiceMethod(new RequestThree(), CancellationToken.None))),
new Route(
"GET",
"/requestfour",
InfoOf.Method <ServiceContainingNonAsyncServiceMethodsThatReturnTasks>(
x => x.ServiceMethod(new RequestFour(), CancellationToken.None))));
}
public void AttributeTest4()
{
var attrs = MappingSchema.Default.GetAttributes<MapValueAttribute>(
InfoOf.Field<AttrTest>(a => a.Field1));
Assert.That(attrs.Length, Is.EqualTo(3));
}
public void Build_Called_ExpectReturnedDelegateCallsServiceMethodOnFactoryCreatedServiceWithBoundModel(
NancyModule module, object request, Request message, Response response)
{
var requestMessageBinderDelegate = MockRepository.GenerateStub <Func <object, object> >();
requestMessageBinderDelegate.Stub(x => x(Arg <object> .Is.Same(request))).Return(message);
var requestMessageBinder = MockRepository.GenerateStub <IServiceRequestBinder>();
requestMessageBinder.Stub(x => x.CreateBindingDelegate(
Arg <Type> .Is.Equal(typeof(Request)),
Arg <ServiceRequestBinderContext> .Matches(ctx => ReferenceEquals(ctx.NancyModule, module))))
.Return(requestMessageBinderDelegate);
var service = MockRepository.GenerateStub <StubService>();
service.Stub(x => x.ServiceMethod(Arg <Request> .Is.Same(message))).Return(response);
var serviceFactory = MockRepository.GenerateStub <Func <Type, object> >();
serviceFactory.Stub(x => x(Arg <Type> .Is.Equal(service.GetType()))).Return(service);
var lambda = (Func <object, object>) new RouteDispatchBuilder()
.WithServiceFactory(serviceFactory)
.WithServiceMethodInvocation(new SyncServiceMethodInvocation())
.WithRequestMessageBinder(requestMessageBinder)
.WithModule(module)
.WithServiceType(service.GetType())
.WithMethod(InfoOf.Method <StubService>(x => x.ServiceMethod(null)))
.Build();
lambda(request).Should().BeSameAs(response);
}
public void GetServiceRoutes_CalledWithServiceTypeInheritingFromAnother_ExpectServiceMethodsFromBaseAndDerivedTypeAreReturned()
{
ResolvedServiceRoutesFor <ServiceInheritingFromAnotherType>()
.ShouldBeEquivalentTo(
new Route("GET", "/requesttwo", InfoOf.Method <ServiceInheritingFromAnotherType>(x => x.ServiceMethod(new RequestTwo()))),
new Route("GET", "/requestthree", InfoOf.Method <ServiceInheritingFromAnotherType>(x => x.MethodFromDerivedService(new RequestThree()))));
}
private bool BuildListMapper()
{
var fromListType = _fromExpression.Type;
var toListType = _localObject.Type;
if (!toListType.IsSubClass(typeof(IEnumerable <>)) || !fromListType.IsSubClass(typeof(IEnumerable <>)))
{
return(false);
}
var clearMethodInfo = toListType.GetMethod("Clear");
if (clearMethodInfo != null)
{
_expressions.Add(Call(_localObject, clearMethodInfo));
}
var fromItemType = fromListType.GetItemType();
var toItemType = toListType.GetItemType();
var addRangeMethodInfo = toListType.GetMethod("AddRange");
if (addRangeMethodInfo != null)
{
var selectExpr = Select(_builder, _fromExpression, fromItemType, toItemType);
_expressions.Add(Call(_localObject, addRangeMethodInfo, selectExpr));
}
else if (toListType.IsGenericType && !toListType.IsGenericTypeDefinition)
{
if (toListType.IsSubClass(typeof(ICollection <>)))
{
var selectExpr = Select(
_builder,
_fromExpression, fromItemType,
toItemType);
_expressions.Add(
Call(
InfoOf.Method(() => ((ICollection <int>)null).AddRange((IEnumerable <int>)null))
.GetGenericMethodDefinition()
.MakeGenericMethod(toItemType),
_localObject,
selectExpr));
}
else
{
_expressions.Add(
Assign(
_localObject,
_builder.ConvertCollection(_fromExpression, toListType)));
}
}
else
{
throw new NotImplementedException();
}
return(true);
}
private static MethodInfo CreateSpecialisedDelegateCreator(MethodInfo serviceMethod)
{
MethodInfo genericDelegateCreator =
InfoOf.Method <AsyncVoidServiceMethodInvocation>(x => CreateInvocationDelegate <object>(null, null))
.GetGenericMethodDefinition();
return(genericDelegateCreator.MakeGenericMethod(GetTaskResultTypeFromMethodReturnType(serviceMethod)));
}
public void CreateInvocationDelegate_CalledWithNullContext_ExpectArgumentNullExceptionWithCorrectParamName()
{
new SyncServiceMethodInvocation().Invoking(
x => x.CreateInvocationDelegate(
InfoOf.Method <StubService>(svc => svc.ServiceMethodWithResponse(null)),
null))
.ShouldThrow <ArgumentNullException>().And.ParamName.Should().Be("context");
}
public void GetServiceRoutes_CalledWithServiceTypeContainingMixtureOfPublicAndNonPublicServiceMethods_ExpectOnlyPublicMethodsAreReturned()
{
ResolvedServiceRoutesFor <ServiceContainingMixtureOfPublicAndNonPublicMethods>()
.ShouldBeEquivalentTo(
new Route(
"GET",
"/requesttwo",
InfoOf.Method <ServiceContainingMixtureOfPublicAndNonPublicMethods>(x => x.ServiceMethod(null))));
}
public void CreateInvocationDelegate_CalledWithAsyncDecoratedMethodWithCancellationToken_ExpectReturnedDelegateReturnsDefaultResponse(
StubService service, object request, Request dto, Response defaultResponse)
{
var lambda = (Func <object, CancellationToken, Task <object> >) new AsyncVoidServiceMethodInvocation().CreateInvocationDelegate(
InfoOf.Method <StubService>(svc => svc.AsyncDecoratedMethodWithCancellationToken(null, CancellationToken.None)),
Stub.InvocationContextFor(service, request, dto, defaultResponse));
lambda(request, CancellationToken.None).Result.Should().BeSameAs(defaultResponse);
}
public void PropertyAttribute()
{
var rd = new AttributeReader();
var attrs = rd.GetAttributes <MapValueAttribute>(InfoOf.Member <AttributeReaderTests>(a => a.Property1));
Assert.NotNull(attrs);
Assert.AreEqual(1, attrs.Length);
Assert.AreEqual("TestName", attrs[0].Value);
}
public void FieldAttribute()
{
var rd = new XmlAttributeReader(new MemoryStream(Encoding.UTF8.GetBytes(Data)));
var attrs = rd.GetAttributes <ColumnAttribute>(InfoOf.Member <XmlReaderTests>(a => a.Field1));
Assert.NotNull(attrs);
Assert.AreEqual(1, attrs.Length);
Assert.AreEqual("TestName", attrs[0].Name);
}
public void AttributeTest5()
{
var attrs = MappingSchema.Default.GetAttributes<MapValueAttribute>(
InfoOf.Field<AttrTest>(a => a.Field1),
a => a.Configuration);
Assert.That(attrs.Length, Is.EqualTo(1));
Assert.That(attrs[0].Value, Is.EqualTo(1));
}
public void CreateInvocationDelegate_CalledWithServiceMethodThatReturnsNoResponse_ExpectReturnedDelegateReturnsDefaultResponse(
StubService service, object request, Request dto, Response defaultResponse)
{
var lambda = (Func <object, object>) new SyncServiceMethodInvocation().CreateInvocationDelegate(
InfoOf.Method <StubService>(x => x.ServiceMethodWithNoResponse(null)),
Stub.InvocationContextFor(service, request, dto, defaultResponse));
lambda(request).Should().BeSameAs(defaultResponse);
}
public void GetServiceRoutes_CalledWithServiceTypeContainingServiceMethodWithNoReturnValue_ExpectServiceMethodIsStillReturned()
{
ResolvedServiceRoutesFor <ServiceContainingServiceMethodWithNoReturnValue>()
.ShouldBeEquivalentTo(
new Route(
"GET",
"/requestone",
InfoOf.Method <ServiceContainingServiceMethodWithNoReturnValue>(x => x.ServiceMethod(null))));
}
public void CreateInvocationDelegate_CalledWithRequestOfIncompatibleType_ExpectExceptionRatherThanPassingNullRequestToService(
object incompatibleRequest)
{
var service = MockRepository.GenerateStrictMock <StubService>();
var lambda = (Func <object, object>) new SyncServiceMethodInvocation().CreateInvocationDelegate(
InfoOf.Method <StubService>(x => x.ServiceMethodWithNoResponse(null)),
Stub.InvocationContextFor(service, incompatibleRequest, incompatibleRequest));
lambda.Invoking(x => x(incompatibleRequest)).ShouldThrow <InvalidCastException>();
}
//private Type _actualLocalObjectType;
public Expression GetExpression()
{
_locals.Add(_localObject);
if (!BuildArrayMapper())
{
var newLocalObjectExpr = GetNewExpression(_toExpression.Type);
//_actualLocalObjectType = newLocalObjectExpr.Type;
_expressions.Add(Assign(
_localObject,
Condition(
Equal(
_toExpression,
Constant(
_builder._mapperBuilder.MappingSchema.GetDefaultValue(_toExpression.Type),
_toExpression.Type)),
Convert(newLocalObjectExpr, _toExpression.Type),
_toExpression)));
if (_cacheMapper)
{
_expressions.Add(
Call(
InfoOf.Method(() => Add(null, null, null)),
_builder._data.LocalDic,
_fromExpression,
_localObject));
}
if (!BuildListMapper())
{
GetObjectExpression();
}
}
_expressions.Add(_localObject);
var expr = Block(_locals, _expressions) as Expression;
if (_cacheMapper)
{
expr = Expression.Convert(
Coalesce(
Call(
InfoOf <IDictionary <object, object> > .Method(_ => GetValue(null, null)),
_builder._data.LocalDic,
_fromExpression),
expr),
_toExpression.Type);
}
return(expr);
}
public void CreateInvocationDelegate_CalledWithServiceMethodThatReturnsNoResponse_ExpectServiceMethodIsStillCalled(
object request, Request dto, Response defaultResponse)
{
var service = MockRepository.GenerateMock <StubService>();
var lambda = (Func <object, object>) new SyncServiceMethodInvocation().CreateInvocationDelegate(
InfoOf.Method <StubService>(x => x.ServiceMethodWithNoResponse(null)),
Stub.InvocationContextFor(service, request, dto, defaultResponse));
lambda(request);
service.AssertWasCalled(x => x.ServiceMethodWithNoResponse(Arg <Request> .Is.Same(dto)), x => x.Repeat.Once());
}
public void GetServiceRoutes_CalledWithServiceTypeContainingMultipleRouteVerbs_ExpectServiceRoutesForEachVerbAreReturned()
{
const string routePath = "/requestfive";
var serviceMethod = InfoOf.Method <ServiceContainingMultipleRouteVerbs>(x => x.ServiceMethod(new RequestFive()));
ResolvedServiceRoutesFor <ServiceContainingMultipleRouteVerbs>()
.ShouldBeEquivalentTo(
new Route("ABC", routePath, serviceMethod),
new Route("DEF", routePath, serviceMethod),
new Route("GHI", routePath, serviceMethod));
}
public void AttributeTest1()
{
var ms = new MappingSchema("2");
var attrs = ms.GetAttributes<MapValueAttribute>(
InfoOf.Field<AttrTestImpl>(a => a.Field1),
a => a.Configuration);
Assert.That(attrs.Length, Is.EqualTo(2));
Assert.That(attrs[0].Value, Is.EqualTo(2));
Assert.That(attrs[1].Value, Is.EqualTo(1));
}
public void CreateInvocationDelegate_CalledWithServiceMethodThatReturnsResponse_ExpectReturnedDelegateReturnsSameResponseAsServiceMethod(
object request, Request dto, Response response)
{
var service = MockRepository.GenerateStub <StubService>();
service.Stub(x => x.ServiceMethodWithResponse(Arg <Request> .Is.Same(dto))).Return(response);
var lambda = (Func <object, object>) new SyncServiceMethodInvocation().CreateInvocationDelegate(
InfoOf.Method <StubService>(x => x.ServiceMethodWithResponse(null)), Stub.InvocationContextFor(service, request, dto));
lambda(request).Should().BeSameAs(response);
}
public void PropertyAttribute()
{
var rd = new XmlAttributeReader(new MemoryStream(Encoding.UTF8.GetBytes(Data)));
MappingSchema.Default.AddMetadataReader(rd);
var attrs = MappingSchema.Default.GetAttributes <MapValueAttribute>(InfoOf.Member <XmlReaderTests>(a => a.Property1));
Assert.NotNull(attrs);
Assert.AreEqual(1, attrs.Length);
Assert.AreEqual("TestName", attrs[0].Value);
}
public void CreateInvocationDelegate_CalledWithNonAsyncDecoratedMethodWithSingleParameter_ExpectReturnedDelegateReturnsResponse(
object request, Request dto, Response response)
{
var service = MockRepository.GenerateStub <StubService>();
service.Stub(x => x.NonAsyncDecoratedMethodWithTaskOfTResponse(Arg <Request> .Is.Same(dto))).Return(Task.FromResult(response));
var lambda = (Func <object, CancellationToken, Task <object> >) new AsyncTaskOfTServiceMethodInvocation().CreateInvocationDelegate(
InfoOf.Method <StubService>(svc => svc.NonAsyncDecoratedMethodWithTaskOfTResponse(null)),
Stub.InvocationContextFor(service, request, dto));
lambda(request, CancellationToken.None).Result.Should().BeSameAs(response);
}
public void GetServiceRoutes_CalledWithServiceTypeContainingMixtureOfServiceAndNonServiceMethods_ExpectOnlyServiceMethodsAreReturned()
{
ResolvedServiceRoutesFor <ServiceContainingMixtureOfServiceAndNonServiceMethods>()
.ShouldBeEquivalentTo(
new Route(
"GET",
"/requesttwo",
InfoOf.Method <ServiceContainingMixtureOfServiceAndNonServiceMethods>(x => x.ServiceMethod(new RequestTwo()))),
new Route(
"GET",
"/requestfour",
InfoOf.Method <ServiceContainingMixtureOfServiceAndNonServiceMethods>(x => x.ServiceMethod(new RequestFour()))));
}
public void GetServiceRoutes_CalledWithServiceTypeContainingImplementationsOfInterfaceServiceMethods_ExpectInterfaceAndDeclaredServiceMethodsAreReturned()
{
ResolvedServiceRoutesFor <ServiceContainingImplementationsOfInterfaceServiceMethods>()
.ShouldBeEquivalentTo(
new Route(
"GET",
"/requestone",
InfoOf.Method <ServiceContainingImplementationsOfInterfaceServiceMethods>(x => x.ServiceMethod(new RequestOne()))),
new Route(
"GET",
"/requesttwo",
InfoOf.Method <ServiceContainingImplementationsOfInterfaceServiceMethods>(x => x.ServiceMethod(new RequestTwo()))));
}
public void Build_CalledWhenDefaultResponseNotSetForServiceMethodNotReturningResponse_ExpectReturnedDelegateReturnsHttpNoContentResponse(
NancyModule module, object requestParameters, Request request)
{
var lambda = (Func <object, object>) new RouteDispatchBuilder()
.WithServiceFactory(x => new StubService())
.WithServiceMethodInvocation(new SyncServiceMethodInvocation())
.WithRequestMessageBinder(StubRequestMessageBinderToReturn(request))
.WithModule(module)
.WithServiceType(typeof(StubService))
.WithMethod(InfoOf.Method <StubService>(x => x.ServiceMethodNotReturningResponse(null)))
.Build();
lambda(requestParameters).Should().Be(HttpStatusCode.NoContent);
}
public void AttributeTest6()
{
var ms = new MappingSchema("2",
new MappingSchema("3")
{
MetadataReader = new XmlAttributeReader(new MemoryStream(Encoding.UTF8.GetBytes(Data)))
});
var attrs = ms.GetAttributes <MapValueAttribute>(
InfoOf.Field <AttrTest>(a => a.Field1),
a => a.Configuration);
Assert.That(attrs !.Length, Is.EqualTo(4));
Assert.That(attrs ![0].Value, Is.EqualTo(2));
public void CreateInvocationDelegate_CalledWithNonAsyncDecoratedMethodWithSingleParameter_ExpectServiceMethodCalledAndAwaitedBeforeResponse(
object request, Request dto, Response defaultResponse)
{
var wasCalledWithCorrectArguments = new ManualResetEvent(false);
var service = CreateStrictMockServiceForDelayedEvent(
x => x.NonAsyncDecoratedMethodWithTaskResponse(Arg <Request> .Is.Same(dto)),
wasCalledWithCorrectArguments);
var lambda = (Func <object, CancellationToken, Task <object> >) new AsyncTaskServiceMethodInvocation().CreateInvocationDelegate(
InfoOf.Method <StubService>(svc => svc.NonAsyncDecoratedMethodWithTaskResponse(null)),
Stub.InvocationContextFor(service, request, dto, defaultResponse));
lambda(request, CancellationToken.None).Wait();
wasCalledWithCorrectArguments.WaitOne(TimeSpan.FromTicks(1)).Should().BeTrue();
}
