public async Task RunCreatesLambdaAndCallsHandle(
TestLambdaMessage expectedResponse,
TestLambdaMessage request,
ServiceCollection collection,
JsonSerializer serializer,
ILogger logger,
[Substitute] TestLambda lambda,
[Substitute] LambdaScope scope,
[Substitute] ILambdaContext context
)
{
lambda.Handle(Any <TestLambdaMessage>(), Any <CancellationToken>()).Returns(expectedResponse);
collection.AddSingleton <ISerializer>(serializer);
collection.AddSingleton(lambda);
collection.AddSingleton(scope);
using var inputStream = await CreateStreamForRequest(request);
var provider = collection.BuildServiceProvider();
await using var host = new TestLambdaHost(lambdaHost =>
{
lambdaHost.ServiceProvider = provider;
lambdaHost.Logger = logger;
});
var cancellationToken = new CancellationToken(false);
var responseStream = await host.Run(inputStream, context, cancellationToken);
var response = await SystemTextJsonSerializer.DeserializeAsync <TestLambdaMessage>(responseStream);
response.Should().NotBeNull();
response !.Id.Should().Be(expectedResponse.Id);
await lambda.Received().Handle(Is <TestLambdaMessage>(req => req.Id == request.Id), Is(cancellationToken));
}
public async Task RunRunsInitializationServices(
TestLambdaMessage expectedResponse,
TestLambdaMessage request,
ServiceCollection collection,
JsonSerializer serializer,
ILogger logger,
[Substitute] ILambdaInitializationService initializationService,
[Substitute] TestLambda lambda,
[Substitute] LambdaScope scope,
[Substitute] ILambdaContext context
)
{
lambda.Handle(Any <TestLambdaMessage>(), Any <CancellationToken>()).Returns(expectedResponse);
collection.AddSingleton <ISerializer>(serializer);
collection.AddSingleton(initializationService);
collection.AddSingleton(lambda);
collection.AddSingleton(scope);
using var inputStream = await CreateStreamForRequest(request);
var provider = collection.BuildServiceProvider();
await using var host = new TestLambdaHost(lambdaHost =>
{
lambdaHost.ServiceProvider = provider;
lambdaHost.RunInitializationServices = true;
lambdaHost.Logger = logger;
});
var cancellationToken = new CancellationToken(false);
await host.Run(inputStream, context, cancellationToken);
await initializationService.Received().Initialize(Is(cancellationToken));
}
public async Task DisposeAsyncIsPreferred(
string expectedResponse,
TestLambdaMessage request,
ServiceCollection collection,
ISerializer serializer,
ILogger logger,
[Substitute] ILambdaInitializationService initializationService,
[Substitute] MultiDisposableLambda lambda,
[Substitute] LambdaScope scope,
[Substitute] ILambdaContext context
)
{
collection.AddSingleton(serializer);
collection.AddSingleton(initializationService);
collection.AddSingleton <TestLambda>(lambda);
collection.AddSingleton(scope);
using var inputStream = await CreateStreamForRequest(request);
var provider = collection.BuildServiceProvider();
await using (var host = new TestLambdaHost(lambdaHost =>
{
lambdaHost.ServiceProvider = provider;
lambdaHost.RunInitializationServices = false;
lambdaHost.Logger = logger;
}))
{
await host.Run(inputStream, context);
}
await lambda.Received().DisposeAsync();
lambda.DidNotReceive().Dispose();
}
public async Task RunDisposesInitializationServicesAsync(
TestLambdaMessage expectedResponse,
TestLambdaMessage request,
ServiceCollection collection,
ISerializer serializer,
ILogger logger,
[Substitute] TestLambda lambda,
[Substitute] LambdaScope scope,
[Substitute] ILambdaContext context
)
{
var initializationService = Substitute.For <ILambdaInitializationService, IAsyncDisposable>();
lambda.Handle(Any <TestLambdaMessage>()).Returns(expectedResponse);
collection.AddSingleton(serializer);
collection.AddSingleton(initializationService);
collection.AddSingleton(lambda);
collection.AddSingleton(scope);
using var inputStream = await CreateStreamForRequest(request);
var provider = collection.BuildServiceProvider();
await using var host = new TestLambdaHost(lambdaHost =>
{
lambdaHost.ServiceProvider = provider;
lambdaHost.RunInitializationServices = true;
lambdaHost.Logger = logger;
});
await host.Run(inputStream, context);
await initializationService.As <IAsyncDisposable>().Received().DisposeAsync();
}
protected override Expression ApplyFilter(Expression source, FilterExpression filter)
{
using LambdaScope lambdaScope = _lambdaScopeFactory.CreateScope(_elementType);
var builder = new MongoWhereClauseBuilder(source, lambdaScope, _extensionType, _nameFactory);
return(builder.ApplyWhere(filter));
}
public async Task ShouldLogExceptions(
string expectedResponse,
TestLambdaMessage request,
ServiceCollection collection,
ISerializer serializer,
TestLambda lambda,
ILogger logger,
Exception exception,
[Substitute] Action <object> suppressor,
[Substitute] ILambdaInitializationService initializationService,
[Substitute] LambdaScope scope,
[Substitute] ILambdaContext context
)
{
collection.AddSingleton(serializer);
collection.AddSingleton(initializationService);
collection.AddSingleton(lambda);
collection.AddSingleton(scope);
lambda.HandleAction = () => throw exception;
using var inputStream = await CreateStreamForRequest(request);
var provider = collection.BuildServiceProvider();
await using var host = new TestLambdaHost(lambdaHost =>
{
lambdaHost.ServiceProvider = provider;
lambdaHost.RunInitializationServices = false;
lambdaHost.SuppressFinalize = suppressor;
lambdaHost.Logger = logger;
});
Func <Task> func = () => host.Run(inputStream, context);
await func.Should().ThrowAsync <Exception>();
logger.ReceivedCalls().Should().Contain(call => (LogLevel)call.GetArguments()[0] == LogLevel.Critical);
}
public async Task FinalizationIsSuppressed(
string expectedResponse,
TestLambdaMessage request,
ServiceCollection collection,
ISerializer serializer,
ILogger logger,
[Substitute] Action <object> suppressor,
[Substitute] ILambdaInitializationService initializationService,
[Substitute] MultiDisposableLambda lambda,
[Substitute] LambdaScope scope,
[Substitute] ILambdaContext context
)
{
collection.AddSingleton(serializer);
collection.AddSingleton(initializationService);
collection.AddSingleton <TestLambda>(lambda);
collection.AddSingleton(scope);
TestLambdaHost host;
using var inputStream = await CreateStreamForRequest(request);
var provider = collection.BuildServiceProvider();
await using (host = new TestLambdaHost(lambdaHost =>
{
lambdaHost.ServiceProvider = provider;
lambdaHost.RunInitializationServices = false;
lambdaHost.SuppressFinalize = suppressor;
lambdaHost.Logger = logger;
}))
{
await host.Run(inputStream, context);
}
suppressor.Received()(Is(host));
}
private static void ParseLamdaDefinitionArgList(LambdaScope scope, List<ParameterExpression> parameters)
{
ParameterExpression paramArgList = scope.RegisterParameter(typeof(object[]), csArgListP);
ParameterExpression varArgList = scope.RegisterVariable(typeof(LuaResult), csArgList);
parameters.Add(paramArgList);
scope.AddExpression(Expression.Assign(varArgList, Expression.New(Lua.ResultConstructorInfoArgN, paramArgList)));
}
private static Expression ParseLamdaDefinition(Scope parent, LuaLexer code, string sName, bool lSelfParameter, Action<Type> functionTypeCollected)
{
List<ParameterExpression> parameters = new List<ParameterExpression>();
LambdaScope scope = new LambdaScope(parent);
// Lese die Parameterliste ein
FetchToken(LuaToken.BracketOpen, code);
if (lSelfParameter)
parameters.Add(scope.RegisterParameter(typeof(object), "self"));
if (code.Current.Typ == LuaToken.Identifier || code.Current.Typ == LuaToken.DotDotDot)
{
if (code.Current.Typ == LuaToken.DotDotDot)
{
code.Next();
ParseLamdaDefinitionArgList(scope, parameters);
}
else
{
Token tName;
Type typeArgument;
ParseIdentifierAndType(scope, code, out tName, out typeArgument);
parameters.Add(scope.RegisterParameter(typeArgument, tName.Value));
while (code.Current.Typ == LuaToken.Comma)
{
code.Next();
if (code.Current.Typ == LuaToken.DotDotDot)
{
code.Next();
ParseLamdaDefinitionArgList(scope, parameters); // last argument
break;
}
else
{
ParseIdentifierAndType(scope, code, out tName, out typeArgument);
parameters.Add(scope.RegisterParameter(typeArgument, tName.Value));
}
}
}
}
FetchToken(LuaToken.BracketClose, code);
// Is there a specific result
if (code.Current.Typ == LuaToken.Colon)
{
var t = code.Current;
code.Next();
Type typeResult = ParseType(scope, code, true);
scope.ResetReturnLabel(typeResult, null);
}
else
scope.ResetReturnLabel(typeof(LuaResult), Expression.Property(null, Lua.ResultEmptyPropertyInfo));
// register the delegate
if (functionTypeCollected != null)
{
functionTypeCollected(
Expression.GetFuncType(
(from p in parameters select p.Type).Concat(new Type[] { scope.ReturnType }).ToArray()
)
);
}
// Lese den Code-Block
ParseBlock(scope, code);
FetchToken(LuaToken.KwEnd, code);
return Expression.Lambda(
scope.ExpressionBlock,
(parent.EmitDebug & LuaDebugLevel.RegisterMethods) == LuaDebugLevel.RegisterMethods ? Lua.RegisterUniqueName(sName) : sName,
parameters);
}
public MongoDbWhereClauseBuilder(Expression source, LambdaScope lambdaScope, Type extensionType)
: base(source, lambdaScope, extensionType)
{
}
public MongoWhereClauseBuilder(Expression source, LambdaScope lambdaScope, Type extensionType, LambdaParameterNameFactory nameFactory)
: base(source, lambdaScope, extensionType, nameFactory)
{
}
