public async void Could_be_defined_via_attribute()
{
var actor = system.FreshActorOf <TestActor>();
Assert.That(await actor.Ask(new RegularMessage()), Is.False);
Assert.That(await actor.Ask(new ReentrantMessage()), Is.True);
}
public async void Client_to_actor()
{
var actor = system.FreshActorOf <TestActor>();
using (var observer = await Observer.Create())
{
await actor.Tell(new Attach { Observer = observer });
Notification @event = null;
var done = new AutoResetEvent(false);
var subscription = observer.Subscribe((Notification e) =>
{
@event = e;
done.Set();
});
await actor.Tell(new Publish { Text = "c-a" });
done.WaitOne(TimeSpan.FromSeconds(5));
Assert.That(@event.Text, Is.EqualTo("c-a"));
subscription.Dispose();
await actor.Tell(new Publish { Text = "kaboom" });
done.WaitOne(TimeSpan.FromSeconds(5));
Assert.That(@event.Text, Is.EqualTo("c-a"));
}
}
public void Client_to_actor()
{
var actor = system.FreshActorOf <TestActor>();
Assert.Throws <ApplicationException>(async() => await
actor.Tell(new Throw(new ApplicationException("c-a"))));
}
public async void Client_to_actor()
{
var actor = system.FreshActorOf <TestActor>();
await actor.Tell(new SetText { Text = "c-a" });
Assert.AreEqual("c-a", await actor.Ask(new GetText()));
}
public async Task When_setting_interleaved_one_off_timer()
{
var actor = system.FreshActorOf <ITestInterleavedTimerMessageActor>();
await actor.Tell(new SetOneOffTimer());
await Try.Until(async() => await actor.Ask(new NumberOfTimesTimerTicked()) == 1);
}
public async void When_just_activated()
{
var actor = system.FreshActorOf <TestActor>();
var hashcode = await actor.Ask(new GetInstanceHashcode());
await Task.Delay(TimeSpan.FromMinutes(1.5));
Assert.AreEqual(hashcode, await actor.Ask(new GetInstanceHashcode()),
"Should respect per-type keepalive timeout and not being GC'ed as per global keepalive timeout");
}
public async Task Activation_is_idempotent()
{
var actor = system.FreshActorOf <ITestActor>();
await actor.Activate();
await actor.Activate();
Assert.AreEqual(1, await actor.Ask(new Activated()));
}
public async Task When_setting_interleaved_one_off_timer()
{
var actor = system.FreshActorOf <ITestInterleavedTimerMessageActor>();
await actor.Tell(new SetOneOffTimer());
Thread.Sleep(100);
Assert.AreEqual(1, await actor.Ask(new NumberOfTimesTimerTicked()));
}
public async Task When_unregistering_never_registered()
{
var actor = system.FreshActorOf <TestActor>();
Assert.DoesNotThrow(async() => await actor.Tell(new UnregisterReminder {
Name = "unknown"
}));
actor = system.FreshActorOf <TestActor>();
Assert.False(await actor.Ask(new IsReminderRegistered {
Name = "unknown"
}));
Assert.DoesNotThrow(async() => await actor.Tell(new UnregisterReminder {
Name = "unknown"
}));
}
public async Task Client_to_actor()
{
var actor = system.FreshActorOf <TestActor>();
var @interface = await actor.Ask(new CheckTypeCodeResolution());
Assert.That(@interface, Is.EqualTo("Orleankka.Features.System_introspection.ITestActor"));
}
public async void Client_to_actor()
{
var actor = system.FreshActorOf <TestActor>();
using (var observer = await Observer.Create())
{
await actor.Tell(new Attach(observer));
ActorRef sender = null;
TextChanged @event = null;
var done = new AutoResetEvent(false);
var subscription = observer.Subscribe(notification =>
{
sender = notification.Sender;
@event = (TextChanged)notification.Message;
done.Set();
});
await actor.Tell(new SetText("c-a"));
done.WaitOne(TimeSpan.FromSeconds(5));
Assert.That(sender, Is.EqualTo(actor));
Assert.That(@event.Text, Is.EqualTo("c-a"));
subscription.Dispose();
await actor.Tell(new SetText("kaboom"));
done.WaitOne(TimeSpan.FromSeconds(5));
Assert.That(@event.Text, Is.EqualTo("c-a"));
}
}
public async void When_using_default_storage_service()
{
var actor = system.FreshActorOf <TestActor>();
await actor.Tell(new SetState { Data = "foo" });
Assert.AreEqual("foo", await actor.Ask(new GetState()));
}
public async Task When_setting_one_off_timer()
{
var actor = system.FreshActorOf <TestActor>();
await actor.Tell(new SetOneOffTimer());
Thread.Sleep(100);
Assert.AreEqual(1, await actor.Ask(new NumberOfTimesTimerFired()));
}
public async void When_reminder_is_fired_an_instance_of_correct_actor_type_should_be_activated()
{
var actor = system.FreshActorOf <TestActor>();
var hashcode = await actor.Ask <long>(new GetInstanceHashcode());
await actor.Tell(new SetReminder());
await Task.Delay(TimeSpan.FromSeconds(90));
Assert.True(await actor.Ask <bool>(new HasBeenReminded()));
Assert.AreNotEqual(hashcode, await actor.Ask <long>(new GetInstanceHashcode()));
}
public async Task When_reminder_is_fired_an_instance_of_correct_actor_type_should_be_activated()
{
var actor = system.FreshActorOf <ITestActor>();
var hashcode = await(result(new InstanceHashcode()) > actor);
await(actor < new SetReminder(TimeSpan.FromMinutes(1.5)));
await(actor < new Kill());
await Task.Delay(TimeSpan.FromMinutes(2.0));
Assert.True(await(result(new HasBeenReminded()) > actor));
Assert.AreNotEqual(hashcode, await actor.Ask(new InstanceHashcode()));
}
public async Task Client_to_actor()
{
var actor = system.FreshActorOf <ITestActor>();
await actor.Tell(new SetText { Text = "c-a" });
Assert.AreEqual("c-a.intercepted", await actor.Ask(new GetText()));
}
public async Task When_reminder_is_fired_an_instance_of_correct_actor_type_should_be_activated()
{
var actor = system.FreshActorOf <TestActor>();
var hashcode = await actor.Ask(new GetInstanceHashcode());
await actor.Tell(new SetReminder { Period = TimeSpan.FromMinutes(1.5) });
await actor.Tell(new Deactivate());
await Task.Delay(TimeSpan.FromMinutes(2.0));
Assert.True(await actor.Ask <bool>(new HasBeenReminded()));
Assert.AreNotEqual(hashcode, await actor.Ask(new GetInstanceHashcode()));
}
public async void When_using_custom_actor_storage_service()
{
var actor = system.FreshActorOf <TestActor>();
var expected = new List <string>
{
$"ReadStateAsync:{typeof(TestActor).FullName}:{actor.Path.Id}", // by default on activate
$"ReadStateAsync:{typeof(TestActor).FullName}:{actor.Path.Id}",
$"WriteStateAsync:{typeof(TestActor).FullName}:{actor.Path.Id}",
};
var invocations = await actor.Ask(new GetStorageProviderInvocations());
CollectionAssert.AreEqual(expected, invocations);
await actor.Tell(new ClearState());
Assert.That(await actor.Ask(new GetStorageProviderInvocations()),
Has.Count.EqualTo(0));
}
public static TypedActorRef <TActor> FreshTypedActorOf <TActor>(this IActorSystem system) where TActor : TypedActor
{
return(new TypedActorRef <TActor>(system.FreshActorOf <TActor>()));
}
public async Task When_reentrant_determined_by_message_type()
{
var actor = system.FreshActorOf <TestActor>();
await TestReentrantReceive(actor);
}