public async Task NewAdditionalInfoTest(string id, string roomNo, string message) { var mockClientProxy = new Mock <Microsoft.AspNetCore.SignalR.IClientProxy>(); var mockClients = new Mock <IHubCallerClients>(); var mockGroupManager = new Mock <IGroupManager>(); var mockManageHubUser = new Mock <IManageHubUser>(); var prepareQueue = new FakeQueue().WithRoomNo(roomNo).WithMessage(message).WithOwnerInitials("PB").Build(); var preparedQueue = _mapper.Map <Queue>(prepareQueue); mockClients.Setup(c => c.Group(preparedQueue.RoomNo.ToString())).Returns(() => mockClientProxy.Object); mockManageHubUser.Setup(h => h.GetConnectedUsers()).Returns(new FakeHubUser(id, null, roomNo.ToString()).BuildAsList()); _mockQueueService.Setup(q => q.NewAdditionalInfo(It.IsAny <string>(), It.IsAny <string>())).Returns(Task.FromResult(preparedQueue)); var hub = new QueueHub(_mockRepo.Object, _mockQueueService.Object, mockManageHubUser.Object) { Clients = mockClients.Object, Context = _mockHubCallerContext.Object, Groups = mockGroupManager.Object }; //System.Diagnostics.Debugger.Launch(); await hub.NewAdditionalInfo(roomNo, preparedQueue.AdditionalMessage); mockClientProxy.Verify(p => p.SendCoreAsync("ReceiveAdditionalInfo", It.Is <object[]>(o => o != null && o.Length == 2 && ((string)o[1]) == preparedQueue.AdditionalMessage), default(CancellationToken)), Times.AtLeastOnce); }
public async void ChangeUserRoomNo_Test(string newRoomNo, string oldRoomNo) { var data = new FakeQueue(); var result = await CallChangeUserRoomNo(newRoomNo, oldRoomNo); Assert.Equal(newRoomNo, result.RoomNo); }
public async void CheckNewQueueNo_IsBreakOn() { var data = new FakeQueue().WithQueueNo(15).WithBreak(true); var result = await CallNewQueueNo(-1, data.BuildAsList()); var expectedQueueMessage = "PB15"; Assert.Equal(expectedQueueMessage, result.QueueNoMessage); Assert.False(result.IsBreak); Assert.False(result.IsSpecial); }
public async void CheckNewAdditionalInfo(string message) { var data = new FakeQueue().WithMessage("blablabla"); var preparedData = data.Build(); var result = await CallNewAdditioanlInfo(message, data.BuildAsList()); Assert.Equal(message, result.AdditionalMessage); Assert.Equal(preparedData.QueueNo, result.QueueNo); Assert.Equal(preparedData.OwnerInitials, result.OwnerInitials); Assert.Equal(preparedData.IsBreak, result.IsBreak); Assert.Equal(preparedData.IsSpecial, result.IsSpecial); Assert.Equal(preparedData.RoomNo, result.RoomNo); }
public async void CheckNewQueueNo_IsSpecialOff() { var data = new FakeQueue().WithQueueNo(15).WithSpecial(true); var preparedData = data.Build(); var result = await CallNewQueueNo(-2, data.BuildAsList()); var expectedQueueMessage = String.Concat(preparedData.OwnerInitials, preparedData.QueueNo); Assert.Equal(expectedQueueMessage, result.QueueNoMessage); Assert.False(result.IsBreak); Assert.False(result.IsSpecial); }
public async Task DelayingQueueAddsWhenTimePasses() { // arrange var added = new List <string>(); var fake = new FakeQueue <string> { OnAdd = added.Add, }; var clock = new FakeSystemClock(); IDelayingQueue <string> delayingQueue = new DelayingQueue <string>(clock, fake); // act delayingQueue.AddAfter("50ms", TimeSpan.FromMilliseconds(50)); delayingQueue.AddAfter("100ms", TimeSpan.FromMilliseconds(100)); clock.Advance(TimeSpan.FromMilliseconds(25)); delayingQueue.AddAfter("75ms", TimeSpan.FromMilliseconds(50)); delayingQueue.AddAfter("125ms", TimeSpan.FromMilliseconds(100)); await Task.Delay(TimeSpan.FromMilliseconds(40)); var countAfter25ms = added.Count; clock.Advance(TimeSpan.FromMilliseconds(30)); await Task.Delay(TimeSpan.FromMilliseconds(40)); var countAfter55ms = added.Count; clock.Advance(TimeSpan.FromMilliseconds(25)); await Task.Delay(TimeSpan.FromMilliseconds(40)); var countAfter80ms = added.Count; clock.Advance(TimeSpan.FromMilliseconds(25)); await Task.Delay(TimeSpan.FromMilliseconds(40)); var countAfter105ms = added.Count; clock.Advance(TimeSpan.FromMilliseconds(25)); await Task.Delay(TimeSpan.FromMilliseconds(40)); var countAfter135ms = added.Count; // assert countAfter25ms.ShouldBe(0); countAfter55ms.ShouldBe(1); countAfter80ms.ShouldBe(2); countAfter105ms.ShouldBe(3); countAfter135ms.ShouldBe(4); added.ShouldBe(new[] { "50ms", "75ms", "100ms", "125ms" }, ignoreOrder: false); }
public async Task <Queue> CallRegisterDoctor(string id, string roomNo, Mock <IHubCallerClients> mockClients, Mock <Microsoft.AspNetCore.SignalR.IClientProxy> mockClientProxy, Mock <IGroupManager> mockGroupManager, Mock <IManageHubUser> mockManageHubUser = null) { if (mockClients == null) { mockClients = _mockClients; } if (mockClientProxy == null) { mockClientProxy = _mockClientProxy; } if (mockGroupManager == null) { mockGroupManager = _mockGroupManager; } if (mockManageHubUser == null) { mockManageHubUser = new Mock <IManageHubUser>(); } var prepareQueue = new FakeQueue().WithQueueNo(12).WithRoomNo(roomNo).Build(); var queue = _mapper.Map <Queue>(prepareQueue); //var prepareUser = new UserData().WithRoomNo(roomNo).BuildAsList(); //mockManageHubUser.Setup(h => h.GetGroupMaster(It.IsAny<string>())).Returns(new FakeHubUser(null, roomNo).BuildAsList()); //_mockRepo.Setup(r => r.User.FindByCondition(It.IsAny<Expression<Func<Entities.Models.User, bool>>>())) // .Returns(prepareUser); //_mockQueueService.Setup(q => q.FindByUserId(It.IsAny<string>())).Returns(queue); //_mockQueueService.Setup(q => q.NewQueueNo(It.IsAny<string>(), It.IsAny<int>())).Returns(Task.FromResult(queue)); //_mockHubCallerContext.Setup(c => c.ConnectionId).Returns(It.IsAny<string>()); //mockClients.Setup(c => c.Group(queue.RoomNo)).Returns(() => mockClientProxy.Object); //var hub = new QueueHub(_mockRepo.Object, _mockQueueService.Object, mockManageHubUser.Object) //{ // Clients = mockClients.Object, // Context = _mockHubCallerContext.Object, // Groups = mockGroupManager.Object //}; //await hub.RegisterDoctor(queue.RoomNo); //return queue; }
public async Task DelayingQueueAddsWhenTimePasses() { var added = new List <string>(); var fake = new FakeQueue <string> { OnAdd = added.Add, }; var clock = new FakeSystemClock(); IDelayingQueue <string> delayingQueue = new DelayingQueue <string>(clock, fake); delayingQueue.AddAfter("50ms", TimeSpan.FromMilliseconds(50)); delayingQueue.AddAfter("100ms", TimeSpan.FromMilliseconds(100)); clock.Advance(TimeSpan.FromMilliseconds(25)); delayingQueue.AddAfter("75ms", TimeSpan.FromMilliseconds(50)); delayingQueue.AddAfter("125ms", TimeSpan.FromMilliseconds(100)); await Task.Delay(TimeSpan.FromMilliseconds(40)); var countAfter25ms = added.Count; clock.Advance(TimeSpan.FromMilliseconds(30)); await Task.Delay(TimeSpan.FromMilliseconds(40)); var countAfter55ms = added.Count; clock.Advance(TimeSpan.FromMilliseconds(25)); await Task.Delay(TimeSpan.FromMilliseconds(40)); var countAfter80ms = added.Count; clock.Advance(TimeSpan.FromMilliseconds(25)); await Task.Delay(TimeSpan.FromMilliseconds(40)); var countAfter105ms = added.Count; clock.Advance(TimeSpan.FromMilliseconds(25)); await Task.Delay(TimeSpan.FromMilliseconds(40)); var countAfter135ms = added.Count; Assert.Equal(0, countAfter25ms); Assert.Equal(1, countAfter55ms); Assert.Equal(2, countAfter80ms); Assert.Equal(3, countAfter105ms); Assert.Equal(4, countAfter135ms); Assert.Equal(new[] { "50ms", "75ms", "100ms", "125ms" }, added); }
public async void CheckNewQueueNo_PlusValues(int queueNo, bool isBreak, bool isSpecial) { //System.Diagnostics.Debugger.Launch(); var data = new FakeQueue().WithBreak(isBreak).WithSpecial(isSpecial); var preparedData = data.WithQueueNo(queueNo).Build(); var result = await CallNewQueueNo(queueNo, data.WithQueueNo(15).BuildAsList()); var queueNoString = queueNo.ToString(); var expectedQueueMessage = String.Concat(preparedData.OwnerInitials, preparedData.QueueNo); Assert.Equal(expectedQueueMessage, result.QueueNoMessage); Assert.False(result.IsBreak); Assert.False(result.IsSpecial); }
public async Task NoAddingAfterShutdown() { var added = new List <string>(); var fake = new FakeQueue <string> { OnAdd = added.Add, }; var clock = new FakeSystemClock(); IDelayingQueue <string> delayingQueue = new DelayingQueue <string>(clock, fake); delayingQueue.AddAfter("one", TimeSpan.FromMilliseconds(10)); delayingQueue.ShutDown(); delayingQueue.AddAfter("two", TimeSpan.FromMilliseconds(10)); clock.Advance(TimeSpan.FromMilliseconds(25)); await Task.Delay(TimeSpan.FromMilliseconds(40)); Assert.Empty(added); }
public void ResetQueueTest() { //System.Diagnostics.Debugger.Launch(); //test data List <Entities.Models.Queue> queues = new FakeQueue().WithQueueNo(10).WithRoomNo("10").BuildAsList(); queues.Add(new FakeQueue().WithQueueNo(17).WithRoomNo("15").Build()); queues.Add(new FakeQueue().WithQueueNo(251).WithRoomNo("3").Build()); var querableQueues = queues.AsQueryable(); //mock var mockScopeFactory = new Mock <IServiceScopeFactory>(); var mockHubContext = new Mock <IHubContext <QueueHub> >(); var mockRepoWrapper = new Mock <IRepositoryWrapper>(); var mockScope = new Mock <IServiceScope>(); var mockServiceProvider = new Mock <IServiceProvider>(); mockScopeFactory.Setup(s => s.CreateScope()).Returns(mockScope.Object); mockServiceProvider.Setup(s => s.GetService(typeof(IRepositoryWrapper))).Returns(mockRepoWrapper.Object); mockScope.Setup(s => s.ServiceProvider).Returns(mockServiceProvider.Object); mockRepoWrapper.Setup(q => q.Queue.FindAll()).Returns(querableQueues); mockRepoWrapper.Setup(q => q.Queue.Update(It.IsAny <Entities.Models.Queue>())); mockRepoWrapper.Setup(r => r.Save()); mockHubContext.Setup(h => h.Clients.Group(It.IsAny <string>()) .SendCoreAsync(It.IsAny <string>(), It.Is <object[]>(o => o != null && o.Length == 1), default)); var resetQueue = new ResetQueue(mockScopeFactory.Object, mockHubContext.Object, _mapper); resetQueue.ProcessInScope(null); var outputQueues = querableQueues.Select(q => q.QueueNo).ToList(); Assert.True(outputQueues.Count == queues.Count); List <int> assertionList = new List <int>(); for (int i = 0; i < outputQueues.Count; i++) { assertionList.Add(1); } Assert.Equal(outputQueues, assertionList); }
public void DelayingQueuePassesCallsThrough() { var added = new List <string>(); var doned = new List <string>(); var fake = new FakeQueue <string> { OnAdd = added.Add, OnDone = doned.Add, OnLen = () => 42, }; var clock = new FakeSystemClock(); IDelayingQueue <string> delayingQueue = new DelayingQueue <string>(clock, fake); delayingQueue.Add("one"); delayingQueue.Done("two"); var len = delayingQueue.Len(); Assert.Equal("one", Assert.Single(added)); Assert.Equal("two", Assert.Single(doned)); Assert.Equal(42, len); }
public void DelayingQueuePassesCallsThrough() { // arrange var added = new List <string>(); var doned = new List <string>(); var fake = new FakeQueue <string> { OnAdd = added.Add, OnDone = doned.Add, OnLen = () => 42, }; var clock = new FakeSystemClock(); IDelayingQueue <string> delayingQueue = new DelayingQueue <string>(clock, fake); // act delayingQueue.Add("one"); delayingQueue.Done("two"); var len = delayingQueue.Len(); // assert added.ShouldHaveSingleItem().ShouldBe("one"); doned.ShouldHaveSingleItem().ShouldBe("two"); len.ShouldBe(42); }
public void NotifyWithPrimaryResourceCausesCacheEntryAndQueueItem() { var generator = Mock.Of <IOperatorGenerator <TypicalResource> >(); var typicalInformer = new FakeResourceInformer <TypicalResource>(); var podInformer = new FakeResourceInformer <V1Pod>(); var addCalls = new List <NamespacedName>(); var queue = new FakeQueue <NamespacedName> { OnAdd = addCalls.Add, }; var cache = new OperatorCache <TypicalResource>(); using var host = new HostBuilder() .ConfigureServices(services => { services .AddLogging() .AddKubernetesOperatorRuntime() .AddOperator <TypicalResource>(op => { op.WithRelatedResource <V1Pod>(); op.Configure(options => options.NewRateLimitingQueue = _ => queue); }) .AddSingleton(generator) .AddSingleton <IResourceInformer <TypicalResource> >(typicalInformer) .AddSingleton <IResourceInformer <V1Pod> >(podInformer) .AddSingleton <IOperatorCache <TypicalResource> >(cache); }) .Build(); var handler = host.Services.GetRequiredService <IOperatorHandler <TypicalResource> >(); var typical = new TypicalResource { ApiVersion = $"{TypicalResource.KubeGroup}/{TypicalResource.KubeApiVersion}", Kind = TypicalResource.KubeKind, Metadata = new V1ObjectMeta( name: "test-name", namespaceProperty: "test-namespace") }; var unrelatedPod = new V1Pod { ApiVersion = TypicalResource.KubeApiVersion, Kind = TypicalResource.KubeKind, Metadata = new V1ObjectMeta( name: "test-unrelated", namespaceProperty: "test-namespace") }; var relatedPod = new V1Pod( apiVersion: TypicalResource.KubeApiVersion, kind: TypicalResource.KubeKind, metadata: new V1ObjectMeta( name: "test-related", namespaceProperty: "test-namespace", ownerReferences: new[] { new V1OwnerReference( uid: typical.Uid(), apiVersion: typical.ApiVersion, kind: typical.Kind, name: typical.Name()) })); typicalInformer.Callback(WatchEventType.Added, typical); podInformer.Callback(WatchEventType.Added, unrelatedPod); podInformer.Callback(WatchEventType.Added, relatedPod); var expectedName = new NamespacedName("test-namespace", "test-name"); Assert.Equal(new[] { expectedName, expectedName }, addCalls); Assert.True(cache.TryGetWorkItem(expectedName, out var cacheItem)); Assert.Equal(typical, cacheItem.Resource); var related = Assert.Single(cacheItem.Related); Assert.Equal(GroupKindNamespacedName.From(relatedPod), related.Key); Assert.Equal(relatedPod, related.Value); }