public async Task CopyAllMessagesTest_many_messages()
{
//ARRANGE
var messageToEnque = 10000;
var consumed = 0;
var logger = new LogProviderMock();
var listener = new MessageListener1(m => Interlocked.Increment(ref consumed));
Func <ITransportConfiguration> configuration = () =>
{
var config = new TransportConfiguration
{
ConsumerPeriod = Timeout.InfiniteTimeSpan
};
config.Listeners.Add(listener);
return(config);
};
var transport = new InMemoryQueueTransport(logger, configuration);
var message = new byte[] { 0, 1, 2 };
await transport.Start();
for (var i = 0; i < messageToEnque; i++)
{
transport.Enque(message);
}
var destination = new byte[transport.PendingMessages][];
//ACT
await transport.CopyMessages(destination);
//ASSERT
Assert.AreEqual(messageToEnque, destination.Count());
Assert.AreEqual(messageToEnque, transport.PendingMessages);
}
public async Task ListnerTest_2_listeners()
{
//ARRANGE
var logger = new LogProviderMock();
Func <ITransportConfiguration> configuration = () => new TransportConfiguration();
var transport = new InMemoryQueueTransport(logger, configuration);
var manager = new TransportManager(transport, logger);
var message = new byte[] { 0, 1, 2 };
byte[] messageReceived1 = null;
byte[] messageReceived2 = null;
var listener1 = new MessageListener1(m => messageReceived1 = m);
var listener2 = new MessageListener2(m => messageReceived2 = m);
//ACT
await listener1.AttachTo(manager);
await listener2.AttachTo(manager);
await transport.Start();
await manager.EnqueueMessage(message);
Thread.Sleep(500);
//ASSERT
Assert.AreEqual(message, messageReceived1);
Assert.AreEqual(message, messageReceived2);
}
public async Task ConsumeMessagesTest_many_messages_async_enque_auto_dequeue()
{
//ARRANGE
var messageToEnque = 1000000;
var consumed = 0;
var logger = new LogProviderMock();
var listener = new MessageListener1(m => Interlocked.Increment(ref consumed));
Func <ITransportConfiguration> configuration = () =>
{
var config = new TransportConfiguration
{
ConsumerPeriod = TimeSpan.FromMilliseconds(1)
};
config.Listeners.Add(listener);
return(config);
};
var transport = new InMemoryQueueTransport(logger, configuration);
var message = new byte[] { 0, 1, 2 };
await transport.Start();
var enqueTask = Task.Factory.StartNew(() =>
{
for (var i = 0; i < messageToEnque; i++)
{
transport.Enque(message);
}
});
var enqueTask1 = Task.Factory.StartNew(() =>
{
for (var i = 0; i < messageToEnque; i++)
{
transport.Enque(message);
}
});
//ACT
Task.WaitAll(enqueTask, enqueTask1);
while (!transport.IsEmpty)
{
Thread.Sleep(1);
}
//ASSERT
Assert.AreEqual(0, transport.PendingMessages);
Assert.AreEqual(2 * messageToEnque, consumed);
}
public async Task ConsumeMessagesTest_many_messages_two_workers()
{
//ARRANGE
var messageToEnque = 100000;
var consumed = 0;
var logger = new LogProviderMock();
var listener = new MessageListener1(m => Interlocked.Increment(ref consumed));
Func <ITransportConfiguration> configuration = () =>
{
var config = new TransportConfiguration
{
ConsumerPeriod = Timeout.InfiniteTimeSpan
};
config.Listeners.Add(listener);
return(config);
};
var transport = new InMemoryQueueTransport(logger, configuration);
var message = new byte[] { 0, 1, 2 };
await transport.Start();
for (var i = 0; i < messageToEnque; i++)
{
transport.Enque(message);
}
//ACT
var task = Task.Factory.StartNew(() =>
{
transport.Consume(configuration());
});
var task1 = Task.Factory.StartNew(() =>
{
transport.Consume(configuration());
});
await Task.WhenAll(task, task1);
while (!transport.IsEmpty)
{
Thread.Sleep(1);
}
//ASSERT
Assert.AreEqual(messageToEnque, consumed);
Assert.AreEqual(0, transport.PendingMessages);
}
