public void TestThatEmployeeIdentifiesModifiesRecovers()
{
var employeeNumber = "12345";
var employee = _world.ActorFor <IEmployee>(() => new EmployeeEntity(employeeNumber));
var state1 = employee.Hire(50000).Await();
Assert.True(state1.PersistenceId > 0);
Assert.Equal(employeeNumber, state1.Number);
Assert.Equal(50000, state1.Salary);
var state3 = employee.Adjust(55000).Await();
Assert.Equal(state1.PersistenceId, state3.PersistenceId);
Assert.Equal(employeeNumber, state3.Number);
Assert.Equal(55000, state3.Salary);
var employeeRecovered = _world.ActorFor <IEmployee>(typeof(EmployeeEntity), employeeNumber);
var state4 = employeeRecovered.Current().Await();
Assert.Equal(state3, state4);
// TODO: test reading event entries
}
public void TestThatStatefulEntityPreservesRestores()
{
RaceConditions.Set(0);
var entityId = $"{_idGenerator.Next(10_000)}";
var state = new Entity1State(entityId, "Sally", 23);
var entity1 = _world.ActorFor <IEntity1>(() => new Entity1Actor(RaceConditions, entityId));
Assert.Equal(state, entity1.DefineWith(state.Name, state.Age).Await());
Assert.Equal(state, entity1.Current().Await());
entity1.ChangeName("Sally Jane");
var newState = entity1.Current().Await();
Assert.Equal("Sally Jane", newState.Name);
entity1.IncreaseAge();
newState = entity1.Current().Await();
Assert.Equal(24, newState.Age);
var restoredEntity1 = _world.ActorFor <IEntity1>(() => new Entity1Actor(RaceConditions, entityId));
var restoredEntity1State = restoredEntity1.Current().Await();
Assert.NotNull(restoredEntity1State);
// check whether race conditions have been reproduced
Assert.Equal(0, RaceConditions.Get());
}
public EventSourcedTest(ITestOutputHelper output)
{
var converter = new Converter(output);
Console.SetOut(converter);
var testWorld = TestWorld.StartWithDefaults("test-es");
_world = testWorld.World;
_dispatcher = new MockJournalDispatcher();
var entryAdapterProvider = EntryAdapterProvider.Instance(_world);
entryAdapterProvider.RegisterAdapter(new Test1HappenedAdapter());
entryAdapterProvider.RegisterAdapter(new Test2HappenedAdapter());
entryAdapterProvider.RegisterAdapter(new Test3HappenedAdapter());
var journal = _world.ActorFor <IJournal <string> >(() => new InMemoryJournalActor <string>(_dispatcher));
var registry = new SourcedTypeRegistry(_world);
registry.Register(Info.RegisterSourced <TestEventSourcedEntity>(journal));
registry.Register(Info.RegisterSourced <ProductEntity>(journal));
registry.Register(Info.RegisterSourced <ProductParent>(journal));
registry.Register(Info.RegisterSourced <ProductGrandparent>(journal));
_result = new Result();
_entity = _world.ActorFor <IEntity>(() => new TestEventSourcedEntity(_result));
}
private IChildCreatingStoppable[] SetUpActors(World world, TestResults results)
{
var stoppables = new IChildCreatingStoppable[3];
stoppables[0] = world.ActorFor <IChildCreatingStoppable>(Definition.Has <ChildCreatingStoppableActor>(Definition.Parameters(results), "p1"));
stoppables[1] = world.ActorFor <IChildCreatingStoppable>(Definition.Has <ChildCreatingStoppableActor>(Definition.Parameters(results), "p2"));
stoppables[2] = world.ActorFor <IChildCreatingStoppable>(Definition.Has <ChildCreatingStoppableActor>(Definition.Parameters(results), "p3"));
return(stoppables);
}
public void TestFiveStepSendingProcess()
{
var process = _world.ActorFor <IFiveStepProcess>(() => new FiveStepSendingSourcedProcess());
_exchangeReceivers.SetProcess(process);
_exchange.Send(new DoStepOne());
Assert.Equal(5, _exchangeReceivers.Access.ReadFrom <int>("stepCount"));
Assert.Equal(5, process.QueryStepCount().Await());
}
public StatefulProcessTest(ITestOutputHelper output)
{
var converter = new Converter(output);
Console.SetOut(converter);
_world = World.StartWithDefaults("five-step-process-test");
var queue = new AsyncMessageQueue(null);
_exchange = new LocalExchange(queue);
_dispatcher = new MockTextDispatcher();
var stateStore = _world.ActorFor<IStateStore>(() => new InMemoryStateStoreActor<TextState>(new List<IDispatcher> {_dispatcher}));
var statefulTypeRegistry = new StatefulTypeRegistry(_world);
var stepCountStateInfo = new Vlingo.Xoom.Lattice.Model.Stateful.Info(stateStore, typeof(StepCountState), stateStore.GetType().Name);
statefulTypeRegistry.Register(stepCountStateInfo);
_exchangeReceivers = new ExchangeReceivers();
_exchangeSender = new LocalExchangeSender(queue);
var processTypeRegistry = new ProcessTypeRegistry(_world);
processTypeRegistry.Register(new StatefulProcessInfo<FiveStepEmittingStatefulProcess, StepCountState>(nameof(FiveStepEmittingStatefulProcess), _exchange, statefulTypeRegistry));
RegisterExchangeCoveys();
}
public void TestSuspendResume()
{
var supervisor = World.ActorFor <IFailureControlSender>(
Definition.Has <SuspendedSenderSupervisorActor>(Definition.NoParameters, "suspended-sender-supervisor"));
var failureControlTestResults = new FailureControlActor.FailureControlTestResults();
var failure = World.ActorFor <IFailureControl>(
Definition.Has <FailureControlActor>(
Definition.Parameters(failureControlTestResults),
SuspendedSenderSupervisorActor.Instance.Value,
"queueArray",
"failure"));
var times = 25;
failureControlTestResults.UntilFailNow = Until(1);
SuspendedSenderSupervisorActor.Instance.Value.UntilInformed = Until(1);
failureControlTestResults.UntilFailureCount = Until(times - 1);
supervisor.SendUsing(failure, times);
failure.FailNow();
failureControlTestResults.UntilFailNow.Completes();
SuspendedSenderSupervisorActor.Instance.Value.UntilInformed.Completes();
failureControlTestResults.UntilFailureCount.Completes();
Assert.Equal(1, SuspendedSenderSupervisorActor.Instance.Value.InformedCount.Get());
Assert.True(failureControlTestResults.AfterFailureCount.Get() >= times - 1);
}
public void TestStopAll()
{
World.ActorFor <ISupervisor>(Definition.Has <StopAllSupervisorActor>(Definition.NoParameters, "stop-all"));
var pingTestResults = new PingActor.PingTestResults();
var ping = World.ActorFor <IPing>(
Definition.Has <PingActor>(
Definition.Parameters(pingTestResults), StopAllSupervisorActor.Instance.Value, "ping"));
var pongTestResults = new PongActor.PongTestResults();
var pong = World.ActorFor <IPong>(
Definition.Has <PongActor>(
Definition.Parameters(pongTestResults), StopAllSupervisorActor.Instance.Value, "pong"));
pingTestResults.UntilStopped = Until(1);
pongTestResults.UntilStopped = Until(1);
Assert.False(PingActor.Instance.Value.IsStopped);
Assert.False(PongActor.Instance.Value.IsStopped);
ping.Ping();
pingTestResults.UntilStopped.Completes();
pongTestResults.UntilStopped.Completes();
Assert.True(PingActor.Instance.Value.IsStopped);
Assert.True(PongActor.Instance.Value.IsStopped);
}
public void TestThatTimeOutOccursForSideEffects()
{
var uc = World.ActorFor <IUsesCompletes>(Definition.Has <UsesCompletesCausesTimeoutActor>(Definition.NoParameters));
var helloCompletes = uc.GetHello()
.AndThenConsume(2, new Hello(HelloNot), hello => SetHello(hello.greeting))
.Otherwise(failedHello =>
{
SetHello(failedHello.greeting);
return(failedHello);
});
untilHello.Completes();
Assert.NotEqual(Hello, greeting);
Assert.Equal(HelloNot, helloCompletes.Outcome.greeting);
var oneCompletes = uc.GetOne()
.AndThenConsume(2, 0, value => SetValue(value))
.Otherwise(value =>
{
untilOne.Happened();
return(0);
});
untilOne.Completes();
Assert.NotEqual(1, value);
Assert.Equal(0, oneCompletes.Outcome);
}
public void TestAfterAndThenCompletesForSideEffects()
{
var uc = World.ActorFor <IUsesCompletes>(Definition.Has <UsesCompletesActor>(Definition.NoParameters));
var helloCompletes = uc.GetHello();
helloCompletes
.AndThen(hello => new Hello(Prefix + helloCompletes.Outcome.greeting))
.AndThenConsume(hello => SetHello(hello.greeting));
untilHello.Completes();
Assert.NotEqual(Hello, helloCompletes.Outcome.greeting);
Assert.NotEqual(Hello, greeting);
Assert.Equal(Prefix + Hello, helloCompletes.Outcome.greeting);
Assert.Equal(Prefix + Hello, greeting);
var one = uc.GetOne();
one
.AndThen(value => one.Outcome + 1)
.AndThenConsume(value => SetValue(value));
untilOne.Completes();
Assert.NotEqual(1, one.Outcome);
Assert.NotEqual(1, value);
Assert.Equal(2, one.Outcome);
Assert.Equal(2, value);
}
public InMemoryStateStoreTest(ITestOutputHelper output)
{
var converter = new Converter(output);
Console.SetOut(converter);
var testWorld = TestWorld.StartWithDefaults("test-store");
_world = testWorld.World;
_interest = new MockStateStoreResultInterest();
_dispatcher = new MockStateStoreDispatcher <TextEntry, TextState>(_interest);
var stateAdapterProvider = new StateAdapterProvider(_world);
new EntryAdapterProvider(_world);
stateAdapterProvider.RegisterAdapter(new Entity1StateAdapter());
// NOTE: No adapter registered for Entity2.class because it will use the default
_store = _world.ActorFor <IStateStore <TextEntry> >(typeof(InMemoryStateStoreActor <TextState, TextEntry>), _dispatcher);
StateTypeStateStoreMap.StateTypeToStoreName(_storeName1, typeof(Entity1));
StateTypeStateStoreMap.StateTypeToStoreName(_storeName2, typeof(Entity2));
}
public void TestTwoArgConsumerProtocol()
{
var poolSize = 4;
var rounds = 2;
var messagesToSend = poolSize * rounds;
var results = new Results(messagesToSend);
var router = World.ActorFor <ITwoArgSupplierProtocol>(typeof(TestRouterActor), poolSize);
for (var i = 0; i < messagesToSend; i++)
{
router
.ProductOf(i, i)
.AndThenConsume(answer => results.Access.WriteUsing("answers", answer));
}
var allExpected = new List <int>();
for (var round = 0; round < messagesToSend; round++)
{
int expected = round * round;
allExpected.Add(expected);
}
for (var round = 0; round < messagesToSend; round++)
{
int actual = results.Access.ReadFrom <int, int>("answers", round);
Assert.True(allExpected.Remove(actual));
}
Assert.Empty(allExpected);
}
public void TestSuspendResume()
{
var testResults = new SuspendedSenderSupervisorResults();
var failureControlSender = World.ActorFor <IFailureControlSender>(
Definition.Has <SuspendedSenderSupervisorActor>(Definition.Parameters(testResults), "suspended-sender-supervisor"));
var failureControlTestResults = new FailureControlActor.FailureControlTestResults();
var failure = World.ActorFor <IFailureControl>(
Definition.Has <FailureControlActor>(
Definition.Parameters(failureControlTestResults),
SuspendedSenderSupervisorActor.Instance.Value,
"queueArray",
"failure"));
var times = 25;
var failureAccess = failureControlTestResults.AfterCompleting(times);
var supervisorAccess = testResults.AfterCompleting(1);
failureControlSender.SendUsing(failure, times);
failure.FailNow();
Assert.Equal(1, supervisorAccess.ReadFromExpecting("informedCount", 1));
Assert.Equal(times, failureAccess.ReadFromExpecting("afterFailureCountCount", times));
}
public ProjectionDispatcherTest(ITestOutputHelper output)
{
var converter = new Converter(output);
Console.SetOut(converter);
World = World.StartWithDefaults("test-store");
var stateAdapterProvider = new StateAdapterProvider(World);
stateAdapterProvider.RegisterAdapter(new Entity1StateAdapter());
new EntryAdapterProvider(World);
StateTypeStateStoreMap.StateTypeToStoreName(nameof(Entity1), typeof(Entity1));
StateTypeStateStoreMap.StateTypeToStoreName(nameof(Entity2), typeof(Entity2));
var dispatcherProtocols =
World.Stage.ActorFor(
new[] { DispatcherInterfaceType, typeof(IProjectionDispatcher) }, ProjectionDispatcherType);
var dispatchers = Protocols.Two <IDispatcher, IProjectionDispatcher>(dispatcherProtocols);
Dispatcher = dispatchers._1;
ProjectionDispatcher = dispatchers._2;
var storeProtocols =
World.ActorFor(
new[] { StateStoreInterfaceType, typeof(IDispatcherControl) },
typeof(InMemoryStateStoreActor <TextState>), Dispatcher);
var storeWithControl = Protocols.Two <IStateStore, IDispatcherControl>(storeProtocols);
Store = storeWithControl._1;
DispatcherControl = storeWithControl._2;
}
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 InMemoryStateStoreRedispatchControlTest(ITestOutputHelper output)
{
var converter = new Converter(output);
Console.SetOut(converter);
_world = World.StartWithDefaults("test-store");
_interest = new MockStateStoreResultInterest();
_interest.AfterCompleting <string, Entity1>(0);
_dispatcher = new MockStateStoreDispatcher <TextState>(_interest);
var stateAdapterProvider = new StateAdapterProvider(_world);
new EntryAdapterProvider(_world);
stateAdapterProvider.RegisterAdapter(new Entity1StateAdapter());
// NOTE: No adapter registered for Entity2.class because it will use the default
StateTypeStateStoreMap.StateTypeToStoreName(typeof(Entity1).FullName, typeof(Entity1));
_store = _world.ActorFor <IStateStore>(typeof(InMemoryStateStoreActor <TextState>), new List <IDispatcher> {
_dispatcher
});
}
public void TestSupplierProtocol()
{
var poolSize = 4;
var rounds = 2;
var messagesToSend = poolSize * rounds;
var results = new Results(messagesToSend);
var router = World.ActorFor <IOneArgSupplierProtocol>(Definition.Has <TestSupplierActor>(Definition.Parameters(poolSize)));
for (var i = 0; i < messagesToSend; i++)
{
var round = i;
router
.CubeOf(round)
.AndThenConsume(answer => results.Access.WriteUsing("answers", answer));
}
var allExpected = new List <int>();
for (var round = 0; round < messagesToSend; round++)
{
int expected = round * round * round;
allExpected.Add(expected);
}
for (var round = 0; round < messagesToSend; round++)
{
int actual = results.Access.ReadFrom <int, int>("answers", round);
Assert.True(allExpected.Remove(actual));
}
Assert.Empty(allExpected);
}
public void TestThatManyScheduleOnceDeliver()
{
var query = World.ActorFor <IFinalCountQuery>(typeof(OnceScheduled), 10);
var count = query.QueryCount().Await <int>();
Assert.Equal(10, count);
}
public void TestConsumerProtocol()
{
var poolSize = 4;
var rounds = 2;
var messagesToSend = poolSize * rounds;
var results = new Results(messagesToSend);
var router = World.ActorFor <IOneArgConsumerProtocol>(typeof(TestConsumerActor), results, poolSize);
for (var i = 0; i < messagesToSend; i++)
{
router.Remember(i);
}
var allExpected = new List <int>();
for (var round = 0; round < messagesToSend; round++)
{
allExpected.Add(round);
}
for (var round = 0; round < messagesToSend; round++)
{
Assert.True(allExpected.Remove(round));
}
Assert.Empty(allExpected);
}
public void TestStopAll()
{
var stopResults = new StopAllSupervisorResult();
World.ActorFor <ISupervisor>(Definition.Has <StopAllSupervisorActor>(Definition.Parameters(stopResults), "stop-all"));
var pingTestResults = new PingActor.PingTestResults();
var ping = World.ActorFor <IPing>(
Definition.Has <PingActor>(
Definition.Parameters(pingTestResults), StopAllSupervisorActor.Instance.Value, "ping"));
var pongTestResults = new PongActor.PongTestResults();
var pong = World.ActorFor <IPong>(
Definition.Has <PongActor>(
Definition.Parameters(pongTestResults), StopAllSupervisorActor.Instance.Value, "pong"));
var pingAccess = pingTestResults.AfterCompleting(1);
var pongAccess = pongTestResults.AfterCompleting(1);
var stopAccess = stopResults.AfterCompleting(1);
ping.Ping();
Assert.Equal(1, stopAccess.ReadFrom <int>("informedCount"));
Assert.Equal(1, pingAccess.ReadFrom <int>("stopCount"));
Assert.Equal(1, pongAccess.ReadFrom <int>("stopCount"));
}
[Fact]//(Skip = "Need explanation of why it should timeout")]
public void TestThatTimeOutOccursForSideEffects()
{
var greetingsTestResults = TestResults.AfterCompleting(1);
var uc = World.ActorFor <IUsesCompletes>(typeof(UsesCompletesCausesTimeoutActor), greetingsTestResults);
var helloCompletes = uc.GetHello()
.AndThenConsume(TimeSpan.FromMilliseconds(2), new Hello(HelloNot), hello => greetingsTestResults.SetGreeting(hello.greeting))
.Otherwise(failedHello =>
{
greetingsTestResults.SetGreeting(failedHello.greeting);
return(failedHello);
});
Assert.NotEqual(Hello, greetingsTestResults.GetGreeting());
Assert.Equal(HelloNot, helloCompletes.Outcome.greeting);
var valueTestResults = TestResults.AfterCompleting(1);
var oneCompletes = uc.GetOne()
.AndThenConsume(TimeSpan.FromMilliseconds(2), 0, value => valueTestResults.SetValue(value))
.Otherwise(value =>
{
valueTestResults.SetValue(value);
return(0);
});
try { Thread.Sleep(100); } catch (Exception) { }
oneCompletes.With(1);
Assert.NotEqual(1, valueTestResults.GetValue());
Assert.Equal(0, oneCompletes.Outcome);
}
public async Task TestThatTaskLikeCompletesCanBeAwaited()
{
var uc = World.ActorFor <IUsesTask>(() => new UsesTaskActor());
var two = await uc.GetTwoAsync();
Assert.Equal(2, two);
}
public async Task TestThatSchedulesLongRunningOperations()
{
var uc = World.ActorFor <IUsesTask>(() => new UsesLongRunningTaskActor());
var one = await uc.GetOne();
Assert.Equal(1, one);
}
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 TestOutcomeInterestSuccess()
{
var test = World.ActorFor <ITestsOutcomeAware>(Definition.Has <DoSomethingOutcomeAwareActor>(Definition.NoParameters));
test.DoSomething();
Thread.Sleep(500);
}
public async Task TestThatMailboxDoesntDeliverWhileAwaiting()
{
var uc = World.ActorFor <IUsesTask>(typeof(UsesTaskActor));
var one = await uc.GetOne();
uc.Change(10);
Assert.Equal(1, one);
}
public void TestThatVoidReturnTypeThrowsException()
{
var testResults = TestResults.AfterCompleting(1);
var uc = World.ActorFor <IUsesCompletes>(typeof(UsesCompletesActor), testResults);
uc.CompletesNotSupportedForVoidReturnType();
Assert.True(testResults.GetExceptionThrown());
}
public void TestWorldNoDefintionActorFor()
{
var testResults = new TestResults(1);
var simple = World.ActorFor <ISimpleWorld>(typeof(SimpleActor), testResults);
simple.SimpleSay();
Assert.True(testResults.Invoked);
}
public void TestWorldActorForFlat()
{
var testResults = new TestResults(1);
var simple = World.ActorFor <ISimpleWorld>(Definition.Has(() => new SimpleActor(testResults)));
simple.SimpleSay();
Assert.True(testResults.Invoked);
}
public void TestWorldActorForDefintion()
{
var testResults = new TestResults(1);
var simple = World.ActorFor <ISimpleWorld>(Definition.Has <SimpleActor>(Definition.Parameters(testResults)));
simple.SimpleSay();
Assert.True(testResults.Invoked);
}