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); }
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 }
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 void TestMissingActorNotCreatedInEventHandler() { var mockProxyFactory = new MockActorProxyFactory(); var actorId = ActorId.CreateRandom(); var instance = mockProxyFactory.CreateActorProxy <IMyStatefulActor>(actorId); Assert.IsNull(instance); }
public void TestMissingActorCreatedInEventHandler() { var mockProxyFactory = new MockActorProxyFactory(); mockProxyFactory.MissingActor += MockProxyFactory_MisingActorId; var actorId = ActorId.CreateRandom(); var instance = mockProxyFactory.CreateActorProxy <IMyStatefulActor>(actorId); Assert.IsInstanceOfType(instance, typeof(IMyStatefulActor)); }
public async Task CanAddMoreHandlersDynamically(string eventName, int messageCount, int expectedHandlerId) { //create mocked handlers based on the amount of messages passed in to the test var mockActorProxyFactory = new MockActorProxyFactory(); for (var i = 0; i <= messageCount; i++) { mockActorProxyFactory.RegisterActor(CreateMockEventHandlerActor(new ActorId($"{eventName}-{i + 1}"))); } //return messages up to the limit of the test requirements var count = 0; _mockMessageProvider.Setup(s => s.ReceiveAsync( It.IsAny <int>(), It.IsAny <TimeSpan>())).ReturnsAsync(() => { if (count >= messageCount) { return(new List <Message>()); } count++; return(CreateMessage(eventName)); }); var mockServiceBusProvider = new Mock <IServiceBusManager>(); mockServiceBusProvider.Setup(s => s.CreateAsync( It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>())); mockServiceBusProvider.Setup(s => s.CreateMessageReceiver( It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <bool>())).Returns(_mockMessageProvider.Object); mockServiceBusProvider.Setup(s => s.GetLockToken(It.IsAny <Message>())).Returns(Guid.NewGuid().ToString); var service = new EventReaderService.EventReaderService( _context, _stateManager, _mockedBigBrother, mockServiceBusProvider.Object, mockActorProxyFactory, _config); var cancellationTokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(10)); await service.InvokeRunAsync(cancellationTokenSource.Token); Assert.Equal(expectedHandlerId, service.HandlerCount); }
public void TestMissingActorSecondTypeCreatedInEventHandler() { var mockProxyFactory = new MockActorProxyFactory(); mockProxyFactory.MissingActor += MockProxyFactory_MisingActor_TwoTypes; var actorId = ActorId.CreateRandom(); var instance1 = mockProxyFactory.CreateActorProxy <IMyStatefulActor>(actorId); var instance2 = mockProxyFactory.CreateActorProxy <IReminderTimerActor>(actorId); Assert.IsInstanceOfType(instance1, typeof(IMyStatefulActor)); Assert.IsInstanceOfType(instance2, typeof(IReminderTimerActor)); }
public EventReaderTests() { _context = CustomMockStatefulServiceContextFactory.Create( ServiceNaming.EventReaderServiceType, ServiceNaming.EventReaderServiceFullUri("test.type", "subA"), Encoding.UTF8.GetBytes(EventReaderInitData.GetReaderInitDataAsString("test.type", "subA")), replicaId: (new Random(int.MaxValue)).Next()); _mockActorProxyFactory = new MockActorProxyFactory(); _stateManager = new MockReliableStateManager(); _config = new ConfigurationSettings(); _mockedBigBrother = new Mock <IBigBrother>().Object; _mockMessageProvider = new Mock <IMessageReceiver>(); }
public MockFabricRuntime(string applicationName) { ApplicationName = applicationName; _stateManager = new MockReliableStateManager(); var serviceProxyFactory = new MockServiceProxyFactory(this); var actorProxyFactory = new MockActorProxyFactory(this); _serviceProxyFactory = serviceProxyFactory; _actorProxyFactory = actorProxyFactory; FG.ServiceFabric.Services.Remoting.Runtime.Client.ServiceProxyFactory.SetInnerFactory((factory, serviceType) => _serviceProxyFactory);; FG.ServiceFabric.Actors.Client.ActorProxyFactory.SetInnerFactory((factory, serviceType, actorType) => _actorProxyFactory);; }
static FixtureBase() { _messageDictionary = new Dictionary <string, string>(); _actorProxyFactory = new MockActorProxyFactory(); _serviceProxyFactory = new MockServiceProxyFactory(); var repositoryFactoryMock = new Mock <IRepositoryFactories>(); var repositoryMock = new Mock <IMessageRepository>(); repositoryMock.Setup(i => i.Send(It.IsAny <string>(), It.IsAny <string>())).Returns((string s, string y) => MockSendMessage(s, y)); repositoryFactoryMock.Setup(f => f.CreateMessageRepository()).Returns(repositoryMock.Object); // setup repositories when you can _factories = repositoryFactoryMock.Object; }
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 Cleanup() { _actorProxyFactory = new MockActorProxyFactory(); _serviceProxyFactory = new MockServiceProxyFactory(); }
public MyMockActorProxyFactoryWrapper() { _proxy = new MockActorProxyFactory(); }