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