private ActorManager CreateActorManager(Type type, ActorActivator activator = null)
{
var registration = new ActorRegistration(ActorTypeInformation.Get(type));
var interactor = new DaprHttpInteractor(clientHandler: null, "http://localhost:3500", apiToken: null);
return(new ActorManager(registration, activator ?? new DefaultActorActivator(), JsonSerializerDefaults.Web, NullLoggerFactory.Instance, ActorProxy.DefaultProxyFactory, interactor));
}
/// <summary>
/// Registers an actor with the runtime.
/// </summary>
/// <typeparam name="TActor">Type of actor.</typeparam>
/// <param name="actorServiceFactory">An optional delegate to create actor service. This can be used for dependency injection into actors.</param>
public void RegisterActor <TActor>(Func <ActorTypeInformation, ActorService> actorServiceFactory = null)
where TActor : Actor
{
var actorTypeInfo = ActorTypeInformation.Get(typeof(TActor));
this.actorServicesFunc.Add(actorTypeInfo, actorServiceFactory);
}
public async Task CreateAsync_CallsConstructor()
{
var activator = new DefaultActorActivator();
var host = new ActorHost(ActorTypeInformation.Get(typeof(TestActor)), ActorId.CreateRandom(), JsonSerializerDefaults.Web, NullLoggerFactory.Instance, ActorProxy.DefaultProxyFactory);
var state = await activator.CreateAsync(host);
Assert.IsType <TestActor>(state.Actor);
}
public async Task DeleteAsync_NotDisposable()
{
var activator = new DefaultActorActivator();
var host = new ActorHost(ActorTypeInformation.Get(typeof(TestActor)), ActorId.CreateRandom(), JsonSerializerDefaults.Web, NullLoggerFactory.Instance, ActorProxy.DefaultProxyFactory);
var actor = new TestActor(host);
var state = new ActorActivatorState(actor);
await activator.DeleteAsync(state); // does not throw
}
public async Task DeleteAsync_Disposable()
{
var activator = new DefaultActorActivator();
var host = new ActorHost(ActorTypeInformation.Get(typeof(DisposableActor)), ActorId.CreateRandom(), NullLoggerFactory.Instance);
var actor = new DisposableActor(host);
var state = new ActorActivatorState(actor);
await activator.DeleteAsync(state); // does not throw
Assert.True(actor.IsDisposed);
}
public async Task CreateAsync_CanActivateWithDI()
{
var activator = CreateActivator(typeof(TestActor));
var host = new ActorHost(ActorTypeInformation.Get(typeof(TestActor)), ActorId.CreateRandom(), JsonSerializerDefaults.Web, NullLoggerFactory.Instance, ActorProxy.DefaultProxyFactory);
var state = await activator.CreateAsync(host);
var actor = Assert.IsType <TestActor>(state.Actor);
Assert.NotNull(actor.SingletonService);
Assert.NotNull(actor.ScopedService);
}
public async Task DeleteAsync_AsyncDisposable()
{
var activator = new DefaultActorActivator();
var host = new ActorHost(ActorTypeInformation.Get(typeof(AsyncDisposableActor)), ActorId.CreateRandom(), JsonSerializerDefaults.Web, NullLoggerFactory.Instance, ActorProxy.DefaultProxyFactory);
var actor = new AsyncDisposableActor(host);
var state = new ActorActivatorState(actor);
await activator.DeleteAsync(state);
Assert.True(actor.IsDisposed);
}
public async Task DeleteAsync_Disposable()
{
var activator = CreateActivator(typeof(DisposableActor));
var host = new ActorHost(ActorTypeInformation.Get(typeof(DisposableActor)), ActorId.CreateRandom(), JsonSerializerDefaults.Web, NullLoggerFactory.Instance, ActorProxy.DefaultProxyFactory);
var state = await activator.CreateAsync(host);
var actor = Assert.IsType <DisposableActor>(state.Actor);
await activator.DeleteAsync(state); // does not throw
Assert.True(actor.IsDisposed);
}
public async Task DeleteAsync_AsyncDisposable()
{
var activator = CreateActivator(typeof(AsyncDisposableActor));
var host = new ActorHost(ActorTypeInformation.Get(typeof(AsyncDisposableActor)), ActorId.CreateRandom(), NullLoggerFactory.Instance);
var state = await activator.CreateAsync(host);
var actor = Assert.IsType <AsyncDisposableActor>(state.Actor);
await activator.DeleteAsync(state);
Assert.True(actor.IsDisposed);
}
public async Task DeleteAsync_DisposesScope()
{
var activator = CreateActivator(typeof(TestActor));
var host = new ActorHost(ActorTypeInformation.Get(typeof(TestActor)), ActorId.CreateRandom(), JsonSerializerDefaults.Web, NullLoggerFactory.Instance, ActorProxy.DefaultProxyFactory);
var state = await activator.CreateAsync(host);
var actor = Assert.IsType <TestActor>(state.Actor);
Assert.False(actor.ScopedService.IsDisposed);
await activator.DeleteAsync(state);
Assert.True(actor.ScopedService.IsDisposed);
}
/// <summary>
/// Creates an instance of <see cref="ActorHost" /> for unit testing an actor instance.
/// </summary>
/// <param name="actorType">The actor type.</param>
/// <param name="options">The <see cref="ActorTestOptions" /> for configuring the host.</param>
/// <returns>An <see cref="ActorHost" /> instance.</returns>
public static ActorHost CreateForTest(Type actorType, ActorTestOptions options = null)
{
if (actorType == null)
{
throw new ArgumentNullException(nameof(actorType));
}
options ??= new ActorTestOptions();
return(new ActorHost(
ActorTypeInformation.Get(actorType),
options.ActorId,
options.JsonSerializerOptions,
options.LoggerFactory,
options.ProxyFactory,
options.TimerManager));
}
public async Task CreateAsync_CreatesNewScope()
{
var activator = CreateActivator(typeof(TestActor));
var host1 = new ActorHost(ActorTypeInformation.Get(typeof(TestActor)), ActorId.CreateRandom(), JsonSerializerDefaults.Web, NullLoggerFactory.Instance, ActorProxy.DefaultProxyFactory);
var state1 = await activator.CreateAsync(host1);
var actor1 = Assert.IsType <TestActor>(state1.Actor);
var host2 = new ActorHost(ActorTypeInformation.Get(typeof(TestActor)), ActorId.CreateRandom(), JsonSerializerDefaults.Web, NullLoggerFactory.Instance, ActorProxy.DefaultProxyFactory);
var state2 = await activator.CreateAsync(host2);
var actor2 = Assert.IsType <TestActor>(state2.Actor);
Assert.Same(actor1.SingletonService, actor2.SingletonService);
Assert.NotSame(actor1.ScopedService, actor2.ScopedService);
}
/// <summary>
/// Registers an actor with the runtime.
/// </summary>
/// <typeparam name="TActor">Type of actor.</typeparam>
/// <param name="actorServiceFactory">An optional delegate to create actor service. This can be used for dependency injection into actors.</param>
public void RegisterActor <TActor>(Func <ActorTypeInformation, ActorService> actorServiceFactory = null)
where TActor : Actor
{
var actorTypeInfo = ActorTypeInformation.Get(typeof(TActor));
ActorService actorService;
if (actorServiceFactory != null)
{
actorService = actorServiceFactory.Invoke(actorTypeInfo);
}
else
{
actorService = new ActorService(actorTypeInfo);
}
// Create ActorManagers, override existing entry if registered again.
this.actorManagers[actorTypeInfo.ActorTypeName] = new ActorManager(actorService);
}
/// <summary>
/// Registers an actor with the runtime.
/// </summary>
/// <param name="tActor">Type of actor.</param>
/// <param name="actorServiceFactory">An optional delegate to create actor service. This can be used for dependency injection into actors.</param>
public void RegisterActor(Type tActor, Func <ActorTypeInformation, ActorService> actorServiceFactory = null)
{
if (tActor.IsSubclassOf(typeof(Actor)))
{
var actorTypeInfo = ActorTypeInformation.Get(tActor);
ActorService actorService;
if (actorServiceFactory != null)
{
actorService = actorServiceFactory.Invoke(actorTypeInfo);
}
else
{
actorService = new ActorService(actorTypeInfo);
}
// Create ActorManagers, override existing entry if registered again.
this.actorManagers[actorTypeInfo.ActorTypeName] = new ActorManager(actorService);
}
}
private ActorManager CreateActorManager(Type type, ActorActivator activator = null)
{
var registration = new ActorRegistration(ActorTypeInformation.Get(type));
return(new ActorManager(registration, activator ?? new DefaultActorActivator(), JsonSerializerDefaults.Web, NullLoggerFactory.Instance, ActorProxy.DefaultProxyFactory, new DaprHttpInteractor()));
}
private ActorManager CreateActorManager(Type type, ActorActivator activator = null)
{
var registration = new ActorRegistration(ActorTypeInformation.Get(type));
return(new ActorManager(registration, activator ?? new DefaultActorActivator(), NullLoggerFactory.Instance));
}
private DependencyInjectionActorActivator CreateActivator(Type type)
{
return(new DependencyInjectionActorActivator(CreateServices(), ActorTypeInformation.Get(type)));
}
