public void TestAfterAndThenCompletesForSideEffects()
{
var greetingsTestResults = TestResults.AfterCompleting(1);
var uc = World.ActorFor <IUsesCompletes>(typeof(UsesCompletesActor), greetingsTestResults);
var helloCompletes = uc.GetHello();
helloCompletes
.AndThen(hello => new Hello(Prefix + hello.Greeting))
.AndThenConsume(hello => greetingsTestResults.SetGreeting(hello.Greeting));
Assert.NotEqual(Hello, greetingsTestResults.GetGreeting());
Assert.NotEqual(Hello, helloCompletes.Outcome.Greeting);
Assert.Equal(Prefix + Hello, greetingsTestResults.GetGreeting());
Assert.Equal(Prefix + Hello, helloCompletes.Outcome.Greeting);
var valueTestResults = TestResults.AfterCompleting(1);
var one = uc.GetOne();
one
.AndThen(value => value + 1)
.AndThenConsume(value => valueTestResults.SetValue(value));
Assert.NotEqual(1, valueTestResults.GetValue());
Assert.NotEqual(1, one.Outcome);
Assert.Equal(2, valueTestResults.GetValue());
Assert.Equal(2, one.Outcome);
}
public void TestThreeArgConsumerProtocol()
{
var poolSize = 4;
var rounds = 2;
var messagesToSend = poolSize * rounds;
var totalMessagesExpected = messagesToSend * poolSize;
var testResults = TestResults.AfterCompleting(totalMessagesExpected);
var testRouter = TestWorld.ActorFor <IThreeArgConsumerProtocol>(
Definition.Has <MathCommandRouter>(Definition.Parameters(poolSize, testResults)));
for (var round = 0; round < messagesToSend; ++round)
{
testRouter.Actor.DoSomeMath(round, round, round);
}
Assert.Equal(totalMessagesExpected, testResults.GetReceivedCount());
var routerActor = (MathCommandRouter)testRouter.ActorInside;
foreach (var routee in routerActor.Routees)
{
Assert.Equal(messagesToSend, routee.MessageCount);
}
}
public void TestThatVoidReturnTypeThrowsException()
{
var testResults = TestResults.AfterCompleting(1);
var uc = World.ActorFor <IUsesCompletes>(typeof(UsesCompletesActor), testResults);
uc.CompletesNotSupportedForVoidReturnType();
Assert.True(testResults.GetExceptionThrown());
}
public void TestBeforeStart()
{
var testResults = TestResults.AfterCompleting(1);
var actor = World.ActorFor <IStoppable>(typeof(LifecycleActor), testResults);
Assert.True(testResults.GetReceivedBeforeStart());
Assert.False(testResults.GetReceivedAfterStop());
}
public void TestReturnsCompletesForSideEffects()
{
var testResults = TestResults.AfterCompleting(2);
var uc = World.ActorFor <IUsesCompletes>(typeof(UsesCompletesActor), testResults);
uc.GetHello().AndThenConsume(hello => testResults.SetGreeting(hello.Greeting));
uc.GetOne().AndThenConsume(value => testResults.SetValue(value));
Assert.Equal(Hello, testResults.GetGreeting());
Assert.Equal(1, testResults.GetValue());
}
public void TestThatTimeOutOccursForSideEffects()
{
var greetingsTestResults = TestResults.AfterCompleting(1);
var uc = World.ActorFor <IUsesCompletes>(typeof(UsesCompletesCausesTimeoutActor), greetingsTestResults);
var helloCompletes = uc.GetHello()
.AndThenConsume(TimeSpan.FromMilliseconds(1), new Hello(HelloNot), hello => greetingsTestResults.SetGreeting(hello.Greeting))
.Otherwise <Hello>(failedHello =>
{
greetingsTestResults.SetGreeting(failedHello.Greeting, true);
return(failedHello);
});
Assert.NotEqual(Hello, greetingsTestResults.GetGreeting(true));
Assert.Equal(HelloNot, helloCompletes.Outcome.Greeting);
var valueTestResults = TestResults.AfterCompleting(1);
var oneCompletes = uc.GetOne()
.AndThenConsume(TimeSpan.FromMilliseconds(1), 0, value => valueTestResults.SetValue(value))
.Otherwise <int>(value =>
{
valueTestResults.SetValue(value, true);
return(0);
});
var thread = new Thread(() =>
{
Thread.Sleep(1500);
oneCompletes.With(1);
});
thread.Start();
Assert.NotEqual(1, valueTestResults.GetValue(true));
Assert.Equal(0, valueTestResults.GetValue(true));
Assert.Equal(0, oneCompletes.Outcome);
}
