public void CommitOutgoingMessageRealTest()
{
var environmentFactory = EnvironmentFactoryFactory.Create();
MessagingWorkers.Start(new TestBatchParameters(), environmentFactory.MessagingEnvironment.MessagingServiceClient);
var pltDeviceOperations = environmentFactory.ManagementEnvironment.ObjDeviceOperations;
var messagingService = new MessagingService(new MessagingOperations(), pltDeviceOperations);
messagingService.RecordOutgoingMessage(_deviceId, _deviceId, "32412341243");
var msg = messagingService.Peek(_deviceId);
Assert.AreEqual(OutgoingState.Ok, msg.State);
Assert.AreEqual(_deviceId, msg.Message.DeviceId);
Assert.AreEqual("32412341243", msg.Message.Payload);
Assert.AreEqual(_deviceId, msg.Message.SenderDeviceId);
var state = messagingService.Commit(_deviceId);
Assert.AreEqual(OutgoingState.Ok, state);
var state2 = messagingService.Commit(_deviceId);
Assert.AreEqual(OutgoingState.Ok, state2);
MessagingWorkers.Stop();
}
public void CommitOneTest()
{
var deviceId = MessagingService.Initialize(Identity.Next());
MessagingService.Enqueue(new EnqueueMessagesDto
{
Messages =
new List <EnqueueMessageDto>
{
new EnqueueMessageDto
{
DeviceId = deviceId,
Payload = Encoding.UTF8.GetBytes("Message no. 1"),
TimeStamp = DateTime.UtcNow,
SenderDeviceId = Identity.Next()
}
}
});
MessagingService.Peek(new DeviceListDto {
DeviceIds = new List <long> {
deviceId
}
});
var result = MessagingService.Commit(new DeviceListDto {
DeviceIds = new List <long> {
deviceId
}
});
Assert.AreEqual(1, result.DeviceIds.Count);
Assert.AreEqual(deviceId, result.DeviceIds[0]);
}
public void CommitOutgoingMessageNoDeviceTest()
{
var messagingOperations = Substitute.For <IMessagingOperations>();
var pltDeviceOperations = Substitute.For <IDeviceOperations>();
var messagingService = new MessagingService(messagingOperations, pltDeviceOperations);
messagingService.Commit(null);
}
public void CommitTwiceOutgoingMessageTest()
{
var messagingOperations = Substitute.For <IMessagingOperations>();
var pltDeviceOperations = Substitute.For <IDeviceOperations>();
pltDeviceOperations.Get("1234").Returns(TestDataCreator.Device("1234", "1234", "12345", "123456", "1234567", 1));
messagingOperations.Commit(1)
.Returns(OutgoingState.Ok);
var messagingService = new MessagingService(messagingOperations, pltDeviceOperations);
var state = messagingService.Commit("1234");
Assert.AreEqual(OutgoingState.Ok, state);
state = messagingService.Commit("1234");
Assert.AreEqual(OutgoingState.Ok, state);
}
public void TryCommitSameDeviceTest()
{
var deviceId = MessagingService.Initialize(Identity.Next());
MessagingService.Commit(new DeviceListDto {
DeviceIds = new List <long> {
deviceId, deviceId
}
});
}
public DeviceListDtoClient Commit(DeviceListDtoClient deviceList)
{
return(new DeviceListDtoClient
{
DeviceIds =
_messagingService.Commit(new DeviceListDto {
DeviceIds = deviceList.DeviceIds
})
.DeviceIds
});
}
public void CommitNothingTest()
{
var deviceId = MessagingService.Initialize(Identity.Next());
var result = MessagingService.Commit(new DeviceListDto {
DeviceIds = new List <long> {
deviceId
}
});
Assert.AreEqual(0, result.DeviceIds.Count);
}
public IActionResult Commit() // GET: v1/messages/commit
{
var deviceId = _authenticationContext.GetContextDevice(this.User);
var state = _messagingService.Commit(deviceId);
if (state == OutgoingState.Fail || state == OutgoingState.Throttled)
{
return(new HttpStatusCodeResult((int)HttpStatusCode.ServiceUnavailable));
}
return(new NoContentResult());
}
public void EnqueuePeekCommitTest()
{
var deviceId = MessagingService.Initialize(Identity.Next());
int enqueueCounter = 0;
int peekcommitCounter = 0;
var cancellationTokenSource = new CancellationTokenSource();
var cancellationToken = cancellationTokenSource.Token;
var peekcommitThread = new Thread(() =>
{
while (!cancellationToken.IsCancellationRequested)
{
var resultPeek = MessagingService.Peek(new DeviceListDto()
{
DeviceIds = new List <long>()
{
deviceId
}
});
if (resultPeek.Messages.Count == 1)
{
var resultCommit = MessagingService.Commit(new DeviceListDto()
{
DeviceIds = new List <long>()
{
deviceId
}
});
Interlocked.Add(ref peekcommitCounter, resultCommit.DeviceIds.Count);
}
}
});
var enqueueThread = new Thread(() =>
{
while (!cancellationToken.IsCancellationRequested)
{
MessagingService.Enqueue(new EnqueueMessagesDto
{
Messages = new List <EnqueueMessageDto>
{
new EnqueueMessageDto
{
DeviceId = deviceId,
Payload = Encoding.UTF8.GetBytes("Stress test message no. " + enqueueCounter),
TimeStamp = DateTime.UtcNow,
SenderDeviceId = Identity.Next()
}
}
});
Interlocked.Increment(ref enqueueCounter);
}
});
peekcommitThread.Start();
enqueueThread.Start();
WaitUntil(500, 1000, () => enqueueCounter);
cancellationTokenSource.Cancel();
enqueueThread.Join();
peekcommitThread.Join();
Assert.IsTrue(peekcommitCounter > 0);
Assert.IsTrue(enqueueCounter > 0);
Assert.IsTrue(enqueueCounter >= peekcommitCounter);
}
public void EnqueuePeekCommitManyDevicesTest()
{
var dequeueDictionary = new Dictionary <long, List <string> >();
var enqueueDictionary = new Dictionary <long, List <string> >();
const int deviceCount = 100;
const int dequeueRandomDeviceCount = 30;
const int enqueueRandomDeviceCount = 5;
for (int i = 0; i < deviceCount; i++)
{
var deviceId = MessagingService.Initialize(Identity.Next());
dequeueDictionary.Add(deviceId, new List <string>());
enqueueDictionary.Add(deviceId, new List <string>());
}
var deviceIds = dequeueDictionary.Keys.ToList();
int enqueueCounter = 0;
int dequeueCounter = 0;
var cancellationTokenSource = new CancellationTokenSource();
var cancellationToken = cancellationTokenSource.Token;
var dequeueThread = new Thread(() =>
{
while (!cancellationToken.IsCancellationRequested)
{
DequeueMessagesDto result = MessagingService.Peek(new DeviceListDto()
{
DeviceIds = GetRandomDevices(deviceIds, dequeueRandomDeviceCount)
});
MessagingService.Commit(new DeviceListDto
{
DeviceIds = result.Messages.Select(m => m.DeviceId).ToList()
});
Interlocked.Add(ref dequeueCounter, result.Messages.Count);
foreach (var msg in result.Messages)
{
dequeueDictionary[msg.DeviceId].Add(Encoding.UTF8.GetString(msg.Payload));
}
}
});
var enqueueThread = new Thread(() =>
{
while (!cancellationToken.IsCancellationRequested)
{
var randomDeviceIds = GetRandomDevices(deviceIds, enqueueRandomDeviceCount);
var messagesToEnqueue = new EnqueueMessagesDto {
Messages = new List <EnqueueMessageDto>()
};
foreach (var deviceId in randomDeviceIds)
{
var nextMsgId = enqueueDictionary[deviceId].Count + 1;
var nextMsg = "Stress test message no. " + nextMsgId;
enqueueDictionary[deviceId].Add(nextMsg);
var msgToEnqueue = new EnqueueMessageDto
{
DeviceId = deviceId,
Payload = Encoding.UTF8.GetBytes(nextMsg),
TimeStamp = DateTime.UtcNow,
SenderDeviceId = Identity.Next()
};
messagesToEnqueue.Messages.Add(msgToEnqueue);
}
var result = MessagingService.Enqueue(messagesToEnqueue);
Interlocked.Add(ref enqueueCounter, result.DeviceIds.Count);
}
});
dequeueThread.Start();
enqueueThread.Start();
WaitUntil(500, 10000, () => enqueueCounter);
cancellationTokenSource.Cancel();
enqueueThread.Join();
dequeueThread.Join();
Assert.IsTrue(dequeueCounter > 0);
Assert.IsTrue(enqueueCounter > 0);
Assert.IsTrue(enqueueCounter >= dequeueCounter);
foreach (var deviceId in deviceIds)
{
var enqueuedItems = enqueueDictionary[deviceId];
var dequeuedItems = dequeueDictionary[deviceId];
Assert.IsTrue(dequeuedItems.Count <= enqueuedItems.Count);
Assert.IsTrue(dequeuedItems.All(enqueuedItems.Contains));
var messageNumbers = dequeuedItems.Select(d => int.Parse(d.Substring(d.LastIndexOf(' ')))).ToList();
Assert.IsTrue(messageNumbers.SequenceEqual(messageNumbers.OrderBy(d => d)));
Assert.AreEqual(messageNumbers.Count, messageNumbers.Distinct().Count());
}
}
public DeviceListDto Commit([FromBody] DeviceListDto deviceList)
{
return(_messagingService.Commit(deviceList));
}
