public async Task CheckpointUpdateDoesNotInterfereWithOtherNamespaces()
{
await using (var storageScope = await StorageScope.CreateAsync())
{
var storageConnectionString = StorageTestEnvironment.StorageConnectionString;
var containerClient = new BlobContainerClient(storageConnectionString, storageScope.ContainerName);
var partitionManager = new BlobPartitionManager(containerClient);
await partitionManager.ClaimOwnershipAsync(new List <PartitionOwnership>()
{
new MockPartitionOwnership("namespace1", "eventHubName", "consumerGroup", "ownerIdentifier", "partitionId", offset: 1),
new MockPartitionOwnership("namespace2", "eventHubName", "consumerGroup", "ownerIdentifier", "partitionId", offset: 1)
});
await partitionManager.UpdateCheckpointAsync(new MockCheckpoint
("namespace1", "eventHubName", "consumerGroup", "ownerIdentifier", "partitionId", 10, 20));
IEnumerable <PartitionOwnership> storedOwnershipList1 = await partitionManager.ListOwnershipAsync("namespace1", "eventHubName", "consumerGroup");
IEnumerable <PartitionOwnership> storedOwnershipList2 = await partitionManager.ListOwnershipAsync("namespace2", "eventHubName", "consumerGroup");
Assert.That(storedOwnershipList1, Is.Not.Null);
Assert.That(storedOwnershipList1.Count, Is.EqualTo(1));
Assert.That(storedOwnershipList1.Single().Offset, Is.EqualTo(10));
Assert.That(storedOwnershipList2, Is.Not.Null);
Assert.That(storedOwnershipList2.Count, Is.EqualTo(1));
Assert.That(storedOwnershipList2.Single().Offset, Is.EqualTo(1));
}
}
public async Task OwnershipClaimFailsWhenETagExistsAndOwnershipDoesNotExist()
{
await using (StorageScope storageScope = await StorageScope.CreateAsync())
{
var storageConnectionString = StorageTestEnvironment.StorageConnectionString;
var containerClient = new BlobContainerClient(storageConnectionString, storageScope.ContainerName);
var partitionManager = new BlobPartitionManager(containerClient);
var ownershipList = new List <PartitionOwnership>();
var eTaggyOwnership =
new MockPartitionOwnership
(
"namespace",
"eventHubName",
"consumerGroup",
"ownerIdentifier",
"partitionId",
offset: 2,
eTag: "ETag"
);
ownershipList.Add(eTaggyOwnership);
await partitionManager.ClaimOwnershipAsync(ownershipList);
IEnumerable <PartitionOwnership> storedOwnershipList = await partitionManager.ListOwnershipAsync("namespace", "eventHubName", "consumerGroup");
Assert.That(storedOwnershipList, Is.Not.Null.And.Empty);
}
}
public async Task FirstOwnershipClaimSucceeds()
{
await using (StorageScope storageScope = await StorageScope.CreateAsync())
{
var storageConnectionString = StorageTestEnvironment.StorageConnectionString;
var containerClient = new BlobContainerClient(storageConnectionString, storageScope.ContainerName);
var partitionManager = new BlobPartitionManager(containerClient);
var ownershipList = new List <PartitionOwnership>();
var ownership =
new MockPartitionOwnership
(
"namespace",
"eventHubName",
"consumerGroup",
"ownerIdentifier",
"partitionId"
);
ownershipList.Add(ownership);
await partitionManager.ClaimOwnershipAsync(ownershipList);
IEnumerable <PartitionOwnership> storedOwnershipList = await partitionManager.ListOwnershipAsync("namespace", "eventHubName", "consumerGroup");
Assert.That(storedOwnershipList, Is.Not.Null);
Assert.That(storedOwnershipList.Count, Is.EqualTo(1));
Assert.That(storedOwnershipList.Single().IsEquivalentTo(ownership), Is.True);
}
}
public async Task CheckpointUpdateDoesNotInterfereWithOtherPartitions()
{
await using (var storageScope = await StorageScope.CreateAsync())
{
var storageConnectionString = StorageTestEnvironment.StorageConnectionString;
var containerClient = new BlobContainerClient(storageConnectionString, storageScope.ContainerName);
var partitionManager = new BlobPartitionManager(containerClient);
await partitionManager.ClaimOwnershipAsync(new List <PartitionOwnership>()
{
new MockPartitionOwnership("eventHubName", "consumerGroup", "ownerIdentifier", "partitionId1", offset: 1),
new MockPartitionOwnership("eventHubName", "consumerGroup", "ownerIdentifier", "partitionId2", offset: 1)
});
await partitionManager.UpdateCheckpointAsync(new MockCheckpoint
("eventHubName", "consumerGroup", "ownerIdentifier", "partitionId1", 10, 20));
var storedOwnershipList = await partitionManager.ListOwnershipAsync("eventHubName", "consumerGroup");
Assert.That(storedOwnershipList, Is.Not.Null);
Assert.That(storedOwnershipList.Count, Is.EqualTo(2));
var storedOwnership1 = storedOwnershipList.First(ownership => ownership.PartitionId == "partitionId1");
var storedOwnership2 = storedOwnershipList.First(ownership => ownership.PartitionId == "partitionId2");
Assert.That(storedOwnership1, Is.Not.Null);
Assert.That(storedOwnership1.Offset, Is.EqualTo(10));
Assert.That(storedOwnership2, Is.Not.Null);
Assert.That(storedOwnership2.Offset, Is.EqualTo(1));
}
}
public async Task BlobPartitionManagerCanListOwnership()
{
await using (StorageScope storageScope = await StorageScope.CreateAsync())
{
var storageConnectionString = StorageTestEnvironment.StorageConnectionString;
var containerClient = new BlobContainerClient(storageConnectionString, storageScope.ContainerName);
var partitionManager = new BlobPartitionManager(containerClient);
Assert.That(async() => await partitionManager.ListOwnershipAsync("namespace", "eventHubName", "consumerGroup"), Throws.Nothing);
}
}
public async Task OwnershipClaimSucceedsWhenETagIsValid()
{
await using (StorageScope storageScope = await StorageScope.CreateAsync())
{
var storageConnectionString = StorageTestEnvironment.StorageConnectionString;
var containerClient = new BlobContainerClient(storageConnectionString, storageScope.ContainerName);
var partitionManager = new BlobPartitionManager(containerClient);
var ownershipList = new List <PartitionOwnership>();
var firstOwnership =
new MockPartitionOwnership
(
"namespace",
"eventHubName",
"consumerGroup",
"ownerIdentifier",
"partitionId",
offset: 1
);
ownershipList.Add(firstOwnership);
await partitionManager.ClaimOwnershipAsync(ownershipList);
// ETag must have been set by the partition manager.
var eTag = firstOwnership.ETag;
ownershipList.Clear();
var secondOwnership =
new MockPartitionOwnership
(
"namespace",
"eventHubName",
"consumerGroup",
"ownerIdentifier",
"partitionId",
offset: 2,
eTag: eTag
);
ownershipList.Add(secondOwnership);
await partitionManager.ClaimOwnershipAsync(ownershipList);
IEnumerable <PartitionOwnership> storedOwnershipList = await partitionManager.ListOwnershipAsync("namespace", "eventHubName", "consumerGroup");
Assert.That(storedOwnershipList, Is.Not.Null);
Assert.That(storedOwnershipList.Count, Is.EqualTo(1));
Assert.That(storedOwnershipList.Single().IsEquivalentTo(secondOwnership), Is.True);
}
}
public async Task ListOwnershipAsyncReturnsEmptyIEnumerableWhenThereAreNoOwnership()
{
await using (StorageScope storageScope = await StorageScope.CreateAsync())
{
var storageConnectionString = StorageTestEnvironment.StorageConnectionString;
var containerClient = new BlobContainerClient(storageConnectionString, storageScope.ContainerName);
var partitionManager = new BlobPartitionManager(containerClient);
IEnumerable <PartitionOwnership> ownership = await partitionManager.ListOwnershipAsync("namespace", "eventHubName", "consumerGroup");
Assert.That(ownership, Is.Not.Null.And.Empty);
}
}
public async Task OwnershipClaimDoesNotInterfereWithOtherEventHubs()
{
await using (var storageScope = await StorageScope.CreateAsync())
{
var storageConnectionString = StorageTestEnvironment.StorageConnectionString;
var containerClient = new BlobContainerClient(storageConnectionString, storageScope.ContainerName);
var partitionManager = new BlobPartitionManager(containerClient);
var ownershipList = new List <PartitionOwnership>();
var firstOwnership =
new MockPartitionOwnership
(
"eventHubName1",
"consumerGroup",
"ownerIdentifier",
"partitionId"
);
ownershipList.Add(firstOwnership);
await partitionManager.ClaimOwnershipAsync(ownershipList);
// ETag must have been set by the partition manager.
var eTag = firstOwnership.ETag;
ownershipList.Clear();
var secondOwnership =
new MockPartitionOwnership
(
"eventHubName2",
"consumerGroup",
"ownerIdentifier",
"partitionId",
eTag: eTag
);
ownershipList.Add(secondOwnership);
await partitionManager.ClaimOwnershipAsync(ownershipList);
var storedOwnershipList = await partitionManager.ListOwnershipAsync("eventHubName1", "consumerGroup");
Assert.That(storedOwnershipList, Is.Not.Null);
Assert.That(storedOwnershipList.Count, Is.EqualTo(1));
Assert.That(storedOwnershipList.Single().IsEquivalentTo(firstOwnership), Is.True);
}
}
public async Task CheckpointUpdateFailsWhenAssociatedOwnershipDoesNotExist()
{
await using (StorageScope storageScope = await StorageScope.CreateAsync())
{
var storageConnectionString = StorageTestEnvironment.StorageConnectionString;
var containerClient = new BlobContainerClient(storageConnectionString, storageScope.ContainerName);
var partitionManager = new BlobPartitionManager(containerClient);
await partitionManager.UpdateCheckpointAsync(new MockCheckpoint
("namespace", "eventHubName", "consumerGroup", "ownerIdentifier", "partitionId", offset : 10, sequenceNumber : 20));
IEnumerable <PartitionOwnership> storedOwnershipList = await partitionManager.ListOwnershipAsync("namespace", "eventHubName", "consumerGroup");
Assert.That(storedOwnershipList, Is.Not.Null.And.Empty);
}
}
public async Task CheckpointUpdateUpdatesOwnershipInformation()
{
await using (StorageScope storageScope = await StorageScope.CreateAsync())
{
var storageConnectionString = StorageTestEnvironment.StorageConnectionString;
var containerClient = new BlobContainerClient(storageConnectionString, storageScope.ContainerName);
var partitionManager = new BlobPartitionManager(containerClient);
var originalOwnership = new MockPartitionOwnership
("namespace", "eventHubName", "consumerGroup", "ownerIdentifier", "partitionId", offset: 1, sequenceNumber: 2);
await partitionManager.ClaimOwnershipAsync(new List <PartitionOwnership>()
{
originalOwnership
});
// ETag must have been set by the partition manager.
DateTimeOffset?originalLastModifiedTime = originalOwnership.LastModifiedTime;
var originalETag = originalOwnership.ETag;
// Give it a 1 second delay before updating the ownership information. We need to do this to ensure
// we won't end up with the same 'LastModifiedTime'. In the InMemoryPartitionManager tests we have control
// over it, but this time this property is entirely handled by the storage service.
await Task.Delay(1000);
await partitionManager.UpdateCheckpointAsync(new MockCheckpoint
("namespace", "eventHubName", "consumerGroup", "ownerIdentifier", "partitionId", 10, 20));
// Make sure the ownership has changed.
IEnumerable <PartitionOwnership> storedOwnershipList = await partitionManager.ListOwnershipAsync("namespace", "eventHubName", "consumerGroup");
Assert.That(storedOwnershipList, Is.Not.Null);
Assert.That(storedOwnershipList.Count, Is.EqualTo(1));
PartitionOwnership storedOwnership = storedOwnershipList.Single();
Assert.That(storedOwnership.Offset, Is.EqualTo(10));
Assert.That(storedOwnership.SequenceNumber, Is.EqualTo(20));
Assert.That(storedOwnership.LastModifiedTime, Is.GreaterThan(originalLastModifiedTime));
Assert.That(storedOwnership.ETag, Is.Not.EqualTo(originalETag));
}
}
public async Task ClaimOwnershipAsyncCanClaimMultipleOwnership()
{
await using (StorageScope storageScope = await StorageScope.CreateAsync())
{
var storageConnectionString = StorageTestEnvironment.StorageConnectionString;
var containerClient = new BlobContainerClient(storageConnectionString, storageScope.ContainerName);
var partitionManager = new BlobPartitionManager(containerClient);
var ownershipList = new List <PartitionOwnership>();
var ownershipCount = 5;
for (int i = 0; i < ownershipCount; i++)
{
ownershipList.Add(
new MockPartitionOwnership
(
"namespace",
"eventHubName",
"consumerGroup",
"ownerIdentifier",
$"partitionId { i }"
));
}
await partitionManager.ClaimOwnershipAsync(ownershipList);
IEnumerable <PartitionOwnership> storedOwnershipList = await partitionManager.ListOwnershipAsync("namespace", "eventHubName", "consumerGroup");
Assert.That(storedOwnershipList, Is.Not.Null);
Assert.That(storedOwnershipList.Count, Is.EqualTo(ownershipCount));
var index = 0;
foreach (PartitionOwnership ownership in storedOwnershipList.OrderBy(ownership => ownership.PartitionId))
{
Assert.That(ownership.IsEquivalentTo(ownershipList[index]), Is.True, $"Ownership of partition '{ ownership.PartitionId }' should be equivalent.");
++index;
}
}
}
public async Task CheckpointUpdateFailsWhenOwnerChanges()
{
await using (StorageScope storageScope = await StorageScope.CreateAsync())
{
var storageConnectionString = StorageTestEnvironment.StorageConnectionString;
var containerClient = new BlobContainerClient(storageConnectionString, storageScope.ContainerName);
var partitionManager = new BlobPartitionManager(containerClient);
var originalOwnership = new MockPartitionOwnership
("namespace", "eventHubName", "consumerGroup", "ownerIdentifier1", "partitionId", offset: 1, sequenceNumber: 2, lastModifiedTime: DateTimeOffset.UtcNow);
await partitionManager.ClaimOwnershipAsync(new List <PartitionOwnership>()
{
originalOwnership
});
// ETag must have been set by the partition manager.
DateTimeOffset?originalLastModifiedTime = originalOwnership.LastModifiedTime;
var originalETag = originalOwnership.ETag;
await partitionManager.UpdateCheckpointAsync(new MockCheckpoint
("namespace", "eventHubName", "consumerGroup", "ownerIdentifier2", "partitionId", 10, 20));
// Make sure the ownership hasn't changed.
IEnumerable <PartitionOwnership> storedOwnershipList = await partitionManager.ListOwnershipAsync("namespace", "eventHubName", "consumerGroup");
Assert.That(storedOwnershipList, Is.Not.Null);
Assert.That(storedOwnershipList.Count, Is.EqualTo(1));
Assert.That(storedOwnershipList.Single().IsEquivalentTo(originalOwnership), Is.True);
Assert.That(originalOwnership.OwnerIdentifier, Is.EqualTo("ownerIdentifier1"));
Assert.That(originalOwnership.Offset, Is.EqualTo(1));
Assert.That(originalOwnership.SequenceNumber, Is.EqualTo(2));
Assert.That(originalOwnership.LastModifiedTime, Is.EqualTo(originalLastModifiedTime));
Assert.That(originalOwnership.ETag, Is.EqualTo(originalETag));
}
}