/// <summary>
/// Request a responses from your service, this will invoke the request handler registered on your service as if it was called from another service.<br/>
/// </summary>
/// <param name="config">Request/Response Configuration</param>
/// <param name="request">Request message</param>
/// <typeparam name="TRequest">Type of Request Message</typeparam>
/// <typeparam name="TResponse">Type of Response Message</typeparam>
/// <returns>Response Message</returns>
public TResponse Request <TRequest, TResponse>(RequestResponseConfig config, TRequest request)
{
var queue = _requestQueues.FirstOrDefault(q => q.Key == config.Name);
var replyQueue = UniqueKeyUtility.Generate();
if (queue.Value != null)
{
MockMessage(queue.Value, new RequestMessage
{
MessageBody = SerializeToJson(request),
RequestType = typeof(TRequest).FullName,
ResponseType = typeof(TResponse).FullName,
Name = config.Name,
ReplyQueue = replyQueue
}, true);
// ReSharper disable once ImplicitlyCapturedClosure
TimerUtility.WaitForIt(() => _responses.Any(r => r.ReplyQueue == replyQueue), Debugger.IsAttached ? 360000 : config.MillisecondsTimeout);
}
Thread.Sleep(100);
var response = _responses.FirstOrDefault(r => r.ReplyQueue == replyQueue);
return(JsonConvert.DeserializeObject <TResponse>(response?.MessageBody));
}
public void CanWaitForItWithoutTimeout()
{
const bool res = true;
TimerUtility.WaitForIt(() => true);
res.Should().BeTrue();
}
public void CanStartTask()
{
var i = 0;
_cut.Start(() => ++ i, 10, new CancellationToken());
TimerUtility.WaitForIt(() => i > 2, 100);
_cut.Stop();
i.Should().BeGreaterOrEqualTo(2);
}
public void CanStartWithCancellationTokenTask()
{
var i = 0;
_cut.Start(() => ++ i, new CancellationToken());
TimerUtility.WaitForIt(() => i > 0, 100);
_cut.IsCompleted.Should().BeTrue();
i.Should().Be(1);
}
public void CanStartTask()
{
var i = 0;
_cut.Start(() => ++ i);
TimerUtility.WaitForIt(() => i > 0, 100);
_cut.IsCompleted.Should().BeTrue();
i.Should().Be(1);
}
private void ExecuteHandler(Action <object, CancellationToken> messageHandler, bool multiThreadedHandler)
{
using (var cut = new QueueHandler(NullLogger.Instance, _queueFactory, _taskFactory))
{
cut.Start("MyQueue", true, LocaleQueueMode.TemporaryMaster, true, messageHandler, null, null, 100, multiThreadedHandler, false, _cancellationToken);
// ReSharper disable once AccessToDisposedClosure
TimerUtility.WaitForIt(() => cut.Idle, 6000);
}
}
public void DeleteLocaleQueueShouldDeleteQueue()
{
var name = $"IntegrationTest_{UniqueKeyUtility.Generate()}";
try
{
_messageQueueManager.Create(name, true, true);
_messageQueueManager.Delete(name, true);
TimerUtility.WaitForIt(() => !_messageQueueManager.Exists(name, true), 10000);
_messageQueueManager.Exists(name, true).Should().BeFalse();
}
finally
{
_messageQueueManager.Delete(name, true);
}
}
public void CanRestartHandler()
{
using (var cut = new QueueHandler(NullLogger.Instance, _queueFactory, _taskFactory))
{
cut.Start("MyQueue", true, LocaleQueueMode.TemporaryMaster, true, (m, c) => { c.WaitHandle.WaitOne(2000); }, null, null, 100, true, false, _cancellationToken);
// ReSharper disable once AccessToDisposedClosure
TimerUtility.WaitForIt(() => cut.Idle, 6000);
cut.Stop();
cut.Start("MyQueue", true, LocaleQueueMode.TemporaryMaster, true, (m, c) => { c.WaitHandle.WaitOne(2000); }, null, null, 100, true, false, _cancellationToken);
// ReSharper disable once AccessToDisposedClosure
TimerUtility.WaitForIt(() => cut.Idle, 6000);
cut.Stop();
}
}
/// <inheritdoc />
public System.Messaging.MessageQueue Create(string name, bool privateQueue, bool transactional)
{
try
{
var queue = System.Messaging.MessageQueue.Create(Path(".", name, privateQueue), transactional);
if (!TimerUtility.WaitForIt(() => Exists(".", name, privateQueue), privateQueue ? 1000 : 20000))
{
throw new TimeoutException("Queue not created in time");
}
return(queue);
}
catch (Exception exception)
{
_logger.Information(exception, "Error Creating Message Queue {Name}", name);
throw new QueueCreateException(name, privateQueue, exception);
}
}
public void CanWaitForExpression()
{
var i = 0;
TimerUtility.WaitForIt(() => { ++i; return(i > 2); }, 100).Should().BeTrue();
}
public void CanWaitForItWithoutTimeout()
{
TimerUtility.WaitForIt(() => true);
}
public void CanWaitForItTimeout()
{
TimerUtility.WaitForIt(() => false, 100).Should().BeFalse();
}
private void WaitForIt()
{
TimerUtility.WaitForIt(() => _pendingMessages == 0, Debugger.IsAttached ? 3600000 : 6000);
}
