Example #1
0
        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();
        }
Example #2
0
        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();
        }
Example #3
0
        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();
        }
Example #4
0
        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();
        }
Example #5
0
        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();
        }