public async Task Should_Store_Registered_Query_Handler_In_Container()
{
var queryHandler = new TestQueryHandler(_testOutputHelper);
var container = new Container();
container.Register <IQueryAsyncHandler <QuerySomething, string> >(() => queryHandler, Lifestyle.Singleton);
var containerAdapter = new SimpleInjectorContainerAdapter(container);
var resolver = new ContainerQueryAsyncHandlerResolver(containerAdapter); // Async handler resolver
const string data = nameof(Should_Store_Registered_Query_Handler_In_Container);
QueryHandlerDelegate <string> queryHandlerDelegate = resolver.ResolveQueryHandler <QuerySomething, string>();
Assert.NotNull(queryHandlerDelegate);
var registeredQueryHandler = container.GetInstance <IQueryAsyncHandler <QuerySomething, string> >();
var query = new QuerySomething(data);
var result1 = await queryHandlerDelegate.Invoke(query);
var result2 = await registeredQueryHandler.HandleAsync(query);
Assert.Equal(data, result1);
Assert.Equal(data, result2);
Assert.Equal(result1, result2);
}
public Task Should_Throw_When_Cancelled()
{
return(Assert.ThrowsAnyAsync <OperationCanceledException>(async() =>
{
var queryHandler = new TestQueryHandler(_testOutputHelper);
var registration = new QueryHandlerRegistration();
registration.Register(() => (IQueryAsyncHandler <QuerySomethingWithDelay, string>)queryHandler);
var cts = new CancellationTokenSource();
var dispatcher = new QueryDispatcher(registration);
Task task = dispatcher.DispatchAsync <QuerySomethingWithDelay, string>(new QuerySomethingWithDelay("This will be cancelled", 3000), cts.Token);
cts.Cancel();
try
{
await task;
}
catch (Exception ex)
{
_testOutputHelper.WriteLine(ex.ToString());
throw;
}
}));
}
public async Task Should_Invoke_Registered_Query_Handler_In_Container_When_Dispatched_Multiple_Times()
{
var queryHandler = new TestQueryHandler(_testOutputHelper);
var container = new Container();
container.Register <IQueryAsyncHandler <QuerySomething, string> >(() => queryHandler, Lifestyle.Singleton);
container.Register <IQueryAsyncHandler <QuerySomethingWithNonReferenceTypeResult, int> >(() => queryHandler, Lifestyle.Singleton);
var containerAdapter = new SimpleInjectorContainerAdapter(container);
var resolver = new ContainerQueryAsyncHandlerResolver(containerAdapter);
const string data1 = "Test message 1.";
const string data2 = "Test message 2.";
const int data3 = 1;
var dispatcher = new QueryDispatcher(resolver);
var result1 = dispatcher.DispatchAsync <QuerySomething, string>(new QuerySomething(data1));
var result2 = dispatcher.DispatchAsync <QuerySomething, string>(new QuerySomething(data2));
var result3 = dispatcher.DispatchAsync <QuerySomethingWithNonReferenceTypeResult, int>(new QuerySomethingWithNonReferenceTypeResult(data3));
await Task.WhenAll(result1, result2, result3);
Assert.Equal(data1, await result1);
Assert.Equal(data2, await result2);
Assert.Equal(data3, await result3);
}
public async Task ShouldResolveQueryHandlersFromContainer()
{
var queryHandler = new TestQueryHandler(_testOutputHelper);
var container = new Container();
container.Register <IQueryAsyncHandler <QuerySomething, string> >(() => queryHandler, Lifestyle.Singleton);
var containerAdapter = new SimpleInjectorContainerAdapter(container);
var resolver = new ContainerQueryAsyncHandlerResolver(containerAdapter); // Async handler resolver
const string data = nameof(ShouldResolveQueryHandlersFromContainer);
QueryHandlerDelegate <string> queryHandlerDelegate = resolver.ResolveQueryHandler <QuerySomething, string>();
queryHandlerDelegate.Should().NotBeNull();
var registeredQueryHandler = container.GetInstance <IQueryAsyncHandler <QuerySomething, string> >();
var query = new QuerySomething(data);
var result1 = await queryHandlerDelegate.Invoke(query);
var result2 = await registeredQueryHandler.HandleAsync(query);
result1.Should().Be(data);
result2.Should().Be(data);
result1.Should().Be(result1);
}
public async Task QueryAsyncCorrectlyUsesQueryHandler()
{
var configuration = new DomainConfiguration();
var modelHandler = new TestModelHandler();
var modelMapper = new TestModelMapper();
var queryHandler = new TestQueryHandler();
configuration.SetHookPoint(typeof(IModelHandler), modelHandler);
configuration.SetHookPoint(typeof(IModelMapper), modelMapper);
configuration.SetHookPoint(typeof(IQueryHandler), queryHandler);
configuration.EnsureCommitted();
var context = new DomainContext(configuration);
modelHandler.DomainContext = context;
modelHandler.Model = new EdmModel();
queryHandler.DomainContext = context;
queryHandler.Results = new string[] { "Test" };
var queryRequest = new QueryRequest(
Domain.Source <string>(context, "Test"), true);
var queryResult = await Domain.QueryAsync(context, queryRequest);
Assert.True(queryResult.Results.Cast <string>()
.SequenceEqual(new string[] { "Test" }));
}
public void ShouldCheckForCorrectQueryType()
{
var queryHandler = new TestQueryHandler(_testOutputHelper);
var registration = new QueryHandlerRegistration();
registration.Register(() => (IQueryHandler <QuerySomethingWithDelay, string>)queryHandler);
QueryHandlerDelegate <string> queryHandlerDelegate = registration.ResolveQueryHandler <QuerySomethingWithDelay, string>();
queryHandlerDelegate.Should().NotBeNull();
const string data = nameof(ShouldCheckForCorrectQueryType);
Func <Task> action = async() =>
{
try
{
await queryHandlerDelegate.Invoke(new QuerySomething(data));
}
catch (Exception ex)
{
_testOutputHelper.WriteLine(ex.ToString());
throw;
}
};
action.Should().Throw <ArgumentException>();
}
public async Task ShouldInvokeRegisteredQueryHandlerInContainerWhenDispatchedMultipleTimes()
{
var queryHandler = new TestQueryHandler(_outputHelper);
var container = new Container();
container.Register <IQueryAsyncHandler <QuerySomething, string> >(() => queryHandler, Lifestyle.Singleton);
container.Register <IQueryAsyncHandler <QuerySomethingWithNonReferenceTypeResult, int> >(() => queryHandler, Lifestyle.Singleton);
var containerAdapter = new SimpleInjectorContainerAdapter(container);
var resolver = new ContainerQueryAsyncHandlerResolver(containerAdapter);
const string data1 = "Test message 1.";
const string data2 = "Test message 2.";
const int data3 = 1;
var dispatcher = new QueryDispatcher(resolver);
var result1 = dispatcher.DispatchAsync <QuerySomething, string>(new QuerySomething(data1));
var result2 = dispatcher.DispatchAsync <QuerySomething, string>(new QuerySomething(data2));
var result3 = dispatcher.DispatchAsync <QuerySomethingWithNonReferenceTypeResult, int>(new QuerySomethingWithNonReferenceTypeResult(data3));
await Task.WhenAll(result1, result2, result3);
(await result1).Should().Be(data1);
(await result2).Should().Be(data2);
(await result3).Should().Be(data3);
}
public Task Should_Check_For_Correct_Query_Type()
{
return(Assert.ThrowsAnyAsync <ArgumentException>(async() =>
{
var queryHandler = new TestQueryHandler(_testOutputHelper);
var registration = new QueryHandlerRegistration();
registration.Register(() => (IQueryHandler <QuerySomethingWithDelay, string>)queryHandler);
QueryHandlerDelegate <string> queryHandlerDelegate = registration.ResolveQueryHandler <QuerySomethingWithDelay, string>();
Assert.NotNull(queryHandlerDelegate);
const string data = nameof(Should_Check_For_Correct_Query_Type);
try
{
await queryHandlerDelegate.Invoke(new QuerySomething(data));
}
catch (Exception ex)
{
_testOutputHelper.WriteLine(ex.ToString());
throw;
}
}));
}
public async Task Should_Allow_Registered_Query_Handlers_With_Non_Reference_Type_Query_Results()
{
var queryHandler = new TestQueryHandler(_testOutputHelper);
var registration = new QueryHandlerRegistration();
registration.Register(() => (IQueryHandler <QuerySomethingWithNonReferenceTypeResult, int>)queryHandler);
var dispatcher = new QueryDispatcher(registration);
var result = await dispatcher.DispatchAsync <QuerySomethingWithNonReferenceTypeResult, int>(new QuerySomethingWithNonReferenceTypeResult(1973));
Assert.Equal(1973, result);
}
public async Task ShouldAllowRegisteredQueryHandlersWithNonReferenceTypeQueryResults()
{
var queryHandler = new TestQueryHandler(_outputHelper);
var registration = new QueryHandlerRegistration();
registration.Register(() => (IQueryHandler <QuerySomethingWithNonReferenceTypeResult, int>)queryHandler);
var dispatcher = new QueryDispatcher(registration);
var result = await dispatcher.DispatchAsync <QuerySomethingWithNonReferenceTypeResult, int>(new QuerySomethingWithNonReferenceTypeResult(1973));
result.Should().Be(1973);
}
public void AuditDecorator_Calls_Query()
{
var queryHandler = new TestQueryHandler();
var query = new TestQuery("Value");
var decorator = new AuditDecorator <TestQuery, string>(_context, _serializer)
{
Handler = queryHandler
};
var result = decorator.Execute(query);
result.Should().Be("Results");
}
public void Should_Invoke_Registered_Query_Handler()
{
var queryHandler = new TestQueryHandler(_testOutputHelper);
var registration = new QueryHandlerRegistration();
registration.Register(() => (IQueryAsyncHandler <QuerySomething, string>)queryHandler);
const string data = nameof(Should_Invoke_Registered_Query_Handler);
var dispatcher = new QueryDispatcher(registration);
var result = dispatcher.Dispatch <QuerySomething, string>(new QuerySomething(data));
Assert.Equal(result, data);
}
public async Task ExecuteAsync_WhenHandlerIsRegistered_ExecutesHandler()
{
var handler = new TestQueryHandler();
var serviceLocator = Substitute.For <IServiceProvider>();
serviceLocator.GetService(typeof(IQueryHandler <TestQuery, Result>))
.Returns(handler);
var queryProcessor = new QueryDispatcher(serviceLocator);
var result = await queryProcessor.ExecuteAsync(new TestQuery("1"));
result.Should().Be(new Result("1"));
}
public void ShouldInvokeRegisteredQueryHandler()
{
var queryHandler = new TestQueryHandler(_outputHelper);
var registration = new QueryHandlerRegistration();
registration.Register(() => (IQueryAsyncHandler <QuerySomething, string>)queryHandler);
const string data = nameof(ShouldInvokeRegisteredQueryHandler);
var dispatcher = new QueryDispatcher(registration);
var result = dispatcher.Dispatch <QuerySomething, string>(new QuerySomething(data));
result.Should().Be(data);
}
public void Should_Allow_Registered_Query_Handlers_In_Container_With_Non_Reference_Type_Query_Results()
{
var queryHandler = new TestQueryHandler(_testOutputHelper);
var container = new Container();
container.Register <IQueryAsyncHandler <QuerySomethingWithNonReferenceTypeResult, int> >(() => queryHandler, Lifestyle.Singleton);
var containerAdapter = new SimpleInjectorContainerAdapter(container);
var resolver = new ContainerQueryAsyncHandlerResolver(containerAdapter); // Async handler resolver
var dispatcher = new QueryDispatcher(resolver);
var result = dispatcher.Dispatch <QuerySomethingWithNonReferenceTypeResult, int>(new QuerySomethingWithNonReferenceTypeResult(1973));
Assert.Equal(1973, result);
}
public void ShouldAllowRegisteredQueryHandlersInContainerWithNonReferenceTypeQueryResults()
{
var queryHandler = new TestQueryHandler(_outputHelper);
var container = new Container();
container.Register <IQueryAsyncHandler <QuerySomethingWithNonReferenceTypeResult, int> >(() => queryHandler, Lifestyle.Singleton);
var containerAdapter = new SimpleInjectorContainerAdapter(container);
var resolver = new ContainerQueryAsyncHandlerResolver(containerAdapter); // Async handler resolver
var dispatcher = new QueryDispatcher(resolver);
var result = dispatcher.Dispatch <QuerySomethingWithNonReferenceTypeResult, int>(new QuerySomethingWithNonReferenceTypeResult(1973));
result.Should().Be(1973);
}
public async Task Given_TestQuery_When_SendAsync_Then_ResultIsReturned()
{
//Arrange
var query = new TestQuery
{
ReturnValue = "ReturnValue"
};
var queryHandler = new TestQueryHandler();
Func <Type, object> resolver = type => { return(queryHandler); };
var queryBus = new QueryBus(resolver);
//Act
var result = await queryBus.SendAsync(query, CancellationToken.None);
//Assert
Assert.That(result, Is.EqualTo(query.ReturnValue));
}
public void ShouldPropagateExceptionFromQueryHandler()
{
var queryHandler = new TestQueryHandler(_outputHelper);
var registration = new QueryHandlerRegistration();
registration.Register(() => (IQueryAsyncHandler <QuerySomethingWithException, string>)queryHandler);
var dispatcher = new LoggingQueryDispatcher(new QueryDispatcher(registration), _outputHelper);
Func <Task> action = () =>
{
return(dispatcher.DispatchAsync <QuerySomethingWithException, string>(
new QuerySomethingWithException("This will cause an exception.")));
};
action.Should().Throw <TestQueryHandlerException>();
}
public async Task ShouldInvokeRegisteredQueryHandlerWithCancellationToken()
{
var queryHandler = new TestQueryHandler(_outputHelper);
var registration = new QueryHandlerRegistration();
registration.Register(() => (IQueryAsyncHandler <QuerySomethingWithDelay, string>)queryHandler);
var cts = new CancellationTokenSource();
var dispatcher = new QueryDispatcher(registration);
const string data = nameof(ShouldInvokeRegisteredQueryHandlerWithCancellationToken);
var result = await dispatcher.DispatchAsync <QuerySomethingWithDelay, string>(new QuerySomethingWithDelay(data, 500), cts.Token);
result.Should().Be(data);
}
public void ShouldInvokeRegisteredQueryHandlerInContainer()
{
var queryHandler = new TestQueryHandler(_outputHelper);
var container = new Container();
container.Register <IQueryHandler <QuerySomething, string> >(() => queryHandler, Lifestyle.Singleton);
var containerAdapter = new SimpleInjectorContainerAdapter(container);
var resolver = new ContainerQueryHandlerResolver(containerAdapter); // Sync handler resolver
const string data = nameof(ShouldInvokeRegisteredQueryHandlerInContainer);
var dispatcher = new QueryDispatcher(resolver);
var result = dispatcher.Dispatch <QuerySomething, string>(new QuerySomething(data));
result.Should().Be(data);
}
public void AuditDecorator_Succeeds()
{
var queryHandler = new TestQueryHandler();
var query = new TestQuery("Value");
var decorator = new AuditDecorator <TestQuery, string>(_context, _serializer)
{
Handler = queryHandler
};
decorator.Execute(query);
_context.QueryExecutions.Should().HaveCount(1);
_context.QueryExecutions.First().Date.Should().BeCloseTo(DateTime.UtcNow, 1000);
_context.QueryExecutions.First().QueryType.Should().Be("AzurePlayground.QueryHandlers.Tests.Decorators.AuditDecoratorTests+TestQuery");
_context.QueryExecutions.First().QueryData.Should().Be(_serializer.SerializeToJson(query));
_context.CallsToSaveChanges.Should().Be(1);
}
public async Task ShouldRegisterAllQueryHandlers()
{
var queryHandler = new TestQueryHandler(_testOutputHelper);
var registration = new QueryHandlerRegistration();
registration.Register(() => (IQueryAsyncHandler <QuerySomething, string>)queryHandler);
QueryHandlerDelegate <string> queryHandlerDelegate = registration.ResolveQueryHandler <QuerySomething, string>();
var query = new QuerySomething(nameof(ShouldRegisterAllQueryHandlers));
var result1 = await queryHandler.HandleAsync(query);
var result2 = await queryHandlerDelegate.Invoke(query);
result1.Should().Be(result2);
}
public async Task Should_Invoke_Registered_Query_Handler_With_Cancellation_Token()
{
var queryHandler = new TestQueryHandler(_testOutputHelper);
var registration = new QueryHandlerRegistration();
registration.Register(() => (IQueryAsyncHandler <QuerySomethingWithDelay, string>)queryHandler);
var cts = new CancellationTokenSource();
var dispatcher = new QueryDispatcher(registration);
const string data = nameof(Should_Invoke_Registered_Query_Handler_With_Cancellation_Token);
var result = await dispatcher.DispatchAsync <QuerySomethingWithDelay, string>(new QuerySomethingWithDelay(data, 500), cts.Token);
Assert.Equal(data, result);
}
public void Should_Invoke_Registered_Query_Handler_In_Container()
{
var queryHandler = new TestQueryHandler(_testOutputHelper);
var container = new Container();
container.Register <IQueryHandler <QuerySomething, string> >(() => queryHandler, Lifestyle.Singleton);
var containerAdapter = new SimpleInjectorContainerAdapter(container);
var resolver = new ContainerQueryHandlerResolver(containerAdapter); // Sync handler resolver
const string data = nameof(Should_Invoke_Registered_Query_Handler_In_Container);
var dispatcher = new QueryDispatcher(resolver);
var result = dispatcher.Dispatch <QuerySomething, string>(new QuerySomething(data));
Assert.Equal(data, result);
}
public async Task ShouldInvokeRegisteredQueryHandlerInContainerWithCancellationToken()
{
var queryHandler = new TestQueryHandler(_outputHelper);
var container = new Container();
container.Register <IQueryAsyncHandler <QuerySomethingWithDelay, string> >(() => queryHandler, Lifestyle.Singleton);
var containerAdapter = new SimpleInjectorContainerAdapter(container);
var resolver = new ContainerQueryAsyncHandlerResolver(containerAdapter);
var dispatcher = new QueryDispatcher(resolver);
var cts = new CancellationTokenSource();
const string data = nameof(ShouldInvokeRegisteredAttributeQueryHandlerWithCancellationToken);
var result = await dispatcher.DispatchAsync <QuerySomethingWithDelay, string>(new QuerySomethingWithDelay(data, 500), cts.Token);
result.Should().Be(data);
}
public async Task ExecutesQueries()
{
// Arrange
var id = Guid.NewGuid();
var handler = new TestQueryHandler();
_handlerRegistry.Register <TestQueryA, TestQueryA.Response, TestQueryHandler>();
_handlerFactory.Setup(x => x.Create <dynamic>(typeof(TestQueryHandler))).Returns(handler);
// Act
var response = await _queryProcessor.ExecuteAsync(new TestQueryA(id));
// Assert
response.ShouldNotBeNull();
response.Id.ShouldBe(id);
handler.Context.ShouldNotBeNull();
handler.Context.Bag.ShouldContainKeyAndValue("id", id);
}
public void ExecutesQueries()
{
// Arrange
var id = Guid.NewGuid();
var handler = new TestQueryHandler();
_handlerRegistry.Register <TestQueryA, Guid, TestQueryHandler>();
_handlerFactory.Setup(x => x.Create(typeof(TestQueryHandler))).Returns(handler);
// Act
var result = _queryProcessor.Execute(new TestQueryA(id));
// Assert
result.ShouldBe(id);
handler.Context.ShouldNotBeNull();
handler.Context.Bag.ShouldContainKeyAndValue("id", id);
_handlerFactory.Verify(x => x.Release(handler), Times.Once);
}
public async Task Should_Invoke_Registered_Query_Handler_In_Container_With_Cancellation_Token()
{
var queryHandler = new TestQueryHandler(_testOutputHelper);
var container = new Container();
container.Register <IQueryAsyncHandler <QuerySomethingWithDelay, string> >(() => queryHandler, Lifestyle.Singleton);
var containerAdapter = new SimpleInjectorContainerAdapter(container);
var resolver = new ContainerQueryAsyncHandlerResolver(containerAdapter);
var dispatcher = new QueryDispatcher(resolver);
var cts = new CancellationTokenSource();
const string data = nameof(Should_Invoke_Registered_Attribute_Query_Handler_With_Cancellation_Token);
var result = await dispatcher.DispatchAsync <QuerySomethingWithDelay, string>(new QuerySomethingWithDelay(data, 500), cts.Token);
Assert.Equal(data, result);
}
public async Task Given_TestQuery_When_SendAsync_Then_ResultIsReturned()
{
//Arrange
var services = new ServiceCollection();
var query = new TestQuery
{
ReturnValue = "ReturnValue"
};
var queryHandler = new TestQueryHandler();
services.AddScoped <IQueryHandler <TestQuery, string> >(provider => queryHandler);
var serviceProvider = services.BuildServiceProvider();
var queryBus = new QueryBus(serviceProvider.GetService);
//Act
var result = await queryBus.SendAsync(query, CancellationToken.None);
//Assert
Assert.That(result, Is.EqualTo(query.ReturnValue));
}
public async Task ShouldInvokeTheActualRegisteredQueryHandler()
{
var queryHandler = new TestQueryHandler(_testOutputHelper);
var registration = new QueryHandlerRegistration();
registration.Register(() => (IQueryHandler <QuerySomething, string>)queryHandler);
QueryHandlerDelegate <string> queryHandlerDelegate = registration.ResolveQueryHandler <QuerySomething, string>();
queryHandlerDelegate.Should().NotBeNull();
const string data = nameof(ShouldInvokeTheActualRegisteredQueryHandler);
// Invoke.
await queryHandlerDelegate.Invoke(new QuerySomething(data));
queryHandler.HandledQueries.Should().HaveCount(1);
queryHandler.HasHandledQuery <QuerySomething>().Should().BeTrue();
}
