public void ChannelFlow_SetsIfTheChannelIsActive(bool value)
{
// Arrange
var node = new RabbitServer();
var model = new FakeModel(node);
// Act
model.ChannelFlow(value);
// Assert
Assert.That(model.IsChannelFlowActive,Is.EqualTo(value));
}
public void CreateStreamProperties_ReturnsStreamProperties()
{
// Arrange
var node = new RabbitServer();
var model = new FakeModel(node);
// Act
var result = model.CreateStreamProperties();
// Assert
Assert.That(result, Is.Not.Null);
}
private void ConfigureQueueBinding(RabbitServer rabbitServer, string exchangeName, string queueName)
{
var connectionFactory = new FakeConnectionFactory(rabbitServer);
using (var connection = connectionFactory.CreateConnection())
using (var channel = connection.CreateModel())
{
channel.QueueDeclare(queue:queueName,durable:false,exclusive:false,autoDelete:false,arguments:null);
channel.ExchangeDeclare(exchange: exchangeName, type: ExchangeType.Direct);
channel.QueueBind(queueName,exchangeName,null);
}
}
public void WithRabbitServer_SetsServer()
{
// Arrange
var factory = new FakeConnectionFactory();
var otherServer = new RabbitServer();
factory.WithRabbitServer(otherServer);
// Act
var result = factory.Server;
// Assert
Assert.That(result, Is.SameAs(otherServer));
}
public void SendToExchangeOnly()
{
var rabbitServer = new RabbitServer();
var connectionFactory = new FakeConnectionFactory(rabbitServer);
using (var connection = connectionFactory.CreateConnection())
using (var channel = connection.CreateModel())
{
const string message = "hello world!";
var messageBody = Encoding.ASCII.GetBytes(message);
channel.BasicPublish(exchange:"my_exchange",routingKey:null,mandatory:false,basicProperties:null,body:messageBody);
}
Assert.That(rabbitServer.Exchanges["my_exchange"].Messages.Count,Is.EqualTo(1));
}
public void ExchangeDeclare_AllArguments_CreatesExchange()
{
// Arrange
var node = new RabbitServer();
var model = new FakeModel(node);
const string exchangeName = "someExchange";
const string exchangeType = "someType";
const bool isDurable = true;
const bool isAutoDelete = false;
var arguments = new Hashtable();
// Act
model.ExchangeDeclare(exchange:exchangeName,type:exchangeType,durable:isDurable,autoDelete:isAutoDelete,arguments:arguments);
// Assert
Assert.That(node.Exchanges,Has.Count.EqualTo(1));
var exchange = node.Exchanges.First();
AssertExchangeDetails(exchange, exchangeName, isAutoDelete, arguments, isDurable, exchangeType);
}
public void QueuePurge_RemovesAllMessagesFromQueue()
{
// Arrange
var node = new RabbitServer();
var model = new FakeModel(node);
model.QueueDeclarePassive("my_other_queue");
node.Queues["my_other_queue"].Messages.Enqueue(new RabbitMessage());
node.Queues["my_other_queue"].Messages.Enqueue(new RabbitMessage());
model.QueueDeclarePassive("my_queue");
node.Queues["my_queue"].Messages.Enqueue(new RabbitMessage());
node.Queues["my_queue"].Messages.Enqueue(new RabbitMessage());
node.Queues["my_queue"].Messages.Enqueue(new RabbitMessage());
node.Queues["my_queue"].Messages.Enqueue(new RabbitMessage());
// Act
model.QueuePurge("my_queue");
// Assert
Assert.That(node.Queues["my_queue"].Messages, Is.Empty);
Assert.That(node.Queues["my_other_queue"].Messages, Is.Not.Empty);
}
public void ReceiveMessagesOnQueue()
{
var rabbitServer = new RabbitServer();
ConfigureQueueBinding(rabbitServer, "my_exchange", "my_queue");
SendMessage(rabbitServer, "my_exchange", "hello_world");
var connectionFactory = new FakeConnectionFactory(rabbitServer);
using (var connection = connectionFactory.CreateConnection())
using (var channel = connection.CreateModel())
{
// First message
var message = channel.BasicGet("my_queue", noAck: false);
Assert.That(message, Is.Not.Null);
var messageBody = Encoding.ASCII.GetString(message.Body);
Assert.That(messageBody, Is.EqualTo("hello_world"));
channel.BasicAck(message.DeliveryTag, multiple: false);
}
}
public void BasicAck()
{
var node = new RabbitServer();
var model = new FakeModel(node);
model.ExchangeDeclare("my_exchange", ExchangeType.Direct);
model.QueueDeclarePassive("my_queue");
model.ExchangeBind("my_queue", "my_exchange", null);
var message = "hello world!";
var encodedMessage = Encoding.ASCII.GetBytes(message);
model.BasicPublish("my_exchange", null, new BasicProperties(), encodedMessage);
model.BasicConsume("my_queue", false, new EventingBasicConsumer(model));
// Act
var deliveryTag = model._workingMessages.First().Key;
model.BasicAck(deliveryTag, false);
// Assert
Assert.That(node.Queues["my_queue"].Messages.Count, Is.EqualTo(0));
}
public void QueueDeclare_WithExclusive_DifferentModel_CreatesQueue()
{
// Arrange
var node = new RabbitServer();
var model = new FakeModel(node);
var model2 = new FakeModel(node);
const string queueName = "someQueue";
const bool isDurable = true;
const bool isExclusive = true;
const bool isAutoDelete = true;
var arguments = new Dictionary <string, object>();
// Act
model.QueueDeclare(queue: queueName, durable: isDurable, exclusive: isExclusive, autoDelete: isAutoDelete, arguments: arguments);
var ex = Assert.Throws <OperationInterruptedException>(
delegate { model2.QueueDeclare(queue: queueName, durable: isDurable, exclusive: isExclusive, autoDelete: isAutoDelete, arguments: arguments); });
// Assert
Assert.That(ex.ShutdownReason.ReplyCode, Is.EqualTo(405));
Assert.That(ex.ShutdownReason.Initiator, Is.EqualTo(ShutdownInitiator.Peer));
StringAssert.StartsWith($"RESOURCE_LOCKED - cannot obtain exclusive access to locked queue '{queueName}'", ex.ShutdownReason.ReplyText);
}
public void QueueDeclare_WithExclusive_SameModel_CreatesQueue()
{
// Arrange
var node = new RabbitServer();
var model = new FakeModel(node);
const string queueName = "someQueue";
const bool isDurable = true;
const bool isExclusive = true;
const bool isAutoDelete = true;
var arguments = new Dictionary <string, object>();
// Act
model.QueueDeclare(queue: queueName, durable: isDurable, exclusive: isExclusive, autoDelete: isAutoDelete, arguments: arguments);
model.QueueDeclare(queue: queueName, durable: isDurable, exclusive: isExclusive, autoDelete: isAutoDelete, arguments: arguments);
// Assert
Assert.That(node.Queues, Has.Count.EqualTo(1));
var queue = node.Queues.First();
AssertQueueDetails(queue, queueName, isAutoDelete, arguments, isDurable, isExclusive);
}
public void RabbitMQ_ReceiveMessage()
{
var rabbitServer = new RabbitServer();
var connectionFactory = new FakeConnectionFactory(rabbitServer);
using (var connection = connectionFactory.CreateConnection())
{
var helper = new RabbitMQHelper(connection, "test_exchange");
var message = Encoding.UTF8.GetBytes("bob");
helper.PushMessageIntoQueue(message, "my_queue");
// First message
var response = helper.ReadMessageFromQueue("my_queue");
response.Should().NotBeNull();
var messageBody = Encoding.UTF8.GetString(message);
messageBody.Should().Be("bob");
}
}
public void SendingAndGettingMultipleMessages()
{
var rabbitServer = new RabbitServer();
var connectionFactory = new FakeConnectionFactory(rabbitServer);
ConfigureQueueBinding(rabbitServer, "my_exchange", "some_queue");
using (var connection = connectionFactory.CreateConnection())
using (var channel = connection.CreateModel())
{
const string message = "hello world!";
var messageBody = Encoding.ASCII.GetBytes(message);
channel.BasicPublish("my_exchange", null, false, channel.CreateBasicProperties(), messageBody);
channel.BasicPublish("my_exchange", null, false, channel.CreateBasicProperties(), messageBody);
var result = channel.BasicGet("some_queue", false);
Assert.That(rabbitServer.Queues["some_queue"].Messages.Count, Is.EqualTo(2));
channel.BasicAck(result.DeliveryTag, false);
Assert.That(rabbitServer.Queues["some_queue"].Messages.Count, Is.EqualTo(1));
result = channel.BasicGet("some_queue", false);
Assert.That(rabbitServer.Queues["some_queue"].Messages.Count, Is.EqualTo(1));
channel.BasicAck(result.DeliveryTag, false);
Assert.That(rabbitServer.Queues["some_queue"].Messages.Count, Is.EqualTo(0));
}
}
public void Nacking_Message_Should_Not_Reenqueue_Brand_New_Message(bool requeue, int expectedMessageCount)
{
// arrange
var node = new RabbitServer();
var model = new FakeModel(node);
var consumer = new QueueingBasicConsumer();
model.ExchangeDeclare("my_exchange", ExchangeType.Direct);
model.QueueDeclare("my_queue");
model.ExchangeBind("my_queue", "my_exchange", null);
var encodedMessage = Encoding.ASCII.GetBytes("hello world!");
model.BasicPublish("my_exchange", null, new BasicProperties(), encodedMessage);
model.BasicConsume("my_queue", false, consumer);
// act
consumer.Queue.TryDequeue(out var message);
model.BasicNack(message.DeliveryTag, false, requeue);
// assert
Assert.That(consumer.Queue.Count, Is.EqualTo(expectedMessageCount));
Assert.That(model.WorkingMessages.Count, Is.EqualTo(expectedMessageCount));
}
public async Task TopicPatternTest()
{
Dictionary <string, int> dict = new Dictionary <string, int>(); //接收的消息数量
Dictionary <string, int> expectedDict = new Dictionary <string, int>(); //发送的消息数量
string[] queues = new string[] { $"{queue1}.topic", $"{queue2}.topic" };
var routeQueues = queues.Select(f => new RouteQueue()
{
Arguments = null,
Queue = f,
Route = $"#.{f}.#",
Options = new QueueOptions()
{
AutoDelete = true,
Durable = true,
Arguments = arguments
}
}).ToArray();
RabbitServer rabbitServer = new RabbitServer();
rabbitServer.Register(services =>
{
services.AddRabbitProducer(options =>
{
options.Hosts = hosts;
options.Port = port;
options.UserName = userName;
options.Password = password;
options.VirtualHost = virtualHost;
options.Arguments = arguments;
options.AutoDelete = true;
options.Durable = true;
options.Queues = null;
options.Type = RabbitExchangeType.Topic;
options.RouteQueues = routeQueues;
options.Exchange = topic;
options.InitializeCount = 10;
});
var builder = services.AddRabbitConsumer(options =>
{
options.Hosts = hosts;
options.Port = port;
options.UserName = userName;
options.Password = password;
options.VirtualHost = virtualHost;
options.Arguments = arguments;
options.AutoDelete = true;
options.Durable = true;
options.Type = RabbitExchangeType.Topic;
options.RouteQueues = routeQueues;
options.FetchCount = 1;
options.AutoAck = false;
});
foreach (var queue in queues)
{
dict[queue] = 0;
expectedDict[queue] = 0;
builder.AddListener(topic, queue, result =>
{
Output.WriteLine($"{queue}:" + JsonSerializer.Serialize(result));
dict[queue]++;
result.Commit();
});
}
});
await rabbitServer.StartAsync();
Thread.Sleep(1000);//等待运行1秒
var serviceProvider = rabbitServer.ServiceProvider;
var factory = serviceProvider.GetService <IRabbitProducerFactory>();
var producer = factory.Create();
for (var i = 0; i < 10; i++)
{
var routeQueue = routeQueues[new Random().Next(0, routeQueues.Length)];
await producer.PublishAsync($"{nameof(RabbitMqServiceTest)}.{routeQueue.Queue}.{i}", "direct" + i);
expectedDict[routeQueue.Queue] += 1;
}
BlockUntil(() => dict.Sum(f => f.Value) >= 10, 3000);
foreach (var queue in queues)
{
Output.WriteLine($"{queue}:{expectedDict[queue]}-{dict[queue]}");
Assert.Equal(expectedDict[queue], dict[queue]);
}
await rabbitServer.StopAsync();
}
public void QueuePurge_RemovesAllMessagesFromQueue()
{
// Arrange
var node = new RabbitServer();
var model = new FakeModel(node);
model.QueueDeclarePassive("my_other_queue");
node.Queues["my_other_queue"].Messages.Enqueue(new RabbitMessage());
node.Queues["my_other_queue"].Messages.Enqueue(new RabbitMessage());
model.QueueDeclarePassive("my_queue");
node.Queues["my_queue"].Messages.Enqueue(new RabbitMessage());
node.Queues["my_queue"].Messages.Enqueue(new RabbitMessage());
node.Queues["my_queue"].Messages.Enqueue(new RabbitMessage());
node.Queues["my_queue"].Messages.Enqueue(new RabbitMessage());
// Act
model.QueuePurge("my_queue");
// Assert
Assert.That(node.Queues["my_queue"].Messages, Is.Empty);
Assert.That(node.Queues["my_other_queue"].Messages, Is.Not.Empty);
}
public RabbitMQHelperTests()
{
server = new RabbitServer();
connection = new FakeConnection(server);
}
private static void RegisterBaseClasses(IUnityContainer container, ISdkConfiguration config)
{
container.RegisterInstance(config, new ContainerControlledLifetimeManager());
//register common types
container.RegisterType <HttpClient, HttpClient>(
new ContainerControlledLifetimeManager(),
new InjectionConstructor());
var seed = (int)DateTime.Now.Ticks;
var rand = new Random(seed);
var value = rand.Next();
Log.Info($"Initializing sequence generator with MinValue={value}, MaxValue={long.MaxValue}");
container.RegisterType <ISequenceGenerator, IncrementalSequenceGenerator>(
new ContainerControlledLifetimeManager(),
new InjectionConstructor(
(long)value,
long.MaxValue));
container.RegisterType <HttpDataFetcher, HttpDataFetcher>("Base",
new ContainerControlledLifetimeManager(),
new InjectionConstructor(
new ResolvedParameter <HttpClient>(),
config.AccessToken ?? string.Empty,
RestConnectionFailureLimit,
RestConnectionFailureTimeoutInSec));
container.RegisterType <LogHttpDataFetcher, LogHttpDataFetcher>("Base",
new ContainerControlledLifetimeManager(),
new InjectionConstructor(
new ResolvedParameter <HttpClient>(),
config.AccessToken ?? string.Empty,
new ResolvedParameter <ISequenceGenerator>(),
RestConnectionFailureLimit,
RestConnectionFailureTimeoutInSec));
var logFetcher = container.Resolve <LogHttpDataFetcher>("Base");
container.RegisterInstance <IDataFetcher>("Base", logFetcher, new ContainerControlledLifetimeManager());
container.RegisterInstance <IDataPoster>("Base", logFetcher, new ContainerControlledLifetimeManager());
container.RegisterType <ISdkConfigurationInternal, SdkConfigurationInternal>(new ContainerControlledLifetimeManager());
var configInternal = new SdkConfigurationInternal(config, logFetcher);
container.RegisterInstance(configInternal);
if (configInternal.Host.Contains("mtsgate-t1"))
{
_environment = "PROD";
}
else if (configInternal.Host.Contains("mtsgate-ci"))
{
_environment = "CI";
}
else
{
_environment = "CUSTOM";
}
container.RegisterType <IRabbitServer>(new ContainerControlledLifetimeManager());
var rabbitServer = new RabbitServer(configInternal);
container.RegisterInstance <IRabbitServer>(rabbitServer);
container.RegisterType <ConnectionValidator, ConnectionValidator>(new ContainerControlledLifetimeManager());
container.RegisterType <IConnectionFactory, ConfiguredConnectionFactory>(new ContainerControlledLifetimeManager());
container.RegisterType <IChannelFactory, ChannelFactory>(new ContainerControlledLifetimeManager());
container.RegisterInstance <ISequenceGenerator>(new IncrementalSequenceGenerator(), new ContainerControlledLifetimeManager());
container.RegisterInstance <IConnectionStatus>(new ConnectionStatus(), new ContainerControlledLifetimeManager());
}
public void BasicGet_MessageOnQueue_GetsMessage()
{
// Arrange
var node = new RabbitServer();
var model = new FakeModel(node);
model.ExchangeDeclare("my_exchange", ExchangeType.Direct);
model.QueueDeclarePassive("my_queue");
model.ExchangeBind("my_queue", "my_exchange", null);
var message = "hello world!";
var encodedMessage = Encoding.ASCII.GetBytes(message);
model.BasicPublish("my_exchange", null, new BasicProperties(), encodedMessage);
// Act
var response = model.BasicGet("my_queue",false);
// Assert
Assert.That(response.Body, Is.EqualTo(encodedMessage));
Assert.That(response.DeliveryTag, Is.GreaterThan(0));
}
public ConsumerService(ILogger <ConsumerService> logger, ConsumerConfiguration consumerConfigurations, LogFormat logFormat, RabbitServer rabbitServer, IConfiguration iConfig, IDatabaseObjects databaseObjects)
{
_consumerConfigurations = consumerConfigurations;
_logger = logger;
_iConfig = iConfig;
_logFormat = logFormat;
_rabbitServer = rabbitServer;
_instances = new Dictionary <IParser, string>();
_databaseObjects = databaseObjects;
var usedDevices = _databaseObjects._usedDevice.Get();
foreach (var item in usedDevices)
{
var targetType = Type.GetType("MLConsumer.DeviceAndParserServices." + item.DeviceClassName);
_instances.Add(Activator.CreateInstance((targetType), _databaseObjects._errorLogService, _iConfig) as IParser, item.DeviceBrand);
}
}
public void TestInitialize()
{
_rabbitServer = new RabbitServer();
_connectionFactory = new FakeConnectionFactory(_rabbitServer);
_rabbitMqHistory = new RabbitMqHistory(_connectionFactory);
}
public void BasicPublish_PublishesMessage()
{
// Arrange
var node = new RabbitServer();
var model = new FakeModel(node);
model.ExchangeDeclare("my_exchange",ExchangeType.Direct);
model.QueueDeclarePassive("my_queue");
model.ExchangeBind("my_queue", "my_exchange", null);
var message = "hello world!";
var encodedMessage = Encoding.ASCII.GetBytes(message);
// Act
model.BasicPublish("my_exchange", null, new BasicProperties(), encodedMessage);
// Assert
Assert.That(node.Queues["my_queue"].Messages.Count,Is.EqualTo(1));
Assert.That(node.Queues["my_queue"].Messages.First().Body, Is.EqualTo(encodedMessage));
}
public void QueueBind_BindsAnExchangeToAQueue()
{
// Arrange
var node = new RabbitServer();
var model = new FakeModel(node);
const string queueName = "someQueue";
const string exchangeName = "someExchange";
const string routingKey = "someRoutingKey";
var arguments = new Hashtable();
model.ExchangeDeclare(exchangeName, "direct");
model.QueueDeclarePassive(queueName);
// Act
model.QueueBind(queueName, exchangeName, routingKey, arguments);
// Assert
AssertBinding(node, exchangeName, routingKey, queueName);
}
private static void AssertBinding(RabbitServer server, string exchangeName, string routingKey, string queueName)
{
Assert.That(server.Exchanges[exchangeName].Bindings, Has.Count.EqualTo(1));
Assert.That(server.Exchanges[exchangeName].Bindings.First().Value.RoutingKey, Is.EqualTo(routingKey));
Assert.That(server.Exchanges[exchangeName].Bindings.First().Value.Queue.Name, Is.EqualTo(queueName));
}
public void ExchangeDelete_ExchangeDoesNotExists_DoesNothing()
{
// Arrange
var node = new RabbitServer();
var model = new FakeModel(node);
const string exchangeName = "someExchange";
model.ExchangeDeclare(exchangeName, "someType");
// Act
model.ExchangeDelete(exchange: "someOtherExchange");
// Assert
Assert.That(node.Exchanges, Has.Count.EqualTo(1));
}
public void ExchangeDeleteNoWait_ExchangeExists_RemovesTheExchange(bool ifUnused)
{
// Arrange
var node = new RabbitServer();
var model = new FakeModel(node);
const string exchangeName = "someExchange";
model.ExchangeDeclare(exchangeName, "someType");
// Act
model.ExchangeDeleteNoWait(exchange: exchangeName, ifUnused: ifUnused);
// Assert
Assert.That(node.Exchanges, Has.Count.EqualTo(0));
}
public void ExchangeDeclarePassive_WithName_CreatesExchange()
{
// Arrange
var node = new RabbitServer();
var model = new FakeModel(node);
const string exchangeName = "someExchange";
// Act
model.ExchangeDeclarePassive(exchange: exchangeName);
// Assert
Assert.That(node.Exchanges, Has.Count.EqualTo(1));
var exchange = node.Exchanges.First();
AssertExchangeDetails(exchange, exchangeName, false, null, false, null);
}
public void Close_ClosesTheChannel()
{
// Arrange
var node = new RabbitServer();
var model = new FakeModel(node);
// Act
model.Close();
// Assert
Assert.That(model.IsClosed,Is.True);
Assert.That(model.IsOpen,Is.False);
Assert.That(model.CloseReason,Is.Not.Null);
}
public async Task SimplePatternTest()
{
int counter = 0;
string queue = $"{queue1}.simple";
RabbitServer rabbitServer = new RabbitServer();
rabbitServer.Register(services =>
{
services.AddRabbitProducer(options =>
{
options.Hosts = hosts;
options.Port = port;
options.UserName = userName;
options.Password = password;
options.VirtualHost = virtualHost;
options.Arguments = arguments;
options.AutoDelete = true;
options.Durable = true;
options.Queues = new string[] { queue };
options.Type = RabbitExchangeType.None;
options.RouteQueues = null;
options.Exchange = string.Empty;
options.InitializeCount = 10;
});
services.AddRabbitConsumer(options =>
{
options.Hosts = hosts;
options.Port = port;
options.UserName = userName;
options.Password = password;
options.VirtualHost = virtualHost;
options.Arguments = arguments;
options.AutoDelete = true;
options.Durable = true;
options.Type = RabbitExchangeType.None;
options.RouteQueues = null;
options.FetchCount = 10;
options.AutoAck = true;
}).AddListener(queue, result =>
{
Output.WriteLine(JsonSerializer.Serialize(result));
counter++;
});
});
await rabbitServer.StartAsync();
Thread.Sleep(1000);//等待运行1秒
var serviceProvider = rabbitServer.ServiceProvider;
var factory = serviceProvider.GetService <IRabbitProducerFactory>();
var producer = factory.Create();
await producer.PublishAsync("hello simple");
await producer.PublishAsync("hello simple again");
BlockUntil(() => counter >= 2, 3000);
Assert.Equal(2, counter);
await rabbitServer.StopAsync();
}
public void Abort_WithArguments_ClosesTheChannel()
{
// Arrange
var node = new RabbitServer();
var model = new FakeModel(node);
// Act
model.Abort(5, "some message");
// Assert
Assert.That(model.IsClosed, Is.True);
Assert.That(model.IsOpen, Is.False);
Assert.That(model.CloseReason, Is.Not.Null);
}
public void QueueDeclarePassive_WithName_CreatesQueue()
{
// Arrange
var node = new RabbitServer();
var model = new FakeModel(node);
const string queueName = "myQueue";
// Act
model.QueueDeclarePassive(queueName);
// Assert
Assert.That(node.Queues, Has.Count.EqualTo(1));
Assert.That(node.Queues.First().Key, Is.EqualTo(queueName));
Assert.That(node.Queues.First().Value.Name, Is.EqualTo(queueName));
}
public async Task LoggerTopicTest()
{
Dictionary <string, int> dict = new Dictionary <string, int>(); //接收的消息数量
Dictionary <string, int> expectedDict = new Dictionary <string, int>(); //发送的消息数量
string[] queues = new string[] { $"{logger}.{queue1}.topic", $"{logger}.{queue2}.topic" };
var routeQueues = queues.Select(f => new RouteQueue()
{
Arguments = null,
Queue = f,
Route = $"#.{f}.#",
Options = new QueueOptions()
{
AutoDelete = true,
Durable = true,
Arguments = arguments
}
}).ToArray();
RabbitServer rabbitServer = new RabbitServer();
rabbitServer.Register(services =>
{
services.AddLogging(builder =>
{
builder.SetMinimumLevel(LogLevel.Trace);
});
services.AddRabbitLogger(options =>
{
options.Hosts = hosts;
options.Port = port;
options.UserName = userName;
options.Password = password;
options.VirtualHost = virtualHost;
options.Arguments = arguments;
options.AutoDelete = true;
options.Durable = true;
options.Queue = string.Empty;
options.Type = RabbitExchangeType.Topic;
options.RouteQueues = routeQueues;
options.Exchange = topic;
options.ApplicationName = nameof(RabbitMqServiceTest.LoggerTopicTest);
options.Category = nameof(RabbitMqServiceTest);
options.MinLevel = LogLevel.Information;
});
var builder = services.AddRabbitConsumer(options =>
{
options.Hosts = hosts;
options.Port = port;
options.UserName = userName;
options.Password = password;
options.VirtualHost = virtualHost;
options.Arguments = arguments;
options.AutoDelete = true;
options.Durable = true;
options.Type = RabbitExchangeType.Topic;
options.RouteQueues = routeQueues;
options.FetchCount = 10;
options.AutoAck = true;
});
foreach (var queue in queues)
{
dict[queue] = 0;
expectedDict[queue] = 0;
builder.AddListener(topic, queue, result =>
{
WriteLogger(queue, result);
if (result.Body.Contains(nameof(RabbitMqServiceTest)))
{
dict[queue]++;
}
});
}
});
await rabbitServer.StartAsync();
Thread.Sleep(1000);//等待运行1秒
var serviceProvider = rabbitServer.ServiceProvider;
var loggerFactory = serviceProvider.GetService <ILoggerFactory>();
int per = 4, count = 10;
for (var i = 0; i < count; i++)
{
var routeQueue = routeQueues[new Random().Next(0, routeQueues.Length)];
var logger = loggerFactory.CreateLogger($"{nameof(RabbitMqServiceTest)}.{routeQueue.Queue}.{i}");
logger.LogTrace("LogTrace");
logger.LogDebug("LogDebug");
logger.LogInformation("LogInformation");
logger.LogWarning("LogWarning");
logger.LogError("LogError");
logger.LogCritical("LogCritical");
expectedDict[routeQueue.Queue] += per;
}
BlockUntil(() => dict.Sum(f => f.Value) >= per * count, 3000);
Thread.Sleep(1000);//等待运行1秒
foreach (var queue in queues)
{
Output.WriteLine($"{queue}:{expectedDict[queue]}-{dict[queue]}");
Assert.Equal(expectedDict[queue], dict[queue]);
}
await rabbitServer.StopAsync();
}
public void QueueDeclare_CreatesQueue()
{
// Arrange
var node = new RabbitServer();
var model = new FakeModel(node);
const string queueName = "someQueue";
const bool isDurable = true;
const bool isExclusive = true;
const bool isAutoDelete = false;
var arguments = new Hashtable();
// Act
model.QueueDeclare(queue:queueName,durable:isDurable,exclusive:isExclusive,autoDelete:isAutoDelete,arguments:arguments);
// Assert
Assert.That(node.Queues, Has.Count.EqualTo(1));
var queue = node.Queues.First();
AssertQueueDetails(queue, queueName, isAutoDelete, arguments, isDurable, isExclusive);
}
public void BasicGet_NoQueue_ReturnsNull()
{
// Arrange
var node = new RabbitServer();
var model = new FakeModel(node);
// Act
var response = model.BasicGet("my_queue", false);
// Assert
Assert.That(response, Is.Null);
}
public async Task LoggerQueueTest()
{
int counter = 0;
string queue = $"{logger}.queue";
RabbitServer rabbitServer = new RabbitServer();
rabbitServer.Register(services =>
{
services.AddLogging(builder =>
{
builder.SetMinimumLevel(LogLevel.Trace);
});
services.AddRabbitLogger(options =>
{
options.Hosts = hosts;
options.Port = port;
options.UserName = userName;
options.Password = password;
options.VirtualHost = virtualHost;
options.Arguments = arguments;
options.AutoDelete = true;
options.Durable = true;
options.Queue = queue;
options.Type = RabbitExchangeType.None;
options.RouteQueues = null;
options.Exchange = string.Empty;
options.ApplicationName = nameof(RabbitMqServiceTest.LoggerQueueTest);
options.Category = nameof(RabbitMqServiceTest);
options.MinLevel = LogLevel.Trace;
});
services.AddRabbitConsumer(options =>
{
options.Hosts = hosts;
options.Port = port;
options.UserName = userName;
options.Password = password;
options.VirtualHost = virtualHost;
options.Arguments = arguments;
options.AutoDelete = true;
options.Durable = true;
options.Type = RabbitExchangeType.None;
options.RouteQueues = null;
options.FetchCount = 10;
options.AutoAck = true;
}).AddListener(queue, result =>
{
WriteLogger(queue, result);
if (result.Body.Contains(nameof(RabbitMqServiceTest)))
{
counter++;
}
});
});
await rabbitServer.StartAsync();
Thread.Sleep(1000);//等待运行1秒
var serviceProvider = rabbitServer.ServiceProvider;
var loggerFactory = serviceProvider.GetService <ILoggerFactory>();
var _logger = loggerFactory.CreateLogger <RabbitMqServiceTest>();
_logger.LogTrace("LogTrace");
_logger.LogDebug("LogDebug");
_logger.LogInformation("LogInformation");
_logger.LogWarning("LogWarning");
_logger.LogError("LogError");
_logger.LogCritical("LogCritical");
BlockUntil(() => counter >= 6, 3000);
Thread.Sleep(1000);//等待运行1秒
Assert.Equal(6, counter);
await rabbitServer.StopAsync();
}
public void ExchangeDeclare_WithNameTypeAndDurable_CreatesExchange()
{
// Arrange
var node = new RabbitServer();
var model = new FakeModel(node);
const string exchangeName = "someExchange";
const string exchangeType = "someType";
const bool isDurable = true;
// Act
model.ExchangeDeclare(exchange: exchangeName, type: exchangeType, durable: isDurable);
// Assert
Assert.That(node.Exchanges, Has.Count.EqualTo(1));
var exchange = node.Exchanges.First();
AssertExchangeDetails(exchange, exchangeName, false, null, isDurable, exchangeType);
}
public void QueueDeleteNoWait_WithArguments_DeletesTheQueue()
{
// Arrange
var node = new RabbitServer();
var model = new FakeModel(node);
const string queueName = "someName";
model.QueueDeclare(queueName, true, true, true, null);
// Act
model.QueueDeleteNoWait(queueName, true, true);
// Assert
Assert.That(node.Queues, Is.Empty);
}
public void TearDown()
{
RabbitClient.Close();
RabbitServer.Close();
}
public void QueueDelete_NonExistentQueue_DoesNothing()
{
// Arrange
var node = new RabbitServer();
var model = new FakeModel(node);
// Act
model.QueueDelete("someQueue");
// Assert
Assert.That(node.Queues, Is.Empty);
}
private static void AssertBinding(RabbitServer server, string exchangeName, string routingKey, string queueName)
{
Assert.That(server.Exchanges[exchangeName].Bindings, Has.Count.EqualTo(1));
Assert.That(server.Exchanges[exchangeName].Bindings.First().Value.RoutingKey, Is.EqualTo(routingKey));
Assert.That(server.Exchanges[exchangeName].Bindings.First().Value.Queue.Name, Is.EqualTo(queueName));
}
public async Task WorkerPatternTest()
{
int counter1 = 0, counter2 = 0;
string queue = $"{queue1}.worker";
RabbitServer rabbitServer = new RabbitServer();
rabbitServer.Register(services =>
{
services.AddRabbitProducer(options =>
{
options.Hosts = hosts;
options.Port = port;
options.UserName = userName;
options.Password = password;
options.VirtualHost = virtualHost;
options.Arguments = arguments;
options.AutoDelete = true;
options.Durable = true;
options.Queues = new string[] { queue };
options.Type = RabbitExchangeType.None;
options.RouteQueues = null;
options.Exchange = string.Empty;
options.InitializeCount = 10;
});
services.AddRabbitConsumer(options =>
{
options.Hosts = hosts;
options.Port = port;
options.UserName = userName;
options.Password = password;
options.VirtualHost = virtualHost;
options.Arguments = arguments;
options.AutoDelete = true;
options.Durable = true;
options.Type = RabbitExchangeType.None;
options.RouteQueues = null;
options.FetchCount = 1;
options.AutoAck = false;
}).AddListener(queue, result =>
{
Output.WriteLine($"worker1:" + JsonSerializer.Serialize(result));
counter1++;
result.Commit();
});
services.AddRabbitConsumer(options =>
{
options.Hosts = hosts;
options.Port = port;
options.UserName = userName;
options.Password = password;
options.VirtualHost = virtualHost;
options.Arguments = arguments;
options.AutoDelete = true;
options.Durable = true;
options.Type = RabbitExchangeType.None;
options.RouteQueues = null;
options.FetchCount = 2;
options.AutoAck = false;
}).AddListener(queue, result =>
{
Output.WriteLine($"worker2:" + JsonSerializer.Serialize(result));
counter2++;
result.Commit();
});
});
await rabbitServer.StartAsync();
Thread.Sleep(1000);//等待运行1秒
var serviceProvider = rabbitServer.ServiceProvider;
var factory = serviceProvider.GetService <IRabbitProducerFactory>();
var producer = factory.Create();
for (var i = 0; i < 10; i++)
{
await producer.PublishAsync("worker" + i);
}
BlockUntil(() => counter1 + counter2 >= 10, 3000);
//单元测试状态下QOS貌似不生效
Output.WriteLine($"worker1:{counter1} worker2:{counter2}");
Assert.True(counter1 <= counter2);
await rabbitServer.StopAsync();
}
public void QueueUnbind_RemovesBinding()
{
// Arrange
var node = new RabbitServer();
var model = new FakeModel(node);
const string queueName = "someQueue";
const string exchangeName = "someExchange";
const string routingKey = "someRoutingKey";
var arguments = new Hashtable();
model.ExchangeDeclare(exchangeName, "direct");
model.QueueDeclarePassive(queueName);
model.ExchangeBind(exchangeName, queueName, routingKey, arguments);
// Act
model.QueueUnbind(queueName, exchangeName, routingKey, arguments);
// Assert
Assert.That(node.Exchanges[exchangeName].Bindings, Is.Empty);
Assert.That(node.Queues[queueName].Bindings, Is.Empty);
}
public void QueueDeclare_NoArguments_CreatesQueue()
{
// Arrange
var node = new RabbitServer();
var model = new FakeModel(node);
// Act
model.QueueDeclare();
// Assert
Assert.That(node.Queues,Has.Count.EqualTo(1));
}
public static void Main(string[] args)
{
Console.Write("请输入角色【0、生产者，1、消费者】：");
var _cmd = Convert.ToInt32(Console.ReadLine());
var _option = 0;
List <string> Route = new List <string>();
string _text;
switch (_cmd)
{
case 0:
Console.Write("请选择发布者类型：0、简单队列，1、发布订阅，2、路由模式，3、通配符匹配：");
_option = Convert.ToInt32(Console.ReadLine());
switch (_option)
{
case 0:
RabbitServer.Productor();
break;
case 1:
RabbitServer.Fanout();
break;
case 2:
//Fast
Console.Write("请输入路由名称：");
_text = Console.ReadLine();
RabbitServer.Direct(_text);
break;
case 3:
//fast.1[,fast.1.2]
Console.Write("请输入路由名称：");
_text = Console.ReadLine();
RabbitServer.Topic(_text);
break;
}
break;
case 1:
Console.Write("请选择消费者类型：0、简单队列，1、发布订阅，2、路由模式，3、通配符匹配：");
_option = Convert.ToInt32(Console.ReadLine());
string[] _arr;
switch (_option)
{
case 0:
Console.Write("请输入是否延迟订阅【0、否，1、是】：");
var _bRst = Convert.ToBoolean(Console.ReadLine());
RabbitClient.Consumer(_bRst);
break;
case 1:
//Fast
Console.Write("请输入队列名称：");
_text = Console.ReadLine();
RabbitClient.Fanout(false, _text);
break;
case 2:
//fast、Fast
Console.Write("请输入队列名称、路由名称【队列与路由用、分隔，多个路由用,分隔】：");
_text = Console.ReadLine();
_arr = _text.Split('、');
RabbitClient.Direct(false, _arr[0], _arr[1].Split(','));
break;
case 3:
//TopicEx、fast、fast.*[,fast.#]=>可以默认一个
Console.Write("请输入交换机名称、队列名称、路由名称【（交换机、队列、路由）用、分隔，多个路由用,分隔】：");
_text = Console.ReadLine();
_arr = _text.Split('、');
RabbitClient.Topic(false, _arr[0], _arr[1], _arr[2].Split(','));
break;
}
break;
}
//CreateHostBuilder(args).Build().Run();
}
public void Setup()
{
// rabbitmq
this._rabbitServer = new RabbitServer();
this._connectionfactory = new FakeConnectionFactory(this._rabbitServer);
}
