public void EnsureUnsubscribeForAsyncSub()
        {
            var subject  = "d37e3729c5c84702b836a4bb4edf7241";
            var recieved = new ConcurrentQueue <Msg>();

            AsyncContext.Run(async() =>
            {
                using (NATSServer.CreateFastAndVerify(Context.Server1.Port))
                {
                    using (var sync = TestSync.SingleActor())
                    {
                        using (var cn = Context.ConnectionFactory.CreateConnection(Context.Server1.Url))
                        {
                            using (var sub = cn.SubscribeAsync(subject, (_, m) =>
                            {
                                recieved.Enqueue(m.Message);
                                sync.SignalComplete();
                            }))
                            {
                                cn.Publish(subject, new byte[0]);
                                sync.WaitForAll();

                                sub.Unsubscribe();

                                cn.Publish(subject, new byte[0]);
                                await Task.Delay(100);
                                Assert.Equal(1, sub.Delivered);
                            }
                        }

                        Assert.Single(recieved);
                    }
                }
            });
        }
        public void EnsureDrainAsync()
        {
            var subject = "5dc823d90cab46679e0bf51afffda767";
            var q       = new ConcurrentQueue <int>();

            AsyncContext.Run(async() =>
            {
                using (NATSServer.CreateFastAndVerify(Context.Server1.Port))
                {
                    using (var sync = TestSync.SingleActor())
                    {
                        var opts = Context.GetTestOptions(Context.Server1.Port);
                        opts.ClosedEventHandler = (sender, args) =>
                        {
                            q.Enqueue(1);
                            sync.SignalComplete();
                        };

                        using (var cn = Context.ConnectionFactory.CreateConnection(opts))
                        {
                            for (var i = 0; i < 50; i++)
                            {
                                cn.Publish(subject, new[] { (byte)i });
                            }

                            await cn.DrainAsync();

                            sync.WaitForAll();
                            Assert.Single(q);
                        }
                    }
                }
            });
        }
        public void EnsureDrain()
        {
            var subject = "176bb0976ef943e3988de4957c9e1a1a";
            var q       = new ConcurrentQueue <int>();

            AsyncContext.Run(() =>
            {
                using (NATSServer.CreateFastAndVerify(Context.Server1.Port))
                {
                    using (var sync = TestSync.SingleActor())
                    {
                        var opts = Context.GetTestOptions(Context.Server1.Port);
                        opts.ClosedEventHandler = (sender, args) =>
                        {
                            q.Enqueue(1);
                            sync.SignalComplete();
                        };

                        using (var cn = Context.ConnectionFactory.CreateConnection(opts))
                        {
                            for (var i = 0; i < 50; i++)
                            {
                                cn.Publish(subject, new[] { (byte)i });
                            }

                            cn.Drain();

                            sync.WaitForAll();
                            Assert.Single(q);
                        }
                    }
                }
            });
        }
        public void EnsurePubSubWithFlush()
        {
            var subject  = "0b122a47380145b49969ddfaafe0c206";
            var recieved = new ConcurrentQueue <Msg>();

            AsyncContext.Run(() =>
            {
                using (NATSServer.CreateFastAndVerify(Context.Server1.Port))
                {
                    using (var sync = TestSync.SingleActor())
                    {
                        using (var cn = Context.ConnectionFactory.CreateConnection(Context.Server1.Url))
                        {
                            using (cn.SubscribeAsync(subject, (_, m) =>
                            {
                                recieved.Enqueue(m.Message);
                                if (recieved.Count == 5)
                                {
                                    sync.SignalComplete();
                                }
                            }))
                            {
                                for (var i = 0; i < 5; i++)
                                {
                                    cn.Publish(subject, new[] { (byte)i });
                                    cn.Flush();
                                    cn.FlushBuffer();
                                }

                                sync.WaitForAll();
                            }
                        }

                        Assert.Equal(5, recieved.Count);
                    }
                }
            });
        }
예제 #5
0
        public void EnsurePubSubWithAsyncHandler()
        {
            var subject  = "236c9af7eae044f585973503e9803f4a";
            var recieved = new ConcurrentQueue <Msg>();

            AsyncContext.Run(() =>
            {
                using (NATSServer.CreateFast(Context.Server1.Port))
                {
                    using (var sync = TestSync.SingleActor())
                    {
                        using (var cn = Context.ConnectionFactory.CreateConnection(Context.Server1.Url))
                        {
                            using (cn.SubscribeAsync(subject, async(_, m) =>
                            {
                                await Task.Delay(100);
                                recieved.Enqueue(m.Message);
                                if (recieved.Count == 5)
                                {
                                    sync.SignalComplete();
                                }
                            }))
                            {
                                for (var i = 0; i < 5; i++)
                                {
                                    cn.Publish(subject, new[] { (byte)i });
                                }

                                sync.WaitForAll();
                            }
                        }

                        Assert.Equal(5, recieved.Count);
                    }
                }
            });
        }
        public void EnsurePubSub()
        {
            var subject  = "16160bf236cb42dda5bbd0dfc744dacc";
            var recieved = new ConcurrentQueue <Msg>();

            AsyncContext.Run(() =>
            {
                using (NATSServer.CreateFastAndVerify(Context.Server1.Port))
                {
                    using (var sync = TestSync.SingleActor())
                    {
                        using (var cn = Context.ConnectionFactory.CreateConnection(Context.Server1.Url))
                        {
                            using (cn.SubscribeAsync(subject, (_, m) =>
                            {
                                recieved.Enqueue(m.Message);
                                if (recieved.Count == 5)
                                {
                                    sync.SignalComplete();
                                }
                            }))
                            {
                                for (var i = 0; i < 5; i++)
                                {
                                    cn.Publish(subject, new[] { (byte)i });
                                }

                                sync.WaitForAll();
                            }
                        }

                        Assert.Equal(5, recieved.Count);
                    }
                }
            });
        }
        public void EnsureAutoUnsubscribeForAsyncSub()
        {
            var subject  = "0be903f6c9c14c10973e78ce03ad47e1";
            var recieved = new ConcurrentQueue <Msg>();

            AsyncContext.Run(async() =>
            {
                using (NATSServer.CreateFast(Context.Server1.Port))
                {
                    using (var sync = TestSync.SingleActor())
                    {
                        using (var cn = Context.ConnectionFactory.CreateConnection(Context.Server1.Url))
                        {
                            using (var sub = cn.SubscribeAsync(subject, (_, m) =>
                            {
                                recieved.Enqueue(m.Message);
                                sync.SignalComplete();
                            }))
                            {
                                sub.AutoUnsubscribe(1);

                                cn.Publish(subject, new byte[0]);
                                cn.Publish(subject, new byte[0]);

                                sync.WaitForAll();

                                await Task.Delay(100);
                                Assert.Equal(1, sub.Delivered);
                            }
                        }

                        Assert.Single(recieved);
                    }
                }
            });
        }