public void CheckpointStoreIsUsedByListOwnershipAsync()
        {
            using var cancellationSource = new CancellationTokenSource();

            var expectedException   = new ApplicationException();
            var mockCheckpointStore = new Mock <CheckpointStore>();
            var mockProcessor       = new MockCheckpointStoreProcessor(mockCheckpointStore.Object, 100, "fakeConsumer", "fakeNamespace", "fakeHub", Mock.Of <TokenCredential>());

            mockCheckpointStore
            .Setup(store => store.ListOwnershipAsync(
                       mockProcessor.FullyQualifiedNamespace,
                       mockProcessor.EventHubName,
                       mockProcessor.ConsumerGroup,
                       cancellationSource.Token))
            .ThrowsAsync(expectedException);

            Assert.That(async() => await mockProcessor.InvokeListOwnershipAsync(cancellationSource.Token), Throws.Exception.EqualTo(expectedException));
        }
        public void CheckpointStoreIsUsedByClaimOwnershipAsync()
        {
            using var cancellationSource = new CancellationTokenSource();

            var expectedException = new ApplicationException();
            var desiredOwnership  = new[] { new EventProcessorPartitionOwnership {
                                                PartitionId = "1"
                                            } };
            var mockCheckpointStore = new Mock <CheckpointStore>();
            var mockProcessor       = new MockCheckpointStoreProcessor(mockCheckpointStore.Object, 100, "fakeConsumer", "fakeNamespace", "fakeHub", Mock.Of <TokenCredential>());

            mockCheckpointStore
            .Setup(store => store.ClaimOwnershipAsync(
                       desiredOwnership,
                       cancellationSource.Token))
            .ThrowsAsync(expectedException);

            Assert.That(async() => await mockProcessor.InvokeClaimOwnershipAsync(desiredOwnership, cancellationSource.Token), Throws.Exception.EqualTo(expectedException));
        }
        public void CheckpointStoreIsUsedByGetCheckpointAsync()
        {
            using var cancellationSource = new CancellationTokenSource();

            var expectedException   = new AmbiguousMatchException();
            var partitionId         = "fakePart";
            var mockCheckpointStore = new Mock <CheckpointStore>();
            var mockProcessor       = new MockCheckpointStoreProcessor(mockCheckpointStore.Object, 100, "fakeConsumer", "fakeNamespace", "fakeHub", Mock.Of <TokenCredential>());

            mockCheckpointStore
            .Setup(store => store.GetCheckpointAsync(
                       mockProcessor.FullyQualifiedNamespace,
                       mockProcessor.EventHubName,
                       mockProcessor.ConsumerGroup,
                       partitionId,
                       cancellationSource.Token))
            .ThrowsAsync(expectedException);

            Assert.That(async() => await mockProcessor.InvokeGetCheckpointAsync(partitionId, cancellationSource.Token), Throws.Exception.EqualTo(expectedException));
        }
        public void CheckpointStoreIsUsedByUpdateCheckpointAsync()
        {
            using var cancellationSource = new CancellationTokenSource();

            var expectedException   = new DivideByZeroException();
            var partitionId         = "fakePart";
            var offset              = 12345;
            var sequence            = 9987;
            var mockCheckpointStore = new Mock <CheckpointStore>();
            var mockProcessor       = new MockCheckpointStoreProcessor(mockCheckpointStore.Object, 100, "fakeConsumer", "fakeNamespace", "fakeHub", Mock.Of <TokenCredential>());

            mockCheckpointStore
            .Setup(store => store.UpdateCheckpointAsync(
                       mockProcessor.FullyQualifiedNamespace,
                       mockProcessor.EventHubName,
                       mockProcessor.ConsumerGroup,
                       partitionId,
                       offset,
                       sequence,
                       cancellationSource.Token))
            .ThrowsAsync(expectedException);

            Assert.That(async() => await mockProcessor.InvokeUpdateCheckpointAsync(partitionId, offset, sequence, cancellationSource.Token), Throws.Exception.EqualTo(expectedException));
        }