public void Initialize()
{
mockMessageHandler = new Mock <IMessageHandler <TestMessage> >();
mockMessageHandler.Setup(p => p.HandleAsync(It.IsAny <TestMessage>(), It.IsAny <ILambdaContext>())).Returns(Task.CompletedTask);
mockServiceScope = new Mock <IServiceScope>();
mockServiceScopeFactory = new Mock <IServiceScopeFactory>();
mockServiceScopeFactory.Setup(p => p.CreateScope()).Returns(mockServiceScope.Object);
mockServiceProvider = new Mock <IServiceProvider>();
mockServiceProvider.Setup(p => p.GetService(typeof(IMessageHandler <TestMessage>)))
.Returns(mockMessageHandler.Object);
mockServiceProvider.Setup(p => p.GetService(typeof(IServiceScopeFactory)))
.Returns(mockServiceScopeFactory.Object);
mockServiceScope.Setup(p => p.ServiceProvider).Returns(mockServiceProvider.Object);
mockLoggerFactory = new Mock <ILoggerFactory>();
mockLoggerFactory.Setup(p => p.CreateLogger(It.IsAny <string>()))
.Returns(Mock.Of <ILogger>());
parallelExecutionOptions = new ParallelSqsExecutionOptions {
MaxDegreeOfParallelism = 4
};
}
public void MaxDegreeOfParallelism_Should_ProperlyPropagated_And_Limited_To_Set_Max()
{
var sqsEvent = new SQSEvent
{
Records = new List <SQSEvent.SQSMessage>
{
new SQSEvent.SQSMessage
{
Body = "{}"
},
new SQSEvent.SQSMessage
{
Body = "{}"
},
new SQSEvent.SQSMessage
{
Body = "{}"
},
new SQSEvent.SQSMessage
{
Body = "{}"
},
}
};
var cq = new ConcurrentQueue <Task>();
//We are checking if parallelism actually does what it's supposed to do. So we should have more then 2 concurrent processes running
parallelExecutionOptions = new ParallelSqsExecutionOptions {
MaxDegreeOfParallelism = 4
};
mockMessageHandler.Setup(p => p.HandleAsync(It.IsAny <TestMessage>(), It.IsAny <ILambdaContext>()))
.Returns(async() =>
{
var t = Task.Delay(1);
cq.Enqueue(t);
Console.WriteLine(cq.Count);
if (cq.Count > 2)
{
throw new Exception("Concurrent Tasks exceeded 2");
}
await t;
cq.TryDequeue(out t);
});
var sut = CreateSystemUnderTest();
Assert.ThrowsAsync <Exception>(() => sut.HandleAsync(sqsEvent, new TestLambdaContext()));
}
public async Task MaxDegreeOfParallelism_Should_ProperlyPropagated()
{
var sqsEvent = new SQSEvent
{
Records = new List <SQSEvent.SQSMessage>
{
new SQSEvent.SQSMessage
{
Body = "{}"
},
new SQSEvent.SQSMessage
{
Body = "{}"
},
new SQSEvent.SQSMessage
{
Body = "{}"
},
}
};
var cq = new ConcurrentQueue <Task>();
parallelExecutionOptions = new ParallelSqsExecutionOptions {
MaxDegreeOfParallelism = 2
};
mockMessageHandler.Setup(p => p.HandleAsync(It.IsAny <TestMessage>(), It.IsAny <ILambdaContext>()))
.Returns(async() =>
{
var t = Task.Delay(1);
cq.Enqueue(t);
if (cq.Count > 2)
{
throw new Exception("not good");
}
await t;
cq.TryDequeue(out t);
});
var sut = CreateSystemUnderTest();
await sut.HandleAsync(sqsEvent, new TestLambdaContext());
mockMessageHandler.VerifyAll();
mockMessageHandler.Verify(
handler => handler.HandleAsync(It.IsAny <TestMessage>(), It.IsAny <ILambdaContext>()),
Times.Exactly(sqsEvent.Records.Count));
}
