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; }