public async Task Should_ContinueToExecuteQueries_WhenErrorExecuting_MultipleQueries() { await _queryEventBus.SetMaxQueryPerIntervalThreshold(5); await _queryEventBus.Reset(); var query1 = new TestQuery(1); var query2 = new TestQuery(2); var query3 = new TestQuery(3); var query4 = new TestQuery(4); var query5 = new TestQuery(5); _querySubscriptions.AddSubscriber(query1); _querySubscriptions.AddSubscriber(query2); _querySubscriptions.AddSubscriber(query3); _querySubscriptions.AddSubscriber(query4); _querySubscriptions.AddSubscriber(query5); query2.MockQueryContext.Setup(c => c.SaveQueryResultToStore()).Throws(new Exception("Force exception")); await _queryEventBus.ExecutePendingQueries(); query1.MockQueryContext.Verify(c => c.SaveQueryResultToStore(), Times.Once); query2.MockQueryContext.Verify(c => c.SaveQueryResultToStore(), Times.Once); query3.MockQueryContext.Verify(c => c.SaveQueryResultToStore(), Times.Once); query4.MockQueryContext.Verify(c => c.SaveQueryResultToStore(), Times.Once); query5.MockQueryContext.Verify(c => c.SaveQueryResultToStore(), Times.Once); }
static async Task Main(string[] args) { // Set up DI in our console app... var executingAssembly = Assembly.GetExecutingAssembly(); var serviceProvider = new ServiceCollection().AddMediatR(executingAssembly) .AddApplication() .BuildServiceProvider(); // Get a handle on out MediatR instance via DI... var mediatr = serviceProvider.GetService <IMediator>(); // Set up our 1st request in the form of a query... var query = new TestQuery { // Query related data goes here... }; // Get MediatR to call the corresponding handler to service the query... var result = await mediatr.Send(query); // Set up our 2nd request in the form of a command... var command = new TestCommand { // Command related data goes here... }; // Get MediatR to call the corresponding handler to service the command... await mediatr.Send(command); System.Console.WriteLine("MediatR!"); }
public async Task Should_HandleConcurrency_ExecuteQueryOnceAndNotExceedThreshold() { await _queryEventBus.SetMaxQueryPerIntervalThreshold(2); await _queryEventBus.Reset(); var query1 = new TestQuery(1); var query2 = new TestQuery(2); var query3 = new TestQuery(3); _querySubscriptions.AddSubscriber(query1); _querySubscriptions.AddSubscriber(query1); _querySubscriptions.AddSubscriber(query1); _querySubscriptions.AddSubscriber(query2); _querySubscriptions.AddSubscriber(query2); _querySubscriptions.AddSubscriber(query3); var executionTasks = new List <Task>(); for (int i = 0; i < 10; i++) { executionTasks.Add(Task.Run(async() => await _queryEventBus.ExecutePendingQueries())); } await Task.WhenAll(executionTasks); query1.MockQueryContext.Verify(c => c.SaveQueryResultToStore(), Times.Once); query2.MockQueryContext.Verify(c => c.SaveQueryResultToStore(), Times.Once); query3.MockQueryContext.Verify(c => c.SaveQueryResultToStore(), Times.Never); Assert.Equal(1, _querySubscriptions.Count); }
public async Task Should_NotExceedMaxQueriesForInterval_MultipleExecution() { await _queryEventBus.SetMaxQueryPerIntervalThreshold(2); await _queryEventBus.Reset(); var query1 = new TestQuery(1); var query2 = new TestQuery(2); var query3 = new TestQuery(3); _querySubscriptions.AddSubscriber(query1); _querySubscriptions.AddSubscriber(query1); _querySubscriptions.AddSubscriber(query1); _querySubscriptions.AddSubscriber(query2); _querySubscriptions.AddSubscriber(query2); _querySubscriptions.AddSubscriber(query3); await _queryEventBus.ExecutePendingQueries(); await _queryEventBus.ExecutePendingQueries(); await _queryEventBus.ExecutePendingQueries(); await _queryEventBus.ExecutePendingQueries(); query1.MockQueryContext.Verify(c => c.SaveQueryResultToStore(), Times.Once); query2.MockQueryContext.Verify(c => c.SaveQueryResultToStore(), Times.Once); query3.MockQueryContext.Verify(c => c.SaveQueryResultToStore(), Times.Never); }
public async Task Should_NotExceedMaxQueriesForInterval() { await _queryEventBus.SetMaxQueryPerIntervalThreshold(2); await _queryEventBus.Reset(); var query1 = new TestQuery(1); var query2 = new TestQuery(2); var query3 = new TestQuery(3); _querySubscriptions.AddSubscriber(query1); _querySubscriptions.AddSubscriber(query1); _querySubscriptions.AddSubscriber(query1); _querySubscriptions.AddSubscriber(query2); _querySubscriptions.AddSubscriber(query2); _querySubscriptions.AddSubscriber(query3); await _queryEventBus.ExecutePendingQueries(); query1.MockQueryContext.Verify(c => c.SaveQueryResultToStore(), Times.Once); query2.MockQueryContext.Verify(c => c.SaveQueryResultToStore(), Times.Once); query3.MockQueryContext.Verify(c => c.SaveQueryResultToStore(), Times.Never); //Executed queries get subscriber count cleared. Assert.Equal(1, _querySubscriptions.Count); Assert.Equal(1, _querySubscriptions.GetSubscriberCount(query3)); }
public string CreateTestAndReturnName(string testName) { if (AuthCheck.NewCheck().MustBeInRole("Dev").IsNotSatisfiedBy(_currentUserFactory.GetCurrentUser())) { throw new UserNotAuthorisedException(); } Guid newTestId = Guid.NewGuid(); TestSaveCommand cmd = new TestSaveCommand() { Id = newTestId, TestName = testName }; _commandProcessor.Execute(cmd); TestQuery qry = new TestQuery() { Id = newTestId }; Test domainEntity = _queryProcessor.Execute(qry); if (domainEntity != null) { return(domainEntity.TestName); } else { throw new Exception("Couldn't get test from database."); } }
public void Get_MediatorWithQueryRequest_ExecutesEFQueryTrackingBehaviorInterceptorAndDisablesTracking() { // arrange var autoMocker = new AutoMocker(); var serviceProvider = autoMocker.GetMock <IServiceProvider>(); var testHandler = new Mock <TestHandler>(); var interceptor = new Mock <IInterceptor>(); var logger = new Mock <IBoltOnLogger <EFQueryTrackingBehaviorInterceptor> >(); serviceProvider.Setup(s => s.GetService(typeof(IRequestHandler <TestQuery, bool>))) .Returns(testHandler.Object); var request = new TestQuery(); var mediatorContext = new MediatorDataContext(); autoMocker.Use <IEnumerable <IInterceptor> >(new List <IInterceptor> { new EFQueryTrackingBehaviorInterceptor(logger.Object, mediatorContext) }); var sut = autoMocker.CreateInstance <BoltOn.Mediator.Pipeline.Mediator>(); testHandler.Setup(s => s.Handle(request)).Returns(true); // act var result = sut.Process(request); // assert Assert.True(result); Assert.True(mediatorContext.IsQueryRequest); logger.Verify(l => l.Debug($"Entering {nameof(EFQueryTrackingBehaviorInterceptor)}...")); logger.Verify(l => l.Debug($"IsQueryRequest: {true}")); }
private static TestCollection CreateCollection() { var query = new TestQuery() { AnInt = 1, PRETest = "Woot" }; var items = new List <Test> { new Test() { IntVal = 1, StringVal = "Da String" }, new Test() { IntVal = -76, StringVal = "Another String" }, new Test() { IntVal = 1233, StringVal = "Tacos" } }; var collection = new TestCollection(42, query, items.Count, items); return(collection); }
public async Task Get_MediatorWithQueryRequest_ExecutesEFQueryTrackingBehaviorInterceptorAndDisablesTracking() { // arrange var autoMocker = new AutoMocker(); var serviceProvider = autoMocker.GetMock <IServiceProvider>(); var testHandler = new Mock <TestHandler>(); var logger = new Mock <IBoltOnLogger <ChangeTrackerInterceptor> >(); serviceProvider.Setup(s => s.GetService(typeof(IHandler <TestQuery, bool>))) .Returns(testHandler.Object); var request = new TestQuery(); var changeTrackerContext = new ChangeTrackerContext(); autoMocker.Use <IEnumerable <IInterceptor> >(new List <IInterceptor> { new ChangeTrackerInterceptor(logger.Object, changeTrackerContext) }); var sut = autoMocker.CreateInstance <BoltOn.Mediator.Pipeline.Mediator>(); testHandler.Setup(s => s.HandleAsync(request, It.IsAny <CancellationToken>())).Returns(Task.FromResult(true)); // act var result = await sut.ProcessAsync(request); // assert Assert.True(result); Assert.True(changeTrackerContext.IsQueryRequest); logger.Verify(l => l.Debug($"Entering {nameof(ChangeTrackerInterceptor)}...")); logger.Verify(l => l.Debug($"IsQueryRequest: {true}")); }
public override async Task <IEnumerable <TestItem> > ExecuteAsync(TestQuery query, CancellationToken cancellationToken = default(CancellationToken)) { var result = await context.TestItems.ToListAsync(); return(result); }
public async Task ShouldNotLogIfQueryIsInExcludeList() { // Arrange LogSettings logSettings = new LogSettings { Exclude = new List <string> { typeof(TestQuery).Name } }; Mock <IOptionsSnapshot <LogSettings> > mockOptions = new Mock <IOptionsSnapshot <LogSettings> >(); mockOptions.Setup(x => x.Value).Returns(logSettings); Mock <IRequestLogger> mockRequestLogger = new Mock <IRequestLogger>(); Mock <ILogger <TestQuery> > mockLogger = new Mock <ILogger <TestQuery> >(); Mock <IQueryHandler <TestQuery, string> > mockQueryHandler = new Mock <IQueryHandler <TestQuery, string> >(); var query = new TestQuery(); mockQueryHandler .Setup(x => x.Handle(query, It.IsAny <RequestContext>())) .ReturnsAsync(new QueryResult <string>("OK")); var decorator = new LogQueryHandlerDecorator <TestQuery, string>(mockRequestLogger.Object, mockQueryHandler.Object, mockOptions.Object, mockLogger.Object); // Act var result = await decorator.Handle(query, Helper.Context); // Assert mockRequestLogger.Verify(x => x.Log(It.IsAny <RequestLog>()), Times.Exactly(0)); Assert.Equal(Messages.Success, result.Code); }
public void PagedQueryHelper_GetPageData_Test(int?page, int?perPage, int offset, int next) { IPagedQuery query = new TestQuery(page, perPage); var pageData = PagedQueryHelper.GetPageData(query); Assert.That(pageData, Is.EqualTo(new PageData(offset, next))); }
public async Task GetPrioritizedQueries_ShouldGetPrioritizedQueriesSubscriptionsBySubscriberCountDescending() { var querySubscriptions = new QuerySubscriptions(); var query1 = new TestQuery(1, QueryFunctionType.SingleQuote); var query2 = new TestQuery(2, QueryFunctionType.IntraDay); var query3 = new TestQuery(3, QueryFunctionType.IntraDay); querySubscriptions.AddSubscriber(query1); querySubscriptions.AddSubscriber(query2); querySubscriptions.AddSubscriber(query2); querySubscriptions.AddSubscriber(query2); querySubscriptions.AddSubscriber(query3); querySubscriptions.AddSubscriber(query3); query1.SetMockQueryContext(_mockContext); query2.SetMockQueryContext(_mockContext); query3.SetMockQueryContext(_mockContext); var priorityRule = new QuerySubscriptionCountRule(_mockContextFactory.Object, querySubscriptions, (new Mock <ILogger <QuerySubscriptionCountRule> >()).Object); var prioritizedQueries = (await priorityRule.GetPrioritizedQueries()).ToList(); Assert.Equal(3, prioritizedQueries.Count); Assert.Equal(prioritizedQueries[0], query2); Assert.Equal(prioritizedQueries[1], query3); Assert.Equal(prioritizedQueries[1], query3); }
public ActionResult <string> Get(string inputValue) { TestQuery query = new TestQuery(inputValue); var result = _cqrs.ExecuteQuery <TestQuery, TestQueryResult>(query); return(result.TestQueryResultValue); }
public async Task ShouldFormatExceptionAsUnHandlerExceptionResult() { // Arrange LogSettings logSettings = new LogSettings(); Mock <IOptionsSnapshot <LogSettings> > mockOptions = new Mock <IOptionsSnapshot <LogSettings> >(); mockOptions.Setup(x => x.Value).Returns(logSettings); Mock <IRequestLogger> mockRequestLogger = new Mock <IRequestLogger>(); Mock <ILogger <TestQuery> > mockLogger = new Mock <ILogger <TestQuery> >(); Mock <IQueryHandler <TestQuery, string> > mockQueryHandler = new Mock <IQueryHandler <TestQuery, string> >(); var query = new TestQuery(); mockQueryHandler .Setup(x => x.Handle(query, It.IsAny <RequestContext>())) .ThrowsAsync(new Exception()); var decorator = new LogQueryHandlerDecorator <TestQuery, string>(mockRequestLogger.Object, mockQueryHandler.Object, mockOptions.Object, mockLogger.Object); // Act var result = await decorator.Handle(query, Helper.Context); // Assert Assert.True(result.HasError); Assert.Equal(Constants.UnhandledException, result.Errors[0].Code); }
public async Task Bug_1623_use_any_within_compiled_query() { var user = new User { Age = 5, UserName = "******" }; theSession.Store(user); await theSession.SaveChangesAsync(); // this should pass => Any works. user.ShouldSatisfyAllConditions( () => theSession.Query <User>().Any(x => x.Age == 6).ShouldBeFalse(), () => theSession.Query <User>().Any(x => x.Age == 5).ShouldBeTrue() ); // this should pass => AnyAsync works, too var asyncR1 = await theSession.Query <User>().AnyAsync(x => x.Age == 6); asyncR1.ShouldBeFalse(); var asyncR2 = await theSession.Query <User>().AnyAsync(x => x.Age == 5); asyncR2.ShouldBeTrue(); var q = new TestQuery() { Age = 6 }; var queryAsync = theSession.Query(q); // theSession.QueryAsync(q, default) will fail also! queryAsync.ShouldBeFalse(); }
public async Task do_not_throw_target_invocation_exception_upon_failure() { var container = Substitute.For <IContainer>(); var scope = Substitute.For <IContainerScope>(); var query = new TestQuery(); var handler = Substitute.For <IQueryHandler <TestQuery, string> >(); Exception actual = null; container.CreateScope().Returns(scope); handler.When(x => x.ExecuteAsync(query)).Do(x => { throw new DataException(); }); scope.ResolveAll(null).ReturnsForAnyArgs(new[] { handler }); var sut = new IocQueryBus(container); try { await sut.QueryAsync(query); } catch (Exception exception) { actual = exception; } actual.Should().BeOfType <DataException>(); }
public Task Consumer_Can_DispatchQuery_To_Consumer() { var testQuery = new TestQuery(); return(ContainerFixture.TestAsync(async fixture => { var testResult = await fixture .Arrange .Container(c => { var hostPlugin = new MockHostPlugin(); hostPlugin.AddPluginType <TestConsumer>(); c.RegisterPlugins(hostPlugin); c.RegisterPlugin <MessagingPlugin>(); }) .Act.OnServices(s => { var dispatcher = s.GetService <IMessagingService>(); return dispatcher.DispatchAsync(testQuery); }); testResult.Assert.State(() => { testQuery.Result.Should().NotBeNull(); testQuery.TestLog.Should().HaveCount(1); testQuery.TestLog.Should().Contain(nameof(TestConsumer)); }); })); }
public void Sut_ShouldBeAsyncQueryHandler( DelegateQueryHandler <TestQuery, object> sut, TestQuery query, object expected) { sut.Should().BeAssignableTo <IAsyncQueryHandler <TestQuery, object> >(); }
public async Task ShouldLogIfSettingsIsNotProvided() { // Arrange LogSettings logSettings = new LogSettings(); // Mock<LogSettings> mockOptions = new Mock<LogSettings>; // mockOptions. Mock <IRequestLogger> mockRequestLogger = new Mock <IRequestLogger>(); Mock <ILogger <TestQuery> > mockLogger = new Mock <ILogger <TestQuery> >(); Mock <IQueryHandler <TestQuery, string> > mockQueryHandler = new Mock <IQueryHandler <TestQuery, string> >(); var query = new TestQuery(); mockQueryHandler .Setup(x => x.Handle(query, It.IsAny <RequestContext>())) .ReturnsAsync(new QueryResult <string>("OK")); var decorator = new LogQueryHandlerDecorator <TestQuery, string>(mockRequestLogger.Object, mockQueryHandler.Object, logSettings, mockLogger.Object); // Act var result = await decorator.Handle(query, Helper.Context); // Assert mockRequestLogger.Verify(x => x.Log(It.IsAny <RequestLog>()), Times.Exactly(1)); Assert.Equal(Messages.Success, result.Code); }
public async Task <IActionResult> Test(TestQuery query) { Console.WriteLine("Testing"); query.GetUserIdentity(this); var result = await _mediator.Send(query); return(result.ToActionResult(this)); }
public async Task Dispatch_GivenQuery_ReturnsResultOfHandler() { var query = new TestQuery(5); var result = await _dispatcher.Dispatch(query); Assert.Equal(result, "5"); }
public WhenDispatchingStrongTypedQuery() { _query = new TestQuery(); _serviceProvider.Setup(p => p.GetService(typeof(IQueryHandler <TestQuery, string>))) .Returns(_handler.Object); _logger = New.Common().Logger <QueryDispatcher>(); _sut = new QueryDispatcher(_serviceProvider.Object, _logger.Creation); }
public void CanLoadQueryByRequestDto() { const string expectedOutput = @"select test_column from test_database..test_table"; var testQuery = new TestQuery(); var sql = testQuery.GetSqlQuery(); Assert.Equal(expectedOutput, sql); }
public async Task Handle_Success_Should_ExecuteHandler() { var mediator = _ServiceProvider.GetRequiredService <IMediator>(); var testQuery = new TestQuery(); var unit = await mediator.Send(testQuery); unit.Should().Be(Unit.Value); }
public void MessageService_Dispatches_Query_To_QueryHandler() { var messageService = new MessageService(UnityConfig.Container); var query = new TestQuery(); var result = messageService.Dispatch(query); result.Should().BeTrue(); }
public async Task QueryAsync_WhenCalledWithSupportedQueryType_AssertQueryAsyncWasCalledOnQueryHandler() { Mock <IQueryHandler <TestQuery, object> > queryHandlerMock = CreateQueryHandlerMock <TestQuery, object>(_fixture.Create <object>()); IQueryBus sut = CreateSut(CreateQueryHandlerMockCollection(queryHandlerMock.Object)); TestQuery testQuery = new TestQuery(); await sut.QueryAsync <TestQuery, object>(testQuery); queryHandlerMock.Verify(m => m.QueryAsync(It.Is <TestQuery>(cmd => cmd == testQuery)), Times.Once); }
public void TestAtQueryKalderQueryHandler() { var queryBus = new QueryBus(CreateContainer()); var query = new TestQuery(); var id = queryBus.Query <TestQuery, Guid>(query); Assert.That(id, Is.Not.Null); Assert.That(id.GetType(), Is.EqualTo(typeof(Guid))); Assert.That(id, Is.Not.EqualTo(Guid.Empty)); }
public void Should_create_empty_metadata() { //Arrange //Act var query = new TestQuery(null); //Assert query.Metadata.Should().NotBeNull(); }
public void Handles_queries() { var proj = CreateAndInitializeTestProjection(); var q = new TestQuery(); Sys.EventStream.Publish(new Query <TestQuery>(CreateTestProbe(), q, Timeout.In(1000))); ExpectMsg <TestQuery>(o => o == q); }
public void Serialize_Should_Include_Query_Type_To_Result() { IObjectSerializer SerializerTested = new JsonObjectSerializer(); string expectedJson = "TestQuery"; TestQuery query = new TestQuery(); string json = SerializerTested.Serialize(query); json.Should().StartWith(expectedJson); }
public async void Does_not_match_when_expression_doesnt() { actor .ExpectAsk<TestQuery>(x => x.Field == "foo" && x.AnotherField == "^_^") .Return(111); var query = new TestQuery {Field = "foo", AnotherField = "bar"}; Assert.AreEqual(default(int), await actor.Ask<int>(query)); }
public async void Matches_when_expression_match() { actor .ExpectAsk<TestQuery>(x => x.Field == "foo" && x.AnotherField == "bar") .Return(111); var query = new TestQuery {Field = "foo", AnotherField = "bar"}; Assert.That(await actor.Ask<int>(query), Is.EqualTo(111)); }
public void Context() { var container = Stub<IContainer>(); IoC.Initialize(container); _testQueryHandler = Mock<IQueryHandler<TestQuery>>(); _testQuery = new TestQuery(); _testQueryHandler.Expect(a => a.Execute<bool>(Arg<TestQuery>.Matches(p => p == _testQuery))).Return(new[] { true }); container.Stub(x => x.Resolve<IQueryHandler<TestQuery>>()).Return(_testQueryHandler); var queryExecutor = new QueryExecutor(); _result = queryExecutor.Execute<TestQuery, bool>(_testQuery); }
public async Task Query_using_eventstream_gets_response() { var responder = Sys.ActorOf(conf => { conf.Receive<IQuery<TestQuery>>((q, ctx) => q.Sender.Tell(new TestResponse { ID = q.Message.ID }, ctx.Self)); }); Sys.EventStream.Subscribe(responder, typeof(IQuery<TestQuery>)); var query = new TestQuery(); var response = await Sys.Query<TestResponse>(query, TimeSpan.FromSeconds(1)); Assert.Equal(query.ID, response.ID); }
public void Visit() { System.Linq.Expressions.Expression<Func<int, int, bool>> largeSumTestExpression = (num1, num2) => (num1 + num2) > 1000; Func<int, int, bool> largeSumTest = largeSumTestExpression.Compile(); TestDataObject obj = new TestDataObjectImpl() { StringProperty = "test", TestField = "test2" }; TestObj obj2 = new TestObj() { TestField = "Test2" }; TestQuery<TestDataObject> ctx = new TestQuery<TestDataObject>(); var list = from o in ctx where o.IntProperty == 1 && o.IntProperty != 2 && o.IntProperty > 3 && o.IntProperty == obj.ID && o.StringProperty == obj2.TestField && o.StringProperty == obj.StringProperty && o.StringProperty.StartsWith(obj2.TestField) && (o.StringProperty.StartsWith("test") || o.StringProperty == "test") && (o.StringProperty is string) && !o.BoolProperty && o.BoolProperty ? false : true && o.StringProperty == new DateTime().ToShortDateString() && new int[] { 1, obj.IntProperty }.Length == 2 && (obj.IntProperty + o.StringProperty.Length) == 4 && largeSumTest(o.IntProperty, o.IntProperty) select new { o.IntProperty, o.BoolProperty, Test = o.IntProperty * 2, Test2 = MethodCallTest(o.StringProperty.Length * 2), TestList = new int[] { o.IntProperty, o.ID, o.StringProperty.Length }, TestObj = new { o.BoolProperty, o.ID }, Date = new DateTime(1000), Test3 = obj.StringProperty, Test4 = new TestDataObjectImpl() { StringProperty = o.StringProperty, ID = MethodCallTest(o.IntProperty) }, Test5 = new List<TestDataObject> { new TestDataObjectImpl() { StringProperty = obj.StringProperty, ID = o.IntProperty }, new TestDataObjectImpl() { StringProperty = o.StringProperty, ID = MethodCallTest(o.IntProperty) } }, Test6 = MethodCallTest(2), Test7 = new List<TestDataObject>() { new TestDataObjectImpl(), obj }.Max(x => x.ID), }; // The TestProvider does not implement Projections // But in that case we just whant to test the visitor var result = list.GetEnumerator(); Assert.That(result, Is.Null); }
public async Task Query_using_actorpath_gets_response() { var responder = Sys.ActorOf(conf => { conf.Receive<IQuery<TestQuery>>((q, ctx) => ctx.Sender.Tell(new TestResponse { ID = q.Message.ID })); }); var path = responder.Path.ToString(); var query = new TestQuery(); var response = await Sys.Query<TestResponse>(ActorSelection(path), query, TimeSpan.FromSeconds(1)); Assert.Equal(query.ID, response.ID); }
public void CallTheInnerMediatorSend() { var mocks = new MockRepository(); var innerMediator = MockInnerMediator(); var query = new TestQuery(); innerMediator .Expect(m => m.Query(query)) .Return(new[] {0, 1, 2, 3, 4}) .Repeat.Once(); Mediator.Query(query); mocks.VerifyAll(); }
public void Setup() { _query = new TestQuery(); }
private SerializableExpression CreateExpression() { // Cannot use another ZetboxObject because in this tests we do not do any type transformations //TestDataObject obj = new TestDataObjectImpl(); TestObj obj2 = new TestObj(); TestQuery<TestDataObject> ctx = new TestQuery<TestDataObject>(); var list = from o in ctx where o.IntProperty == 1 && o.IntProperty != 2 && o.IntProperty > 3 //&& o.IntProperty == obj.ID && o.StringProperty == obj2.TestField //&& o.StringProperty == obj.StringProperty && o.StringProperty.StartsWith(obj2.TestField) && (o.StringProperty.StartsWith("test") || o.StringProperty == "test") && !o.BoolProperty select new { o.IntProperty, o.BoolProperty }; return Zetbox.API.SerializableExpression.FromExpression(list.Expression, iftFactory); }
public override void SetUp() { base.SetUp(); ctx = new TestQuery<IDataObject>(); }
public void Handles_queries() { var proj = CreateAndInitializeTestProjection(); var q = new TestQuery(); Sys.EventStream.Publish(new Query<TestQuery>(CreateTestProbe(), q, Timeout.In(1000))); ExpectMsg<TestQuery>(o => o == q); }