public async Task WhenSavingQueryThenShouldSaveToUnderlyingStorage()
{
var services = new ServiceCollection();
services.AddOpenEventSourcing()
.AddEntityFrameworkCoreInMemory()
.AddJsonSerializers()
.Services
.AddLogging(configure => configure.AddConsole());
var serviceProvider = services.BuildServiceProvider();
var dbContext = serviceProvider.GetRequiredService <IDbContextFactory>().Create();
var store = serviceProvider.GetRequiredService <IQueryStore>();
var serializer = serviceProvider.GetRequiredService <IQuerySerializer>();
var query = new FakeQuery();
await store.SaveAsync(query);
dbContext.Queries.Count(q => q.Id == query.Id).Should().Be(1);
var result = await dbContext.Queries.FirstAsync(q => q.Id == query.Id);
result.Id.Should().Be(query.Id);
result.Timestamp.Should().Be(query.Timestamp);
result.CorrelationId.Should().Be(query.CorrelationId);
result.UserId.Should().Be(query.Actor);
result.Data.Should().Be(serializer.Serialize(query));
}
public void RebindEntityToEntityIsUnchanged()
{
var source = new FakeQuery <Sample>(new FakeQueryProvider()).Select(f => f);
var rebound = ElasticFieldsProjectionExpressionVisitor.Rebind(hitParameter, "prefix", validMapping, source.Expression);
Assert.Same(source.Expression, rebound);
}
public async Task Send_FakeQuery_ShouldGoThroughHandlersCorrectly()
{
// Arrange
var serviceProvider = new ServiceCollection()
.AddLiteBus(configuration =>
{
configuration.AddQueries(builder =>
{
// Global Handlers
builder.RegisterPreHandler <FakeGlobalQueryPreHandler>();
builder.RegisterPostHandler <FakeGlobalQueryPostHandler>();
// Fake Query Handlers
builder.RegisterPreHandler <FakeQueryPreHandler>();
builder.RegisterHandler <FakeQueryHandlerWithoutResult>();
builder.RegisterPostHandler <FakeQueryPostHandler>();
});
})
.BuildServiceProvider();
var queryMediator = serviceProvider.GetRequiredService <IQueryMediator>();
var query = new FakeQuery();
// Act
var queryResult = await queryMediator.QueryAsync(query);
// Assert
queryResult.CorrelationId.Should().Be(query.CorrelationId);
query.ExecutedTypes.Should().HaveCount(5);
query.ExecutedTypes[0].Should().Be <FakeGlobalQueryPreHandler>();
query.ExecutedTypes[1].Should().Be <FakeQueryPreHandler>();
query.ExecutedTypes[2].Should().Be <FakeQueryHandlerWithoutResult>();
query.ExecutedTypes[3].Should().Be <FakeQueryPostHandler>();
query.ExecutedTypes[4].Should().Be <FakeGlobalQueryPostHandler>();
}
public void RebindElasticFieldsToHitProperties()
{
var source = new FakeQuery<Sample>(new FakeQueryProvider()).Select(f => ElasticFields.Score);
var rebound = ElasticFieldsProjectionExpressionVisitor.Rebind(hitParameter, "prefix", validMapping, source.Expression);
var flattened = FlatteningExpressionVisitor.Flatten(rebound);
Assert.Single(flattened.OfType<MemberExpression>(), e => e.Expression == hitParameter && e.Member.Name == "_score");
}
public void RebindCollectsSinglePropertyFieldName()
{
var source = new FakeQuery <Sample>(new FakeQueryProvider()).Select(s => s.Name);
var rebound = MemberProjectionExpressionVisitor.Rebind(typeof(Sample), validMapping, source.Expression);
Assert.Contains("name", rebound.Collected);
Assert.Equal(1, rebound.Collected.Count());
}
public void RebindEntityToEntityIsUnchanged()
{
var source = new FakeQuery <Sample>(new FakeQueryProvider()).Select(f => f);
var rebound = ElasticFieldsExpressionVisitor.Rebind(typeof(Sample), validMapping, source.Expression);
Assert.Same(source.Expression, rebound.Item1);
}
public void RebindEntityToEntityIsUnchanged()
{
var source = new FakeQuery<Sample>(new FakeQueryProvider()).Select(f => f);
var rebound = ElasticFieldsExpressionVisitor.Rebind("prefix", validMapping, source.Expression);
Assert.Same(source.Expression, rebound.Item1);
}
public void RebindCollectsSinglePropertyFieldName()
{
var source = new FakeQuery<Sample>(new FakeQueryProvider()).Select(s => s.Name);
var rebound = MemberProjectionExpressionVisitor.Rebind(typeof(Sample), validMapping, source.Expression);
Assert.Contains("name", rebound.Collected);
Assert.Equal(1, rebound.Collected.Count());
}
public void RebindElasticFieldsToHitProperties()
{
var source = new FakeQuery <Sample>(new FakeQueryProvider()).Select(f => ElasticFields.Score);
var rebound = ElasticFieldsProjectionExpressionVisitor.Rebind(hitParameter, "prefix", validMapping, source.Expression);
var flattened = FlatteningExpressionVisitor.Flatten(rebound);
Assert.Single(flattened.OfType <MemberExpression>(), e => e.Expression == hitParameter && e.Member.Name == "_score");
}
public void RebindElasticFieldsToHitProperties()
{
var source = new FakeQuery<Sample>(new FakeQueryProvider()).Select(f => ElasticFields.Score);
var rebound = ElasticFieldsExpressionVisitor.Rebind(typeof(Sample), validMapping, source.Expression);
var flattened = FlatteningExpressionVisitor.Flatten(rebound.Item1);
Assert.Single(flattened.OfType<MemberExpression>(), e => e.Expression == rebound.Item2 && e.Member.Name == "_score");
}
public void RebindCollectsSinglePropertyFieldName()
{
var source = new FakeQuery<Sample>(new FakeQueryProvider()).Select(s => s.Name);
var hitParameter = Expression.Parameter(typeof(Hit));
var rebound = ProjectionExpressionVisitor.Rebind(hitParameter, "prefix", validMapping, source.Expression);
Assert.Contains("prefix.name", rebound.FieldNames);
Assert.Equal(1, rebound.FieldNames.Count());
}
public void RebindCollectsSinglePropertyFieldName()
{
var source = new FakeQuery <Sample>(new FakeQueryProvider()).Select(s => s.Name);
var hitParameter = Expression.Parameter(typeof(Hit));
var rebound = ProjectionExpressionVisitor.Rebind(hitParameter, "prefix", validMapping, source.Expression);
Assert.Contains("prefix.name", rebound.FieldNames);
Assert.Equal(1, rebound.FieldNames.Count());
}
public void RebindCollectsTupleCreateProjectionPropertiesFieldNames()
{
var source = new FakeQuery <Sample>(new FakeQueryProvider()).Select(s => Tuple.Create(s.Name, s.Id, ElasticFields.Score));
var rebound = MemberProjectionExpressionVisitor.Rebind(typeof(Sample), validMapping, source.Expression);
Assert.Contains("name", rebound.Collected);
Assert.Contains("id", rebound.Collected);
Assert.Contains("_score", rebound.Collected);
Assert.Equal(3, rebound.Collected.Count());
}
public void RebindCollectsTupleCreateProjectionPropertiesFieldNames()
{
var source = new FakeQuery<Sample>(new FakeQueryProvider()).Select(s => Tuple.Create(s.Name, s.Id, ElasticFields.Score));
var rebound = MemberProjectionExpressionVisitor.Rebind(typeof(Sample), validMapping, source.Expression);
Assert.Contains("name", rebound.Collected);
Assert.Contains("id", rebound.Collected);
Assert.Contains("_score", rebound.Collected);
Assert.Equal(3, rebound.Collected.Count());
}
public void RebindElasticFieldsToHitProperties()
{
var source = new FakeQuery <Sample>(new FakeQueryProvider()).Select(f => ElasticFields.Score);
var rebound = ElasticFieldsExpressionVisitor.Rebind(typeof(Sample), validMapping, source.Expression);
var flattened = FlatteningExpressionVisitor.Flatten(rebound.Item1);
Assert.Single(flattened.OfType <MemberExpression>(), e => e.Expression == rebound.Item2 && e.Member.Name == "_score");
}
public void RebindTupleCreateMethodElasticFieldsToHitProperties()
{
var source = new FakeQuery<Sample>(new FakeQueryProvider()).Select(f => Tuple.Create(ElasticFields.Score));
var rebound = ElasticFieldsExpressionVisitor.Rebind("prefix", validMapping, source.Expression);
var flattened = FlatteningExpressionVisitor.Flatten(rebound.Item1);
Assert.Single(flattened.OfType<MemberExpression>(), e => e.Expression == rebound.Item2 && e.Member.Name == "_score");
Assert.Contains(rebound.Item2, flattened);
}
public void RebindCollectsAnonymousProjectionPropertiesFieldNames()
{
var source = new FakeQuery <Sample>(new FakeQueryProvider()).Select(s => new { s.Name, s.Id, score = ElasticFields.Score });
var rebound = MemberProjectionExpressionVisitor.Rebind("prefix", validMapping, source.Expression);
Assert.Contains("prefix.name", rebound.Collected);
Assert.Contains("prefix.id", rebound.Collected);
Assert.Contains("_score", rebound.Collected);
Assert.Equal(3, rebound.Collected.Count());
}
public void DispatchQueryToRegisteredHandler()
{
var handler = new SpyHandler <FakeQuery>();
var query = new FakeQuery("query");
Register(handler);
WhenQuery(query);
Assert.Equal(new[] { query }, handler.ReceivedMessages);
}
public void RebindTupleCreateMethodElasticFieldsToHitProperties()
{
var source = new FakeQuery <Sample>(new FakeQueryProvider()).Select(f => Tuple.Create(ElasticFields.Score));
var rebound = ElasticFieldsExpressionVisitor.Rebind("prefix", validMapping, source.Expression);
var flattened = FlatteningExpressionVisitor.Flatten(rebound.Item1);
Assert.Single(flattened.OfType <MemberExpression>(), e => e.Expression == rebound.Item2 && e.Member.Name == "_score");
Assert.Contains(rebound.Item2, flattened);
}
public void DispatchTheQuery_HandlerNotRegistered_ExceptionThrown()
{
IServiceCollection serviceCollection = new ServiceCollection();
IQuery fakeQuery = new FakeQuery();
IResolver resolver = new Resolver(serviceCollection.BuildServiceProvider());
IQueryDispatcher queryDispatcher = new QueryDispatcher(resolver);
Assert.Throws <NotRegisteredQueryHandlerException <FakeQuery> >(() => queryDispatcher.RunQuery <FakeQuery, FakeQueryResult>(new FakeQuery()));
}
public void RebindCollectsTupleCreateProjectionPropertiesFieldNames()
{
var source = new FakeQuery<Sample>(new FakeQueryProvider()).Select(s => Tuple.Create(s.Name, s.Id, ElasticFields.Score));
var hitParameter = Expression.Parameter(typeof(Hit));
var rebound = ProjectionExpressionVisitor.Rebind(hitParameter, "prefix", validMapping, source.Expression);
Assert.Contains("prefix.name", rebound.FieldNames);
Assert.Contains("prefix.id", rebound.FieldNames);
Assert.Contains("_score", rebound.FieldNames);
Assert.Equal(3, rebound.FieldNames.Count());
}
public void RebindCollectsTupleCreateProjectionPropertiesFieldNames()
{
var source = new FakeQuery <Sample>(new FakeQueryProvider()).Select(s => Tuple.Create(s.Name, s.Id, ElasticFields.Score));
var hitParameter = Expression.Parameter(typeof(Hit));
var rebound = ProjectionExpressionVisitor.Rebind(hitParameter, "prefix", validMapping, source.Expression);
Assert.Contains("prefix.name", rebound.FieldNames);
Assert.Contains("prefix.id", rebound.FieldNames);
Assert.Contains("_score", rebound.FieldNames);
Assert.Equal(3, rebound.FieldNames.Count());
}
public void RebindWithNonElasticMemberIsUnchanged()
{
var source = new FakeQuery <Sample>(new FakeQueryProvider()).Select(f => f.Name);
var rebound = ElasticFieldsProjectionExpressionVisitor.Rebind(hitParameter, "prefix", validMapping, source.Expression);
var memberExpression = FlatteningExpressionVisitor.Flatten(rebound).OfType <MemberExpression>().FirstOrDefault();
Assert.NotNull(memberExpression);
Assert.Equal(memberExpression.Member.Name, "Name");
Assert.IsAssignableFrom <ParameterExpression>(memberExpression.Expression);
Assert.Equal("f", ((ParameterExpression)memberExpression.Expression).Name);
}
public void Process_WithRegisteredHandler_ShouldReturnNotNull()
{
// Assign
FakeQuery query = new FakeQuery();
IQueryProcessor processor = new FakeQueryProcessor();
// Act
FakeResult result = processor.Process(query);
// Assert
Assert.NotNull(result);
}
public void CanProcess_WithRegisteredHandler_ShouldReturnTrue()
{
// Assign
FakeQuery query = new FakeQuery();
IQueryProcessor processor = new FakeQueryProcessor();
// Act
bool canProcess = processor.CanProcess(query);
// Assert
Assert.True(canProcess);
}
public void WhenSavingNullQueryThenShoudThrowArgumentNullException()
{
var dbContextFactory = new Mock <IDbContextFactory>().Object;
var querySerializer = new Mock <IQuerySerializer>().Object;
var logger = new Mock <ILogger <EntityFrameworkCoreQueryStore> >().Object;
var store = new EntityFrameworkCoreQueryStore(dbContextFactory: dbContextFactory, querySerializer: querySerializer, logger: logger);
FakeQuery query = null;
Func <Task> act = async() => await store.SaveAsync(query);
act.Should().Throw <ArgumentNullException>()
.And.ParamName.Should().Be("query");
}
public void RebindAnonymousProjectionEntityAndElasticFieldsToMaterializationAndHitProperty()
{
var source = new FakeQuery<Sample>(new FakeQueryProvider()).Select(f => new { f, ElasticFields.Score });
var rebound = ElasticFieldsProjectionExpressionVisitor.Rebind(hitParameter, "prefix", validMapping, source.Expression);
var flattened = FlatteningExpressionVisitor.Flatten(rebound);
Assert.Single(flattened.OfType<MemberExpression>(), m => m.Expression == hitParameter && m.Member.Name == "_score");
Assert.Contains(hitParameter, flattened);
var entityParameter = flattened.OfType<ParameterExpression>().FirstOrDefault(p => p.Name == "f" && p.Type == typeof(Sample));
Assert.NotNull(entityParameter);
Assert.Single(flattened.OfType<NewExpression>(), e => e.Arguments.Contains(entityParameter));
}
public void RebindAnonymousProjectionEntityAndElasticFieldsToMaterializationAndHitProperty()
{
var source = new FakeQuery <Sample>(new FakeQueryProvider()).Select(f => new { f, ElasticFields.Score });
var rebound = ElasticFieldsProjectionExpressionVisitor.Rebind(hitParameter, "prefix", validMapping, source.Expression);
var flattened = FlatteningExpressionVisitor.Flatten(rebound);
Assert.Single(flattened.OfType <MemberExpression>(), m => m.Expression == hitParameter && m.Member.Name == "_score");
Assert.Contains(hitParameter, flattened);
var entityParameter = flattened.OfType <ParameterExpression>().FirstOrDefault(p => p.Name == "f" && p.Type == typeof(Sample));
Assert.NotNull(entityParameter);
Assert.Single(flattened.OfType <NewExpression>(), e => e.Arguments.Contains(entityParameter));
}
public void RebindTupleCreateMethodEntityAndElasticFieldsToMaterializationAndHitProperty()
{
var source = new FakeQuery <Sample>(new FakeQueryProvider()).Select(f => Tuple.Create(ElasticFields.Id, f));
var rebound = ElasticFieldsExpressionVisitor.Rebind("prefix", validMapping, source.Expression);
var flattened = FlatteningExpressionVisitor.Flatten(rebound.Item1);
Assert.Single(flattened.OfType <MemberExpression>(), e => e.Expression == rebound.Item2 && e.Member.Name == "_id");
Assert.Contains(rebound.Item2, flattened);
var entityParameter = flattened.OfType <ParameterExpression>().FirstOrDefault(p => p.Name == "f" && p.Type == typeof(Sample));
Assert.NotNull(entityParameter);
Assert.Single(flattened.OfType <MethodCallExpression>(), e => e.Arguments.Contains(entityParameter));
}
public void SetUp()
{
_fakeCommand = new FakeCommand();
_fakeQuery = new FakeQuery();
_fakeEvent = new FakeEvent();
_mockCommandBus = new Mock <ICommandBus>();
_mockQueryBus = new Mock <IQueryBus>();
_mockQueryBus.Setup(p => p.Execute(_fakeQuery)).Returns(true);
_mockEventBus = new Mock <IEventBus>();
_messageBus = new MessageBus(
_mockCommandBus.Object,
_mockQueryBus.Object,
_mockEventBus.Object);
}
public void WhenQueryIsNullThenShouldThrowArgumentNullException()
{
var services = new ServiceCollection();
services.AddOpenEventSourcing()
.AddQueries()
.Services
.AddLogging();
var serviceProvider = services.BuildServiceProvider();
var dispatcher = serviceProvider.GetRequiredService <IQueryDispatcher>();
FakeQuery query = null;
Func <Task> act = () => dispatcher.DispatchAsync(query);
act.Should().Throw <ArgumentNullException>()
.And.ParamName.Should().Be(nameof(query));
}
public void WhenNoHandlerRegisteredForQueryThenShouldThrowInvalidOperationException()
{
var services = new ServiceCollection();
services.AddOpenEventSourcing()
.AddQueries()
.Services
.AddLogging();
var serviceProvider = services.BuildServiceProvider();
var dispatcher = serviceProvider.GetRequiredService <IQueryDispatcher>();
var command = new FakeQuery();
Func <Task> act = () => dispatcher.DispatchAsync(command);
act.Should().Throw <InvalidOperationException>()
.And.Message.Should().Be($"No query handler for type '{typeof(FakeQuery).FriendlyName()}' has been registered.");
}
public async Task when_processing_the_query()
{
FakeQueryTypeCollection = new Mock <IQueryTypeCollection>();
FakeServiceProvider = new Mock <IServiceProvider>();
Subject = new QueryProcessor(FakeQueryTypeCollection.Object, FakeServiceProvider.Object);
async Task should_invoke_the_correct_query_handler_and_return_a_result()
{
FakeQuery expectedQuery = null;
var expectedResult = new FakeResult();
var fakeQueryHandler = new FakeQueryHandler(x => { expectedQuery = x; return(expectedResult); });
FakeServiceProvider.Setup(x => x.GetService(typeof(IEnumerable <IQueryHandler <FakeQuery, FakeResult> >))).Returns(new[] { fakeQueryHandler });
var query = new FakeQuery();
var result = await Subject.ProcessAsync(query);
query.Should().Be(expectedQuery);
result.Should().Be(expectedResult);
}
void should_throw_exception_if_the_query_handler_is_not_found()
{
var query = new Mock <IQuery <FakeResult> >().Object;
Subject.Awaiting(x => x.ProcessAsync(query)).Should()
.Throw <QueryProcessorException>()
.WithMessage($"The query handler for '{query}' could not be found");
}
void should_throw_exception_if_multiple_query_handlers_are_found()
{
var handlerType = typeof(IQueryHandler <FakeMultiQuery1, FakeResult>);
var enumerableType = typeof(IEnumerable <IQueryHandler <FakeMultiQuery1, FakeResult> >);
FakeServiceProvider.Setup(x => x.GetService(enumerableType)).Returns(new[] { new Mock <IQueryHandler <FakeMultiQuery1, FakeResult> >().Object, new Mock <IQueryHandler <FakeMultiQuery1, FakeResult> >().Object });
var query = new FakeMultiQuery1();
Subject.Awaiting(x => x.ProcessAsync(query)).Should()
.Throw <QueryProcessorException>()
.WithMessage($"Multiple query handlers for '{handlerType}' was found");
}
}
public void SetUp()
{
_query = new FakeQuery();
_handler = new FakeQueryHandler();
_kernel = new StandardKernel();
_kernel.Bind <IQueryHandler <FakeQuery, bool> >()
.ToConstant(_handler);
_mockLogger = new Mock <IQueryLogger>();
_mockDialogService = new Mock <IExceptionDialogService>();
_bus = new QueryBus(
_mockLogger.Object,
_mockDialogService.Object);
QueryBus.Kernel = _kernel;
}
public async Task Dispatch_Resolves_Handler_And_Calls_It()
{
var fakeQuery = new FakeQuery();
var fakeModel = new FakeModel();
var handler = new Mock <IQueryHandler <FakeQuery, FakeModel> >();
handler
.Setup(x => x.HandleAsync(fakeQuery, _cancellationToken))
.ReturnsAsync(fakeModel);
_mockHandlerFactory
.Setup(x => x.CreateHandler(typeof(IQueryHandler <FakeQuery, FakeModel>)))
.Returns(handler.Object);
FakeModel result =
await _dispatcher.DispatchAsync(fakeQuery, _cancellationToken);
Assert.That(result, Is.EqualTo(fakeModel));
}
public async Task when_processing_the_query()
{
FakeQueryTypeCollection = new Mock <IQueryTypeCollection>();
FakeServiceProvider = new Mock <IServiceProvider>();
Subject = new QueryProcessor(FakeQueryTypeCollection.Object, FakeServiceProvider.Object);
async Task should_invoke_the_correct_query_handler()
{
var fakeQueryHandler = new FakeQueryHandler(x => { Expected = x; return(new FakeResult()); });
FakeServiceProvider.Setup(x => x.GetService(typeof(IQueryHandler <FakeQuery, FakeResult>))).Returns(fakeQueryHandler);
var query = new FakeQuery();
await Subject.ProcessAsync(query);
Expected.Should().Be(query);
}
async Task should_return_the_result_from_the_query_handler()
{
var expected = new FakeResult();
var query = new FakeQuery();
var fakeQueryHandler = new FakeQueryHandler(x => expected);
FakeServiceProvider.Setup(x => x.GetService(typeof(IQueryHandler <FakeQuery, FakeResult>))).Returns(fakeQueryHandler);
var result = await Subject.ProcessAsync(query);
result.Should().Be(expected);
}
void should_throw_exception_if_the_query_handler_is_not_found()
{
var query = new Mock <IQuery <FakeResult> >().Object;
Subject.Awaiting(async x => await x.ProcessAsync(query)).Should()
.Throw <QueryProcessorException>()
.WithMessage($"The query handler for '{query}' could not be found");
}
void should_throw_exception_if_the_query_type_is_not_found()
{
var queryName = "NotFoundQuery";
var json = JObject.Parse("{}");
Subject.Awaiting(async x => await x.ProcessAsync <object>(queryName, json)).Should()
.Throw <QueryProcessorException>()
.WithMessage("The query type 'NotFoundQuery' could not be found");
}
void should_throw_exception_if_the_json_is_invalid()
{
var queryName = "FakeQuery";
FakeQueryTypeCollection.Setup(x => x.GetType(queryName)).Returns(typeof(FakeQuery));
Subject.Awaiting(async x => await x.ProcessAsync <object>(queryName, (JObject)null)).Should()
.Throw <QueryProcessorException>()
.WithMessage("The json could not be converted to an object");
}
void should_throw_exception_if_the_dictionary_is_invalid()
{
var queryName = "FakeQuery";
FakeQueryTypeCollection.Setup(x => x.GetType(queryName)).Returns(typeof(FakeQuery));
Subject.Awaiting(async x => await x.ProcessAsync <object>(queryName, (IDictionary <string, string>)null)).Should()
.Throw <QueryProcessorException>()
.WithMessage("The dictionary could not be converted to an object");
}
}
public string get_query_Name(FakeQuery query)
{
return(null);
}
public void RebindCollectsAnonymousProjectionPropertiesFieldNames()
{
var source = new FakeQuery<Sample>(new FakeQueryProvider()).Select(s => new { s.Name, s.Id, score = ElasticFields.Score });
var rebound = MemberProjectionExpressionVisitor.Rebind("prefix", validMapping, source.Expression);
Assert.Contains("prefix.name", rebound.Collected);
Assert.Contains("prefix.id", rebound.Collected);
Assert.Contains("_score", rebound.Collected);
Assert.Equal(3, rebound.Collected.Count());
}
public void RebindTupleCreateMethodEntityAndElasticFieldsToMaterializationAndHitProperty()
{
var source = new FakeQuery<Sample>(new FakeQueryProvider()).Select(f => Tuple.Create(ElasticFields.Id, f));
var rebound = ElasticFieldsExpressionVisitor.Rebind("prefix", validMapping, source.Expression);
var flattened = FlatteningExpressionVisitor.Flatten(rebound.Item1);
Assert.Single(flattened.OfType<MemberExpression>(), e => e.Expression == rebound.Item2 && e.Member.Name == "_id");
Assert.Contains(rebound.Item2, flattened);
var entityParameter = flattened.OfType<ParameterExpression>().FirstOrDefault(p => p.Name == "f" && p.Type == typeof(Sample));
Assert.NotNull(entityParameter);
Assert.Single(flattened.OfType<MethodCallExpression>(), e => e.Arguments.Contains(entityParameter));
}
public async Task when_processing_the_query()
{
FakeQueryTypeCollection = new Mock <IQueryTypeCollection>();
FakeServiceProvider = new Mock <IServiceProvider>();
Subject = new QueryProcessor(FakeQueryTypeCollection.Object, FakeServiceProvider.Object);
async Task should_invoke_the_correct_query_handler()
{
FakeQuery expectedQuery = null;
var fakeQueryHandler = new FakeQueryHandler(x => { expectedQuery = x; return(new FakeResult()); });
FakeServiceProvider.Setup(x => x.GetService(typeof(IQueryHandler <FakeQuery, FakeResult>))).Returns(fakeQueryHandler);
var query = new FakeQuery();
await Subject.ProcessAsync(query);
query.Should().Be(expectedQuery);
}
async Task should_create_the_query_from_a_string()
{
var expectedQueryType = typeof(FakeQuery);
var fakeQueryHandler = new Mock <IQueryHandler <FakeQuery, FakeResult> >();
FakeQueryTypeCollection.Setup(x => x.GetType(expectedQueryType.Name)).Returns(expectedQueryType);
FakeServiceProvider.Setup(x => x.GetService(typeof(IQueryHandler <FakeQuery, FakeResult>))).Returns(fakeQueryHandler.Object);
await Subject.ProcessAsync <FakeResult>(expectedQueryType.Name, "{}");
fakeQueryHandler.Verify(x => x.HandleAsync(It.IsAny <FakeQuery>()));
}
async Task should_create_the_query_from_a_dictionary()
{
var expectedQueryType = typeof(FakeQuery);
var fakeQueryHandler = new Mock <IQueryHandler <FakeQuery, FakeResult> >();
FakeQueryTypeCollection.Setup(x => x.GetType(expectedQueryType.Name)).Returns(expectedQueryType);
FakeServiceProvider.Setup(x => x.GetService(typeof(IQueryHandler <FakeQuery, FakeResult>))).Returns(fakeQueryHandler.Object);
await Subject.ProcessAsync <FakeResult>(expectedQueryType.Name, new Dictionary <string, IEnumerable <string> >());
fakeQueryHandler.Verify(x => x.HandleAsync(It.IsAny <FakeQuery>()));
}
async Task should_create_a_complex_query_from_a_dictionary()
{
var expectedQueryType = typeof(FakeComplexQuery);
FakeComplexQuery expectedQuery = null;
var fakeQueryHandler = new FakeComplexQueryHandler(x => { expectedQuery = x; return(new List <FakeResult>()); });
FakeQueryTypeCollection.Setup(x => x.GetType(expectedQueryType.Name)).Returns(expectedQueryType);
FakeServiceProvider.Setup(x => x.GetService(typeof(IQueryHandler <FakeComplexQuery, IEnumerable <FakeResult> >))).Returns(fakeQueryHandler);
var query = new Dictionary <string, IEnumerable <string> >
{
{ "String", new[] { "Value" } },
{ "Int", new[] { "1" } },
{ "Bool", new[] { "true" } },
{ "DateTime", new[] { "2018-07-06" } },
{ "Guid", new[] { "3B10C34C-D423-4EC3-8811-DA2E0606E241" } },
{ "NullableDouble", new[] { "2.1" } },
{ "UndefinedProperty", new[] { "should_not_be_used" } },
{ "Array", new[] { "1", "2" } },
{ "IEnumerable", new[] { "3", "4" } },
{ "List", new[] { "5", "6" } }
};
await Subject.ProcessAsync <IEnumerable <FakeResult> >(expectedQueryType.Name, query);
expectedQuery.String.Should().Be("Value");
expectedQuery.Int.Should().Be(1);
expectedQuery.Bool.Should().Be(true);
expectedQuery.DateTime.Should().Be(DateTime.Parse("2018-07-06"));
expectedQuery.Guid.Should().Be(new Guid("3B10C34C-D423-4EC3-8811-DA2E0606E241"));
expectedQuery.NullableDouble.Should().Be(2.1);
expectedQuery.Array.Should().Equal(1, 2);
expectedQuery.IEnumerable.Should().Equal(3, 4);
expectedQuery.List.Should().Equal(5, 6);
}
async Task should_return_the_result_from_the_query_handler()
{
var expected = new FakeResult();
var fakeQueryHandler = new FakeQueryHandler(x => expected);
FakeServiceProvider.Setup(x => x.GetService(typeof(IQueryHandler <FakeQuery, FakeResult>))).Returns(fakeQueryHandler);
var query = new FakeQuery();
var result = await Subject.ProcessAsync(query);
result.Should().Be(expected);
}
void should_throw_exception_if_the_query_handler_is_not_found()
{
var query = new Mock <IQuery <FakeResult> >().Object;
Subject.Awaiting(async x => await x.ProcessAsync(query)).Should()
.Throw <QueryProcessorException>()
.WithMessage($"The query handler for '{query}' could not be found");
}
void should_throw_exception_if_the_query_type_is_not_found()
{
var queryName = "NotFoundQuery";
var json = JObject.Parse("{}");
Subject.Awaiting(async x => await x.ProcessAsync <object>(queryName, json)).Should()
.Throw <QueryProcessorException>()
.WithMessage("The query type 'NotFoundQuery' could not be found");
}
void should_throw_exception_if_the_json_is_invalid()
{
var queryName = "FakeQuery";
FakeQueryTypeCollection.Setup(x => x.GetType(queryName)).Returns(typeof(FakeQuery));
Subject.Awaiting(async x => await x.ProcessAsync <object>(queryName, (JObject)null)).Should()
.Throw <QueryProcessorException>()
.WithMessage("The json could not be converted to an object");
}
void should_throw_exception_if_the_dictionary_is_invalid()
{
var queryName = "FakeQuery";
FakeQueryTypeCollection.Setup(x => x.GetType(queryName)).Returns(typeof(FakeQuery));
Subject.Awaiting(async x => await x.ProcessAsync <object>(queryName, (IDictionary <string, IEnumerable <string> >)null)).Should()
.Throw <QueryProcessorException>()
.WithMessage("The dictionary could not be converted to an object");
}
}
private object ParseCommand()
{
if (Connection.State != ConnectionState.Open)
{
throw new Exception("Cmd001: Connection must be open before calling a command");
}
foreach (FakeParameter param in _parameterCollection)
{
CommandText = CommandText.Replace(param.ParameterName, param.Value.ToString());
}
FakeQuery operations = JsonConvert.DeserializeObject <FakeQuery>(CommandText);
object result = null;
{
{
if (operations.Create != null)
{
if (operations.Create.Table == null)
{
throw new FakeException("Create:Table is not specified");
}
{
FakeDatabase db = JsonConvert.DeserializeObject <FakeDatabase>(File.ReadAllText(Connection.Database));
if (db == null)
{
db = new FakeDatabase()
{
Name = Connection.Database
}
}
;
if (db.Tables.Find(x => x.Name == operations.Create.Table.Name) != null)
{
throw new FakeException("Create:Table is already exists");
}
db.Tables.Add(operations.Create.Table);
File.WriteAllText(Connection.Database, JsonConvert.SerializeObject(db));
}
result = 1;
}
else if (operations.Insert != null)
{
int rowsAffected = 0;
{
FakeDatabase db = JsonConvert.DeserializeObject <FakeDatabase>(File.ReadAllText(Connection.Database));
var table = db.Tables.Find(x => x.Name == operations.Insert.Into);
if (table == null)
{
throw new FakeException("Insert:Table is not exists");
}
List <object> rows = new List <object>();
for (int i = 0; i < table.Headers.Count; i++)
{
rows.Add(new object());
}
for (int i = 0; i < operations.Insert.Values.Count; i++)
{
int index = i % operations.Insert.Headers.Count;
var header = table.Headers.Find(x => x.Name == operations.Insert.Headers[index]);
if (header.Attributes.Contains(FakeDbAttribute.NotNull) && operations.Insert.Values[i] == null)
{
throw new FakeException($"Insert: Field {operations.Insert.Headers[index]} has NotNull attribute, but passed value is null");
}
rows[i] = operations.Insert.Values[i];
if (i % operations.Insert.Headers.Count == operations.Insert.Headers.Count - 1)
{
table.Rows.Add(rows);
rows = new List <object>(table.Headers.Count);
rowsAffected++;
}
}
File.WriteAllText(Connection.Database, JsonConvert.SerializeObject(db));
}
result = rowsAffected;
}
else if (operations.Update != null)
{
int rowsAffected = 0;
{
FakeDatabase db = JsonConvert.DeserializeObject <FakeDatabase>(File.ReadAllText(Connection.Database));
var table = db.Tables.Find(x => x.Name == operations.Update.Table);
// Parse where
string[] words = operations.Update.Where.Split('=');
int index = table.Headers.FindIndex(u => u.Name == words[0]);
foreach (var row in table.Rows.Where(u => u[index].ToString() == words[1].Trim()))
{
for (int i = 0; i < operations.Update.To.Count; i++)
{
int idx = table.Headers.FindIndex(x => x.Name.ToLower() == operations.Update.To[i].Field.Trim().ToLower());
row[idx] = operations.Update.To[i].Value;
}
rowsAffected++;
}
File.WriteAllText(Connection.Database, JsonConvert.SerializeObject(db));
}
result = rowsAffected;
}
else if (operations.Delete != null)
{
int rowsAffected = 0;
{
FakeDatabase db = JsonConvert.DeserializeObject <FakeDatabase>(File.ReadAllText(Connection.Database));
var table = db.Tables.Find(x => x.Name == operations.Delete.From);
// Parse where
string[] words = operations.Delete.Where.Split('=');
int index = table.Headers.FindIndex(u => u.Name == words[0]);
var rowsToDelete = table.Rows.Where(u => u[index].ToString() == words[1].Trim()).ToList();
for (int i = 0; i < rowsToDelete.Count; i++)
{
table.Rows.Remove(rowsToDelete[i]);
rowsAffected++;
}
File.WriteAllText(Connection.Database, JsonConvert.SerializeObject(db));
}
result = rowsAffected;
}
else if (operations.Select != null)
{
{
FakeDatabase db = JsonConvert.DeserializeObject <FakeDatabase>(File.ReadAllText(Connection.Database));
var table = db.Tables.Find(x => x.Name == operations.Select.From);
List <List <object> > rowsToSelect;
if (operations.Select.Where != null)
{
// Where filter
string[] words = operations.Select.Where.Split('=');
int index = table.Headers.FindIndex(u => u.Name == words[0]);
rowsToSelect = table.Rows.Where(u => u[index].ToString() == words[1].Trim()).ToList();
}
else
{
// Without where
rowsToSelect = table.Rows;
}
List <List <object> > tableResults = new List <List <object> >();
List <object> headers = new List <object>();
List <int> indices = new List <int>();
if (operations.Select.Fields != null && operations.Select.Fields.Count > 0)
{
// Fields filter
for (int i = 0; i < operations.Select.Fields.Count; i++)
{
int indexOfHeader = table.Headers.FindIndex(u => u.Name == operations.Select.Fields[i]);
if (indexOfHeader == -1)
{
throw new FakeException($"Select: Field {operations.Select.Fields[i]} is not exists");
}
headers.Add(operations.Select.Fields[i]);
indices.Add(indexOfHeader);
}
}
else
{
// All fields
for (int i = 0; i < table.Headers.Count; i++)
{
headers.Add(table.Headers[i].Name);
indices.Add(i);
}
}
tableResults.Add(headers);
foreach (List <object> row in rowsToSelect)
{
List <object> fieldRow = new List <object>();
for (int i = 0; i < indices.Count; i++)
{
fieldRow.Add(row[indices[i]]);
}
tableResults.Add(fieldRow);
}
result = tableResults;
}
}
}
}
return(result);
}
public void RebindWithNonElasticMemberIsUnchanged()
{
var source = new FakeQuery<Sample>(new FakeQueryProvider()).Select(f => f.Name);
var rebound = ElasticFieldsExpressionVisitor.Rebind("prefix", validMapping, source.Expression);
var memberExpression = FlatteningExpressionVisitor.Flatten(rebound.Item1).OfType<MemberExpression>().FirstOrDefault();
Assert.NotNull(memberExpression);
Assert.Equal(memberExpression.Member.Name, "Name");
Assert.IsAssignableFrom<ParameterExpression>(memberExpression.Expression);
Assert.Equal("f", ((ParameterExpression)memberExpression.Expression).Name);
}
public string get_query_Name(FakeQuery query)
{
return null;
}
