public async Task ActorMultipleTest()
{
int count = 0;
using IActorHost actorHost = new ActorHost(_loggerFactory)
.Register <ICache>(() => new StringCache(y => count += y));
ActorKey key1 = new ActorKey("Cache/Test1");
ICache cache1 = actorHost.GetActor <ICache>(key1);
count.Should().Be(1);
ActorKey key2 = new ActorKey("Cache/Test2");
ICache cache2 = actorHost.GetActor <ICache>(key2);
count.Should().Be(2);
(await actorHost.Deactivate <ICache>(key1)).Should().BeTrue();
count.Should().Be(1);
(await actorHost.Deactivate <ICache>(key2)).Should().BeTrue();
count.Should().Be(0);
await actorHost.DeactivateAll();
}
public async Task Given2Actors_WhenCreatedAndDeletedDifferentTask_ShouldPass()
{
int count = 0;
int count2 = 0;
const int max = 10;
const int maxLoop = 10;
using IActorHost actorHost = new ActorHost(_loggerFactory)
.Register <ICache>(() => new StringCache(y => CountControl(ref count, y)))
.Register <ICache2>(() => new StringCache2(y => CountControl(ref count2, y)));
for (int loop = 0; loop < maxLoop; loop++)
{
_output.WriteLine($"Loop: {loop}");
await Enumerable.Range(0, max)
.Select(x => new Task[]
{
Task.Run(() => {
ActorKey key = new ActorKey($"cache/test/{x}");
ICache cache = actorHost.GetActor <ICache>(key);
cache.GetActorKey().Should().Be(key);
cache.GetActorHost().Should().Be(actorHost);
}),
Task.Run(() => {
ActorKey key2 = new ActorKey($"cache/test/{x}");
ICache2 cache2 = actorHost.GetActor <ICache2>(key2);
cache2.GetActorKey().Should().Be(key2);
cache2.GetActorHost().Should().Be(actorHost);
}),
})
.SelectMany(x => x)
.WhenAll();
count.Should().Be(max);
count2.Should().Be(max);
await Enumerable.Range(0, max)
.Select(x => new Task <bool>[]
{
Task.Run(async() => await actorHost.Deactivate <ICache>(new ActorKey($"cache/test/{x}"))),
Task.Run(async() => await actorHost.Deactivate <ICache2>(new ActorKey($"cache/test/{x}"))),
})
.SelectMany(x => x)
.WhenAll();
count.Should().Be(0);
count2.Should().Be(0);
await actorHost.DeactivateAll();
count.Should().Be(0);
count2.Should().Be(0);
}
}
public async Task ActorMethodTest()
{
int count = 0;
using IActorHost actorHost = new ActorHost(_loggerFactory)
.Register <ICache>(() => new StringCache(y => count += y));
ActorKey key1 = new ActorKey("Cache/Test1");
ICache cache1 = actorHost.GetActor <ICache>(key1);
count.Should().Be(1);
const string firstText = "first";
bool test = await cache1.IsCached(firstText);
test.Should().BeFalse();
await cache1.Add(firstText);
test = await cache1.IsCached(firstText);
test.Should().BeTrue();
(await actorHost.Deactivate <ICache>(key1)).Should().BeTrue();;
count.Should().Be(0);
await actorHost.DeactivateAll();
}
public async Task Given2Actors_WhenCreatedAndDeletedDifferentKeyRange_ShouldPass()
{
int count = 0;
int count2 = 0;
const int max = 1000;
const int maxLoop = 10;
using IActorHost actorHost = new ActorHost(100000, _loggerFactory)
.Register <ICache>(() => new StringCache(y => CountControl(ref count, y)))
.Register <ICache2>(() => new StringCache2(y => CountControl(ref count2, y)));
for (int loop = 0; loop < maxLoop; loop++)
{
_output.WriteLine($"Loop: {loop}");
await Enumerable.Range(0, max)
.Select((x, i) => new Task[]
{
Task.Run(() => actorHost.GetActor <ICache>(new ActorKey($"cache/test/{i}"))),
Task.Run(() => actorHost.GetActor <ICache2>(new ActorKey($"cache/test/{i+100}"))),
})
.SelectMany(x => x)
.WhenAll();
count.Should().Be(max);
count2.Should().Be(max);
var results = await Enumerable.Range(0, max)
.Select((x, i) => new Task <bool>[]
{
Task.Run(async() => await actorHost.Deactivate <ICache>(new ActorKey($"cache/test/{i}"))),
Task.Run(async() => await actorHost.Deactivate <ICache2>(new ActorKey($"cache/test/{i+100}"))),
})
.SelectMany(x => x)
.WhenAll();
results.All(x => x == true).Should().BeTrue();
count.Should().Be(0);
count2.Should().Be(0);
await actorHost.DeactivateAll();
count.Should().Be(0);
count2.Should().Be(0);
}
}
public async Task Given2Actors_WhenCreatedAndDeleted_ShouldPass()
{
int count = 0;
int count2 = 0;
const int max = 10;
using IActorHost actorHost = new ActorHost(_loggerFactory)
.Register <ICache>(() => new StringCache(y => CountControl(ref count, y)))
.Register <ICache2>(() => new StringCache2(y => CountControl(ref count2, y)));
Enumerable.Range(0, max)
.ForEach(x =>
{
ActorKey key = new ActorKey($"cache/test/{x}");
ICache cache = actorHost.GetActor <ICache>(key);
cache.GetActorKey().Should().Be(key);
cache.GetActorHost().Should().Be(actorHost);
ActorKey key2 = new ActorKey($"cache/test/{x}");
ICache2 cache2 = actorHost.GetActor <ICache2>(key2);
cache2.GetActorKey().Should().Be(key2);
cache2.GetActorHost().Should().Be(actorHost);
});
count.Should().Be(max);
count2.Should().Be(max);
await Enumerable.Range(0, max)
.Select(async x =>
{
ActorKey key = new ActorKey($"cache/test/{x}");
(await actorHost.Deactivate <ICache>(key)).Should().BeTrue();
ActorKey key2 = new ActorKey($"cache/test/{x}");
(await actorHost.Deactivate <ICache2>(key2)).Should().BeTrue();
})
.WhenAll();
count.Should().Be(0);
count2.Should().Be(0);
await actorHost.DeactivateAll();
count.Should().Be(0);
count2.Should().Be(0);
}
public async Task GivenActor_WhenMultipleCreated_KeyAndManagerShouldBeSet()
{
int count = 0;
using IActorHost actorHost = new ActorHost(_loggerFactory)
.Register <ICache>(() => new StringCache(y => count += y));
const int max = 10;
var keyList = new List <ActorKey>();
Enumerable.Range(0, max)
.ForEach((x, index) =>
{
ActorKey key = new ActorKey($"cache/test_{index}");
keyList.Add(key);
ICache cache = actorHost.GetActor <ICache>(key);
cache.GetActorKey().Should().Be(key);
cache.GetActorManager().Should().Be(actorHost);
});
count.Should().Be(max);
keyList
.ForEach(x =>
{
ICache cache = actorHost.GetActor <ICache>(x);
cache.GetActorKey().Should().Be(x);
cache.GetActorManager().Should().Be(actorHost);
});
count.Should().Be(max);
await keyList
.ForEachAsync(async x =>
{
(await actorHost.Deactivate <ICache>(x)).Should().BeTrue();
});
count.Should().Be(0);
await actorHost.DeactivateAll();
count.Should().Be(0);
}
public async Task GivenActor_WhenCreatedDeactivated_CountsShouldFollowLifecycle()
{
int count = 0;
using IActorHost actorHost = new ActorHost(_loggerFactory)
.Register <ICache>(() => new StringCache(y => count += y));
ActorKey key = new ActorKey("cache/test");
ICache cache = actorHost.GetActor <ICache>(key);
count.Should().Be(1);
(await actorHost.Deactivate <ICache>(key)).Should().BeTrue();
count.Should().Be(0);
await actorHost.DeactivateAll();
count.Should().Be(0);
}
public async Task GivenActor_WhenCreated_KeyAndManagerShouldBeSet()
{
int count = 0;
using IActorHost actorHost = new ActorHost(_loggerFactory)
.Register <ICache>(() => new StringCache(y => count += y));
ActorKey key = new ActorKey("cache/test");
ICache cache = actorHost.GetActor <ICache>(key);
cache.GetActorKey().Should().Be(key);
cache.GetActorManager().Should().Be(actorHost);
count.Should().Be(1);
(await actorHost.Deactivate <ICache>(key)).Should().BeTrue();
count.Should().Be(0);
await actorHost.DeactivateAll();
count.Should().Be(0);
}
public async Task ActorProxyMultiTaskTest()
{
const int taskCount = 10;
using IActorHost actorHost = new ActorHost(_loggerFactory)
.Register <ICache>(() => new StringCache());
var tasks = new List <Task>();
ActorKey key1 = new ActorKey("Cache/Test1");
CancellationTokenSource tokenSource = new CancellationTokenSource();
for (int i = 0; i < taskCount; i++)
{
Task t = Task.Run(() => TestAccess(actorHost, key1, tokenSource.Token));
tasks.Add(t);
}
await Task.Delay(TimeSpan.FromSeconds(10));
tokenSource.Cancel();
Task.WaitAll(tasks.ToArray());
(await actorHost.Deactivate <ICache>(key1)).Should().BeTrue();
}
