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);
}
public void EnqueueMessageTest()
{
//ARRANGE
var logger = new LogProviderMock();
Func <ITransportConfiguration> configuration = () => new TransportConfiguration();
var transport = new InMemoryQueueTransport(logger, configuration);
var message = new byte[] { 0, 1, 2 };
byte[] dequeuedMessage;
//ACT
transport.Start();
transport.Enque(message);
var result = transport.TryDequeue(out dequeuedMessage);
//ASSERT
Assert.IsTrue(result);
Assert.AreEqual(message, dequeuedMessage);
}
static async Task Main(string[] args)
{
var messageDispatched = 0;
//var resolver = new UnityDependencyResolver();
//using (new InformationLogEventWriter())
//{
// ApplicationConfiguration.RegisterDependencyResolver(() => resolver);
// ApplicationConfiguration.RegisterServerInitialiserFactory(() => new ServerInitialiser());
// Program.InitializeServer();
//}
var compressor = new DeflateCompressor();
var serialaser = new InMemorySerializer(compressor);
var logger = new MockLogProvider();
var transport = new InMemoryQueueTransport(logger, () => new TransportConfiguration());
await transport.Start();
var transportManager = new TransportManager(transport, null);
var dispatcher = new TransportDispatcher(transportManager ,serialaser);//resolver.Resolve<ITranspontDispatcher>();
var internalListener = new MessageListener();
await dispatcher.TransportManager.RegisterListener(internalListener);
var tasks = new List<Task>();
for (var i = 0; i < 1; i++)
{
var batch = i;
var task = Task.Factory.StartNew(async () =>
{
for (var j = 0; j < 1; j++)
{
var command = new LogErrorCommand(Guid.NewGuid(), Guid.NewGuid());
Interlocked.Increment(ref messageDispatched);
Console.WriteLine(String.Format("Dispatched message No: {0}, batch: {1}. Total number messages: {2}", j, batch, messageDispatched));
//Thread.Sleep(10);
await dispatcher.SendMessage(command);
}
});
tasks.Add(task);
}
Console.ReadLine();
}
