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