public void QueueItem_AllItemsShouldGetProcess_WhenItemsGetFasterAddedThanProcessed()
        {
            /** ---- Arrange ---- */
            Mock<IDeserializer> mockDeserializer = new Mock<IDeserializer>();
            mockDeserializer.Setup(f => f.Deserialize(It.IsAny<string>()))
                   .Callback(() => Thread.Sleep(50));


            var systemUnderTest = new DefaultQueueProcessor<string>(mockDeserializer.Object.Deserialize);

            var testElements = 100;

            /** ---- Act ---- */

            for (var i = 0; i < testElements; i++)
            {
                systemUnderTest.QueueItem(i.ToString());
            }

            systemUnderTest.BlockUntilNothingLeftInQueue();

            /** ---- Assert ---- */
            mockDeserializer.Verify(deserializer => deserializer.Deserialize(It.IsAny<string>()),Times.Exactly(testElements));

            systemUnderTest.Dispose();
        }
        public void ProcessAsync_ExceptionWhileProcessingItem_ThrowException()
        {
            var queue          = new SingleItemQueue(new StringItem("An item"));
            var handler        = new ThrowExceptionPayloadHandler(new Exception("An exception"));
            var queueProcessor = new DefaultQueueProcessor <string>(queue, handler);

            Assert.ThrowsAsync <Exception>(() => queueProcessor.ProcessAsync());
        }
        public async Task ProcessAsync_AnItemInQueue_ReturnsTrue()
        {
            var queue          = new SingleItemQueue(new StringItem("An item"));
            var handler        = new FakePayloadHandler();
            var queueProcessor = new DefaultQueueProcessor <string>(queue, handler);

            var processed = await queueProcessor.ProcessAsync();

            Assert.IsTrue(processed);
        }
        public async Task ProcessAsync_EmptyQueue_ReturnsFalse()
        {
            var queue          = new EmptyQueue();
            var handler        = new FakePayloadHandler();
            var queueProcessor = new DefaultQueueProcessor <string>(queue, handler);

            var processed = await queueProcessor.ProcessAsync();

            Assert.IsFalse(processed);
        }
        public void QueueItem_ThrowsNoException_WhenAlreadyDisposed()
        {
            /** ---- Arrange ---- */
            Mock<IDeserializer> mockDeserializer = new Mock<IDeserializer>();

            var systemUnderTest = new DefaultQueueProcessor<string>(mockDeserializer.Object.Deserialize);

            /** ---- Act ---- */
            systemUnderTest.Dispose();

            /** ---- Assert ---- */
            systemUnderTest.QueueItem("This should not throw an exception.");
        }
        public async Task ProcessAsync_SingleItemInQueue_ProcessesAndEmptiesQueue()
        {
            using (var scope = new IsolationScope(TestFixtureContext.Provider))
            {
                var connection = scope.Provider.GetRequiredService <IDbConnection>();
                await connection.ExecuteSqlAsync("INSERT INTO Kiukie.Queue(Payload) VALUES(@Payload)", new StringItem("An item"));

                var queue          = new DefaultQueue <string>(connection);
                var handler        = new FakePayloadHandler();
                var queueProcessor = new DefaultQueueProcessor <string>(queue, handler);

                var processed = await queueProcessor.ProcessAsync();

                Assert.IsTrue(processed);

                processed = await queueProcessor.ProcessAsync();

                Assert.IsFalse(processed);
            }
        }