public async Task Run()
        {
            var data = new object();

            var message = Substitute.For<IQueued<object>>();
            message.Data().Returns(Task.FromResult(data));
            message.Complete();

            var msgs = new List<IQueued<object>>();
            msgs.Add(message);

            var poller = Substitute.For<IPoller<object>>();
            poller.PollMany(1).Returns(Task.FromResult<IEnumerable<IQueued<object>>>(msgs));

            var processor = Substitute.For<IProcessor<object>>();
            processor.Process(data).Returns(Task.FromResult(true));

            var tracker = Substitute.For<ITimingTracker>();
            tracker.Calculate(Arg.Any<TimeSpan>(), 1).Returns<byte>(6);

            var d = new DequeueBatchDynamic<object>(poller, processor, tracker);

            var result = await d.Run();
            Assert.IsTrue(result);

            tracker.Received().Calculate(Arg.Any<TimeSpan>(), 1);
            message.Received().Data();
            message.Received().Complete();
            poller.Received().PollMany(1);
            processor.Received().Process(data);
        }
 public void DefaultBatch()
 {
     var poller = Substitute.For<IPoller<object>>();
     var processor = Substitute.For<IProcessor<object>>();
     var tracker = Substitute.For<ITimingTracker>();
     var dbd = new DequeueBatchDynamic<object>(poller, processor, tracker);
     Assert.AreEqual(DequeueBatch<object>.MinimumBatchSize, dbd.BatchCount);
 }
        public void DefaultBatch()
        {
            var poller    = Substitute.For <IPoller <object> >();
            var processor = Substitute.For <IProcessor <object> >();
            var tracker   = Substitute.For <ITimingTracker>();
            var dbd       = new DequeueBatchDynamic <object>(poller, processor, tracker);

            Assert.AreEqual(DequeueBatch <object> .MinimumBatchSize, dbd.BatchCount);
        }
        public async Task RunPollNull()
        {
            var poller = Substitute.For <IPoller <object> >();

            poller.PollMany(1).Returns(Task.FromResult <IEnumerable <IQueued <object> > >(null));

            var processor = Substitute.For <IProcessor <object> >();
            var tracker   = Substitute.For <ITimingTracker>();

            var d      = new DequeueBatchDynamic <object>(poller, processor, tracker);
            var result = await d.Run();

            Assert.IsFalse(result);

            await poller.Received().PollMany(1);
        }
        public void RunCompleteUpIntegration()
        {
            var random   = new Random();
            var duration = TimeSpan.FromMilliseconds(10);

            var poller    = Substitute.For <IPoller <object> >();
            var processor = Substitute.For <IProcessor <object> >();

            var d = new DequeueBatchDynamic <object>(poller, processor, new TimingTracker(TimeSpan.FromMinutes(1), 50));

            d.RunCompleted(1, duration);
            d.RunCompleted(2, duration);
            d.RunCompleted(1, duration);
            d.RunCompleted(3, duration);
            d.RunCompleted(1, duration);

            Assert.AreEqual(4, d.BatchCount);
        }
        public void RunCompleteUp()
        {
            var random   = new Random();
            var count    = random.Next(5, int.MaxValue);
            var duration = TimeSpan.FromMilliseconds(random.Next());

            var poller    = Substitute.For <IPoller <object> >();
            var processor = Substitute.For <IProcessor <object> >();
            var tracker   = Substitute.For <ITimingTracker>();

            tracker.Calculate(duration, 1).Returns((byte)2);

            var d = new DequeueBatchDynamic <object>(poller, processor, tracker);

            d.RunCompleted(count, duration);

            Assert.AreEqual(2, d.BatchCount);

            tracker.Received().Calculate(duration, 1);
        }
        public async Task Run()
        {
            var data = new object();

            var message = Substitute.For <IQueued <object> >();

            message.Data().Returns(Task.FromResult(data));
            await message.Complete();

            var msgs = new List <IQueued <object> >();

            msgs.Add(message);

            var poller = Substitute.For <IPoller <object> >();

            poller.PollMany(1).Returns(Task.FromResult <IEnumerable <IQueued <object> > >(msgs));

            var processor = Substitute.For <IProcessor <object> >();

            processor.Process(data).Returns(Task.FromResult(true));

            var tracker = Substitute.For <ITimingTracker>();

            tracker.Calculate(Arg.Any <TimeSpan>(), 1).Returns <byte>(6);

            var d = new DequeueBatchDynamic <object>(poller, processor, tracker);

            var result = await d.Run();

            Assert.IsTrue(result);

            tracker.Received().Calculate(Arg.Any <TimeSpan>(), 1);
            await message.Received().Data();

            await message.Received().Complete();

            await poller.Received().PollMany(1);

            await processor.Received().Process(data);
        }
        public async Task RunPollNull()
        {
            var poller = Substitute.For<IPoller<object>>();
            poller.PollMany(1).Returns(Task.FromResult<IEnumerable<IQueued<object>>>(null));

            var processor = Substitute.For<IProcessor<object>>();
            var tracker = Substitute.For<ITimingTracker>();

            var d = new DequeueBatchDynamic<object>(poller, processor, tracker);
            var result = await d.Run();

            Assert.IsFalse(result);

            poller.Received().PollMany(1);
        }
        public void RunCompleteDownIntegration()
        {
            var random = new Random();
            var duration = TimeSpan.FromMilliseconds(10);

            var poller = Substitute.For<IPoller<object>>();
            var processor = Substitute.For<IProcessor<object>>();

            var d = new DequeueBatchDynamic<object>(poller, processor, new TimingTracker(TimeSpan.FromMinutes(1), 50));
            d.RunCompleted(1, duration);
            d.RunCompleted(2, duration);
            d.RunCompleted(3, duration);
            d.RunCompleted(1, TimeSpan.FromMinutes(1));
            d.RunCompleted(1, TimeSpan.FromMinutes(1));
            d.RunCompleted(1, TimeSpan.FromMinutes(1));

            Assert.AreEqual(1, d.BatchCount);
        }
        public void RunCompleteDown()
        {
            var random = new Random();
            var count = random.Next(5, int.MaxValue);
            var duration = TimeSpan.FromMilliseconds(random.Next());

            var poller = Substitute.For<IPoller<object>>();
            var processor = Substitute.For<IProcessor<object>>();
            var tracker = Substitute.For<ITimingTracker>();
            tracker.Calculate(duration, 1).Returns((byte)2);
            tracker.Calculate(duration, 2).Returns((byte)1);

            var d = new DequeueBatchDynamic<object>(poller, processor, tracker);
            d.RunCompleted(1, duration);
            d.RunCompleted(1, duration);

            Assert.AreEqual(1, d.BatchCount);

            tracker.Received().Calculate(duration, 1);
            tracker.Received().Calculate(duration, 2);
        }