internal static async Task <UserActor.UserActor> CreateUserActorAsync(ActorId id, IActorFactory actorFactory = null,
IServiceFactory serviceFactory = null, IUsersServiceProxy usersServiceProxy = null,
IInvoicesServiceProxy invoicesServiceProxy = null, bool invokeOnActivate = true)
{
if (actorFactory == null)
{
actorFactory = new Mock <IActorFactory>().Object;
}
if (serviceFactory == null)
{
serviceFactory = new Mock <IServiceFactory>().Object;
}
if (usersServiceProxy == null)
{
usersServiceProxy = new Mock <IUsersServiceProxy>().Object;
}
if (invoicesServiceProxy == null)
{
invoicesServiceProxy = new Mock <IInvoicesServiceProxy>().Object;
}
Func <ActorService, ActorId, ActorBase> factory =
(service, actorId) => new UserActor.UserActor(service, id, actorFactory, serviceFactory, usersServiceProxy, invoicesServiceProxy);
var svc = MockActorServiceFactory.CreateActorServiceForActor <UserActor.UserActor>(factory);
var actor = svc.Activate(id);
if (invokeOnActivate)
{
await actor.InvokeOnActivateAsync();
}
return(actor);
}
public static TestContext WithHappyPath()
{
var testContext = new TestContext();
testContext.TelemetryClient = new TelemetryClient(new TelemetryConfiguration("", testContext.MockTelemetryChannel));
testContext.Actors = Enumerable.Range(0, 10).Select(x => Guid.NewGuid()).Select(x =>
{
var actorProxyFactory = new MockActorProxyFactory();
var mockServiceProxyFactory = new MockServiceProxyFactory();
var actorServiceForActor = MockActorServiceFactory.CreateActorServiceForActor <Instance>();
var instance = new Instance(actorServiceForActor, new ActorId(x), testContext.ClusterClient.Object,
testContext.TelemetryClient);
return(instance);
}).ToList();
var setupSequentialResult = testContext.GuidGetter.SetupSequence(x => x.GetAGuid());
foreach (var actor in testContext.Actors)
{
setupSequentialResult.Returns(actor.Id.GetGuidId());
testContext.MockActorProxyFactory.RegisterActor(actor);
}
testContext.PoolActorService = CreatePoolActorService(testContext.TelemetryClient, testContext.MockActorProxyFactory,
testContext.GuidGetter.Object);
testContext.Pool = testContext.PoolActorService.Activate(new ActorId("fabric:/myapplicationname/myservicetypename"));
return(testContext);
}
public async Task TestMultipleActors()
{
Func <ActorService, ActorId, ActorBase> actorFactory = (service, actorId) => new MyStatefulActor(service, actorId);
var svc = MockActorServiceFactory.CreateActorServiceForActor <MyStatefulActor>(actorFactory);
var actor1 = svc.Activate(new ActorId(Guid.NewGuid()));
var actor2 = svc.Activate(new ActorId(Guid.NewGuid()));
var stateManager1 = (MockActorStateManager)actor1.StateManager;
var stateManager2 = (MockActorStateManager)actor2.StateManager;
const string stateName = "test";
var payload1 = new Payload(StatePayload);
var payload2 = new Payload(OtherStatePayload);
//create states
await actor1.InsertAsync(stateName, payload1);
await actor2.InsertAsync(stateName, payload2);
//get states
var actual1 = await stateManager1.GetStateAsync <Payload>(stateName);
Assert.AreEqual(StatePayload, actual1.Content);
var actual2 = await stateManager2.GetStateAsync <Payload>(stateName);
Assert.AreEqual(OtherStatePayload, actual2.Content);
}
public void TestMultipleActorsForSingleActorId()
{
var sharedId = new ActorId(Guid.NewGuid());
//mock out the called actors
var statefulActorSvc = MockActorServiceFactory.CreateActorServiceForActor <MockTestStatefulActor>(
(service, actorId) => new MockTestStatefulActor(service, actorId));
var reminderActorService = MockActorServiceFactory.CreateActorServiceForActor <MockReminderTimerActor>(
(service, actorId) => new MockReminderTimerActor(service, actorId));
var statefulActor = statefulActorSvc.Activate(sharedId);
var reminderActor = reminderActorService.Activate(sharedId);
//prepare the service:
var mockProxyFactory = new MockActorProxyFactory();
mockProxyFactory.RegisterActor(statefulActor);
mockProxyFactory.RegisterActor(reminderActor);
//act:
var a1 = mockProxyFactory.CreateActorProxy <IMyStatefulActor>(sharedId);
var a2 = mockProxyFactory.CreateActorProxy <IReminderTimerActor>(sharedId);
//assert:
Assert.AreSame(typeof(MockTestStatefulActor), a1.GetType());
Assert.AreSame(typeof(MockReminderTimerActor), a2.GetType());
}
public async Task TestServiceProxyFactory()
{
//mock out the called service
var mockProxyFactory = new MockActorProxyFactory();
mockProxyFactory.MissingActor += MockProxyFactory_MisingActorId;
//prepare the actor:
Func <ActorService, ActorId, ActorBase> actorFactory = (service, actorId) => new ActorCallerActor(service, actorId, mockProxyFactory);
var svc = MockActorServiceFactory.CreateActorServiceForActor <ActorCallerActor>(actorFactory);
var actor = svc.Activate(ActorId.CreateRandom());
//act:
await actor.InsertAsync("test", new Payload("some other value"));
//check if the other actor was called
var statefulActorId = await actor.StateManager.GetStateAsync <ActorId>(ActorCallerActor.ChildActorIdKeyName);
var statefulActor = mockProxyFactory.CreateActorProxy <IMyStatefulActor>(ActorCallerActor.CalledServiceName, statefulActorId);
var payload = await((MyStatefulActor)statefulActor).StateManager.GetStateAsync <Payload>("test");
//assert:
Assert.AreEqual("some other value", payload.Content);
}
internal static async Task <VehicleActor.VehicleActor> CreateVehicleActorAsync(ActorId id, IActorFactory actorFactory = null,
IServiceFactory serviceFactory = null, IVehiclesServiceProxy vehiclesServiceProxy = null,
bool invokeOnActivate = true)
{
if (actorFactory == null)
{
actorFactory = new Mock <IActorFactory>().Object;
}
if (serviceFactory == null)
{
serviceFactory = new Mock <IServiceFactory>().Object;
}
if (vehiclesServiceProxy == null)
{
vehiclesServiceProxy = new Mock <IVehiclesServiceProxy>().Object;
}
Func <ActorService, ActorId, ActorBase> factory =
(service, actorId) => new VehicleActor.VehicleActor(service, id, actorFactory, serviceFactory, vehiclesServiceProxy);
var svc = MockActorServiceFactory.CreateActorServiceForActor <VehicleActor.VehicleActor>(factory);
var actor = svc.Activate(id);
if (invokeOnActivate)
{
await actor.InvokeOnActivateAsync();
}
return(actor);
}
public async Task TestSubscribe_Doesnt_CrashAsync()
{
//var service = new CustomActorService(MockStatefulServiceContextFactory.Default, ActorTypeInformation.Get(typeof(MyStatefulActor)));
//var factory = new MockActorServiceRemotingClientFactory(service);
//var proxyFactory = new ActorProxyFactory(callbackClient => factory)
var guid = Guid.NewGuid();
var id = new ActorId(guid);
Func <ActorService, ActorId, ActorBase> factory = (service, actorId) => new ExampleActorMock(service, actorId);
var svc = MockActorServiceFactory.CreateActorServiceForActor <ExampleActorMock>(factory);
var actor = svc.Activate(id);
var mockProxyFactory = new MockActorProxyFactory();
mockProxyFactory.RegisterActor(actor);
var eventSubscriptionHelper = new MockActorEventSubscriptionHelper();
var exampleService = new ExampleClient(MockStatefulServiceContextFactory.Default, new MockReliableStateManager(),
eventSubscriptionHelper, mockProxyFactory);
await exampleService.DoSomething(guid, "message text");
Assert.IsTrue(eventSubscriptionHelper.IsSubscribed <IExampleEvents>(exampleService));
Assert.IsFalse(IsSuccess);
//Subscribe doesn't crash the test, but the Event is not really fired and processed at this time
}
private static MyStatefulActor CreateActor(ActorId id)
{
Func <ActorService, ActorId, ActorBase> actorFactory = (service, actorId) => new MyStatefulActor(service, id);
var svc = MockActorServiceFactory.CreateActorServiceForActor <MyStatefulActor>(actorFactory);
var actor = svc.Activate(id);
return(actor);
}
private static EventHandlerActor.EventHandlerActor CreateEventHandlerActor(ActorId id, IBigBrother bigBrother)
{
ActorBase ActorFactory(ActorService service, ActorId actorId) => new EventHandlerActor.EventHandlerActor(service, id, new Mock <IEventHandlerFactory>().Object, bigBrother);
var svc = MockActorServiceFactory.CreateActorServiceForActor <EventHandlerActor.EventHandlerActor>(ActorFactory);
var actor = svc.Activate(id);
return(actor);
}
public void TestAnotherCustomActorService_CreateFails()
{
//an ActorService with a NON standard constructor can be created by the MockActorServiceFactory
Assert.ThrowsException <InvalidOperationException>(() =>
{
var customActorService =
MockActorServiceFactory.CreateCustomActorServiceForActor <AnotherCustomActorService, OnActivateActor>();
});
}
private void actorProxyFactory_MissingActor(object sender, MissingActorEventArgs args)
{
var registrar = (MockActorProxyFactory)sender;
Func <ActorService, ActorId, ActorBase> actorFactory = (service, actorId) => new ApprovalActor(service, actorId, _actorProxyFactory, _serviceProxyFactory, _factories);
var svc = MockActorServiceFactory.CreateActorServiceForActor <ApprovalActor>(actorFactory);
var actor = svc.Activate(args.Id);
registrar.RegisterActor(actor);
}
private static IEventHandlerActor CreateMockEventHandlerActor(ActorId id)
{
ActorBase ActorFactory(ActorService service, ActorId actorId) => new MockEventHandlerActor(service, id);
var svc = MockActorServiceFactory.CreateActorServiceForActor <MockEventHandlerActor>(ActorFactory);
var actor = svc.Activate(id);
return(actor);
}
public async Task InvokeOnDeactivateAsyncTest()
{
var svc = MockActorServiceFactory.CreateActorServiceForActor <InvokeOnActor>();
var actor = svc.Activate(new ActorId(Guid.NewGuid()));
await actor.InvokeOnDeactivateAsync();
Assert.IsTrue(actor.OnDeactivateCalled);
}
public void TestCustomActorServiceActivate()
{
//an ActorService with a standard constructor can be created by the MockActorServiceFactory
var customActorService = MockActorServiceFactory.CreateCustomActorServiceForActor <CustomActorService, InvokeOnActor>();
var actor = customActorService.Activate <InvokeOnActor>(new ActorId(123L));
Assert.IsInstanceOfType(customActorService, typeof(CustomActorService));
Assert.IsInstanceOfType(actor, typeof(InvokeOnActor));
Assert.AreEqual(123L, actor.Id.GetLongId());
}
public void TestAnotherCustomActorService_CreateFails()
{
//an ActorService with a NON standard constructor can be created by the MockActorServiceFactory
Assert.ThrowsException <InvalidOperationException>(() =>
{
// ReSharper disable once UnusedVariable
var customActorService =
MockActorServiceFactory.CreateCustomActorServiceForActor <AnotherCustomActorService, InvokeOnActor>();
});
}
public async Task InvokeOnPostActorMethodAsyncTest()
{
var svc = MockActorServiceFactory.CreateActorServiceForActor <InvokeOnActor>();
var actor = svc.Activate(new ActorId(Guid.NewGuid()));
var context = MockActorMethodContextFactory.CreateForTimer(nameof(actor.ActorOperation));
await actor.InvokeOnPostActorMethodAsync(context);
Assert.IsTrue(actor.OnPostActorMethodCalled);
}
private async Task <T> CreateActorConditional <T>(ActorId id, Func <ActorService, ActorId, ActorBase> funcOverride)
where T : Actor, IActor
{
var svc = MockActorServiceFactory.CreateActorServiceForActor <T>(funcOverride);
var actor = svc.Activate <T>(id);
await actor.InvokeOnActivateAsync();
_actorProxyFactory.RegisterActor(actor);
return(actor);
}
public void TestDefault()
{
var instance = MockActorServiceFactory.CreateActorServiceForActor <MockActor>();
Assert.IsInstanceOfType(instance, typeof(MockActorService <MockActor>));
Assert.AreEqual(MockStatefulServiceContextFactory.Default, instance.Context);
Assert.AreEqual(ActorTypeInformation.Get(typeof(MockActor)).ImplementationType, instance.ActorTypeInformation.ImplementationType);
Assert.IsNotNull(instance.StateProvider);
Assert.IsNotNull(instance.Settings);
}
public async Task CustomStatefulActor_ShouldHaveUniqueStateManagerPerId()
{
Dictionary <ActorId, IActorStateManager> stateManagerMap = new Dictionary <ActorId, IActorStateManager>();
Func <ActorBase, IActorStateProvider, IActorStateManager> stateManagerFactory = (actr, stateProvider) =>
{
if (!stateManagerMap.TryGetValue(actr.Id, out var actorStateManager))
{
actorStateManager = new MockActorStateManager();
stateManagerMap[actr.Id] = actorStateManager;
}
return(actorStateManager);
};
// Every actor instance has its own state manager.
Func <ActorService, ActorId, ActorBase> actorFactory = (service, actorId) => new MyStatefulActor(service, actorId);
var customActorService = MockActorServiceFactory.CreateCustomActorServiceForActor <CustomActorService, MyStatefulActor>(actorFactory, stateManagerFactory: stateManagerFactory);
var id1 = ActorId.CreateRandom();
var id2 = ActorId.CreateRandom();
var actor1 = customActorService.Activate <MyStatefulActor>(id1);
var stateManager1 = (MockActorStateManager)actor1.StateManager;
var actor2 = customActorService.Activate <MyStatefulActor>(id2);
var stateManager2 = (MockActorStateManager)actor2.StateManager;
var actor1_2 = customActorService.Activate <MyStatefulActor>(id1);
var stateManager1_2 = (MockActorStateManager)actor1_2.StateManager;
const string stateName = "test";
const string payloadText = "foo";
var payload = new Payload(payloadText);
//create state
await actor1.InsertAsync(stateName, payload);
//get state
var actualState1 = await stateManager1.GetStateAsync <Payload>(stateName);
Assert.AreEqual(payloadText, actualState1.Content);
var actualState2 = await stateManager2.TryGetStateAsync <Payload>(stateName);
Assert.IsFalse(actualState2.HasValue);
var actualState1_2 = await stateManager1_2.GetStateAsync <Payload>(stateName);
Assert.AreEqual(payloadText, actualState1_2.Content);
Assert.AreNotSame(stateManager1, stateManager2);
Assert.AreSame(stateManager1, stateManager1_2);
}
public void TestActorMethodContexts()
{
var svc = MockActorServiceFactory.CreateActorServiceForActor <InvokeOnActor>();
var actor = svc.Activate(new ActorId(Guid.NewGuid()));
var context = MockActorMethodContextFactory.CreateForActor(nameof(actor.ActorOperation));
Assert.IsInstanceOfType(context, typeof(ActorMethodContext));
context = MockActorMethodContextFactory.CreateForTimer(nameof(actor.ActorOperation));
Assert.IsInstanceOfType(context, typeof(ActorMethodContext));
context = MockActorMethodContextFactory.CreateForReminder(nameof(actor.ActorOperation));
Assert.IsInstanceOfType(context, typeof(ActorMethodContext));
}
private static void MockProxyFactory_MisingActorId(object sender, MissingActorEventArgs args)
{
if (args.ActorType != typeof(IMyStatefulActor))
{
return;
}
Func <ActorService, ActorId, ActorBase> actorFactory = (service, actorId) => new MyStatefulActor(service, actorId);
var svc = MockActorServiceFactory.CreateActorServiceForActor <MyStatefulActor>(actorFactory);
var actor = svc.Activate(args.Id);
args.ActorInstance = actor;
}
public async Task TestActorTimerRegistration()
{
var svc = MockActorServiceFactory.CreateActorServiceForActor <ReminderTimerActor>();
var actor = svc.Activate(new ActorId(Guid.NewGuid()));
//setup
await actor.RegisterTimerAsync();
//assert
var timers = actor.GetActorTimers(); //extension method
bool hasTimer = timers.Any();
Assert.IsTrue(hasTimer);
}
public void TestCustomContext()
{
var newUri = new Uri("fabric:/MockApp/OtherMockStatefulService");
var serviceTypeName = "OtherMockServiceType";
var partitionId = Guid.NewGuid();
var replicaId = long.MaxValue;
var context = new MockCodePackageActivationContext("fabric:/MyApp", "MyAppType", "Code", "Ver", "Context", "Log", "Temp", "Work", "Man", "ManVer");
var serviceContext = MockStatefulServiceContextFactory.Create(context, serviceTypeName, newUri, partitionId, replicaId);
var instance = MockActorServiceFactory.CreateActorServiceForActor <MockActor>(context: serviceContext);
Assert.IsInstanceOfType(instance, typeof(MockActorService <MockActor>));
Assert.AreEqual(serviceContext, instance.Context);
}
public async Task TestActorReminderRegistration()
{
var svc = MockActorServiceFactory.CreateActorServiceForActor <ReminderTimerActor>();
var actor = svc.Activate(new ActorId(Guid.NewGuid()));
string reminderName = "reminder";
//setup
await actor.RegisterReminderAsync(reminderName);
//assert
var reminderCollection = actor.GetActorReminders();
bool hasReminder = reminderCollection.Any(r => string.Equals(r.Name, reminderName));
Assert.IsTrue(hasReminder);
}
internal static InvoiceActor CreateActor(ActorId id, IActorFactory actorFactory = null, IServiceFactory serviceFactory = null)
{
if (actorFactory == null)
{
actorFactory = new Mock <IActorFactory>().Object;
}
if (serviceFactory == null)
{
serviceFactory = new Mock <IServiceFactory>().Object;
}
Func <ActorService, ActorId, ActorBase> factory =
(service, actorId) => new InvoiceActor(service, id, actorFactory, serviceFactory);
var svc = MockActorServiceFactory.CreateActorServiceForActor <InvoiceActor>(factory);
var actor = svc.Activate(id);
return(actor);
}
public async Task TestServiceProxyFactory()
{
//mock out the called service
var mockProxyFactory = new MockServiceProxyFactory();
var mockService = new MockTestStatefulService();
mockProxyFactory.RegisterService(ServiceCallerActor.CalledServiceName, mockService);
//prepare the actor:
Func <ActorService, ActorId, ActorBase> actorFactory = (service, actorId) => new ServiceCallerActor(service, actorId, mockProxyFactory);
var svc = MockActorServiceFactory.CreateActorServiceForActor <ServiceCallerActor>(actorFactory);
var actor = svc.Activate(ActorId.CreateRandom());
//act:
await actor.InsertAsync("test", new Payload("some other value"));
//assert:
Assert.IsTrue(mockService.InsertAsyncCalled);
}
public async Task TestActorProxyFactory()
{
//mock out the called actor
var id = new ActorId(ActorCallerService.CalledActorId);
Func <ActorService, ActorId, ActorBase> actorFactory = (service, actorId) => new MockTestStatefulActor(service, id);
var svc = MockActorServiceFactory.CreateActorServiceForActor <MockTestStatefulActor>(actorFactory);
var actor = svc.Activate(id);
//prepare the service:
var mockProxyFactory = new MockActorProxyFactory();
mockProxyFactory.RegisterActor(actor);
var serviceInstance = new ActorCallerService(MockStatelessServiceContextFactory.Default, mockProxyFactory);
//act:
await serviceInstance.CallActorAsync();
//assert:
Assert.IsTrue(actor.InsertAsyncCalled);
}
public void ResolveTest()
{
using (var container = new WindsorContainer())
{
var resolver = new ActorResolver(container.Kernel, typeof(TestActor));
var actorService = MockActorServiceFactory.CreateActorServiceForActor <TestActor>();
Assert.Throws <ComponentNotFoundException>(() => resolver.Resolve(actorService, new ActorId(1)));
container.Register(
Component.For <TestActor>().LifestyleTransient());
var actor = resolver.Resolve(actorService, new ActorId(1));
Assert.NotNull(actor);
var testActor = Assert.IsType <TestActor>(actor);
Assert.Equal(new ActorId(1), testActor.ActorId);
}
}
public async Task TestGetActorRemindersExtensionMethod()
{
var svc = MockActorServiceFactory.CreateActorServiceForActor <ReminderTimerActor>();
var actor = svc.Activate(new ActorId(Guid.NewGuid()));
string reminderName = "reminder";
IEnumerable <IActorReminder> reminderCollection = null;
// Test empty when no reminders
reminderCollection = actor.GetActorReminders();
Assert.IsFalse(reminderCollection.Any());
// Test non-empty when reminder registered
await actor.RegisterReminderAsync(reminderName);
reminderCollection = actor.GetActorReminders();
Assert.IsTrue(reminderCollection.Any(r => string.Equals(r.Name, reminderName)));
// Test non-empty when reminder registered
await actor.UnregisterReminderAsync(reminderName);
reminderCollection = actor.GetActorReminders();
Assert.IsFalse(reminderCollection.Any(r => string.Equals(r.Name, reminderName)));
}
public ReproActorTest()
{
_actorService = MockActorServiceFactory.CreateActorServiceForActor <ReproActor>();
_actor = _actorService.Activate(new ActorId(string.Empty));
_actor.InvokeOnActivateAsync().Wait();
}
