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))); }