public async Task SendsToIndexInBatches()
        {
            var indexer     = new Mock <IEventIndexer <TransferEvent> >();
            var indexedLogs = CaptureCallsToIndexer(indexer);

            var handler = new EventIndexTransactionLogHandler <TransferEvent>(indexer.Object, logsPerIndexBatch: 2);

            var transactionLog1 = new Mock <TransactionLogWrapper>();
            var transactionLog2 = new Mock <TransactionLogWrapper>();

            transactionLog1.Setup(t => t.IsForEvent <TransferEvent>()).Returns(true);
            transactionLog2.Setup(t => t.IsForEvent <TransferEvent>()).Returns(true);

            var eventLog1 = new EventLog <TransferEvent>(new TransferEvent(), new FilterLog());
            var eventLog2 = new EventLog <TransferEvent>(new TransferEvent(), new FilterLog());

            transactionLog1.Setup(t => t.Decode <TransferEvent>()).Returns(eventLog1);
            transactionLog2.Setup(t => t.Decode <TransferEvent>()).Returns(eventLog2);


            await handler.HandleAsync(transactionLog1.Object);

            Assert.Empty(indexedLogs);
            Assert.Equal(1, handler.Pending);
            await handler.HandleAsync(transactionLog2.Object);

            Assert.Equal(2, indexedLogs.Count);
            Assert.Equal(0, handler.Pending);
        }
        public async Task WillIgnoreLogsThatDoNotMatchTheEvent()
        {
            var indexer     = new Mock <IEventIndexer <TransferEvent> >();
            var indexedLogs = CaptureCallsToIndexer(indexer);
            var handler     =
                new EventIndexTransactionLogHandler <TransferEvent>(indexer.Object, logsPerIndexBatch: 1);

            var logForAnotherEvent = new Mock <TransactionLogWrapper>();

            logForAnotherEvent.Setup(t => t.IsForEvent <TransferEvent>()).Returns(false);

            await handler.HandleAsync(logForAnotherEvent.Object);

            Assert.Empty(indexedLogs);
            Assert.Equal(0, handler.Pending);
        }
        public async Task WhenDisposeIsCalledWillAttemptToIndexPendingItems()
        {
            var indexer     = new Mock <IEventIndexer <TransferEvent> >();
            var indexedLogs = CaptureCallsToIndexer(indexer);

            using (var handler =
                       new EventIndexTransactionLogHandler <TransferEvent>(indexer.Object, logsPerIndexBatch: 2))
            {
                var transactionLog1 = new Mock <TransactionLogWrapper>();
                transactionLog1.Setup(t => t.IsForEvent <TransferEvent>()).Returns(true);

                var eventLog1 = new EventLog <TransferEvent>(new TransferEvent(), new FilterLog());
                transactionLog1.Setup(t => t.Decode <TransferEvent>()).Returns(eventLog1);

                await handler.HandleAsync(transactionLog1.Object);

                Assert.Equal(1, handler.Pending);
            }

            //calling dispose should cause app to process remaining pending items
            Assert.Single(indexedLogs);
        }